DP——状态压缩dp

状态压缩DP

蒙德里安的梦想

分析题目，当我们先摆横着放的方块，再摆放竖着放的方块，当横着放的小方块摆放完后，竖着放的方块也就确定了，因此总方案数应该等于只放横着的小方块的合法方案数。我们考虑每一列可以摆放成功的小方块，每一种情况可以由一个二进制数来表示，位数等于行数。我们用$f[i,j]$来表示第$i$列的第$j$个状态的合法方案数，可以知道$f[i,j]$可以由第$i-1$列的状态转移过来，只要第$i-1$列的第$k$个状态与第$i$列的第$j$个状态不重叠（$j$&$k$ == 0），且摆放之后不存在连续奇数个0（无法竖着摆放，方案不合法），就代表$f[i,j]$可以由$f[i-1,k]$转移过来，且$f[i,j]+=f[i-1,k]$.

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;

const int N = 12, M = 1 << 12;

int n, m;
long long f[N][M];
bool st[M];

int main()
{
    while(cin >> n >> m, n || m)
    {
        memset(f, 0, sizeof f);
        
        //预处理奇数个0的状态，将其标记
        for(int i = 0; i < 1 << n; i ++)
        {
            st[i] = true;
            int cnt = 0;
            //将每一位取出来
            for(int j = 0; j < n; j ++)
            {
                if(i >> j & 1)
                {
                    if(cnt & 1)
                    {
                        st[i] = false;
                        break;
                    }
                }
                else cnt ++;
            }
            if(cnt & 1) st[i] = false;
        }
        
        f[0][0] = 1; //第0列只有竖着摆放一种情况
        for(int i = 1; i <= m; i ++)
        {
            for(int j = 0; j < 1 << n; j ++)
            {
                for(int k = 0; k < 1 << n; k ++)
                {
                    //是否可以从i-1列的第k个状态转移过来
                    if((j & k) == 0 && st[j | k])
                    {
                        f[i][k] += f[i - 1][j];
                    }
                }
            }
        }
        
        //第m列全0，就代表0~m-1列已经摆放合法
        cout << f[m][0] << endl;
    }
    
    return 0;
}

最短Hamilton路径

如果我们依次枚举所有点，时间复杂度为$O(n!\ast n)$，因此我们用一个二进制的数来表示所有经过的情况，位数是1代表经过了这个点，我们还需要表示该种情况的终点是那个点，如000111表示经过了0到2号点，但我们并不知道终点是那个点，因此我们用$f[i,j]$来表示，当前经过了$i$个点且终点为$j$最小代价，$i$就是我们用来表示所有情况的二进制数。我们要求从0到$n-1$经过所有点，就代表$111...$这个状态且终点为$n-1$，我们可以思考该状态可以由那种状态转移过来，很显然是$011...$这状态，而我们知道$011...$这个状态是代表了很多终点不同的路径，我们只要枚举$011...$该状态下，以终点$k$结尾的路径再加上$k$到$j$的权重$w[k,j]$，求最小值即可。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 20, M = 1 << N;

int n;
int w[N][N];
int f[M][N];

int main()
{
    cin >> n;
    
    memset(w, 0x3f, sizeof w);
    for(int i = 0; i < n; i ++)
        for(int j = 0; j < n; j ++)
            cin >> w[i][j];
            
    memset(f, 0x3f, sizeof f);
    f[1][0] = 0; //初始时只有0号点
    for(int i = 0; i < 1 << n; i ++)
    {
        //枚举当前状态的最后一个点j
        for(int j = 0; j < n; j ++)
        {
            if((i >> j) & 1)
            {
                // i-(1<<j)是上一个状态，即j位上是0
                for(int k = 0; k < n; k ++)
                {
                    //枚举到上一个状态的终点k，求最小值
                    if(i - (1 << j) >> k & 1) 
                        f[i][j] = min(f[i][j], f[i - (1 << j)][k] + w[k][j]);
                }
            }
        }
    }
    
    cout << f[(1 << n) - 1][n - 1] << endl;
    return 0;
}