从n个元素中选择k个的所有组合(包含重复元素)

LeetCode:Combinations这篇博客中给出了不包含重复元素求组合的5种解法。我们在这些解法的基础上修改以支持包含重复元素的情况。对于这种情况,首先肯定要对数组排序,以下不再强调

修改算法1:按照求包含重复元素集合子集的方法LeetCode:Subsets II算法1的解释,我们知道:若当前处理的元素如果在前面出现过m次,那么只有当前组合中包含m个该元素时,才把当前元素加入组合

class Solution {
public:
    void combine(vector<int> &vec, int k) {
        if(k > vec.size())return;
        sort(vec.begin(), vec.end());

        vector<int>tmpres;
        helper(vec, 0, k, 0, tmpres);
    }
    
    //从vec的[start,vec.size()-1]范围内选取k个数,tmpres是当前组合
    //times是上一个元素出现的次数
    void helper(vector<int> &vec, int start, int k, int times, vector<int> &tmpres)
    {
        if(vec.size()-start < k)return;
        if(k == 0)
        {
            for(int i = 0; i < tmpres.size(); i++)
                cout<<tmpres[i]<<" ";
            cout<<endl;
            return;
        }
        if(start == 0 || vec[start] != vec[start-1])//当前元素前面没有出现过
        {
            //选择vec[start]
            tmpres.push_back(vec[start]);
            helper(vec, start+1, k-1, 1, tmpres);
            tmpres.pop_back();
            //不选择vec[start]
            helper(vec, start+1, k, 1, tmpres);
        }
        else//当前元素前面出现过
        {
            if(tmpres.size() >= times && tmpres[tmpres.size()-times] == vec[start])
            {
                //只有当tmpres中包含times个vec[start]时,才选择vec[start]
                tmpres.push_back(vec[start]);
                helper(vec, start+1, k-1, times+1, tmpres);
                tmpres.pop_back();
            }
            helper(vec, start+1, k, times+1, tmpres);
        }
    }
};

从[1,2,2,3,3,4,5]中选3个的结果如下:

image


修改算法2:同理,可以得到代码如下                    本文地址

class Solution {
public:
    void combine(vector<int> &vec, int k) {
        if(k > vec.size())return;
        sort(vec.begin(), vec.end());

        vector<int>tmpres;
        helper(vec, 0, k, 0, tmpres);
    }
    
    //从vec的[start,vec.size()-1]范围内选取k个数,tmpres是当前组合
    //times是上一个元素出现的次数
    void helper(vector<int> &vec, int start, int k, int times, vector<int> &tmpres)
    {
        if(vec.size()-start < k)return;
        if(k == 0)
        {
            for(int i = 0; i < tmpres.size(); i++)
                cout<<tmpres[i]<<" ";
            cout<<endl;
            return;
        }
        for(int i = start; i <= vec.size()-k; i++)
        {
            if(i == 0 || vec[i] != vec[i-1])//当前元素前面没有出现过
            {
                times = 1;
                //选择vec[i]
                tmpres.push_back(vec[i]);
                helper(vec, i+1, k-1, 1, tmpres);
                tmpres.pop_back();
            }
            else//当前元素前面出现过
            {
                times++;
                //vec[i]前面已经出现过times-1次
                if(tmpres.size() >= times-1 && tmpres[tmpres.size()-times+1] == vec[i])
                {
                    //只有当tmpres中包含times-1个vec[i]时,才选择vec[i]
                    tmpres.push_back(vec[i]);
                    helper(vec, i+1, k-1, times, tmpres);
                    tmpres.pop_back();
                }
            }
        }
    }
};

修改算法3:算法3是根据LeetCode:Subsets 算法2修改未来,同理我们也修改LeetCode:SubsetsII 算法2

class Solution {
public:
    void combine(vector<int> &vec, int k) {
        if(k > vec.size())return;
        sort(vec.begin(), vec.end());

        vector<vector<int> > res(1);//开始加入一个空集
        int last = vec[0], opResNum = 1;//上一个数字、即将要进行操作的子集数量
        for(int i = 0; i < vec.size(); ++i) 
        {
            if(vec[i] != last)
            {
                last = vec[i];
                opResNum = res.size();
            }
            //如果有重复数字,即将操作的子集的数目和上次相同
            int resSize = res.size();
            for(int j = resSize-1; j >= resSize - opResNum; j--)
            {
                res.push_back(res[j]);
                res.back().push_back(vec[i]);
                if(res.back().size() == k)//找到一个大小为k的组合
                {
                    for(int i = 0; i < res.back().size(); i++)
                        cout<<res.back()[i]<<" ";
                    cout<<endl;
                }
            }
        }
    }
};

对于算法4和算法5,都是基于二进制思想,这种解法不适用与包含重复元素的情况

 

【版权声明】转载请注明出处:http://www.cnblogs.com/TenosDoIt/p/3695463.html

