HDU4370 0-1规划跑最短路

0 or 1

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 2736    Accepted Submission(s): 901

Problem Description

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 ₁₂+X ₁₃+...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 ₁₂+X ₁₃+X ₁₄=1
X ₁₄+X ₂₄+X ₃₄=1
X ₁₂+X ₂₂+X ₃₂+X ₄₂=X ₂₁+X ₂₂+X ₂₃+X ₂₄
X ₁₃+X ₂₃+X ₃₃+X ₄₃=X ₃₁+X ₃₂+X ₃₃+X ₃₄

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

Hint

For sample, X ₁₂=X ₂₄=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规划模型。

解题的关键在于如何看出这个模型的本质。

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非负且题目要求总代价最小，因此最优答案的路径一定可以对应一条简单路径。

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

以上情况设为A

非常非常非常非常非常非常非常非常抱歉，简单路径只是充分条件，但不必要。（对造成困扰的队伍深表歉意）

漏了如下的情况B：

从1出发，走一个环（至少经过1个点，即不能是自环），回到1；从n出发，走一个环（同理），回到n。

容易验证，这是符合题目条件的。且A || B为该题要求的充要条件。

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

因此我们可以从1出发，找一个最小花费环，记代价为c1,再从n出发，找一个最小花费环，记代价为c2。（只需在最短路算法更新权值时多加一条记录即可：if(i==S) cir=min(cir,dis[u]+g[u][i])）

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

#include<set>
#include<map>
#include<queue>
#include<stack>
#include<ctime>
#include<deque>
#include<cmath>
#include<vector>
#include<string>
#include<cctype>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<sstream>
#include<iostream>
#include<algorithm>
#define REP(i,s,t) for(int i=(s);i<=(t);i++)
#define REP2(i,t,s) for(int i=(t);i>=s;i--)

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned long ul;

int n;
const int MAXN=305;
const int INF=0x3f3f3f3f;
int path[MAXN][MAXN];
bool vis[MAXN];//在队列标志
int dist[MAXN];
void SPFA(int start,int n)
{
    memset(vis,false,sizeof(vis));
    queue<int>Q;
    for(int i=1; i<=n; i++)
    {
        if(i==start)
        {
            dist[i]=INF;
        }
        else
        {
            dist[i]=path[start][i];
            Q.push(i);
            vis[i]=1;
        }
    }
    while(!Q.empty())
    {
        int u=Q.front();
        Q.pop();
        vis[u]=0;
        REP(i,1,n)
        {
            if(dist[i]>dist[u]+path[u][i])
            {
                dist[i]=dist[u]+path[u][i];
                if(!vis[i])
                {
                    vis[i]=1;
                    Q.push(i);
                }
            }
        }
    }
}
int main()
{
#ifdef ONLINE_JUDGE
#else
    freopen("test.in","r",stdin);
#endif
    while(~scanf("%d",&n))
    {
        REP(i,1,n)
        {
            REP(j,1,n)
            {
                int c;
                scanf("%d",&path[i][j]);
            }
        }
        SPFA(1,n);
        int ans=dist[n];
        int c1=dist[1];
        SPFA(n,n);
        int c2=dist[n];
        printf("%d\n",min(ans,c1+c2));
    }
    return 0;
}