子集和问题（回溯法）

小忆控～

于 2024-05-29 21:30:15 发布

阅读量896

点赞数 14

文章标签：算法 c++ 数据结构深度优先 c语言

本文链接：https://blog.csdn.net/2301_79582459/article/details/139305682

版权

前言

【问题描述】考虑定义如下的PARTITION问题中的一个变型。给定一个n个整数的集合X={x1,x2,…,xn}和整数y，找出和等于y的X的子集Y。

一、算法思路

基本思想：确定了解空间的组织结构后，回溯法从开始结点（根结点）出发，以深度优先方式搜索整个解空间。这个开始结点成为活结点，同时也成为当前的扩展结点。在当前的扩展结点处，搜索向纵深方向移至一个新结点。这个新结点就成为新的活结点，并成为当前扩展结点。如果在当前的扩展结点处不能再向纵深方向移动，则当前扩展结点就成为死结点。此时，应往回移动（回溯）至最近的一个活结点处，并使这个活结点成为当前的扩展结点。回溯法以这种工作方式递归地在解空间中搜索，直至找到所要求的解或解空间中已无活结点时为止。

二、分析过程

重要❗❗❗

解的n元组：

解是一个包含0和1的n元组，其中每个元素对应集合X中对应位置的元素是否包含在子集Y中。

x的取值范围：
x为集合X中的每个元素，取值为正整数。

约束条件：
子集Y中元素之和等于给定整数y。

目标函数：
找出和等于y的X的子集Y。

三、代码实现

伪代码：

代码如下（示例）：这个代码很重要！！！

INPUT:X集合(数组),  整数y
OUTPUT:X集合对应的n元布尔向量，使得对应的元素为1的xi之和为y。
    1. 初始化n元布尔向量c[n]，值为-1；s=0
    2. flag ←false
    3. k ←1 
    4. while k≥ 1
    5.     while c[k]≤0
    6.          c[k] ← c[k] +1
    7.          if c[k]=1 then s=s+X[k]   
    8.            if s=y then set flag ←true, c[k+1]~c[n]←0
                                    且从两个while循环退出
    9.           else if s<y  then k k+1
   10.     end while 　
   11.     s=s-X[k]                
   12.     c[k] ←-1
   13.      k ←k-1
   14.  end while
   15.  if flag then output c
   16.  else output “no solution”

C++：

#include <iostream>
#include <vector>

void subsetSumUtil(std::vector<int>& X, std::vector<int>& currSubset, std::vector<int>& result, int target, int currSum, int index) {
    if (currSum == target) {
        result = currSubset;
        return;
    }
    
    if (currSum > target || index >= X.size()) {
        return;
    }

    // Include the current element
    currSubset.push_back(X[index]);
    subsetSumUtil(X, currSubset, result, target, currSum + X[index], index + 1);
    currSubset.pop_back();

    // Exclude the current element
    subsetSumUtil(X, currSubset, result, target, currSum, index + 1);
}

std::vector<int> findSubsetSum(std::vector<int>& X, int y) {
    std::vector<int> result;
    std::vector<int> currSubset;
    subsetSumUtil(X, currSubset, result, y, 0, 0);
    return result;
}

int main() {
    std::vector<int> X = {3, 34, 4, 12, 5, 2};
    int y = 9;

    std::vector<int> subset = findSubsetSum(X, y);
    
    if (!subset.empty()) {
        std::cout << "Subset with sum " << y << " exists: ";
        for (int num : subset) {
            std::cout << num << " ";
        }
        std::cout << std::endl;
    } else {
        std::cout << "No subset with sum " << y << " exists." << std::endl;
    }

    return 0;
}

结果：

总结

在考虑PARTITION问题的变种，即找出和等于给定整数y的X的子集Y时，可以使用回溯法来解决。算法的思路是通过搜索所有可能的子集组合，尝试包含或排除每个元素，直到找到合适的子集使得和等于给定整数y。算法的时间复杂度可能为指数级的O(2^n)，因为需要搜索所有可能的子集。需要注意的是，回溯法的时间复杂度通常较高，特别是在面对大规模输入时。因此，在实际应用中需要考虑性能问题，并且可能需要对算法进行优化或者考虑其他更高效的解决方案。