报名明年4月蓝桥杯软件赛的同学们，如果你是大一零基础，目前懵懂中，不知该怎么办，可以看看本博客系列：备赛20周合集
20周的完整安排请点击：20周计划
每周发1个博客，共20周（读者可以按自己的进度选"正常"和"快进"两种计划）。
每周3次集中答疑，周三、周五、周日晚上，在QQ群上答疑：
文章目录
- [0. 上周答疑](#0. 上周答疑)
- [1. 精讲题](#1. 精讲题)
-
- [1.1 修剪灌木](#1.1 修剪灌木)
- [1.2 英文数字计数](#1.2 英文数字计数)
- [1.3 矩形拼接](#1.3 矩形拼接)
- [1.4 最少砝码](#1.4 最少砝码)
- [1.5 蜂巢](#1.5 蜂巢)
- [1.6 立方体表面距离](#1.6 立方体表面距离)
- [2. 刷题](#2. 刷题)
第 4周: 杂题-2
0. 上周答疑
伪代码怎么转化Java语言？
C/C++、Java、Python代码怎么互转？
回答：用大数据模型转 ，例如文心一言3.5，是免费的。
在转换代码这件事上，大数据模型做得很好。
1. 精讲题
本周还是杂题！
大家是不是感到太慢了，什么时候才学数据结构、算法呢？我想立刻现在马上学：二分、排序、二叉树、DFS、...
不要着急，杂题做得越多，后面的学习越高效越快！
一是提高编码能力！争取做到：一次写20行代码，不用调试一次过！
二是算法能力！杂题虽然没用到经典算法，但它们的解题步骤其实也是算法，有时难度不亚于经典算法。
下面给出6个精讲题，有模拟、构造、思维、数学等各种杂题，难度从简单到难。大家自己先做，然后再看题解。
1.1 修剪灌木
难度 **
2022年第十三届省赛：链接1-蓝桥OJ 、链接2-NewOj
【题解 】这是一道思维题。由于每棵灌木都会在2N天内被剪为0，所以不会无限长高。其中的第i棵，它左边有i-1棵，右边有n-i棵。爱丽丝分别从左右绕回来，各需要2i和2(n-i-1)天，取最大值就是高度。i从0开始。
（1）C/C++代码
cpp
#include<bits/stdc++.h>
using namespace std;
int main() {
int n; cin >> n;
for (int i = 0; i < n; i++) cout << max(i, n - i - 1) * 2 << endl;
return 0;
}（2）python代码
python
n = int(input())
for i in range (n): print(max(i,n-i-1)*2)（3）java代码
java
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
for (int i = 0; i < n; i++) {
System.out.println(Math.max(i, n - i - 1) * 2);
}
}
}1.2 英文数字计数
见博客 ：英文数字计数
难度 ***
1.3 矩形拼接
2022年第十三届省赛: 链接-NewOJ
难度 *** 准确地说，难度有3.5颗星
【题解 】本题是一道纯粹的构造题，思维简单，但是代码比较繁琐细致，目的是考核编码能力。
3个矩形摆在一起，可能有几个边？读者可以在纸上手画观察，如果3个矩形完全不能匹配，是8边形；如果能完全匹配成一个新矩形，是4边形；其他情况是6边形。
本题只有3个矩形，并不复杂。3个矩形做任意组合，每个矩形有横竖两种摆法，共48种情况。T = 1000组测试，总计算量是1000×48，计算量很小不会超时，所以简单地用暴力法组合出所有情况，取最小值即可。
（1）C/C++代码
下面的C++代码，第10 ~ 14行，对3个矩形进行组合。第15 ~ 17行，每个矩形有横和竖两种摆法。
第18行，如果一个矩形的边长等于另外两个矩形边长之和，那么至少是6个边。然后第20行，如果这两个矩形边长相等，那么就是4个边。后面几行请自己分析。
cpp
#include<bits/stdc++.h>
using namespace std;
int a[3][2];
int main(){
int T; cin >> T;
while(T--) {
for(int i = 0; i < 3; i++)
cin >> a[i][0] >> a[i][1];
int ans = 8;
for(int i = 0; i < 3; i++) //第1个矩形
for(int j = 0; j < 3; j++)
if(i != j) //第2个矩形
for(int k = 0; k < 3; k++)
if(k != i && k != j) //第3个矩形
for(int ii = 0; ii <= 1; ii++){ //第1个有横竖两种摆法
for(int jj = 0; jj <= 1; jj++){ //第2个横竖摆
for(int kk = 0; kk <= 1; kk++){ //第3个横竖摆
if(a[i][ii] == a[j][jj] + a[k][kk]){
ans = min(ans, 6);
if(a[j][1-jj] == a[k][1-kk])
ans = min(ans, 4);
}
if(a[i][ii] == a[j][jj] || a[j][jj] == a[k][kk])
ans = min(ans, 6);
if(a[i][ii] == a[j][jj] && a[j][jj] == a[k][kk])
ans = min(ans, 4);
}
}
}
cout<<ans<<endl;
}
return 0;
}（2）python代码
python
def check1(x1,x2,x3):
if x1>=x2 and x1>=x3:
if x1==x2+x3 and a[2]+a[3]-x2==a[4]+a[5]-x3: return True
if x2>=x1 and x2>=x3:
if x2==x1+x3 and a[0]+a[1]-x1==a[4]+a[5]-x3: return True
if x3>=x1 and x3>=x2:
if x3==x1+x2 and a[0]+a[1]-x1==a[2]+a[3]-x2: return True
return False
def check2(x1,x2,x3):
if x1>=x2 and x1>=x3:
if x1==x2+x3: return True
if x2>=x1 and x2>=x3:
if x2==x1+x3: return True
if x3>=x1 and x3>=x2:
if x3==x1+x2: return True
return False
T = int(input())
for t in range(T):
a=list(map(int,input().split()))
ans=8
for i in range(0,2): #第1个矩形
for j in range(2,4): #第2个矩形
for k in range(4,6): #第3个矩形
x1,x2,x3 = a[i],a[j],a[k]
if x1==x2 and x2==x3: ans = min(ans,4)
if check1(x1,x2,x3): ans = min(ans,4)
if x1==x2 or x1==x3 or x2==x3: ans = min(ans,6)
if check2(x1,x2,x3): ans = min(ans,6)
print(ans)（3）java代码
java
import java.util.*;
import java.io.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int T = in.nextInt();
for(int _t = 1; _t <= T; _t++){
int[][] a = new int[3][2];
int ans = 8;
for(int i = 0; i < 3; i++) {
a[i][0] = in.nextInt();
a[i][1] = in.nextInt();
}
//枚举第一个矩形下标为i，第二个矩形下标为j，第三个矩形下标为k
for(int i = 0; i < 3; i++)
for(int j = 0; j < 3; j++)
if(i != j)
for(int k = 0; k < 3; k++)
if(i != k && j != k)
//枚举三个矩形的两条边
for(int ii = 0; ii <= 1; ii++)
for(int jj = 0; jj <= 1; jj++)
for(int kk = 0; kk <= 1; kk++) {
if(a[i][ii] == a[j][jj])//6条边的情况1
ans = Math.min(ans, 6);
if(a[i][ii] == a[j][jj] && a[i][ii] == a[k][kk])//4条边的情况1
ans = Math.min(ans, 4);
//枚举仅考虑a[i][ii] 与 a[j][jj] + a[k][kk]的关系
if(a[i][ii] == a[j][jj] + a[k][kk]) {
ans = Math.min(ans, 6); //6条边的情况2
if(a[j][1 - jj] == a[k][1 - kk]) //4条边的情况2
ans = Math.min(ans, 4);
}
}
System.out.println(ans);
}
}
}1.4 最少砝码
2021年第十二届蓝桥杯省赛: 链接1-蓝桥OJ
难度 ***
【题解 】这是一道找规律题。
题目要求给出最少数量的几个整数（砝码），通过加减组合得到1 ~ N的整数。熟悉二进制的都知道，用1、2、4、8、16、...这些2的倍数，可以组合后相加得到任意整数。不过，本题的砝码不仅可以相加，还可以放在天平的两边通过减法得到新的称重。例如N = 3时，砝码可以是{1, 2}，也可以是{1, 3}、{2, 3}。
本题的思维有一点难度，读者如果自己提前做了此题，思维过程可能比较繁琐。下面给出一种简洁的推理方法。
设当前砝码称重范围是1 ~ R。加一个砝码w，并且要求不重复加w前已经能得到的称重，那么w将是一个很大的砝码。新的称重范围是：
{1, 2, ..., R, w-R, w-R+1,..., w, w+1, w+2, ..., w+R}
因为从R到w-R是连续的，所以有w-R = R+1，即w = 2R+1。也就是说，如果当前称重范围是1 ~ R，那么加一个w = 2R+1的砝码，可以扩展到新的称重范围R'= w+R = 3R+1。
下面列表计算，每一行的"原砝码，原称重范围"是上一行的"新砝码，新称重范围"。
这个表格给出了一种最少砝码的实现方式，虽然可能有其他实现方式，但这种实现方式最大程度扩展了新的R'，是一种最优方案。
根据这个表格可以得到计算方法：（1）砝码按3的倍数增长；（2）每加一个砝码，称重范围增长到R' = 3R+1。
R按3倍增长，这比二进制的倍增还快，当N = 1 0 9 10^9 109时，计算量 l o g 3 N log_3N log3N < l o g 2 N log_2N log2N = 30。
（1）C/C++代码
cpp
#include <stdio.h>
int main() {
int N;
scanf("%d", &N);
int R = 1;
int cnt = 1;
while (R < N) {
R = R * 3 + 1;
cnt++;
}
printf("%d", cnt);
return 0;
}（2）python代码
python
N = int(input())
R = 1
cnt = 1
while R < N:
R = R*3 + 1
cnt += 1
print(cnt)（3）java代码
java
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int N = scanner.nextInt();
int R = 1;
int cnt = 1;
while (R < N) {
R = R * 3 + 1;
cnt++;
}
System.out.println(cnt);
}
}1.5 蜂巢
2022年第十三届省赛: [链接1-蓝桥OJ]
难度 ****
【题解 】本题是一道构造题，考点有两个：坐标转换、距离计算。
蜂巢有6个方向，看起来比较复杂，但实际上走步非常简单，例如样例中从B走到C，C在B的右下方，B只要一直向右向下走，且不超过C的行和列，不管怎么走，一定能以最小步数走到C。
本题的难点是对坐标的处理。如果是简单的直角坐标系，很容易计算。本题是六角形的蜂巢，每个蜂巢的中心点是否能转为直角坐标？把蜂巢的关系用下面的直角坐标表示：
中心点O，对应的6个蜂巢的坐标分别为(-2, 0)、(-1, 1)、(1, 1)、(2, 0)、(1, -1)、(-1, -1)，下面代码中用xdir[]、ydir[]表示。
先计算得到起点坐标(x1, y1)、终点坐标(x2, y2)。如何计算起点到终点的步数？由于蜂巢的坐标比较奇怪，不能直接用"曼哈顿距离[ 曼哈顿距离，又称为出租车距离：两点的距离等于x方向上的距离加上y方向上的距离，即|x1-x2| + |y1-y2|。]"计算。读者如果已经做了这一题，可能是用各种复杂的判断来计算的。下面给出一个简单巧妙的方法。
坐标之差的绝对值dx = |x1-x2|，dy = |y1-y2|，有以下结论：
1、若dx ≥ dy，那么最少步数是(dx+dy)/2，即先横着走，再斜着走；
2、若dx < dy，一直斜着走就行，最少步数是dy。
（1）C/C++代码
代码中有一个地方需要注意，即坐标值应该用long long，如果用int会溢出。
cpp
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll xdir[] = {-2,-1,1,2, 1,-1}; //横向
ll ydir[] = { 0, 1,1,0,-1,-1}; //纵向
void walk(ll d, ll q, ll &x, ll &y){
x += xdir[d] * q;
y += ydir[d] * q; //引用传参，返回坐标值(x,y)
}
int main(){
ll d1,p1,q1,d2,p2,q2;
cin>>d1>>p1>>q1>>d2>>p2>>q2;
ll x1 = 0, y1 = 0; //计算起点坐标(x1, y1)
walk(d1,p1,x1,y1); //先走第1个方向
walk((d1 + 2) % 6,q1,x1,y1); //再走第2个方向
ll x2 = 0, y2 = 0; //计算终点坐标(x2, y2)
walk(d2,p2,x2,y2);
walk((d2 + 2) % 6,q2,x2,y2);
ll dx = abs(x1 - x2), dy = abs(y1 - y2);
if (dx >= dy) cout << (dx+dy)/2; //先横走，再斜着走
else cout << dy; //一直斜着走就行了
}（2）python代码
python
xdir = [-2,-1,1,2, 1,-1]
ydir = [ 0, 1,1,0,-1,-1]
def walk(d, q,x,y):
x += xdir[d]*q
y += ydir[d]*q
return x,y
d1,p1,q1,d2,p2,q2 = map(int,input().split())
x1, y1 = walk(d1,p1,0,0)
x1, y1 = walk((d1 + 2) % 6, q1,x1,y1)
x2, y2 = walk(d2,p2,0,0)
x2, y2 = walk((d2 + 2) % 6, q2,x2,y2)
dx,dy = abs(x1 - x2), abs(y1 - y2);
if (dx >= dy): print((dx+dy)//2) #先横走，再斜着走
else: print(dy) #一直斜着走 （3）java代码
java
import java.util.*;
public class Main {
static long[] xdir = {-2, -1, 1, 2, 1, -1}; //横向
static long[] ydir = {0, 1, 1, 0, -1, -1}; //纵向
static void walk(int d, long q, long[] pos) {
pos[0] += xdir[d] * q;
pos[1] += ydir[d] * q;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int d1 = scanner.nextInt();
long p1 = scanner.nextLong();
long q1 = scanner.nextLong();
int d2 = scanner.nextInt();
long p2 = scanner.nextLong();
long q2 = scanner.nextLong();
long[] pos1 = {0, 0};
walk(d1, p1, pos1);
walk((d1 + 2) % 6, q1, pos1);
long[] pos2 = {0, 0};
walk(d2, p2, pos2);
walk((d2 + 2) % 6, q2, pos2);
long dx = Math.abs(pos1[0] - pos2[0]);
long dy = Math.abs(pos1[1] - pos2[1]);
if (dx >= dy) System.out.println((dx + dy) / 2);
else System.out.println(dy);
}
}1.6 立方体表面距离
见博客 ：立方体表面距离
难度 *****
2. 刷题
还是继续刷题吧。上周的题目链接，大家接着做：