动态规划dpの状态压缩——蒙德里安的梦想,最短Hamilton路径，小国王，玉米地，炮兵阵地

蒙德里安的梦想

dp（1/100）
思路之前笼统地写过，第E题 具体看注释

#include
using namespace std;
typedef long long LL;
const int N = 12, M = 1 << N;
LL f[N][M];
bool st[M];

int main()
{
	int n, m;
	while(cin >> n >> m, n || m){
		//预处理连续偶数个0的状态为true，连续奇数个0的状态为false 
		for(int i = 0; i < 1 << n; i ++ ){
			int cnt = 0;
			st[i] = true;
			for(int j = 0; j < n; j ++ ){
				if(i >> j & 1){
					if(cnt & 1) st[i] = false;
					cnt = 0;
				}else cnt ++;
			}
			if(cnt & 1) st[i] = false;
		}
		
		memset(f, 0, sizeof f);
		f[0][0] = 1; //第1列不会有前面的第0列向他伸出小方块，所以第1列只有是0才有一种方案 
		//相当于表示当空棋盘的时候有一种方案（n=0，m=0） 
		for(int i = 1; i <= m; i ++ )  //枚举第2列到第m+1列 
			for(int j = 0; j < 1 << n; j ++ ) //两层暴力找当前状态和上一个状态 
				for(int k = 0; k < 1 << n; k ++ )
					if((j & k) == 0 && st[j | k]) //当j和k某位都是1，表示在这个位置都有小方块捅进来，方块重叠
												//j|k表示空位，如果st也为true则为一个合法的转换条件 
						f[i][j] += f[i - 1][k];
		//第m+1列没有小方块捅进来，即0状态的时候，为合法方案 
		cout << f[m][0] << endl;
	}	
	return 0;
 } 

玉米地

dp(4/100)
思路：f[i][j]表示已经摆好了前 i - 1行，第i行的状态是 j 的方案数

#include 
using namespace std;
const int N = 14, M = 1 << 12, mod = 1e8;
int g[N];
vector<int> h[M];
vector<int> st;
int f[N][M];
int n, m;

//判断没有没有两个相邻的1
bool check(int x){
    return !(x & (x >> 1));
}

int main()
{
    cin >> n >> m;
    //技巧：把土地的情况也处理成二进制数，只有就可以通过相与来判断是否种植在了土地贫瘠的地方
    for (int i = 1; i <= n; i ++ )
        for (int j = 0; j < m; j ++ ){
            int x;
            cin >> x;
            g[i] <<= 1;
            g[i] += !x;
        }
        
    for (int i = 0; i < 1 << m; i ++ )
        if(check(i)) st.push_back(i);
        
    for (int i = 0; i < st.size(); i ++ )
        for (int j = 0; j < st.size(); j ++ )
            if((st[i] & st[j]) == 0) h[i].push_back(j);
        
    f[0][0] = 1; //初始不放玉米也是一种方案
    //枚举到第n + 1行是为了，摆前n行的方案数最大值，相当于摆到第n + 1行，第n + 1行不种玉米的最大方案数
    for (int i = 1; i <= n + 1; i ++ )
        for (int j = 0; j < st.size(); j ++){
            if(st[j] & g[i]) continue; //如果种到了土地贫瘠的地方就跳过这个状态
            for(int k : h[j])
                f[i][j] = (f[i][j] + f[i - 1][k]) % mod;
        }
        
    cout << f[n + 1][0] << endl;
    return 0;
}

小国王

dp(3/100)
思路：f[i][j][s]表示只摆在前i行，已经摆了j个国王，第i行摆放的状态是s的方案数

#include
using namespace std;
const int N = 12, M = 1 << 10, K = 110;
#define int long long
int n, m;
int f[N][K][M], cnt[M]; //cnt中存是状态放国王的个数，即二进制表示中1的个数
vector<int> st; //st中存的是预处理出来的合法状态数
vector<int> h[M]; //h[a]中存的是合法状态a可以转化到的状态

//检查是否没有连续的两个国王，即二进制表示中两个1挨在一起（11001）
bool check(int x)
{
    for (int i = 0; i < n; i ++ )
        if ((x >> i) & 1 && (x >> i + 1) & 1) return false;
    return true;
}

//计算状态中放置的国王数，即二进制表示中1的个数
int count(int x)
{
    int ans = 0;
    for(int i = 0; i < n; i ++ ) ans += x >> i & 1;
    return ans;
}

