HDU 5067 动态规划---旅行商（tsp）问题

动态规划的状态有时不易表示，需要用一些编码技术把状态用简单的方式表示。一般数据n<16或者n<32很可能就是状态压缩dp法的标志，要注意好这些数据规模的提示作用。我们以TSP问题为例用状态压缩dp法解决。TSP问题(Traveling Salesman Problem)是数学领域中著名问题之一。假设有一个旅行商人要拜访N个城市，他必须选择所要走的路径，路径的限制是每个城市只能拜访一次，而且最后要回到原来出发的城市，要求路径的总和最小。其中，N<=16。
我们先考虑如何表示一个点集。由于只有16个点，所以我们用一个整数表示一个点集。例如5=0000 0000 0000 0101，它的第0位和第2位是1，就表示这个点集里有2个点，分别是点0和点2。

dp[S][v]中S表示已经访问过的顶点集合不包括起点0，v表示当前所在的顶点数组的值，dp[S][v]的值表示从v出发访问剩余的所有顶点最终回到顶点0的路径的权重总和的最小值。这样，dp[0][0]即为所求解。初始化时，除了dp[(1<<n)-1][0]=0之外，其余的值都是INF。状态转移方程如下。

状态压缩DP

DP过程中的状态不可能像背包问题一样只有整数，肯定有各种各样稀奇古怪的状态，需要不止一个变量来表示。这种情况下如果需要使用DP 就必须把状态压缩成一个数来表示，并且一个数只能对应于一种状态。

特别地，对于集合我们可以把每一个元素的选取与否对应到一个二进制位里，从而把状态压缩成一个整数，大大方便了计算和维护。

对于不是整数的情况，很多时候很难确定一个合适的递推顺序，因此使用记忆化搜索可以避免这个问题。如下面TSP问题的法一。

TSP问题

一张图上有n个点，给定相应的邻接矩阵，需要求出从0号节点出发，经过且只经过每个顶点一次，最后仍回到0号节点的最小边权。TSP问题可以用状压DP来快速求解。

定义dp[S][v]为已经经过了点集S之后，目前在点v(v已经包含在S中)，回到0节点的最小边权。 
所以有如下的递推公式

---

**dp[V[0] = 0 
dp[S][v] = min(dp[S∪{u}][u]+d[v][u])(其中u不属于S)**

---

将S看作一个长度为n的bit流，第几号节点访问过就把S的第几号节点置为1，其他都是0，这样就可以将状态压缩成了一个数字来表示，并且有一一对应性。

采用记忆化搜索的TSP状压DP代码如下

int n;
int d[maxn][maxn];
int dp[1<<maxn][maxn];
int rec(int S,int v)
{
    if(dp[S][v] >= 0) {
        return dp[S][v];
    }
    if(v == 0 && S == (1<<maxn)-1) return dp[S][v] = 0;
    int ans = INF;
    for(int i = 0 ; i < n ; i ++) {
        if(!(S>>i&1)) {
            ans = min(ans,d[v][i]+rec(S|(1<<i),i));
        }
    }
    return dp[S][v] = ans;
}
void solve(void)
{
    memset(dp,-1,sizoef(dp));
    cout << rec(0,0) << endl;
}

此外也可以不用记忆化搜索，观察递推的顺序从而使用循环求解。 

发现对于任意的两个整数i和j 如果它们对应的集合满足S(i)包含于S(j) 那么i<=j。

代码如下

int dp[1<<maxn][maxn];
void solve()
{
    for(int i = 0 ; i < (1<<n) ; i ++) {
        fill(dp[S],dp[S]+n,INF);
    }
    dp[(1<<n)-1][0] = 0;
    for(int S = (1<<n)-1 ; S >= 0 ; S --) {
        for(int i = 0 ; i < n ; i ++) {
            for(int j = 0 ; j < n ; j ++) {
                if(!(S>>j&1))
                    dp[S][i] = min(dp[S][i],dp[S|1<<j][j]+d[i][j]);
            }
        }
    }
    cout << dp[0][0] << endl;
}

HDU 5067的状压dp代码

#include <iostream>
#include <stdio.h>
#include <cmath>
#include <cstring>
#include <algorithm>

using namespace std;

#define ll long long
#define LL long long
#define inf 0x3f3f3f3f

int a[150][150];
int dp[(1<<11)][20];
int xx[20],yy[20];

int cnt;

int dfs(int num,int now)
{
    if(dp[num][now]!=-1) return dp[num][now];
    int t=num;
    int ret=inf;
    for(int i=0;i<cnt;i++)
    {
        if(!((num>>i)&1))
        {
            int t=num+(1<<i);
            int ans=dfs(t,i)+abs(xx[i]-xx[now])+abs(yy[i]-yy[now]);
            ret=min(ans,ret);
        }
    }
    if(ret==inf)return dp[num][now]=xx[now]+yy[now];
    return dp[num][now]=ret;
}

int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m))
    {
        memset(a,0,sizeof(a));
        cnt=0;
        xx[0]=yy[0]=0;
        cnt++;
        memset(dp,-1,sizeof(dp));
        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
            {
                int t;
                scanf("%d",&t);
                if(t)
                {
                    xx[cnt]=i,yy[cnt]=j;
                    a[i][j]=cnt++;
                }
            }
            printf("%d\n",dfs(1,0));
    }
    return 0;
}

HDU 5067 DFS爆搜加剪枝代码

#include <iostream>
#include <stdio.h>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <queue>
#include <map>
#include <stack>
#define inf 0x3f3f3f3f

using namespace std;

typedef long long ll;

int p[15][2];
int ans,cnt;
int vis[15];
void dfs(int x, int y,int now,int dis)
{
    if(dis>=ans)
        return ;
    if(now==cnt)
    {
        ans=min(ans,dis+x+y);
        return ;
    }

    for(int i=0;i<cnt;i++)
    {
        if(vis[i]==0)
        {
            vis[i]=1;
            int dist=dis+abs(x-p[i][0])+abs(y-p[i][1]);
            dfs(p[i][0],p[i][1],now+1,dist);
            vis[i]=0;
        }
    }

}

int main()
{
    int n,m,tmp;
    while(~scanf("%d%d",&n,&m))
    {
        cnt=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                scanf("%d",&tmp);
                if(i==0&&j==0)
                    continue;
                if(tmp!=0)
                {
                    p[cnt][0]=i;
                    p[cnt++][1]=j;
                }
            }
        }
        memset(vis,0,sizeof(vis));
        ans=10000000;
        dfs(0,0,0,0);
        printf("%d\n",ans);
    }
    return 0;
}