92. 递归实现指数型枚举 - AcWing题库

最新推荐文章于 2025-01-16 17:20:16 发布

zhangpz_

最新推荐文章于 2025-01-16 17:20:16 发布

阅读量738

点赞数 21

CC 4.0 BY-SA版权

文章标签：深度优先算法

本文链接：https://blog.csdn.net/Doctor_Anonymous/article/details/138041717

文章介绍了如何使用递归和状态数组实现从1到n的整数中随机选择子集的指数型枚举问题，以及LeetCode中的爬楼梯问题的递推和递归解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

92. 递归实现指数型枚举 - AcWing题库

70. 爬楼梯 - 力扣（LeetCode）

92. 递归实现指数型枚举 - AcWing题库

从 1∼n这 n 个整数中随机选取任意多个，输出所有可能的选择方案。

输入格式

输入一个整数 n。

输出格式

每行输出一种方案。

同一行内的数必须升序排列，相邻两个数用恰好 11 个空格隔开。

对于没有选任何数的方案，输出空行。

本题有自定义校验器（SPJ），各行（不同方案）之间的顺序任意。

数据范围

1≤n≤15

输入样例：

输出样例：

code:

#include <stdio.h>
#include <stdlib.h>
#define N 20
int n;
int st[N] = {};//开一个状态数组 0表示空着  1表示选了  2表示不选
void dfs(int x){
    if(x > n){
        for(int i = 1 ; i <= n ; i++){
            if(st[i] == 1){
                printf("%d ", i);
            }
        }
        printf("\n");
        return;
    }
    //选择
    st[x] = 1;
    dfs(x + 1);
    st[x] = 0;
	//不选
    st[x] = 2;
    dfs(x + 1);
    st[x] = 0;
}
int main()
{
    scanf("%d", &n);
    dfs(1);
    return 0;
}

程序概览

这个程序定义了一个递归函数 dfs（深度优先搜索），用于生成从 1 到 n 的所有子集。在 dfs 函数中，我们探索了两种情况：选择当前元素（将其状态设置为 1）和不选择当前元素（将其状态设置为 2）。接下来，我们详细分析这个函数的行为。

执行过程细节

调用 dfs(1)：
1. 首先，检查 x > n 的条件。对于 x=1 和 n=3，这个条件为假，所以不执行 if 语句块内的代码。
2. 接下来，设置 st[1] = 1。
3. 紧接着，调用 dfs(2)。在这一点上，程序的执行流进入 dfs(2)，开始处理 dfs(2) 内的所有逻辑。
执行 dfs(2) 中的代码：
1. 程序会在 dfs(2) 完成其全部逻辑（包括它自己的递归调用等）后，才会返回到 dfs(1) 中 dfs(2) 调用之后的代码行 st[x] = 0。
回到 dfs(1) 继续执行：
1. 完成 dfs(2) 后，st[1] 被设置为 0。
2. 然后，设置 st[1] = 2，并再次调用 dfs(2)。同样地，程序将进入 dfs(2) 并处理所有相关逻辑。
3. dfs(2)完成后继续执行st[1] = 0。

回溯的执行过程

具体例子分析（假设 `n=3`）

初始调用 dfs(1)：
1. 选择 1（设置 st[1] = 1），然后递归调用 dfs(2)。
在 dfs(2) 中：
1. 选择 2（设置 st[2] = 1），然后递归调用 dfs(3)。
在 dfs(3) 中：
1. 选择 3（设置 st[3] = 1），然后递归调用 dfs(4)。
达到结束条件，开始输出（dfs(4) 发现 x > n）：
1. 输出 {1, 2, 3}。
2. 回溯到 dfs(3)：撤销选择 3（设置 st[3] = 0），尝试不选择 3，再次调用 dfs(4)。
再次达到临界条件：
1. 输出 {1, 2}。
2. 回溯到 dfs(2)：撤销选择 2（设置 st[2] = 0），尝试不选择 2，调用 dfs(3)。
继续在 dfs(3) 中操作：
1. 之前已经尝试了选择 3 和不选择 3 的情况，输出 {1, 3} 和 {1}。
2. 回溯到 dfs(1)：撤销选择 1（设置 st[1] = 0），尝试不选择 1，调用 dfs(2)。
对于 dfs(2) 和 dfs(3)，再次执行选择和不选择的操作：
1. 生成并输出剩余的子集 {2, 3}, {2}, 和 {3}, {}。

树状图理解

                                dfs(1)
                               /     \
                             /         \
                 [1]选1 (选取1)           [1]不选1 (不选取1)
                   /           \           /         \
                 /               \       /             \
          dfs(2, {1})         dfs(2, {})   dfs(2, {1})   dfs(2, {})
            /       \           /    \      /     \       /     \
          /           \       /      \    /       \     /       \
     [2]选2         [2]不选2 [2]选2 [2]不选2 [2]选2 [2]不选2 [2]选2 [2]不选2
       / \             / \     / \      / \     / \      / \      / \
  dfs(3,{1,2}) ...   ...  ... ...   ...  ...  ...  ...  ...   ...  ...
   /       \
  /         \
[3]选3   [3]不选3

每次都有两个选项，选择和不选择。这里用数组st记录状态，每个位置如果是0表示空着，1表示选择，2表示不选

70. 爬楼梯 - 力扣（LeetCode）

递推

int nums[50];
int climbStairs(int n){
    nums[1] = 1;
    nums[2] = 2;
    for(int i = 3 ; i <= n ; i++){
        nums[i] = nums[i - 1] + nums[i - 2];
    }
    return nums[n];
}

递归

                                    nums[5]
                                   /       \
                              nums[4]     nums[3]
                             /    \        /    \
                        nums[3]  nums[2] nums[2]  nums[1]
                        /    \
                   nums[2]  nums[1]