挑战程序设计竞赛 3.3 活用各种数据结构

活用各种数据结构

Binary Indexed Tree

POJ 1990  有N头牛，位置x，权值v。两两交谈时要以max(vi, vj)×|xi - xj|的音量。问所有N×(N-1)/2组牛交谈的音量总和

  按 v 排序，后面每加入一只新的牛 i 时，此时它的v最大，所以总是取vi；同时维护两个BIT，都以x为下标，一个维护数量，一个维护坐标，这样可以O(logN)得到所有|xi-xj|。

#include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
#define ll long long
#define lowbit(x) x &(-x)
const int N = 2e4 + 5;

struct cow {
    ll v, x;
} a[N];

bool operator<(cow x1, cow x2) { return x1.v < x2.v; }

ll n, num[N], sum[N], res, maxx;

void add(ll *arr, ll i, ll k) {
    while (i <= maxx) {
        arr[i] += k;
        i += lowbit(i);
    }
}

ll getsum(ll *arr, ll i) {
    ll ans = 0;
    while (i) {
        ans += arr[i];
        i -= lowbit(i);
    }
    return ans;
}

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%lld%lld", &a[i].v, &a[i].x);
        maxx = max(maxx, a[i].x);
    }
    sort(a, a + n);
    for (int i = 0; i < n; i++) {
        ll n1 = getsum(num, a[i].x - 1), n2 = i - n1,
           s1 = getsum(sum, a[i].x - 1), s2 = getsum(sum, maxx) - s1;
        res += (n1 * a[i].x - s1 + s2 - n2 * a[i].x) * a[i].v;
        add(num, a[i].x, 1);
        add(sum, a[i].x, a[i].x);
    }
    printf("%lld", res);
}

 

POJ 3109  给出二维平面上N个黑点的坐标，其余格点为白点。当一个白点上下左右（直线方向）上都有黑点时，会变成黑点。问最后有几个黑点。

  先离散化。预处理每个y坐标上最左边的x坐标和最右边的x坐标。按 x一维 y二维 对点排序，当加入一个点是所在y坐标上最左边时，在BIT上+1；是最右边时，BIT上-1。然后加上col[i][j]与col[i][j+1]之间的点数量。

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
#define ll long long
#define lowbit(x) x &(-x)
const int N = 1e5 + 5;

int n, X[N], Y[N], mmin[N], mmax[N], a[N], w, h;
vector<int> col[N];

int compress(int *x) {
    vector<int> xs(n);
    for (int i = 0; i < n; i++) xs[i] = x[i];
    sort(xs.begin(), xs.end());
    int nn = 1;
    for (int i = 1; i < n; i++) {
        if (xs[nn - 1] < xs[i]) xs[nn++] = xs[i];
    }
    for (int i = 0; i < n; i++) {
        int l = 0, r = nn;
        while (l < r - 1) {
            int mid = (l + r) / 2;
            if (xs[mid] <= x[i])
                l = mid;
            else
                r = mid;
        }
        x[i] = l + 1;
    }
    return nn;
}

void add(int i, int k) {
    while (i <= h) {
        a[i] += k;
        i += lowbit(i);
    }
}

int sum(int i) {
    int ans = 0;
    while (i) {
        ans += a[i];
        i -= lowbit(i);
    }
    return ans;
}

void pul(int x, int y) {
    if (x == mmin[y] && x < mmax[y])
        add(y, 1);
    else if (mmin[y] < x && x == mmax[y])
        add(y, -1);
}

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d%d", &X[i], &Y[i]);
    }
    w = compress(X), h = compress(Y);
    memset(mmin, 127, sizeof(mmin));
    for (int i = 0; i < n; i++) {
        col[X[i]].push_back(Y[i]);
        mmin[Y[i]] = min(mmin[Y[i]], X[i]);
        mmax[Y[i]] = max(mmax[Y[i]], X[i]);
    }
    ll res = n;
    for (int i = 1; i <= w; i++) {
        sort(col[i].begin(), col[i].end());
        for (int j = 0; j < col[i].size() - 1; j++) {
            res += sum(col[i][j + 1] - 1) - sum(col[i][j]);
            pul(i, col[i][j]);
        }
        pul(i, col[i].back());
    }
    printf("%lld", res);
}

 

POJ 2155  矩阵上单点修改，区间查询。

  裸的二维BIT。 

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
#define ll long long
#define lowbit(x) x&(-x)
const int N = 1e3 + 5;

int C[N][N], n, q;

