蓝桥杯刷题

kkkwang0o0

已于 2024-05-25 22:12:31 修改

阅读量1k

点赞数 14

分类专栏：蓝桥杯文章标签：蓝桥杯算法职场和发展

于 2024-03-31 15:37:29 首次发布

本文链接：https://blog.csdn.net/m0_73569492/article/details/136516303

版权

蓝桥杯专栏收录该内容

1 篇文章 0 订阅

订阅专栏

递归与递推

递归

1.指数型枚举

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

思路：枚举每一位对应的数字选与不选，例如：第一位对应的数字为1，有一种方案是选1，另外一种方案是不选

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

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 20;
int n;
bool st[N];
void dfs(int u)
{
    if (u > n)
    {
        for (int i = 1; i <= n; i ++)
        {
            if (st[i]) cout << i << ' ';
        }
        cout << endl;
        return ; //选完三个数，回溯
    }
    //选当前位置所对应的数
    st[u] = true; //选的数标记为true
    dfs(u + 1); //递归到下一位
    
    //不选当前位置所对应的数
    st[u] = false;
    dfs(u + 1);
}
int main()
{
    cin >> n;
    dfs(1);
    return 0;
}

2.排列形枚举

解析：把 1 ∼ n 这 n 个整数排成一行后随机打乱顺序

思路：考虑每一位可以填哪几个数，用过的数字需要标记

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

#include <algorithm>
#include <iostream>


using namespace std;

const int N = 20;
int n;
int path[N], cnt;
bool st[N];

void dfs(int u)
{
    if (u > n)
    {
        for (int i = 1; i <= n; i ++)
            cout << path[i] << ' ';
            
        cout << endl;
        return; //回溯
    }
    
    for (int i = 1; i <= n; i ++)
    {
        if (!st[i])
        {
            path[u] = i;
            st[i] = true; //标记
            dfs(u + 1);
            st[i] = false; //恢复现场
        }
    }
}
int main()
{
    cin >> n;
    dfs(1);
    return 0;
}

3.组合型枚举

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

思路：画一棵递归搜索树

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

输入样例：

5 3

输出样例：

#include <iostream>

using namespace std;

const int N = 50;
int path[N];
bool st[N];
int n, m;

void dfs(int u, int last)
{
    //剪枝：当可填入数字小于当前空缺的位数时
    if (n - last < m - u) return;
    //当所有位数全部填满，输出结果，回溯
    if (u > m)
    {
        for (int i = 1; i <= m; i ++) printf("%d ", path[i]);
        puts("");
        return;
    }
    
    //填入数字
    for (int i = last; i <= n; i ++)
    {
        if (!st[i])
        {
            path[u] = i;
            st[i] = true;
            dfs(u + 1, i);
            st[i] = false; //恢复现场
        }
    }
}
int main()
{
    scanf("%d%d", &n, &m);
    
    dfs(1, 1);
    
    return 0;
}

递推

斐波那契

解析：其数值为：1、1、2、3、5、8、13、21、34……在数学上，这一数列以如下递推的方法定z义：F(0)=1，F(1)=1, F(n)=F(n - 1)+F(n - 2)

AcWing 717. 简单斐波那契

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 50;
int n, a[N];

int main()
{
    cin >> n;
    if (n == 1) cout << "0" << endl;
    else
    {
        a[0] = 0;
        a[1] = 1;
        
        cout << a[0] << ' ' << a[1];
        for (int i = 2; i < n; i ++)
        {
            a[i] = a[i - 1] + a[i - 2];
            cout << ' ' << a[i];
        }
        cout << endl;
    }
    return 0;
}

习题：

费解的开关

解析：每一盏灯都有两种选择：按或者不按。

通过递推发现规律：1. 当第一行的操作方案确定时，剩余行的操作方案也确定了

2.前一行的状态影响下一行的操作

举例：

假设第一行选择某一种方案进行操作后的状态如图所示：

第一行的状态决定了第二行的操作（要使得第一行灯灭的格子变亮，就必须对该格子下方的方格进行操作）：

操作完成后第一行的格子全亮

以此类推......

思路：

1.枚举第一行格子的每一种操作方案

2.枚举前四行的状态，操作下一行，使得前四行的格子全亮

3.判断最后一行格子是否全亮

题目：

你玩过“拉灯”游戏吗？

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

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

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

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

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

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

输入格式

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

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

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

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

输出格式

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

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

数据范围

0<n≤500

输入样例：
3
00111
01011
10001
11010
11100

11101
11101
11110
11111
11111

