Question

给定一系列整数，有很多查询。每个查询都有一个范围[l，r]，你要找到给定范围的中位数[l，r]

查询数量可以达到100,000 序列的长度可以大到100,000

我想知道是否有任何数据结构可以支持这样的查询

我的解决方案：

我今天咨询了我的合作伙伴，他告诉我使用分区树。

我们可以在nlog（n）时间内构建一个分区树，并在log（n）时间内回答每个查询

分区树实际上是合并排序的过程，但是对于树中的每个节点，它保存了转到左子树的整数数。因此，我们可以使用此信息来处理查询。

这是我的代码：

该程序用于在给定区间[l，r]中找到x，以最小化以下等式。

alt text http://acm.tju.edu.cn/toj/3556_01.jpg

解释

seq保存序列

pos在排序后保存位置

ind保存索引

cntL保存在给定范围内转到左侧树的整数数

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define N 100008
typedef long long LL;
int n, m, seq[N], ind[N], pos[N], next[N];
int cntL[20][N];
LL sum[20][N], sumL, subSum[N];

void build(int l, int r, int head, int dep)
{
    if (l == r)
    {
        cntL[dep][l] = cntL[dep][l-1];
        sum[dep][l] = sum[dep][l-1];
        return ;
    }
    int mid = (l+r)>>1;
    int hl = 0, hr = 0, tl = 0, tr = 0;
    for (int i = head, j = l; i != -1; i = next[i], j++)
    {
        cntL[dep][j] = cntL[dep][j-1];
        sum[dep][j] = sum[dep][j-1];
        if (pos[i] <= mid)
        {
            next[tl] = i;
            tl = i;
            if (hl == 0) hl = i;
            cntL[dep][j]++;
            sum[dep][j] += seq[i];
        }
        else
        {
            next[tr] = i;
            tr = i;
            if (hr == 0) hr = i;
        }
    }
    next[tl] = -1;
    next[tr] = -1;
    build(l, mid, hl, dep+1);
    build(mid+1, r, hr, dep+1);
}

int query(int left, int right, int ql, int qr, int kth, int dep)
{
    if (left == right)
    {
        return ind[left];
    }
    int mid = (left+right)>>1;
    if (cntL[dep][qr] - cntL[dep][ql-1] >= kth)
    {
        return query(left, mid, left+cntL[dep][ql-1]-cntL[dep][left-1], left+cntL[dep][qr]-cntL[dep][left-1]-1, kth, dep+1);
    }
    else
    {
        sumL += sum[dep][qr]-sum[dep][ql-1];
        return query(mid+1, right, mid+1+ql-left-(cntL[dep][ql-1]-cntL[dep][left-1]), mid+qr+1-left-(cntL[dep][qr]-cntL[dep][left-1]), \
                kth-(cntL[dep][qr]-cntL[dep][ql-1]), dep+1);
    }
}

inline int cmp(int x, int y)
{
    return seq[x] < seq[y];
}

int main()
{
    int ca, t, i, j, middle, ql, qr, id, tot;
    LL ans;
    scanf("%d", &ca);
    for (t = 1; t <= ca; t++)
    {
        scanf("%d", &n);
        subSum[0] = 0;
        for (i = 1; i <= n; i++) 
        {
            scanf("%d", seq+i);
            ind[i] = i;
            subSum[i] = subSum[i-1]+seq[i];
        }
        sort(ind+1, ind+1+n, cmp);
        for (i = 1; i <= n; i++)
        {
            pos[ind[i]] = i;
            next[i] = i+1;
        }
        next[n] = -1;
        build(1, n, 1, 0);
        printf("Case #%d:\n", t);
        scanf("%d", &m);
        while (m--)
        {
            scanf("%d%d", &ql, &qr);
            ql++, qr++;
            middle = (qr-ql+2)/2;
            sumL= 0;
            id = query(1, n, ql, qr, middle, 0);
            ans = subSum[qr]-subSum[ql-1]-sumL;
            tot = qr-ql+1;
            ans = ans-(tot-middle+1)*1ll*seq[id]+(middle-1)*1ll*seq[id]-sumL;
            printf("%lld\n", ans);
        }
        puts("");
    }
}

Answer 1

这称为Range Median Query问题。以下文章可能相关：Towards Optimal Range Medians。（免费链接，感谢belisarius）。

摘自论文摘要：

我们考虑以下问题：   给定n个元素的未排序数组，   和一系列的间隔   数组，计算每个中位数   由...定义的子阵列   间隔。我们描述一个简单的   需要O（nlogk + klogn）的算法   时间回答k这样的中位数查询。   这通过a改进了以前的算法   对数因子并匹配a   比较k = O（n）的下界。该   我们简单的空间复杂性   算法是指针中的O（nlogn）   机器型号，RAM中的O（n）   模型。在后一种模式中，更多   涉及O（n）空间数据结构即可   在O（nlogn）时间建造   每个查询的时间减少到   O（LOGN / loglogn）。我们也给   两者的有效动态变体   数据结构，达到O（log ^ 2n）   使用O（nlogn）空间查询时间   比较模型和   O（（logn / loglogn）^ 2）查询时间使用   RAM中的O（nlogn / loglogn）空间   模型，并在细胞探针中显示   模型，任何数据结构   支持O（log ^ O（1）n）时间的更新   必须有Ω（logn / loglogn）查询时间。

我们的方法自然会推广到   高维范围中位数   问题，元素位置和   查询范围是多维的 - 它   将范围中值查询缩小为a   对数范围计数   查询。

当然，您可以在O（n ^ 3）时间（或者甚至可能是O（n ^ 2logn）时间）和O（n ^ 2）空间中预处理整个数组，以便能够返回O中的中位数（ 1）时间。

其他约束可能有助于简化解决方案。例如，我们是否知道r-l将小于已知常数？等...

数据结构问题

1 个答案: