HDU 4370 0 or 1 (01规划)【Dijkstra】||【spfa】

<题目链接>

题目大意：

一个n*n的01矩阵，满足以下条件

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).

另给出一个矩阵C，求∑Cij*Xij(1<=i,j<=n)的最小值。

解题分析：

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

Dijkstra代码：

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 using namespace std;

 const int N =;
 #define INF 0x3f3f3f3f
 int n;
 int cost[N][N];
 int dis[N];
 bool vis[N];

 void dij(int s){
     memset(vis,false,sizeof(vis));
     for(int i=;i<=n;i++){         //初始化
         if(i==s)dis[i]=INF;    //将s的dis值初始化为INF,这样就可以从其它点开始松弛最短路，从而得到s的闭环长度,因为其它点cur的dis初始化为cost[s][cur]。所以用s到cur的距离，再加上cur到s的最短距离，确实是s的最小非自环
         else if(cost[s][i]!=INF)dis[i]=cost[s][i];
         else dis[i]=INF;
     }
     for(int k=;k<=n;k++){
         int mn=INF,cur;
         for(int i=;i<=n;i++){
             if(!vis[i]&&dis[i]<mn){
                 mn=dis[i];
                 cur=i;
             }
         }
         vis[cur]=true;
         for(int i=;i<=n;i++){
             if(!vis[i]&&dis[i]>dis[cur]+cost[cur][i]){
                 dis[i]=dis[cur]+cost[cur][i];
             }
         }
     }
 }

 int main(){
     while(scanf("%d",&n)!=EOF){
         for(int i=;i<=n;i++){
             for(int j=;j<=n;j++){
                 scanf("%d",&cost[i][j]);
             }
         }
         dij();
         int loop1,loopn,dist;   //loop1为1的最短非自环，loop2为n的最短非自环
         loop1=dis[],dist=dis[n];
         dij(n);
         loopn=dis[n];
         int ans=min(dist,loop1+loopn);
         printf("%d\n",ans);
     }
     return ;
 }

spfa代码：

 #include<stdio.h>
 #include<iostream>
 #include<string.h>
 #include<algorithm>
 using namespace std;

 const int INF=0x3f3f3f3f;
 const int MAXN=;
 int cost[MAXN][MAXN];//保存路径长度的邻接矩阵
 int dist[MAXN];
 int que[MAXN];//注意队列的循环利用，建成循环队列
 bool vis[MAXN];//是否在队列中标记

 void SPFA(int start,int n)
 {
     int front=,rear=;
     for(int v=;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=;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=;//循环队列
                 }
             }
         }
         vis[u]=false;
         if(front>=MAXN)front=;
     }

 }
 int main(){
     int n;
     while(scanf("%d",&n)!=EOF){
         for(int i=;i<=n;i++)
           for(int j=;j<=n;j++)
             scanf("%d",&cost[i][j]);
         SPFA(,n);
         int ans=dist[n];//1到n的最短路
         int loop1=dist[];//1的闭环长度
         SPFA(n,n);
         int loopn=dist[n];//n的闭环长度
         ans=min(ans,loop1+loopn);
         printf("%d\n",ans);
     }
     return ;
 }

2018-10-14