3

什么是位掩码动态编程？

 9 months ago
source link: https://www.jdon.com/70876.html
Go to the source link to view the article. You can view the picture content, updated content and better typesetting reading experience. If the link is broken, please click the button below to view the snapshot at that time.
neoserver,ios ssh client

什么是位掩码动态编程？

位掩码动态编程（Bitmask DP：Bitmask Dynamic Programming）是一种强大的技术，用于解决涉及集合子集和优化的问题。它结合了动态编程的效率和使用位掩码对集合的紧凑表示。

什么是位掩码？
位掩码是一个二进制数，每一位代表集合中的一个特定元素。如果某位为 1，则表示集合中包含了相应的元素。反之，如果某位为 0，则表示不包含该元素。

例如，考虑一个集合 {A、B、C}。我们可以用位掩码来表示以下子集：

  • A：100（二进制）= 4（十进制）
  • B: 010（二进制）= 2（十进制）
  • C: 001（二进制）= 1（十进制）
  • AB：110（二进制）= 6（十进制）

为什么使用位掩码 DP？
位掩码 DP 有几个优点：

  • 紧凑表示法：它可以高效地表示大型集合，尤其是在处理子集时。
  • 减少状态空间：它通过只考虑相关组合，减少了动态编程中需要探索的状态数量。
  • 高效计算：AND、OR 和 XOR 等位运算为操作集合和执行计算提供了高效的方法。

它是如何工作的？
以下是比特掩码 DP 的基本概要：

  • 定义状态：选择一个比特掩码来表示当前状态，其中每个比特表示一个特定元素的存在或不存在。
  • 定义子问题：根据位掩码所代表元素的不同组合确定子问题。
  • 解决子问题：利用动态编程原理递归解决较小的子问题，并存储其解决方案。
  • 合并解决方案：合并子问题的解决方案，得出原始问题的最佳解决方案。

位掩码 DP 是一种多用途技术，可用于各种问题，包括

  • 子集和：寻找总和等于目标值的元素子集。
  • 背包问题：在给定的重量限制内选择最有价值的物品。
  • 硬币找零问题：找出最小数量的硬币来换取给定的金额。
  • 旅行推销员问题：找出访问每个城市一次并返回起点的最短路线。
  • 图形着色：为图形中的顶点分配颜色，使相邻的顶点具有不同的颜色。

简单案例：
使用位掩码动态编程法计算通过重新排列数组 A[] 的元素而形成的所有可能数组，可以按照以下步骤进行：

def count_permutations(arr):
    n = len(arr)
    total_permutations = 1 << n  # Total number of subsets (2^n)

dp = [0] * total_permutations  # 初始化动态编程数组

# 基本情况排列空集的方法只有一种
    dp[0] = 1

for mask in range(1, total_permutations):
        dp[mask] = 0

# 计算掩码中设置的位数
        num_bits = bin(mask).count('1')

for i in range(n):
            如果当前排列中没有使用第 i 个元素
            if (mask & (1 << i)) == 0:
                # 更新当前掩码的排列数
                dp[mask | (1 << i)] += dp[mask]

# 排列总数是所有掩码的 dp[掩码]之和
    total_arrangements = sum(dp)

return total_arrangements

# Example usage
arr = [1, 2, 3]
result = count_permutations(arr)
print("Total number of arrangements:", result)

这段 Python 代码使用位掩码动态编程法来计算通过重新排列数组 A[] 中的元素而形成的所有可能数组。函数 count_permutations 初始化了一个动态编程数组 dp，并遍历所有可能的掩码来计算排列数。最终结果是 dp 数组中所有值的总和。

请注意，由于子集的指数增长（2^N），这种方法在 N 值较小的情况下（最多 15 个）也能有效工作。对于较大的 N 值，可能需要更高效的算法。

难点问题：
给定大小为 N（1 <= N <=15）的数组 A[]，计算所有通过重新排列 A[]的元素而形成的数组，使得该数组的相邻元素至少有以下一个条件为真：

  • A % A[i + 1] == 0
  • A[i + 1] % A == 0
在打印之前，计数可以是一个很大的模数答案，即 10的9次方+ 7。

