HDU-4370 0 or 1（最短路[Dijkstra]）

0 or 1

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)

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 <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>

using namespace std;

const int INF=0x3f3f3f3f;
const int MAXN=305;

int n,s,dis[MAXN],w[MAXN][MAXN];
bool vis[MAXN];
priority_queue <pair<int,int> > q;
//优先队列以pair<... , ...>为元素，是以first为关键字判别，first最大的最先出队

void Dijkstra(int& cir) {
    int j,u,tmp;
    dis[s]=0;
    q.push(make_pair(0,s));//make_pair(...);  无需写出类型，就可以生成一个pair对象
    while(!q.empty()) {
        u=q.top().second;
        q.pop();
        if(!vis[u]) {
            vis[u]=true;
            cir=min(cir,dis[u]+w[u][s]);
            for(j=1;j<=n;++j)
                if((tmp=dis[u]+w[u][j])<dis[j])
                    q.push(pair<int,int>(-(dis[j]=tmp),j));//pair<int,int>(...);  生成一个pair<int,int>对象（将第一个值变为负值，则会优先将first绝对值更小的出队）
        }
    }
}

int main() {
    int i,j,cir1,cirn;
    while(1==scanf("%d",&n)) {
        for(i=1;i<=n;++i) {
            for(j=1;j<=n;++j)
                scanf("%d",&w[i][j]);
            w[i][i]=INF;//顶点i到顶点i的距离为INF，防止产生自环
        }
        memset(vis,false,sizeof(vis));
        memset(dis,0x3f,sizeof(dis));
        cir1=cirn=INF;
        s=n;
        Dijkstra(cirn);
        memset(vis,false,sizeof(vis));
        memset(dis,0x3f,sizeof(dis));
        s=1;
        Dijkstra(cir1);
        printf("%d\n",min(dis[n],cir1+cirn));
    }
    return 0;
}