数据结构与算法之状压DP剪枝

躺平的小懒猫

于 2023-09-19 10:58:31 发布

阅读量110

点赞数

分类专栏：数据结构与算法文章标签：剪枝算法机器学习

本文链接：https://blog.csdn.net/weixin_47225948/article/details/133018621

版权

数据结构与算法专栏收录该内容

86 篇文章 2 订阅

订阅专栏

数据结构与算法之状压DP剪枝

一、C 状压DP剪枝源码实现及详解
二、C++ 状压DP剪枝源码实现及详解
三、java 状压DP剪枝源码实现及详解

状压DP（State Compressed Dynamic Programming）是一种常用的动态规划算法，用于解决状态空间较大的问题。其核心思想是将状态用二进制数表示，以减少存储空间和计算时间。状压DP常用于求解集合、排列、子集等问题。

在状压DP的算法中，剪枝是一种常用的优化技巧。剪枝可以大大减少搜索的次数，提高求解效率。

剪枝的原理是基于以下观察：

有些状态是无法到达的，因为它们不满足问题的约束条件。
有些状态可以被其它更优的状态替代，因此不需要计算它们。

基于以上观察，可以在状态转移中加入一些判断条件，判断某些状态是否需要进行计算。这种判断条件就叫做剪枝。

例如，在求解旅行商问题（TSP）时，可以通过判断当前走过的路径长度是否已经超过最优解，来进行剪枝。如果当前路径长度已经大于最优解，那么后续搜索就可以停止，因为后续路径长度一定会更大。

另外，还可以通过预处理一些数据，来减少搜索的次数。例如，在求解子集和问题时，可以预处理出每个数在所有子集中的状态，以避免重复计算。

总之，剪枝在状压DP中是一种非常有效的优化技巧，可以大大提高算法的求解效率。

在这里插入图片描述

一、C 状压DP剪枝源码实现及详解

什么是状态压缩DP？
状态压缩DP是一种基于状态压缩的动态规划算法，它的基本思想是将一个状态用一个整数来表示，从而避免使用数组来存储状态，达到优化空间效果的目的。
为什么需要状态压缩DP？
在一些特殊的问题中，状态的数目非常大，甚至超出了计算机的存储容量，无法使用数组来存储状态，这时就需要用到状态压缩DP来解决这些问题。
状态压缩DP的实现方式
状态压缩DP的实现方式有两种，一种是使用二进制位来表示状态，另一种是使用其他进制来表示状态，如八进制、十六进制等。这里我们以使用二进制位来表示状态为例进行讲解。
C语言状态压缩DP剪枝代码实现
下面是一个使用C语言实现的状态压缩DP剪枝代码实现。该代码实现了求解给定长度为N的01字符串中包含连续1的子串数目的问题。

#include<stdio.h>
#include<string.h>
#define MAXN 25
#define max(a,b) ((a)>(b)?(a):(b))

int N,a[MAXN],f[1<<MAXN],ans=0;

int main()
{
    scanf("%d",&N);
    for(int i=0;i<N;i++)
        scanf("%d",&a[i]);
    for(int i=0;i<N;i++)
    {
        if(a[i]==1)
        {
            int j=i;
            while(j<N&&a[j]==1) j++;
            for(int k=i;k<j;k++)
                f[1<<k]=1;
            i=j-1;
        }
    }
    for(int i=0;i<(1<<N);i++)
    {
        if(f[i])
        {
            for(int j=0;j<N;j++)
            {
                if((i>>j)&1)
                {
                    if((i>>(j+1)&1)) f[i|(1<<j)]=1;
                }
            }
        }
    }
    for(int i=0;i<(1<<N);i++)
    {
        int cnt=0;
        for(int j=0;j<N;j++)
        {
            if((i>>j)&1) cnt++;
        }
        if(f[i]) ans=max(ans,cnt);
    }
    printf("%d\n",ans);
    return 0;
}

状态压缩DP剪枝代码实现详解
下面对代码中的各个部分进行详细解释。

（1）定义变量和常量

#define MAXN 25
#define max(a,b) ((a)>(b)?(a):(b))

int N,a[MAXN],f[1<<MAXN],ans=0;

MAXN为字符串最大长度，a数组用来存储输入的字符串，f数组用来存储状态转移的结果，ans为最终结果。

（2）读入字符串

scanf("%d",&N);
for(int i=0;i<N;i++)
    scanf("%d",&a[i]);

读入字符串长度和字符串。

（3）预处理连续1的子串

for(int i=0;i<N;i++)
{
    if(a[i]==1)
    {
        int j=i;
        while(j<N&&a[j]==1) j++;
        for(int k=i;k<j;k++)
            f[1<<k]=1;
        i=j-1;
    }
}

将连续1的子串转换为对应的状态，并将该状态的值设为1，表示该状态是合法的。

（4）状态转移

for(int i=0;i<(1<<N);i++)
{
    if(f[i])
    {
        for(int j=0;j<N;j++)
        {
            if((i>>j)&1)
            {
                if((i>>(j+1)&1)) f[i|(1<<j)]=1;
            }
        }
    }
}

对于每个合法的状态i，在该状态的基础上转移出新的合法状态。具体的转移方式是，如果该状态中存在连续的两个1，即第j位和第j+1位均为1，则将该状态i中第j+1位设为1，得到新的状态i|(1<<j)，并将该状态的值设为1，表示该状态是合法的。

（5）统计结果

