HDU 4370 0 or 1 (最短路）

[题目链接](http://acm.hdu.edu.cn/showproblem.ph

Problem Description
Given a n/n matrix Cij (1<=i,j<=n),We want to find a n/n matrix Xij (1<=i,j<=n),which is 0 or 1.

Besides,Xij meets the following conditions:

1.X12+X13+...X1n=1
2.X1n+X2n+...Xn-1n=1
3.for each i (1<i<n), satisfies ∑Xki (1<=k<=n)=∑Xij (1<=j<=n).

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

X12+X13+X14=1
X14+X24+X34=1
X12+X22+X32+X42=X21+X22+X23+X24
X13+X23+X33+X43=X31+X32+X33+X34

Now ,we want to know the minimum of ∑Cij*Xij(1<=i,j<=n) you can get.

Hint

For sample, X12=X24=1,all other Xij 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 Cij(0<=Cij<=100000).

Output
For each case, output the minimum of ∑Cij*Xij 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

分析：
3个条件明显在刻画未知数之间的关系，从图论的角度思考问题，容易得到下面3个结论：

1.X12+X13+...X1n=1 于是1号节点的出度为1

2..X1n+X2n+...Xn-1n=1 于是n号节点的入度为1

3.∑Xki =∑Xij 于是2~n-1号节点的入度必须等于出度

于是3个条件等价于一条从1号节点到n号节点的路径，故Xij=1表示需要经过边(i,j)，代价为Cij。Xij=0表示不经过边(i,j)。注意到Cij非负且题目要求总代价最小，因此最优答案的路径一定可以对应一条简单路径。

情况A：
基本思路就是把矩阵看做一个图，图中有n个点，1号点出度为1，n号点入度为1，其它点出度和入度相等，路径长度都是非负数，等价于一条从1号节点到n号节点的路径，故Xij=1表示需要经过边(i,j)，代价为Cij。Xij=0表示不经过边(i,j)。注意到Cij非负且题目要求总代价最小，因此最优答案的路径一定可以对应一条简单路径。

最终，我们直接读入边权的邻接矩阵，跑一次1到n的最短路即可，记最短路为path。

情况B：
从1出发，走一个环（至少经过1个点，即不能是自环），回到1；从n出发，走一个环（同理），回到n。也就是1和n点的出度和入度都为1，其它点的出度和入度为0.

由于边权非负，于是两个环对应着两个简单环。

因此我们可以从1出发，找一个最小花费环，记代价为c1,再从n出发，找一个最小花费环，记代价为c2。

故最终答案为min(path,c1+c2)

由于要计算从出发点出发的闭环的路径长度。所以要在普通SPFA的基础上做点变化。

就是把dist[start]设为INF。同时一开始并不是让出发点入队，而是让出发点能够到达的点入队。

代码：

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<queue>
#include<algorithm>
using namespace std;
const int INF=0x3f3f3f3f;
int tu[310][310];//保存路径长度的邻接矩阵
int dis[310];//距离的标记
int vis[310];//是否在队列中标记
int n;
void spfa(int start )
{
    queue<int>q;
    for(int v=1; v<=n; v++) //初始化
    {
        if(v==start)//由于要找start的闭环，所以dis[start]设为INF，且不入队
        {
            dis[v]=INF;
            vis[v]=0;
        }
        else
        {
            dis[v]=tu[start][v];
            q.push(v);
            vis[v]=1;
        }
    }

    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int v=1; v<=n; v++)
        {
            if(dis[v]>dis[u]+tu[u][v])
            {
                dis[v]=dis[u]+tu[u][v];
                if(!vis[v])//不在队列
                {
                    vis[v]=true;
                    q.push(v);

                }
            }
        }
        vis[u]=false;
    }
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1; i<=n; i++)
            for(int j=1; j<=n; j++)
                scanf("%d",&tu[i][j]);
        spfa(1);
        int ans1=dis[n];//1到n的最短路
        int ans2=dis[1];//1的闭环长度
        spfa(n);
        ans2+=dis[n];//n的闭环长度
        printf("%d
",min(ans1,ans2));
    }
    return 0;
}