转载于:https://www.cnblogs.com/TenosDoIt/p/3695463.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 假设有 m 个长度为 l 的数组 A1, A2, ..., Am,要求取出 n 个不重复组合,其每个组合由 m 个元素组成,每个元素分别来自不同的数组,且每个元素的下标不能相同。 可以使用递归方法实现这个功能,具体步骤如下: 1. 定义一个长度为 m 的数组 index,用于存储每个数组已经选出的元素下标。 2. 定义一个长度为 m 的数组 selected,用于标记每个数组是否已经选过元素。 3. 定义一个递归函数,函数参数包括当前组合的长度 k、当前已经选出的元素下标 index、当前已经选出的数组数量 count。 4. 在递归函数,从第一个数组 A1 开始遍历,如果该数组还没有被选,则在该数组选择一个下标 i,并将其存入 index 数组。 5. 如果当前已经选出的数组数量 count 小于 m,递归调用函数,继续从下一个数组开始选择元素,直到选出 m 个数组为止。 6. 如果当前已经选出的数组数量 count 等于 m,表示已经选出了一个完整的组合,可以将当前的 index 数组保存下来。 7. 回溯到上一层递归,尝试选择当前数组的下一个元素,直到该数组的所有元素都被选完为止。 8. 如果当前数组所有元素都被选完,回溯到上一层递归,尝试选择上一个数组的下一个元素,直到所有数组的所有元素都被选完为止。 9. 最后返回所有不重复组合。 以下是一个示例代码(假设每个数组元素为整数): ``` def get_combinations(arrays, n): m = len(arrays) index = [-1] * m selected = [False] * m combinations = [] def find_combinations(k, index, count): if count < m: for i in range(m): if not selected[i]: selected[i] = True index[i] = 0 find_combinations(k, index, count + 1) selected[i] = False else: combination = [arrays[i][index[i]] for i in range(m)] if len(set(index)) == m and combination not in combinations: combinations.append(combination) if k < n: for i in range(m): if not selected[i]: for j in range(index[i] + 1, len(arrays[i])): index[i] = j find_combinations(k + 1, index, count) index[i] = -1 find_combinations(0, index, 0) return combinations ``` 其,arrays 是一个包含 m 个数组的列表,n 是要取出的组合数量。可以使用以下代码调用该函数: ``` arrays = [[1, 2, 3], [4, 5], [6, 7, 8]] combinations = get_combinations(arrays, 3) print(combinations) ``` 输出结果为: ``` [[1, 4, 6], [1, 4, 7], [1, 4, 8], [1, 5, 6], [1, 5, 7], [1, 5, 8], [2, 4, 6], [2, 4, 7], [2, 4, 8], [2, 5, 6], [2, 5, 7], [2, 5, 8], [3, 4, 6], [3, 4, 7], [3, 4, 8], [3, 5, 6], [3, 5, 7], [3, 5, 8]] ``` ### 回答2: 要比较多个长度不同的数组,并取得n个不重复组合,我们可以使用递归的方法。首先,我们需要定义一个函数来表示递归过程。 在递归函数,我们首先判断当前需要比较的数组是否为空或长度为0,如果是,则返回一个空数组作为结束条件。然后我们取出第一个数组的第一个元素,并将其与其它数组的元素进行组合。 通过循环遍历其它数组的元素,将当前组合与递归函数返回的结果进行合并,得到一个新的组合数组。然后,我们将新的组合数组与递归调用函数传入剩余的数组进行递归调用,并将返回的结果与当前组合进行合并。 最后,我们返回所有的组合数组。 具体的实现如下所示: ```python def compare_arrays(arrays, n): # 结束条件:没有需要比较的数组 if not arrays: return [[]] # 获取第一个数组 current_array = arrays[0] rest_arrays = arrays[1:] # 递归调用比较剩余数组 combinations = compare_arrays(rest_arrays, n) # 比较当前数组的元素与剩余数组的元素进行组合 results = [] for value in current_array: for combination in combinations: # 判断组合是否已经有n个元素 if len(combination) == n: continue # 判断当前元素是否已经在组合 if value in combination: continue # 添加新的组合 new_combination = combination + [value] results.append(new_combination) return results ``` 使用示例: ```python arrays = [[1, 2], [3, 4, 5], [6, 7, 8, 9]] n = 2 combinations = compare_arrays(arrays, n) print(combinations) ``` 输出结果: ``` [[1, 3], [1, 4], [1, 5], [2, 3], [2, 4], [2, 5], [1, 6], [1, 7], [1, 8], [1, 9], [2, 6], [2, 7], [2, 8], [2, 9]] ``` 以上代码可以通过递归的方式比较多个长度不同的数组,并取得n个不重复的所有组合。 ### 回答3: 如果有多个长度不同的数组,要取得n个不重复组合,可以使用递归和回溯算法来实现。 首先,我们需要定义一个函数,该函数需要传递以下参数: 1. 一个列表,用于存储当前选取的组合; 2. 一个整数n,表示要选取的组合个数; 3. 多个长度不同的数组,用于组合。 然后,我们可以按照以下步骤来实现算法: 1. 如果当前选取的组合个数等于n,将当前组合添加到结果列表,并返回; 2. 遍历数组的每个元素: - 将该元素添加到当前组合; - 递归调用函数,传入更新后的列表和n; - 将该元素从当前组合移除,进行下一次迭代。 最后,我们可以在主函数将每个数组传入该函数,并设置初始列表为空列表。这样,就可以得到所有不重复组合。 需要注意的是,为了避免重复组合,我们可以在每次迭代时,只从当前元素的下一个位置开始遍历数组,这样可以确保不会选取到之前已经选过的元素。 总结起来,多个长度不同的数组对比取得n个不重复组合的算法可以通过递归和回溯来实现,具体步骤如上所述。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值