蓝桥杯C++ AB组辅导课第一讲递归与递推 Acwing

最新推荐文章于 2023-09-30 21:02:40 发布

5pace

最新推荐文章于 2023-09-30 21:02:40 发布

阅读量2.7k

点赞数

文章标签：蓝桥杯 c++ 深度优先

本文链接：https://blog.csdn.net/m0_51448653/article/details/122380775

版权

例题

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

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

输入格式
输入一个整数 n。

输出格式
每行输出一种方案。

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

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

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

数据范围

1≤n≤15

输入样例：

输出样例：

思路：

实际上每个数只要考虑选（1）和不选（2）这两个状态，也就是说回溯回来不需要恢复成0，相当于每个结点有两个分叉，所以是 $2^n$ 指数型枚举
dfs时，结束递归时一定要return

#include <iostream>
using namespace std;

const int N = 16;

int n;
int st[N];      // 0表示还没考虑 1表示选 2表示不选

void dfs(int u)
{
    if (u > n)
    {
        for (int i = 1; i <= n; i ++ )
            if (st[i] == 1)
                printf("%d ", i);
        puts("");
        
        return ;
    }
    
    st[u] = 2;
    dfs(u + 1);
    // st[u] = 0;
    
    st[u] = 1;
    dfs(u + 1);
    // st[u] = 0;
}

int main()
{
    scanf("%d", &n);
    
    dfs(1);
    
    return 0;
}

AcWing 94. 递归实现排列型枚举

把 1∼n 这 n 个整数排成一行后随机打乱顺序，输出所有可能的次序。

输入格式
一个整数 n。

输出格式
按照从小到大的顺序输出所有方案，每行 1 个。

首先，同一行相邻两个数用一个空格隔开。

其次，对于两个不同的行，对应下标的数一一比较，字典序较小的排在前面。

数据范围

1≤n≤9

输入样例：

输出样例：

思路：

有 $n * (n - 1) * . . . * 1$ 种排列方式，因此是排列型枚举
每次递归决定当前这个盒子中放什么数字，由于不重复放，因此开一个数组记录当前是否用过这个数字，因此回溯要恢复现场

#include <iostream>
using namespace std;

const int N = 10;

int n;
int state[N];
bool st[N];

void dfs(int u)
{
    if (u > n)
    {
        for (int i = 1; i <= n; i ++ )
            printf("%d ", state[i]);
        puts("");
        
        return ;
    }
    
    for (int i = 1; i <= n; i ++ )
    {
        if (!st[i])
        {
            st[i] = true;
            state[u] = i;
            dfs(u + 1);
            
            // state[u] = 0;
            st[i] = false;
        }
    }
}

int main()
{
    scanf("%d", &n);
    
    dfs(1);
    
    return 0;
}

AcWing 717. 简单斐波那契

以下数列 0 1 1 2 3 5 8 13 21 … 被称为斐波纳契数列。

这个数列从第 3 项开始，每一项都等于前两项之和。

输入一个整数 N，请你输出这个序列的前 N 项。

输入格式
一个整数 N。

输出格式
在一行中输出斐波那契数列的前 N 项，数字之间用空格隔开。

数据范围

0<N<46

输入样例：

输出样例：

0 1 1 2 3

// 递推
#include <iostream>
using namespace std;

int main()
{
    int n; scanf("%d", &n);
    
    int a = 0, b = 1, c;
    for (int i = 0; i < n; i ++ )
    {
        printf("%d ", a);
        c = a + b, a = b, b = c;
    }
}

#include <iostream>
using namespace std;

const int N = 47;

int n;
int f[N];

int dfs(int u)
{
    if (u == 1 || u == 2 || f[u]) return f[u];
    return f[u] = dfs(u - 1) + dfs(u - 2);
}

int main()
{
    scanf("%d", &n);
    
    f[1] = 0, f[2] = 1;
    dfs(n);
    
    for (int i = 1; i <= n; i ++ ) cout << f[i] << ' ' ;
    
    return 0;
}

AcWing 95. 费解的开关

你玩过“拉灯”游戏吗？

