C++博客-英雄哪里出来-随笔分类-树状数组[更新中...]

HDU 2688 Rotate

英雄哪里出来 — Mon, 11 Apr 2011 04:19:00 GMT

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2688

/*
题意：
    给定一串长度为N的序列(N <= 3000000)，然后是M(M<=10000)个操作，
每个操作有两种形式：
1. Q 询问当前序列的顺序数
2. R S E (abs(E-S) <= 1000)将下标S到E的数列向左循环旋转一次

题解：
    树状数组

思路：
    经典问题，首先将N个数的顺序数用树状数组求出来，这个操作是nlogn
的，然后对于每次R操作，统计在[S+1，E]区间中比v[S]大的数和小的数的个数，
将之前的顺序数 - 比它大的数 + 比它小的数，更新这个值。然后顺序赋值即可。
Q操作只需要直接输出当前顺序数的值即可。
*/

#include <iostream>

using namespace std;

#define maxn 10001
int ans[3000001];
int n, m;

#define ll __int64

ll c[maxn];

int lowbit(int x) {
    return x & (-x);
}

void add(int pos) {
    while(pos < maxn) {
        c[pos] ++;
        pos += lowbit(pos);
    }
}

ll sum(int pos) {
    ll s = 0;
    while(pos > 0) {
        s += c[pos];
        pos -= lowbit(pos);
    }
    return s;
}

int main() {
    int i;
    while(scanf("%d", &n) != EOF) {
        for(i = 1; i <= 10000; i++)
            c[i] = 0;
        ll val = 0;
        for(i = 0; i < n; i++) {
            scanf("%d", &ans[i]);
            val += sum(ans[i] - 1);
            add(ans[i]);
        }
        scanf("%d", &m);

        while(m--) {
            char str[10];
            scanf("%s", str);

            if(str[0] == 'Q') {
                printf("%I64d\n", val);
            }else {
                int s, e;
                scanf("%d %d", &s, &e);
                if(s > e) {
                    int tmp = s;
                    s = e;
                    e = tmp;
                }

                if(s != e) {
                    int v = ans[s];
                    int lt = 0, bt = 0;
                    for(i = s; i < e; i++) {
                        ans[i] = ans[i+1];
                        if(v < ans[i+1]) {
                            lt ++;
                        }
                        if(v > ans[i+1]) {
                            bt ++;
                        }

                    }
                    ans[e] = v;
                    val = val - lt + bt;
                }
            }
        }
    }
    return 0;
}

英雄哪里出来 2011-04-11 12:19 发表评论

PKU 3145 Harmony Forever

英雄哪里出来 — Sun, 10 Apr 2011 03:12:00 GMT

摘要: 题目链接：http://poj.org/problem?id=3145 /**//*题意：对于一个集合S，一共两种操作：1. B X: 添加一个数X到S. 第K个B操作发生在第K个时间点，并且每个之前S集合中没有X。2. A Y: 在S集合中所有数中, 被Y除后余数最小... 阅读全文

英雄哪里出来 2011-04-10 11:12 发表评论

PKU 1990 MooFest

英雄哪里出来 — Sat, 09 Apr 2011 14:06:00 GMT

题目链接：http://poj.org/problem?id=1990

/*
题意：
    约翰农夫有N(N <= 20000)头牛，每头牛有一个权值Vi，他将它们排成一排，
牛i和牛j的阈值是  两者的距离差*max(Vi, Vj)，现在给出每头牛的权值和它的
位置，求所有两头牛之间的阈值之和。

题解：
    树状数组

思路：
    我们准备两个树状数组，以每头牛的位置作为树状数组的下标，其中一个用
来表示当前位置的牛的位置的值，另一个则记录当前位置牛的个数，然后对所有
牛以Vi为关键字进行递增排序。
    接下来对每头牛进行一次线扫，首先统计比当前这头牛的位置小的和大的牛
的数目和位置和，然后做差求出以当前牛的权值为最大值的阈值总和。之后将这
头牛的数量和位置插入到树状数组中进行更新。
*/

#include <iostream>
#include <algorithm>

using namespace std;

#define maxn 20010
#define ll __int64

struct point {
    int V;
    int pos;
}pt[maxn];

ll c[2][maxn];
int n, Max;

ll ABS(ll v) {
    return v < 0 ? -v : v;
}

