nefu487最长递增子序列问题【网络流24题】超详细讲解+模板
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 |
注：还是得靠自己啊……自学能力亟待加强，看下文中的第三条建边冥思苦想好久好久==结果自己写一组例子就明白了
3是啥意思呢？由于1.2建边构造了可行流的开始和结束，第三条就是用来构造可行流中间部分的==
即 找到某个点后面的某点 使得前面的点dp值恰好比后面的点的dp值大一，那么这么一来，刚刚连接上的边是最长路径中的必然的一部分
上图：
粉线就是长度递降的路径
问题分析】
第一问时LIS，动态规划求解，第二问和第三问用网络最大流解决。
【建模方法】
首先动态规划求出F[i]，表示以第i位为开头的最长上升序列的长度，求出最长上升序列长度K。
1、把序列每位i拆成两个点<i.a>和<i.b>，从<i.a>到<i.b>连接一条容量为1的有向边。
2、建立附加源S和汇T，如果序列第i位有F[i]=K，从S到<i.a>连接一条容量为1的有向边。
3、如果F[i]=1，从<i.b>到T连接一条容量为1的有向边。
4、如果j>i且A[i] < A[j]且F[j]+1=F[i]，从<i.b>到<j.a>连接一条容量为1的有向边。
求网络最大流，就是第二问的结果。把边(<1.a>,<1.b>)(<N.a>,<N.b>)(S,<1.a>)(<N.b>,T)这四条边的容量修改为无穷大，再求一次网络最大流，就是第三问结果。
【建模分析】
上述建模方法是应用了一种分层图的思想，把图每个顶点i按照F[i]的不同分为了若干层，这样图中从S出发到T的任何一条路径都是一个满足条件的最长上升子序列。由于序列中每个点要不可重复地取出，需要把每个点拆分成两个点。单位网络的最大流就是增广路的条数，所以最大流量就是第二问结果。第三问特殊地要求x1和xn可以重复使用，只需取消这两个点相关边的流量限制，求网络最大流即可。
#include<cstdio>
#include<iostream>
using namespace std;
const int oo=1e9;
/**oo 表示无穷大*/
const int mm=111111;
/**mm 表示边的最大数量，记住要是原图的两倍，在加边的时候都是双向的*/
const int mn=999;
/*mn 表示点的最大数量*/
int node,src,dest,edge;
/*node 表示节点数，src 表示源点，dest 表示汇点，edge 统计边数*/
int ver[mm],flow[mm],next[mm];
/*ver 边指向的节点，flow 边的容量，next 链表的下一条边*/
int head[mn],work[mn],dis[mn],q[mn];
/*head 节点的链表头，work 用于算法中的临时链表头，dis 计算距离*/
/*初始化链表及图的信息*/
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;
}
/*增加一条u 到v 容量为c 的边*/
void addedge(int u,int v,int c)
{
ver[edge]=v,flow[edge]=c,next[edge]=head[u],head[u]=edge++;
ver[edge]=u,flow[edge]=0,next[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=next[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;
/**work 是临时链表头，这里用i 引用它，这样寻找过的边不再寻找*/
for(int &i=work[u],v,tmp; i>=0; i=next[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],f[10005],F[10005];
int main()
{
int n,s;
while(~scanf("%d",&n))
{
for (int i=1; i<=n; i++)
{
scanf("%d",&a[i]);
}
s=-1;
for (int i=1; i<=n; i++)
{
f[i]=1;
for (int j=1; j<i; j++)
{
if (f[j]+1>f[i]&&a[j]<a[i])
{
f[i]=f[j]+1;
}
}
if (f[i]>s) s=f[i];
}
cout << s<< endl;
prepare(n+n+2,0,n+n+1);
for(int i=1;i<=n;i++)
{
if(f[i]==s)
addedge(i+n,dest,1);
if(f[i]==1)
addedge(src,i,1);
addedge(i,i+n,1);
}
for(int i=1;i<=n;i++)
for(int j=1;j<i;j++)
{
if(f[j]+1==f[i]&&a[i]>a[j])
{
addedge(j+n,i,1);
}
}
int ans1=Dinic_flow();
cout<<ans1<<endl;
prepare(n*2+2,0,n*2+1);
for (int i=1; i<=n; i++)
{
if (i==1||i==n)
{
addedge(i,i+n,oo);
if (f[i]==1) addedge(src,i,oo);
if (f[i]==s) addedge(i+n,dest,oo);
}
else
{
addedge(i,i+n,1);
if (f[i]==1) addedge(src,i,1);
if (f[i]==s) addedge(i+n,dest,1);
}
for (int j=1; j<i; j++)
{
if (f[j]+1==f[i]&&a[i]>a[j]) addedge(j+n,i,1);
}
}
int ans2=Dinic_flow();
if (ans2>oo)//至于这里为什么加这么一个判断，是因为如果有两个节点的时候我们视为只有一种（这么说有点牵强，是题目不严谨==）
cout<<ans1<<endl;
else
cout<<ans2<<endl;
}
return 0;
}