void add(int x, int y, int k) {
    for (int i = x; i <= n; i += lowbit(i)) {
        for (int j = y; j <= n; j += lowbit(j)) {
            C[i][j] += k;
        }
    }
}

ll sum(int x, int y) {
    ll ans = 0;
    for (int i = x; i; i -= lowbit(i)) {
        for (int j = y; j; j -= lowbit(j)) {
            ans += C[i][j];
        }
    }
    return ans;
}

int main() {
    int T, x1, x2, y1, y2;
    char c;
    scanf("%d", &T);
    while (T--) {
        memset(C, 0, sizeof(C));
        scanf("%d%d", &n, &q);
        for (int i = 0; i < q; i++) {
            getchar();
            scanf("%c", &c);
            if (c == 'C') {
                scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
                add(x1, y1, 1);
                add(x1, y2 + 1, -1);
                add(x2 + 1, y1, -1);
                add(x2 + 1, y2 + 1, 1);
            } else {
                scanf("%d%d", &x1, &y1);
                printf("%lld\n", sum(x1, y1) % 2);
            }
        }
        if (T) printf("\n");
    }
}

 

POJ 2886  一群小朋友围坐一起，编号1-N，每个人手上一张卡片。从k号开始，卡片号码为ai正数时，指定第ai个下家；否则，指定第-ai个上家，自己出局，由指定玩家继续。第x个出局获得F(x)个糖果(F(x)为x的因子个数)，问谁糖果最多。

  预处理因子。BIT维护当前小朋友的在场状态，二分查询下一个要出局的人的编号。

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
#define ll long long
#define lowbit(x) x&(-x)
const int N = 5e5 + 5;

int n, k;
int C[N], num[N], p[N], anti[N];
char name[N][15];

void add(int i, int k) {
    while (i <= n) {
        C[i] += k;
        i += lowbit(i);
    }
}

int sum(int i) {
    int ans = 0;
    while (i) {
        ans += C[i];
        i -= lowbit(i);
    }
    return ans;
}

int main() {
    for (int i = 1; i <= 500000; i++) {
        for (int j = 1; j * j <= i; j++) {
            if (i % j == 0) {
                if (j * j == i)
                    num[i]++;
                else
                    num[i] += 2;
            }
        }
    }
    int cnt = 1;
    for (int i = 1; i <= 500000; i++) {
        if (num[i] > num[cnt]) cnt = i;
        anti[i] = cnt;
    }
    while (scanf("%d%d", &n, &k) != EOF) {
        int pos = anti[n];
        memset(C, 0, sizeof(C));
        for (int i = 1; i <= n; i++) add(i, 1);
        for (int i = 1; i <= n; i++) scanf("%s%d", name[i], &p[i]);
        add(k, -1);
        for (int i = 2; i <= pos; i++) {
            int mod = n - i + 1, inc;
            if (p[k] > 0)
                inc = (p[k] - 1) % mod + 1;
            else
                inc = (p[k] % mod + mod) % mod + 1;
            int sk = sum(k), sn = sum(n);
            if (inc <= sn - sk) {
                int l = k + 1, r = n + 1;
                while (r - l > 1) {
                    int mid = (r + l) / 2;
                    if (sum(mid) <= inc + sk && sum(mid - 1) < inc + sk)
                        l = mid;
                    else
                        r = mid;
                }
                k = l;
            } else {
                int l = 1, r = k;
                while (r - l > 1) {
                    int mid = (l + r) / 2;
                    if (sum(mid) <= inc - sn + sk &&
                        sum(mid - 1) < inc - sn + sk)
                        l = mid;
                    else
                        r = mid;
                }
                k = l;
            }
            add(k, -1);
        }
        printf("%s %d\n", name[k], num[pos]);
    }
}

 

 线段树和平方分割

 POJ 3264  查询区间的极差

  线段数维护区间最大值和最小值

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

const int N = 5e4 + 5;
int n, q, ans1, ans2;

struct node {
    int lch, rch, mmin, mmax;
} tree[4 * N];

void build(int k, int l, int r) {
    tree[k].lch = l, tree[k].rch = r;
    if (tree[k].lch == tree[k].rch) {
        scanf("%d", &tree[k].mmin);
        tree[k].mmax = tree[k].mmin;
        return;
    }
    int mid = (l + r) / 2;
    build(k * 2, l, mid);
    build(k * 2 + 1, mid + 1, r);
    tree[k].mmax = max(tree[2 * k].mmax, tree[2 * k + 1].mmax);
    tree[k].mmin = min(tree[2 * k].mmin, tree[2 * k + 1].mmin);
}

