HDU 4370 0 or 1（最短路）

0 or 1

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

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

 

 

Author

Snow_storm

 

 

Source

2012 Multi-University Training Contest 8

 

 

Recommend

zhuyuanchen520

 

 

1001  (已更新)

显然，题目给的是一个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)

 

 

/*

HDU 4370 0 or 1

转换思维的题啊，由一道让人不知如何下手的题，转换为了最短路

基本思路就是把矩阵看做一个图，图中有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。

（只需在最短路算法更新权值时多加一条记录即可：if(i==S) cir=min(cir,dis[u]+g[u][i])）



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

*/

/*

本程序用SPFA来完成最短路。

但是由于要计算从出发点出发的闭环的路径长度。

所以要在普通SPFA的基础上做点变化。



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

出发点能够到达的点入队。

*/

#include<stdio.h>

#include<iostream>

#include<string.h>

#include<algorithm>

using namespace std;



const int INF=0x3f3f3f3f;

const int MAXN=330;

int cost[MAXN][MAXN];//保存路径长度的邻接矩阵

int dist[MAXN];

int que[MAXN];//注意队列的循环利用，建成循环队列

bool vis[MAXN];//是否在队列中标记



void SPFA(int start,int n)

{

    int front=0,rear=0;

    for(int v=1;v<=n;v++)//初始化

    {

        if(v==start)//由于要找start的闭环，所以dist[start]设为INF，且不入队

        {

            dist[v]=INF;

            vis[v]=false;

        }

        else if(cost[start][v]!=INF)

        {

            dist[v]=cost[start][v];

            que[rear++]=v;

            vis[v]=true;

        }

        else//即dist[start][v]==INF情况，对本题没有这种情况

        {

            dist[v]=INF;

            vis[v]=false;

        }

    }



    while(front!=rear)//注意这个条件是不等，因为是循环队列

    {

        int u=que[front++];

        for(int v=1;v<=n;v++)

        {

            if(dist[v]>dist[u]+cost[u][v])

            {

                dist[v]=dist[u]+cost[u][v];

                if(!vis[v])//不在队列

                {

                    vis[v]=true;

                    que[rear++]=v;

                    if(rear>=MAXN) rear=0;//循环队列

                }

            }

        }

        vis[u]=false;

        if(front>=MAXN)front=0;

    }



}

int main()

{

    //freopen("in.txt","r",stdin);

    //freopen("out.txt","w",stdout);

    int n;

    while(scanf("%d",&n)!=EOF)

    {

        for(int i=1;i<=n;i++)

          for(int j=1;j<=n;j++)

            scanf("%d",&cost[i][j]);

        SPFA(1,n);

        int ans=dist[n];//1到n的最短路

        int loop1=dist[1];//1的闭环长度

        SPFA(n,n);

        int loopn=dist[n];//n的闭环长度

        ans=min(ans,loop1+loopn);

        printf("%d\n",ans);

    }

    return 0;

}

 

 

下面是用堆栈实现的SPFA

/*

用堆栈实现SPFA，有时候比队列快

*/

#include<stdio.h>

#include<iostream>

#include<string.h>

#include<algorithm>

using namespace std;

const int MAXN=330;

const int INF=0x3f3f3f3f;



int cost[MAXN][MAXN];

int dist[MAXN];

int Q[MAXN];

bool vis[MAXN];



void SPFA(int start,int n)

{//堆栈实现，有时候比队列快

    int top=0;

    for(int v=1;v<=n;v++)

    {

        if(v==start)

        {

            dist[v]=INF;

            vis[v]=false;

        }

        else

        {

            dist[v]=cost[start][v];

            vis[v]=true;

            Q[top++]=v;

        }

    }

    while(top!=0)

    {

        int u=Q[--top];

        for(int v=1;v<=n;v++)

        {

            if(dist[v]>dist[u]+cost[u][v])

            {

                dist[v]=dist[u]+cost[u][v];

                if(!vis[v])

                {

                    vis[v]=true;

                    Q[top++]=v;

                }

            }

        }

        vis[u]=false;

    }

}

int main()

{

    //freopen("in.txt","r",stdin);

    //freopen("out.txt","w",stdout);

    int n;

    while(scanf("%d",&n)!=EOF)

    {

        for(int i=1;i<=n;i++)

          for(int j=1;j<=n;j++)

            scanf("%d",&cost[i][j]);

        SPFA(1,n);

        int ans=dist[n];//1到n的最短路

        int loop1=dist[1];//1的闭环长度

        SPFA(n,n);

        int loopn=dist[n];//n的闭环长度

        ans=min(ans,loop1+loopn);

        printf("%d\n",ans);

    }

    return 0;

}