signed main()
{
    cin >> n >> m;
    for (int i = 0; i < 1 << n; i ++ )
        //预处理，把符合条件的状态push到st中，同时计算该状态的cnt
        if (check(i)){
            st.push_back(i);
            cnt[i] = count(i);
        }
    
    for(int i = 0; i < st.size(); i ++ ) //枚举每个状态
        for(int j = 0; j < st.size(); j ++ ){
            int a = st[i], b = st[j];
            //上下两行没有国王相邻以及斜角相邻，则上一行状态可以转化成下一行状态
            if((a & b) == 0 && check(a | b))
                h[a].push_back(b);//这里方便理解直接存的是状态，可以优化为存状态在st中的下标
                                    //那样在下面动态规划第三层循环为a < st.size()
        }
        
    f[0][0][0] = 1;//初始一个国王也没放，状态为00000，有一种方案
    
    //技巧：如果枚举到i = n，则最大值需要遍历最后一行得出
    //如果枚举到再往下一行，则课直接输出第n+1行状态为00000，摆放了m个国王的数量
    for (int i = 1; i <= n + 1; i ++ )
        for (int j = 0; j <= m; j ++ ) 
            for (int a = 0; a < 1 << n; a ++ )
                for (auto b : h[a]){ //遍历该状态可以转换的到的状态
                    int c = cnt[a];
                    if(j >= c) f[i][j][a] += f[i - 1][j - c][b];
                }
    cout << f[n + 1][m][0] << endl;
    return 0;
}

炮兵阵地

dp(5/100)
思路：该问题不同于前两个问题，由于炮兵的攻击范围是上下左右分别两个格子，所以除了当前行的状态，还需要记录上一行的状态。三维数组很有可能会存储空间超限，所以需要使用到滚动数组技巧。
f[i,j,k]表示第i行的状态是k，第i-1行的状态是j，所摆放的炮兵最大值

#include 
using namespace std;
const int N = 12, M = 1 << 10, K = 110;
//f[i,j,k]表示第i行的状态是k，第i-1行的状态是j，所摆放的炮兵最大值
int f[2][M][M]; //技巧：因为只用到上一行的状态所以用滚动数组，直接按奇偶划分当前行和上一行
int cnt[M]; //记录每个状态中1的个数
vector<int> st; //合法的状态
int n, m;
int g[K];//用二进制数表示每一行的高地状态

bool check(int x){
    if(x & (x << 1)) return false;
    if(x & (x << 2)) return false;
    return true;
}

int count(int x){
    int res = 0;
    while(x){
        if(x & 1) res ++;
        x >>= 1;
    }
    return res;
}

int main()
{
    cin >> n >> m;
    for(int i = 1; i <= n; i ++ )
        for(int j = 0; j < m; j ++ ){
            char x; 
            cin >> x;
            g[i] <<= 1;
            if(x == 'H') g[i] ++;
        }
        
    for(int i = 0; i < 1 << m; i ++ )
        if(check(i)){
            st.push_back(i);
            cnt[i] = count(i);
        }
    
    for(int i = 1; i <= n + 2; i ++ ) //计算到第几行了
        for(int j = 0; j < st.size(); j ++ ) //遍历上一行的状态
            for(int k = 0; k < st.size(); k ++ ) //遍历当前行的状态
                for(int u = 0; u < st.size(); u ++ ){ //遍历上上行的状态
                    int a = st[j], b = st[k], c = st[u];
                    if(a & b | a & c | b & c) continue; //如果当前行和前一行或前两行能互相攻击到以及前一行和前前行能相互攻击到，不合法
                    if(g[i] & b | g[i - 1] & a) continue; //如果当前行或者上一行有炮放在了山地上则不合法
                    f[i & 1][j][k] = max(f[i & 1][j][k], f[i - 1 & 1][u][j] + cnt[b]); //到第i行的炮兵数为合法的第i-1行数量加上第i行放置数量取max
                }
    //前n行的最大放置数量等同于前n+2行第n+1和第n+2行状态都为00000（不放置炮兵）的数量
    cout << f[n + 2 & 1][0][0] << endl;
    return 0;
}

最短Hamilton路径

dp(2/100)
思路:
f[i,j]表示从0走到 j，走过的点状态是 i 的路径最小值。例如 i 为 11001,1表示经过的点，0表示尚未走过的点。

#include
using namespace std;
const int N = 20, M = 1 << N;
int f[M][N], w[N][N];

int main()
{
    int n;
    cin >> n;
    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走到0（走过第0点的状态为000001），距离是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 >> k & 1)//i状态包含第k点
                        f[i][j] = min(f[i][j], f[i-(1<<j)][k] + w[k][j]);
    
    //		f[(11111111)B][n-1]
    cout << f[(1 << n) - 1][n - 1] << endl;
    return 0;
}