HDU 3998 Sequence

题意：给出一个n个数字的序列，求最长上升子序列长度，并求出最多可以找出多少个最长上升子序列（每个位置上的数字只能在找出的序列中出现一次）

只能出现一次，还是可以联想到最大流的。而对于一个已经给定了的长度，貌似想控制在网络中的路径长度不太可能。假定每个位置上的当前最长上升子序列的标记为dp(i)。每个流会对应一种物理方案，那么必须是dp(j)=dp(i)+1,(j>i),所以，对于所有的符合条件的i,j，有边(i',j,1)。另外由于是每个数字只可以使用一次，所以肯定对应一条边(i,i',1)，对于所有dp(i)=1的点，对应边(S,i,1),对于所有dp(i)=ans的点，对应边(i',T,1)，这样一来，跑S->T的最大流就可以得出答案。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define INF 0x7fffffff
#define maxn 1<<13
#define maxm 1<<17
using namespace std;
int v[maxm],next[maxm],w[maxm];
int first[maxn],d[maxn],work[maxn],q[maxn];
int e,S,T;
int dp[maxn],s[maxn];
void init(){
    e = 0;
    memset(first,-1,sizeof(first));
}

void add_edge(int a,int b,int c){
    //printf("add:%d to %d,cap = %d
",a,b,c);
    v[e] = b;w[e] = c;next[e] = first[a];first[a] = e++;
    v[e] = a;w[e] = 0;next[e] = first[b];first[b] = e++;
}

int bfs(){
    int rear = 0;
    memset(d,-1,sizeof(d));
    d[S] = 0;q[rear++] = S;
    for(int i = 0;i < rear;i++){
        for(int j = first[q[i]];j != -1;j = next[j])
            if(w[j] && d[v[j]] == -1){
                d[v[j]] = d[q[i]] + 1;
                q[rear++] = v[j];
                if(v[j] == T)   return 1;
            }
    }
    return 0;
}

int dfs(int cur,int a){
    if(cur == T)    return a;
    for(int &i = work[cur];i != -1;i = next[i]){
        if(w[i] && d[v[i]] == d[cur] + 1)
            if(int t = dfs(v[i],min(a,w[i]))){
                w[i] -= t;w[i^1] += t;
                return t;
            }
    }
    return 0;
}

int dinic(){
    int ans = 0;
    while(bfs()){
        memcpy(work,first,sizeof(first));
        while(int t = dfs(S,INF))   ans += t;
    }
    return ans;
}

int main()
{
    int n;
    while(scanf("%d",&n) == 1){
        for(int i = 1;i <= n;i++){
            scanf("%d",&s[i]);
            dp[i] = 1;
        }
        int ans = 1;
        for(int i = 2;i <= n;i++)
            for(int j = 1;j < i;j++)
                if(s[i] > s[j] && dp[j] >= dp[i]){
                    dp[i] = dp[j] + 1;
                    ans = max(ans,dp[i]);
                }
        init();
        S = 0,T = n*2+1;
        for(int i = 1;i <= n;i++){
            add_edge(i,i+n,1);
            if(dp[i] == 1)      add_edge(S,i,1);
            if(dp[i] == ans)    add_edge(i+n,T,1);
            for(int j = i+1;j <= n;j++){
                if(dp[j] == dp[i] + 1)  add_edge(i+n,j,1);
            }
        }
        printf("%d
%d
",ans,dinic());
    }
    return 0;
}