int cmp(point a, point b) {
    return a.V < b.V;
}

int lowbit(int x) {
    return x & (-x);
}

void add(int idx, int pos, int v) {
    while(pos <= Max) {
        c[idx][pos] += v;
        pos += lowbit(pos);
    }
}

ll sum(int idx, int pos) {
    ll s = 0;
    while(pos > 0) {
        s += c[idx][pos];
        pos -= lowbit(pos);
    }
    return s;
}

int main() {
    int i;
    while(scanf("%d", &n) != EOF) {
        Max = 0;
        for(i = 0; i < n; i++) {
            scanf("%d %d", &pt[i].V, &pt[i].pos);
            if(pt[i].pos > Max)
                Max = pt[i].pos;
        }

        for(i = 1; i <= Max; i++)
            c[0][i] = c[1][i] = 0;
        sort(pt, pt + n, cmp);

        ll ans = 0;
        for(i = 0; i < n; i++) {
            ans += ABS((sum(0, Max) - sum(0, pt[i].pos)
                 - (sum(1, Max) - sum(1, pt[i].pos)) * pt[i].pos)) * pt[i].V;

            ans += ABS((sum(0, pt[i].pos)
                 - sum(1, pt[i].pos) * pt[i].pos)) * pt[i].V;

            add(0, pt[i].pos, pt[i].pos);
            add(1, pt[i].pos, 1);
        }
        printf("%I64d\n", ans);
    }
    return 0;
}

英雄哪里出来 2011-04-09 22:06 发表评论

PKU 2828 Buy Tickets

英雄哪里出来 — Sat, 09 Apr 2011 07:06:00 GMT

题目链接：http://poj.org/problem?id=2828

/*
题意：
    给定N(1 <= N <= 200000)个整数对(A,B)，表示在A右边的位置插入一个B，
经过N次操作后问最后的B序列的排列情况。
题解：
    树状数组或者线段树

思路：
    这题的数据量比较大，一开始可以模拟一下过程，但是直接暴力肯定是超时
的，因为每次插入过程，这个位置的后面的元素必然是要顺序往后移动的。所以
总的复杂度高达O(n^2)。
    但是这个问题可以转化，我们这样考虑，对于任意两个整数对(A1,B1)和(A2,B2)
保证(A1,B1)在(A2,B2)之前出现，如果A1小于A2，后面的整数对是不影响前面整
数对的位置关系的，否则B1的位置必然要受到B2的影响而向后移动一位。
    于是A1和A2之间就存在一个逆序关系，我们可以联想到树状数组求逆序数时
候的做法，从后往前，对于最后一个数，它的位置就是An，因为之后没有插入数
了，它已经稳定下来了，然后将这个位置插入到树状数组的相应位置去，每次扫
描到当前数的时候二分枚举当前数前面有多少“空位”，空位的统计可以采用树
状数组的成段求和，找到后将这个数插入，N次操作后答案就保存下来了。
*/

#include <iostream>

using namespace std;

#define maxn 200010

int n;
int c[maxn];

struct point {
    int A, B;
}pt[maxn];

int lowbit(int x) {
    return x & (-x);
}

void add(int pos) {
    while(pos <= n) {
        c[pos] ++;
        pos += lowbit(pos);
    }
}

int sum(int pos) {
    int s = 0;
    while(pos > 0) {
        s += c[pos];
        pos -= lowbit(pos);
    }
    return s;
}

int ans[maxn];

int main() {
    int i;
    while(scanf("%d", &n) != EOF) {
        for(i = 1; i <= n; i++)
            c[i] = 0;
        for(i = 1; i <= n; i++) {
            scanf("%d %d", &pt[i].A, &pt[i].B);
            pt[i].A ++;
        }
        for(i = n; i >= 1; i--) {
            int l = 1;
            int r = n;
            int as = 1;
            while(l <= r) {
                int m = (l + r) >> 1;
                if(m - sum(m) >= pt[i].A) {
                    r = m - 1;
                    as = m;
                }else
                    l = m + 1;
            }
            ans[as] = pt[i].B;
            add(as);
        }
        for(i = 1; i <= n; i++) {
            if(i != 1)
                printf(" ");
            printf("%d", ans[i]);
        }
        puts("");
    }
    return 0;
}

