递归基础_组合数_输出的各种办法(递归)_(持续更新)

B: 部分和问题***(注意部分和 ! = 任意子区间求和不一样)

描述   给你N个数,问你能不能从其中取出一些，让它们的和为K.

输入

第一行包括两个数，N，K,分别代表数字个数,以及和为K. 接下来N行，每行一个数字.

输出

如果能选出一些数和为K, 输出YE5,  否则，输出N0

样例

输入:

4 0

1 -1  2  3

输出:

YE5

输入:

2 2

1 -3

输出:

N0

本题求组合数和，注意pe之外，思维比较基础，办法很多，以下为利用dfs思想实现的一种办法

如果求组合数输出各种可能，直接递归是不行的，那样智能遍历，需要一个媒介数组，存放每种可能，因为要每次返回都要利用上一层的东西

观察 1 2 3 4  对于C（4，3）= C（n，r）

1 2 3

1 2 4

1 3 4

2 3 4

对于（a，b，c）型，最终在 首位   a =  n-r+1 = 4-3+1 = 2 , 递归函数内部 c=n , it = r  时停止遍历 ，注意第47行的条件；

组合数比全排列难的地方就在于这个限制 "重复" 条件，首先，对于任何一层的组合，

1. 遍历首位不会超过n-r+1
2. 遍历尾部不会超过n,
3. 遍历总数不会超过r

因此分为两个部分,dfs函数是对尾部(分支)的遍历 , 利用条件3约束, main函数内是对首位穷举, 方式是循环, 利用条件3约束

如果用bool 标记已经找过的数，思路和排列差不多，标记每次遍历到直接跳过就行了，返回的时候在函数末尾消除标记就可

(用全排列改写的组合数输出)

