[codevs 1913] 数字梯形问题

[codevs 1913] 数字梯形问题

题解：

本题就是加强版的 [codevs 1033] 蚯蚓的游戏问题。

分别针对三个规则建图、运行最小费用最大流。

规则1：从梯形的顶至底的m条路径互不相交。

分析：因为要互不相交，所以每个点只能走一次，因此要拆点（X->Xi,Xj），容量为1费用为数字相反数，从源点向顶层每个Xi连容量为1，费用为0的边。从底层每个Xj向汇点连一条同样的边。再在相邻边之间连同样的边。最后求解最小费用最大流，取费用相反数就是结果。

规则2：从梯形的顶至底的m条路径仅在数字结点处相交。

分析：仅在数字节点处相交，即一个数字可以经过多次，那么可以放宽Xi和Xj之间容量的限制（由1修改为INF或者m），但注意顶层必须从m个点处引出m条道路，所以顶层的点拆点后的边的容量不能修改（其实改了也没影响），同时还应把底层的Xj连向汇点的边的容量放宽，为了充分利用规则1中已经建好的图，扫一遍边集修改就行了。

规则3：从梯形的顶至底的m条路径允许在数字结点相交或边相交。

分析：这里类比规则2，可以再把相邻点之间的边的容量的限制放宽（由1修改为INF或者m）。注意源点向顶层Xi的边不能改。

利用原有的边建图会更方便更快。

代码：

总时间耗费: 7ms 
总内存耗费: 364B

#include<cstdio>
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;

const int maxn = 400 + 10;
const int INF = 1000000007;

int n, m, s, t, delta;
int map[maxn][maxn], ID[maxn][maxn];

struct Edge {
	int from, to, cap, flow, cost;
};

vector<Edge> edges;
vector<int> G[maxn];


void AddEdge(int from, int to, int cap, int cost) {
	edges.push_back((Edge){from, to, cap, 0, cost});
	edges.push_back((Edge){to, from, 0, 0, -cost});
	int sz = edges.size();
	G[from].push_back(sz-2);
	G[to].push_back(sz-1);
}

bool inq[maxn];
int a[maxn], d[maxn], p[maxn];

bool BellmanFord(int& flow, int& cost) {
	for(int i = s; i <= t; i++) d[i] = INF;
	memset(inq, 0, sizeof(inq));
	d[s] = 0; inq[s] = 1; p[s] = 0; a[s] = INF;
	
	queue<int> Q;
	Q.push(s);
	while(!Q.empty()) {
		int x = Q.front(); Q.pop();
		inq[x] = 0;
		for(int i = 0; i < G[x].size(); i++) {
			Edge& e = edges[G[x][i]];
			if(e.cap > e.flow && d[e.to] > d[x] + e.cost) {
				d[e.to] = d[x] + e.cost;
				p[e.to] = G[x][i];
				a[e.to] = min(a[x], e.cap-e.flow);
				if(!inq[e.to]) {
					Q.push(e.to);
					inq[e.to] = 1;
				}
			}
		}
	}
	if(d[t] == INF) return 0;
	flow += a[t];
	cost += d[t] * a[t];
	int x = t;
	while(x != s) {
		edges[p[x]].flow += a[t];
		edges[p[x]^1].flow -= a[t];
		x = edges[p[x]].from;
	}
	return 1;
}

void MincostMaxflow() {
	int flow = 0, cost = 0;
	while(BellmanFord(flow, cost));
	cout << -cost << endl;
}
 
void init() {
	cin >> m >> n;
	for(int i = 1; i <= n; i++)
		for(int j = 1; j < m+i; j++) {
			ID[i][j] = ++t;
			cin >> map[i][j];
		}
	delta = t;
	t = t * 2 + 1;
}

void init_1() {
	for(int x = 1; x <= n; x++)
		for(int y = 1; y < x+m; y++) {
			int& id = ID[x][y];
			AddEdge(id, id+delta, 1, -map[x][y]);
			if(x == 1) AddEdge(s, id, 1, 0);
			if(x == n) AddEdge(id+delta, t, 1, 0); //key1
			else {
				AddEdge(id+delta, ID[x+1][y], 1, 0);
				AddEdge(id+delta, ID[x+1][y+1], 1, 0);
			}
		}
}

void init_2() {
	for(int x = 1; x <= delta; x++) 
		for(int i = 0; i < G[x].size(); i++) //key 2
			if(edges[G[x][i]].to == x + delta) {
				edges[G[x][i]].cap = m;
				break;
			}
	for(int y = 1; y < n+m; y++) {
		int x = ID[n][y] + delta;
		for(int i = 0; i < G[x].size(); i++) 
			if(edges[G[x][i]].to == t) edges[G[x][i]].cap = m; //key 4
	}
	for(int i = 0; i < edges.size(); i++) edges[i].flow = 0;
}

void init_3() {
	for(int i = 0; i < edges.size(); i++) {
		Edge& e = edges[i];
		e.flow = 0;
		if(e.cap && e.from != s) e.cap = m; //key 3
	}
}
	
void debug() {
	for(int i = 0; i < edges.size(); i++) {
		Edge& e = edges[i];
		if(e.cap) printf("%d %d %d %d\n", e.from, e.to, e.cap, e.cost);
	}
}

void regulation_1() {
	init_1();
	//debug();
	MincostMaxflow();
}


void regulation_2() {
	init_2();
	//debug();
	MincostMaxflow();
}

void regulation_3() {
	init_3();
	//debug();
	MincostMaxflow();
}

int main() {
	init();
	regulation_1();
	regulation_2();
	regulation_3();
  return 0;
}