POJ2104-K-th Number

最新推荐文章于 2020-01-14 17:00:51 发布

原创最新推荐文章于 2020-01-14 17:00:51 发布 · 465 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

POJ 同时被 3 个专栏收录

119 篇文章

订阅专栏

线段树

9 篇文章

订阅专栏

分桶法和平方分割

2 篇文章

订阅专栏

本文介绍了解决静态区间查询第K大值问题的两种高效算法：分桶法结合平方分割与归并树法。分桶法通过将数据划分为多个桶来减少计算复杂度；归并树法则在每个节点维护一个有序数组，并通过归并操作更新子节点数据。

静态区间求第K大的值，有多种方式。
首先可以用分桶法和平方分割求解，将数据分为多个桶，每个桶分别处理桶内的数据以降低复杂度。

#include <cstdio>
#include <vector>
#include <algorithm>

using namespace std;

const int maxn = 100000 + 10;
const int B = 1000;

int a[maxn];
int nums[maxn];
vector<int> bucket[maxn/B];

int main(int argc, char const *argv[]) {
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
        bucket[i/B].push_back(a[i]);
        nums[i] = a[i];
    }

    sort(nums, nums + n);
    for (int i = 0; i < n / B; i++) {
        sort(bucket[i].begin(), bucket[i].end());
    }

    for (int i = 0; i < m; i++) {
        int l, r, k;
        scanf("%d%d%d", &l, &r, &k);
        l--;
        //二分搜索
        int lb = -1, ub = n - 1;
        while (ub - lb > 1) {
            int mid = (lb + ub) >> 1;
            int x = nums[mid];
            int tl = l, tr = r, c = 0;
            //区间两端多出来的部分
            while (tl < tr && tl % B != 0) {
                if (a[tl++] <= x) {
                    c++;
                }
            }
            while (tl < tr && tr % B != 0) {
                if (a[--tr] <= x) {
                    c++;
                }
            }

            while (tl < tr) {
                int b = tl / B;
                c += upper_bound(bucket[b].begin(), bucket[b].end(), x) - bucket[b].begin();
                tl += B;
            }

            if (c >= k) {
                ub = mid;
            } else {
                lb = mid;
            }
        }
        printf("%d\n", nums[ub]);
    }
    return 0;
}

另外一种更快的算法是使用归并树，线段树内每个元素维护一个数组，然后对子节点进行归并。

#include <cstdio>
#include <vector>
#include <algorithm>

using namespace std;

#define lchild rt << 1, l, m
#define rchild rt << 1 | 1, m + 1, r

const int sz = (1 << 18) - 1;
const int maxn = 100000 + 10;

int n;
int a[maxn];
int num[maxn];

vector<int> tree[sz];

void build(int rt = 1, int l = 1, int r = n) {
    if (l == r) {
        tree[rt].push_back(a[l-1]);
    } else {
        int m = (l + r) >> 1;
        build(lchild);
        build(rchild);
        tree[rt].resize(r - l + 1);
        merge(tree[rt<<1].begin(), tree[rt<<1].end(),
            tree[rt<<1|1].begin(), tree[rt<<1|1].end(), tree[rt].begin());
    }
}

int query(int L, int R, int x, int rt = 1, int l = 1, int r = n) {
    if (R < l || r < L) {
        return 0;
    } else if (L <= l && r <= R) {
        return upper_bound(tree[rt].begin(), tree[rt].end(), x) - tree[rt].begin();
    } else {
        int m = (l + r) / 2;
        int lc = query(L, R, x, lchild);
        int rc = query(L, R, x, rchild);
        return lc + rc;
    }
}

int main(int argc, char const *argv[]) {
    int m;
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
        num[i] = a[i];
    }
    sort(num, num + n);

    build();
    for (int i = 0; i < m; i++) {
        int l, r, k;
        scanf("%d%d%d", &l, &r, &k);
        int lb = -1, ub = n;
        while (ub - lb > 1) {
            int mid = (lb + ub) / 2;
            int c = query(l, r, num[mid]);
            if (c >= k) {
                ub = mid;
            } else {
                lb = mid;
            }
        }
        printf("%d\n", num[ub]);
    }
    return 0;
}

当然还有暴力转移的莫队算法等等…..