英雄哪里出来 2011-04-09 15:06 发表评论

PKU 3067 Japan

英雄哪里出来 — Fri, 08 Apr 2011 15:14:00 GMT

题目链接：http://poj.org/problem?id=3067

/*
题意：
    左边N个点，右边M个点，分别南北方向排列，1对应1，2对应2，给出
K条记录，每条记录表示左边的A点和右边的B点相连，两条相连的先会有一
个交点，现在保证任意三个线不会交与一点，问一共多少个交点。

题解：
    树状数组

思路：
    题目求的是交点的数目，仔细观察就可以发现，如果有以下四个点，A1
，B1属于左边，A2，B2属于右边，当且仅当 A1和A2的大小关系和 B1与B2
的大小关系相反，于是可以联想到求一个数列的逆序数的时候用到的树状数
组的成段求和。
    我们只要将读入的整数对按左边的点递增排序，如果左边点大小相同则按
右边点递增排序，每次在树状数组中统计比当前右边的点大的数的数目，然后
再将这个点插入树状数组，这就实现了一个逆序统计。
    这里需要注意的是，统计的时候需要采用__int64，因为总的交点数可能
会超过int。最大的情况是左右两边都是1000个点，并且两两有边，那么最大
的交点数量就是：
1 * (1 + 2 +  + 999)
+
2 * (1 + 2 +  + 998)
+

998 * (1 + 2)
+
999 * 1
+
1000 * 0
    可以写个程序统计一下，发现这个数字是超过int的。
    ll ans = 0;
    for(i = 1; i <= 1000; i++) {
        ans += i * (1001 - i) * (1000 - i) / 2;
    }
*/

#include <iostream>
#include <algorithm>

using namespace std;

struct Double {
    int l, r;
}dt[1000100];

int N, M, K;
#define ll __int64

int cmp(Double a, Double b) {
    if(a.l == b.l)
        return a.r < b.r;
    return a.l < b.l;
}

int lowbit(int x) {
    return x & (-x);
}

ll c[1010];
void add(int pos) {
    while(pos <= M) {
        c[pos] ++;
        pos += lowbit(pos);
    }
}

ll sum(int pos) {
    ll s = 0;
    while(pos > 0) {
        s += c[pos];
        pos -= lowbit(pos);
    }
    return s;
}

int main() {
    int t;
    int i;
    int Case = 1;

    scanf("%d", &t);

    while(t--) {
        memset(c, 0, sizeof(c));
        scanf("%d %d %d", &N, &M, &K);
        for(i = 0; i < K; i++) {
            scanf("%d %d", &dt[i].l, &dt[i].r);
        }
        sort(dt, dt + K, cmp);

        ll ans = 0;
        for(i = 0; i < K; i++) {
            ans += sum(M) - sum(dt[i].r);
            add(dt[i].r);
        }
        printf("Test case %d: %I64d\n", Case++, ans);
    }
    return 0;
}

英雄哪里出来 2011-04-08 23:14 发表评论

HDU 2871 Memory Control

英雄哪里出来 — Fri, 08 Apr 2011 07:26:00 GMT

摘要: 题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2871 /**//*题意：现在有1到N(N <= 50000)个连续内存块，然后给出四种操作：1. Reset 释放所有内存块，并且输出“Reset Now”。2... 阅读全文

英雄哪里出来 2011-04-08 15:26 发表评论

HDU 1166 敌兵布阵

英雄哪里出来 — Thu, 07 Apr 2011 10:04:00 GMT

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1166

/*
题意：
    给定N(N <= 50000)个数, 表示敌人有N个工兵营地，接下来有N个正整数, 第
i个正整数ai代表第i个工兵营地里开始时有ai个人（1<=ai<=50）。
接下来每行有一条命令，命令有4种形式：
(1)Add i j   ,i和j为正整数, 表示第i个营地增加j个人（j不超过30）
(2)Sub i j   ,i和j为正整数, 表示第i个营地减少j个人（j不超过30）;
(3)Query i j ,i和j为正整数, i<=j，表示询问第i到第j个营地的总人数;
(4)End 表示结束，这条命令在每组数据最后出现

解法：
    树状数组或者线段树

思路：
    典型的树状数组模板题，Add和Sub是同一个操作，Sub就是Add一个负的值，只
是Sub之前先要判断这个点有没有这么多，询问就是利用树状数组的成段求和。
*/