25 盏灯排成一个 5×5 的方形。

每一个灯都有一个开关，游戏者可以改变它的状态。

每一步，游戏者可以改变某一个灯的状态。

游戏者改变一个灯的状态会产生连锁反应：和这个灯上下左右相邻的灯也要相应地改变其状态。

我们用数字 1 表示一盏开着的灯，用数字 0 表示关着的灯。

下面这种状态

10111
01101
10111
10000
11011
在改变了最左上角的灯的状态后将变成：

01111
11101
10111
10000
11011
再改变它正中间的灯后状态将变成：

01111
11001
11001
10100
11011
给定一些游戏的初始状态，编写程序判断游戏者是否可能在 6 步以内使所有的灯都变亮。

输入格式
第一行输入正整数 n，代表数据中共有 n 个待解决的游戏初始状态。

以下若干行数据分为 n 组，每组数据有 5 行，每行 5 个字符。

每组数据描述了一个游戏的初始状态。

各组数据间用一个空行分隔。

输出格式
一共输出 n 行数据，每行有一个小于等于 6 的整数，它表示对于输入数据中对应的游戏状态最少需要几步才能使所有灯变亮。

对于某一个游戏初始状态，若 6 步以内无法使所有灯变亮，则输出 −1。

数据范围

0<n≤500

输入样例：

输出样例：

3
2
-1

思路：

目标是把所有开关全部变成1，由于当上一行的状态确定时，若上一行存在0的状态，只能由下一行的位置影响上一行的0（注意这是四连通），因此可以使用递推
只要第0行开关状态确定，则所有开关的状态都可以递推出来，因此只要枚举第一行状态的所有情况，有 $2^5$ 种
从第0行递推出第1到第4行的所有状态，若当前行状态已确定，且存在开关是0状态的，则需要下一行的位置对开关进行切换，影响当前行开关是0的状态
最后枚举最后一行，若该状态全部是1，则表示成功，更新最小步数

语法：

char二维数组的输入方式
第一行一共32种状态，也就是 $[0, 31]$ ，op >> i & 1
每种枚举方式中，一开始用backup备份g，最后再备份回来
如果res大于6，直接赋值为-1
即使g二维数组是char类型，但可以g[a][b]^=1，0变成1，1变成0

#include <iostream>
#include <cstring>
using namespace std;

const int N = 6;

char g[N][N], backup[N][N];
int dx[5] = {0, 1, 0, -1, 0}, dy[5] = {1, 0, -1, 0, 0};

void turn(int x, int y)
{
    for (int i = 0; i < 5; i ++ )
    {
        int a = x + dx[i], b = y + dy[i];
        if (a < 0 || a > 4 || b < 0 || b > 4) continue;
        g[a][b] ^= 1;
    }
}

int main()
{
    int _; scanf("%d", &_);
    
    while (_ -- )
    {
        for (int i = 0; i < 5; i ++ ) cin >> g[i];
        
        int res = 10;
        for (int op = 0; op < 32; op ++ )
        {
            memcpy(backup, g, sizeof g);
            int step = 0;
            
            for (int i = 0; i < 5; i ++ )
                if (op >> i & 1)
                {
                    step ++ ;
                    turn(0, i);
                }
            
            for (int i = 0; i < 4; i ++ )
                for (int j =0 ; j < 5; j ++ )
                    if (g[i][j] == '0')
                    {
                        step ++ ;
                        turn(i + 1, j);
                    }
            
            bool dark = false;
            for (int i = 0; i < 5; i ++ )
                if (g[4][i] == '0')
                {
                    dark = true;
                    break;
                }
            
            if (!dark) res = min(res, step);
            memcpy(g, backup, sizeof backup);
        }
        
        if (res > 6) res = -1;
        printf("%d\n", res);
    }
}

习题

AcWing 93. 递归实现组合型枚举

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

输入格式
两个整数 n,m ,在同一行用空格隔开。

输出格式
按照从小到大的顺序输出所有方案，每行 1 个。

首先，同一行内的数升序排列，相邻两个数用一个空格隔开。

