计算从n个人中选k个人组成委员会的不同组合数 用C语言函数递归

Posted 2023-04-19

参考技术A int fun(int n,int k)

if(k>n)
return 0;
else if(n==k||k==0)
return 1;
else
return fun(n-1,k)+fun(n-1,k-1);


void main()

int n,k,result;
scanf("%d",&k);
result=fun(n,k);
printf("%d\n",result);
追问

应该输入
scanf("%d%d",&n,&k);
总之非常感谢！！！！！

追答

哈哈，太晚了，着急睡觉，忘写了，不好意思哈

本回答被提问者采纳 参考技术B 原理是一样的，可以参考下面的稍微改一下，自己动手可以学的更多，呵呵

#include <iostream.h>//实现数据的全排序
void swap(int *a,int x,int y)//数据交换

int temp = a[x];
a[x] = a[y];
a[y] = temp;

void Perm(int *a,int k,int m)//实现全排序

if ( k ==m)

for (int i=0;i<=m;i++)

cout<<a[i]<<" ";

cout<<endl;

else

for (int j =k;j<=m;j++)

swap(a,k,j);
Perm(a,k+1,m);
swap(a,k,j);



int main()

int a[10];
for (int i=0;i<10;i++)

a[i] = i;

Perm(a,0,9);

return 0;

Python实现对于给定的输入，保证和为 target 的不同组合数

题目描述

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。

对于给定的输入，保证和为 target 的不同组合数少于 150 个。
题目链接：https://leetcode.cn/problems/combination-sum/

测试用例

• 示例1

输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

• 示例2

输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]

• 示例3

输入: candidates = [2], target = 1
输出: []

解决思路

对于这种寻找数字组合的解决思路通常有两种方案：

1. 对于候选数组里面的元素，采用选和不选来构建树
2. 使用target作为根节点来构建树

下面对于这两种解决思路我们来使用代码进行实现

• 采用选和不选来构建树
  

import copy
def combinationSum(candidates, target):
    """采用树的结构选择和不选择的思想来寻找所有组合的可能
    :type candidates: List[int]
    :type target: int
    :rtype: List[List[int]]
    """
    #用来保存组合的结果
    res_com_list = []
    def find_com(target,index,com_list):
        """
        :param target:寻找的目标值
        :param index:索引下标
        :param com_list:符合条件的组合结果
        :return:
        """
        #超出了数组的边界直接返回
        if index == len(candidates):
            return
        #寻找的组合符合条件
        if target == 0:
            res_com_list.append(copy.copy(com_list))
            return
        #直接跳过当前元素
        find_com(target, index + 1,com_list)
        #选择当前元素
        #如果当前元素添加到列表之后target>=0则添加进去
        if target - candidates[index] >= 0:
            #添加符合条件的元素到列表中
            com_list.append(candidates[index])
            #减少target的值,进行下一轮元素的添加
            find_com(target - candidates[index],index,com_list)
            #选择另一条分支
            com_list.remove(com_list[-1])

    find_com(target,0,[])

    return res_com_list

• 使用target作为根节点来构建树
  

def combinationSum(candidates, target):
    """根据target为根节点来构建树
    :param candidates:
    :param target:
    :return:
    """
    #用来保存最终的组合结果
    res_com_list = []
    def find_com(candidates,index,size,com_list,target):
        """通过回溯法来寻找符合条件的组合
        :param candidates:待候选的数组
        :param index:寻找数组的开始下标位置
        :param size:寻找数组的长度
        :param com_list:用来保存符合条件的组合
        :param target:寻找组合的目标值
        :return:
        """
        if target < 0:
            return
        elif target == 0:
            res_com_list.append(com_list)
            return
        else:
            for i in range(index,size):
                #剪枝处理,对于后面target为负的树就直接跳出寻找
                if target - candidates[i] < 0:
                    break
                find_com(candidates,i,size,com_list+[candidates[i]],target-candidates[i])
    #对候选数组进行排序,为了后面的剪枝
    find_com(candidates,0,len(candidates),[],target)
    return res_com_list

参考

1. 回溯算法 + 剪枝（回溯经典例题详解）
2. 组合总和