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