C++博客-夜幻梦回-文章分类-线段树||splay树||树状数组

pku 3667——线段树

火碳黑 — Sun, 25 Jul 2010 02:53:00 GMT

#include < stdio.h >
#define maxn 50005
struct
{
     /*
    ml线段左边的最大空位，mr线段右边的最大空位，mm线段的最大空位，f线段最大空位的起始位置
    cov线段是否被覆盖，ud线段被覆盖时，有没有往下将更改传递给孩子，len线段的长度
     */
     int l, r, ml, mr, mm, f, cov, ud, len;
}tree[maxn * 3 ];
void build ( int l, int r, int i)
{
    tree[i].l = l, tree[i].r = r;
    tree[i].ml = tree[i].mr = tree[i].len = tree[i].mm = r - l + 1 ;
    tree[i].f = tree[i].l;
    tree[i].cov = tree[i].ud = 0 ;
     if (l == r)
    {
         return ;
    }
     int m = (l + r) / 2 ;
    build (l, m , i * 2 ), build (m + 1 , r, i * 2    + 1 );
}
void down( int i)
{
     /*
    往下传递改节点的覆盖信息，如果往下传递，则更新孩子的数据
    因为赖操作是针对已经确定被更新的线段的整块区域，所以不管孩子的在没修改之前的信息如何，都要被覆盖。孩子之前的信息已经没用了。
     */
     if (tree[i].ud) // tree[i].ud为1时，表示该节点的覆盖信息还没传递到孩子，否则，表示该节点的信息已经传递给孩子了
    {
         // 对自己的更改
         if (tree[i].cov)
        {
            tree[i].ml = tree[i].mr = tree[i].mm = 0 ;
        }
         else
        {
            tree[i].ml = tree[i].mr = tree[i].mm = tree[i].r - tree[i].l + 1 ;
            tree[i].f = tree[i].l;
        }
         // 对孩子的更改，由于对于赖操作的更细传递到该节点，如果要利用到孩子节点的信息，所以也要修改孩子的数据
         if (tree[i].l != tree[i].r)
        {
            tree[i * 2 ].cov = tree[i * 2 + 1 ].cov = tree[i].cov;
            tree[i * 2 ].ud = tree[i * 2 + 1 ].ud = 1 ;
             if (tree[i].cov)
            {
                tree[i * 2 ].ml = tree[i * 2 ].mr = tree[i * 2 ].mm = 0 ;
                tree[i * 2 + 1 ].ml = tree[i * 2 + 1 ].mr = tree[i * 2 + 1 ].mm = 0 ;
            }
             else
            {
                tree[i * 2 ].ml = tree[i * 2 ].mr = tree[i * 2 ].mm = tree[i * 2 ].r - tree[i * 2 ].l + 1 ;
                tree[i * 2 ].f = tree[i * 2 ].l;
                tree[i * 2 + 1 ].ml = tree[i * 2 + 1 ].mr = tree[i * 2 + 1 ].mm = tree[i * 2 + 1 ].r - tree[i * 2 + 1 ].l + 1 ;
                tree[i * 2 + 1 ].f = tree[i * 2 + 1 ].l;
            }
        }
        tree[i].ud = 0 ;
    }
}
void insert( int l, int r, int i, int cov)
{
     if (tree[i].l >= l && tree[i].r <= r) // 线段在更新范围内，则只需将修改信息传递给孩子，并修改必要的数据后直接返回
    {
        tree[i].cov = cov;
        tree[i].ud = 1 ;
        down(i);
         return ;
    }
    down(i);
     int m = (tree[i].l + tree[i].r) >> 1 ;
     if (l > m)
    {
        insert(l, r, i * 2 + 1 , cov);
    }
     else if (m >= r)
    {
        insert(l, r, i * 2 , cov);
    }
     else
    {
        insert(l, r, i * 2 , cov), insert(l, r, i * 2 + 1 , cov);
    }
     // 由于改线段没被覆盖，数据的信息要通过孩子的信息来结合修改。
    tree[i].ml = tree[i * 2 ].ml, tree[i].mr = tree[i * 2 + 1 ].mr;
     if (tree[i * 2 ].ml == tree[i * 2 ].len)
    {
        tree[i].ml += tree[i * 2 + 1 ].ml;
    }
     if (tree[i * 2 + 1 ].mr == tree[i * 2 + 1 ].len)
    {
        tree[i].mr += tree[i * 2 ].mr;
    }
    tree[i].mm = tree[i * 2 ].mm;
    tree[i].f = tree[i * 2 ].f;
     if (tree[i].mm < tree[i * 2 ].mr + tree[i * 2 + 1 ].ml)
    {
        tree[i].mm = tree[i * 2 ].mr + tree[i * 2 + 1 ].ml;
        tree[i].f = tree[i * 2 ].r - tree[i * 2 ].mr + 1 ;
    }
     if (tree[i].mm < tree[i * 2 + 1 ].mm)
    {
        tree[i].mm = tree[i * 2 + 1 ].mm;
        tree[i].f = tree[i * 2 + 1 ].f;
    }
}
int find( int len, int i)
{
    down(i);
     if (tree[i].ml >= len)
    {
         return tree[i].l;
    }
     else if (tree[i * 2 ].mm >= len)
    {
         return find (len, i * 2 );
    }
     else if (tree[i * 2 ].mr + tree[i * 2 + 1 ].ml >= len)
    {
         return tree[i * 2 ].r - tree[i * 2 ].mr + 1 ;
    }
     else if (tree[i * 2 + 1 ].mm >= len)
    {
         return find (len, i * 2 + 1 );
    }
     return 0 ;
}
int main()
{
     int n, m, op, d, x, ans;
    scanf( " %d%d " , & n, & m);
    build ( 1 , n, 1 );
     while (m -- )
    {
        scanf( " %d " , & op);
         if (op == 1 )
        {
            scanf( " %d " , & d);
            ans = find(d, 1 );
            printf( " %d\n " , ans);
             if (ans)
            {
                insert(ans, ans + d - 1 , 1 , 1 );
            }
        }
         else if (op == 2 )
        {
            scanf( " %d%d " , & x, & d);
            insert(x, x + d - 1 , 1 , 0 );
        }
    }
     return 0 ;
}

