动态规划——状态压缩dp

acwing291.蒙德里安的梦想

#include<iostream>
#include<cstring>

using namespace std;

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

long long int f[N][M]; //f[i][j]表示第i列j状态有多少个可行解
int n, m;
bool st[M]; //st[i]表示合并列的状态i是否合法

int main()
{
    while(cin >> n >> m, n || m)
    {
        //预处理判断合并列的状态i是否合法
        //合并列的某行是1表示横放,是0表示竖放、
        //如果合并列不存在连续的奇数个0,即为合法状态
        for(int i = 0; i < 1 << n; i ++ ) //枚举从0到2^n个状态
        {
            st[i] = true;
            int cnt = 0; //记录合并列中连续0的个数
            for(int j = 0; j < n; j ++ ) //枚举每一位
            {
                if(i >> j & 1) //如果第j位等于1,进入判断,判断是不是有奇数个0
                {
                    if(cnt & 1) //如果有奇数个0,该状态不合法
                    {
                        st[i] = false; //记录i状态不合法
                        break;
                    }
                }
                else cnt ++ ; //如果是0,记录0的个数
            }
            if(cnt & 1) st[i] = false; //判断前面没1了的最高位0奇偶情况
        }   

        //状态计算
        memset(f, 0, sizeof f);
        f[0][0] = 1; //第i列不横放是一种合法的方案
        for(int i = 1; i <= m; i ++ ) //枚举列
            for(int j = 0; j < 1 << n; j ++ ) //枚举第i列的所有状态
                for(int k = 0; k < 1 << n; k ++ ) //枚举第i - 1列的状态
                    //两列状态兼容:不出现重叠的1、不出现连续的奇数0
                    if((j & k) == 0 && st[j | k]) f[i][j] += f[i - 1][k];

        cout << f[m][0] << endl; //第m列不横放,即答案
    }


    return 0;
}

acwing91.最短hamilton路径

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;

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

int n;
int weight[N][N];

//第一维:哪些点被用过(用二进制表示(状态压缩)),第二维:目前停在哪个点上
int f[M][N]; //状态是i的情况下停在点j的最短路径

int main()
{
    cin >> n;
    for(int i = 0; i < n; i ++ )
        for(int j = 0; j < n; j ++ )
            cin >> weight[i][j];
            
    memset(f, 0x3f, sizeof f);
    f[1][0] = 0;
    
    for(int i = 0; i < 1 << n; i ++ )
        for(int j = 0; j < n; j ++ )
            if(i >> j & 1) //i的第j为是否被用过
                for(int k = 0; k < n; k ++ )
                    if(i - (1 << j) >> k & 1)
                        f[i][j] = min(f[i][j], f[i - (1 << j)][k] + weight[k][j]);
                        
    cout << f[(1 << n) - 1][n - 1] << endl;
    return 0;
}