久久激情网站,国产一区二区在线观看免费播放,亚洲国产合集

pku 3667——线�D�|��(w��i)

Sun, 25 Jul 2010 02:53:00 GMT

#include < stdio.h >
#define maxn 50005
struct
{
     /*
    ml�U�段左边的最大空位，mr�U�段双��的最大空位，mm�U�段的最大空位，f�U�段最大空位的起始位置
    cov�U�段是否被覆盖，ud�U�段被覆盖时�Q�有没有往下将更改传递给孩子�Q�len�U�段的长�?br>     */
     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)
{
     /*
    往下传递改节点的覆盖信息，如果往下传递，则更新孩子的数据
    因�ؓ(f��)赖操作是针对已经��定被更新的�U�段的整块区域，所以不��孩子的在没修改之前的信息如何，都要被覆盖。孩子之前的信息已经没用了�?br>     */
     if (tree[i].ud) // tree[i].ud�?�Ӟ��表示该节点的覆盖信息�q�没传递到孩子�Q�否则，表示该节点的信息已经传递给孩子�?/span>
    {
         // 对自��q��更改
         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;
        }
         // 对孩子的更改�Q�由于对于赖操作的更�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) // �U�段在更新范围内�Q�则只需��修改信息传递给孩子�Q��ƈ修改必要的数据后直接�q�回
    {
        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);
    }
     // �׃��改线�D�|��被覆盖，数据的信息要通过孩子的信息来�l�合修改�?/span>
    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 ;
}

火碳�?/a> 2010-07-25 10:53 发表评论

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

代码�Q?br>

#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)//二分枚�D数来��定其名��?/span>
        {
            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

*/

火碳�?/a> 2010-05-24 17:50 发表评论

pku 1151 Atlantis——线�D�|��(w��i)

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

题意�Q�切割矩形�?/span>
先计��绿色部分，在计��橙色部分，再计��蓝色部分�?/span>

#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) // �׃��对于竖直边，肯定先插入在删除�Q�所以这里写的不是很�W�合所有的插入删除�l�计�?nbsp;
{
     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 ++ ) // 坐标��L��?nbsp;
        {
             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 ;
}

火碳�?/a> 2010-05-24 15:52 发表评论

pku 3468 A Simple Problem with Integers——线�D�|��(w��i)

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
代码�Q?br>

#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; // ��查更�?nbsp;
        tree[th * 2 ].delta += tree[th].delta, tree[th * 2 + 1 ].delta += tree[th].delta; // 把孩子的delta更新�Q�即赖操�?nbsp;
        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 ;
}

火碳�?/a> 2010-05-19 10:37 发表评论

pku 3321 Apple Tree——树(w��i)状数�l?

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
题意�Q�给��Z��颗树(w��i)�Q�对某个节点�q�行操作�Q�如果有�Ҏ(gu��)���Q�则摘；没有�Q�则长个�Ҏ(gu��)��。求某个节点拥有的苹果数量，每个节点最多只有一个苹果�?span style="font-family: sans-serif;">
代码�Q?br />
#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++;//��d��旉����ꐠ，���可以是问题转化为求区间和�?/span>
    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
*/

火碳�?/a> 2010-05-13 22:37 发表评论

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

题意�Q�某星左下方的星��Cؓ(f��)它的倹{��求出��g��0到n-1的星数�?/span>
代码�Q?/span>

#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); // �?w��i)状数组的坐标是�?开始   �?/span>
        sum[s(x + 1 )] ++ ;
        update(x + 1 );
    }
     for (i = 0 ; i < n; i ++ )
    {
        printf( " %d\n " , sum[i]);
    }
    system( " pause " );
     return 0 ;
}

火碳�?/a> 2010-05-13 20:32 发表评论

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
题意�Q�给出每个数所在位�|�的逆序列个敎ͼ�求这些数�?br>用线�D�|��(w��i)写，一来统计个敎ͼ�而来可以随时删除已去掉的敎ͼ��q�些操作都是logn�?br>