火碳黑 2010-07-25 10:53 发表评论

pku 2104 K-th Number__线段树

火碳黑 — Mon, 24 May 2010 09:50:00 GMT

K-th Number

Description

You are working for Macrohard company in data structures department. After failing your previous task about key insertion you were asked to write a new data structure that would be able to return quickly k-th order statistics in the array segment.
That is, given an array a[1...n] of different integer numbers, your program must answer a series of questions Q(i, j, k) in the form: "What would be the k-th number in a[i...j] segment, if this segment was sorted?"
For example, consider the array a = (1, 5, 2, 6, 3, 7, 4). Let the question be Q(2, 5, 3). The segment a[2...5] is (5, 2, 6, 3). If we sort this segment, we get (2, 3, 5, 6), the third number is 5, and therefore the answer to the question is 5.

Input

The first line of the input file contains n --- the size of the array, and m --- the number of questions to answer (1 <= n <= 100 000, 1 <= m <= 5 000).
The second line contains n different integer numbers not exceeding 10⁹ by their absolute values --- the array for which the answers should be given.
The following m lines contain question descriptions, each description consists of three numbers: i, j, and k (1 <= i <= j <= n, 1 <= k <= j - i + 1) and represents the question Q(i, j, k).

Output

For each question output the answer to it --- the k-th number in sorted a[i...j] segment.

Sample Input

7 3
1 5 2 6 3 7 4
2 5 3
4 4 1
1 7 3

Sample Output

5
6
3

代码：