#include <iostream>
#include <cstring>
#include <queue>
#include <cstdio>
#include <cmath>
#include <map>
#include <algorithm>
typedef long long ll;
using namespace std;
int n;
int r;
int a[11];
bool x[11];
void f(int it,int num) {
//num表示此时已经排列了几层(栈的深度)
//it表示下一个要压入的数
    a[num]=it;//入栈
    x[it]=1;//mark
    if(num==r) {
        for(int j=1; j<=r; j++) {
            cout<<a[j]<<" ";
        }
        printf("
");
    } else {
        for(int i=it+1; i<=n; i++) {
            if(x[i]==1)continue;
            else f(i,num+1);
        }
    }
    x[it]=0;
}

int main () {
    cin>>n>>r;
    memset(x,0,sizeof(x));
    for(int i=1; i<=n-r+1; i++) {
        f(i,1);
    }

    return 0;
}

进一步化简,  从num=0,开始记录,

#include <iostream>
#include <cstring>
#include <queue>
#include <cstdio>
#include <cmath>
#include <map>
#include <algorithm>
typedef long long ll;
using namespace std;
int n;
int r;
int a[11];
bool x[11];
void f(int it,int num) {
//num表示此时已经排列了几层(栈的深度)
//it表示下一个要压入的数
    a[num]=it;//入栈
    x[it]=1;//mark
    if(num==r) {
        for(int j=1; j<=r; j++) {
            cout<<a[j]<<" ";
        }
        printf("
");
    } else {
        for(int i=it+1; i<=n; i++) {
            if(x[i]==1)continue;
            else f(i,num+1);
        }
    }
    x[it]=0;
}

int main () {
    cin>>n>>r;
    memset(x,0,sizeof(x));
    
    f(0,0);
    

    return 0;
}

但是如果找规律，就需要明确找的数都只能比上一层的大，然后在此基础上循环到恰好是r个

以下为— dfs 利用栈—实现的  输出n个数的 全组和  

#include <iostream>
#include <cstring>
#include <queue>
#include <cstdio>
#include <cmath>
#include <map>
#include <algorithm>
typedef long long ll;
using namespace std;
const int m=25;
ll a[m];
bool t=0;
ll sum=0;
int n;
ll k;
//用数组下标输出组合数!!!
//C(n,k)=C(n=1,k-1)


//1 2 3 4 5 6
//5 22 2 4 6 8 10
//5  2 4 6 8 10
ll b[m];
//b[m]看作一个栈
int g=1;
ll r;

void dfs(int num,int it) {

    b[it]=a[num];
    if(it==r) {
        for(int i=1; i<r; i++)printf("%lld ",b[i]);
        printf("%lld
",b[r]);
        //cout<<g++<<" "<<it<<"
";
    } else {
        for(int i=num+1; i<=n; i++) {
            dfs(i,it+1);
        }
    }
}

int main() {

    scanf("%d",&n);
    for(int i=1; i<=n; i++)scanf("%lld",&a[i]);
    for(r=1; r<=n; r++) {
        for(int i=1; i<=n-r+1; i++) {
            sum=0;
            dfs(i,1);
        }
    }
    puts("");

    return 0;
}

从0开始更加简洁;

#include <iostream>
#include <cstring>
#include <queue>
#include <cstdio>
#include <cmath>
#include <map>
#include <algorithm>
typedef long long ll;
using namespace std;
const int m=25;
ll a[m];
bool t=0;
ll sum=0;
int n;
ll k;
//用数组下标输出组合数!!!
//C(n,k)=C(n-1,k-1)


//1 2 3 4 5 6
//5 22 2 4 6 8 10
//5  2 4 6 8 10
ll b[m];
//b[m]看作一个栈
int g=1;
ll r;

void dfs(int num,int it) {

    b[it]=a[num];
    if(it==r) {
        for(int i=1; i<r; i++)printf("%lld ",b[i]);
        printf("%lld
",b[r]);
        //cout<<g++<<" "<<it<<"
";
    } else {
        for(int i=num+1; i<=n; i++) {
            dfs(i,it+1);
        }
    }
}

int main() {

    scanf("%d",&n);
    for(int i=1; i<=n; i++)scanf("%lld",&a[i]);
    for(r=1; r<=n; r++) {

        dfs(0,0);

    }
    puts("");

    return 0;
}

在这基础上，直接把每次得到的序列求和，可以完成这题，

#include <iostream>
#include <cstring>
#include <queue>
#include <cstdio>
#include <cmath>
#include <map>
#include <algorithm>
typedef long long ll;
using namespace std;
const int m=25;
ll a[m];
bool t=0;
ll sum=0;
int n;
ll k;
//用数组下标输出组合数!!!
//C(n,k)=C(n=1,k-1)


//1 2 3 4 5 6
//5 22 2 4 6 8 10
//5  2 4 6 8 10
ll b[m];
//b[m]看作一个栈
int g=1;
ll r;



void f(int no,int now) {
    if(t==1)return;
    b[now]=a[no];//更新入栈,
    if(now==r) { //栈满检查
        sum=0;
        for(int i=1; i<=r&&t==0; i++) {
            sum+=b[i];
            if(sum==k)t=1;
        }
    } else {
        for(int i=no+1; i<=n; i++) {
            f(i,now+1);
        }
    }
}

int main() {

    scanf("%d%lld",&n,&k);
    for(int i=1; i<=n; i++)scanf("%lld",&a[i]);
    for(r=1; r<=n; r++) {
        for(int i=1; i<=n-r+1; i++) {
            sum=0;
            f(i,1);
        }
    }
    if(t==1)cout<<"YE5";
    else cout<<"N0";

    puts("");


    return 0;
}

当然，求和，其实是不需要求这个序列的，遍历每一种可能，之后不需要把序列存下来，直接检查和，就可以满足了，

不含媒介数组的办法（注意第 44 行，sum减回来当前值的操作在每次到底之后都要执行）

#include <iostream>
#include <cstring>
#include <queue>
#include <cstdio>
#include <cmath>
#include <map>
#include <algorithm>
typedef long long ll;
using namespace std;
const int m=25;
ll a[m];
bool t=0;
ll sum=0;
int n;
ll k;
//用数组下标输出组合数!!!
//C(n,k)=C(n=1,k-1)


//1 2 3 4 5 6
//5 22 2 4 6 8 10
//5  2 4 6 8 10
ll b[m];
//b[m]看作一个栈
int g=1;
ll r;

void f2(int no,int now) {
    sum+=a[no];//更新入栈,
    //cout<<"sum="<<sum<<" ";

    if(sum==k||t==1) {
        t=1;
        return;
    }
    if(now<r) { //栈满,
        //cout<<"sum="<<sum<<"
";
        //

        for(int i=no+1; i<=n; i++) {
            f2(i,now+1);
        }
    }
    sum-=a[no];//弹出!!!小心少了这一步 
}
int main() {

    scanf("%d%lld",&n,&k);
    for(int i=1; i<=n; i++)scanf("%lld",&a[i]);
    
    for(r=1; r<=n; r++) {
        for(int i=1; i<=n-r+1; i++) {
            sum=0;
            f2(i,1);
        }
    }
    if(t==1)cout<<"YE5";
    else cout<<"N0";
    puts("");
    return 0;
}

另外的写法——来源：https://blog.csdn.net/randyjiawenjie/article/details/6784355

问题：求n个数中K个数的组合，假设函数原型为 int combination（int n,int k）,其中 n的范围为 1……n,

例如：combination（5，3） 要求输出：543、542、541、531、532、521、432、431、421、321

如果输出时有用到数组，其空间需要在开始动态分配好，结束时释放。还是利用递归，关键：c(m,k) = c(m -1 , k- 1) + c(m - 2, k - 1) + ...+ c(k - 1.k - 1)

# include <stdio.h>
# define MAXN 100
int a[MAXN];
/**
 * 组合问题
 *问题描述：找出从自然数1、2、……、m中任取k个数的所有组合。
 */
void comb(int m, int k) {
    int i, j;
    for (i = m; i >= k; i--) {
        a[k] = i;
        if (k > 1)
            comb(i - 1, k - 1);
        else {
            for (j=a[0];j>0;j--)
            printf("%4d",a[j]);
            printf("
");
        }
    }
}

int main() {
    a[0] = 3;
//    int a[] = {1,2,3,4,5};
    comb(5, 3);
    return 0;
}

凡是含—输出该序列—的题目都需要一个 “栈” 存放结果，区别在于，他把上界n-r+1写进了递归函数中，

表示为 for (i = m; i >= k; i--)，思维更复杂，这个每次递归的时候上界都会变，

另一种写法：也是利用01标记法，但是实现写了一个表 + bfs实现   https://blog.csdn.net/cao2219600/article/details/79587306

同理也可以使用 01 标记+ dfs实现（待续）