算法提高之动态规划：状态压缩dp

最新推荐文章于 2024-10-05 22:19:52 发布
最新推荐文章于 2024-10-05 22:19:52 发布
阅读量282 收藏 2
点赞数
分类专栏： 算法提高 文章标签： 算法 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37448336/article/details/122292195
版权
本文详细介绍了四种基于棋盘式和集合式的算法问题，包括小国王、玉米田、炮兵阵地和愤怒的小鸟。通过对每种问题的状态转移和合法状态的判断，实现动态规划求解。涉及到了位运算、状态压缩和二维滚动数组等技巧，旨在解决棋盘约束下的优化问题和覆盖问题。
摘要由CSDN通过智能技术生成

目录

0、概述

在这里插入图片描述
在这里插入图片描述
蒙德里安的梦想（棋盘式）
最短hamilton路径（集合式）

1、小国王（棋盘式 井字形 ）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

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

using namespace std;

typedef long long LL;

//N=12 为f[n+1][m][0]做铺垫  期初N=10 N+1=11 多开一维
const int N = 12, M = 1 << 10, K = 110;

int n, m;
//所有合法的状态
vector<int> state;
//每个状态中1的个数
int cnt[M];
//所有由i-1层 转化到i层的 i-1层1的状态
vector<int> head[M];
LL f[N][K][M];

//检查状态中是否存在两个连续的1
bool check(int state)
{
    for (int i = 0; i < n; i ++ )
        if ((state >> i & 1) && (state >> i + 1 & 1))
            return false;
    return true;
}
//求方案中1的个数
int count(int state)
{
    int res = 0;
    for (int i = 0; i < n; i ++ ) res += state >> i & 1;
    return res;
}

int main()
{
    cin >> n >> m;
	//处理合法状态
    for (int i = 0; i < 1 << n; i ++ )
        if (check(i))
        {
            state.push_back(i);
            cnt[i] = count(i);
        }
	//不同状态之间的关系
	//i和j分别表示第i层和第i-1层。且state中存储的是不相邻两个1的状态
    for (int i = 0; i < state.size(); i ++ )
        for (int j = 0; j < state.size(); j ++ )
        {
            int a = state[i], b = state[j];
            //第一个保证 同一列没有国王
            //第二个保证 a，b合并成一行，没有相邻的1
            if ((a & b) == 0 && check(a | b))
            	//对于第i层，i-1层这样摆是合法的，加入第i层的方案中	 
            	//保存的是合法方案在vector中的下标
                head[i].push_back(j);
        }
//所有只摆在前i行，已经摆了j个国王，且第i行摆放的状态是s的所有方案的集合
//前0行，一个国王都不摆，合法方案是0，的方案数为1
    f[0][0][0] = 1;
    //为f[n+1][m][0]做铺垫 i<=n+1
    for (int i = 1; i <= n + 1; i ++ )
        for (int j = 0; j <= m; j ++ )
        //枚举i层所有的合法方案 
            for (int a = 0; a < state.size(); a ++ )
            //对应i-1层的合法方案
                for (int b : head[a])
                {
                //求a中的国王个数
                    int c = cnt[state[a]];
                    if (j >= c)
                        f[i][j][a] += f[i - 1][j - c][b];
                }
//假设存在第n+1行，第n+1行一个没有摆 这样能够求出所有前n行摆放完毕的方案数
//在循环的时候，i<=n+1
//所有只摆在前n行，已经摆了m个国王，且第i行摆放的状态是没有摆的所有方案的集合
    cout << f[n + 1][m][0] << endl;

    return 0;
}

2、玉米田（棋盘式 十字形）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

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

using namespace std;

const int N = 14, M = 1 << 12, mod = 1e8;

int n, m;
int w[N];
//记录合法状态
vector<int> state;
//第i层是由哪些i-1层的状态转移而来的
vector<int> head[M];
int f[N][M];

bool check(int state)
{
    for (int i = 0; i  < m; i ++ )
        if ((state >> i & 1) && (state >> i + 1 & 1))
            return false;
    return true;
}