#include<stdio.h>
#include<stdlib.h>
#define maxn 100010
struct T
{
    int l, r, dep;
    T * pl, *pr;
}fn[maxn * 3];
int th = 0, a, b, sort[30][maxn], s[maxn], s1, s2;
T * build(int l, int r, int dep)
{
    T * p = &fn[th++];
    p->l = l, p->r = r, p->dep = dep;
    if (l == r)
    {
        sort[dep][l] = s[l];
    }
    else
    {
        int m = (l + r) / 2, i, j, k;
        p->pl = build(l, m, dep + 1), p->pr = build(m + 1, r, dep + 1);
        for (k = i = l, j = m + 1;i <= m && j <= r;)
        {
            if (sort[dep + 1][i] < sort[dep + 1][j])
            {
                sort[dep][k++] = sort[dep + 1][i++];
            }
            else
            {
                sort[dep][k++] = sort[dep + 1][j++];
            }
        }
        for (; i <= m; i++)
        {
            sort[dep][k++] = sort[dep + 1][i];
        }
        for (; j <= r; j++)
        {
            sort[dep][k++] = sort[dep + 1][j];
        }
    }
    return p;
}
int query(T * p, int num)
{
    int m, l, r, t;
//确定所询问区间里排在num前的数的个数
    if (a <= p->l && p->r <= b)
    {
        l = p->l, r = p->r;
        if (sort[p->dep][p->r] <= num)
        {
            return r - l + 1;
        }
        while (l < r)
        {
            m = (l + r) / 2;
            if (sort[p->dep][m] > num)
            {
                r = m;
            }
            else
            {
                l = m + 1;
            }
        }
        return r - p->l;
    }
    else
    {
        m = (p->l + p->r) / 2;
        t = 0;
        if (a <= m)
        {
            t += query(p->pl, num);
        }
        if (b > m)
        {
            t += query(p->pr, num);
        }
        return t;
    }
}
int main()
{
    int n, m, i, l, r, mid, pre, c;
    scanf("%d%d", &n, &m);
    for (i = 1; i <= n; i++)
    {
        scanf("%d", &s[i]);
    }
    T * tree = build(1, n, 0);
    while (m--)
    {
        scanf("%d%d%d", &a, &b, &c);
        l = 1, r = n;
        while (l < r)//二分枚举数来确定其名次
        {
            mid = (l + r) / 2;
            pre = query(tree, sort[0][mid]);
            if (pre >= c)
            {
                r = mid;
            }
            else
            {
                l = mid + 1;
            }
        }
        printf("%d\n", sort[0][l]);
    }
    system("pause");
    return 0;
}
/*
7 100
5 3 2 9 8 1 6

*/

火碳黑 2010-05-24 17:50 发表评论

pku 1151 Atlantis——线段树

火碳黑 — Mon, 24 May 2010 07:52:00 GMT

Atlantis

Description

There are several ancient Greek texts that contain descriptions of the fabled island Atlantis. Some of these texts even include maps of parts of the island. But unfortunately, these maps describe different regions of Atlantis. Your friend Bill has to know the total area for which maps exist. You (unwisely) volunteered to write a program that calculates this quantity.

Input

The input consists of several test cases. Each test case starts with a line containing a single integer n (1 <= n <= 100) of available maps. The n following lines describe one map each. Each of these lines contains four numbers x1;y1;x2;y2 (0 <= x1 < x2 <= 100000;0 <= y1 < y2 <= 100000), not necessarily integers. The values (x1; y1) and (x2;y2) are the coordinates of the top-left resp. bottom-right corner of the mapped area.
The input file is terminated by a line containing a single 0. Don't process it.

Output

For each test case, your program should output one section. The first line of each section must be "Test case #k", where k is the number of the test case (starting with 1). The second one must be "Total explored area: a", where a is the total explored area (i.e. the area of the union of all rectangles in this test case), printed exact to two digits to the right of the decimal point.
Output a blank line after each test case.

Sample Input

