POJ 2516 Minimum Cost

题目链接:Minimum Cost

解题思路:看一下题面，有多个仓库，多个商店，多种商品，不同的仓库运送不同的商品到不同的商店有着不同的费用。求将所有商品运送到商店的最小费用。但是这里存在无解的情况，那就是供不应求的情况，每种货物的数量不足要求的数量，那么就输出-1。

剩下的就是构图+套模板。

构图:这里有许多的物品，当时我想的是将每一个仓库和商店拆开，将拆开的点分为in && out，在里面设置流量限制，其他的边容量就都是INF。最后一想每个货物运送的话费用不一样，就不能很合理的构建费用图来辅助。后来看了看网上的解题思路，都是在节点间构建一个矩阵。其实4000MS，可以把K个物品分成K个小问题，每一个问题单独求解，再将答案求和就是这个case的答案。每次跑最小费用流的模板之前都要将之前的图memset一下。因为每个物品的图不一样，可能里面还残留这之前图的残留的有容量的边。

创建超极源点和汇点，源点连接每一个仓库，花费为0，容量为这个仓库的这个物品的存货量。每一个商店连接汇点，花费为0，容量为这个商店这个物品的需求量。再在每一个仓库和商店之中，只要仓库有存货就连接一条边（之前一直WA就是应为这里将   库存 >= 需求设置为判断条件），容量为INF,花费就是对应的单位花费。

PS：这类题目难点并不是算法多么精妙，最重要的是对于题目的理解，如何更加高效的建图。更加易于编程。图建好就基本可以A屌这一道题了。（一些测试数据可以看看discuss）

#include<stdio.h>
#include<string.h>
#include<queue>
#define MAX 130
#define MAXN 55
#define INF 0x3f3f3f3f

using namespace std;

bool vis[MAX];
int dis[MAX];
int pre[MAX];
int Map[MAX][MAX];
int cost[MAX][MAX];
int offer_sum[MAX], need_sum[MAX];
int offer[MAXN][MAXN];
int need[MAXN][MAXN];
int info[MAXN][MAXN][MAXN];
int n, m, k, ans;

int minNum(int a, int b){
    return a < b ? a : b;
}

void init(){
	memset(Map, 0, sizeof(Map));
	memset(offer_sum, 0, sizeof(offer_sum));
	memset(need_sum, 0, sizeof(need_sum));
	ans = 0;
}

bool spfa(){
	int i, j;
	queue<int> que;
	memset(dis, 127, sizeof(dis));
	memset(vis, false, sizeof(vis));
	memset(pre, 0, sizeof(pre));
	que.push(0);
	vis[0] = true;
	dis[0] = 0;
	while(!que.empty()){
		int s = que.front();
		que.pop();
		for(i = 1; i <= n + m + 1; i++){
			if(Map[s][i] && dis[i] > dis[s] + cost[s][i]){
				dis[i] = dis[s] + cost[s][i];
				pre[i] = s;
				if(!vis[i]){
					que.push(i);
					vis[i] = true;
				}
			}
		}
		vis[s] = false;
	}
	if(dis[n + m + 1] < INF){
		return true;
	}
	return false;
}

int slove(){
	int u = n + m + 1;
	int detla = INF;
	while(u){
		detla = minNum(detla, Map[pre[u]][u]);
		u = pre[u];
	}
	u = n + m + 1;
	while(u){
		Map[pre[u]][u] -= detla;
		Map[u][pre[u]] += detla;
		u = pre[u];
	}
	return dis[n + m + 1] * detla;
}

int mincostflow(){
	int ret = 0;
	while(spfa()){
		ret += slove();
	}
	return ret;
}

int main(){
	int i, j, g;
	//freopen("in.txt", "r", stdin);
	while(scanf("%d%d%d", &n, &m, &k) && (n || m || k)){
		init();
		for(i = 1; i <= n; i++){
			for(j = 1; j <= k; j++){
				scanf("%d", &need[i][j]);
				need_sum[j] += need[i][j];
			}
		}
		for(i = 1; i <= m; i++){
			for(j = 1; j <= k; j++){
				scanf("%d", &offer[i][j]);
				offer_sum[j] += offer[i][j];
			}
		}
		for(i = 1; i <= k; i++){
			for(j = 1; j <= n; j++){
				for(g = 1; g <= m; g++){
					scanf("%d", &info[i][j][g]);
				}
			}
		}
		int flag = 0;
		for(i = 1; i <= k; i++){
			if(offer_sum[i] < need_sum[i]){
				flag = 1;
				break;
			}
		}
		if(flag){
			printf("-1\n");
			continue;	
		}
		for(i = 1; i <= k; i++){
			memset(Map, 0, sizeof(Map));
			memset(cost, 0, sizeof(cost));
			for(j = 1; j <= m; j++){
				Map[0][j] = offer[j][i];
			}
			for(j = m + 1; j <= n + m; j++){
				Map[j][m + n + 1] = need[j - m][i];
			}
			for(j = 1; j <= m; j++){
				for(g = m + 1; g <= m + n; g++){
					if(offer[j][i] > 0){
						Map[j][g] = INF;
						cost[j][g] = info[i][g - m][j];
						cost[g][j] = -cost[j][g];
					}
				}
			}
			ans += mincostflow();
		}
		printf("%d\n", ans);
	}
	return 0;
}