poj_2396 有上下界的网络流

#include<stdio.h>
#include<string.h>
#include<queue>
#include<algorithm>
using namespace std;
#define MAX_NODE 250
#define MAX_EDGE_NUM 50000
#define INFINITE 1 << 25
#define min(a, b) a<b? a:b
#define max(a,b) a>b? a:b
//============================= 以下为 寻找最大网络流的 ISAP算法 部分 =============================
struct Edge{		//定义边
	int from;
	int to;
	int w;
	int next;
	int rev;
	bool operator == (const pair<int, int>& p){
		return from == p.first && to == p.second;
	}
};
Edge gEdges[MAX_EDGE_NUM];

int gEdgeCount;
int gFlow[MAX_NODE][MAX_NODE];
int gGap[MAX_NODE];
int gDist[MAX_NODE];
int gHead[MAX_NODE];
int gPre[MAX_NODE];
int gPath[MAX_NODE];
int ss, tt, sum1, sum2, m, n;
int gSource, gDestination;
void InsertEdge(int u, int v, int w){
	Edge* it = find(gEdges, gEdges + gEdgeCount, pair<int, int>(u, v));
	if (it != gEdges + gEdgeCount){
		if (u == ss || v == tt){
			it->w += w;
		}
		else{
			it->w = w;
		}
	}
	else{
		int e1 = gEdgeCount;
		gEdges[e1].from = u;
		gEdges[e1].to = v;
		gEdges[e1].w = w;
		gEdges[e1].next = gHead[u];
		gHead[u] = e1;

		gEdgeCount++;
		int e2 = gEdgeCount;
		gEdges[e2].from = v;
		gEdges[e2].to = u;
		gEdges[e2].w = 0;
		gEdges[e2].next = gHead[v];
		gHead[v] = e2;

		gEdges[e1].rev = e2;
		gEdges[e2].rev = e1;
		gEdgeCount++;
	}

}

void Bfs(){
	memset(gGap, 0, sizeof(gGap));
	memset(gDist, -1, sizeof(gDist));
	gGap[0] = 1;
	gDist[gDestination] = 0;
	queue<int>Q;
	Q.push(gDestination);
	while (!Q.empty()){
		int n = Q.front();
		Q.pop();
		for (int e = gHead[n]; e != -1; e = gEdges[e].next){
			int v = gEdges[e].to;
			if (gDist[v] >= 0)
				continue;
			gDist[v] = gDist[n] + 1;
			gGap[gDist[v]] ++;
			Q.push(v);
		}
	}
}

int ISAP(int n){ // n为节点的数目
	Bfs();
	int u = gSource;
	int e, d;
	int ans = 0;
	while (gDist[gSource] <= n){
		if (u == gDestination){ //增广
			int min_flow = INFINITE;
			for (e = gPath[u]; u != gSource; e = gPath[u = gPre[u]]){ //注意，先u = gPre[u]， 再取 e = gPath[u]
				min_flow = min(min_flow, gEdges[e].w);
			}
			u = gDestination;
			for (e = gPath[u]; u != gSource; e = gPath[u = gPre[u]]){
				gEdges[e].w -= min_flow;
				gEdges[gEdges[e].rev].w += min_flow;

				gFlow[gPre[u]][u] += min_flow;
				gFlow[u][gPre[u]] -= min_flow;  //这个不能少，注意！！！！
			}
			ans += min_flow;
		}
		for (e = gHead[u]; e != -1; e = gEdges[e].next){
			if (gEdges[e].w > 0 && gDist[u] == gDist[gEdges[e].to] + 1)
				break;
		}
		if (e >= 0){ //向前推进
			gPre[gEdges[e].to] = u; //前一个点
			gPath[gEdges[e].to] = e;//该点连接的前一个边
			u = gEdges[e].to;
		}
		else{
			d = n;
			for (e = gHead[u]; e != -1; e = gEdges[e].next){
				if (gEdges[e].w > 0)	//需要能够走通才行!!
					d = min(d, gDist[gEdges[e].to]);
			}
			if (--gGap[gDist[u]] == 0) //gap优化
				break;

			gDist[u] = d + 1;		//重标号

			++gGap[gDist[u]];	//更新 gap！！
			if (u != gSource)
				u = gPre[u];//回溯
		}
	}
	return ans;
}

//=================================以上为 ISAP 算法 ============================

//将图打印出来，用于debug
void print_graph(int n){
	for (int u = 0; u < n; u++){
		printf("node %d links to ", u);
		for (int e = gHead[u]; e != -1; e = gEdges[e].next)
			printf("%d(flow = %d) ", gEdges[e].to, gEdges[e].w);
		printf("\n");
	}
}

//保存 第i行第j列的数字的范围
struct Node{
	int min_val;
	int max_val;
};
Node gNodes[250][25];

//设置数字的范围
bool SetDataCons(Node& node, char op, int val){
	if (op == ‘=‘){
		if (node.max_val != -1 && node.max_val < val){
			return false;
		}
		if (node.min_val != -1 && node.min_val > val){
			return false;
		}
		node.max_val = node.min_val = val;
	}
	else if (op == ‘>‘){
		if (node.max_val != -1 && node.max_val <= val){
			return false;
		}
		node.min_val = max(node.min_val, val + 1);
	}
	else if (op == ‘<‘){
		if (val <= 0){
			return false;
		}
		if (node.min_val != -1 && node.min_val >= val){
			return false;
		}
		if (node.max_val != -1)
			node.max_val = min(node.max_val, val - 1);
		else
			node.max_val = val - 1;
	}
	return true;
}

