[HDOJ3998] Sequence（DP，最大流）

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3998

给数字，问LIS以及每一个数字只取一次，最多能取多少个LIS。

LIS直接O(n^2) dp即可。

关键是怎么在统计最多能取多少个不相交的LIS：

每个数作为一个点，假如dp(i)=1，则说明这个点作为起点是不亏的，假如dp(i)=LIS，那么这个点肯定有机会是最后一个点。这样源点和汇点的边就建好：

源点 到 dp(i)=1 容量为1

dp(i)=LIS 到 汇点 容量为1

还要描述点与点之间的关系，所以不要忘记拆点。左半部分记为A集合，右半部分记为B集合。

A到B同位置的点要连一条边，容量为1。保证可以从A侧到B侧。

接下来可以枚举任意两个点i j，满足恰好的递推关系就行：i > j && x(i)>x(j) && dp(i)=dp(j)+1，则j到i连一条边，容量为1（注意是从B集合到A集合哦，不然的话只有A到B是不能满足匹配的）。

#include <bits/stdc++.h>
using namespace std;

typedef struct Edge {
    int u, v, w, next;
}Edge;

const int inf = 0x7f7f7f7f;
const int maxn = 6660;

int cnt, dhead[maxn];
int cur[maxn], dd[maxn];
Edge dedge[maxn<<8];
int S, T, N;

void init() {
    memset(dhead, -1, sizeof(dhead));
    for(int i = 0; i < maxn; i++) dedge[i].next = -1;
    S = 0; cnt = 0;
}

void adde(int u, int v, int w, int c1=0) {
    dedge[cnt].u = u; dedge[cnt].v = v; dedge[cnt].w = w; 
    dedge[cnt].next = dhead[u]; dhead[u] = cnt++;
    dedge[cnt].u = v; dedge[cnt].v = u; dedge[cnt].w = c1; 
    dedge[cnt].next = dhead[v]; dhead[v] = cnt++;
}

bool bfs(int s, int t, int n) {
    queue<int> q;
    for(int i = 0; i < n; i++) dd[i] = inf;
    dd[s] = 0;
    q.push(s);
    while(!q.empty()) {
        int u = q.front(); q.pop();
        for(int i = dhead[u]; ~i; i = dedge[i].next) {
            if(dd[dedge[i].v] > dd[u] + 1 && dedge[i].w > 0) {
                dd[dedge[i].v] = dd[u] + 1;
                if(dedge[i].v == t) return 1;
                q.push(dedge[i].v);
            }
        }
    }
    return 0;
}

int dinic(int s, int t, int n) {
    int st[maxn], top;
    int u;
    int flow = 0;
    while(bfs(s, t, n)) {
        for(int i = 0; i < n; i++) cur[i] = dhead[i];
        u = s; top = 0;
        while(cur[s] != -1) {
            if(u == t) {
                int tp = inf;
                for(int i = top - 1; i >= 0; i--) {
                    tp = min(tp, dedge[st[i]].w);
                }
                flow += tp;
                for(int i = top - 1; i >= 0; i--) {
                    dedge[st[i]].w -= tp;
                    dedge[st[i] ^ 1].w += tp;
                    if(dedge[st[i]].w == 0) top = i;
                }
                u = dedge[st[top]].u;
            }
            else if(cur[u] != -1 && dedge[cur[u]].w > 0 && dd[u] + 1 == dd[dedge[cur[u]].v]) {
                st[top++] = cur[u];
                u = dedge[cur[u]].v;
            }
            else {
                while(u != s && cur[u] == -1) {
                    u = dedge[st[--top]].u;
                }
                cur[u] = dedge[cur[u]].next;
            }
        }
    }
    return flow;
}

int n;
int x[maxn];
int dp[maxn];
int ret;

void work1() {
    ret = 0;
    memset(dp, 0, sizeof(dp));
    for(int i = 1; i <= n; i++) {
        dp[i] = 1;
        for(int j = 1; j <= i; j++) {
            if(x[i] > x[j]) dp[i] = max(dp[i], dp[j]+1);
        }
        ret = max(ret, dp[i]);
    }
    printf("%d
", ret);
}

void work2() {
    if(ret == 1) {
        printf("%d
", n);
        return;
    }
    init();
    S = 0, T = 2 * n + 1, N = T + 1;
    for(int i = 1; i <= n; i++) {
        adde(i, i+n, 1);
        if(dp[i] == 1) adde(S, i, 1);
        if(dp[i] == ret) adde(i+n, T, 1);
    }
    for(int i = 2; i <= n; i++) {
        for(int j = 1; j < i; j++) {
            if(x[i] > x[j] && dp[i] == dp[j] + 1) {
                adde(j+n, i, 1);
            }
        }
    }
    cout << dinic(S, T, N) << endl;
}

int main() {
    // freopen("in", "r", stdin);
    while(~scanf("%d",&n)) {
        init();
        for(int i = 1; i <= n; i++) scanf("%d", &x[i]);
        work1(); work2();
    }
    return 0;
}