01111
11111
11111
11111
11111
输出样例：
3
2
-1

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 10;
int n;
int g[N][N], backup[N][N];
string s[N];
int dx[] = {0, 1, -1, 0 , 0};
int dy[] = {0, 0, 0, 1, -1};

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 < 5 && b >= 0 && b < 5)
        {
            if (g[a][b] == 0) g[a][b] = 1;
            else g[a][b] = 0;
        }
    }
}
int main()
{
   scanf ("%d", &n);
   
   while (n --)
   {
       int res = 10;
       
       for (int i = 0; i < 5; i ++) cin >> s[i];
       
       for (int i = 0; i < 5; i ++)
           for (int j = 0; j < 5; j ++)
                g[i][j] = s[i][j] - '0';
                
        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;
        cout << res << endl;
   }
}

AcWing 1209. 带分数

解析： n = a + b / c

经过变形得：b = nc - ac

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 10;
bool st[N], backup[N];
int n, ans;
//n = a + b / c
//b = nc - ac

//判断a, b, c是否满足要求
bool check(int a, int c)
{
    long long b = n * (long long)c - a * c;
    
    if (!a || !b || !c) return false;
    
    memcpy(backup, st, sizeof st);
    
    while (b)
    {
        int x = b % 10;
        b /= 10;
        if (!x || backup[x]) return false;
        backup[x] = true;
    }
    
    for (int i = 1; i <= 9; i ++)
        if (!backup[i]) return false;
        
    return true;
}
void dfs_c(int u, int a, int c)
{
    if (u > 9) return;

    if (check(a, c)) ans ++;
    
    for (int i = 1; i <= 9; i ++)
    {
        if (!st[i])
        {
            st[i] = true;
            dfs_c(u + 1, a, c * 10 + i);
            st[i] = false;
        }
    }
}
//u当前用了几位数 当前a为多少
void dfs_a(int u, int a)
{
    if (a >= n) return;
    
    if (a) dfs_c(u, a, 0);
    
    for (int i = 1; i <= 9; i ++)
    {
        if (!st[i])
        {
            st[i] = true;
            dfs_a(u + 1, a * 10 + i);
            st[i] = false;
        }
    }
}
int main()
{
    scanf("%d", &n);
    
    dfs_a(0, 0); //dfs_a(u, a);
    
    printf("%d\n", ans);
    
    return 0;
}

AcWing 116. 飞行员兄弟

输入样例：

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

输出样例：

分析：

类似于费解的开关：初始状态为4 * 4, 对于这16个可操作的位置，每一个位置可选方案为两种，一共有2^16种操作方案,枚举这2^16种方案

#include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>

using namespace std;

typedef pair<int, int> PII;
const int N = 10;
char g[N][N], backup[N][N];
vector<PII> ans;
void turn(int x, int y)
{
    for (int i = 0; i < 4; i ++)
    {
        if (g[x][i] == '+') g[x][i] = '-';
        else g[x][i] = '+';
        
        if (g[i][y] == '+') g[i][y] = '-';
        else g[i][y] = '+';
    }
    
    if (g[x][y] == '+') g[x][y] = '-';
    else if (g[x][y] == '-') g[x][y] = '+';
}
int main()
{
    for (int i = 0; i < 4; i ++) scanf("%s", g[i]);
    
    
    for (int op = 0; op < (1 << 16); op ++)
    {
        memcpy(backup, g, sizeof g);
        vector<PII> tmp;
        int step = 0;
        for (int i = 0; i < 4; i ++)
        {
            for (int j = 0; j < 4; j ++)
            {
                int x = i * 4 + j;
                if (op >> x & 1)
                {
                    turn(i, j);
                    tmp.push_back({i + 1, j + 1});
                    step ++;
                }
            }
        }
        
        bool flag = true;
        for (int i = 0; i < 4; i ++)
        {
            for (int j = 0; j < 4; j ++)
            {
                if (g[i][j] == '+')
                {
                    flag = false;
                }
            }
        }
        if (flag)
        {
            if (ans.empty() || tmp.size() < ans.size())
            {
                ans = tmp;
            }
        }
        memcpy(g, backup, sizeof g);
    }
    cout << ans.size() << endl;
    for (auto it : ans) cout << it.first << ' ' << it.second << endl;
}

二分与前缀和

二分查找

图解分析：

模板：

从左边开始找：

int l = 0;
int r = n - 1;
while (l < r)
{
     int mid = (l + r) / 2;
     if (a[mid] >= x) r = mid;
     else l = mid + 1;
}

从右边开始找：

l = 0;
r = n - 1;
while(l < r)
{
    int mid = (l + r + 1) / 2;
    if (a[mid] <= x) l = mid;
    else r = mid - 1;
}

大概思路：

根据a[mid]与x的大小关系，不断更新左右区间

二分例题:

AcWing 1221. 四平方和

思路：

1.先枚举c和d，将c和d的结果用一个结构体存储起来

2.再枚举a和b，在存储的结构体数组中查找与a和b互补的结果

