售货员的难题（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;
}