poj 3311 floyd+dfs或状态压缩dp 两种方法

Hie with the Pie

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 6436		Accepted: 3470

Description

The Pizazz Pizzeria prides itself in delivering pizzas to its customers as fast as possible. Unfortunately, due to cutbacks, they can afford to hire only one driver to do the deliveries. He will wait for 1 or more (up to 10) orders to be processed before he starts any deliveries. Needless to say, he would like to take the shortest route in delivering these goodies and returning to the pizzeria, even if it means passing the same location(s) or the pizzeria more than once on the way. He has commissioned you to write a program to help him.

Input

Input will consist of multiple test cases. The first line will contain a single integer n indicating the number of orders to deliver, where 1 ≤ n ≤ 10. After this will be n + 1 lines each containing n + 1 integers indicating the times to travel between the pizzeria (numbered 0) and the n locations (numbers 1 to n). The jth value on the ith line indicates the time to go directly from location i to location j without visiting any other locations along the way. Note that there may be quicker ways to go from i to j via other locations, due to different speed limits, traffic lights, etc. Also, the time values may not be symmetric, i.e., the time to go directly from location i toj may not be the same as the time to go directly from location j to i. An input value of n = 0 will terminate input.

Output

For each test case, you should output a single number indicating the minimum time to deliver all of the pizzas and return to the pizzeria.

Sample Input

3
0 1 10 10
1 0 1 2
10 1 0 10
10 2 10 0
0

Sample Output

8

Source

East Central North America 2006

 

题意：有N个城市(1~N)和一个PIZZA店(0),要求一条回路，从0出发，又回到0，而且距离最短。

 求距离之和。

 

题解：n的范围很小，先floyd 求出每两点之间的最短距离

    一遍dfs求 能够构成回路的距离最小值

 

简单dfs处理

 /******************************
 code by drizzle
 blog: www.cnblogs.com/hsd-/
 ^ ^    ^ ^
  O      O
 ******************************/
 //#include<bits/stdc++.h>
 #include<iostream>
 #include<cstring>
 #include<cmath>
 #include<cstdio>
 #define ll long long
 #define mod 1000000007
 #define PI acos(-1.0)
 using namespace std;
 int n;
 ll mp[][];
 int used[];
 ll ans=mod;
 void floyd()
 {
     for(int i=;i<=n;i++)
     {
         for(int j=;j<=n;j++)
         {
             for(int k=;k<=n;k++)
             {
             mp[j][k]=min(mp[j][k],mp[j][i]+mp[i][k]);
             }
         }
     }
 }
 void dfs(int dep,int v,ll c)
 {
     if(dep==n)
     {
      ans=min(ans,c+mp[v][]);
      return ;
     }
     for(int i=;i<=n;i++)
     {
         if(!used[i])
         {
             used[i]=;
             dfs(dep+,i,c+mp[v][i]);
             used[i]=;
         }
     }
 }
 int main()
 {
     while((scanf("%d",&n))!=EOF){
         ans=mod;
         if(n==) break;
         memset(mp,,sizeof(mp));
         memset(used,,sizeof(used));
         for(int i=;i<=n;i++)
             for(int j=;j<=n;j++)
                 scanf("%I64d",&mp[i][j]);
         used[]=;
         floyd();
         dfs(,,);
         printf("%I64d\n",ans);
     }
     return ;
 }

状态压缩dp处理   也是第一次接触状态压缩 算是入门了 参考别人的代码 码的。

dfs处理 会有很多重复的运算 考虑dp处理其实就是类似poj滑雪的记忆化

dp[i][j]  代表 状态i下到j城市的最短距离   ans=dp[i][j]+mp[j][0]//回到0点

这里重要处理的就是怎么存储一个状态 共有2^10种

采用状态压缩 对于城市的去或者不去 采用0/1标记 

1~2^10 每一个值代表一个状态  具体看fun（）

 /******************************
 code by drizzle
 blog: www.cnblogs.com/hsd-/
 ^ ^    ^ ^
  O      O
 ******************************/
 //#include<bits/stdc++.h>
 #include<iostream>
 #include<cstring>
 #include<cmath>
 #include<cstdio>
 #define ll long long
 #define mod 1000000007
 #define PI acos(-1.0)
 using namespace std;
 int n;
 ll mp[][];
 ll dp[<<][];
 int used[];
 ll ans=mod;
 void floyd()
 {
     for(int i=;i<=n;i++)
     {
         for(int j=;j<=n;j++)
         {
             for(int k=;k<=n;k++)
             {
             mp[j][k]=min(mp[j][k],mp[j][i]+mp[i][k]);
             }
         }
     }
 }
 void fun()
 {
     for(int s=;s<=(<<n)-;s++)
         for(int i=;i<=n;i++)
     {
         if(s&(<<(i-)))//判断是否经过城市i
         {
             if(s==(<<(i-)))//只经过i
             dp[s][i]=mp[][i];
             else
             {
                 dp[s][i]=mod;
                 for(int j=;j<=n;j++)
                 {
                     if((s&(<<(j-)))&&j!=i)//判断绕行其他城市是否更优，取最优
                      dp[s][i]=min(dp[s^(<<(i-))][j]+mp[j][i],dp[s][i]);
                 }//类似floyd的处理
             }
         }
     }
     ans=dp[(<<n)-][]+mp[][];//回到0点
     for(int i=;i<=n;i++)
         ans=min(ans,dp[(<<n)-][i]+mp[i][]);
     printf("%I64d\n",ans);
 }
 int main()
 {
     while((scanf("%d",&n))!=EOF){
         ans=mod;
         if(n==) break;
         memset(mp,,sizeof(mp));
         memset(used,,sizeof(used));
         for(int i=;i<=n;i++)
             for(int j=;j<=n;j++)
                 scanf("%I64d",&mp[i][j]);
         floyd();
         fun();
     }
     return ;
 }