线段树(Segment Tree)（转）

typedef struct node {
    int l;        //线段的左端点
    int r;        //线段的左端点
    int value;    //线段上的值
}node;

bulid//以节点v为根建树、v对应区间为[l,r]
{
    对节点v初始化
     if (l!=r) {
          以v的左孩子为根建树，区间为[l,(l+r)/2]
          以v的右孩子为根建树，区间为[(l+r)/2+1,r]
    }
}

#define N 10000
node tree[N];
void bulid(int l, int r, int v) //对结点v进行建立，区间为l~r
{
    tree[v].l = l;
    tree[v].r = r;
    if(l == r) {
        //进行结点的初始化
        tree[v].value = a[r];
        return;
    }
    int mid = (l + r) / 2;
    bulid(v * 2, l, mid);
    bulid(v * 2 + 1, mid + 1, r);
    //根据左右儿子更新当前结点
    tree[v].value = tree[v * 2].value + tree[v * 2 + 1].value;
}

typedef struct node {
    int l;        //线段的左端点
    int r;        //线段的左端点
    int value;    //线段上的值
    int add;
}node;
void update(int v, int r, int l, int m)//更新区间l~r加上数m
{
    if(tree[v].l == l && tree[v].r == r) {  //找到，更新并记录增量
        tree[v].value += m * (r - l + 1);
        tree[v].add = m;
        return;
    }
    if(tree[v].add) {
        tree[2 * v].add += tree[v].add;
        tree[2 * v + 1].add += tree[v].add;
        tree[v].add = 0;
    }
    int mid = (tree[v].l + tree[v].r) / 2;
    if(r <= mid) {
        update(v * 2, l, r, m);   //只对左儿子更新
    } else {
        if(l > mid) {
            update(v * 2 + 1, l, r, m);  //只对右儿子更新
        } else {                        //区间横跨左右儿子区间，对其两者均进行更新
            update(v * 2, l, mid, m);
            update(v * 2 + 1, mid + 1, r, m);
        }
    }
}

void query(int v, int l, int r)  //当前查询结点为v，要查询的区间为l~r
{
    if(tree[v].l == l && tree[v].r == r) {
        ans += tree[v].value;
        return;
    }
    if(tree[v].add) {
        tree[v * 2].add += tree[v].add;
        tree[v * 2 + 1].add += tree[v].add;
        tree[v].add = 0;
    }
    int mid = (tree[v].l + tree[v].r) / 2;
    if(r <= mid) {
        query(v * 2, l, r);   //要查询的区间都在左儿子
    } else {
        if(l > mid) {
            query(v * 2 + 1, l, r);  //要查询的区间都在左儿子
        } else {                //要查询的区间横跨左右孩子
            query(v * 2, l, mid);
            query(v * 2 + 1, mid + 1, r);
        }
    }
}

Description

N (2 <= N <= 8,000) cows have unique brands in the range 1..N. In a spectacular display of poor judgment, they visited the neighborhood ‘watering hole‘ and drank a few too many beers before dinner. When it was time to line up for their evening meal, they did not line up in the required ascending numerical order of their brands. 

Regrettably, FJ does not have a way to sort them. Furthermore, he‘s not very good at observing problems. Instead of writing down each cow‘s brand, he determined a rather silly statistic: For each cow in line, he knows the number of cows that precede that cow in line that do, in fact, have smaller brands than that cow. 

Given this data, tell FJ the exact ordering of the cows. 
Input

* Line 1: A single integer, N 

* Lines 2..N: These N-1 lines describe the number of cows that precede a given cow in line and have brands smaller than that cow. Of course, no cows precede the first cow in line, so she is not listed. Line 2 of the input describes the number of preceding cows whose brands are smaller than the cow in slot #2; line 3 describes the number of preceding cows whose brands are smaller than the cow in slot #3; and so on. 
Output

* Lines 1..N: Each of the N lines of output tells the brand of a cow in line. Line #1 of the output tells the brand of the first cow in line; line 2 tells the brand of the second cow; and so on.
Sample Input

5
1
2
1
0
Sample Output

2
4
5
3
1

Given an integer array nums, find the sum of the elements between indices i and j (i ≤ j), inclusive.

The update(i, val) function modifies nums by updating the element at index i to val.

Example:

Given nums = [1, 3, 5]

sumRange(0, 2) -> 9
update(1, 2)
sumRange(0, 2) -> 8
Note:

The array is only modifiable by the update function.
You may assume the number of calls to update and sumRange function is distributed evenly.