【gym 101606K】Knightsbridge Rises （最大流+打印路径）

https://codeforces.com/gym/101606/problem/K

题意

有 n个吊车，m个重物，现在要把m个重物放上楼顶，每个吊车有两个属性w1,w2，代表把这个吊车放上楼顶需要w1的力量，这个吊车拥有w2的力量，w1为0代表已经在楼顶上了。每个吊车只能使用一次。问是否可以将所有的重物都放上楼顶，并且输出一种方案。

题解

判断是否可行

1. 设超级源点S，超级汇点T，从S向w1=0的吊车连一条容量为1的边，将所有重物都连一条容量为1的边到T。
2. 对于每个吊车，因为只能选一次的原因，所以要对其限流，将吊车分裂成两个点W1,W2，从W1连一条容量为1的边到W2。
3. 如果一个吊车可以拿动另一个吊车那么就从一个吊车的W2连容量为1的边到另一个吊车W1。如果可以拿得动重物，那么就从W2连容量为1的边到重物。
   最大流 == 重物个数 即可行
   打印路径
   因为这个图很特殊，边的容量都是1，所以用没用过可以直接看边的流量是否改变。
   直接从每一个重物沿着反向边找吊车。
   如果找合法的反向边呢？反向边编号为奇数，且流量为负数。
   同时因为对吊车进行了裂点，所以还需注意下吊车的点。

代码

#include <bits/stdc++.h>
using namespace std;
#define FOR0(a,b) for(int i = a; i < b; ++i)
#define FORE(a,b) for(int i = a; i <= b; ++i)
typedef long long ll;
typedef pair<int,int> pii;
const int maxn = 1000;
const int INF = 0x3f3f3f3f;
struct Dinic {
	vector<int> G[maxn];
	struct Edge {
		int from, to, cap, flow;
	};
	void AddEdge(int from, int to, int cap) {
		edges.push_back((Edge){from,to,cap,0});
		edges.push_back((Edge){to,from,0,0});
		m = edges.size();
		G[from].push_back(m-2);
		G[to].push_back(m-1);
	}

	int n,m,s,t;
	vector<Edge> edges;
	
	bool vis[maxn];
	int d[maxn];
	int cur[maxn];
	bool bfs() {
		memset(vis, 0, sizeof vis);
		queue<int> Q;
		Q.push(s);
		d[s] = 0;
		vis[s] = 1;
		while(!Q.empty()) {
			int x = Q.front();
			Q.pop();
			for(int i = 0; i < G[x].size(); ++i) {
				Edge& e = edges[G[x][i]];
				if(!vis[e.to] && e.cap > e.flow) {
					vis[e.to] = 1;
					d[e.to] = d[x]+1;
					Q.push(e.to);
				}
			}
		}
		return vis[t];
	}
	void setn(int n) {
		this->n = n;
	}
	int dfs(int x,int a) {
		if(x == t || a == 0) return a;
		int flow = 0, f;
		for(int& i = cur[x]; i < G[x].size(); ++i) {
			Edge& e = edges[G[x][i]];
			if(d[x]+1 == d[e.to] && (f=dfs(e.to, min(a, e.cap-e.flow))) > 0) {
				e.flow += f;
				edges[G[x][i]^1].flow -= f;
				flow += f;
				a -= f;
				if(a == 0) break;
			}
		}
		return flow;
	}

	int maxflow(int s,int t) {
		this->s = s; this->t = t;
		int flow = 0;
		while(bfs()) {
			memset(cur,0,sizeof cur);
			flow += dfs(s,INF);
		}
		return flow;
	}
	int pre[maxn];
	vector<int> path;
	void dfs2(int x, int s) {

		for(int i = 0; i < G[x].size(); ++i) {
			int w = edges[G[x][i]].flow, v = edges[G[x][i]].to;
			// cout << x <<" " << v << " " << w << " " << G[x][i] << endl;
			if(G[x][i]%2  && w < 0 && v != s) { 
				if(v <= n) {
					
					path.push_back(v);
				}
				dfs2(v,s);
			}
		}
	}
	void print(int m) {
		// for(int i = 0; i < edges.size(); ++i) {
		// 	cout << edges[i].from <<" "<<edges[i].to <<" " << edges[i].flow <<" "<< edges[i].cap << endl;
		// }
		for(int i = 1; i <= m; ++i) {
			path.clear();
			dfs2(2*n+i,0);
			reverse(path.begin(), path.end());
			for(int i = 0; i < path.size(); ++i)
				cout << path[i] <<" ";
			cout << endl;
		}
	}
}dinic;
struct crane {
	int a,b;
}cr[105];
int w[105];
int main() {
	int n;
	scanf("%d", &n);
	for(int i = 1; i <= n; ++i) {
		scanf("%d%d", &cr[i].a, &cr[i].b);
		if(cr[i].a == 0)
			dinic.AddEdge(0,i,1);
		dinic.AddEdge(i,i+n,1);
	}
	int m;
	scanf("%d", &m);
	for(int i = 1; i <= m; ++i) {
		scanf("%d", &w[i]);
		dinic.AddEdge(2*n+i, 2*n+m+1, 1);
	} 
	for(int i = 1; i <= n; ++i) {
		for(int j = 1; j <= n; ++j) {
			if(i == j) continue; 
			if(cr[i].b >= cr[j].a) 
				dinic.AddEdge(n+i,j,1);
		}
		for(int j = 1; j <= m; ++j) {
			if(cr[i].b >= w[j]) {
				dinic.AddEdge(n+i,2*n+j,1);
			}
		}
	}
	dinic.setn(n);
	int flow = dinic.maxflow(0,n*2+m+1);
	if(flow < m) {
		puts("impossible");
	} else {
		// cout << flow << endl;
		dinic.print(m);
	}
	return 0;
}