HDU 3001 Traveling (状压DP)*

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3001

#include<bits/stdc++.h>
using namespace std;

#define debug puts("YES");
#define rep(x,y,z) for(int (x)=(y);(x)<(z);(x)++)
#define read(x,y) scanf("%d%d",&x,&y)
#define ll long long

#define lrt int l,int r,int rt
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define root l,r,rt
const int  maxn =1e6+5;
const int mod=1e9+7;
///const int INF = 1e6;
const int INF=252645135;
ll powmod(ll x,ll y){ll t; for(t=1;y;y>>=1,x=x*x%mod) if(y&1) t=t*x%mod; return t;}
ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
/*
题目大意：类似TSP，求出所有城市遍历到后的最短路径距离。

因为一个城市不能经过超过两次，
所以要用三进制压缩下，
当然，需要手动确定枚举位置。

还是老套路，用前面的状态更新以后的状态，
最外层从小到大枚举所有三进制状态是肯定的，
那么下面如何枚举点来，确定当前位置和下一步位置的关系呢，

首先几个条件要清楚，第一层枚举的状态中作为末尾的点必须存在，
当前状态DP值必须要有实际意义，第二层枚举点时，
该层点经过次数有限定，并且要有边链接关系，这些细节带着代码区看吧。

这道题为了扩展状态的方便，dp方程表达为二维，
因为这道题二维状态才可以确定一个最优值，
dp[i][j]表示在i三进制状态中走到j点的最优值是多少。

*/

int n,m,g[20][20];
int x,y,z;
int p3[20];
int ans;

int dp[60000][11];///i状态目前走到j的最优值
bool judge(int x)
{
    int cnt=0;
    while(x) {if(x%3) cnt++;x/=3;}
    return cnt==n;
}

int main()
{
    p3[0]=1;for(int i=1;i<15;i++) p3[i]=p3[i-1]*3;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        memset(g,-1,sizeof(g));
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&x,&y,&z);
            if(g[x][y]==-1||z<g[x][y]) g[x][y]=g[y][x]=z;///保留最小的
        }

       memset(dp,0xf,sizeof(dp));
        for(int i=1;i<=n;i++) dp[p3[i-1]][i]=0;///初始化数组

        ans=INF;
        for(int i=0;i<p3[n];i++)
        {
            for(int j=1;j<=n;j++)
            {
                int cur=i;for(int k=1;k<j;k++) cur/=3;
                if(cur%3==0) continue;///当前位置没有到达
                if(dp[i][j]==INF) continue;///当前状态不可到达
                for(int k=1;k<=n;k++)
                {
                    int cur=i,tp=1;for(int p=1;p<k;p++) cur/=3,tp*=3;
                    if(k==j) continue;
                    if(g[k][j]==-1) continue;
                    if(cur%3>=2) continue;///一条路不能走超过两次
                    if(dp[i+tp][k]>dp[i][j]+g[k][j]) dp[i+tp][k]=dp[i][j]+g[k][j];
                }
            }
            if(judge(i))  for(int j=1;j<=n;j++) ans=min(ans,dp[i][j]);
        }
        if(ans==INF) puts("-1");
        else printf("%d\n",ans);
    }
    return 0;
}