HDU 3998 Sequence 最长上升子序列+最大流

/*
很典型的题了，求最长上升子序列就不赘述了
现在要得到不重复利用元素，可以构造几个这样长度的序列
和同类型的求几条最短路类似，
Maxlen[i]表示到i的最长序列长度
Maxlen[i]=1的连源点
Maxlen[i]=maxlen的连汇点（maxlen为最长序列的长度）
对Maxlen[i]=Maxlen[j]+1(1<=j<i)连一条j到i的边
所有边边权为1,得到的最大流就是可以构造的最大个数
*/
#include <cstdio>
#include <iostream>
#include <memory.h>
#include<queue>
#include<set>
#include<ctime>
#include<algorithm>
#include<cmath>
#include<vector>
#define  LL __int64
using namespace std;
const int maxn=10009;
const LL inf=(1LL)<<35;
int aMaxlen[1009];
int b[1009];

struct edge    
{     
    int v, next;     
    LL val;     
} net[ 500010 ];     
int n,m;  
int level[maxn], Qu[maxn], out[maxn],next[maxn];    
class Dinic {     
public:     
    int end;    
    Dinic() {     
        end = 0;     
        memset( next, -1, sizeof(next) );     
    }     
    inline void insert( int x, int y, LL c) {     
        net[end].v = y, net[end].val = c,    
        net[end].next = next[x],     
        next[x] = end ++;     
        net[end].v = x, net[end].val = 0,    
        net[end].next = next[y],     
        next[y] = end ++;     
    }     
    bool BFS( int S, int E ) {     
        memset( level, -1, sizeof(level) );     
        int low = 0, high = 1;     
        Qu[0] = S, level[S] = 0;     
        for( ; low < high; ) {     
            int x = Qu[low];     
            for( int i = next[x]; i != -1; i = net[i].next ) {     
                if( net[i].val == 0 ) continue;     
                int y = net[i].v;     
                if( level[y] == -1 ) {     
                    level[y] = level[x] + 1;     
                    Qu[ high ++] = y;     
                }     
            }     
            low ++;     
        }     
        return level[E] != -1;     
    }      
      
    LL MaxFlow( int S, int E ){     
        LL maxflow = 0;     
        for( ; BFS(S, E) ; ) {     
            memcpy( out, next, sizeof(out) );     
            int now = -1;     
            for( ;; ) {     
                if( now < 0 ) {     
                    int cur = out[S];     
                    for(; cur != -1 ; cur = net[cur].next )      
                        if( net[cur].val && out[net[cur].v] != -1 && level[net[cur].v] == 1 )     
                            break;     
                    if( cur >= 0 ) Qu[ ++now ] = cur, out[S] = net[cur].next;     
                    else break;     
                }     
                int u = net[ Qu[now] ].v;     
                if( u == E ) {     
                    LL flow = inf;     
                    int index = -1;     
                    for( int i = 0; i <= now; i ++ ) {     
                        if( flow > net[ Qu[i] ].val )     
                            flow = net[ Qu[i] ].val, index = i;     
                    }     
                    maxflow += flow;     
                    for( int i = 0; i <= now; i ++ )     
                        net[Qu[i]].val -= flow, net[Qu[i]^1].val += flow;     
                    for( int i = 0; i <= now; i ++ ) {     
                        if( net[ Qu[i] ].val == 0 ) {     
                            now = index - 1;     
                            break;     
                        }     
                    }     
                }     
                else{     
                    int cur = out[u];     
                    for(; cur != -1; cur = net[cur].next )      
                        if (net[cur].val && out[net[cur].v] != -1 && level[u] + 1 == level[net[cur].v])     
                            break;     
                    if( cur != -1 )     
                        Qu[++ now] = cur, out[u] = net[cur].next;     
                    else out[u] = -1, now --;     
                }     
            }     
        }     
        return maxflow;     
    }     
};     
int main()
{
	while(scanf("%d",&n)!=EOF)
	{
		for(int i=1;i<=n;i++)
		scanf("%d",&b[i]);
		aMaxlen[1]=1;
		for(int i=2;i<=n;i++)
		{
		int nTmp=0;
			for(int j=1;j<i;j++)
				if(b[i]>b[j])
				{
				if(aMaxlen[j]>nTmp)
				nTmp=aMaxlen[j];
				}
				aMaxlen[i]=nTmp+1;
		}
		int nMax=-1;
		for(int i=1;i<=n;i++)
			if(nMax<aMaxlen[i])
				nMax=aMaxlen[i];

			
		Dinic my;
		int end=1009;
		for(int i=1;i<=n;i++)
		{
			if(aMaxlen[i]==nMax)
			my.insert(i,end,1);
			if(aMaxlen[i]==1)
			my.insert(0,i,1);
		}
		for(int i=1;i<=n;i++)
		for(int j=i+1;j<=n;j++)
		{
			if(aMaxlen[j]==aMaxlen[i]+1)
			my.insert(i,j,1);
		}
		printf("%d\n%I64d\n",nMax,my.MaxFlow(0,end));
	}
return 0;
}