POJ 2182 Lost Cows——线段树

传送门
Description

N (2 <= N <= 8,000) cows have unique brands in the range 1…N. In a spectacular display of poor judgment, they visited the neighborhood ‘watering hole’ and drank a few too many beers before dinner. When it was time to line up for their evening meal, they did not line up in the required ascending numerical order of their brands.

Regrettably, FJ does not have a way to sort them. Furthermore, he’s not very good at observing problems. Instead of writing down each cow’s brand, he determined a rather silly statistic: For each cow in line, he knows the number of cows that precede that cow in line that do, in fact, have smaller brands than that cow.

Given this data, tell FJ the exact ordering of the cows.
Input

• Line 1: A single integer, N

• Lines 2…N: These N-1 lines describe the number of cows that precede a given cow in line and have brands smaller than that cow. Of course, no cows precede the first cow in line, so she is not listed. Line 2 of the input describes the number of preceding cows whose brands are smaller than the cow in slot #2; line 3 describes the number of preceding cows whose brands are smaller than the cow in slot #3; and so on.
  Output

• Lines 1…N: Each of the N lines of output tells the brand of a cow in line. Line #1 of the output tells the brand of the first cow in line; line 2 tells the brand of the second cow; and so on.

Sample Input

5
1
2
1
0

Sample Output

2
4
5
3
1

题意： 给定一个数组长度n，即n个从1到n编号的数字被打乱了顺序。然后给出n-1个数，分别表示在这个位置之前有多少个小于这个数的数字，要你推导出这个数组。

题解： 看了题目自然就想到应该是倒推，我们很容易从最后一个数字0得出这个位置上应该是数字1。令输入数组为a[]，我们需要通过倒推得到目标数组ans[]，ans[i]就应该等于目前未出现的第a[i]+1小的数字。
然而这样的思路，应该如何转换成线段树或者树状数组的代码呢。我们构建一个完全二叉树，每一片叶子表示能够放下一个数字，并且我们要让这些数字沿叶子递增。每当我们在一片叶子上放入数字之后，我们就让他的父亲节点的值-1.以每个节点的值表示这条分支还能存放几个数字，以此来确定当前第i小的数字是多少。

//线段树
#include<iostream>
#include<algorithm>
using namespace std;
const int N = 1000000;

int n, ans[N], s[N];

struct node{
    int l, r, n;
} a[N];

void build(int l, int r, int i){
    a[i].l = l;
    a[i].r = r;
    a[i].n = r - l + 1; //该区间内能放的数字个数
    if(l!=r){
        int mid = (l + r) / 2;
        build(l, mid, 2 * i);
        build(mid + 1, r, 2 * i + 1);
    }
}
 
int insert(int i, int x){
    a[i].n--;
    if(a[i].l == a[i].r)
        return a[i].l;
    if(a[2*i].n >= x)//左子树的数字足够，则走左子树
        insert(2 * i, x);
    else//否则走右子树，并且将子树视为新树，编号从1开始
        insert(2 * i + 1, x - a[2 * i].n);
}
 
int main(){
    int i,j;
    while(~scanf("%d",&n)){
        s[1] = 0;
        for(i = 2; i<=n; i++)
            scanf("%d", s+i);
        build(1, n, 1);
        for(i = n; i>=1; i--)//逆推
            ans[i] = insert(1, s[i] + 1);
        for(i = 1; i<=n; i++)
            printf("%d\n", ans[i]);
    }
    return 0;
}

//树状数组
#include <iostream>
#define N 100005
using namespace std;

int c[N], a[N], b[N], n;

void add(int x, int val){
    while (x <= n){
        c[x] += val;
        x += x & (-x);
    }
}

int count(int x){
    int s = 0;
    while (x > 0){
        s += c[x];
        x -= x & -x;
    }
    return s;
}

int find(int x){
    int l = 1, r = n;
    int p;
    while (l <= r){
        int mid = (l + r) / 2;
        if (count(mid) >= x){
            p = mid;
            r = mid - 1;
        }
        else l = mid + 1;
    }
    return p;
}

int main(){
    scanf("%d", &n);
    add(1, 1);
    for (int i = 2; i <= n; i++){
        scanf("%d", a+i);
        add(i, 1);
    }   
    for (int i = n; i >= 1; i--){
        b[i] = find(a[i] + 1);
        add(b[i], -1);
    }
    for (int i = 1; i <= n; i++)
        printf("%d\n", b[i]);
    return 0;
}