//建图
void BuildGraph(){
	//注意，第i行，第j列，对应node结构体的 gNodes[i][j]，并且对应，最后的图中的节点为 i和 j+m(m为行数）
	for (int i = 1; i <= m; i++){
		for (int j = 1; j <= n; j++){
			if (gNodes[i][j].max_val == -1){
				if (gNodes[i][j].min_val == -1){
					InsertEdge(i, j + m, INFINITE);
				}
				else{
					sum1 += gNodes[i][j].min_val;
					InsertEdge(i, tt, gNodes[i][j].min_val);
					InsertEdge(ss, j + m, gNodes[i][j].min_val);
					InsertEdge(i, j + m, INFINITE);

					gFlow[i][j + m] = gNodes[i][j].min_val;	//边的下限，先加入到最后的边的流量中
				}
			}
			else {
				if (gNodes[i][j].min_val == -1){
					InsertEdge(i, j + m, gNodes[i][j].max_val);
					
				}
				else{
					sum1 += gNodes[i][j].min_val;

					InsertEdge(i, tt, gNodes[i][j].min_val);
					InsertEdge(ss, j + m, gNodes[i][j].min_val);

					if (gNodes[i][j].max_val > gNodes[i][j].min_val)
						InsertEdge(i, j + m, gNodes[i][j].max_val - gNodes[i][j].min_val);

					gFlow[i][j + m] = gNodes[i][j].min_val;//边的下限，先加入到最后的边的流量中
				}
			}
		}
	}
}
int main(){

	int c, w, u, v, cas, val;
	char op;
	scanf("%d", &cas);
	while (cas --){
		scanf("%d %d", &m, &n);
		memset(gNodes, -1, sizeof(gNodes));
		gEdgeCount = 0;
		memset(gEdges, 0, sizeof(gEdges));

		memset(gFlow, 0, sizeof(gFlow));
		memset(gHead, -1, sizeof(gHead));

		gSource = 0, gDestination = n + m + 1;
		ss = n + m + 2, tt = n + m + 3;
		sum1 = 0, sum2 = 0;
		bool valid_data = true;
		//输入的过程中，先插入一些边 从 SS 出发的
		for (int i = 1; i <= m; i++){
			scanf("%d", &w);
			if (valid_data == false)
				continue;
			if (w < 0){
				valid_data = false;
			}
			sum1 += w;
			InsertEdge(ss, i, w);
		}
		
		InsertEdge(gSource, tt, sum1);
		//输入的过程中，先插入一些边 到达 TT的
		for (int i = m + 1; i <= m + n; i++){
			scanf("%d", &w);
			if (valid_data == false)
				continue;
			if (w < 0)
				valid_data = false;
			sum2 += w;
			InsertEdge(i, tt, w);
		}

		InsertEdge(ss, gDestination, sum2);
	
		if (sum1 != sum2){
			valid_data = false;
		}

		sum1 = sum2 = (sum1 + sum2);

		//设置 矩阵中数字的范围
		scanf("%d", &c);
		for (int i = 0; i < c; i++){
			scanf("%d %d %c %d", &u, &v, &op, &val);
			if (valid_data == false)
				continue;

			if (w < 0){
				if (op == ‘=‘ || op == ‘<‘)
					valid_data = false;
				continue;
			}

			if (u == 0){
				if (v == 0){
					for (int i = 1; i <= m; i++){
						for (int j = 1; j <= n; j++){
							if (valid_data == false){
								break;
							}
							valid_data = SetDataCons(gNodes[i][j],op, val);
						}
					}
				}
				else{
					for (int i = 1; i <= m; i++){
						if (valid_data == false){
							break;
						}
						valid_data = SetDataCons(gNodes[i][v], op, val);
					}
				}
			}
			else{
				if (v == 0){
					for (int j = 1; j <= n; j++){
						if (valid_data == false){
							break;
						}
						valid_data = SetDataCons(gNodes[u][j], op, val);
					}
				}
				else{
					valid_data = SetDataCons(gNodes[u][v], op, val);
				}
			}
		}
		if (valid_data == false){
			printf("IMPOSSIBLE\n\n");
			continue;
		}
		//插入 t-->s的边，容量无穷大，使得有源汇的网络变为无源汇的网络
		InsertEdge(gDestination, gSource, INFINITE);
		//建图
		BuildGraph();

		gSource = ss;
		gDestination = tt;
//		print_graph(n + m + 4);
		//找最大流
		int ans = ISAP(n + m + 4);

		if (ans != sum1){
			printf("IMPOSSIBLE\n\n");
			continue;
		}
		//输出各个边的流量, 从图中节点i到节点j的流量，即为 矩阵 中 [i][j-m]的数字的大小
		for (int i = 1; i <= m; i++){
			for (int j = m+1; j <= m+n; j++){
				printf("%d ", gFlow[i][j]);
			}
			printf("\n");
		}
		printf("\n");
	}
	return 0;
}