2021年藍橋杯省賽B組題目解析（C/C++）
A 空間 / 填空 5分
【問題描述】256MB的內存空間開一個數組，數組的每個元素都是32位二進制整數，
如果不考慮程序占用的空間和維護內存需要的輔助空間，
請問256MB的空間可以存儲多少個32位二進制整數。
- 答案：67108864
【解析】1MB=2^10KB=1024KB, 1KB=1024B, 1B=8bit。
#include<iostream>
using namespace std;
int main() {
long long ans = 1ll*256*1024*1024*8/32;
cout<<ans<<endl;//67108864
return 0;
}
B 卡片 / 填空 5分
【問題描述】小藍有很多數字卡片，每張卡片上都是數字 0 到 9。
小藍准備用這些卡片來拼一些數，他想從 1 開始拼出正整數，每拼一個，就保存起來，卡片就不能用來拼其它數了。
小藍想知道自己能從 1 拼到多少。
例如，當小藍有 30 張卡片，其中 0 到 9 各 3 張，則小藍可以拼出 1 到 10，但是拼 11 時卡片 1 已經只有一張了，不夠拼出 11。
現在小藍手里有 0 到 9 的卡片各 2021 張，共 20210 張，請問小藍可以從1拼到多少？
- 答案：3181
【解析】暴力枚舉1~n即可，直到0-9有一個用完
#include<iostream>
using namespace std;
int num[10];
int main() {
for(int i=1; ;i++){
int temp=i;
while(temp){
num[temp%10]++;
if(num[temp%10]>2021) {
cout<<i-1<<endl;//3181
return 0;
}
temp /= 10;
}
}
return 0;
}
C 直線 / 填空 10分
在平面直角坐標系中，兩點可以確定一條直線。
如果有多點在一條直線上，那么這些點中任意兩點確定的直線是同一條。
給定平面上 2 × 3 個整點 {(x,y)|0 ≤ x < 2,0 ≤ y < 3, x ∈ Z,y ∈ Z}，
即橫坐標是 0 到 1 (包含 0 和 1) 之間的整數、
縱坐標是 0 到 2 (包含 0 和 2) 之間的整數的點。
這些點一共確定了 11 條不同的直線。
給定平面上 20 × 21 個整點 {(x,y)|0 ≤ x < 20,0 ≤ y < 21, x ∈ Z,y ∈ Z}，
即橫坐標是 0 到 19 (包含 0 和 19) 之間的整數、
縱坐標是 0 到 20 (包含 0 和 20) 之間的整數的點。
請問這些點一共確定了多少條不同的直線。
- 答案：40257
【解析】整體思路：枚舉兩點坐標，建立直線方程，判重
- 建立方程：Y=KX+B，涉及到浮點數。
k = (y2-y1)/(x2-x1)
b = y2-k*x2 = (x2*y1-x1*y2)/(x2-x1) //注意不要依賴於 k，本身 k 就存在誤差了
使用 set 去重
#include<iostream>
#include<cmath>
#include<set>
using namespace std;
set<pair<double,double> > s;
int main(){
int n=20, m=21;
for(int x1=0; x1<n; x1++){
for(int y1=0; y1<m; y1++){
for(int x2=0; x2<n; x2++){
for(int y2=0; y2<m; y2++){
if(x1==x2||y1==y2) continue;
double k = 1.0*(y2-y1)/(x2-x1);
double b = 1.0*(x2*y1-y2*x1)/(x2-x1);
s.insert(make_pair(k,b));
}
}
}
}
cout<<s.size()+n+m<<endl;
return 0;
}
自寫 eps，check 判重，這樣時間復雜度高
#include<iostream>
#include<cmath>
using namespace std;
const double eps = 1e-8;
const int N=1e5+10;//最大值 n*m*n*m < 1e5
struct T{
double k,b;
}t[N];
int ans=0;
void check(T a){
bool flag=1;
for(int i=1; i<=ans; i++){
T temp = t[i];
if(fabs(temp.k-a.k)<eps && fabs(temp.b-a.b)<eps) {
flag=0; break;
}
}
if(flag) t[++ans]=a;
}
int main(){
int n=20, m=21;
for(int x1=0; x1<n; x1++){
for(int y1=0; y1<m; y1++){
for(int x2=0; x2<n; x2++){
for(int y2=0; y2<m; y2++){
if(x1==x2||y1==y2) continue;
double k = 1.0*(y2-y1)/(x2-x1);
double b = 1.0*(x2*y1-x1*y2)/(x2-x1);
T temp = (T){k,b};
check(temp);
}
}
}
}
cout<<ans+n+m<<endl;
return 0;
}
- 對上述程序進行改進
#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;
const double eps = 1e-8;
const int N=1e6+10;//最大值 n*m*n*m < 1e5
struct T{
double k,b;
bool operator < (const T& t) const{
if(fabs(k-t.k)>eps) return k < t.k;
return b < t.b;
}
}t[N];
int main(){
int n=20, m=21, cnt=0, ans=0;
for(int x1=0; x1<n; x1++){
for(int y1=0; y1<m; y1++){
for(int x2=0; x2<n; x2++){
for(int y2=0; y2<m; y2++){
if(x1==x2||y1==y2) continue;
double k = 1.0*(y2-y1)/(x2-x1);
double b = 1.0*(x2*y1-x1*y2)/(x2-x1);
t[cnt++]=(T){k,b};
}
}
}
}
sort(t, t+cnt);//最后排序計數，稍快一點
for(int i=1; i<cnt; i++){
if(fabs(t[i].k-t[i-1].k)<eps && fabs(t[i].b-t[i-1].b)<eps)continue;
else ans++;
}
cout<<ans+n+m+1<<endl;//第一個數沒加，所以多 +1
return 0;
}
- 建立方程：AX+BY+C=0，保證 gcd(A, B, C)=1。
A = y1-y2;
B = x2-x1;
C = x1*y2-x2*y1;
#include<iostream>
#include<cmath>
#include<set>
using namespace std;
struct T {
int a,b,c;
bool operator < (const T &t) const {
if (a == t.a) return b == t.b ? c < t.c : b < t.b;
return a < t.a;
}
bool operator == (const T& t) const {
return a==t.a && b==t.b && c==t.c;
}
};
set<T> s;
int gcd(int a,int b) {
return b==0 ? a : gcd(b, a%b);
}
int main() {
int n=20, m=21;
for(int x1=0; x1<n; x1++) {
for(int y1=0; y1<m; y1++) {
for(int x2=0; x2<n; x2++) {
for(int y2=0; y2<m; y2++) {
if(x1==x2||y1==y2) continue;
int a = y1-y2;
int b = x2-x1;
int c = x1*y2-x2*y1;
int t = gcd(gcd(a, b), gcd(b, c));
s.insert((T) {a/t,b/t,c/t});
}
}
}
}
cout<<s.size()+n+m<<endl;
return 0;
}
- 兩點確定一直線，減去同一行，列，對角線重復部分即可，但是這樣有加深了題目難度，需要推導公式。
D 貨物擺放 / 填空 10分
小藍有一個超大的倉庫，可以擺放很多貨物。
現在，小藍有 n 箱貨物要擺放在倉庫，每箱貨物都是規則的正方體。
小藍規定了長、寬、高三個互相垂直的方向，每箱貨物的邊都必須嚴格平行於長、寬、高。
小藍希望所有的貨物最終擺成一個大的立方體。
即在長、寬、高的方向上分別堆 L、W、H 的貨物，滿足 n = L × W × H。
給定 n，請問有多少種堆放貨物的方案滿足要求。
例如，當 n = 4 時，有以下 6 種方案：1×1×4、1×2×2、1×4×1、2×1×2、2 × 2 × 1、4 × 1 × 1。
請問，當 n = 2021041820210418 （注意有 16 位數字）時，總共有多少種方案？
- 答案：2430
【解析】將 n 分解因數，求三個因數的乘積為 n 即可。
#include<iostream>
#include<set>
using namespace std;
typedef long long ll;
int main() {
ll n=2021041820210418,ans=0;
set<ll> s;
for(ll i=1; i*i<=n; i++) {
if(n%i==0) {
s.insert(i); s.insert(n/i);
}
}
for(set<ll>::iterator l=s.begin(); l!=s.end(); l++) {
for(set<ll>::iterator w=s.begin(); w!=s.end(); w++) {
for(set<ll>::iterator h=s.begin(); h!=s.end(); h++) {
if(*l * *w * *h==n) ans++;
}
}
}
cout<<ans<<endl;
return 0;
}
E 路徑 / 填空 15分
小藍學習了最短路徑之后特別高興，他定義了一個特別的圖，希望找到圖中的最短路徑。
小藍的圖由 2021 個結點組成，依次編號 1 至 2021。
對於兩個不同的結點 a, b，如果 a 和 b 的差的絕對值大於 21，則兩個結點之間沒有邊相連；
如果 a 和 b 的差的絕對值小於等於 21，則兩個點之間有一條長度為 a 和 b 的最小公倍數的無向邊相連。
例如：
結點 1 和結點 23 之間沒有邊相連；
結點 3 和結點 24 之間有一條無向邊，長度為 24；
結點 15 和結點 25 之間有一條無向邊，長度為 75。
請計算，結點 1 和結點 2021 之間的最短路徑長度是多少。
- 答案：10266837
【解析】簡單的最短路徑，數據量 (2e3)^3 = 8e9，貌似不是很大，跑一下 floyed
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
const int N=1e4+10;
int a[N][N];
int gcd(int a,int b) {
return b==0?a:gcd(b, a%b);
}
int main() {
int n=2021;
memset(a, 0x3f, sizeof(a));
for(int i=1; i<=n; i++) {
for(int j=i+1; j-i<=21; j++) {
a[i][j] = a[j][i] = i*j/gcd(i, j);
}
}
for(int k=1; k<=n; k++) {// 跑一下 floyed
for(int i=1; i<=n; i++) {
for(int j=1; j<=n; j++) {
a[i][j]=min(a[i][j], a[i][k]+a[k][j]);
}
}
}
cout<<a[1][n]<<endl;//10266837
return 0;
}
F 時間顯示 / 程序題 15 分
時間限制：1.0s 內存限制：256.0MB
【問題描述】小藍要和朋友合作開發一個時間顯示的網站。
在服務器上，朋友已經獲取了當前的時間，用一個整數表示，
值為從 1970 年 1 月 1 日 00:00:00 到當前時刻經過的毫秒數。
現在，小藍要在客戶端顯示出這個時間。
小藍不用顯示出年月日，只需要顯示出時分秒即可，毫秒也不用顯示，直接舍去即可。
給定一個用整數表示的時間，請將這個時間對應的時分秒輸出 。
【輸入格式】輸入一行包含一個整數，表示時間。
【輸出格式】輸出時分秒表示的當前時間，格式形如 HH:MM:SS，
其中 HH 表示時，值為 0 到 23，MM 表示分，值為 0 到 59，SS 表示秒，值為 0 到 59。
時、分、秒不足兩位時補前導 0。
【樣例輸入1】46800999
【樣例輸出1】13:00:00
【樣例輸入2】1618708103123
【樣例輸出2】01:08:23
【評測用例規模與約定】對於所有評測用例，給定的時間為不超過 10^18 的正整數。
#include<iostream>
#include<iomanip>
#include<algorithm>
#include<climits>
typedef long long ll;
using namespace std;
int main() {
ll n = 46800999;
n = 1618708103123;
n = LLONG_MAX;//#define LLONG_MAX 9223,37203,68547,75807 ll
cin>>n;
int h = n/1000/60/60%24;
int m = n/1000/60%60;
int s = n/1000%60;
printf("%02d:%02d:%02d\n",h,m,s);
return 0;
}
G 砝碼稱重 / 程序題 20 分
時間限制：1.0s 內存限制：256.0MB
【問題描述】
你有一架天平和 N 個砝碼，這 N 個砝碼重量依次是 \(W_1,W_2,...,W_N\)。
請你計算一共可以稱出多少種不同的重量？
注意砝碼可以放在天平兩邊。
【輸入格式】輸入的第一行包含一個整數 N。第二行包含 N 個整數： \(W_1,W_2,...,W_N\)。
【輸出格式】輸出一個整數代表答案。
【樣例輸入】
3
1 4 6
【樣例輸出】
10
【樣例說明】
能稱出的 10 種重量是：1、2、3、4、5、6、7、9、10、11。
1 = 1；
2 = 6 - 4 (天平一邊放 6，另一邊放 4)；
3 = 4 - 1；
4 = 4；
5 = 6 - 1；
6 = 6；
7 = 1 + 6；
9 = 4 + 6 - 1；
10 = 4 + 6；
11 = 1 + 4 + 6。
【評測用例規模與約定】
對於 50% 的評測用例，1≤N≤15。
對於所有評測用例，1≤N≤100，N個砝碼總重不超過100000。
【解析】dfs/dp
- 搜索，50分
當前砝碼可以選擇 放天平左邊，右邊或者不放，三個遞歸關系即可。
#include<iostream>
#include<cmath>
using namespace std;
const int N=1e5+10;
int w[N],vis[N],n,m=0,ans=0;
void dfs(int x, int y) {//前x個元素，可稱出重量y
if(x>n) return;
vis[abs(y)] = 1;
dfs(x+1, y+w[x]);//加天平左邊
dfs(x+1, y); //不加
dfs(x+1, y-w[x]);//加天平右邊
}
int main() {
// freopen("data.in", "r", stdin);
cin>>n;
for(int i=0; i<n; i++) {
cin>>w[i]; m+=w[i];
}
dfs(0, 0);
for(int i=1; i<=m; i++) {
if(vis[i]==1) ans++;
}
cout<<ans<<endl;
return 0;
}
- dp (動態規划，還可以狀態壓縮，但是沒必要)
狀態：f[i][j] 表示前 i 個物品配成重量 j 是否可行
初始狀態：f[0][0]=1, f[i][0]=1, f[0][i]=0;
狀態轉移方程：
f[i][j] = f[i-1][j] + f[i-1][abs(j-w[i])] + f[i-1][j+w[i]];
#include<iostream>
#include<cmath>
using namespace std;
const int N=1e5+10;
int w[N], f[110][N], n, m, ans=0;
int main(){
// freopen("data.in", "r", stdin);
cin>>n;
for(int i=1; i<=n; i++) {
cin>>w[i]; m+=w[i];
}
f[0][0]=1;
for(int i=1; i<=n; i++){
for(int j=0; j<=m; j++){
f[i][j]=f[i-1][j]+f[i-1][abs(j-w[i])]+f[i-1][j+w[i]];
}
}
for(int i=1; i<=m; i++){
if(f[n][i]) ans++;
}
cout<<ans<<endl;
return 0;
}
G JAVA_最少砝碼 / 程序題 20 分
【問題描述】你有一架天平。
現在你要設計一套砝碼，使得利用這些砝碼可以稱出任意小於等於 N 的正整數重量。
那么這套砝碼最少需要包含多少個砝碼？
注意砝碼可以放在天平兩邊。
【輸入格式】輸入包含一個正整數 N。
【輸出格式】輸出一個整數代表答案。
【樣例輸入】7
【樣例輸出】3
【樣例說明】
3 個砝碼重量是 1、4、6，可以稱出 1 至 7 的所有重量。
1 = 1；
2 = 6 - 4 (天平一邊放 6，另一邊放 4)；
3 = 4 - 1；
4 = 4；
5 = 6 - 1；
6 = 6；
7 = 1 + 6；
少於 3 個砝碼不可能稱出 1 至 7 的所有重量。
【評測用例規模與約定】對於所有評測用例，1 ≤ N ≤ 1000000000。
【解析】三進制
- 參考程序
#include<iostream>
#include<cmath>
using namespace std;
int main(){
int n; cin>>n;
int i=1, sum=1;
for(; sum<n; i++){
sum += pow(3, i);
}
cout<<i<<endl;
return 0;
}
H 楊輝三角形 / 程序題 20 分
時間限制：1.0s 內存限制：256.0MB
【問題描述】下面的圖形是著名的楊輝三角形：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
如果我們按從上到下、從左到右的順序把所有數排成一列，可以得到如下數列：
1,1,1,1,2,1,1,3,3,1,1,4,6,4,1,⋯
給定一個正整數 N，請你輸出數列中第一次出現 N 是在第幾個數？
【輸入格式】輸入包含一個正整數 N。
【輸出格式】輸出一個整數代表答案。
【樣例輸入】6
【樣例輸出】13
【評測用例規模與約定】
對於 20% 的評測用例，1 ≤ N ≤ 10；
對於所有評測用例，1 ≤ N ≤ 1000000000。
【解析】
暴力枚舉，但是要注意空間，（慎用）極限開空間拿分，不過這道題可以。
由於題目限制較大，直接開 NxN 二維數組模擬能有 20+，后面的就是看數據了。
可以猜測並不是 80% 數據都是極限數據，也有平常數據，
但是要看模擬數組可以到達這個點不，為了盡量獲取最多模擬數據，使用滾動數組模擬。
#include<iostream>
using namespace std;
const int N=256.0*1024*1024/4/2-10;//空間用到極致,細節,多拿10分,慎用
int a[2][N], cnt=0;
int main() {
// cout<<N<<endl; // 33554422=3.3e7,O(n)不超 1s，很重要
int n; cin>>n;
a[0][0]=1;
for(int i=1; i<=N; i++) {
for(int j=0; j<i; j++) {
a[i%2][j]=a[(i-1)%2][j]+a[(i-1)%2][j-1];
++cnt;
if(a[i%2][j]==n) {
cout<<cnt<<endl; return 0;
}
}
}
return 0;
}
【正解思路】搜索剪枝，或者二分+找規律，有誰要是強行 dp出來，那給你點贊。
參考文章：https://blog.csdn.net/weixin_44091134/article/details/116748883
- 參考程序
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
int n;
ll C(int a,int b) { //計算C（a，b）
ll res=1;
for(int i=a,j=1; j<=b; i--,j++) {
res = res*i/j;
if(res>n) return res; // 大於n已無意義，且防止爆ll
}
return res;
}
bool check(int k) {
// 二分該斜行,找到大於等於該值的第一個數
// 左邊界2k，右邊界為max(l, n)取二者最大，避免右邊界小於左邊界
int l=2*k, r=max(n,l);
while(l < r) {
int mid = l+r>>1;
if(C(mid, k) >= n) r=mid;
else l = mid+1;
}
if(C(r, k)!=n) return false;
cout<<1ll*(r+1)*r/2+k+1<<endl;
return true;
}
int main() {
cin>>n;
for(int i=16; ; i--){// 從第16斜行枚舉
if(check(i)) break;
}
return 0;
}
I 雙向排序 / 程序題 25 分
時間限制：1.0s 內存限制：256.0MB
【問題描述】給定序列 \((a_1 , a_2 , ... , a_n) = (1,2,...,n)\)，即 \(a_i=i\)。
小藍將對這個序列進行 m 次操作，每次可能是將 \((a_1,a_2,...,a_{q_i})\) 降序排列，
或者將 \((a_{q_i}, a_{q_{i+1}}, ..., a_n)\) 升序排列。
請求出操作完成后的序列。
【輸入格式】
輸入的第一行包含兩個整數 n,m，分別表示序列的長度和操作次數。
接下來 m 行描述對序列的操作，其中第 i 行包含兩個整數 pi, qi 表示操作類型和參數。
當 pi=0 時，將 \((a_1, a_2, ..., a_{q_i})\) 降序排列；
當 pi=1 時，將 \((a_{q_i}, a_{q_{i+1}}, ..., a_n)\) 升序排列。
【輸出格式】
輸出一行，包含 n 個整數，相鄰的整數之間使用一個空格分隔，表示操作完成后的序列。
【樣例輸入】
3 3
0 3
1 2
0 2
【樣例輸出】
3 1 2
【樣例說明】
原數列為 (1, 2, 3)。
第 1 步后為 (3, 2, 1)。
第 2 步后為 (3, 1, 2)。
第 3 步后為 (3, 1, 2)。與第 2 步操作后相同，因為前兩個數已經是降序了。
【評測用例規模與約定】
對於 30% 的評測用例，n , m ≤ 1000；
對於 60% 的評測用例，n, m ≤ 5000；
對於所有評測用例，1 ≤ n , m ≤ 100000，0 ≤ pi ≤ 1，1≤qi≤n；
【解析】暴力打天下，60分到手
#include<iostream>
#include<algorithm>
using namespace std;
const int N=1e5+10;
int a[N],n,m,p,q;
bool cmp(int a,int b) {
return a>b;
}
int main() {
// freopen("data.in", "r", stdin);
cin>>n>>m;
for(int i=1; i<=n; i++) a[i]=i;
for(int i=1; i<=m; i++) {
cin>>p>>q;
if(p==0) {
sort(a+1, a+1+q, cmp);
} else if(p==1) {
sort(a+q, a+1+n);
}
}
for(int i=1; i<n; i++) cout<<a[i]<<" ";
cout<<a[n]<<endl;
return 0;
}
【正解】一時沒想到
J 括號序列 / 程序題 25 分
時間限制：1.0s 內存限制：256.0MB
給定一個括號序列，要求盡可能少地添加若干括號使得括號序列變得合法，
當添加完成后，會產生不同的添加結果，請問有多少種本質不同的添加結果。
兩個結果是本質不同的是指存在某個位置一個結果是左括號，而另一個是右括號。
例如，對於括號序列 ((()，只需要添加兩個括號就能讓其合法，
有以下幾種不同的添加結果：()()()、()(())、(())()、(()()) 和 ((()))。
【輸入格式】輸入一行包含一個字符串 s，表示給定的括號序列，序列中只有左括號和右括號。
【輸出格式】輸出一個整數表示答案，答案可能很大，請輸出答案除以 1000000007(即1e9+7)的余數。
【樣例輸入】((()
【樣例輸出】5
【評測用例規模與約定】
對於 40% 的評測用例，∣ s ∣ ≤ 200。
對於所有評測用例，1 ≤ ∣ s ∣ ≤ 5000。
【解析】搜索 / dp
參考文獻：2021年藍橋杯c++b組解析