线性规划与网络流24题之数字梯形问题 最大权不相交路径
2014-06-13 16:24
519 查看
http://acm.nefu.edu.cn/JudgeOnline/problemshow.php?problem_id=484
分析(引用BYvoid 大牛的分析):
求图的最大权不相交路径及其变种,用费用最大流解决。
建模方法:
-------------------------------------------------------------------------------------------------------------------
(Yran填加)在数字梯形的最下面再增加一行,使新增加的数字都是0如样例:
2 5
2 3
3 4 5
9 10 9 1
1 1 10 1 1
1 1 10 12 1 1
0 0 0 0 0 0 0
-------------------------------------------------------------------------------------------------------------------
规则(1)
把梯形中每个位置抽象为两个点<i.a>,<i.b>,建立附加源S 汇T。
1、对于每个点i 从<i.a>到<i.b>连接一条容量为1,费用为点i 权值的有向边。
2、从S 向梯形顶层每个<i.a>连一条容量为1,费用为0的有向边。
3、从梯形底层每个<i.b>向T 连一条容量为1,费用为0的有向边。
4、对于每个点i 和下面的两个点j,分别连一条从<i.b>到<j.a>容量为1,费用为0的有向边。
求最大费用最大流,费用流值就是结果。
规则(2)
把梯形中每个位置看做一个点i,建立附加源S 汇T。
1、从S 向梯形顶层每个i 连一条容量为1,费用为0的有向边。
2、从梯形底层每个i 向T 连一条容量为无穷大,费用为0的有向边。
3、对于每个点i 和下面的两个点j,分别连一条从i 到j 容量为1,费用为点i 权值的有向边。
求最大费用最大流,费用流值就是结果。
规则(3)
把梯形中每个位置看做一个点i,建立附加源S 汇T。
1、从S 向梯形顶层每个i 连一条容量为1,费用为0的有向边。
2、从梯形底层每个i 向T 连一条容量为无穷大,费用为0的有向边。
3、对于每个点i 和下面的两个点j,分别连一条从i 到j 容量为无穷大,费用为点i 权值的有向边。
求最大费用最大流,费用流值就是结果。
建模分析:
对于规则1,要求路径完全不相交,也就是每个点最多只能被访问了一次,所以要把点拆分,之间连接容量为1的边。因为任
意一条ST 之间的路径都是一个解,在拆分的点内部的边费用设为点的权值,求最大费用最大流就是费用最大的m 条路经。
对于规则2,要求路径可以相交,但不能有重叠,此时可以不必拆点了。为了保证路径没有重叠,需要在相邻的两个点上限制
流量为1,由于顶层的每个点只能用1次,S 向顶层点流量限制也为1。费用只需设在相邻点的边上,求最大费用最大流即可。
对于规则3,要求路径除了顶层每个点以外可以任意相交重叠。在规则2的基础上,取消除S 到顶层顶点之间的边以外所有边
的流量限制即可。
#include <stdio.h>
#include <iostream>
using namespace std;
//----------------------------------------------
//最小费用流模板
const int oo=1e9;
const int mm=11111;
const int mn=888;
int node,src,dest,edge;
int ver[mm],flow[mm],cost[mm],next[mm];
int head[mn],dis[mn],p[mn],q[mn],vis[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,vis[i]=0;
edge=0;
}
void addedge(int u,int v,int f,int c)
{
ver[edge]=v,flow[edge]=f,cost[edge]=c,next[edge]=head[u],head[u]=edge++;
ver[edge]=u,flow[edge]=0,cost[edge]=-c,next[edge]=head[v],head[v]=edge++;
}
bool spfa()
{
int i,u,v,l,r=0,tmp;
for(i=0; i<node; ++i)
dis[i]=oo;
dis[q[r++]=src]=0;
p[src]=p[dest]=-1;
for(l=0; l!=r; (++l>=mn)?l=0:l) //循环队列
{
for(i=head[u=q[l]],vis[u]=0; i>=0; i=next[i])
if(flow[i]&&dis[v=ver[i]]>(tmp=dis[u]+cost[i]))
{
dis[v]=tmp;
p[v]=i^1;
if(vis[v])
continue;
vis[q[r++]=v]=1;
if(r>=mn)
r=0;
}
}
return p[dest]>-1;
}
int SpfaFlow()
{
int i,ret=0,delta;
while(spfa())
{
for(i=p[dest],delta=oo; i>=0; i=p[ver[i]])
if(flow[i^1]<delta)
delta=flow[i^1];
for(i=p[dest]; i>=0; i=p[ver[i]])
flow[i]+=delta,flow[i^1]-=delta;
ret+=delta*dis[dest];
}
return ret;
}
//------------------------------------------------------
struct note
{
int x,y,z;
}a[30][30];
int main()
{
int m,n;
while(~scanf("%d%d",&m,&n))
{
int cnt=1;
for(int i=0;i<n;i++)
for(int j=0;j<m+i;j++)
{
scanf("%d",&a[i][j].x);
}
//first
for(int i=0;i<n;i++)
for(int j=0;j<m+i;j++)
{
a[i][j].y=cnt++;
a[i][j].z=cnt++;
}
for(int i=0;i<n+m;i++)
{
a
[i].x=0;
a
[i].y=cnt++;
a
[i].z=cnt++;
}
prepare(cnt+2,0,cnt);
for(int i=0;i<=n;i++)
{
for(int j=0;j<m+i;j++)
{
if(i==0)
addedge(src,a[i][j].y,1,0);
addedge(a[i][j].y,a[i][j].z,1,-a[i][j].x);
if(i!=n)
{
addedge(a[i][j].z,a[i+1][j].y,1,0);
addedge(a[i][j].z,a[i+1][j+1].y,1,0);
}
if(i==n)
addedge(a[i][j].z,dest,oo,0);
}
}
int ans=SpfaFlow();
printf("%d\n",-ans);
//two
cnt=1;
for(int i=0;i<n;i++)
for(int j=0;j<m+i;j++)
{
a[i][j].y=cnt++;
}
for(int i=0;i<n+m;i++)
{
a
[i].x=0;
a
[i].y=cnt++;
}
prepare(cnt+2,0,cnt);
for(int i=0;i<=n;i++)
{
for(int j=0;j<m+i;j++)
{
if(i==0)
addedge(src,a[i][j].y,1,0);
if(i!=n)
{
addedge(a[i][j].y,a[i+1][j].y,1,-a[i][j].x);
addedge(a[i][j].y,a[i+1][j+1].y,1,-a[i][j].x);
}
if(i==n)
addedge(a[i][j].y,dest,oo,0);
}
}
ans=SpfaFlow();
printf("%d\n",-ans);
//three
prepare(cnt+2,0,cnt);
for(int i=0;i<=n;i++)
{
for(int j=0;j<m+i;j++)
{
if(i==0)
addedge(src,a[i][j].y,1,0);
if(i!=n)
{
addedge(a[i][j].y,a[i+1][j].y,oo,-a[i][j].x);
addedge(a[i][j].y,a[i+1][j+1].y,oo,-a[i][j].x);
}
if(i==n)
addedge(a[i][j].y,dest,oo,0);
}
}
ans=SpfaFlow();
printf("%d\n",-ans);
}
return 0;
}
description |
给定一个由n 行数字组成的数字梯形如下图所示。梯形的第一行有m 个数字。从梯形的顶部的m 个数字开始,在每个数字处可以沿左下或右下方向移动,形成一条从梯形的顶至底的路径。 规则1:从梯形的顶至底的m条路径互不相交。 规则2:从梯形的顶至底的m条路径仅在数字结点处相交。 规则3:从梯形的顶至底的m条路径允许在数字结点相交或边相交。 2 3 3 4 5 9 10 9 1 1 1 10 1 1 1 1 10 12 1 1 对于给定的数字梯形,分别按照规则1,规则2,和规则3 计算出从梯形的顶至底的m条路径,使这m条路径经过的数字总和最大。 |
input |
多组数据输入. 每组输入第1 行中有2个正整数m和n(m,n<=20),分别表示数字梯形的第一行有m个数字,共有n 行。接下来的n 行是数字梯形中各行的数字。第1 行有m个数字,第2 行有m+1 个数字,…。 |
output |
每组输出规则1,规则2,和规则3 计算出的最大数字总和,每行一个最大总和。 |
sample_input |
2 5 2 3 3 4 5 9 10 9 1 1 1 10 1 1 1 1 10 12 1 1 |
sample_output |
66 75 77 |
求图的最大权不相交路径及其变种,用费用最大流解决。
建模方法:
-------------------------------------------------------------------------------------------------------------------
(Yran填加)在数字梯形的最下面再增加一行,使新增加的数字都是0如样例:
2 5
2 3
3 4 5
9 10 9 1
1 1 10 1 1
1 1 10 12 1 1
0 0 0 0 0 0 0
-------------------------------------------------------------------------------------------------------------------
规则(1)
把梯形中每个位置抽象为两个点<i.a>,<i.b>,建立附加源S 汇T。
1、对于每个点i 从<i.a>到<i.b>连接一条容量为1,费用为点i 权值的有向边。
2、从S 向梯形顶层每个<i.a>连一条容量为1,费用为0的有向边。
3、从梯形底层每个<i.b>向T 连一条容量为1,费用为0的有向边。
4、对于每个点i 和下面的两个点j,分别连一条从<i.b>到<j.a>容量为1,费用为0的有向边。
求最大费用最大流,费用流值就是结果。
规则(2)
把梯形中每个位置看做一个点i,建立附加源S 汇T。
1、从S 向梯形顶层每个i 连一条容量为1,费用为0的有向边。
2、从梯形底层每个i 向T 连一条容量为无穷大,费用为0的有向边。
3、对于每个点i 和下面的两个点j,分别连一条从i 到j 容量为1,费用为点i 权值的有向边。
求最大费用最大流,费用流值就是结果。
规则(3)
把梯形中每个位置看做一个点i,建立附加源S 汇T。
1、从S 向梯形顶层每个i 连一条容量为1,费用为0的有向边。
2、从梯形底层每个i 向T 连一条容量为无穷大,费用为0的有向边。
3、对于每个点i 和下面的两个点j,分别连一条从i 到j 容量为无穷大,费用为点i 权值的有向边。
求最大费用最大流,费用流值就是结果。
建模分析:
对于规则1,要求路径完全不相交,也就是每个点最多只能被访问了一次,所以要把点拆分,之间连接容量为1的边。因为任
意一条ST 之间的路径都是一个解,在拆分的点内部的边费用设为点的权值,求最大费用最大流就是费用最大的m 条路经。
对于规则2,要求路径可以相交,但不能有重叠,此时可以不必拆点了。为了保证路径没有重叠,需要在相邻的两个点上限制
流量为1,由于顶层的每个点只能用1次,S 向顶层点流量限制也为1。费用只需设在相邻点的边上,求最大费用最大流即可。
对于规则3,要求路径除了顶层每个点以外可以任意相交重叠。在规则2的基础上,取消除S 到顶层顶点之间的边以外所有边
的流量限制即可。
#include <stdio.h>
#include <iostream>
using namespace std;
//----------------------------------------------
//最小费用流模板
const int oo=1e9;
const int mm=11111;
const int mn=888;
int node,src,dest,edge;
int ver[mm],flow[mm],cost[mm],next[mm];
int head[mn],dis[mn],p[mn],q[mn],vis[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,vis[i]=0;
edge=0;
}
void addedge(int u,int v,int f,int c)
{
ver[edge]=v,flow[edge]=f,cost[edge]=c,next[edge]=head[u],head[u]=edge++;
ver[edge]=u,flow[edge]=0,cost[edge]=-c,next[edge]=head[v],head[v]=edge++;
}
bool spfa()
{
int i,u,v,l,r=0,tmp;
for(i=0; i<node; ++i)
dis[i]=oo;
dis[q[r++]=src]=0;
p[src]=p[dest]=-1;
for(l=0; l!=r; (++l>=mn)?l=0:l) //循环队列
{
for(i=head[u=q[l]],vis[u]=0; i>=0; i=next[i])
if(flow[i]&&dis[v=ver[i]]>(tmp=dis[u]+cost[i]))
{
dis[v]=tmp;
p[v]=i^1;
if(vis[v])
continue;
vis[q[r++]=v]=1;
if(r>=mn)
r=0;
}
}
return p[dest]>-1;
}
int SpfaFlow()
{
int i,ret=0,delta;
while(spfa())
{
for(i=p[dest],delta=oo; i>=0; i=p[ver[i]])
if(flow[i^1]<delta)
delta=flow[i^1];
for(i=p[dest]; i>=0; i=p[ver[i]])
flow[i]+=delta,flow[i^1]-=delta;
ret+=delta*dis[dest];
}
return ret;
}
//------------------------------------------------------
struct note
{
int x,y,z;
}a[30][30];
int main()
{
int m,n;
while(~scanf("%d%d",&m,&n))
{
int cnt=1;
for(int i=0;i<n;i++)
for(int j=0;j<m+i;j++)
{
scanf("%d",&a[i][j].x);
}
//first
for(int i=0;i<n;i++)
for(int j=0;j<m+i;j++)
{
a[i][j].y=cnt++;
a[i][j].z=cnt++;
}
for(int i=0;i<n+m;i++)
{
a
[i].x=0;
a
[i].y=cnt++;
a
[i].z=cnt++;
}
prepare(cnt+2,0,cnt);
for(int i=0;i<=n;i++)
{
for(int j=0;j<m+i;j++)
{
if(i==0)
addedge(src,a[i][j].y,1,0);
addedge(a[i][j].y,a[i][j].z,1,-a[i][j].x);
if(i!=n)
{
addedge(a[i][j].z,a[i+1][j].y,1,0);
addedge(a[i][j].z,a[i+1][j+1].y,1,0);
}
if(i==n)
addedge(a[i][j].z,dest,oo,0);
}
}
int ans=SpfaFlow();
printf("%d\n",-ans);
//two
cnt=1;
for(int i=0;i<n;i++)
for(int j=0;j<m+i;j++)
{
a[i][j].y=cnt++;
}
for(int i=0;i<n+m;i++)
{
a
[i].x=0;
a
[i].y=cnt++;
}
prepare(cnt+2,0,cnt);
for(int i=0;i<=n;i++)
{
for(int j=0;j<m+i;j++)
{
if(i==0)
addedge(src,a[i][j].y,1,0);
if(i!=n)
{
addedge(a[i][j].y,a[i+1][j].y,1,-a[i][j].x);
addedge(a[i][j].y,a[i+1][j+1].y,1,-a[i][j].x);
}
if(i==n)
addedge(a[i][j].y,dest,oo,0);
}
}
ans=SpfaFlow();
printf("%d\n",-ans);
//three
prepare(cnt+2,0,cnt);
for(int i=0;i<=n;i++)
{
for(int j=0;j<m+i;j++)
{
if(i==0)
addedge(src,a[i][j].y,1,0);
if(i!=n)
{
addedge(a[i][j].y,a[i+1][j].y,oo,-a[i][j].x);
addedge(a[i][j].y,a[i+1][j+1].y,oo,-a[i][j].x);
}
if(i==n)
addedge(a[i][j].y,dest,oo,0);
}
}
ans=SpfaFlow();
printf("%d\n",-ans);
}
return 0;
}
相关文章推荐
- 【网络流24题】No.16 数字梯形问题 (不相交路径 最大费用流)
- [网络流24题] 16 数字梯形(最大权不相交路径 ,最小费用最大流)
- 线性规划与网络流24题之最长k可重区间集问题 最大权不相交路径(最大费用最大流)
- LOJ6010 「网络流 24 题 - 11」数字梯形 坠大费用坠大流 坠大权不相交路径
- 线性规划与网络流24题 3.最小路径覆盖问题(nefu 481)
- 线性规划与网络流24题 2太空飞行计划问题 最大权闭合图问题(不懂) nefu 476
- 【网络流24题】No.21 (最长 k 可重区间集问题 最长不相交路径 最大费用流)
- 线性规划与网络流24题 2太空飞行计划问题 最大权闭合图问题(不懂) nefu 476
- 【网络流24题】No.11(航空路线问题 最长不相交路径 最大费用流)
- 【网络流24题】 No.6 最长不减子序列问题 (最大流)[模型:最多不相交路径]
- 线性规划与网络流24——最小路径覆盖问题
- 【网络流与线性规划24题】【机器人路径规划问题】【IDA*】【题解】
- 线性规划与网络流24题 餐巾计划问题
- 线性规划与网络流24题 04魔术球问题
- 线性规划与网络流24题 1飞行员配对方案问题
- 线性规划与网络流24题 11航空路线问题
- 线性规划与网络流24题の2 太空飞行计划问题(最大权闭合图问题)
- 线性规划与网络流24题 10餐巾计划问题
- 线性规划与网络流24题 06最长递增子序列问题
- 线性规划与网络流24题 10餐巾计划问题