@author：xuanzo
如有错误，感谢指正。
A、九进制转十进制
【问题描述】
九进制正整数 (2022)9 转换成十进制等于多少？
#include<bits/stdc++.h>
using namespace std;
int main(){
int n=2022;
int ans=0;
for(int i=0;i<4;i++){
ans+=(n%10)*pow(9,i);
cout<<(n%10)*pow(9,i)<<endl;
n/=10;
}
cout<<ans<<endl;
return 0;
}
//1478
B、顺子日期
【问题描述】
小明特别喜欢顺子。顺子指的就是连续的三个数字：123、456 等。顺子日
期指的就是在日期的 yyyymmdd 表示法中，存在任意连续的三位数是一个顺
子的日期。例如 20220123 就是一个顺子日期，因为它出现了一个顺子：123； 而 20221023 则不是一个顺子日期，它一个顺子也没有。小明想知道在整个 2022
年份中，一共有多少个顺子日期。
#include<bits/stdc++.h>
using namespace std;
int mon[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
int main(){
int d=1,m=1,ans=0;
while(m<=12){
int a=m/10,b=m%10,c=d/10,e=d%10;
if(b==c-1&&(a==b-1||c==e-1)){
cout<<m<<' '<<d<<endl;
ans++;
}
d++;
if(d>mon[m]){
d=1;
m++;
}
}
cout<<ans<<endl;
return 0;
}
//14
C、刷题统计
【问题描述】
小明决定从下周一开始努力刷题准备蓝桥杯竞赛。他计划周一至周五每天
做 a 道题目，周六和周日每天做 b 道题目。请你帮小明计算，按照计划他将在
第几天实现做题数大于等于 n 题？
【输入格式】
输入一行包含三个整数 a, b 和 n.
【输出格式】
输出一个整数代表天数。
【样例输入】
10 20 99
【样例输出】
8
【评测用例规模与约定】
对于 50% 的评测用例，1 ≤ a, b, n ≤ 106.
对于 100% 的评测用例，1 ≤ a, b, n ≤ 1018
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int main(){
ll a,b,n;
cin>>a>>b>>n;
ll w=a*5+b*2;
ll ans=0;
ans+=(n/w)*7;
n%=w;int cnt=1;
while(n>0){
ans++;
if(cnt<=5){
n-=a;
}else{
n-=b;
}
cnt++;
}
cout<<ans<<endl;
return 0;
}
D、修剪灌木
【问题描述】
爱丽丝要完成一项修剪灌木的工作。
有 N 棵灌木整齐的从左到右排成一排。爱丽丝在每天傍晚会修剪一棵灌
木，让灌木的高度变为 0 厘米。爱丽丝修剪灌木的顺序是从最左侧的灌木开始，
每天向右修剪一棵灌木。当修剪了最右侧的灌木后，她会调转方向，下一天开
始向左修剪灌木。直到修剪了最左的灌木后再次调转方向。然后如此循环往复。
灌木每天从早上到傍晚会长高 1 厘米，而其余时间不会长高。在第一天的
早晨，所有灌木的高度都是 0 厘米。爱丽丝想知道每棵灌木最高长到多高。
【输入格式】
一个正整数 N ，含义如题面所述。
【输出格式】
输出 N 行，每行一个整数，第行表示从左到右第 i 棵树最高能长到多高。
【样例输入】
3
【样例输出】
424
【评测用例规模与约定】
对于 30% 的数据，N ≤ 10.
对于 100% 的数据，1 < N ≤ 10000.
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
if(n==1){
cout<<1<<endl;
return 0;
}
for(int i=1;i<=n;i++){
cout<<max((i-1)*2,(n-i)*2)<<endl;
}
return 0;
}
//1 2 i 4 5
//i*2 (n-i)*2
E、X 进制减法
【问题描述】
进制规定了数字在数位上逢几进一。
X 进制是一种很神奇的进制，因为其每一数位的进制并不固定！例如说某
种 X 进制数，最低数位为二进制，第二数位为十进制，第三数位为八进制，则
X 进制数 321 转换为十进制数为 65。
现在有两个 X 进制表示的整数 A 和 B，但是其具体每一数位的进制还不确
定，只知道 A 和 B 是同一进制规则，且每一数位最高为 N 进制，最低为二进
制。请你算出 A − B 的结果最小可能是多少。
请注意，你需要保证 A 和 B 在 X 进制下都是合法的，即每一数位上的数
字要小于其进制。
【输入格式】
第一行一个正整数 N，含义如题面所述。
第二行一个正整数 Ma，表示 X 进制数 A 的位数。
第三行 Ma 个用空格分开的整数，表示 X 进制数 A 按从高位到低位顺序各
个数位上的数字在十进制下的表示。
第四行一个正整数 Mb，表示 X 进制数 B 的位数。
第五行 Mb 个用空格分开的整数，表示 X 进制数 B 按从高位到低位顺序各
个数位上的数字在十进制下的表示。
请注意，输入中的所有数字都是十进制的。
【输出格式】
输出一行一个整数，表示 X 进制数 A − B 的结果的最小可能值转换为十进
制后再模 1000000007 的结果。
【样例输入】
11
3
10 4 0
3
1 2 0
【样例输出】
94
【样例说明】
当进制为：最低位 2 进制，第二数位 5 进制，第三数位 11 进制时，减法
得到的差最小。此时 A 在十进制下是 108，B 在十进制下是 14，差值是 94。
【评测用例规模与约定】
对于 30% 的数据，N ≤ 10; Ma, Mb ≤ 8.
对于 100% 的数据，2 ≤ N ≤ 1000; 1 ≤ Ma, Mb ≤ 100000; A ≥ B.
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int mod=1e9+7;
int a[100005],b[100005],d[100005],dig[100005];
int main(){
memset(a,0,sizeof(a));
memset(b,0,sizeof(b));
int n,ma,mb;
cin>>n;
cin>>ma;
for(int i=ma-1;i>=0;i--){
cin>>a[i];
}
cin>>mb;
for(int i=mb-1;i>=0;i--){
cin>>b[i];
d[i]=a[i]-b[i];//差值
}
int m=max(ma,mb);
ll last=0;
ll ans=0;
for(int i=m-1;i>0;i--){
int Mindig=max(a[i-1],b[i-1])+1;
Mindig=max(Mindig,2);
last+=d[i];
last*=Mindig;last%=mod;
//cout<<Mindig<<' '<<last<<endl;
}
last+=d[0];
cout<<last<<endl;
return 0;
}
/*
因为A>=B 全部取到最小即可
*/
F、统计子矩阵
【问题描述】
给定一个 N × M 的矩阵 A，请你统计有多少个子矩阵 (最小 1 × 1，最大
N × M) 满足子矩阵中所有数的和不超过给定的整数 K?
【输入格式】
第一行包含三个整数 N, M 和 K.
之后 N 行每行包含 M 个整数，代表矩阵 A.
【输出格式】
一个整数代表答案。
【样例输入】
3 4 10
1 2 3 4
5 6 7 8
9 10 11 12
【样例输出】
19
【样例说明】
满足条件的子矩阵一共有 19，包含：
大小为 1 × 1 的有 10 个。
大小为 1 × 2 的有 3 个。
大小为 1 × 3 的有 2 个。
大小为 1 × 4 的有 1 个。
大小为 2 × 1 的有 3 个。
【评测用例规模与约定】
对于 30% 的数据，N, M ≤ 20.
对于 70% 的数据，N, M ≤ 100.
对于 100% 的数据，1 ≤ N, M ≤ 500; 0 ≤ Ai j ≤ 1000; 1 ≤ K ≤ 250000000.
#include<bits/stdc++.h>
using namespace std;
int a[505][505];
int main(){
memset(a,0,sizeof(a));
int n,m,k;
cin>>n>>m>>k;
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
cin>>a[i][j];
a[i][j]+=a[i-1][j]+a[i][j-1]-a[i-1][j-1];
}
}
int ans=0;
for(int x=1;x<=n;x++){
for(int y=1;y<=m;y++){
for(int xx=x;xx<=n;xx++){
if(a[xx][y]-a[x-1][y]-a[xx][y-1]+a[x-1][y-1]>k)break;
int l=y,r=m+1,yy=y;
while(l<r){
int mid=(l+r)>>1;
if(a[xx][mid]-a[x-1][mid]-a[xx][y-1]+a[x-1][y-1]<=k){
l=mid+1;yy=mid;
}else{
r=mid;
}
}
//cout<<x<<' '<<y<<' '<<xx<<' '<<yy<<endl;
ans+=yy-y+1;
}
}
}
cout<<ans<<endl;
return 0;
}
/*
(n^3)logn
考虑二位前缀和
可以O(1)查子矩阵和
然后枚举左上点，枚举右下点的x，二分y
*/
G、积木画
【问题描述】
小明最近迷上了积木画，有这么两种类型的积木，分别为 I 型（大小为 2
个单位面积）和 L 型（大小为 3 个单位面积）：
同时，小明有一块面积大小为 2 × N 的画布，画布由 2 × N 个 1 × 1 区域构
成。小明需要用以上两种积木将画布拼满，他想知道总共有多少种不同的方式？
积木可以任意旋转，且画布的方向固定。
【输入格式】
输入一个整数 N，表示画布大小。
【输出格式】
输出一个整数表示答案。由于答案可能很大，所以输出其对 1000000007 取
模后的值
【样例输入】
3
【样例输出】
5
【样例说明】
五种情况如下图所示，颜色只是为了标识不同的积木：
【评测用例规模与约定】
对于所有测试用例，1 ≤ N ≤ 10000000.
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int mod=1e9+7;
ll dp[10000005][2];
int main(){
memset(dp,0,sizeof(dp));
int n;
cin>>n;
dp[0][0]=1;
for(int i=1;i<=n;i++){
dp[i][0]=(dp[i-1][0]+(i>=2?dp[i-2][0]:0)+dp[i-1][1])%mod;
dp[i][1]=(dp[i-1][1]+(i>=2?2*dp[i-2][0]:0))%mod;
//cout<<dp[i][0]<<' '<<dp[i][1]<<endl;
}
cout<<dp[n][0]<<endl;
return 0;
}
/*
dp[i][0]表示当前位置填满
dp[i][1]表示当前位置孔雀一个
*/
H、扫雷
【问题描述】
小明最近迷上了一款名为《扫雷》的游戏。其中有一个关卡的任务如下，
在一个二维平面上放置着 n 个炸雷，第 i 个炸雷 (xi, yi,ri) 表示在坐标 (xi, yi) 处
存在一个炸雷，它的爆炸范围是以半径为 ri 的一个圆。
为了顺利通过这片土地，需要玩家进行排雷。玩家可以发射 m 个排雷火
箭，小明已经规划好了每个排雷火箭的发射方向，第 j 个排雷火箭 (xj, yj,rj) 表
示这个排雷火箭将会在 (xj, yj) 处爆炸，它的爆炸范围是以半径为 rj 的一个圆，
在其爆炸范围内的炸雷会被引爆。同时，当炸雷被引爆时，在其爆炸范围内的
炸雷也会被引爆。现在小明想知道他这次共引爆了几颗炸雷？
你可以把炸雷和排雷火箭都视为平面上的一个点。一个点处可以存在多个
炸雷和排雷火箭。当炸雷位于爆炸范围的边界上时也会被引爆。
【输入格式】
输入的第一行包含两个整数 n、m.
接下来的 n 行，每行三个整数 xi, yi,ri，表示一个炸雷的信息。
再接下来的 m 行，每行三个整数 xj, yj,rj，表示一个排雷火箭的信息。
【输出格式】
输出一个整数表示答案。
【样例输入】
2 1
2 2 4
4 4 2
0 0 5
【样例输出】
2
【样例说明】
示例图如下，排雷火箭 1 覆盖了炸雷 1，所以炸雷 1 被排除；炸雷 1 又覆盖了炸雷 2，所以炸雷 2 也被排除。
【评测用例规模与约定】
对于 40% 的评测用例：0 ≤ x, y ≤ 109, 0 ≤ n, m ≤ 103, 1 ≤ r ≤ 10.
对于 100% 的评测用例：0 ≤ x, y ≤ 109, 0 ≤ n, m ≤ 5 × 104, 1 ≤ r ≤ 10.
#include<bits/stdc++.h>
#define ll long long
using namespace std;
struct Node{
ll x,y,d2;
double d;
int r;
bool type;//0:lei 1: huo
friend bool operator < (Node a,Node b){
return a.d2<b.d2;
}
}node[100005];//1e5
bool vis[100005];
int main(){
int n,m;//5e4
cin>>n>>m;
for(int i=0;i<n;i++){
//雷
cin>>node[i].x>>node[i].y>>node[i].r;
node[i].d2=node[i].x*node[i].x+node[i].y*node[i].y;
node[i].d=sqrt(node[i].d2);
node[i].type=0;
}
for(int i=n;i<n+m;i++){
//火箭
cin>>node[i].x>>node[i].y>>node[i].r;
node[i].d2=node[i].x*node[i].x+node[i].y*node[i].y;
node[i].type=1;
}
sort(node,node+n+m);
queue<int> q;
int tol=n+m;
memset(vis,0,sizeof(vis));
for(int i=0;i<tol;i++){
if(node[i].type==1){
vis[i]=1;
q.push(i);
}
}
int ans=0;
while(!q.empty()){
int now=q.front();
q.pop();
ll r2=node[now].r*node[now].r;
double r=node[now].r;
int cnt=now-1;
while(cnt>=0&&fabs(node[cnt].d-node[now].d)<=r){
if(!vis[cnt]&&node[cnt].type==0){
//没访问过且是雷，且被覆盖
ll d2=(node[cnt].x-node[now].x)*(node[cnt].x-node[now].x)+(node[cnt].y-node[now].y)*(node[cnt].y-node[now].y);
if(d2<=r2){
q.push(cnt);
vis[cnt]=1;
ans++;
}
}
cnt--;
}
cnt=now+1;
while(cnt<tol&&fabs(node[cnt].d-node[now].d)<=r){
if(!vis[cnt]&&node[cnt].type==0){
//没访问过且是雷，且被覆盖
ll d2=(node[cnt].x-node[now].x)*(node[cnt].x-node[now].x)+(node[cnt].y-node[now].y)*(node[cnt].y-node[now].y);
if(d2<=r2){
q.push(cnt);
vis[cnt]=1;
ans++;
}
}
cnt++;
}
}
cout<<ans<<endl;
return 0;
}
/*
小范围暴力
按与原点(0,0)的距离排序
考虑r最大只有10，
因此只需要通过与原点距离的差值来缩小需要查点的范围
*/
I、李白打酒加强版
【问题描述】
话说大诗人李白，一生好饮。幸好他从不开车。
一天，他提着酒壶，从家里出来，酒壶中有酒 2 斗。他边走边唱：
无事街上走，提壶去打酒。
逢店加一倍，遇花喝一斗。
这一路上，他一共遇到店 N 次，遇到花 M 次。已知最后一次遇到的是花，
他正好把酒喝光了。
请你计算李白这一路遇到店和花的顺序，有多少种不同的可能？
注意：壶里没酒 ( 0 斗) 时遇店是合法的，加倍后还是没酒；但是没酒时遇
花是不合法的。
【输入格式】
第一行包含两个整数 N 和 M.
【输出格式】
输出一个整数表示答案。由于答案可能很大，输出模 1000000007 的结果。
【样例输入】
5 10
【样例输出】
14
【样例说明】
如果我们用 0 代表遇到花，1 代表遇到店，14 种顺序如下：
010101101000000
010110010010000
011000110010000
100010110010000
011001000110000
100011000110000
100100010110000
010110100000100
011001001000100
100011001000100
100100011000100
011010000010100
100100100010100
101000001010100
【评测用例规模与约定】
对于 40% 的评测用例：1 ≤ N, M ≤ 10。
对于 100% 的评测用例：1 ≤ N, M ≤ 100。
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int mod=1e9+7;
ll dp[105][105][105];//dp[i][j][k] 店i次 花j次 剩余酒k 最高100
int main(){
int n,m,tol;
cin>>n>>m;//100 100
tol=n+m;
memset(dp,0,sizeof(dp));
dp[0][0][2]=1;
ll ans=0;
for(int now=1;now<=tol;now++){// 200
for(int i=0;i<=n;i++){//店次数 100
int j=now-i;
if(j<0||j>m)continue;
for(int k=0;k<100;k++){//100
if(k%2==0)//店
if(i>=1)
dp[i][j][k]+=dp[i-1][j][k/2];
//花
if(j>=1)
dp[i][j][k]+=dp[i][j-1][k+1];
dp[i][j][k]%=mod;
if(dp[i][j][k])
//cout<<i<<' '<<j<<' '<<k<<' '<<dp[i][j][k]<<endl;
//最后一次 花
if(now==tol){
ans=dp[i][j-1][1]%mod;
}
}
//单独算100
dp[i][j][100]=0;
if(i>=1)
for(int k=50;k<=100;k++){
dp[i][j][100]+=dp[i-1][j][k];
dp[i][j][100]%=mod;
}
}
}
cout<<ans<<endl;
return 0;
}
/*
考虑花最多100次，所以但凡大于100酒都可以视为无限
因此dp即可
复杂度O(n^3)
*/
J、 砍竹子
【问题描述】
这天，小明在砍竹子，他面前有 n 棵竹子排成一排，一开始第 i 棵竹子的
高度为 hi.
他觉得一棵一棵砍太慢了，决定使用魔法来砍竹子。魔法可以对连续的一
段相同高度的竹子使用，假设这一段竹子的高度为 H，那么使用一次魔法可以
把这一段竹子的高度都变为 ⌊ √⌊ H2 ⌋ + 1⌋，其中 ⌊x⌋ 表示对 x 向下取整。小明想
知道他最少使用多少次魔法可以让所有的竹子的高度都变为 1。
【输入格式】
第一行为一个正整数 n，表示竹子的棵数。
第二行共 n 个空格分开的正整数 hi，表示每棵竹子的高度。
【输出格式】
一个整数表示答案。
【样例输入】
6
2 1 4 2 6 7
【样例输出】
5
【样例说明】
其中一种方案：
2 1 4 2 6 7
→ 2 1 4 2 6 2
→ 2 1 4 2 2 2
→ 2 1 1 2 2 2
→ 1 1 1 2 2 2
→ 1 1 1 1 1 1
共需要 5 步完成
【评测用例规模与约定】
对于 20% 的数据，保证 n ≤ 1000, hi ≤ 106。
对于 100% 的数据，保证 n ≤ 2 × 105, hi ≤ 1018。
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int h[200005];
int to[1000005];
const ll Ma=1e18;
void init(){
for(int i=1;i<=1000000;i++){
to[i]=int(sqrt(i/2+1));
}
return;
}
int To(ll x){
if(x>1000000){
return int(sqrt(x/2+1));
}else{
return to[x];
}
}
struct Node{
int l,r,h;
friend bool operator <(Node x,Node y){
if(x.h==y.h)
return x.l>y.l;
else
return x.h<y.h;
}
};
int main(){
init();
int n;
cin>>n;
priority_queue<Node> q;
for(int i=1;i<=n;i++){
cin>>h[i];
Node x;
x.l=i;x.r=i;x.h=h[i];
if(h[i]!=1)
q.push(x);
}
ll ans=0;
while(!q.empty()){
Node now=q.top();
q.pop();
while(!q.empty()&&q.top().h==now.h&&q.top().l==now.r+1){
now.r=q.top().r;
q.pop();
}
//cout<<now.l<<' '<<now.r<<' '<<now.h<<endl;
now.h=To(now.h);
ans++;
if(now.h>1)
q.push(now);
}
cout<<ans<<endl;
return 0;
}
/*
1e18 sqrt(1e9) 1e4.5
对于大的数直接算，1e18最多两次会到1e4.5
小的数先预处理
然后用优先队列去先减大的数
每次减的时候合并相同值的相邻区间
*/
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