2
10 10 20 20
15 15 25 25.5
0

Sample Output

Test case #1
Total explored area: 180.00

题意：切割矩形。
先计算绿色部分，在计算橙色部分，再计算蓝色部分。

#include < stdio.h >
#include < stdlib.h >
#define maxn 500
struct T
{
     int l, r, cov;
     double len;
}tree[maxn * 5 ];
struct R
{
     double x, y1, y2;
     int lr;
}rec[maxn * 2 ];
double y[maxn * 2 ];
int cmp1( const void * a, const void * b)
{
     double aa = * (( double * )a), bb = * (( double * )b);
     if (aa > bb)
    {
         return 1 ;
    }
     if (aa == bb)
    {
         return 0 ;
    }
     return - 1 ;
}
int cmp2( const void * a, const void * b)
{
    R aa = * ((R * )a), bb = * ((R * )b);
     if (aa.x > bb.x)
    {
         return 1 ;
    }
     if (aa.x == bb.x)
    {
         return 0 ;
    }
     return - 1 ;
}
void build( int l, int r, int th)
{
    tree[th].l = l, tree[th].r = r, tree[th].cov = 0 , tree[th].len = 0 ;
     if (l + 1 == r)
    {
         return ;
    }
     int m = (l + r) >> 1 ;
    build(l, m, th * 2 ), build(m, r, th * 2 + 1 );
}
void op( int l, int r, int th, int del) // 由于对于竖直边，肯定先插入在删除，所以这里写的不是很符合所有的插入删除统计。
{
     if (tree[th].l == l && tree[th].r == r)
    {
        tree[th].cov += del;
         if (tree[th].cov > 0 )
        {
            tree[th].len = y[r] - y[l];
        }
         else
        {
            tree[th].len = tree[th * 2 ].len + tree[th * 2 + 1 ].len;
        }
         return ;
    }
     int m = (tree[th].l + tree[th].r) >> 1 ;
     if (r <= m)
    {
        op(l, r, th * 2 , del);
    }
     else if (l >= m)
    {
        op(l, r, th * 2 + 1 , del);
    }
     else
    {
        op(l, m, th * 2 , del), op(m, r, th * 2 + 1 , del);
    }
     if (tree[th].cov > 0 )
    {
        tree[th].len = y[tree[th].r] - y[tree[th].l];
    }
     else
    {
        tree[th].len = tree[th * 2 ].len + tree[th * 2 + 1 ].len;
    }
}
int bs( int l, int r, double key)
{
     int m;
     while (l <= r)
    {
        m = (l + r) >> 1 ;
         if (y[m] > key)
        {
            r = m - 1 ;
        }
         else if (y[m] < key)
        {
            l = m + 1 ;
        }
         else
        {
             return m;
        }
    }
}
int main()
{
     int n, i, j, k, l, r, ca = 0 ;
     double ans, x1, y1, x2, y2;
     while (scanf( " %d " , & n), n)
    {
        ca ++ ;
         for (i = 0 , j = 0 ; i < n; i ++ )
        {
            scanf( " %lf%lf%lf%lf " , & x1, & y1, & x2, & y2);
            y[j] = y1, rec[j].x = x1, rec[j].y1 = y1, rec[j].y2 = y2, rec[j ++ ].lr = 1 ;
            y[j] = y2, rec[j].x = x2, rec[j].y1 = y1, rec[j].y2 = y2, rec[j ++ ].lr = - 1 ;
        }
        qsort(y, j, sizeof ( double ), cmp1);
        qsort(rec, j, sizeof (R), cmp2);
         for (k = i = 1 ; i < j; i ++ ) // 坐标离散化
        {
             if (y[i] != y[i - 1 ])
            {
                y[k ++ ] = y[i];
            }
        }
        build( 0 , k, 1 );
        k -- ;
         for (i = 0 , ans = 0 ; i < j - 1 ; i ++ )
        {
            l = bs( 0 , k, rec[i].y1), r = bs( 0 , k, rec[i].y2);
            op(l, r, 1 , rec[i].lr);
            ans += 1.0 * tree[ 1 ].len * (rec[i + 1 ].x - rec[i].x);
        }
        printf( " Test case #%d\nTotal explored area: %.2lf\n\n " , ca, ans);
    }
    system( " pause " );
     return 0 ;
}

