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
);
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]
);
}
printf("%d\n",min(ans,dis1+dis2));
}
}