HDOJ 5592 ZYB's Premutation（逆序对变题：树状数组+二分||线段树）

ZYB's Premutation

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit:131072/131072 K (Java/Others)
Total Submission(s): 1051    Accepted Submission(s): 544

Problem Description

ZYB has a premutationP,buthe only remeber the reverse log of each prefix of the premutation,now he askyou to
restore the premutation.

Pair (i,j)(i<j)is considered as a reverse log if Ai>Ajis matched.

 

 

Input

In the first line there is the number of testcases T.

For each teatcase:

In the first line there is one number N.

In the next line there are NnumbersAi,describethe number of the reverse logs of each prefix,

The input is correct.

1≤T≤5,1≤N≤50000

 

 

Output

For each testcase,print the ans.

 

 

Sample Input

1

3

0 1 2

 

 

Sample Output

3 1 2

 

题意：有一个排列p，里面的数是1~n,现在分别给出【1，n】(1<=i<=n)范围内逆序对的数目，求排列的方式。

分析：我们可以逆向考虑（因为正向的话由于第一位的逆序对数一定是0，算不出什么），对于第i个数，它使逆序对的数量增加了temp=num[i]-num[i-1],即区间【1，i-1】内比这个数大的有temp个，即它在i个数中从小到大排在（i-temp）个，那么找到这个数即可。可以用树状数组或线段树

线状数组：先初始化每个位置的val都为1，getsum（i）就能得到位置在i及其前面的数的个数（小于等于），然后利用二分的思想找到要求的值保存在数组中。

注意：由于一个数用过后就不能再用了，所以某一个数被找到后应该将val-1.

#include <cstdio>
#include <cmath>
#include <queue>
#include <stack>
#include <cstring>
#include <algorithm>
using namespace std;
#define mst(a,b) memset((a),(b),sizeof(a))
#define f(i,a,b) for(int i=(a);i<(b);++i)
#define rush() int T;scanf("%d",&T);while(T--)
typedef long long ll;
const int maxn= 500005;
const ll mod = 1e9+7;
const int INF = 0x3f3f3f3f;
const double eps = 1e-6;

int num[maxn];
int tree[maxn];
int ans[maxn];
int n;

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

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

int getsum(int pos)
{
    int ans=0;
    while(pos>0)
    {
        ans+=tree[pos];
        pos-=lowbit(pos);
    }
    return ans;
}

int solve(int k)
{
    int ans;
    int l=1;
    int r=n;
    while(r-l>=0)
    {
        int m=(l+r)/2;
        if(getsum(m)>=k)
        {
            ans=m;
            r=m-1;
        }
        else l=m+1;
    }
    return ans;
}

int main()
{
    rush()
    {
        mst(tree,0);
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
        {
            add(i,1);
            scanf("%d",&num[i]);
        }
        for(int i=n;i>=1;i--)
        {
            int temp=num[i]-num[i-1];
            temp=i-temp;
            ans[i]=solve(temp);
            add(ans[i],-1);
        }
        for(int i=1;i<n;i++)
        {
            printf("%d ",ans[i]);
        }
        printf("%d\n",ans[n]);
    }
    return 0;
}

线段树的思路与上面的基本一致，附上代码

#include <cstdio>
#include <cmath>
#include <queue>
#include <stack>
#include <cstring>
#include <algorithm>
using namespace std;
#define mst(a,b) memset((a),(b),sizeof(a))
#define f(i,a,b) for(int i=(a);i<(b);++i)
#define rush() int T;scanf("%d",&T);while(T--)
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1

typedef long long ll;
const int maxn= 50005;
const ll mod = 1e9+7;
const int INF = 0x3f3f3f3f;
const double eps = 1e-6;

int num[maxn];
int ans[maxn];
int tree[maxn<<2];

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);
}

int query(int pos,int l,int r,int rt)
{
    if(l==r)
    {
        tree[rt]=0;
        return l;
    }
    int m=(l+r)>>1;
    int ans;
    if(tree[rt<<1]>=pos)  ans=query(pos,lson); //左区间的数的个数大于等于pos，所以一定在左区间里
    else ans=query(pos-tree[rt<<1],rson);      //如果在右区间里，说明它是右区间第（pos-左区间的数）小的
    pushup(rt);
    return ans;
}

int main()
{
    int n;
    rush()
    {
        scanf("%d",&n);
        build(1,n,1);
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&num[i]);
        }
        for(int i=n;i>=1;i--)
        {
            int temp=num[i]-num[i-1];
            temp=i-temp;            //第temp小
            ans[i]=query(temp,1,n,1);
        }
        for(int i=1;i<n;i++)
        {
            printf("%d ",ans[i]);
        }
        printf("%d\n",ans[n]);
    }
    return 0;
}