旅行售货员问题（搜索优化，状态压缩）

旅行售货员问题

Description
旅行售货员问题又称TSP问题，问题如下：某售货员要到若干个城市推销商品，已知各城市之间的路程（或旅费），他要选定一条从驻地出发，经过每个城市一遍最后回到驻地的路线，使总的路线（或总的旅费）最小。数学模型为给定一个无向图，求遍历每一个顶点一次且仅一次的一条回路，最后回到起点的最小花费。

Input
输入的第一行为测试样例的个数T，接下来有T个测试样例。

每个测试样例的第一行是无向图的顶点数n、边数m（ 1 < n ≤ 18，m < n×n ），接下来m行，每行三个整数u、v和w，表示顶点u和v之间有一条权值为w的边相连。（ 1 ≤ u < v ≤ n，w ≤ 1000 ）。假设起点（驻地）为1号顶点。

Output
对应每个测试样例输出一行，格式为"Case #: W"，其中’#'表示第几个测试样例（从1开始计），W为TSP问题的最优解，如果找不到可行方案则输出-1。

Sample Input
2
5 8
1 2 5
1 4 7
1 5 9
2 3 10
2 4 3
2 5 6
3 4 8
4 5 4
3 1
1 2 10

Sample Output
Case 1: 36
Case 2: -1

dfs单源最短路径优化

#include<bits/stdc++.h>
using namespace std;
int a[20][20],vis[20];
vector<int>q[20];
int dis[20];
int sum;
void dfs(int i,int n,int s,int len)//i:点 n:有多少个点 s：已搜索了多少个点 len：路径长度
{
    if(s==n)
    {
        if(a[i][1]!=-1)
        {
            sum=min(sum,a[i][1]+len);
        }
        return;
    }
    for(int j=0; j<q[i].size(); j++)
    {
        int v=q[i][j];
        if(vis[v]==0&&len+a[i][v]+dis[v]<sum)
        {
            vis[v]=1;
            dfs(v,n,s+1,len+a[i][v]);
            vis[v]=0;
        }
    }
}
int main()
{
    int n,t,m;
    cin>>t;
    for(int i=1; i<=t; i++)
    {
        cin>>n>>m;
        sum=INT_MAX;
        memset(vis,0,sizeof(vis));
        memset(a,-1,sizeof(a));
        for(int j=1; j<=n; j++)
            q[j].clear();
        for(int j=1; j<=m; j++)
        {
            int x,y,z;
            cin>>x>>y>>z;
            q[x].push_back(y);
            q[y].push_back(x);
            a[x][y]=z;
            a[y][x]=z;
        }
        for(int j=1; j<=n; j++)
        {
            dis[j]=a[1][j]==-1? INT_MAX:a[1][j];
        }
        vis[1]=1;
        while(true)//求单源最短路径
        {
            int u=-1,maxlen=INT_MAX;
            for(int j=1; j<=n; j++)
            {
                if(vis[j]==0&&maxlen>dis[j])
                {
                    u=j;
                    maxlen=dis[j];
                }
            }
            if(u==-1)
                break;
            vis[u]=1;
            for(int j=1; j<=n; j++)
            {
                if(a[u][j]!=-1&&dis[u]+a[u][j]<dis[j])
                    dis[j]=dis[u]+a[u][j];
            }
        }
        int f=0;
        for(int j=2; j<=n; j++)
        {
            if(dis[j]==INT_MAX)//如果1不能到达某个点则没有可行方案
            {
                f=1;
                break;
            }
        }
        if(f==1)
        {
            cout<<"Case "<<i<<": "<<"-1"<<endl;
            continue;
        }
        memset(vis,0,sizeof(vis));
        vis[1]=1;
        dfs(1,n,1,0);
        if(sum==INT_MAX)
            sum=-1;
        cout<<"Case "<<i<<": "<<sum<<endl;
    }
}

状态压缩dp

/*dp[i][0]表示i点经过0个点回到0点的最短路径*/
#include<bits/stdc++.h>
using namespace std;
#define inf 0x3f3f3f3f
int a[18][18],dp[18][1<<18];
int main()
{
    int n,t,m;
    cin>>t;
    for(int i=1;i<=t;i++)
    {
        cin>>n>>m;
        int sum=-1;
        memset(dp,inf,sizeof(dp));
        memset(a,inf,sizeof(a));
        for(int j=1;j<=m;j++)
        {
            int x,y,z;
            cin>>x>>y>>z;
            a[x-1][y-1]=z;
            a[y-1][x-1]=z;
        }
        for(int j=0;j<n;j++)
            dp[j][0]=a[j][0];
        for(int j=1;j<(1<<n);j++)
        {
            for(int u=0;u<n;u++)
            {
                for(int v=0;v<n;v++)
                {
                    if((j>>v)&1)
                    {
                        dp[u][j]=min(dp[u][j],dp[v][~(1<<v)&j]+a[u][v]);
                    }
                }
            }
        }
        if(dp[0][(1<<n)-2]!=inf)
            sum=dp[0][(1<<n)-2];
        cout<<"Case "<<i<<": "<<sum<<endl;
    }
}