uva 11525(线段树)

题目链接：http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=2520

题意：有一个排列1~k，求第n个排列，其中n为 ，K(1≤K≤50000)，S₁, S₂ ,…, S_k.(0≤S_i≤K-i).

分析：这道题目乍看之下没有什么好的思路，k！太大了，但是仔细看一看就会发现n和康托展开式很类似

如果不知道康托展开的话请看：http://www.doc88.com/p-293361248346.html

                                       http://blog.csdn.net/morgan_xww/article/details/6275460

要求第n个全排列，这不就是逆康托展开吗？

没错，仔细对比逆康托展开的推理过程就会发现，其实第n个全排列中的第i个数就是该排列中未出现过的比si大的第一个数。

比如：2 1 0   则比2大的第一个数是3，3未出现过，所以第一个数是3

                      比1大的第一个数是2，2未出现过，所以第二个数是2

                      比0大的第一个数是1，1未出现过，所以第三个数是1

        所以结果为3 2 1

 再比如：1 0 0   则比1大的第一个数是2,2未出现过，所以第一个数是2

                         比0 大的第一个数是1，1未出现过，所以第二个数是1

                         比0大的第一个数是1，但是1，2已经出现过了，所以第三个数是3

以此类推

普通的逆康托展开复杂度是O(n^2)，这样对于k<=50000来说肯定是会超时的，可以用线段树（二分+树状数组）优化。

由上面的分析可知，

解法1：

线段树的具体做法同样是把 [1, K] 的数置成 1. 此时每条线段的权所代表的意义为在该区间内还有多少个数可以用。查找大于si的第一个未出现过的数，然后把这个数赋为0。 查找的时候如果左线段可用的数大于等于当前我们查找的数, 说明我们要找的数在左线段, 进入左线段, 查找的数不变; 否则说明在右线段, 进入右线段, 查找的数减去左线段可用的数的数目. 递归返回条件为当前节点代表的线段为单位线段(说明我们已经找到了)。

AC代码如下：

#include<stdio.h>
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
const int maxn=50000+10;
int tree[maxn<<2],ans;
void PushUp(int rt)
{
    tree[rt]=tree[rt<<1]+tree[rt<<1|1];
}
void build(int l,int r,int rt)
{
    if(l==r)
    {
        tree[rt]=1;
        return ;
    }
    int m=(l+r)>>1;
    build(lson);
    build(rson);
    PushUp(rt);
}
void update(int p,int x,int l,int r,int rt)
{
    if(l==r)
    {
        tree[rt]=x;
        ans=l;
        return ;
    }
    int m=(l+r)>>1;
    if(p<=tree[rt<<1])
        update(p,x,lson);
    else
        update(p-tree[rt<<1],x,rson);
    PushUp(rt);
}
int main()
{
    int t,n,i,x;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        build(1,n,1);
        for(i=0;i<n;i++)
        {
            scanf("%d",&x);
            update(x+1,0,1,n,1);
            printf("%d",ans);
            if(i!=n-1)
                printf(" ");
        }
        printf("
");
    }
    return 0;
}

解法2：

树状数组的具体做法是初始把 [1, K] 的数置成 1, 然后根据所给 S 数组, 去查找前缀和, 前缀和 sum[N] 代表 [1, N] 内有多少个数可以用. 注意前缀和是单调不减的, 因此我们可以二分, 查找第一个等于我们要找的数/的那个下标, 便是全排列当前位的数, 然后把这个下标里的数置成 0, 同时更新树状数组.

AC代码如下：

#include<stdio.h>
#include<string.h>
const int maxn=50000+10;
int c[maxn],num[maxn];
int n;
int lowbit(int x)
{
    return x&(-x);
}
void update(int x,int num)
{
    while(x<=n)
    {
        c[x]+=num;
        x+=lowbit(x);
    }
}
int sum(int x)
{
    int ret=0;
    while(x>0)
    {
        ret+=c[x];
        x-=lowbit(x);
    }
    return ret;
}
int binary(int x)
{
    int low=1,high=n;
    while(low<=high)
    {
        int m=(low+high)>>1;
        int cnt=sum(m);
        if(cnt==x)
        {
            if(num[m])
                return m;
            else
                high=m-1;
        }
        else if(cnt<x)
            low=m+1;
        else
            high=m-1;
    }
    return 0;
}
int main()
{
    int t,i,x;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        memset(c,0,sizeof(c));
        for(i=1;i<=n;i++)
            num[i]=1;
        for(i=1;i<=n;i++)
            update(i,1);
        for(i=0;i<n;i++)
        {
            scanf("%d",&x);
            int cnt=binary(x+1);
            update(cnt,-1);
            num[cnt]=0;
            printf("%d",cnt);
            if(i!=n-1)
                printf(" ");
        }
        printf("
");
    }
    return 0;
}