for(int i=0;i<(1<<N);i++)
{
    int cnt=0;
    for(int j=0;j<N;j++)
    {
        if((i>>j)&1) cnt++;
    }
    if(f[i]) ans=max(ans,cnt);
}

遍历所有状态i，统计其中二进制位为1的个数cnt，并将结果与之前的最大值ans取最大值，最终得到答案。

总结
状态压缩DP是一种非常有效的动态规划算法，特别适用于状态数目非常庞大的问题。在实现状态压缩DP时，需要注意状态的定义、状态转移和结果统计等方面的细节，才能得到正确的结果。

在这里插入图片描述

二、C++ 状压DP剪枝源码实现及详解

状压DP是一种常用的动态规划算法，特别适用于某些具有二进制状态的问题，比如选取一个由n个元素组成的集合的子集，用二进制的1和0来表示是否选择了某个元素。在这里，我们将详细讨论一下C++中的状压DP剪枝实现方法。

状态压缩

位运算是实现状压DP的关键，它可以将集合压缩成一个二进制数。例如，假设我们有一个集合S = {1,2,3,4}，其中元素1和3被选择，那么我们可以用二进制数1010（十进制数10）来表示这个集合。

那么，一个大小为n的集合的所有子集都可以用一个n位的二进制数表示，其中第i位表示集合中第i个元素是否被选择。比如， $S=\{1,2,3\}$ ，则子集 ${1,2\}$ 可以表示为二进制数101，也就是5。

状态转移方程

DP状态转移方程和常规的DP算法类似，不过需要将状态压缩成二进制数，以方便计算。我们以背包问题为例，假设有一个容量为V的背包和n个物品，第i个物品的体积为v[i]，价值为w[i]。我们可以用一个1~n的二进制数表示集合，其中第i位表示是否选择第i个物品，对于状态i，其代表的集合中物品的体积和价值可以分别表示为：

体积： $vol(i)=\sum\limits_{j=1}^n (v_j\cdot [i\text{的第j位为1}])$

价值： $val(i)=\sum\limits_{j=1}^n (w_j\cdot [i\text{的第j位为1}])$

其中，[ ]表示取整函数，可以将bool类型的值转换为0或1。

我们可以用一个二维数组dp来表示DP的状态，其中dp[i][j]表示前i个物品，体积不超过j的情况下能够获得的最大价值。状态转移方程为：

$\ \text{if }j\geq v[i]$

$\ \text{otherwise}$

其中，第一行表示当背包容量小于第i个物品的体积时，无法选择第i个物品。

状态遍历

状态遍历是状压DP的核心，我们需要遍历所有可能的状态。对于一个大小为n的集合，一共有 $2^n$ 个子集，因此状态遍历的时间复杂度是指数级的。为了减少计算量，我们可以采用DP剪枝技巧，即预处理出每个状态的前缀和，从而将时间复杂度降为O(n^2)。具体实现如下：

for(int i=0;i<(1<<n);i++){
for(int j=0;j<n;j++){
if(i&(1<<j)) dp[i][j+1]=dp[i][j]+1;
else dp[i][j+1]=dp[i][j];
}
}
for(int i=0;i<(1<<n);i++){
for(int j=0;j<=V;j++){
if(dp[i][n]>j) continue;
for(int k=0;k<n;k++){
if(i&(1<<k)) dp[i][j]=max(dp[i][j],dp[i^(1<<k)][j-v[k]]+w[k]);
}
}
}

其中，dp[i][j]表示状态为i，当前容量为j时能够获得的最大价值，dp[i][j+1]表示状态i的前缀和，即前j+1个元素中被选择的元素的数量。接下来，我们依次遍历所有状态，从小到大枚举背包容量，再枚举每个物品，如果当前状态i中第k个物品被选择，则计算状态转移方程。注意，如果当前状态的前缀和大于j，则不需要再进行计算，直接跳过即可。

在这里插入图片描述

三、java 状压DP剪枝源码实现及详解

状压DP剪枝是一种优化动态规划算法的方法，主要针对状态空间较大的问题，能够显著地减少算法的时间复杂度。

核心思想是将状态用二进制表示，将多个状态压缩成一个数字，从而减少状态数。同时，使用剪枝技巧，避免无用状态的计算。

以下是Java实现状压DP剪枝的示例代码：

int N = 20;  // 最大物品数量

// 状态压缩
int[] mask = new int[N];

for (int i = 0; i < N; i++) {
    mask[i] = 1 << i;
}

int[][] dp = new int[1 << N][N + 1];  // 状态数组

// 初始化状态
for (int i = 0; i < (1 << N); i++) {
    Arrays.fill(dp[i], Integer.MIN_VALUE);
    dp[i][0] = 0;
}

// 状态转移
for (int i = 0; i < (1 << N); i++) {
    for (int j = 0; j <= N; j++) {
        if (dp[i][j] == Integer.MIN_VALUE) {  // 剪枝
            continue;
        }
        for (int k = 0; k < N; k++) {
            if ((i & mask[k]) != 0) {  // 判断是否已经选择此物品
                continue;
            }
            dp[i | mask[k]][j + 1] = Math.max(dp[i | mask[k]][j + 1], dp[i][j] + values[k]);  // 状态转移
        }
    }
}

// 输出最大价值
int ans = 0;
for (int i = 0; i <= N; i++) {
    ans = Math.max(ans, dp[(1 << N) - 1][i]);
}
System.out.println(ans);