#include <iostream>

using namespace std;

#define maxn 1000010

int c[maxn], n;
int a[maxn];
char ch[100];

int lowbit(int x) {
    return x & (-x);
}

void Add(int x, int add) {
    while(x <= n) {
        c[x] += add;
        x += lowbit(x);
    }
}

int sum(int x) {
    int s = 0;
    while(x > 0) {
        s += c[x];
        x -= lowbit(x);
    }
    return s;
}

int main() {
    int t, as, bs, i, q = 1;
    scanf("%d", &t);
    while(t--) {
        scanf("%d", &n);
        memset(c, 0, sizeof(c));
        for(i = 1; i <= n ;i++) {
            scanf("%d", &a[i]);
            Add(i, a[i]);
        }
        printf("Case %d:\n", q++);
        while(scanf("%s" , ch) != EOF) {
            if(!strcmp(ch, "End"))
                break;
            else if(!strcmp(ch, "Query")) {
                scanf("%d%d", &as, &bs);
                printf("%d\n", sum(bs) - sum(as - 1));
            }else if(!strcmp(ch, "Add")) {
                scanf("%d%d", &as, &bs);
                Add(as, bs);
            } else if(!strcmp(ch, "Sub")) {
                scanf("%d%d", &as, &bs);
                Add(as, -bs);
            }
        }

    }
}

英雄哪里出来 2011-04-07 18:04 发表评论

ZJU 1484 Minimum Inversion Number

英雄哪里出来 — Thu, 07 Apr 2011 09:55:00 GMT

题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1484

/*
题意：
    给出0 ~ N-1 (1 <= N <= 5000) 的一个排列, 经过循环移位，一共有N个排列，
问这N个排列中逆序对数目最小的。

解法：
    树状数组

思路：
    树状数组求逆序数有一个经典算法，把数字大小对应到树状数组的小标，然后
从后往前遍历每个数字，统计比这个数字小的数的个数，然后将这个数插入到树状
数组中，遍历完毕，累加和就是该序列的逆序对的数目。
    这题要求序列循环移位n次，每次移位统计一次逆序对，最后得到最小的，如果
按照前面的算法，最好的情况是O(n^2log(n))，所以需要找到一些技巧，将复杂度
降下来，我们发现以下两个数列：
1. a1, a2, , an-1, an
2. a2, a3, , an, a1
第二个是第一个循环左移一位的结果，如果将第一个序列的逆序数分情况讨论就是
S = A + B；其中A = (a2~an)本身的逆序对数目；B = a1和(a2~an)的逆序对数目；
而第二个序列中则是S' = A + B'；其中B' = (n-1) - B，于是S和A如果已知，那么
就可以轻松求得S' = A + (n-1) - (S - A)。这样一来，只要知道前一个序列的逆
序数，下一个序列就可以在O(1)的时间内求得。只要每次更新S 和 A 的值即可。
    更加一般化的，S表示当前序列的逆序数对数，A表示比当前数小的数的个数，
题目中数列是一个排列，所以A的值其实就是当前值减一。
*/

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

#define maxn 5001

int n;
short c[maxn], val[maxn];

int lowbit(int x) {
    return x & (-x);
}

void add(int pos) {
    while(pos <= n) {
        c[pos] ++;
        pos += lowbit(pos);
    }
}

int sum(int pos) {
    int s = 0;
    while(pos > 0) {
        s += c[pos];
        pos -= lowbit(pos);
    }
    return s;
}

int main() {
    int i;
    while(scanf("%d", &n) != EOF) {
        for(i = 1; i <= n; i++) {
            int x;
            scanf("%d", &x);
            val[i] = x + 1;
        }
        for(i = 1; i <= n; i++)
            c[i] = 0;
        int ans = 0;
        for(i = n; i >= 1; i--) {
            int x = sum(val[i] - 1);
            add(val[i]);
            ans += x;
        }

        int Min = ans;
        int A = val[1] - 1;
        for(i = 2; i <= n; i++) {
            ans = ans - A + (n-1-A);
            A   = val[i] - 1;
            if(ans < Min)
                Min = ans;
        }
        printf("%d\n", Min);
    }
    return 0;
}

