蓝桥杯刷题总结-合集(持续更新)
蓝桥杯刷题总结
待办：
- 0. 刷题前须知
- 1. 递归与递推
- 2. 二分
- 3. 前缀和
- 4. 数学
- 5. 枚举
- 6. 模拟
- 7. 排序
- 8. 双指针
- 9. BFS
- 10. 图论
- 11. 树状数组
- 12. 线段树
- 13. 贪心
- 14. 数论
- 15. 简单DP
- 16. 复杂DP
- 17. 杂题
- 18. 十一届蓝桥杯真题
- 19. 十二届蓝桥杯真题
BaseOn ： https://www.acwing.com
0、刷提前的须知
1、输入
in.next()和in.nextLine()
package com.caopeng.zero;
import java.util.Scanner;
/**
* @author Crescent_P
* @date 2021-12-02 19:41
*/
public class InputOutput1 {
public static void main(String[] args) {
// Scanner类输入
Scanner in = new Scanner(System.in);
// 整数
// int a = in.nextInt();
// 浮点数
// double v = in.nextDouble();
// 长整数
// long c = in.nextLong();
// short
// short d = in.nextShort();
// 字符串
String s1 = in.next(); // c++ 中的 cin/scanf 遇到空格结束
String s2 = in.nextLine(); // c++ 中的 gets 遇到回车结束
// 输入 abc def g
System.out.println("s1 :" + s1); // s1 :abc
System.out.println("s2 :" + s2); // s2 : def g
}
}
hasNext()
package com.caopeng.zero;
import java.util.Scanner;
/**
* @author Crescent_P
* @date 2021-12-02 19:41
*/
public class InputOutput2 {
public static void main(String[] args) {
// Scanner类输入
Scanner in = new Scanner(System.in);
// hasNext()
// hasNext()返回的是bool类型、当缓冲区有数据返回true
// 当缓冲区没有数据会发生阻塞、等待数据的输入
// 遇到多组输入，不知道什么时候能结束输入可以使用
// while(in.hasNext()) 相当于 while(scanf())
int a,b,c;
while(in.hasNext()){
a = in.nextInt();
b = in.nextInt();
c = in.nextInt();
System.out.printf("%d\n",a+b+c); // 模式化输出
}
}
}
2、输出
// 常见的输出
System.out.println(); // 带换行的
System.out.print(); // 不带换行的
System.out.printf(); // 格式化输出，相当于c/c++ 的 printf
3、快速输出输出
BufferedReader和BufferedWriter实现
4、集合容器
1、递归与递推
递归实现指数型枚举
java
import java.util.*;
public class Main{
static Scanner in = new Scanner(System.in); // 输入
// 看题目范围 n是1到15，我们稍微把数组开大一点点、防止数组越界。
static int max = 20,n;
// 判断每一位是否被用过
static boolean[] st = new boolean[max];
public static void main(String[] args){
n = in.nextInt();
dfs(0);
}
// dfs(深度优先搜索)
private static void dfs(int u){
// 搜索到最后一位
if(u == n){
// 打印输出
for(int i = 0;i < n;i++){
if(st[i]) System.out.printf("%d ",i+1);
}
System.out.println();
return;
}
// 要第u位
st[u] = true;
dfs(u+1);
// 不要第u位
st[u] = false;
dfs(u+1);
}
}
C/C++
#include
using namespace std;
const int N = 20;
bool st[N];
int n;
void dfs(int u){
// 递归到了叶子节点
if(u == n){
for(int i = 0;i < n;i++){
if(st[i]) cout << i + 1 << " ";
}
cout << endl; // 换行
return;
}
// 选
st[u] = true;
dfs(u+1);
// 不选
st[u] = false;
dfs(u+1);
}
int main(){
cin >> n;
dfs(0);
return 0;
}
递归实现排列型枚举
Java
import java.util.*;
import java.io.*;
public class Main {
static Scanner in = new Scanner(System.in);
static int max = 10, n;
static int[] path = new int[max]; // 存储路径
static boolean[] st = new boolean[max]; // 记录每个数字是否被使用了
static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
public static void main(String[] args)throws Exception{
n = in.nextInt();
dfs(0);
out.flush();
}
private static void dfs(int u) throws Exception{
if(u == n){
for(int i = 0;i < n;i++) out.write(path[i] + " "); // 快速写出
out.write("\n"); // 换行
return;
}
for(int i = 0;i < n;i++){
if(!st[i]){
st[i] = true;
path[u] = i+1;
dfs(u+1);
st[i] = false;
path[u] = 0;
}
}
}
}
C/C++
#include
using namespace std;
const int N = 10;
int path[N];
bool st[N];
int n;
void dfs(int u){
if(u == n){
for(int i = 0;i < n;i++) cout << path[i] << " ";
cout << endl;
return;
}
for(int i = 0;i < n;i++){
if(!st[i]){
st[i] = true;
path[u] = i+1;
dfs(u+1);
st[i] = false;
}
}
}
int main(){
cin >> n;
dfs(0);
return 0;
}
递归实现组合型枚举
Java
import java.util.*;
public class Main{
static Scanner in = new Scanner(System.in);
static int max = 30,n,m;
static int[] path = new int[max];
public static void main(String[] args){
n = in.nextInt();
m = in.nextInt();
dfs(0);
return;
}
public static void dfs(int u){
if(u == m){
for(int i = 0;i < m;i++) System.out.printf("%d ",path[i]);
System.out.println();
return;
}
for(int i = 1;i <= n;i++){
if(u == 0) path[u] = i;
else {
if(path[u-1] < i) path[u] = i;
else continue;
}
dfs(u+1);
}
}
}
C/C++
#include
using namespace std;
const int N = 30;
int path[N];
int n,m;
void dfs(int u){
if(u == m){
for(int i = 0;i < m;i++) cout << path[i] << " ";
cout << endl;
return;
}
for(int i = 1;i <= n;i++){
if(u == 0) path[u] = i;
else{
// 前一位要比这一位小
if(path[u-1] < i) path[u] = i;
else continue;
}
dfs(u+1);
}
}
int main(){
cin >> n >> m;
dfs(0);
return 0;
}
简单的斐波那契数列
java
import java.util.*;
public class Main{
static Scanner in = new Scanner(System.in);
static int n,a = 0,b = 1;
public static void main(String[] args){
n = in.nextInt();
for(int i = 0;i < n;i++){
System.out.printf("%d ",a);
int temp = a + b;
a = b;
b = temp;
}
}
}
C/C++
#include
using namespace std;
// 递推公式
// a[i] = a[i-1] + a[i-2]
int n;
int main(){
int a = 0,b = 1;
cin >> n;
for(int i = 0;i < n;i++){
cout << a << " ";
int temp = a + b;
b = a;
a = temp;
}
cout << endl;
return 0;
}
费解的开关
想写出这个题目，首先得分析出几个点：
- 每个灯泡只能被摁一次，因为摁两次不会有任何改变，并且还多了步数
- 摁的顺序是无所谓的，先摁哪个再摁哪个是没关系的。
依靠上面两个结论，我们来看这一题：
- 我们可以先只看第一行，第一行我们可以随意摁，但是每个灯泡只能被操作一次。
- 第一行被操作过了，轮到第二行，此时第一行如果还有灭的，只能通过第二行来将其熄灭。逻辑就是这样，下面的每一行的灯泡是否操作，都是看上一行灯灯泡的状态。
因此：
- 我们枚举第一行的所有状态
- 怎么枚举，第一行一共5个灯泡、每个灯泡开或关有两种状态、那么就是2^5=32种状态
- 之后根据当前第一行的状态去操作后续的行
- 到最后一行、看是否有开的，如果有，说明不能全灭
C/C++
#include
using namespace std;
const int N = 6;
char g[N][N],backup[N][N];
// 偏移量,用于遍历(x,y)的上下左右中
int dx[5] = {1,0,-1,0,0},dy[5] = {0,1,0,-1,0};
// 将(x,y)的上下左右摁一遍
void turn(int x,int y){
for(int i = 0;i < 5;i++){
int nx = x + dx[i],ny = y + dy[i];
if(nx < 0 || nx > 5 || ny < 0 || ny > 5) continue; // 外界不需要考虑
if(g[nx][ny] == '0') g[nx][ny] = '1';
else g[nx][ny] = '0';
}
}
int main(){
int T;
cin >> T;
while(T--){
// 将图读入
for(int i = 0;i < 5;i++) cin >> g[i];
// 第一行一共5个按钮,每个按钮开或不开一共2种情况,2^5 = 32
int ans = 10;
for(int op = 0;op < 32;op++){
memcpy(backup,g,sizeof g); // 将 g的内容放入backup中备份
int step = 0; // 操作的步数
// 第一行所有情况
for(int i = 0;i < 5;i++){
// 当前对应了1就操作
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) ans = min(ans,step);
memcpy(g,backup,sizeof g); // 将 g的内容放入backup中备份
}
if(ans > 6) ans = -1;
cout << ans << endl;
}
return 0;
}
java
import java.util.*;
public class Main{
static Scanner in = new Scanner(System.in);
static int max = 5;
static char[][] g = new char[max][max];
static char[][] backup = new char[max][max];
static int[] dx = {1,0,-1,0,0},dy = {0,1,0,-1,0};
public static void main(String[] args){
int T = in.nextInt();
// T个测试样例
while(T-- > 0){
// 读入图
int res = 10;
for(int i = 0;i < 5;i++) g[i] = in.next().toCharArray();
// 要对图进行一次备份
for(int i = 0;i < 5;i++){
for(int j = 0;j < 5;j++) backup[i][j] = g[i][j];
}
// 第一行有5个格子,每个格子开或关有2种可能,一共2^5=32种,我们这里采用二进制来表示
for(int op = 0;op < 32;op++){
int step = 0;
// 先操作第一行
for(int i = 0;i < 5;i++){
// 当前位是1就进行一次操作
if((op >> i & 1) == 1){
turn(0,i);
step++;
}
}
// 通过上一行操作下一行
for(int i = 0;i < 4;i++){
for(int j = 0;j < 5;j++){
// 当前是灭的,那么下一行对应的就要开
if(g[i][j] == '0'){
turn(i+1,j);
step++;
}
}
}
// 判断最后一行有没有灭的
boolean dark = false;
for(int i = 0;i < 5;i++){
if(g[4][i] == '0'){
dark = true;
break;
}
}
// 全灭的话
if(!dark) res = Math.min(res,step);
// 对图进行还原
for(int i = 0;i < 5;i++){
for(int j = 0;j < 5;j++) g[i][j] = backup[i][j];
}
}
// 超过步数
if(res > 6) res = -1;
// 此时已经遍历了32种情况
System.out.println(res);
}
}
public static void turn(int x,int y){
for(int i = 0;i < 5;i++){
int nx = x + dx[i],ny = y + dy[i];
if(nx < 0 || nx >= 5 || ny < 0 || ny >= 5) continue; // 出界不需要考虑
if(g[nx][ny] == '0') g[nx][ny] = '1';
else g[nx][ny] = '0';
}
}
}
翻硬币
按照之前的思考：
- 每个硬币只会主动被翻一次(因为旁边的翻动不是主动翻动)
- 翻动的顺序没有关系
对于此题：
我们可以就从左到右枚举，当前对应位不一样，就翻转一下即可。
c/c++
#include
using namespace std;
string a,b;
int ans = 0;
int main(){
cin >> a >> b;
int n = a.length();
for(int i = 0;i < n - 1;i++){
// 当前字符不相等,就要翻转,
// 翻转后一定相等,就不用判断了
// 但是只要翻转了,下一个字符就一定会改
if(a[i] != b[i]){
ans++;
if(a[i+1] == '*') a[i+1] = 'o';
else a[i+1] = '*';
}
}
cout << ans << endl;
}
Java
import java.util.*;
import java.io.*;
public class Main{
static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
static int N = 110;
static char[] begin = new char[N],end = new char[N];
public static void main(String[] args)throws Exception{
int ans = 0;
// 读入
String a = in.readLine();
String b = in.readLine();
begin = a.toCharArray();
end = b.toCharArray();
for(int i = 0;i < begin.length-1;i++){
if(begin[i] != end[i]){
if(begin[i+1] == '*') begin[i+1] = 'o';
else begin[i+1] = '*';
ans++;
}
}
in.close();
System.out.println(ans);
}
}
飞行员兄弟
C/C++
#include
#define x first
#define y second
using namespace std;
typedef pair PII;
const int N = 5;
char g[N][N],backup[N][N];
// 将二维映射成一维
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] = '-';
}
// 将x行,y列的所有操作一遍
void turn_all(int x,int y){
for(int i = 0;i < 4;i++){
turn_one(i,y);
turn_one(x,i);
}
// 上面导致(x,y)改变了两次,抵消了
turn_one(x,y);
}
int main(){
// 读入图
for(int i = 0;i < 5;i++) cin >> g[i];
vector ans;
// 枚举所有的情况
for(int op = 0;op < 1 << 16;op++){
memcpy(backup,g,sizeof g); // 备份
// 这一种情况的操作
vector temp;
// 对每一个点继续操作
for(int i = 0;i < 4;i++){
for(int j = 0;j < 4;j++){
// 点是二维的,我们映射成一维好操作
if(op >> get(i,j) & 1){
temp.push_back({i,j}); // 将操作入队列
turn_all(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){
// ans为空或者ans的操作步骤比temp多
if(ans.empty() || ans.size() > temp.size()) ans = temp;
}
memcpy(g,backup,sizeof g); // 还原
}
// 输出
cout << ans.size() << endl;
for(auto op : ans){
cout << op.x + 1 << " " << op.y+1 << endl;
}
return 0;
}
Java
import java.util.*;
public class Main{
static int N = 4;
static char[][] g = new char[N][N],backup = new char[N][N];
static Scanner in = new Scanner(System.in);
static List<int[]> ans = new ArrayList<>();
public static void main(String[] args){
// 把图给读进来
for(int i = 0;i < 4;i++) g[i] = in.next().toCharArray();
// 一共16个开关,全部枚举,2^16
for(int op = 0;op < (1 << 16);op++){
List<int[]> temp = new ArrayList<>();
// 备份图
for(int i = 0;i < 4;i++){
for(int j = 0;j < 4;j++){
backup[i][j] = g[i][j];
}
}
// 遍历每一个点
for(int i = 0;i < 4;i++){
for(int j = 0;j < 4;j++){
// 为1就是要操作
if(((op >> get(i,j)) & 1) == 1){
turn_all(i,j);
temp.add(new int[]{i,j});
}
}
}
// 此时遍历完了,看是否全打开了
boolean 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){
if(ans.isEmpty() || ans.size() > temp.size() ) ans = temp;
}
// 复原
for(int i = 0;i < 4;i++){
for(int j = 0;j < 4;j++){
g[i][j] = backup[i][j];
}
}
}
System.out.println(ans.size());
for(int[] res : ans){
System.out.printf("%d %d\n",res[0]+1,res[1]+1);
}
}
public static int get(int x,int y){
return 4 * x + y;
}
public static 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);
}
public static void turn_one(int x,int y){
if(g[x][y] == '-') g[x][y] = '+';
else g[x][y] = '-';
}
}
带分数
思路一：
- 将带分数形式化为 ： n = a + b / c
- 其中a、b、c 就是1~9的组合
- 再简化 就是 n * c = a * c + b
- 这样我们只要枚举所有的a、b、c
- 能够让上面的等式成立即可
- 如何枚举所有所有的a、b、c呢？
- 通过之前的递归实现排列型枚举、也是全排列即可
C/C++
#include JAVA
import java.util.*;
public class Main{
static int N = 10;
static int[] path = new int[N]; // 用于储存全排列
static boolean[] st = new boolean[N];
static Scanner in = new Scanner(System.in);
static int n,ans = 0;
public static void main(String[] args){
n = in.nextInt();
dfs(1);
System.out.println(ans);
}
private static void dfs(int u){
// 此时path以及存好了全排列
if(u == N){
for(int i = 1;i <= 7;i++){
for(int j = i+1;j <= 8;j++){
int a = cala(1,i);
int b = cala(i+1,j);
int c = cala(j+1,9);
if(n*c == a*c + b) ans++;
}
}
}
for(int i = 1;i < N ;i++){
if(!st[i]){
path[u] = i;
st[i] = true;
dfs(u+1);
st[i] = false;
}
}
}
public static int cala(int l,int r){
int sum = 0;
for(int i = l;i <= r;i++){
sum *= 10;
sum += path[i];
}
return sum;
}
}
思路二：
- 根据上面可知 n * c = a * c + b
- 等式中三个位置数，知道其中两个即可
- 那么我们枚举a和c，就可以得到b
- 判断b是否符合要求、如果符合要求即可
c/c++
#include Java
import java.util.*;
public class Main{
static int N = 10;
static boolean[] st = new boolean[N]; // 每一位只能使用一次
static Scanner in = new Scanner(System.in);
static int n,ans = 0;
public static void main(String[] args){
n = in.nextInt();
// 从1开始搜索,此时a为0
dfs_a(1,0);
System.out.println(ans);
}
private static void dfs_a(int u,int a){
// 第十位
if(u == N) return;
// 剪枝,a不可能大于n
if(a > n) return;
// 递归遍历c
if(a > 0) dfs_c(u,a,0);
for(int i = 1;i < N;i++){
if(!st[i]){
st[i] = true;
// 递归a
dfs_a(u+1,a*10+i);
st[i] = false;
}
}
}
private static void dfs_c(int u,int a,int c){
if(u == N) return;
// 判断此时的ac是否满足条件
if(check(a,c)) ans++;
for(int i = 1;i < N;i++){
if(!st[i]){
st[i] = true;
// 递归c
dfs_c(u+1,a,c*10+i);
st[i] = false;
}
}
}
// 判断是否满足条件
private static boolean check(int a,int c){
int b = n * c - a * c;
// a b c 都是正数
if(b <= 0 || a <= 0 || c <= 0) return false;
// 判断是否有重复使用的数
boolean[] backup = new boolean[N];
// 使用备份来判断
for(int i = 1;i < N;i++) backup[i] = st[i];
while(b > 0){
int x = b %10;
b /= 10;
if(x == 0 || backup[x]) return false;
backup[x] = true;
}
// 判断1~9是否每一位都使用过
for(int i = 1;i < N;i++){
if(!backup[i]) return false;
}
return true;
}
}
2、二分
整数二分模板
数的范围
C/C++
#include Java
机器人跳跃问题
C/C++
#include JAVA
分巧克力
C/C++
#include 数的三次方根
这个就是浮点数二分问题
C/C++
#include 四平方和
C\C++
暴力，能过一定的点，最终TLE
#include哈希
数据太强了、hash也卡
STL的哈希表
#include手写哈希表可以过
#include3、前缀和
前缀和公式推导
前缀和
C/C++
#include K倍区间
C/C++
#include 二维前缀和公式推导
子矩阵的和
C/C++
#include Java
激光炸弹
4、数学
买不到的数目
#include 蚂蚁感冒
#include 饮料换购
#include 15、简单DP
动态规划分析方法
01背包问题
#include 摘花生
#include 最长上升子序列
#include