售货员的难题（luogu1171）

题目见网址：https://www.luogu.org/problem/show?pid=1171
这道题虽有更好的解法，但这次用在了图的遍历学习练习中，在学完图的存储方式（邻接表和动态数组存邻接边）与图的深度优先遍历与宽度优先遍历后拿来练手图的搜索的。题目给下去了，但是luogu数据强些，在codevs上能AC的，在luogu上只能90分。
下面贴出AC历程中各分值程序，并作简单解读。
1.会图上的深度搜索的初学者写出来便是40分，其他TLE。

#include<iostream>
#include<climits>
#include<cstring>
using namespace std;
const int MAXN=21;
int map[MAXN][MAXN];
bool vis[MAXN];
int n,minn=INT_MAX;
void dfs(int t,int tot,int count){
     if(count==n){
         if(map[t][1]){
             tot+=map[t][1];
             if(tot<minn){
                 minn=tot;           
            }
         }        
         return ;
     }
     for(int i=1;i<=n;i++)
         if(!vis[i]&&map[t][i])
         {            
             vis[i]=1;
             dfs(i,tot+map[t][i],count+1);
             vis[i]=0;
         }
     }
 int main(){
     cin >> n;
     for(int i=1;i<=n;i++)
         for(int j=1;j<=n;j++)
             cin >> map[i][j];
     vis[1]=1;
     dfs(1,0,1);    
     cout << minn << endl;
     return 0;
}  

2.最容易想到的最优化剪枝是，如果路虽未走完，但是已走的路的长度已大于已经存在的最优值了，那么就没有走下去的必要了。这样优化后80分，其它TLE.

#include<iostream>
#include<climits>
#include<cstring>
using namespace std;
const int MAXN=21;
int map[MAXN][MAXN];
bool vis[MAXN];
int n,minn=INT_MAX;
void dfs(int t,int tot,int count){
     if(tot > minn) return ;  //最优化剪枝
     if(count==n){
         if(map[t][1]){
             tot+=map[t][1];
             if(tot<minn){
                 minn=tot;           
            }
         }        
         return ;
     }
     for(int i=1;i<=n;i++)
         if(!vis[i]&&map[t][i])
         {            
             vis[i]=1;
             dfs(i,tot+map[t][i],count+1);
             vis[i]=0;
         }
     }
 int main(){
     cin >> n;
     for(int i=1;i<=n;i++)
         for(int j=1;j<=n;j++)
             cin >> map[i][j];
     vis[1]=1;
     dfs(1,0,1);    
     cout << minn << endl;
     return 0;
}  

3.优化得不够，需要进一步剪枝。新定义一个low数组，用来记录以每个点出发的最小值，并用sum来记录下所有理想下的最小值之各，在优化时满足已经走过的路+理想状态下剩余未走的路程 < 已有最优值时，才需要进一步住下走。这样之后能得90分，另外一个点TLE.

#include<iostream>
#include<climits>
#include<cstring>
using namespace std;
const int MAXN=21;
int map[MAXN][MAXN];
bool vis[MAXN];
int low[MAXN];
int n,minn=INT_MAX,sum;
void dfs(int t,int tot,int count){
     if(tot > minn) return ;
     if(count==n){
         if(map[t][1]){
             tot+=map[t][1];
             if(tot<minn){
                 minn=tot;           
            }
         }        
         return ;
     }
     for(int i=1;i<=n;i++)
         if(!vis[i]&&map[t][i]&&tot+map[t][i]+sum-low[t] < minn) {            
             vis[i]=1;
             sum -= low[t];
             dfs(i,tot+map[t][i],count+1);
             sum += low[t];
             vis[i]=0;
         }
     }
 int main(){
     cin >> n;
     for(int i=1;i<=n;i++){
        low[i] = INT_MAX;
        for(int j=1;j<=n;j++)   {
            cin >> map[i][j];
            if(i!=j && low[i] > map[i][j])  low[i] = map[i][j]; 
        }   
        sum += low[i];             
     }         
     vis[1]=1;
     dfs(1,0,1);    
     cout << minn << endl;
     return 0;
}  

4.最后看能否想办法让minn尽可能的出来的得早些，或者在前面尽可能出来接近最终解的值，这样在剪枝时效率会更高些，执行时间也就会少些。因此，可以考虑将每个点相接的每条边做一次升序排序，如从3出发到其它点的边，可以做个排序，对边值排序中需要将边的另一个端点一起跟着，不然就乱了，因此需要定义一个结构体，记录边值和对应边的端点值。做法：
（1）读数据时每次得到一行的值后对边值排序。
（2）在搜索时按边值从小到大的顺序搜，如果发现已走的路+新加入的边值后> 已有最优值，则return,不用继续搜这个点出发的其它边了，因为后边的边只会是越来越大的，再往下搜就没有意义了，因此果断剪枝。
代码如下：

#include<iostream>
#include<climits>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN=21;
struct node{
    int v,t;
};
node edge[MAXN][MAXN];
int map[MAXN][MAXN];
bool vis[MAXN];
int low[MAXN];
int n,minn=INT_MAX,sum;
void dfs(int t,int tot,int count){
    if(tot > minn) return ;
     if(count==n){
         if(map[t][1]){
             tot+=map[t][1];
             if(tot<minn){
                 minn=tot;           
            }
         }        
         return ;
     }
     for(int i=2;i<=n;i++)      //排完序后的第一个边值一定是0,也就是自已到自已的那个0边 
     {
        int v = edge[t][i].v;   //排完序后的 t号点出发的边中第i小的边的对应点 
        int w = edge[t][i].t;   //排完序后的 t号点出发的边中第i小的边的对应边权值 
        if(!vis[v]&&map[t][v]&&tot+map[t][v]+sum-low[t] < minn)  //注意现在搜索的新的点是v 
         {            
             if(tot+map[t][v] > minn)   //搜索剪枝 
                 return ; 
             vis[v]=1;
             sum -= low[t];
             dfs(v,tot+map[t][v],count+1);
             sum += low[t];
             vis[v]=0;
         }
     }         
 }
 int cmp(const node&a,const node &b){
    return a.t < b.t;
 }
 int main(){
     cin >> n;
     for(int i=1;i<=n;i++){
        low[i] = INT_MAX;
        for(int j=1;j<=n;j++){
            cin >> map[i][j];
            edge[i][j].v = j; edge[i][j].t = map[i][j];    //用结构体存边与点 
            if(i!=j && low[i] > map[i][j])  low[i] = map[i][j]; 
        }   
        sum += low[i];     
        sort(edge[i]+1,edge[i]+1+n,cmp);       //对i出发的所有边进行排序  
     }         
     vis[1]=1;
     dfs(1,0,1);    
     cout << minn << endl;
     return 0;
}