LightOJ 1277 Looking for a Subsequence

http://www.lightoj.com/volume_problemstat.php?problem=1277

　　LightOJ搞得挺漂亮的，第一次到那里交题，挺喜欢的。

　　线段树统计题，题意是：给出一行数，找到所要求的长度的单调上升子序列，并输出该序列。

　　这题我是先从后往前，求出到达某个位置的时候，最长可以构建出多长的单调上升子序列。这是一个dp问题，不过用dp方法复杂度是O(n^2)会超时，所以我用线段树来降低查找的复杂度。题目比较简单，不过数据范围较大，所以要用hash来离散化处理。最后回溯一下就可以搜索出目标序列了！

代码如下：

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

using namespace std;

typedef vector<int> vi;
const int hashSize = 400009;
const int HASH = 0x55555555;
int hash[hashSize], hashPos[hashSize];
vi buf, X;

void insHash(int x, int pos) {
    int p = (x ^ HASH) % hashSize;

    if (p < 0) p += hashSize;
    while (hash[p] != x && ~hashPos[p]) {
        p++;
        if (p >= hashSize) p -= hashSize;
    }

    hash[p] = x;
    hashPos[p] = pos;
}

int getPos(int x) {
    int p = (x ^ HASH) % hashSize;

    if (p < 0) p += hashSize;
    while (hash[p] != x && ~hashPos[p]) {
        p++;
        if (p >= hashSize) p -= hashSize;
    }

    return hashPos[p];
}

void initHash() {
    memset(hashPos, -1, sizeof(hashPos));
}

void scan(int &x) {
    char c;

    for ( ; ((c = getchar()) < '0' || c > '9') && c != '-'; ) ;
    if (c != '-') for (x = c - '0'; '0' <= (c = getchar()) && c <= '9'; x = x * 10 + c - '0') ;
    else for (x = 0; '0' <= (c = getchar()) && c <= '9'; x = x * 10 + '0' - c) ;
}

int treeSize;

void input(int n) {
    int x;

    X.clear();
    buf.clear();
    initHash();

    while (n--) {
        scan(x);
        X.push_back(x);
        buf.push_back(x);
    }
    sort(X.begin(), X.end());

    int endi = unique(X.begin(), X.end()) - X.begin();

    treeSize = endi;
    for (int i = 0; i < endi; i++) {
        insHash(X[i], i);
    }
}

#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1
#define ROOT 0, treeSize - 1, 1

const int maxn = 100001;
int mx[maxn << 2];

void build(int l, int r, int rt) {
    mx[rt] = 0;
    if (l == r) return ;

    int m = (l + r) >> 1;

    build(lson);
    build(rson);
    mx[rt] = max(mx[rt << 1], mx[rt << 1 | 1]);
}

void update(int p, int x, int l, int r, int rt) {
    if (l == r) {
        mx[rt] = max(mx[rt], x);
        return ;
    }
    int m = (l + r) >> 1;

    if (p <= m) update(p, x, lson);
    else update(p, x, rson);
    mx[rt] = max(mx[rt << 1], mx[rt << 1 | 1]);
}

int query(int L, int R, int l, int r, int rt) {
    if (L <= l && r <= R) {
        return mx[rt];
    }
    int m = (l + r) >> 1;

    if (L <= m) {
        if (m < R) {
            return max(query(L, R, lson), query(L, R, rson));
        } else {
            return query(L, R, lson);
        }
    }
    if (m < R) {
        return query(L, R, rson);
    }
}

int maxLen[maxn];

void deal(int n, int m) {
    input(n);
    build(ROOT);
    for (int i = n - 1; i >= 0; i--) {
        int pos = getPos(buf[i]) + 1;

//        printf("~%d\n", pos);
        if (pos < treeSize) {
            maxLen[i] = query(pos, treeSize - 1, ROOT) + 1;
            update(pos - 1, maxLen[i], ROOT);
        } else {
            maxLen[i] = 1;
            update(pos - 1, maxLen[i], ROOT);
        }
//        printf("%d ", maxLen[i]);
    }
//    puts("~~~");

    while (m--) {
        int x, i = 0;

        scan(x);
        while (i < n) {
            if (maxLen[i] >= x) break;
            i++;
        }
        if (i >= n) puts("Impossible");
        else {
            int last = buf[i];

            printf("%d", buf[i]);
            x--;
            i++;
            while (x) {
                if (maxLen[i] >= x && buf[i] > last) {
                    printf(" %d", buf[i]);
                    x--;
                    last = buf[i];
                }
                i++;
            }
            puts("");
        }
    }
}

int main() {
    int n, m;
    int T;

//    freopen("in", "r", stdin);
    scan(T);
    for (int i = 1; i <= T; i++) {
        printf("Case %d:\n", i);
        scan(n);
        scan(m);
        deal(n, m);
    }

    return 0;
}

——written by Lyon