NOIP2008传纸条-【DP/费用流】

题意

在一个矩形上求两条不相交的价值最大的路径

做法一：DP

常规dp题，略过

做法二：最大费用最大流

这道题可以作为费用流入门题，可以很好理解费用流的用途

建模过程：

1、找出方案可行：考虑最大流建图方法

首先因为要找不想交的两条路径，我们可以限制每个点只被选择一次，对于点的限制一般是拆点的套路。

将一个点i拆分为2个点，i和i’并且连边权为1,这样就可以限制这个点只被选择一次，不过源点和汇点（左上角、右下角）的两个点可以选择两次所以边权为2

然后i’和下方的点j连边，i’和右边的点i连边，边权都为1，表示可以向下走，和向右走。边权为1表示只能走一次
2、考虑费用赋权

对于原图，只有点权。所以将i和i’之间的边赋权值为点权，其他的费用为0

最后跑一次费用流即可

参考代码

#include
using namespace std;
#define in read()
#define ll long long 
#define db double 
#define pc(x) putchar(x)
#define gc getchar()
const int inf=0x7fffffff;
const int mod =1e9+7;
inline int read(){	int x=0,f=1;char c=gc;
	while((c<'0'||c>'9')&&(c!='-'))c=gc;if(c=='-')f=-1,c=gc;
	for(;c>='0'&&c<='9';c=gc)x=x*10+c-'0';	return x*f;
}
const int N=1e4+10;
struct Edge{
	int v,nxt,c,f;
}e[N*10];
int cnt=1,first[N],ans;
int S,T,n,m;
inline void  add(int u,int v,int c,int f){
	e[++cnt].v=v;e[cnt].nxt=first[u];first[u]=cnt;e[cnt].c=c;e[cnt].f=f;
}
inline void ins(int u,int v,int c,int f){
	add(u,v,c,f);add(v,u,0,-f);
}
namespace D{
	int vis[N],dis[N];
	int spfa(int s,int t){
		memset(vis,0,sizeof(vis));
		memset(dis,-1,sizeof(dis));
		dis[t]=0;vis[t]=1;
		deque<int>q;
		q.push_back(t);
		while(!q.empty()){
			int now=q.front();q.pop_front();vis[now]=0;  
			for(int i=first[now];i;i=e[i].nxt){
			//	cerr<
				if(e[i^1].c && dis[now]-e[i].f > dis[e[i].v] ){
					dis[e[i].v]=dis[now]-e[i].f;
					if(!vis[e[i].v]){
						vis[e[i].v]=1;
						if(!q.empty()&&dis[e[i].v] > dis[q.front()])q.push_front(e[i].v);else q.push_back(e[i].v);
					}
				}
			}
		}
		return dis[s]!=-1;
	}
	int dfs(int x,int t,int f,int &ans){
		vis[x]=1; 
		if(x==t) return f; 
		int used=0,w; 
		for(int i=first[x];i;i=e[i].nxt){
			int v=e[i].v,c=e[i].c,ff=e[i].f;
			if(!vis[v] && c && dis[x]-ff==dis[v]){
				w=dfs(v,t,min(c,f-used) , ans);
				if(w)ans+= w*ff, e[i].c-=w;e[i^1].c+=w;used+=w;
				if(used==f)break;
			}
		}
		return used;
	}
	int flow(int s,int t,int &ans){
		int ret=0;
		while(spfa(s,t)){ 
			vis[t]=1;
			while(vis[t]){
				memset(vis,0,sizeof(vis));
				ret+=dfs(s,t,inf,ans);
			}
		}
		return ret;
	}
}
inline int idx (int x,int y){
	return (x-1)*m+y;
}
int dx[]={0,1 };
int dy[]={1,0 };
int main(){
 	n=in;m=in;int tmp=0;
 	for(int i=1;i<=n;i++)
 	for(int j=1;j<=m;j++){
 		int x=in;
 		int id=idx(i,j);
 		if(id==1 || id==m*n)ins(id,id+n*m,2,x),tmp+=x;
 		else ins(id,id+n*m,1,x); 		 
 		for(int k=0;k<2;k++){
 			int tx=i+dx[k],ty=j+dy[k];
 			if(tx==n+1||ty==m+1)continue;
 			int id1=idx(tx,ty);
 			ins(id+n*m,id1,1,0);
		}
	}
	int ans=0;S=1,T=2*n*m; 
	D::flow(S,T,ans);
	cout<<ans-tmp;
	return 0;
}