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

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;
}