火碳�?/a> 2010-04-23 12:29 发表评论

Sun, 11 Oct 2009 11:48:00 GMT

�?w��i)状数组是对一个数�l�改变某个元素和求和比较实用的数据结构。两中操作都是O(logn)�?/span>
在解题过�E�中�Q�我们有旉��要维护一个数�l�的前缀和S[i]=A[1]+A[2]+...+A[i]�?/span>

但是不难发现�Q�如果我们修改了��L��一个A[i],S[i]、S[i+1]...S[n]都会(x��)发生变化�?/p>

可以��_(d��)��每次修改A[i]后，调整前缀和S[]在最坏情况下�?x��)需要O(n)的时间�?/p>

当n非常大时�Q�程序会(x��)�q�行得非常缓慢�?/p>

因此�Q�这里我们引�?#8220;�?w��i)状数�?#8221;�Q�它的修改与求和都是O(logn)的，效率非常高�?/p>

【理论�?/p>

��Z��Ҏ(gu��)��(w��i)状数�l�有个�Ş 象的认识�Q�我们先看下面这张图�?/p>

如图所�C�，�U�色矩�Ş表示的数�l�C[]��是�?w��i)状数组�?/p>

�q�里�Q�C[i]表示A[i-2^k+1]到A[i]的和�Q�而k则是i在二�q�制时末��?的个敎ͼ�

或者说是i�?的幂方和表示时的最��指数�?/p>

�Q?当然�Q�利用位�q�算�Q�我们可以直接计��出2^k=i&(i^(i-1)) �Q?/p>

同时�Q�我们也不难发现�Q�这个k��是该节点在�?w��i)中的高度，因而这个树(w��i)的高度不�?x��)超�q�logn�?/p>

所�?当我们修改A[i]的值时�Q�可以从C[i]往根节点一路上溯，调整�q�条路上的所有C[]卛_��Q?/p>

�q�个操作的复杂度在最坏情况下��是�?w��i)的高度即O(logn)�?nbsp;

另外�Q�对于求数列的前n��和�Q�只需扑ֈ�n以前的所有最大子�?w��i)，把其根节点的C加�v来即可�?/p>

不难发现�Q�这些子�?w��i)的数目是n在二�q�制�?的个敎ͼ�或者说是把n展开�?的幂方和时的��Ҏ(gu��)��,

因此�Q�求和操作的复杂度也是O(logn)�?/p>

接着�Q�我们考察�q�两�U�操作下标变化的规律�Q?/p>

首先看修�Ҏ(gu��)��作：(x��)

已知下标i�Q�求其父节点的下标�?br> 我们可以考虑�Ҏ(gu��)��(w��i)从逻辑上�{化：(x��)

如图�Q�我们将子树(w��i)向右对称��L��Q�虚拟出一些空白结点（图中白色�Q�，��原�?w��i)�{化成完全二叉�?w��i)�?/p>

有图可知�Q�对于节点i�Q�其父节点的下标与翻折出的空白节点下标相同�?/p>

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

�?nbsp; p = i + i&(i^(i-1)) �?/p>

接着对于求和操作�Q?/p>

因�ؓ(f��)每棵子树(w��i)覆盖的范围都�?的幂�Q�所以我们要求子�?w��i)i的前一��|��(w��i)�Q�只需让i减去2的最��幂卛_��?/p>

�?nbsp; p = i - i&(i^(i-1)) �?/p>

��x��Q�我们已�l�比较详�l�的分析了树(w��i)状数�l�的复杂度和原理�?

在最后，我们��给��Z��些树(w��i)状数�l�的实现代码�Q�希望读者能够仔�l�体�?x��)其中的�l�节�?/p>

【代码�?/p>

求最��幂2^k:

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

求前n��和�Q?br>

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

�Ҏ(gu��)��个元素进行加法操作：(x��)

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

火碳�?/a> 2009-10-11 19:48 发表评论