蒙德里安的梦想

最新推荐文章于 2025-06-06 21:48:36 发布

＠_＠201

最新推荐文章于 2025-06-06 21:48:36 发布

阅读量282

点赞数

文章标签：动态规划算法 c++

本文链接：https://blog.youkuaiyun.com/weixin_63537536/article/details/131768822

版权

算法基础（蒟蒻的打卡）专栏收录该内容

71 篇文章

订阅专栏

文章描述了一个关于计算N×M棋盘能被分割成多少个1×2的长方形的问题，提出了使用动态规划和状态压缩的方法来解决。通过预处理非法状态和计算每列的状态转移，最终得出方案数。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目

求把 N×M 的棋盘分割成若干个 1×2 的长方形，有多少种方案。

例如当 N=2，M=4 时，共有 5 种方案。当 N=2，M=3 时，共有 3 种方案。

如下图所示：

输入格式

输入包含多组测试用例。

每组测试用例占一行，包含两个整数 N 和 M。

当输入用例 N=0，M=0 时，表示输入终止，且该用例无需处理。

输出格式

每个测试用例输出一个结果，每个结果占一行。

数据范围

1≤N,M≤11

输入样例：

输出样例：

AC代码

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

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

typedef long long LL;

LL f[N][M];
vector<int> state[M];
bool st[M];
int n, m;

int main(){
    while(cin >> n >> m, n || m)
    {
        //预处理1   将空余不是偶数个连续0的状态标记去除；
        for(int i = 0; i < (1 << n); i++)
        {
            int cnt = 0;        //计数连续个0的个数
            bool isvalid = true;//初始默认该状态有效（连续0为偶数）
            for(int j = 0; j < n; j++)//枚举每一列
            {
                if(i >> j & 1)  //i>>j表示i的第j位，该判断即表示当该位的状态为1时
                {
                    if(cnt & 1) //如果该位的状态为1，之前存在的连续0个数为奇数，则该状态无效
                    {
                        isvalid = false;
                        break;
                    }
                    cnt = 0;    //置零，进入下一次的计数
                }
                else cnt ++;
            }
            if(cnt & 1)isvalid = false;//之前存在的连续0个数为奇数，该状态无效
            st[i] = isvalid;    //打标记
        }
        
        //预处理2   将第i-1列的前一列i-2列中存在摆放重合的状态去除
        for(int i = 0; i < (1 << n); i++)
        {
            state[i].clear();
            for(int j = 0; j < (1 << n); j++)   //st[i|j]表示的是状态i与j组合后是否仍合法(即连续0的个数合法)
                if((i & j) == 0 && st[i | j])state[i].push_back(j);//真正合法的状态
        }
        
        //DP
        memset(f, 0, sizeof f);
        f[0][0] = 1;
        for(int i = 1; i <= m; i++)             //遍历每一列
            for(int j = 0; j < (1 << n); j++)   //遍历该列每一种状态
                for(auto k : state[j])          //获取合法的状态进行计算
                    f[i][j] += f[i - 1][k];
                
        cout << f[m][0] << endl;
    }
    
    return 0;
}