Rent a Car UVA - 12433

一道最小费用最大流的问题，假设一个源点，从源点到各个代表请求的顶点（编号为1~N）的容量为请求的数量，同时从编号N+1~2N到汇点的容量为同样请求的数量，对于买车的情况是从源点开始，到编号为2*N+1的顶点建立边，容量不限，花费为对应的单价，同时要建立该节点到N+1~2N的边，容量也不限，花费为0。最后还要建立对应的天与天之间的边，表示之前多余的可以传递到下一天。对于维修的情况，首先要判断维修结束是否还能用，也就是在N天之前要结束维修，如果可以，就按照代码中的方式建边，边的容量不限，消费为维修车辆的单价，后面直接用对应算法即可，具体实现见如下代码：

#include<iostream>
#include<vector>
#include<string>
#include<set>
#include<stack>
#include<queue>
#include<map>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<cstring>
#include<sstream>
#include<cstdio>
#include<deque>
#include<functional>
using namespace std;
const int MAX = 200;
const int Inf = 0x3f3f3f3f;

class Edge{
public:
	int from, to, cap, flow, cost;
	Edge(int fr = 0, int t = 0, int ca = 0, int fl = 0, int co = 0)
		:from(fr), to(t), cap(ca), flow(fl), cost(co){}
};

class Solve{
public:
	int N, C, R;
	vector<Edge> edge;
	vector<int> G[MAX];
	int r[200], c[200], p[200], d[200], s[200];
	int res;

	void addEdge(int from,int to,int cap,int flow,int cost){
		edge.push_back(Edge(from, to, cap, flow, cost));
		edge.push_back(Edge(to, from, 0, flow, -cost));
		int m = edge.size();
		G[from].push_back(m - 2);
		G[to].push_back(m - 1);
	}

	bool BellManFord(int s_ind,int e_ind,int& flow,int& cost){
		int price[200];
		memset(price, Inf, sizeof(price));
		int inq[200];
		int parent[200];
		int Flow[200];
		Flow[s_ind] = Inf;
		memset(inq, 0, sizeof(inq));
		queue<int> q;
		q.push(s_ind);
		price[s_ind] = 0;
		inq[s_ind] = true;
		while (!q.empty()){
			int id = q.front();
			q.pop();
			inq[id] = false;
			for (int i = 0; i < G[id].size(); i++){
				int ide = G[id][i];
				int to = edge[ide].to;
				if (edge[ide].cap > edge[ide].flow&&price[to] > price[id] + edge[ide].cost){
					price[to] = price[id]+edge[ide].cost;
					Flow[to] = min(Flow[id], edge[ide].cap - edge[ide].flow);
					parent[to] = ide;
					if (!inq[to]){
						inq[to] = true;
						q.push(to);
					}
				}
			}
		}
		if (price[e_ind] == Inf) return false;
		flow += Flow[e_ind];
		cost += Flow[e_ind] * price[e_ind];
		for (int i = e_ind; i != s_ind; i = edge[parent[i]].from){
			edge[parent[i]].flow += Flow[e_ind];
			edge[parent[i] ^ 1].flow -= Flow[e_ind];
		}
		return true;
	}

	void Init(){
		res = 0;
		edge.clear();
		cin >> N >> C >> R;
		for (int i = 0; i < 200; i++) G[i].clear();
		for (int i = 1; i <= N; i++) cin >> r[i];
		for (int i = 1; i <= C; i++) cin >> c[i] >> p[i];
		for (int i = 1; i <= R; i++) cin >> d[i] >> s[i];
		for (int i = 1; i <= N; i++){//初始建边
			addEdge(0, i, r[i], 0, 0);
			addEdge(i + N, 2 * N + 2, r[i], 0, 0);
			res += r[i];
		}
		for (int i = 1; i <= C;i++){//购买 2*N+1
			addEdge(0, 2 * N + 1, c[i], 0, p[i]);
		}
		for (int i = 1; i <= N; i++){//购买之后
			addEdge(2 * N + 1, i+N, Inf, 0, 0);
		}
		for (int i = 1; i < N; i++){//前面一天多余的车可以传递给后面一天
			addEdge(i, i + 1, Inf, 0, 0);
		}
		for (int i = 1; i <= N;i++){//修车
			for (int j = 1; j <= R; j++){
				if (i + d[j] + 1 <= N){
					addEdge(i, i + d[j] + 1 + N, Inf, 0, s[j]);
				}
			}
		}
	}

	int Deal(){
		Init();
		int flow = 0, cost = 0;
		while (BellManFord(0, 2 * N + 2, flow, cost));
		if (flow == res) return cost;
		else return -1;
	}
};

int main(){
	Solve a;
	int T;
	cin >> T;
	for (int i = 1; i <= T; i++){
		int r = a.Deal();
		cout << "Case " << i << ": ";
		if (r == -1) cout << "impossible\n";
		else cout << r << endl;
	}
	return 0;
}