英雄哪里出来 2011-04-07 17:55 发表评论

PKU 3378 Crazy Thairs

英雄哪里出来 — Thu, 07 Apr 2011 05:16:00 GMT

摘要: 题目链接：http://poj.org/problem?id=3378 /**//*题意：给定N (1 <= N <= 50000) 个小于等于10^9的数Ai, 要求找出Crazy Thair的数量。Crazy Thair是一个五元组{i,&nb... 阅读全文

英雄哪里出来 2011-04-07 13:16 发表评论

PKU 2892 Tunnel Warfare

英雄哪里出来 — Thu, 07 Apr 2011 04:31:00 GMT

摘要: 题目链接：http://poj.org/problem?id=2892 /**//*题意：给出M(M <= 50000)组操作，每组操作的形式如下：1 D x: 将第x个村庄摧毁2 Q x: 询问和第x个村庄直接或者间接连接的村庄数目3 R: ... 阅读全文

英雄哪里出来 2011-04-07 12:31 发表评论

PKU 2155 Matrix

英雄哪里出来 — Thu, 07 Apr 2011 03:35:00 GMT

题目链接：http://poj.org/problem?id=2155

/*
题意：
    对于一个n*n(n <= 1000)的矩阵A，要求作如下操作：
1. C x1 y1 x2 y2 (1 <= x1 <= x2 <= n, 1 <= y1 <= y2 <= n) 将当前范围内
的值和1异或。
2. Q x y (1 <= x, y <= n) 询问 A[x, y]。

解法：
    树状数组

思路：
    这题和树状数组的操作正好相反，树状数组是对点更新，成段求和，这题要
求成段更新，对点求值。但是还是可以转化，我们不妨先来考虑一维的情况，给
定一排数字，每次在区间进行进行成端加上一个数，然后询问某个点的值，很容
易想到线段树，但是线段树的常系数太大，我们试图用树状数组来解决，方法是
给定区间[a, b]，如果要求在[a,b]区间都加上T我们只要在a的位置插入一个T，
然后在b+1的位置插入一个-T，这样下次询问某个值k的时候，只要将[1,k]的和求
出来就是k这个位置的值，为什么呢？分三种情况讨论：
1. k < a        先前的插入操作不影响此次结果
2. a <= k <= b  a的位置插入T后，统计时值被加了一次
3. k > b。      a的位置有T，b+1的位置有-T，正好抵消
所以结论成立。
    然后就可以扩展到二维的情况，也是一样，如果对于(x1, y1) (x2, y2)这个
矩形，只要在(x1, y1) (x2+1, y2+1)这两个点插入T，而(x2+1, y1) (x1, y2+1)
这两个点插入-T即可。
    本题的操作是异或，其实还是一样的，就是在二进制内的无进位加法。
*/

#include <iostream>

using namespace std;

#define maxn 1001

int c[maxn][maxn];
int n;

int lowbit(int x) {
    return x & (-x);
}

void add(int x, int y) {
    while(x <= n) {
        int ty = y;
        while(ty <= n) {
            c[x][ty] ^= 1;
            ty += lowbit(ty);
        }
        x += lowbit(x);
    }
}

int sum(int x, int y) {
    int s = 0;
    if(x > n) x = n;
    if(y > n) y = n;
    while(x >= 1) {
        int ty = y;
        while(ty >= 1) {
            s ^= c[x][ty];
            ty -= lowbit(ty);
        }
        x -= lowbit(x);
    }
    return s;
}

int main() {
    int t, m;
    int i, j;
    scanf("%d", &t);

    while(t--) {
        scanf("%d %d", &n, &m);
        memset(c, 0, sizeof(c));
        while(m--) {
            char str[5];
            int x1, y1, x2, y2;
            scanf("%s", str);
            if(str[0] == 'C') {
                scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
                add(x1, y1);
                add(x2+1, y2+1);
                add(x1, y2+1);
                add(x2+1, y1);
            }else {
                scanf("%d %d", &x1, &y1);
                printf( "%d\n", sum(x1, y1) );
            }
        }

        if(t)
            puts("");
    }
    return 0;
}

英雄哪里出来 2011-04-07 11:35 发表评论

PKU 2886 Who Gets the Most Candies

英雄哪里出来 — Thu, 07 Apr 2011 03:03:00 GMT