注意：结构体数组要按字典序排列，必须从小到大依次排好，只有这样，查找到的第一个结果是按字典序排列的

代码：

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 25000010;

int cnt;
struct Sum {
    int s, c, d;
    bool operator < (const Sum &t)const{
        if (s != t.s) return s < t.s;
        if (c != t.c) return c < t.c;
        return d < t.d;
    }
}sum[N];


int main()
{
    int n;
    scanf("%d", &n);
    
    for (int c = 0; c * c <= n; c ++)
    {
        for (int d = c; c * c + d * d <= n; d ++)
        {
            sum[cnt ++] = {c * c + d * d, c, d};
        }
    }
    
    sort(sum, sum + cnt);
    
    for (int a = 0; a * a <= n; a ++)
    {
        for (int b = a; a * a + b * b <= n; b ++)
        {
            int t = n - (a * a + b * b);
            
            int l = 0, r = cnt - 1;
            
            while (l < r)
            {
                int mid = (l + r) / 2;
                
                if (sum[mid].s >= t) r = mid;
                else l = mid + 1;
            }
            
            if (sum[l].s == t)
            {
                printf("%d %d %d %d\n", a, b, sum[l].c, sum[l].d);
                return 0;
            }
        }
    }
}

前缀和：

一维前缀和：

图解分析：

模板：

int n, m;
int sum[N];
void Prefix_and(int a[])
{
    for (int i = 1; i <= n; i ++ )  sum[i] = sum[i - 1] + a[i];
}
int Sum(int l, int r)
{
    return sum[r] - sum[l - 1];
}

一维前缀和例题（C++版）：

Acwing795.前缀和

#include <iostream>

using namespace std;

const int N = 100010;

int n, m;
int sum[N];
void Prefix_and(int a[])
{
    for (int i = 1; i <= n; i ++ )  sum[i] = sum[i - 1] + a[i];
}
int Sum(int l, int r)
{
    return sum[r] - sum[l - 1];
}
int main()
{
    cin >> n >> m;
   
    int a[N];
    for (int i = 1; i <= n; i ++ ) scanf("%d", &a[i]);
    Prefix_and(a);
    while (m --)
    {
        int l, r;
        cin >> l >> r;
        cout << Sum(l, r) << endl;;
    }
}

二维前缀和：

图解分析：

模板：

int n, m;
int sum[N][N];
void Prefix_and(int a[N][N])
{
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )
            sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + a[i][j];
}
int Sum(int x1, int y1, int x2, int y2)
{
    int res = sum[x2][y2] - sum[x2][y1 - 1] - sum[x1 - 1][y2] + sum[x1 - 1][y1 - 1];
    return res;
}

二维前缀和例题（C++版）：

Acwing796.子矩阵的和

#include <iostream>

using namespace std;

const int N = 1010;
int n, m;
int sum[N][N];
void Prefix_and(int a[N][N])
{
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )
            sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + a[i][j];
}
int Sum(int x1, int y1, int x2, int y2)
{
    int res = sum[x2][y2] - sum[x2][y1 - 1] - sum[x1 - 1][y2] + sum[x1 - 1][y1 - 1];
    return res;
}
int main()
{
    int q;
    cin >> n >> m >> q;
    
    int a[N][N];
    for (int i = 1; i <= n; i ++ ) 
        for (int j = 1; j <= m; j ++ )
            cin >> a[i][j];
    Prefix_and(a);
    while (q --)
    {
        int x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;
        
        cout << Sum(x1, y1, x2, y2) << endl;
    }
}

前缀和例题：

AcWing 1230. K倍区间

分析：

代码：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;
const int N = 1e5 + 10;
LL s[N], cnt[N];
int n, k;

int main()
{
    scanf("%d%d", &n, &k);
    for (int i = 1; i <= n; i ++)
    {
        scanf("%lld", &s[i]);
        s[i] += s[i - 1];
    }
    
    
    LL res = 0;
    cnt[0] = 1; //s[0] = 0, s[0] % k = 0
    
    for (int i = 1; i <= n; i ++)
    {
        res += cnt[s[i] % k];
        
        cnt[s[i] % k] ++;
    }
    
    printf("%lld\n", res);
    return 0;
}

数学知识

基础知识：

数学知识总结-CSDN博客文章浏览阅读84次。数学知识总结https://blog.csdn.net/m0_73569492/article/details/133841389?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522171229013416800182136639%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=171229013416800182136639&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_ecpm_v1~rank_v31_ecpm-1-133841389-null-null.nonecase&utm_term=%E6%95%B0%E5%AD%A6%E7%9F%A5%E8%AF%86&spm=1018.2226.3001.4450

例题：

AcWing 1205. 买不到的数目

思路分析：

裴蜀定理（来自百度百科）：