int main()
{
    cin >> n >> m;
    //初始化每行的状态
    for (int i = 1; i <= n; i ++ )
        for (int j = 0; j < m; j ++ )
        {
            int t;
            cin >> t;
            //记录某一行的所有状态
            //为1表示不可选，为0表示可选
            w[i] += !t * (1 << j);
        }
	//一行m列   保存玉米不相邻的状态
    for (int i = 0; i < 1 << m; i ++ )
        if (check(i))
            state.push_back(i);
	//记录能从i-1层到i层的所有合法方案 j转移到i
    for (int i = 0; i < state.size(); i ++ )
        for (int j = 0; j < state.size(); j ++ )
        {
            int a = state[i], b = state[j];
            if ((a & b)==0)
                head[i].push_back(j);
        }

    f[0][0] = 1;
    // f[n + 1][0] 枚举到n+1行为前者做铺垫
    for (int i = 1; i <= n + 1; i ++ )
        for (int j = 0; j < state.size(); j ++ )
            if (!(state[j] & w[i]))
                for (int k : head[j])
                    f[i][j] = (f[i][j] + f[i - 1][k]) % mod;

    cout << f[n + 1][0] << endl;

    return 0;
}

3、炮兵阵地（棋盘式）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
因为第i-1行与第i行已经确定，需要枚举第i-2行
在这里插入图片描述
在这里插入图片描述

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

using namespace std;

//N=10 每一行10个元素，10列。
//每一行所有格子的状态 M表示状态
const int M = 1 << 10;

int n, m;
//地图 100行，每行10个元素
int g[1010];

//f[i][j][k] 所有已经摆放完前i行，且第i-1行的状态是j，第i行的状态是k
//的所有摆放方案的最大值
//如果使用一般数组存储，第一维是100 M=1024 4(int)*100*1024*1024=400Mb
//空间限制是 64Mb 超出空间限制，需要使用二维的滚动数组存储 8Mb
int f[2][M][M];
//存储合法状态
vector<int> state;
int cnt[M];

bool check(int state)
{
    for (int i = 0; i < m; i ++ )
    //当前位置是1 后两个位置全是0
        if ((state >> i & 1) && ((state >> i + 1 & 1) || (state >> i + 2 & 1)))
            return false;
    return true;
}
//每一个二进制数中1的个数
int count(int state)
{
    int res = 0;
    for (int i = 0; i < m; i ++ )
        if (state >> i & 1)
            res ++ ;
    return res;
}

int main()
{
    cin >> n >> m;
    //将地图写成01的格式
    for (int i = 1; i <= n; i ++ )
        for (int j = 0; j < m; j ++ )
        {
            char c;
            cin >> c;
            //表示地图的每一行
            g[i] += (c == 'H') << j;
        }
	//找到所有每行两个炮至少隔两个空格的状态->合法状态
    for (int i = 0; i < 1 << m; i ++ )
        if (check(i))
        {
            state.push_back(i);
            cnt[i] = count(i);
        }
	//f[i][j][k] 所有已经摆放完前i行，且第i-1行的状态是j，第i行的状态是k
	//摆放前n+2行
    for (int i = 1; i <= n+2; i ++ )
    //i-1行状态
        for (int j = 0; j < state.size(); j ++ )
        	//i行状态
            for (int k = 0; k < state.size(); k ++ )
               //i-2行的状态
                for (int u = 0; u < state.size(); u ++ )
                {
                //a i-1行状态 b i行的状态  c i-2行的状态
                    int a = state[j], b = state[k], c = state[u];
                    if (a & b | a & c | b & c) continue;
                    //不用考虑i-1行与i-2行
                    if (g[i] & b) continue;
               //cnt[b] i行中炮的数量
               //f[i-1][u][j] 已经摆放完前i-1行，第i-2行是u，i-1行是j
               //&1 变成滚动数组  &1 奇数为1，偶数为0 奇偶交替计算
                    f[i & 1][j][k] = max(f[i & 1][j][k], f[i - 1 & 1][u][j] + cnt[b]);
                }
	//所有已经摆放完前n+2行，且第i-1行的状态是0，第i行的状态是0
	cout<<f[n+2&1][0][0]<<endl;
	/*  当i<=n时需要手动计算答案
    int res = 0;
    for (int i = 0; i < state.size(); i ++ )
        for (int j = 0; j < state.size(); j ++ )
            res = max(res, f[n & 1][i][j]);

    cout << res << endl;
	*/
    return 0;
}