其次，对于两个不同的行，对应下标的数一一比较，字典序较小的排在前面（例如 1 3 5 7 排在 1 3 6 8 前面）。

数据范围

n>0 ,
0≤m≤n ,
n+(n−m)≤25

输入样例：

5 3

输出样例：

思考题：如果要求使用非递归方法，该怎么做呢？

思路：

dfs第一个参数为当前放到第i个位置（一共m个），第二个参数为这一次开始选择的数字（比上一次的大）
枚举边界为放到第m+1个位置，也就是说放完了
剪枝，加上后面放的数不足m个

#include <iostream>
using namespace std;

const int N = 30;

int n, m;
int state[N];

void dfs(int u, int start)
{
    if (u + n - start < m) return ;
    if (u == m + 1)
    {
        for (int i = 1; i <= m; i ++ )
            cout << state[i] << ' ';
        cout << endl;
        return ;
    }
    
    for (int i = start; i <= n; i ++ )
    {
        state[u] = i;
        dfs(u + 1, i + 1);
    }
}

int main()
{
    cin >> n >> m;
    
    dfs(1, 1);
    
    return 0;
}

AcWing 1209. 带分数

100 可以表示为带分数的形式：100=3+69258714
还可以表示为：100=82+3546197
注意特征：带分数中，数字 1∼9 分别出现且只出现一次（不包含 0）。

类似这样的带分数，100 有 11 种表示法。

输入格式
一个正整数。

输出格式
输出输入数字用数码 1∼9 不重复不遗漏地组成带分数表示的全部种数。

数据范围

1≤N<106

输入样例1：

输出样例1：

输入样例2：

输出样例2：

思路：

给一个数n，问有多少组 $a+\frac{b}{c}=n$ ，且abc三个数不重不漏地涵盖1-9这9个数字
暴力枚举9个数的全排列，然后用一个长度为9的数组保存全排列的结果
从全排列的结果中用两重循环暴力分解出三段，每段代表一个数
验证枚举出的三个数是否满足题干条件，若满足则计数

#include <iostream>
using namespace std;

int n, cnt;
bool st[10];
int state[10];

int calc(int l, int r)
{
    int res = 0;
    for (int i = l; i <= r; i ++ )
        res = res * 10 + state[i];
    return res;
}

void dfs(int u)
{
    if (u == 10)
    {
        for (int i = 1; i < 10; i ++ )
            for (int j = i + 1; j < 9; j ++ )
            {
                int a = calc(1, i);
                int b = calc(i + 1, j);
                int c = calc(j + 1, 9);
                
                if (a * c + b == n * c) cnt ++ ;
            }
        
        return ;
    }
    
    for (int i = 1; i <= 9; i ++ )
        if (!st[i])
        {
            state[u] = i;
            st[i] = true;
            dfs(u + 1);
            st[i] = false;
        }
}

int main()
{
    cin >> n;
    
    dfs(1);
    
    cout << cnt << endl;
    
    return 0;
}

AcWing 116. 飞行员兄弟

“飞行员兄弟”这个游戏，需要玩家顺利的打开一个拥有 16 个把手的冰箱。

已知每个把手可以处于以下两种状态之一：打开或关闭。

只有当所有把手都打开时，冰箱才会打开。

把手可以表示为一个 4×4 的矩阵，您可以改变任何一个位置 [i,j] 上把手的状态。

但是，这也会使得第 i 行和第 j 列上的所有把手的状态也随着改变。

请你求出打开冰箱所需的切换把手的次数最小值是多少。

输入格式
输入一共包含四行，每行包含四个把手的初始状态。

符号 + 表示把手处于闭合状态，而符号 - 表示把手处于打开状态。

至少一个手柄的初始状态是关闭的。

输出格式
第一行输出一个整数 N，表示所需的最小切换把手次数。

接下来 N 行描述切换顺序，每行输出两个整数，代表被切换状态的把手的行号和列号，数字之间用空格隔开。

注意：如果存在多种打开冰箱的方式，则按照优先级整体从上到下，同行从左到右打开。

数据范围

1≤i,j≤4

输入样例：

-+--
----
----
-+--

输出样例：

