最长递增子序列问题（最大流）

Description

给定正整数序列x1 , ... , xn 。
（1）计算其最长递增子序列的长度s。
（2）计算从给定的序列中最多可取出多少个长度为s的递增子序列。
（3）如果允许在取出的序列中多次使用x1和xn，则从给定序列中最多可取出多少个长度为s的递增子序列。
设计有效算法完成（1）（2）（3）提出的计算任务。

Input

多组数据输入.
每组输入第1 行有1个正整数n，表示给定序列的长度。接下来的1 行有n个正整数x1 ,... , xn。

Output

每组输出第1 行是最长递增子序列的长度s。第2行是可取出的长度为s 的递增子序列个数。第3行是允许在取出
的序列中多次使用x1和xn时可取出的长度为s 的递增子序列个数。

Sample Input

4
3 6 2 5

Sample Output

2
2
3

题目出自nefu487

思路：第一问好求，直接dp就ok，然后第二三问就得用网络流的知识解决了。网上各种题解都说要拆点，我写完了之后看了看觉得其实并没有意义，拆点是自己本身这个点有权值的时候才需要去拆点，这一题主要是看子序列的建边，与每个点自身的dp数值并木有关系，所以这题的建边并不需要拆点，第二问就是从源点连边到dp值为1的点，从dp值最大的点连边到汇点，然后满足dp相互关系的点之间连边就ok，然后跑最大流就得到第二问结果。至于第三问，只是在第二问的基础上把第一个点如果和起点存在边，将权值设为oo，最后一个点如果和终点存在边，将权值设为oo就好，其他无大改变，当然，如果第三问跑的最大流是无穷大了，这只有一种可能，就是所有的点的输入权值都相等了，使得每个点都和源点和汇点连边的权值成为了无穷大，所以答案自然就错了，所以这时候应当把答案输出成第二问计算出来的答案。

经过我的验证的确不需要拆点   ╮（╯—╰）╭……

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include<string.h>
#include<algorithm>
#include<math.h>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
const   int oo=1e9;/**oo 表示无穷大*/
const  int mm=111111111;/**mm 表示边的最大数量，记住要是原图的两倍，在加边的时候都是双向的*/
const  int mn=2010;/**mn 表示点的最大数量*/
int node,src,dest,edge;/**node 表示节点数，src 表示源点，dest 表示汇点，edge 统计边数*/
int ver[mm],flow[mm],nex[mm];
int head[mn],work[mn],dis[mn],q[mn];
void prepare(int _node, int _src,int _dest)
{
    node=_node,src=_src,dest=_dest;
    for(int i=0; i<=node; ++i)head[i]=-1;
    edge=0;
}
void addedge( int u,  int v,  int c)
{
    ver[edge]=v,flow[edge]=c,nex[edge]=head[u],head[u]=edge++;
    ver[edge]=u,flow[edge]=0,nex[edge]=head[v],head[v]=edge++;
}
bool Dinic_bfs()
{
    int i,u,v,l,r=0;
    for(i=0; i<node; ++i)dis[i]=-1;
    dis[q[r++]=src]=0;
    for(l=0; l<r; ++l)
        for(i=head[u=q[l]]; i>=0; i=nex[i])
            if(flow[i]&&dis[v=ver[i]]<0)
            {
                dis[q[r++]=v]=dis[u]+1;
                if(v==dest)  return 1;
            }
    return 0;
}
int Dinic_dfs(  int u, int exp)
{
    if(u==dest)  return exp;
    for(  int &i=work[u],v,tmp; i>=0; i=nex[i])
        if(flow[i]&&dis[v=ver[i]]==dis[u]+1&&(tmp=Dinic_dfs(v,min(exp,flow[i])))>0)
        {
            flow[i]-=tmp;
            flow[i^1]+=tmp;
            return tmp;
        }
    return 0;
}
int Dinic_flow()
{
    int i,ret=0,delta;
    while(Dinic_bfs())
    {
        for(i=0; i<node; ++i)work[i]=head[i];
        while((delta=Dinic_dfs(src,oo)))ret+=delta;
    }
    return ret;
}

int a[10005],dp[10005];
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        for(int i=1; i<=n; i++)
            scanf("%d",&a[i]);
        for(int i=1; i<=n; i++)
        {
            dp[i]=1;
            for(int j=1; j<i; j++)
                if(a[j]<a[i])
                    dp[i]=max(dp[i],dp[j]+1);
        }
        int max0=0;
        for(int i=1; i<=n; i++)
            max0=max(max0,dp[i]);
        printf("%d\n",max0);

        prepare(n+2,0,n+1);///第二问建图
        for(int i=1; i<=n; i++)
        {
            if(dp[i]==1)
                addedge(0,i,1);
            if(dp[i]==max0)
                addedge(i,n+1,1);
            for(int j=1; j<i; j++)
                if(dp[j]+1==dp[i]&&a[i]>a[j])
                    addedge(j,i,1);
        }
        int ans1=Dinic_flow();
        printf("%d\n",ans1);

        prepare(n+2,0,n+1);///第三问建图
        for (int i=1; i<=n; i++)
        {
            if (i==1||i==n)
            {
                if (dp[i]==1) addedge(0,i,oo);
                if (dp[i]==max0) addedge(i,n+1,oo);
            }
            else
            {
                if (dp[i]==1) addedge(0,i,1);
                if (dp[i]==max0) addedge(i,n+1,1);
            }
            for(int j=1; j<i; j++)
                if(dp[j]+1==dp[i]&&a[i]>a[j])
                    addedge(j,i,1);
        }
        int ans2=Dinic_flow();
        if(ans2>=oo)///只有在所有数据都相等的情况下才会出现这种情况
            printf("%d\n",ans1);
        else
            printf("%d\n",ans2);
    }
    return 0;
}