例子1：
输入A[] = {2, 3, 6}
输出： 22
说明： {3, 6, 2} 和 {2, 6, 3{3, 6, 2} 和 {2, 6, 3} 是数组 A[] 的两种可能的重新排列方式，使得相邻元素满足其中一个必要条件。

例子2：
输入A[] = {1, 4, 3}
输出： 22
说明： {3, 1, 4} 和 {4, 1, 3{3, 1, 4} 和 {4, 1, 3} 是数组 A[] 的两种可能的重新排列，使得相邻元素满足其中一个必要条件。

解决方案：
位掩码动态编程法可以用来解决这个问题。在这个问题中，DP 的主要概念将是：

DP[j]代表满足上述条件的排列数，其中 i 代表位掩码形式的子集，j 代表该子集的最后一个元素，因此当子集 i 中添加新元素时，要检查可分性条件。

转换：
dp[i | (1 << (k - 1))][k] = (dp[i | (1 << (k - 1))][k] + dp[j])

这里 k 是数组 A[] 的第 k 个元素，被添加到子集 i 的末尾，子集 i 的最后一个元素是数组 A[] 的第 j 个元素

步骤：

声明DP [1 << N ][ N + 1] 数组。 通过迭代 0 到N – 1 作为 i 来初始化基本情况，然后设置dp [1 << i ][ i + 1] = 1 对于每次迭代，迭代1到2 N个 N 的所有子集从1迭代到N as j如果子集i的第 j位未设置，则意味着当前子掩码中不考虑第 j 个元素，因此我们跳过该迭代。 否则，从 1 迭代到N作为k，并且对于每次迭代，检查第 k位是否不在当前子掩码中，并且最后一个元素j和k满足所需条件，然后根据转换更新dp表： dp[i | (1 << (k – 1))][k] = (dp[i | (1 << (k – 1))][k] + dp[j])迭代完所有子掩码后，添加dp[(1 << N) – 1] ，它表示满足上述条件的最后一个元素i的大小为N的排列计数。 返回ans。

下面是是C++代码：

// C++ code to implement the approach
include <bits/stdc++.h>
using namespace std;

// mod
const int mod = 1e9 + 7;

// 函数计算通过重新排列给定数组而形成的满足以下条件的数组的数目
//
int countOfArr(int A[], int N)
{
    // DP array initalized with 0
    vector<vector<int> > dp((1 << (N + 1)),
                            vector<int>(N + 2, 0));

// base case
    for (int i = 0; i < N; i++)
        dp[1 << i][i + 1] = 1;

// 遍历所有子集
    for (int i = 1; i < (1 << N); i++) {

// 如果从数组 A[] 中选取的最后一个元素是 j
        for (int j = 1; j <= N; j++) {

// 如果第 j 个元素不在当前子集中
          // i 跳过迭代
            if (((1 << (j - 1)) & i) == 0)
                continue;

// tring to choose k'th element from array A[]
            for (int k = 1; k <= N; k++) {

// 如果 A 的第 k 个元素未被访问，并且
         // 最后一个元素 j 和当前元素 k
        // 满足所需条件，则更新 dp；      
          //满足所需的条件更新 dp
       // 根据转换
                if (((1 << (k - 1)) & i) == 0
                    and (A[j - 1] % A[k - 1] == 0
                        or A[k - 1] % A[j - 1] == 0)) {
                    dp[i | (1 << (k - 1))][k]
                        = (dp[i | (1 << (k - 1))][k]
                        + dp[i][j])
                        % mod;
                }
            }
        }
    }

// 计数所有排列组合的变量
    int ans = 0;

// accumulating all arrangements of size N and last
    // element i
    for (int i = 1; i <= N; i++) {
        ans = (ans + dp[(1 << N) - 1][i]) % mod;
    }

// return the total count
    return ans;
}

// Driver Code
int32_t main()
{

// Input
    int N = 3;
    int A[] = { 2, 3, 6 };

// Function Call
    cout << countOfArr(A, N) << endl;

return 0;
}

输出
2

时间复杂度： O( N 2 * 2 N )，其中N是输入数组A[]的大小。辅助空间： O( N * 2 N )
 


report

Recommend

About Joyk


Aggregate valuable and interesting links.
Joyk means Joy of geeK