void ask_interval(int k, int l, int r) {
    if (l <= tree[k].lch && tree[k].rch <= r) {
        ans1 = max(ans1, tree[k].mmax);
        ans2 = min(ans2, tree[k].mmin);
        return;
    }
    int mid = (tree[k].lch + tree[k].rch) / 2;
    if (l <= mid) ask_interval(2 * k, l, r);
    if (r > mid) ask_interval(2 * k + 1, l, r);
}

int main() {
    scanf("%d%d", &n, &q);
    build(1, 1, n);
    int x, y;
    for (int i = 0; i < q; i++) {
        scanf("%d%d", &x, &y);
        ans1 = 0, ans2 = (int)1e6 + 1;
        ask_interval(1, x, y);
        printf("%d\n", ans1 - ans2);
    }
}

 

POJ 3668  查询区间最大频次

  线段树维护区间最大频次，最小的数的频次，最大的数的频次。

#include <cstdio>
#include <iostream>
using namespace std;
#define P pair<int, int>
const int N = 1e5 + 10;

int n, q, a[N];

struct data {
    int lch, rch, i, num, ln, rn;
    //num, ln, rn, 最大频次, 最小的数的频次, 最大的数的频次
} tree[4 * N], ans;

bool operator>(const data &x1, const data &x2) { return x1.num > x2.num; }

data comb(data x1, data x2) {
    data res;
    if (a[x1.rch] == a[x2.lch]) {
        res.i = a[x1.rch];
        res.num = x1.rn + x2.ln;
        res = res > x1 ? res : x1;
        res = res > x2 ? res : x2;
    } else {
        res = x1 > x2 ? x1 : x2;
    }
    res.lch = x1.lch;
    res.rch = x2.rch;
    if (a[x1.lch] == a[x2.lch])
        res.ln = x1.ln + x2.ln;
    else
        res.ln = x1.ln;
    if (a[x1.rch] == a[x2.rch])
        res.rn = x1.rn + x2.rn;
    else
        res.rn = x2.rn;
    return res;
}

void build(int k, int l, int r) {
    if (l == r) {
        tree[k] = {l, r, a[l], 1, 1, 1};
        return;
    }
    int mid = (l + r) / 2;
    build(k * 2, l, mid);
    build(k * 2 + 1, mid + 1, r);
    tree[k] = comb(tree[k * 2], tree[k * 2 + 1]);
}

void query(int k, int l, int r) {
    if (l <= tree[k].lch && tree[k].rch <= r) {
        ans = comb(ans, tree[k]);
        return;
    }
    int mid = (tree[k].lch + tree[k].rch) / 2;
    if (l <= mid) query(k * 2, l, r);
    if (r > mid) query(k * 2 + 1, l, r);
}

int main() {
    while (scanf("%d", &n) != EOF, n) {
        scanf("%d", &q);
        for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
        build(1, 1, n);
        int x, y;
        for (int i = 0; i < q; i++) {
            scanf("%d%d", &x, &y);
            ans = {x, x, a[x], 1, 1, 1};
            query(1, x + 1, y);
            printf("%d\n", ans.num);
        }
    }
}

 

 POJ 3470  给出n堵墙和m只小鸟的坐标，每只小鸟会向最先与墙发生碰撞的方向飞行（保证存在且唯一）。问每堵墙被多少只小鸟撞。

  解决方案其实就是比较明显的扫描线+线段树……但是代码量会因人而异。我自己写的就非常长，速度也慢，就不贴代码了。网上有一个七八十行的版本写的非常好……值得学习QAQ

 

 POJ 1210  给出n个区间[ai, bi](bi≤5e4)并各对应数ci, bi-ai≥ci-1。问最小的数集Z，与每一个区间重复的点数都不小于ci。

  对所有区间按左端点排序，贪心地往后放节点。线段树维护区间和（每一个节点是布尔型），并查集维护点的分布情况。数集最大是取遍1-5e4，复杂度O(nlogn)。（这个版本的代码也不是很简洁……）

#include <algorithm>
#include <cstdio>
using namespace std;
const int N = 5e4 + 10;

int n;

struct node {
    int lch, rch, w, f;
    //累加前区间和一定小于区间长, 从而不会超出int
} tree[N * 4];

void build(int k, int l, int r) {
    tree[k] = {l, r, 0, 0};
    if (l == r) return;
    int mid = (l + r) / 2;
    build(k * 2 + 1, l, mid);
    build(k * 2 + 2, mid + 1, r);
}

