论代码规范（废除）

 

0.每一行只能有一条语句，可用 “,” 链接

1.固定变量必需要大写, 如给定的N,M等, 需大写的只需大写第一个字母

2.临时变量用小写. 如x, y, now, res 等;其没有固定的含义, 仅仅为了存不一样意义的变量

3.函数内的变量名一般为小写

4.C++关键字后必需要有空格

5.逻辑运算符，算术运算符，关系运算符，赋值运算符 先后都须要加空格

6.指针运算符的符号需写在变量名的前面 如int *a

7.起变量名能用全名则用全名， 如 int tree_number[];

8.函数名尽可能由操做类型+名词构成 如 int Query_sum () int Get_Flow ()

9.函数名每一个单词开头字母都用大写，若需多个单词链接，则添加下划线 如 int Tree_Build ()

10.不常常用的变量名字要打全称 如 int Edge_Count

11.少数变量 如EPS INF 能够全用大写， 而且由#define 实现，INF 需用1ex来表示 如 #define INF 1e7

12.除非一个整型变量也不用，不然必需要加读入优化，且无需读负数时不用写上关于负数的判断

13.尽可能将最经常使用的临时变量添加register 修饰符

14.struct 多用于纯数据类型，可添加少许函数，如存点与边，class 用于大型数据结构，如Lct，线段树，splay

15.数据结构必定要封装起来使用

16.多开局部变量，少用全局变量，需用时可做为函数参数传递

17.不用纠结于驼峰命名法

 

附上一篇较规范的代码

 

#include <cstdio>

#define Max 200190

void read (long long &now)
{
    now = 0;
    register char word = getchar ();
    bool flag = false;
    while (word < '0' || word > '9')
    {
        if (word == '-')
            flag = true;
        word = getchar ();
    }
    while (word >= '0' && word <= '9')
    {
        now = now * 10 + word - '0';
        word = getchar ();
    }    
    if (flag)
        now = -now; 
}

inline long long min (long long a, long long b)
{
    return a < b ? a : b;
}

inline long long max (long long a, long long b)
{
    return a > b ? a : b;
}

inline long long swap (long long &a, long long &b)
{
    long long now = a; 
    a = b;
    b = now;
}

long long tree_dis[Max];
long long Cur;

class Segment_Tree_Type
{
    private :
        
        struct Segment_Tree
        {
            long long l;
            long long r;
            long long Mid;
            long long Sum;
            long long Ruri;
        }
        tree[Max << 3];
        
    public :
        
        void Build (long long l, long long r, long long now)
        {
            tree[now].l = l;
            tree[now].r = r;
            if (l == r)
            {
                tree[now].Sum = tree_dis[++Cur];
                return ;
            }
            tree[now].Mid = (l + r) >> 1;
            Build (l, tree[now].Mid, now << 1);
            Build (tree[now].Mid + 1, r, now << 1 | 1);
            tree[now].Sum = tree[now << 1].Sum + tree[now << 1 | 1].Sum;
        }
        
        void Change_single (long long pos, long long now, long long to)
        {
            if (tree[now].l == tree[now].r)
            {
                tree[now].Sum += to;
                return ;
            }
            if (tree[now].Ruri)
            {
                tree[now << 1].Sum += (tree[now << 1].r - tree[now << 1].l + 1) * tree[now].Ruri;
                tree[now << 1].Ruri += tree[now].Ruri;
                tree[now << 1 | 1].Sum += (tree[now << 1 | 1].r - tree[now << 1 | 1].l + 1) * tree[now].Ruri;
                tree[now << 1 | 1].Ruri += tree[now].Ruri;
                tree[now].Ruri = 0;
            }
            if (pos <= tree[now].Mid)
                Change_single (pos, now << 1, to);
            else if (pos > tree[now].Mid)
                Change_single (pos, now << 1 | 1, to);
            tree[now].Sum = tree[now << 1].Sum + tree[now << 1 | 1].Sum;
        }
        
        void Change_section (long long l, long long r, long long now, long long to)
        {
            if (tree[now].l == l && tree[now].r == r)
            {
                tree[now].Sum += (tree[now].r - tree[now].l + 1) * to;
                tree[now].Ruri += to;
                return ;
            }
            if (tree[now].Ruri)
            {
                tree[now << 1].Sum += (tree[now << 1].r - tree[now << 1].l + 1) * tree[now].Ruri;
                tree[now << 1].Ruri += tree[now].Ruri;
                tree[now << 1 | 1].Sum += (tree[now << 1 | 1].r - tree[now << 1 | 1].l + 1) * tree[now].Ruri;
                tree[now << 1 | 1].Ruri += tree[now].Ruri;
                tree[now].Ruri = 0;
            }
            if (r <= tree[now].Mid)
                Change_section (l, r, now << 1, to);
            else if (l > tree[now].Mid)
                Change_section (l, r, now << 1 | 1, to);
            else 
            {
                Change_section (l, tree[now].Mid, now << 1, to);
                Change_section (tree[now].Mid + 1, r, now << 1 | 1, to);
            }
            tree[now].Sum = tree[now << 1].Sum + tree[now << 1 | 1].Sum;
        }
        