摘要: 题目链接：http://poj.org/problem?id=2886 /**//*题意：有一排编号为1到N的小孩顺时针围成圈，没人手上有一张编号为A[i]的卡片，游戏从第K个小孩开始，他告诉自己的卡片数字然后跳出圆圈，如果A[i]大于0，那么左数第A[i]个小孩出圈否则右数第A[i]个出圈，游戏一直进行直到所有孩子都出去位置，第p个出圈的将会得到... 阅读全文

英雄哪里出来 2011-04-07 11:03 发表评论

PKU 2985 The k-th Largest Group

英雄哪里出来 — Thu, 07 Apr 2011 01:31:00 GMT

题目链接：http://poj.org/problem?id=2985

/*
题意：
    给定N(N <= 200000)个操作，每个操作是以下两种形式：
0 x y ：合并x所在的组和y所在的组，如果x和y同组，不合并。
1 k：输出第k大的组的元素个数。

解法：
树状数组 + 并查集

思路：
     将元素的个数对应树状数组的下标，每次合并操作，在树状
数组中对应两个集合大小的位置分别减1，两集合之后的位置+1，
询问操作只需要二分答案，然后每次统计比k大的数的个数判可行
即可。
*/

#include <iostream>

using namespace std;

#define maxn 200010

int c[maxn];
int prev[maxn], num[maxn];
int n;

int lowbit(int x) {
    return x & (-x);
}
void add(int pos, int num) {
    while(pos <= n) {
        c[pos] += num;
        pos += lowbit(pos);
    }
}

int sum(int pos) {
    int s = 0;
    while(pos > 0) {
        s += c[pos];
        pos -= lowbit(pos);
    }
    return s;
}

int find(int x) {
    int q = x;
    while(x != prev[x]) {
        x = prev[x];
    }
    return x;
}

void Union(int x, int y) {
    x = find(x);
    y = find(y);

    if(x != y) {
        if(num[x] == num[y])
            add(num[x], -2);
        else {
            add(num[x], -1);
            add(num[y], -1);
        }
        add(num[x] + num[y], 1);

        if(num[x] < num[y]) {
            prev[x] = y;
            num[y] += num[x];
        }else {
            prev[y] = x;
            num[x] += num[y];
        }
    }
}

int Query(int k) {
    int l = 1;
    int r = n;
    int ans = 0;
    int all = sum(n);
    while(l <= r) {
        int m = (l + r) >> 1;
        if(k <= all - sum(m-1)) {
            l = m + 1;
            ans = m;
        }else
            r = m - 1;
    }
    return ans;
}

int main() {
    int i, m;
    int op, x, y;
    while(scanf("%d %d", &n, &m) != EOF) {
        for(i = 1; i <= n; i++) {
            c[i] = 0;
            prev[i] = i;
            num[i] = 1;
        }
        add(1, n);
        while(m--) {
            scanf("%d", &op);
            if(op == 0) {
                scanf("%d %d", &x, &y);
                Union(x, y);
            }else {
                scanf("%d", &x);
                printf("%d\n", Query(x));
            }
        }

    }
    return 0;
}

英雄哪里出来 2011-04-07 09:31 发表评论

HDU 3450 Counting Sequences

英雄哪里出来 — Wed, 06 Apr 2011 04:49:00 GMT

摘要: 题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3450 /**//*题意：给定N(N <= 100000)个数字ai和一个H，要求求出特殊序列的数量，所谓特殊序列，就是相邻两个数字的绝对值小于等于H并且序列长度大于等于2。解法：树状数组 + 动态规划思路：... 阅读全文

英雄哪里出来 2011-04-06 12:49 发表评论

HDU 2836 Traversal

英雄哪里出来 — Wed, 06 Apr 2011 04:38:00 GMT

摘要: 题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2836 /**//*题意：给定N(N <= 100000)个数字ai和一个H，要求求出特殊序列的数量，所谓特殊序列，就是相邻两个数字的绝对值小于等于H并且序列长度大于等于2。解法：树状数组 + 动态规划思路：... 阅读全文

英雄哪里出来 2011-04-06 12:38 发表评论

HDU 2227 Find the nondecreasing subsequences

英雄哪里出来 — Wed, 06 Apr 2011 04:11:00 GMT

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2227

/*
题意：
    给定N(N <= 100000)个数字ai，找出这个序列中有多少非递减序列。

解法：
树状数组 + 动态规划

思路：
    如果n的值小于等于1000，我们可以用动态规划来解，dp[i]表示
到第i个位置能够找到的非递减序列的解的数量，那么有状态转移方程
dp[i] = sum{ dp[j], j，但是n很大，所以不能采用，但是我们观察到这个转移方程是以求和
的形式出现，并且有一个限制条件就是a[j] <= a[i]，那么如果我们把
数字映射到下标，就可以轻松的通过树状数组的成段求和来统计了。
    具体做法是：由于数字较大，我们可以先将所有数字离散化，这样
每个数字就有一个 <= n 的标号，然后这个标号就可以对应树状数组的
下标了，每次从左往右在树状数组中统计比当前数小或者相等的数的个
数，然后将当前数字（离散后的数字）插入到树状数组中，循环结束，
累加和就是最后的答案了。
。
*/

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