火碳黑 2010-05-24 15:52 发表评论

pku 3468 A Simple Problem with Integers——线段树

火碳黑 — Wed, 19 May 2010 02:37:00 GMT

A Simple Problem with Integers

Description

You have N integers, A₁, A₂, ... , A_N. You need to deal with two kinds of operations. One type of operation is to add some given number to each number in a given interval. The other is to ask for the sum of numbers in a given interval.

Input

The first line contains two numbers N and Q. 1 ≤ N,Q ≤ 100000.
The second line contains N numbers, the initial values of A₁, A₂, ... , A_N. -1000000000 ≤ A_i ≤ 1000000000.
Each of the next Q lines represents an operation.
"C abc" means adding c to each of A_a, A_a₊₁, ... , A_b. -10000 ≤ c ≤ 10000.
"Q ab" means querying the sum of A_a, A_a₊₁, ... , A_b.

Output

You need to answer all Q commands in order. One answer in a line.

Sample Input

10 5
1 2 3 4 5 6 7 8 9 10
Q 4 4
Q 1 10
Q 2 4
C 3 6 3
Q 2 4

Sample Output

4
55
9
15
代码：

#include < stdio.h >
#include < stdlib.h >
#define maxn 100010
struct T
{
     int l, r;
    __int64 value, delta;
}tree[ 5 * maxn];
__int64 v[maxn];
void build( int l, int r, int th)
{
    tree[th].l = l, tree[th].r = r, tree[th].delta = 0 ;
     if (l == r)
    {
        tree[th].value = v[l];
         return ;
    }
     int k = (l + r) / 2 ;
    build(l, k, th * 2 );
    build(k + 1 , r, th * 2 + 1 );
    tree[th].value = tree[th * 2 ].value + tree[th * 2 + 1 ].value;
}
void update( int l, int r, int th, __int64 d)
{
    tree[th].value += (r - l + 1 ) * d;
     if (tree[th].delta)
    {
        tree[th].value += (tree[th].r - tree[th].l + 1 ) * tree[th].delta; // 检查更新
        tree[th * 2 ].delta += tree[th].delta, tree[th * 2 + 1 ].delta += tree[th].delta; // 把孩子的delta更新，即赖操作
        tree[th].delta = 0 ;
    }
     if (tree[th].l == l && tree[th].r == r)
    {
        tree[th * 2 ].delta += d, tree[th * 2 + 1 ].delta += d;
         return ;
    }
     int k = (tree[th].l + tree[th].r) / 2 ;
     if (r <= k)
    {
        update(l, r, th * 2 , d);
    }
     else if (l >= k + 1 )
    {
        update(l, r, th * 2 + 1 , d);
    }
     else
    {
        update(l, k, th * 2 , d), update(k + 1 , r, th * 2 + 1 , d);
    }
}
__int64 sum( int l, int r, int th)
{
     if (tree[th].delta)
    {
        tree[th].value += (tree[th].r - tree[th].l + 1 ) * tree[th].delta;
        tree[th * 2 ].delta += tree[th].delta, tree[th * 2 + 1 ].delta += tree[th].delta;
        tree[th].delta = 0 ;
    }
     if (tree[th].l == l && tree[th].r == r)
    {
         return tree[th].value;
    }
     int k = (tree[th].l + tree[th].r) / 2 ;
     if (r <= k)
    {
         return sum(l, r, th * 2 );
    }
     else if (l >= k + 1 )
    {
         return sum(l, r, th * 2 + 1 );
    }
     else
    {
         return sum(l, k, th * 2 ) + sum(k + 1 , r, th * 2 + 1 );
    }
}
int main()
{
     int n, m, i, x, y;
    __int64 delta;
     char op[ 2 ];
    scanf( " %d%d " , & n, & m);
     for (i = 1 ; i <= n; i ++ )
    {
        scanf( " %I64d " , & v[i]);
    }
    build( 1 , n, 1 );
     while (m -- )
    {
        scanf( " %s " , op);
         if ( * op == ' Q ' )
        {
            scanf( " %d%d " , & x, & y);
            printf( " %I64d\n " , sum(x, y, 1 ));
        }
         else
        {
            scanf( " %d%d%I64d " , & x, & y, & delta);
            update(x, y, 1 , delta);
        }
    }
    system( " pause " );
     return 0 ;
}