思路：

本题比较特殊，可以用代码把所有情况枚举一遍，会发现每种局面的操作方案是唯一的，所以第一次找到的解一定是最优解。
$2^{16}*16*16$

#include <iostream>
#include <cstring>
#include <vector>
using namespace std;

typedef pair<int, int> PII;

char g[4][4], backup[4][4];

int get(int x, int y)
{
    return x * 4 + y;
}

void turn_one(int x, int y)
{
    if (g[x][y] == '+') g[x][y] = '-';
    else g[x][y] = '+';
}

void turn_all(int x, int y)
{
    for (int i = 0; i < 4; i ++ )
    {
        turn_one(x, i);
        turn_one(i, y);
    }
    
    turn_one(x, y);
}

int main()
{
    for (int i = 0; i < 4; i ++ ) cin >> g[i];
    
    vector<PII> res;
    for (int op = 0; op < (1 << 16); op ++ )
    {
        memcpy(backup, g, sizeof backup);
        vector<PII> temp;
        
        for (int i = 0; i < 4; i ++ )
            for (int j = 0; j < 4; j ++ )
                if (op >> get(i, j) & 1)
                {
                    turn_all(i, j);
                    temp.push_back({i, j});
                }
                    
        bool has_closed = false;
        for (int i = 0; i < 4; i ++ )
            for (int j = 0; j < 4; j ++ )
                if (g[i][j] == '+')
                    has_closed = true;
        
        if (has_closed == false)
        {
            if (res.empty() || res.size() > temp.size()) res = temp;
        }
        
        memcpy(g, backup, sizeof backup);
    }
    
    cout << res.size() << endl;
    for (auto op : res) cout << op.first + 1 << ' ' << op.second + 1 << endl;
}

AcWing 1208. 翻硬币

小明正在玩一个“翻硬币”的游戏。

桌上放着排成一排的若干硬币。我们用 * 表示正面，用 o 表示反面（是小写字母，不是零）。

比如，可能情形是：oo*oooo

如果同时翻转左边的两个硬币，则变为：oooo***oooo

现在小明的问题是：如果已知了初始状态和要达到的目标状态，每次只能同时翻转相邻的两个硬币,那么对特定的局面，最少要翻动多少次呢？

我们约定：把翻动相邻的两个硬币叫做一步操作。

输入格式
两行等长的字符串，分别表示初始状态和要达到的目标状态。

输出格式
一个整数，表示最小操作步数

数据范围
输入字符串的长度均不超过100。
数据保证答案一定有解。

输入样例1：

**********
o****o****

输出样例1：

输入样例2：

*o**o***o***
*o***o**o***

输出样例2：

思路：

规则是每次翻转两个相邻的硬币，一个硬币要翻转必会使左右两边其中一个受到牵连，因此可以贪心单一方向进行牵连，就不会使之前翻好的硬币重新翻转

#include <iostream>
#include <cstring>
using namespace std;

const int N = 110;

int n;
char s1[N], s2[N];

void turn(int i)
{
    if (s1[i] == '*') s1[i] = 'o';
    else s1[i] = '*';
}

int main()
{
    cin >> s1 >> s2;
    
    n = strlen(s1);
    
    int res = 0;
    for (int i = 0; i < n; i ++ )
        if (s1[i] != s2[i])
        {
            turn(i), turn(i + 1);
            res ++ ;
        }
    
    cout << res << endl;
}

5pace

关注

0
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
蓝桥杯C++ AB组辅导课第一讲递归与递推 Acwing

第一讲递归与递推例题AcWing 92. 递归实现指数型枚举从 1∼n 这 n 个整数中随机选取任意多个，输出所有可能的选择方案。输入格式输入一个整数 n。输出格式每行输出一种方案。同一行内的数必须升序排列，相邻两个数用恰好 1 个空格隔开。对于没有选任何数的方案，输出空行。本题有自定义校验器（SPJ），各行（不同方案）之间的顺序任意。数据范围1≤n≤15输入样例：3输出样例：322 311 31 21 2 3思路：实际上每个数只要考虑选（1）和
复制链接

扫一扫