对任何整数a、b和它们的最大公约数d，关于未知数x和y的线性不定方程（称为裴蜀等式）：若a,b是整数,且gcd(a,b)=d，那么对于任意的整数x,y,ax+by都一定是d的倍数，特别地，一定存在整数x,y，使ax+by=d成立。

一个重要推论是：a,b互质的充分必要条件是存在整数x,y使ax+by=1

一个结论：

如果a，b互质，那么由ax+by，x >= 0, y >= 0不能凑出的最大数是ab-a-b

代码：

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

int main()
{
    int p, q;
    cin >> p >> q;
    cout << p * q - p - q << endl;
    return 0;
}

AcWing 1211. 蚂蚁感冒

输入样例1：

3
5 -2 8

输出样例1：

输入样例2：

5
-10 8 -20 12 25

输出样例2：

思路分析：

代码：

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 110;
int n, x[N];
int main()
{
    cin >> n;
    for (int i = 0; i < n; i ++)
        cin >> x[i];
        
    int l = 0, r = 0; //左边向右，右边向左
    
    for (int i = 0; i < n; i ++)
    {
        if (abs(x[i]) < abs(x[0]) && abs(x[i]) == x[i]) l ++;
        if (abs(x[i]) > abs(x[0]) && abs(x[i]) != x[i]) r ++;
    }
    
    int res = 1;
    if (x[0] > 0 && r != 0 || x[0] < 0 && l != 0) res += (l + r);
    cout << res << endl;
}

AcWing 1216. 饮料换购

小tips：

代码：

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

int main()
{
    int n;
    cin >> n;
    
    int cnt = 0;
    while (n >= 3)
    {
        int t = n / 3;
        n = n - t * 2;
        cnt = cnt + 3 * t;
    }
    cnt += n;
    cout << cnt << endl;
}

动态规划

基础知识：

动态规划总结（闫氏Dp分析法）-CSDN博客文章浏览阅读162次。动态规划总结https://blog.csdn.net/m0_73569492/article/details/133935136?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522171232251816800182120954%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=171232251816800182120954&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_ecpm_v1~rank_v31_ecpm-8-133935136-null-null.nonecase&utm_term=%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92&spm=1018.2226.3001.4450

例题：

AcWing 1212. 地宫取宝

输入样例1：

2 2 2
1 2
2 1

输出样例1：

输入样例2：

2 3 2
1 2 3
2 1 5

输出样例2：

思路分析：

代码：

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 55, mod = 1e9 + 7;
int n, m, k;
int g[N][N];
int f[N][N][15][15]; //f(i, j, k, w)  
int main()
{
    scanf("%d%d%d", &n, &m, &k);
    
    for (int i = 1; i <= n; i ++)
        for (int j = 1; j <= m; j ++)
        {
            scanf("%d", &g[i][j]);
            g[i][j] ++;
        }
    
    //第一个数拿
    f[1][1][1][g[1][1]] = 1;
    //第一个数不拿
    f[1][1][0][0] = 1;
    
    for (int i = 1; i <= n; i ++)
    {
        for (int j = 1; j <= m; j ++)
        {
            //第一个格子已经初始化过
            if (i == 1 && j == 1) continue;
            
            for (int u = 0; u <= k; u ++)
            {
                for (int v = 0; v <= 13; v ++)
                {
                    int &val = f[i][j][u][v];
                    
                    val = (val + f[i - 1][j][u][v]) % mod;
                    val = (val + f[i][j - 1][u][v]) % mod;
                    if (u > 0 && v == g[i][j])
                    {
                        for (int t = 0; t < v; t ++)
                        {
                            val = (val + f[i][j - 1][u - 1][t]) % mod;
                            val = (val + f[i - 1][j][u - 1][t]) % mod;
                        }
                    }
                }
            }
        }
    }
    
    int res = 0;
    for (int i = 0; i <= 13; i ++)
        res = (res + f[n][m][k][i]) % mod;
        
    printf("%d\n", res);
}

AcWing 1214. 波动数列

思路分析：

代码：

#include <iostream>
#include <cstring>

using namespace std;

const int N = 1100, mod = 1e8 + 7;
int n, s, a, b;
int f[N][N];

int get_mod(int x, int d) //x % d的正余数
{
    return (x % d + d) % d;
}
int main()
{
    scanf("%d%d%d%d", &n, &s, &a, &b);
    
    f[0][0] = 1;
    for (int i = 1; i < n; i ++)
    {
        for (int j = 0; j < n; j ++)
        {
            f[i][j] = (f[i - 1][get_mod(j + a * i, n)] + f[i - 1][get_mod(j - b * i, n)]) % mod;
        }
    }
        
    printf("%d\n", f[n - 1][get_mod(s, n)]);
}

该博客根据AcWing蓝桥杯辅导课总结得来！！！