void down(int k) {
    tree[k * 2 + 1].f = tree[k * 2 + 2].f = 1;
    tree[k * 2 + 1].w = tree[k * 2 + 1].rch - tree[k * 2 + 1].lch + 1;
    tree[k * 2 + 2].w = tree[k * 2 + 2].rch - tree[k * 2 + 2].lch + 1;
    tree[k].f = 0;
}

void add(int k, int l, int r) {
    if (tree[k].f) return;
    if (l <= tree[k].lch && tree[k].rch <= r) {
        tree[k].w = tree[k].rch - tree[k].lch + 1;
        tree[k].f = 1;
        return;
    }
    if (l <= tree[k].rch && tree[k].lch <= r) {
        int mid = (tree[k].lch + tree[k].rch) / 2;
        if (l <= mid) add(k * 2 + 1, l, r);
        if (r > mid) add(k * 2 + 2, l, r);
        tree[k].w = tree[k * 2 + 1].w + tree[k * 2 + 2].w;
    }
}

int ask(int k, int l, int r) {
    if (l <= tree[k].lch && tree[k].rch <= r) {
        return tree[k].w;
    }
    if (tree[k].f) down(k);
    if (l <= tree[k].rch && tree[k].lch <= r) {
        int res = 0, mid = (tree[k].lch + tree[k].rch) / 2;
        if (l <= mid) res += ask(k * 2 + 1, l, r);
        if (r > mid) res += ask(k * 2 + 2, l, r);
        return res;
    }
    return 0;
}

struct data {
    int l, r, c;
} a[N];

bool cmp(data x, data y) { return x.r < y.r; }

int par[N];

int find(int x) {
    if (x < 0) return -1;
    if (x == par[x]) return x;
    return par[x] = find(par[x]);
}

int main() {
    build(0, 0, 50000);
    for (int i = 0; i <= 50000; i++) par[i] = i;
    scanf("%d", &n);
    for (int i = 0; i < n; i++) scanf("%d%d%d", &a[i].l, &a[i].r, &a[i].c);
    sort(a, a + n, cmp);
    for (int i = 0; i < n; i++) {
        int tot = ask(0, a[i].l, a[i].r);
        int j;
        for (j = find(a[i].r); tot < a[i].c && a[i].r - j < a[i].c;
             j = find(j - 1)) {
            tot++;
            par[j]--;
        }
        add(0, j + 1, a[i].r);
    }
    printf("%d", ask(0, 0, 50000));
}

 

UVA 11990  给出一个n(≤2e5)的排列，有m(≤1e5)次删除操作，输出每次输出前数列的逆序对数。

  对于在位置i的数xi，设想在二维坐标上的点(i, x)，相当于查询删除的点左上方和右下方有多少个点。对横坐标和纵坐标分块，每个块储存所在行的块的前缀和。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 2e5 + 5;
const int SN = 450;

int n, m;
ll res;
int X[N], Y[N];
int sum[SN][SN];

void add(int x, int y) {
    X[x] = y;
    Y[y] = x;
    for (int i = x / SN; i < n / SN; i++) sum[i][y / SN]++;
}

void remove(int x, int y) {
    X[x] = Y[y] = -1;
    for (int i = x / SN; i < n / SN; i++) sum[i][y / SN]--;
}

int Sum(int x, int y) {  //包含点(x,y)
    int ans = 0, bx = x / SN, by = y / SN;
    if (bx > 0) {
        for (int i = 0; i < by; i++) ans += sum[bx - 1][i];
    }
    for (int i = bx * SN; i <= x; i++) {
        if (X[i] != -1 && X[i] <= y) ans++;
    }
    for (int i = by * SN; i <= y; i++) {
        if (Y[i] != -1 && Y[i] < bx * SN) ans++;
    }
    return ans;
}

int inv(int x, int y) { return Sum(x, n - 1) + Sum(n - 1, y) - 2 * Sum(x, y); }

int main() {
    while (scanf("%d%d", &n, &m) != EOF) {
        memset(X, -1, sizeof(X));
        memset(Y, -1, sizeof(Y));
        memset(sum, 0, sizeof(sum));
        res = 0;
        int x;
        for (int i = 0; i < n; i++) {
            scanf("%d", &x);
            x--;
            res += inv(x, i);
            add(x, i);
        }
        for (int i = 0; i < m; i++) {
            scanf("%d", &x);
            x--;
            printf("%lld\n", res);
            int y = X[x];
            remove(x, y);
            res -= inv(x, y);
        }
    }
}

 

 

END