0 or 1 图论最短路spfa

Given a n*n matrix C ij (1<=i,j<=n),We want to find a n*n matrix X ij (1<=i,j<=n),which is 0 or 1. 


Besides,X ij meets the following conditions: 


1.X 12+X 13+...X 1n=1 
2.X 1n+X 2n+...X n-1n=1 
3.for each i (1<i<n), satisfies ∑X ki (1<=k<=n)=∑X ij (1<=j<=n). 


For example, if n=4,we can get the following equality: 


X 12+X 13+X 14=1 
X 14+X 24+X 34=1 
X 12+X 22+X 32+X 42=X 21+X 22+X 23+X 24 
X 13+X 23+X 33+X 43=X 31+X 32+X 33+X 34 


Now ,we want to know the minimum of ∑C ij*X ij(1<=i,j<=n) you can get. 
Hint


For sample, X 12=X 24=1,all other X ij is 0. 
Input
The input consists of multiple test cases (less than 35 case). 
For each test case ,the first line contains one integer n (1<n<=300). 
The next n lines, for each lines, each of which contains n integers, illustrating the matrix C, The j-th integer on i-th line is C ij(0<=C ij<=100000).
Output
For each case, output the minimum of ∑C ij*X ij you can get. 
Sample Input
4
1 2 4 10
2 0 1 1
2 2 0 5
6 3 1 2
Sample Output
3

题解：

这道题出的真的是很棒，感觉自己好菜系列又增加了一道题目。

这道题目要求找一个满足给定条件的0,1矩阵使得找出的矩阵对应位置与给出矩阵对应位置乘积之和最小。

我们这样想，把给出的矩阵看作是一个图的邻接矩阵，矩阵的数就代表的是边的权值。

而要求我们给出的0，1矩阵呢，就相当于在原图之中找一些边，这些边的选取满足一些条件，然后求这些边权值之和的最小值。

题目中要求第一行的后n-1的位置有且只能有1个1，这也就变相的说明了我们找的边的左端点为1号顶点的边只能有一条，也就是1号点的出度为1。

同理n号点的入度为1。其他点的入度与出度相同。

而我们又要求最小和，所以说其他点入读和出度都不会大于1，不然就不优了。

所以说，我们可以想到从1点出发求到n点的一条最短路。这显然是满足条件的边选择方法。

但是最短路不是唯一的情况。

还有一种情况就是从点1出发，走一个闭环，然后回到点1，得到的长度为dis1

从点n出发，走一个闭环，然后回到点n，得到的长度为dis2

dis = dis1+dis2

我们要对上述两种情况取一个最小值。

（有的同学可能会想，如果从1出发的闭环经过了n，这样n的入度+1，从n出发的闭环又回到了n，这样n的入度又+1，与n的入度为1矛盾，怎么办）

（我们可以说明上面的情况一定不会是最优解，一定会被从1到n的最短路优化掉，因为从1到n再回到1的闭环一定比直接从1到n要短）

代码：

#include <cstdio>
#include <iostream>
#include <algorithm> 
#include <cstring>
#include <queue>
using namespace std;
const int MAXN = 400;
int head[MAXN];
int d[MAXN];
int G[MAXN][MAXN];
int cnt;
struct edge{ 
    int v; 
    int next; 
    int cost; 
}Es[100000];  
void init(){ 
    cnt = 0; 
    memset(head,-1,sizeof(head)); 
}
inline void add_edge(int i,int j,int cost){   
    Es[cnt].v = j; 
    Es[cnt].cost = cost; 
    Es[cnt].next = head[i]; 
    head[i] = cnt++; 
}   
void spfa(int x){
	int visit[MAXN];
	memset(d,0x3f,sizeof(d));
	memset(visit,0,sizeof(visit));
	queue<int> Q;
	Q.push(x);
	d[x] = 0;
	visit[x] = 1;
	while(!Q.empty()){
		int u = Q.front();Q.pop();
		for(int e = head[u];e != -1;e = Es[e].next)
		{
			int v = Es[e].v;
			if(d[v] > d[u] + Es[e].cost){
				d[v] = d[u] + Es[e].cost;
				if(!visit[v]){
					visit[v] = 1;
					Q.push(v);
				}
			}
		}
		visit[u] = 0;
	}
}
int main()
{
	int n;
	while(scanf("%d",&n) != EOF){
		int ans = 0x3f3f3f3f;
		init();
		for(int i = 1;i <= n;i++){
			for(int j = 1;j <= n;j++){
				int c;
				scanf("%d",&G[i][j]);
				//if(i != j)
				add_edge(i,j,G[i][j]);
			}
		}
		spfa(1);
		ans = min(ans,d[n]);
		int dis1 = 0x3f3f3f3f,dis2 = 0x3f3f3f3f;
		for(int i = 2;i <= n;i++){
			dis1 = min(dis1,d[i] + G[i][1]);
		}
		spfa(n);
		for(int i = 1;i < n;i++){
			dis2 = min(dis2,d[i] + G[i][n]);
		}
		printf("%d\n",min(ans,dis1+dis2));
	}
}