4、愤怒的小鸟（集合式）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

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

#define x first
#define y second

using namespace std;

typedef pair<double, double> PDD;

const int N = 18, M = 1 << 18;
const double eps = 1e-8;


int n, m;
//记录所有点
PDD q[N];
//path[i][j] 表示第i个点和第j个点构成的抛物线能覆盖的点的状态
int path[N][N];
//M所有点的状态，需要抛物线的最小值
int f[M];


int cmp(double x, double y)
{
//浮点数比较需要误差容忍度
    if (fabs(x - y) < eps) return 0;
    if (x < y) return -1;
    //x>y
    return 1;
}

int main()
{
    int T;
    cin >> T;
    while (T -- )
    {
        cin >> n >> m;
        for (int i = 0; i < n; i ++ ) cin >> q[i].x >> q[i].y;

        memset(path, 0, sizeof path);
        for (int i = 0; i < n; i ++ )
        {
        //特判一下：对于i和j为同一个点时，状态中只有它一个点被覆盖
        //有些抛物线无法与其他点公用，只能单独占用一个点
            path[i][i] = 1 << i;
            for (int j = 0; j < n; j ++ )
            {
            //通过i和j两个点求抛物线的a和b
                double x1 = q[i].x, y1 = q[i].y;
                double x2 = q[j].x, y2 = q[j].y;
                //x1和x2不能相等
                if (!cmp(x1, x2)) continue;
                double a = (y1 / x1 - y2 / x2) / (x1 - x2);
                double b = y1 / x1 - a * x1;
				
				//确保是开口向下的抛物线 确保a为负数 a<0 
                if (cmp(a, 0) >= 0) continue;
                //枚举哪些点会被抛物线覆盖
                int state = 0;
                for (int k = 0; k < n; k ++ )
                {
                    double x = q[k].x, y = q[k].y;
                    if (!cmp(a * x * x + b * x, y)) state += 1 << k;
                }
                path[i][j] = state;
            }
        }

        memset(f, 0x3f, sizeof f);
        f[0] = 0;
        //枚举所有的状态 i+1  i不能是所有位置都为1的状态
        //1<<n  1，n个0 -1后->n个1  i不能为n个1 需要空余的列
        for (int i = 0; i < (1 << n)-1; i ++ )
        {
        	//从i中找到任意一个没有被覆盖的列
            int x = 0;
            for (int j = 0; j < n; j ++ )
            //这一位是0
                if (!(i >> j & 1))
                {
                    x = j;
                    break;
                }
			//枚举所有能覆盖掉x的抛物线
			//path[x][j] 第x个点 和第j个点构成的抛物线
            for (int j = 0; j < n; j ++ )
            	//新的状态  所求的结果是最小的小鸟数量
                f[i | path[x][j]] = min(f[i | path[x][j]], f[i] + 1);
        }
		//1后边n个0 -1后 变成 n个1
        cout << f[(1 << n) - 1] << endl;
    }

    return 0;
}
素位明哲
关注
专栏目录
动态规划-关于dp[i]含义的一点心得
m0_49190756的博客
03-11 892
关于dp[i]的含义，目前接触到的有两种： 第一种： dp[i]表示以索引i结尾的最大值，这种情况包含的结果内必须是i是最后一个元素，包括下标i之前的最大连续子序列和为dp[i]。 举例：leetcode53. 最大子数组和 给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 子数组 是数组中的一个连续部分。 示例 1： 输入：nums = [-2,1,-3,4,-1,2,1,-5,4] 输出：6 解释：连续子数组[4,-1,2,1.
暑假集训每日一题0720（状态压缩DP）
weixin_30595035的博客
07-20 81
Description 有N个点，有一个商人想经过所有的点恰好一次（商人最终不一定要回到起点），求商人需要走最短路程。 Input 两个整数N，M表示图的点数和边数，接下去有M行，每行三个整数a ,b ,c 表示从a到b有一条无向边，长度是c N<=15 c<=10000 Output 输出商人需要走过的最短距离 ,如果不能到达所有的点，输出-...
算法：状态压缩dp
m0_63997099的博客
05-01 1501
状态压缩dp实际上比其他dp要容易想一点，因为状态很容易定义，并且使用状压那么数据就必须很小比如int32位，longlong64位，数据大小最多那么大。是一种在解决某些特定类型的问题时非常有效的技术，特别是在涉及到限制状态或配置数量较多，但可以用整数或位操作来紧凑表示的情况。这种方法通常用于解决优化问题，特别是在图论、搜索问题、排列组合问题中非常常见，如旅行商问题（TSP）、位掩码问题等。状态压缩DP的核心思想是使用整数的二进制表示来表示复杂的状态集合。每一个比特位可以代表一个元素的某种状态（通常是存在或
动态规划：状态压缩DP入门（两道例题c++）
ylh的博客
02-08 783
状态压缩DP ， 糖果，最短路径 旅行商问题
状态压缩动态规划（State Compression DP）算法详解
TheJustice_的博客
06-26 1926
状态压缩DP的核心思想是利用位运算来表示和操作状态。可以用一个整数的二进制位来表示一个状态集合中的元素是否存在。例如，对于一个有 n 个元素的集合，可以用一个 n 位的二进制数表示其子集，其中第 i 位为1表示该子集包含第 i 个元素，为0则表示不包含。状态压缩DP是一种高效解决某些组合优化问题的技术，通过使用位运算来表示和操作状态，大大减少了状态空间的大小和复杂度。在理解和应用状态压缩DP时，关键在于正确表示和转移状态。希望通过本文的讲解和例题分析，能帮助读者更好地理解和应用这一算法。
动态规划——状态压缩dp
qq_57150526的博客
12-28 2801
状态压缩就是使用某种方法，简明扼要地以最小代价来表示某种状态，通常是用一串01数字（二进制数）来表示各个点的状态。这就要求使用状态压缩的对象的点的状态必须只有两种，0 或 1；当然如果有三种状态用三进制来表示也未尝不可。棋盘类型的题目一般要求我们依照一定的约束条件，摆放棋子，一般问棋子的数量、摆放的方案数。。。
每周一算法：状态压缩动态规划
少儿编程乔老师
11-04 681
状态压缩动态规划。状态压缩是指用二进制表示集合的方式对状态进行压缩，将其表示为一个整数。需要借助状态压缩实现状态表示的动态规划问题就称为状态压缩动态规划
动态规划之状态压缩dp入门
热门推荐
qxAi的博客
02-04 5万+
状态压缩动态规划（简称状压dp）是另一类非常典型的动态规划，通常使用在NP问题的小规模求解中，虽然是指数级别的复杂度，但速度比搜索快，其思想非常值得借鉴。 为了更好的理解状压dp，首先介绍位运算相关的知识。 1.’&’符号，x&y，会将两个十进制数在二进制下进行与运算，然后返回其十进制下的值。例如3(11)&2(10)=2(10)。 2.’|’符号，x|y，会将两个十进制数在二进制下进行或运
算法: 状态压缩DP
Wangpeiyi9979的博客
06-20 1021
文章目录什么是状态压缩DP常用位运算例题一: 旅行商问题例题二：Traveling by Stagecoach(Poj 2686) 什么是状态压缩DP DP，即动态规划，传统的动态规划都是基于整数的， 比如背包问题。定义状态dp[i][j]dp[i][j]dp[i][j]：背包容量为jjj时前iii件物品的最大收益。这里iii取整数。而对于状态压缩型的DP：动态规划是基于集合的，但是我们使用二进制...
算法学习系列（五十九）：状态压缩DP
weixin_60033897的博客
05-10 975
关于这个状态压缩 $DP$ 其实是挺难的，因为本身不好想，并且这个题目的多样性也比较多，一般有两类题：棋盘类和集合类，棋盘类就是精准覆盖问题，用规定的图形把整个棋盘完全覆盖有多少种方案，然后集合类目前见到的问题就是那个旅行问题了。棋盘问题只要学了再写其它类型的还是比较简单的，集合类目前就只会那个最短 $Hamilton$ 路径问题，其实考试估计也是只会这两种问题，再出就不会了，但是怎么说呢，万一出了呢，那就是别人不会我会，那就是赚了。还是得多练，然后搞清楚内在本质，加油吧！
动态规划：状态压缩DP - 愤怒的小鸟
07-09
### 动态规划：状态压缩DP - 愤怒的小鸟 #### 题目介绍 本题源自AcWing平台编号为524的题目《愤怒的小鸟》。题目要求寻找最少数量的抛物线，使得每条抛物线都能覆盖给定的一组点中的若干个点。具体而言，给定一组...
状压DP_C++_算法_状压_状态压缩DP_状压DP_
09-30
**状压DP（动态规划状态压缩）是一种在解决动态规划问题时优化空间复杂度的方法，尤其适用于当状态之间有大量重叠或者状态数量极其庞大时。C++是实现这一算法的常用编程语言，其强大的模板机制和高效性能使得在处理...
算法学习笔记：状态压缩 DP
Plozia 的小窝
03-02 393
算法学习笔记：状态压缩 DP1. 前言2. 详解3. 关于空间4. 练习题 1. 前言 状态压缩 DP，简称状压 DP，是一种 DP (废话)。 这种 DP 的特点就是通常与二进制有关（当然也可能是其他进制），通常复杂度为 2 的阶乘次级别。 状压 DP 的问题有两个鲜明的特征： 问题的数据规模特别小，2 的阶乘次可以通过。 题目通常都是选与不选两种选择，可以使用二进制串表示。 第 2 个是什么意思呢？ 打个比方，现在有 5 盘菜在你面前，编号 1-5，你此时想吃 1,3,4 号菜，那么就可以将你做的选
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1136
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
算法：按既定顺序创建目标数组
AWSDN的博客
09-29 248
本文主要介绍按既定顺序创建目标数组问题
DAY17||654.最大二叉树 |617.合并二叉树 |700.二叉搜索树中的搜索 |
2301_79865280的博客
09-29 1310
给定一个不含重复元素的整数数组。通过给定的数组构建最大二叉树，并且输出这个树的根节点。示例 ：构造二叉树一定要，因为要先找到中，才能分割左右子树。本题图解思路：本题做过上一题构建数组确实变得容易很多。代码优化方向有，不用每次找左右子树的时候构建新的数组的话效率就会高很多。（即直接用下标索引直接在原数组上操作）关于加不加if的问题，如果允许空节点进入递归，就不加。
class 004 选择 冒泡 插入排序
最新发布
2301_80967814的博客
10-05 246
我感觉这个真是没有什么好讲的, 这个是比较简单的, 感觉没有什么必要写一篇博客, 而且这个这么简单的排序问题肯定有人已经有写好的帖子了, 肯定写的比我好, 所以我推荐大家直接去看“左程云”老师的讲解就很好了, 一定是能看懂的, 要是用文字形式再写一遍, 反而有点画蛇添足了. 这里就将三个排序的代码写上.这三个排序算法中唯一需要注意的是：插入排序, 这个在小数据量的时候排序的速度是非常快的, 一般认为数组长度在10 ~ 50之间, 插入排序的效率是非常快的. 后续学习的Tim都有插入排序的参与.Tim。
算法讲解—最小生成树（Kruskal 算法）
ZH_qaq的博客
10-05 830
根据度娘的解释我们可以知道，最小生成树(Minimum Spanning Tree, MST)就是：一个有n个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有n个结点，并且有保持图连通的最少的边。简单点来说就是求最小的连通图，就是从一个点能到达图的任意一点，且花费的代价最小（所有边的权值最小）。最小生成树问题通常用于网络设计、电路设计等领域，目的是找到连接所有节点的最低成本方式。常见的算法有克鲁斯卡尔算法（Kruskal）和普里姆算法（Prim）等。
C - Separated Lunch
m0_74304371的博客
10-05 172
C - Separated Lunch(KEYENCE Programming Contest 2024 (AtCoder Beginner Contest 374))
动态规划详解：状态压缩dp与优化技术
"阮新波关于状态压缩dp的文章，讲解了动态规划在ACM竞赛中的应用和重要性，以及动态规划的定义和基本思想。文章提到了动态规划的三大性质：最优子结构、子问题重叠和无后效性，并列举了不同类型的dp问题，如简单基础...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值