火碳黑 2010-05-19 10:37 发表评论

pku 3321 Apple Tree——树状数组

火碳黑 — Thu, 13 May 2010 14:37:00 GMT

Apple Tree

Description

There is an apple tree outside of kaka's house. Every autumn, a lot of apples will grow in the tree. Kaka likes apple very much, so he has been carefully nurturing the big apple tree.

The tree has N forks which are connected by branches. Kaka numbers the forks by 1 to N and the root is always numbered by 1. Apples will grow on the forks and two apple won't grow on the same fork. kaka wants to know how many apples are there in a sub-tree, for his study of the produce ability of the apple tree.

The trouble is that a new apple may grow on an empty fork some time and kaka may pick an apple from the tree for his dessert. Can you help kaka?

Input

The first line contains an integer N (N ≤ 100,000) , which is the number of the forks in the tree.
The following N - 1 lines each contain two integers u and v, which means fork u and fork v are connected by a branch.
The next line contains an integer M (M ≤ 100,000).
The following M lines each contain a message which is either
"C x" which means the existence of the apple on fork x has been changed. i.e. if there is an apple on the fork, then Kaka pick it; otherwise a new apple has grown on the empty fork.
or
"Q x" which means an inquiry for the number of apples in the sub-tree above the fork x, including the apple (if exists) on the fork x
Note the tree is full of apples at the beginning

Output

For every inquiry, output the correspond answer per line.

Sample Input

Sample Output

3
2
题意：给出一颗树，对某个节点进行操作，如果有苹果，则摘；没有，则长个苹果。求某个节点拥有的苹果数量，每个节点最多只有一个苹果。
代码：

#include<stdio.h>
#include<stdlib.h>
#define maxn 100020
int low[maxn], high[maxn], n, c[maxn], t[maxn];
struct P
{
    int pt, head;
}p[maxn];
struct N
{
    int pt, id;
}node[maxn];
int th = 0, time = 0;
int create(int id)
{
    th++;
    node[th].pt = -1, node[th].id = id;
    return th;
}
int lowbit(int x)
{
    return x & (-x);
}
void update(int x, int y)
{
    while (x <= n)
    {
        c[x] += y;
        x += lowbit(x);
    }
}
int sum(int x)
{
    int s = 0;
    while (x > 0)
    {
        s += c[x];
        x -= lowbit(x);
    }
    return s;
}
void dfs(int root)
{
    int v = p[root].head;
    time++;//添加时间戳 ，就可以是问题转化为求区间和 
    low[root] = time;
    for (v = p[root].head; v != -1; v = node[v].pt)
    {
        dfs(node[v].id);
    }
    high[root] = time;
}
int main()
{
    int i, u, v, no, m, x, num;
    scanf("%d", &n);
    for (i = 1; i <= n; i++)
    {
        p[i].pt = -1, p[i].head = -1;
        update(i, 1);
        t[i] = 1;
    }
    num = n;
    while (--num)
    {
        scanf("%d%d", &u, &v);
        no = create(v);
        node[p[u].pt].pt = no;
        p[u].pt = no;
        if (p[u].head == -1)
        {
            p[u].head = no;
        }
    }
    dfs(1);
    char a[2];
    scanf("%d", &m);
    while (m--)
    {
        scanf("%s%d", a, &x);
        if (a[0] == 'Q')
        {
            printf("%d\n", sum(high[x]) - sum(low[x] - 1));
        }
        else
        {
            if (t[x])
            {
                update(low[x], -1);
                t[x] = 0;
            }
            else
            {
                update(low[x], 1);
                t[x] = 1;
            }
        }
    }
    system("pause");
    return 0;
}
/*
5
1 2
1 3
3 4
3 5
*/