typedef unsigned int ui;
typedef __int64 ll;

#define maxn 100010
#define mod 1000000007

int n;
ui val[maxn], t[maxn];
ll c[maxn];
int tot;

int lowbit(int x) {
    return x & (-x);
}

void add(int pos, ll v) {
    while(pos <= tot) {
        c[pos] += v; if(c[pos] >= mod ) c[pos] %= mod;
        pos += lowbit(pos);
    }
}

ll sum(int pos) {
    int s = 0;
    while(pos >= 1) {
        s += c[pos]; if(s >= mod ) s %= mod;
        pos -= lowbit(pos);
    }
    return s;
}

int Bin(ui v) {
    int l = 1;
    int r = tot;
    while(l <= r) {
        int m = (l + r) >> 1;
        if(v == t[m])
            return m;
        if(v > t[m])
            l = m + 1;
        else
            r = m - 1;
    }
}

int main() {
    int i;
    while(scanf("%d", &n) != EOF) {
        for(i = 0; i < n; i++) {
            scanf("%u", &val[i]);
            t[i+1] = val[i];
        }
        tot = 0;
        sort(t+1, t+1+n);
        for(i = 1; i <= n; i++) {
            if(i==1 || t[i] != t[i-1]) {
                t[++tot] = t[i];
                c[tot] = 0;
            }
        }
        for(i = 0; i < n; i++) {
            val[i] = Bin(val[i]);
        }
        ll ans = 0;
        add(1, 1);
        for(i = 0; i < n; i++) {
            ll x = sum(val[i]);
            ans += x;  if(ans >= mod) ans %= mod;
            add(val[i], x);
        }
        printf("%d\n", (int)ans);
    }
    return 0;
}

英雄哪里出来 2011-04-06 12:11 发表评论

ZJU 1440 Bone Sort

英雄哪里出来 — Wed, 06 Apr 2011 03:38:00 GMT

题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1440

/*
题意：
    给定N(N <= 10000)个互不相等的数字ai，要求求出进行至少多少
次交换操作，使得数列递增，并且输出原数列的逆序对的数目。

解法：
树状数组

思路：
    至少多少次交换可以采用贪心，每次找出数列中最小的那个数换到
它应该有的位置上，这一步可以采用hash，因为数字都不相同并且有可
能很大，事先离散化一下。求逆序数可以采用树状数组的区间求和，从
后往前线性扫描，每次统计比当前数小的sum和，然后将这个数插入到
树状数组中，n次循环过后，累加的值就是逆序数了。
*/
#include <iostream>
#include <algorithm>
#include <cstdio>
using namespace std;

#define ll long long
#define maxn 100010
int c[maxn], val[maxn], bin[maxn], n;
int pos[maxn];

int Binary(int val) {
    int l = 1;
    int r = n;
    while(l <= r) {
        int m = (l + r) >> 1;
        if(bin[m] == val)
            return m;
        if(val > bin[m]) {
            l = m + 1;
        }else
            r = m - 1;
    }
}

int lowbit(int x) {
    return x & (-x);
}

void add(int pos) {
    while(pos <= n) {
        c[pos] ++;
        pos += lowbit(pos);
    }
}
int sum(int pos) {
    int s = 0;
    while(pos > 0) {
        s += c[pos];
        pos -= lowbit(pos);
    }
    return s;
}