        long long Query_section (long long l, long long r, long long now)
        {
            if (tree[now].l == l && tree[now].r == r)
                return tree[now].Sum;
            if (tree[now].Ruri)
            {
                tree[now << 1].Sum += (tree[now << 1].r - tree[now << 1].l + 1) * tree[now].Ruri;
                tree[now << 1].Ruri += tree[now].Ruri;
                tree[now << 1 | 1].Sum += (tree[now << 1 | 1].r - tree[now << 1 | 1].l + 1) * tree[now].Ruri;
                tree[now << 1 | 1].Ruri += tree[now].Ruri;
                tree[now].Ruri = 0;
            }
            tree[now].Sum = tree[now << 1].Sum + tree[now << 1 | 1].Sum;
            if (r <= tree[now].Mid)
                return Query_section (l, r, now << 1);
            else if (l > tree[now].Mid)
                return Query_section (l, r, now << 1 | 1);
            else 
                return Query_section (l, tree[now].Mid, now << 1) + Query_section (tree[now].Mid + 1, r, now << 1 | 1); 
        }
};

Segment_Tree_Type Tree;

struct Graph_Type
{
    
    struct Edges
    {
        long long to;
        long long next;
    }
    
    edge[Max << 3];
    long long edge_list[Max];
    long long Edge_Count;
    
    inline void Add_Edge (long long from, long long to)
    {
        Edge_Count++;
        edge[Edge_Count].to = to;
        edge[Edge_Count].next = edge_list[from];
        edge_list[from] = Edge_Count;
        Edge_Count++;
        edge[Edge_Count].to = from;
        edge[Edge_Count].next = edge_list[to];
        edge_list[to] = Edge_Count;
    }
};

Graph_Type Graph;

class Tree_Chain_Get_Type 
{
    private :
        
        struct Point_Type
        {
            long long deep;
            long long size;
            long long father;
            long long up_chain_point;
            long long end;
            long long dis;
            long long tree_number;
        }
        
        point[Max];
    
        long long Count;
            
    public :
 
        inline void Clear ()
        {
             Count = 0;
        }
        
        void Dfs_1 (long long now, long long father)
        {
            point[now].father = father;
            point[now].deep = point[father].deep + 1;
            long long pos = Count++;
            for (long long i = Graph.edge_list[now]; i; i = Graph.edge[i].next)
                if (Graph.edge[i].to != father)
                    Dfs_1 (Graph.edge[i].to, now);
            point[now].size = Count - pos;
        }
        
        void Dfs_2 (long long now, long long chain)
        {
            long long pos = 0;
            point[now].up_chain_point = chain;
            point[now].tree_number = ++Count;
            tree_dis[Count] = point[now].dis;
            for (long long i = Graph.edge_list[now]; i; i = Graph.edge[i].next)
                if (!point[Graph.edge[i].to].tree_number && point[Graph.edge[i].to].size > point[pos].size)
                    pos = Graph.edge[i].to;
            if (!pos)
            {
                point[now].end = Count;
                return ;
            }
            Dfs_2 (pos, chain);
            for (long long i = Graph.edge_list[now]; i; i = Graph.edge[i].next)
                if (Graph.edge[i].to != pos && !point[Graph.edge[i].to].tree_number)
                    Dfs_2 (Graph.edge[i].to, Graph.edge[i].to);
            point[now].end = Count;
        }
        
        long long Query_chain (long long x)
        {
            long long Answer = 0;
            while (point[x].up_chain_point)
            {
                Answer += Tree.Query_section (point[point[x].up_chain_point].tree_number, point[x].tree_number, 1);
                x = point[point[x].up_chain_point].father; 
            }
            return Answer;
        }
        
        long long Get_Point_number (long long now)
        {
            return point[now].tree_number;
        }
        
        void Key_in_point_dis (long long now, long long dis)
        {
            point[now].dis = dis;
        }
        
        long long Get_Point_End_number (long long now)
        {
            return point[now].end;
        }
};

Tree_Chain_Get_Type Make;

long long N, M;

int main (int argc, char *argv[])
{
    read (N);
    read (M);
    long long x, y;
    for (long long i = 1; i <= N; i++)
    {
        read (x);
        Make.Key_in_point_dis (i, x); 
    }
    for (long long i = 1; i < N; i++)
    {
        read (x);
        read (y);
        Graph.Add_Edge (x, y); 
    }
    Make.Dfs_1 (1, 0);
    Make.Clear ();
    Make.Dfs_2 (1, 1);
    Tree.Build (1, N, 1);
    while (M--)
    {
        read (x);
        if (x == 1)
        {
            read (x);
            read (y);
            Tree.Change_single (Make.Get_Point_number (x), 1, y);  
        }
        else if (x == 2)
        {
            read (x);
            read (y);
            Tree.Change_section (Make.Get_Point_number (x), Make.Get_Point_End_number (x), 1, y); 
        }
        else 
        {
            read (x);
            printf ("%lld\n", Make.Query_chain (x));
        }
    }
    return 0;
}