火碳黑 2010-05-13 22:37 发表评论

pku 2352 Stars__树状数组

火碳黑 — Thu, 13 May 2010 12:32:00 GMT

Stars

Description

Astronomers often examine star maps where stars are represented by points on a plane and each star has Cartesian coordinates. Let the level of a star be an amount of the stars that are not higher and not to the right of the given star. Astronomers want to know the distribution of the levels of the stars.

For example, look at the map shown on the figure above. Level of the star number 5 is equal to 3 (it's formed by three stars with a numbers 1, 2 and 4). And the levels of the stars numbered by 2 and 4 are 1. At this map there are only one star of the level 0, two stars of the level 1, one star of the level 2, and one star of the level 3.

You are to write a program that will count the amounts of the stars of each level on a given map.

Input

The first line of the input file contains a number of stars N (1<=N<=15000). The following N lines describe coordinates of stars (two integers X and Y per line separated by a space, 0<=X,Y<=32000). There can be only one star at one point of the plane. Stars are listed in ascending order of Y coordinate. Stars with equal Y coordinates are listed in ascending order of X coordinate.

Output

The output should contain N lines, one number per line. The first line contains amount of stars of the level 0, the second does amount of stars of the level 1 and so on, the last line contains amount of stars of the level N-1.

Sample Input

Sample Output

题意：某星左下方的星数为它的值。求出值从0到n-1的星数。
代码：

#include < stdio.h >
#define maxn 32010
int c[maxn], sum[maxn];
int lowBit( int x)
{
     return x & (x ^ (x - 1 ));//return x & (-x);更快
}
void update( int x)
{
     while (x < maxn)
    {
        c[x] ++ ;
        x += lowBit(x);
    }
}
int s( int x)
{
     int pre = 0 ;
     while (x > 0 )
    {
        pre += c[x];
        x -= lowBit(x);
    }
     return pre;
}
int main()
{
     int i, n, x, y;
    scanf( " %d " , & n);
     for (i = 0 ; i < n; i ++ )
    {
        scanf( " %d%d " , & x, & y); // 树状数组的坐标是从1开始
        sum[s(x + 1 )] ++ ;
        update(x + 1 );
    }
     for (i = 0 ; i < n; i ++ )
    {
        printf( " %d\n " , sum[i]);
    }
    system( " pause " );
     return 0 ;
}

火碳黑 2010-05-13 20:32 发表评论

pku 2182 Lost Cows——线段树入门题

火碳黑 — Fri, 23 Apr 2010 04:29:00 GMT

Lost Cows

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

Sample Output

2
4
5
#include<stdio.h>
#define maxn 8000
int tree[maxn*3], s[maxn], ans[maxn];
void build(int l, int r, int depth)
{
    tree[depth] = r - l + 1;
    if (l != r)
    {
        int mid = (l + r) >> 1;
        build(l, mid, (depth << 1));
        build(mid + 1, r, (depth << 1) + 1);
    }
}
void find(int l, int r, int index, int num, int depth)
{
    tree[depth]--;
    if (l == r)
    {
        ans[index] = r;
        return;
    }
    else
    {
        int mid = (l + r) >> 1, m = depth << 1;
        if (num <= tree[m])
        {
            find(l, mid, index, num, m);
        }
        else
        {
            num -= tree[m];
            find(mid + 1, r, index, num, m + 1);
        }
    }
}
int main()
{
    int n, i;
    while (scanf("%d", &n) != EOF)
    {
        build(1, n, 1);
        for (i = 2, s[1] = 1; i <= n; i++)
        {
            scanf("%d", &s[i]);
            s[i]++;
        }
        for (i = n; i >= 1; i--)
        {
            find(1, n, i, s[i], 1);
        }
        for (i = 1; i <= n; i++)
        {
            printf("%d\n", ans[i]);
        }
    }
    return 0;
}

3
1
题意：给出每个数所在位置的逆序列个数，求这些数。
用线段树写，一来统计个数，而来可以随时删除已去掉的数，这些操作都是logn。

火碳黑 2010-04-23 12:29 发表评论

树状数组

火碳黑 — Sun, 11 Oct 2009 11:48:00 GMT

树状数组是对一个数组改变某个元素和求和比较实用的数据结构。两中操作都是O(logn)。
在解题过程中，我们有时需要维护一个数组的前缀和S[i]=A[1]+A[2]+...+A[i]。

但是不难发现，如果我们修改了任意一个A[i],S[i]、S[i+1]...S[n]都会发生变化。

可以说，每次修改A[i]后，调整前缀和S[]在最坏情况下会需要O(n)的时间。

当n非常大时，程序会运行得非常缓慢。

因此，这里我们引入“树状数组”，它的修改与求和都是O(logn)的，效率非常高。

【理论】

为了对树状数组有个形象的认识，我们先看下面这张图。

如图所示，红色矩形表示的数组C[]就是树状数组。

这里，C[i]表示A[i-2^k+1]到A[i]的和，而k则是i在二进制时末尾0的个数，

或者说是i用2的幂方和表示时的最小指数。

（当然，利用位运算，我们可以直接计算出2^k=i&(i^(i-1)) ）

同时，我们也不难发现，这个k就是该节点在树中的高度，因而这个树的高度不会超过logn。

所以,当我们修改A[i]的值时，可以从C[i]往根节点一路上溯，调整这条路上的所有C[]即可，

这个操作的复杂度在最坏情况下就是树的高度即O(logn)。

另外，对于求数列的前n项和，只需找到n以前的所有最大子树，把其根节点的C加起来即可。

不难发现，这些子树的数目是n在二进制时1的个数，或者说是把n展开成2的幂方和时的项数,

因此，求和操作的复杂度也是O(logn)。

接着，我们考察这两种操作下标变化的规律：

首先看修改操作：

已知下标i，求其父节点的下标。
我们可以考虑对树从逻辑上转化：

如图，我们将子树向右对称翻折，虚拟出一些空白结点（图中白色），将原树转化成完全二叉树。

有图可知，对于节点i，其父节点的下标与翻折出的空白节点下标相同。

因而父节点下标 p=i+2^k (2^k是i用2的幂方和展开式中的最小幂，即i为根节点子树的规模)

即 p = i + i&(i^(i-1)) 。

接着对于求和操作：

因为每棵子树覆盖的范围都是2的幂，所以我们要求子树i的前一棵树，只需让i减去2的最小幂即可。

即 p = i - i&(i^(i-1)) 。

至此，我们已经比较详细的分析了树状数组的复杂度和原理。

在最后，我们将给出一些树状数组的实现代码，希望读者能够仔细体会其中的细节。

【代码】

求最小幂2^k:

int Lowbit(int t)
{
return t & ( t ^ ( t - 1 ) );
}

求前n项和：

int Sum(int end)
{
    int sum = 0;
    while(end > 0)
    {
        sum += in[end];
        end -= Lowbit(end);
    }
    return sum;
}

对某个元素进行加法操作：

void plus(int pos , int num)
{
    while(pos <= n)
    {
          in[pos] += num;
          pos += Lowbit(pos);
    }
}

火碳黑 2009-10-11 19:48 发表评论