int main() {
    int i;
    while(scanf("%d", &n) != EOF) {
        for(i = 1; i <= n; i++) {
            scanf("%d", &val[i]);
            bin[i] = val[i];
        }
        sort(bin+1, bin+1+n);
        for(i = 1; i <= n; i++) {
            val[i] = Binary(val[i]);
        }
        for(i = 1; i <= n; i++)
            c[i] = 0;

        ll ans = 0;
        int swp = 0;
        for(i = n; i >= 1; i--) {
            ans += sum(val[i]-1);
            add(val[i]);
        }
        for(i = 1; i <= n; i++) {
            pos[ val[i] ] = i;
        }

        for(i = 1; i <= n; i++) {
            if(val[i] != i) {
                swp ++;

                int pre = pos[i];
                int nowVal = val[i];
                swap( val[ pre ], val[i] );

                pos[ nowVal ] = pre;
            }
        }
        printf("%d\n%lld\n", swp, ans);
    }
    return 0;
}

英雄哪里出来 2011-04-06 11:38 发表评论

PKU 2761 Feed the dogs

英雄哪里出来 — Sun, 03 Apr 2011 02:28:00 GMT

摘要: 题目链接：http://poj.org/problem?id=2761 /**//*题意：给出一个长度为N(N <= 100000)的数列，然后是一连串询问，询问数<= 50000，询问的格式是a, b, k，问[a, b]区间中的k小数。解法：二分+树状数组或者二分+归并... 阅读全文

英雄哪里出来 2011-04-03 10:28 发表评论

HDU 2852 KiKi's K-Number

英雄哪里出来 — Thu, 31 Mar 2011 05:10:00 GMT

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2852

/*
题意：
    给出三种操作，
    0 在容器中插入一个数。
    1 在容器中删除一个数。
    2 求出容器中大于a的第k大元素。

解法：
二分+树状数组

思路：
    树状数组的特点就是对点更新，成段求和，而且常数非常小。原始
的树状数组只有两种操作，在某点插入一个数和求1到i的所有数的和。
这道题目一共有三种操作，但是实质上其实只有两种：插入和询问。插入
操作和删除操作可以视为一种，只不过一个是将标记+1，另一个是-1，而
插入的数对应于树状数组的下标，这样就可以在log(n)的时间内完成插入
和删除。求大于a的k大元素，可以通过二分枚举答案来完成，枚举的是当
前答案在树状数组中的位置，设为m，然后对v[a+1]  v[m]求和就是小
于等于m的数的个数，这一步可以用树状数组的求和操作来完成，然后根据
和k的比较来调整m的位置。询问的复杂度也是log(n)的。
*/

#include <iostream>

using namespace std;

#define maxn 100002
int C[maxn], n;

int lowbit(int x) {
    return x & (-x);
}

void Add(int pos, int val) {
    while(pos < maxn) {
        C[pos] += val;
        pos += lowbit(pos);
    }
}

int Sum(int pos) {
    int S = 0;
    while(pos >= 1) {
        S += C[pos];
        pos -= lowbit(pos);
    }
    return S;
}

int find(int a, int k) {
    int l = a + 1;
    int r = maxn - 1;
    int S = Sum(a);
    int ans = maxn;

    while(l <= r) {
        int m = (l + r) >> 1;
        int nS = Sum(m);
        if(nS - S >= k) {
            r = m - 1;
            if(m < ans)
                ans = m;
        }else
            l = m + 1;
    }

    return ans;
}

int main() {
    int n;
    int i;
    while(scanf("%d", &n) != EOF) {
        for(i = 1; i < maxn; i++)
            C[i] = 0;
        while(n--) {
            int id, e, a, k;
            scanf("%d", &id);
            if(id == 0) {
                scanf("%d", &e);
                Add(e, 1);
            }else if(id == 1) {
                scanf("%d", &e);
                if(Sum(e) - Sum(e-1) == 0)
                    printf("No Elment!\n");
                else
                    Add(e, -1);
            }else {
                scanf("%d %d", &a, &k);
                int num = find(a, k);
                if(num == maxn) {
                    printf("Not Find!\n");
                }else
                    printf("%d\n", num);
            }
        }
    }
    return 0;
}

英雄哪里出来 2011-03-31 13:10 发表评论