网络流二十四题 ————(十九）、P4013 数字梯形问题 费用流经典建模

比较简单的费用流建模，但还是写了1h，只能说不够熟练。

说一下我做题时的想法吧：

首先肯定先考虑无任何限制的规则3：

无限制的话，只需要考虑第一层最为起点，每个点只能用一次这个限制即可：

直接按要求连边建图(流量均为inf，花费为：-权值)，然后S连向第一层流量为1，花费为0，这里控制第一层每个点只能取一次表示这个点开始的一条路径。最后一层连向终点，流量inf，花费0. 

然后仔细分析一下题目，发现：

每层连向下一层连边本来就是边不相交的(任意情况我们都可以让左边的路径选择最左边的边，构造出边不相交的路径，这里可以画图看一看，很容易就想明白了)，相交的情况只会出现在同一条路径访问两次。

所以对于规则二：我们只需要多一个限制：每条边最多访问1次即可，就把每条边的流量设为1就行。

对于规则一：又多了一个每个点最多用一次的限制，即经过每个点的流量最多为1，这里点流量限制我们一般的做法是拆点：

即把一个点拆成入点和出点，入点连向出点，流量为1，花费0。这个点的出边由出点往外连，这个点的入边连向入点。

这样入点连向出点的边的流量就限制了这个点选择的次数。

所以规则一也就easy解决了！。

这道题不错，把常用限制套路考了一遍！

#include<bits/stdc++.h> 
using namespace std;
typedef long long ll;
const int N=1000005;
const int M=1000005;
const ll inf=0x7fffffff;
struct MCMF{
	struct EDGE {
		int nxt, to, cost, flow;
	}ee[M << 1];
	int n,s,t;
	int cur[N],head[N],vis[N];
	ll dis[N];
	ll mincost=0,maxflow=0;
	inline void AD(int from, int to, int flow, int cost) {
		ee[++cnt].nxt = head[from];
		ee[cnt].to = to;
		ee[cnt].cost = cost;
		ee[cnt].flow = flow;
		head[from] = cnt;
	}
	int cnt=1;
	inline void add(int u,int v,int flow,int cost){
	    AD(u,v,flow,cost);
	    AD(v,u,0,-cost);
	  //  cout<<u<<"  ->  "<<v<<endl;
	}
	inline int spfa()
	{
	    for(int i=1;i<=n;++i)dis[i]=inf,vis[i]=0;
	    queue<int>q;q.push(s);
	    dis[s]=0;vis[s]=1;
	    while(!q.empty()){
	        int u=q.front();
	        vis[u]=0;q.pop();
	        for(int i=head[u];i;i=ee[i].nxt)
	        {
	            int v=ee[i].to;
	            if(!ee[i].flow)continue;
	            if(ee[i].flow&&dis[v]>dis[u]+ee[i].cost){
	                dis[v]=dis[u]+ee[i].cost;
	                if(!vis[v]){
	                    vis[v]=1;
	                    q.push(v);
	                }
	            }
	        }
	    }
	    return dis[t]!=inf;
	}
	inline ll dfs(int u,ll flow)
	{
	    if(u==t)return flow;
	    ll rest=flow;
	    vis[u]=1;
	    for(int i=cur[u];i&&rest;i=ee[i].nxt){
	        cur[u]=i;
	        int v=ee[i].to;
	        ll w=ee[i].cost,flow=ee[i].flow;
	        if(ee[i].flow&&(dis[v]==dis[u]+w)&&!vis[v]){
	            ll k=dfs(v,min(flow,rest));
	            if(k){
	                mincost+=k*w;
	                ee[i].flow-=k;
	                ee[i^1].flow+=k;
	                rest-=k;
	            }
	        }
	    }
	    vis[u]=0;
	    return flow-rest;
	}
	void gao(){
		while(spfa()){
	        for(int i=1;i<=n;++i)cur[i]=head[i];
	        maxflow+=dfs(s,inf);
	    }
	}
	void init(int nn,int ss,int tt){
		n=nn,s=ss,t=tt;
		maxflow=mincost=0;
		for(int i=0;i<=n;i++)head[i]=0;
	}
}mc;
int a[110][110];
map<pair<int,int>,int>mp;
void path(int p,int t){
	while(p!=t){
		cout<<p<<" -> ";
		for(int i=mc.head[p];i;i=mc.ee[i].nxt){
			if(i&1)continue;
			if(mc.ee[i^1].flow){
				mc.ee[i^1].flow--;
				p=mc.ee[i].to;
		//		cout<<p<<" == ";
				break;
			}
		}
	}
	cout<<endl;
}
int main()
{
	ios::sync_with_stdio(false);
  	cin.tie(0);
  	int n,m,s,t;
	cin>>n>>m;
	int sm=0,sz=0;
	for(int i=1;i<=m;i++){
		for(int j=1;j<n+i;j++){
			cin>>a[i][j];
			mp[{i,j}]=++sz; 
		}
	} 
	//cout<<"=======   "<<sz<<endl;
	
	//规则1 ,每个点拆成入点和出点，限制入点到出点流量为1，
	//则每个点只能访问一次 ，根据题目性质，只要每个点访问一次，边一定不相交 
	s=sz*2+1,t=sz*2+2;
	mc.init(sz*2+2,s,t);
	for(int i=1;i<=m;i++){
		for(int j=1;j<n+i;j++){
			int u=mp[{i,j}];
			mc.add(u+sz,u,1,0);
			if(i==m)continue; 
			for(int k=j;k<=j+1;k++){
				int pv=mp[{i+1,k}]+sz,v=mp[{i+1,k}];
				mc.add(u,pv,1,-a[i+1][k]);
				
			}
		}
	} 
	for(int i=1;i<=n;i++)
		mc.add(s,mp[{1,i}],1,-a[1][i]);
	for(int i=1;i<n+m;i++)
		mc.add(mp[{m,i}],t,1,0);
	mc.gao();
	cout<<-mc.mincost<<endl;
	//规则三： 边不相交，只要限制每条边的流量为1，就一定能保证边不相交，这里有点思维，画画图比较好理解 
	s=sz+1,t=sz+2;
	mc.init(sz+2,s,t);
	for(int i=1;i<m;i++){
		for(int j=1;j<n+i;j++){
			for(int k=j;k<=j+1;k++){
				int u=mp[{i,j}],v=mp[{i+1,k}];
				mc.add(u,v,1,-a[i+1][k]);
			}
		}
	} 
	for(int i=1;i<=n;i++)
		mc.add(s,mp[{1,i}],1,-a[1][i]);
	for(int i=1;i<n+m;i++)
		mc.add(mp[{m,i}],t,inf,0);
	mc.gao();
	cout<<-mc.mincost<<endl;
	//规则三： 无限制直接连边 
	s=sz+1,t=sz+2;
	mc.init(sz+2,s,t);
	for(int i=1;i<m;i++){
		for(int j=1;j<n+i;j++){
			for(int k=j;k<=j+1;k++){
				int u=mp[{i,j}],v=mp[{i+1,k}];
				mc.add(u,v,inf,-a[i+1][k]);
			}
		}
	} 
	for(int i=1;i<=n;i++)
		mc.add(s,mp[{1,i}],1,-a[1][i]);
	for(int i=1;i<n+m;i++)
		mc.add(mp[{m,i}],t,inf,0);
	mc.gao();
	cout<<-mc.mincost<<endl;
//	for(int i=1;i<=n;i++)path(i,t);
	return 0;
}