这篇博客涵盖了多个编程挑战的解决方案，包括判断大小月、闰年的算法，以及数值转换和溢出处理。还讨论了动态规划在扔鸡蛋问题中的应用，快速排序的原理，以及使用分治法解决数组问题。此外，还涉及了二维数组中寻找特定元素的策略和图形几何问题的数学解法。
1.
标题：第几天
2000年的1月1日，是那一年的第1天。
那么，2000年的5月4日，是那一年的第几天？
注意：需要提交的是一个整数，不要填写任何多余内容。
“==================手动分割============================”
大小月判断：
https://jingyan.baidu.com/article/7082dc1c504716e40b89bd69.html
然后需判断闰年，闰年二月有29天，平年二月有28天
①、普通年能被4整除且不能被100整除的为闰年。否则为平年。（如2004年就是闰年，1900年不是闰年）
②、世纪年能被400整除的是闰年。否则为平年。（如2000年是闰年，1900年不是闰年）
int main()
{
int years;
cin>>years;
if((years%4==0&&years%100!=0)||years%400==0)
cout<<"YES";
else cout<<"NO";
}
直接手算就可以了
答案：31+29+31+30+4=125
2：明码
汉字的字形存在于字库中，即便在今天，16点阵的字库也仍然使用广泛。
16点阵的字库把每个汉字看成是16x16个像素信息。并把这些信息记录在字节中。
一个字节可以存储8位信息，用32个字节就可以存一个汉字的字形了。
把每个字节转为2进制表示，1表示墨迹，0表示底色。每行2个字节，
一共16行，布局是：
第1字节，第2字节
第3字节，第4字节
....
第31字节, 第32字节
这道题目是给你一段多个汉字组成的信息，每个汉字用32个字节表示，这里给出了字节作为有符号整数的值。
题目的要求隐藏在这些信息中。你的任务是复原这些汉字的字形，从中看出题目的要求，并根据要求填写答案。
这段信息是（一共10个汉字）：
4 0 4 0 4 0 4 32 -1 -16 4 32 4 32 4 32 4 32 4 32 8 32 8 32 16 34 16 34 32 30 -64 0
16 64 16 64 34 68 127 126 66 -124 67 4 66 4 66 -124 126 100 66 36 66 4 66 4 66 4 126 4 66 40 0 16
4 0 4 0 4 0 4 32 -1 -16 4 32 4 32 4 32 4 32 4 32 8 32 8 32 16 34 16 34 32 30 -64 0
0 -128 64 -128 48 -128 17 8 1 -4 2 8 8 80 16 64 32 64 -32 64 32 -96 32 -96 33 16 34 8 36 14 40 4
4 0 3 0 1 0 0 4 -1 -2 4 0 4 16 7 -8 4 16 4 16 4 16 8 16 8 16 16 16 32 -96 64 64
16 64 20 72 62 -4 73 32 5 16 1 0 63 -8 1 0 -1 -2 0 64 0 80 63 -8 8 64 4 64 1 64 0 -128
0 16 63 -8 1 0 1 0 1 0 1 4 -1 -2 1 0 1 0 1 0 1 0 1 0 1 0 1 0 5 0 2 0
2 0 2 0 7 -16 8 32 24 64 37 -128 2 -128 12 -128 113 -4 2 8 12 16 18 32 33 -64 1 0 14 0 112 0
1 0 1 0 1 0 9 32 9 16 17 12 17 4 33 16 65 16 1 32 1 64 0 -128 1 0 2 0 12 0 112 0
0 0 0 0 7 -16 24 24 48 12 56 12 0 56 0 -32 0 -64 0 -128 0 0 0 0 1 -128 3 -64 1 -128 0 0
注意：需要提交的是一个整数，不要填写任何多余内容。
“==================手动分割============================”
1.一共十个汉字，每一行代表一个汉字，需要把int类型的十进制数据转换成二进制数据，int在此题中占有8位，可以考虑开辟一个长度为8的数组来记录二进制数值。
2.难点在于如何转换负数的二进制，负数的二进制在计算机中以补码的形式存在，对其相反数取补码便是负数在计算机中存储的形式。这里笔者刚开始认为取补码的形式是原码符号位不动，真值部分取补码进行转换，实际上直接对绝对值的原码形式取补是一样的，因为取补的时候要进行取反，所以符号位0转换成了符号位1。
3.补码反码原码知识链接：https://blog.csdn.net/sugarbliss/article/details/79789250
下面上代码：
#include<bits/stdc++.h>
using namespace std;
int Binary[8];//定义储存二进制的数组
void TransFormation(int a){
bool isnegative=false;
int temp,index=0;
memset(Binary,0,sizeof(Binary));//初始化数组
if(a<0){
isnegative=true;
a=-a;
}
while(a)
{
Binary[index++]=a%2;//倒序储存二进制码
a/=2;
}
if(isnegative){
for(int i=0;i<8;i++){
Binary[i]^=1;//按位取反，得到反码
}
for(int j=0;j<8;j++){
if(j==0)
temp=Binary[j]+=1;//加一，取补码
else
temp=Binary[j];
if(temp==2){
Binary[j+1]+=1;//处理进位
Binary[j]%=2;
}
else
break;
}
}
for(int i=7;i>=0;i--){
if(Binary[i])
cout<<"#";
else
cout<<' ';
}
}
int main()
{
int data[15][40];
int m=10,n=32;
for(int i=0;i<m;i++)
for(int j=0;j<n;j++)
cin>>data[i][j];
for(int i=0;i<m;i++){
for(int j=0;j<n;j++){
TransFormation(data[i][j]);
if(j&1)//位运算判断偶数
cout<<endl;
}
cout<<endl;
}
return 0;
}
运行结果：
就这？答案是387,420,489
3. 标题：乘积尾零
如下的10行数据，每行有10个整数，请你求出它们的乘积的末尾有多少个零？
5650 4542 3554 473 946 4114 3871 9073 90 4329
2758 7949 6113 5659 5245 7432 3051 4434 6704 3594
9937 1173 6866 3397 4759 7557 3070 2287 1453 9899
1486 5722 3135 1170 4014 5510 5120 729 2880 9019
2049 698 4582 4346 4427 646 9742 7340 1230 7683
5693 7015 6887 7381 4172 4341 2909 2027 7355 5649
6701 6645 1671 5978 2704 9926 295 3125 3878 6785
2066 4247 4800 1578 6652 4616 1113 6205 3264 2915
3966 5291 2904 1285 2193 1428 2265 8730 9436 7074
689 5510 8243 6114 337 4096 8199 7313 3685 211
注意：需要提交的是一个整数，表示末尾零的个数。不要填写任何多余内容。
“==================手动分割============================”
1.这要是直接算肯定溢出。刚开始的想法是用栈之类的数据结构保存0，但是如果在未出现0之前数据已经溢出则会导致计算错误，毕竟int类型的数据所能表示的数实再是太小了。计算器启动，唉，还是算了吧，Excel启动。
2.考虑0结尾肯定是2或者5结尾的数字相乘，计算2或5结尾的数字中较少的那一个便可以计算0的个数。
int num_zeros()
{
int num[10][10];
int num1=0,num2=0;
for(int i=0;i<10;i++)
for(int j=0;j<10;j++){
cin>>num[i][j];
if(num[i][j]%2==0)
num1++;
if(num[i][j]%5==0)
num2++;
}
return min(num1,num2);
}
运行结果：
4.标题：测试次数
x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。
各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。
x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。
如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。
特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。
如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n
为了减少测试次数，从每个厂家抽样3部手机参加测试。
某次测试的塔高为1000层，如果我们总是采用最佳策略，在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢？
请填写这个最多测试次数。
注意：需要填写的是一个整数，不要填写任何多余内容。
1.阿这，有必要嘛，不就扔个鸡蛋的题目嘛，非要邹出一个x星球摔手机阿。
2.考虑使用动态规划。结果和两个变量有关，一个是鸡蛋的数量，另外一个是所需检验的楼数。当我有一个鸡蛋，我可以在需要检验的楼层之间一层一层扔，假如在X层扔，碎了的状态就变成鸡蛋少一个，在1-X-1层扔。没碎，鸡蛋数目不变，在X以上层数开始扔，此时的楼数是M-X。再扔的步骤就变成了子问题了。问题结构类似，并且可以用到之前的结果可以使用动态规划的方法。若用不到之间子问题的结果，可以考虑使用分治法。
转移方程：
其中max是鸡蛋咋扔咋不碎的最坏情况，求得便是最坏情况，故取最大值，min是如何扔鸡蛋，从哪一层开始扔鸡蛋，是扔鸡蛋的方法，所以要选择最优的方法。
考虑初始状态：只有1个鸡蛋，M层楼需要扔M次，只有一层楼需要扔1次。初始化时，将dp[i][j]设为j就可以了，这是最坏情况。
class Eggs{
public:
int getminStep(int eggNum,int floorNum){
if(floorNum<1||eggNum<1)
return 0;
int dp[eggNum+1][floorNum+1];
for(int i=1;i<eggNum+1;i++)
for(int j=1;j<floorNum+1;j++)
dp[i][j]=j;
for(int n=2;n<eggNum+1;n++)
for(int m=1;m<floorNum+1;m++)
for(int k=1;k<=m;k++)
dp[n][m]=min(dp[n][m],1+max(dp[n-1][k-1],dp[n][m-k]));
return dp[eggNum][floorNum];
}
};
运行结果：
5.
标题：快速排序。
以下代码可以从数组a[]中找出第k小的元素。
它使用了类似快速排序中的分治算法，期望时间复杂度是O(N)的。
请仔细阅读分析源码，填写划线部分缺失的内容。
#include <stdio.h>
int quick_select(int a[], int l, int r, int k) {
int p = rand() % (r - l + 1) + l;
//随机在r-l中选择一个下标作为基准的下标
int x = a[p];
//x为排序基准的元素
{int t = a[p]; a[p] = a[r]; a[r] = t;}
//将x与此趟排序最末元素a[r]交换位置，此时基准在最末
int i = l, j = r;
//用i，j记录左右边界的下标，作为双指针
while(i < j) {
while(i < j && a[i] < x) i++;
//从左起，找到第一个大于基准的数
if(i < j) {
a[j] = a[i];
j--;
//将这个大于基准的数与复制到右边位置
}
while(i < j && a[j] > x) j--;
//从右起，找到第一个小于基准的数，用原来的i的位置接收这个数
if(i < j) {
a[i] = a[j];
i++;
}
}
a[i] = x;
//将基准换成x，至此第i号元素在第i-1个位置上
p = i;
if(i - l + 1 == k) return a[i];
if(i - l + 1 < k) return quick_select(a,i+1,r,k-i+l-1 ); //填空
else return quick_select(a, l, i - 1, k);
}
int main()
{
int a[] = {1, 4, 2, 8, 5, 7, 23, 58, 16, 27, 55, 13, 26, 24, 12};
printf("%dn", quick_select(a, 0, 14, 5));
return 0;
}注意：只填写划线部分缺少的代码，不要抄写已经存在的代码或符号。
1.复习一下快排，快排基于分治法的思想，这里有一篇文章我觉得写的很好。
god-jiang：神级基础排序——快速排序zhuanlan.zhihu.com
分治法可以用来解决某一个规模较大且能够被分解成问题类似的子问题的问题，例如二分查找，对N个数字查找与对N/2个数字查找的问题是类似的，就可以利用分治法。而快速排序每一趟排序相当于定下了基准的位置，再对基准之前之后的数组进行排序。
下面上快排的代码：
int partition(int arr[],int startIndex,int endIndex);
void swap(int arr[],int i,int j);
void quickSort(int arr[],int startIndex,int endIndex)
{
if(startIndex<endIndex){
//找出基准
int partition=partition(arr,startIndex,endIndex);
quickSort(arr,startIndex,partition-1);
quickSort(arr,partition+1);
}
}
int partition(int arr[],int startIndex,int endIndex)
{
int pivot=arr[startIndex];
int left=startIndex;
int right=endIndex;
while(left!=right)
{
while(arr[right]>pivot&&left<right)
right--;
while(arr[left]<pivot&&left<right)
left++;
if(left<right)
swap(arr,left,right);
}
return left;
}
void swap(int i,int j)
{
arr[i]^=arr[j];
arr[j]^=arr[i];
arr[i]^=arr[j];
}
6.标题：递增三元组
给定三个整数数组
A = [A1, A2, ... AN],
B = [B1, B2, ... BN],
C = [C1, C2, ... CN]，
请你统计有多少个三元组(i, j, k) 满足：
1. 1 <= i, j, k <= N
2. Ai < Bj < Ck
【输入格式】
第一行包含一个整数N。
第二行包含N个整数A1, A2, ... AN。
第三行包含N个整数B1, B2, ... BN。
第四行包含N个整数C1, C2, ... CN。
对于30%的数据，1 <= N <= 100
对于60%的数据，1 <= N <= 1000
对于100%的数据，1 <= N <= 100000 0 <= Ai, Bi, Ci <= 100000
【输出格式】
一个整数表示答案
【样例输入】
3
1 1 1
2 2 2
3 3 3
【样例输出】
27
“======================手动分割========================”
1.三重循环暴力找，暴力杯实至名归。
int main()
{
int N;
cin>>N;
int A[N],B[N],C[N];
for(int i=0;i<N;i++)
cin>>A[i];
for(int i=0;i<N;i++)
cin>>B[i];
for(int i=0;i<N;i++)
cin>>C[i];
int res=0;
for(int i=0;i<N;i++)
for(int j=0;j<N;j++)
for(int k=0;k<N;k++)
//if(A[i]<B[j]<C[k])
//这里整错了假如A[i]<B[j]不成立是0对于第三个数只要大于0即成立
if(A[i]<B[j]&&B[j]<C[k])
res++;
cout<<res;
return 0;
}
但是感觉不太好，时间复杂度是N^3。
如果以B中的元素作为基准，找出A和C第一个比B[i]大的元素，再通过公式计算个数，可以将时间复杂度降低到N^2。但是此时要建立在有序数组的基础上，C自带的sort函数复杂度也不会超过N^2,故总的复杂度还是N^2。
上代码：
int main()
{
int N;
cin>>N;
int A[N+1],B[N+1],C[N+1];
for(int i=1;i<=N;i++)
cin>>A[i];
for(int i=1;i<=N;i++)
cin>>B[i];
for(int i=1;i<=N;i++)
cin>>C[i];
sort(A,A+N);
sort(B,B+N);
sort(C,C+N);
int j=1;
int k=1;
//维护双指针
long long res=0;
for(int i=1;i<=N;i++){
while(j<=N&&A[j]<B[i])
j++;
while(k<=N&&C[k]<=B[i])
k++;
res+=(long long)(j-1)*(N-k+1);
}
cout<<res;
return 0;
}
7.标题：螺旋折线
如图p1.png所示的螺旋折线经过平面上所有整点恰好一次。
对于整点(X, Y)，我们定义它到原点的距离dis(X, Y)是从原点到(X, Y)的螺旋折线段的长度。
例如dis(0, 1)=3, dis(-2, -1)=9
给出整点坐标(X, Y)，你能计算出dis(X, Y)吗？
【输入格式】
X和Y
【输出格式】
输出dis(X, Y)
【样例输入】0 1
【样例输出】3
1.我一开始的想法是用动态规划做，但是找不到前后项之间的关系。后来上网看了题解。
先听我细细道来，看不懂再看大佬的题解。
2.首先这个图形绕来绕去，像是多个正方形嵌套，仅看第三象限的y=x的点，对(0,0)点向左下角翻折一次，(-1,-1)向左下角翻转一次，每一次都得到一个与上一次得到的正方形边长和相差8的正方形。可以考虑使用等差数列来计算。
3.可以分为两种情况，y=x下方的点，可以用max(abs(x),abs(y))个等差的正方形减去与到y=x上的点的绝对值距离来计算。y=x上方的点，可以用max(abs(x),abs(y))个等差的正方形加上y=x上的点的绝对值距离来计算。
下面上代码：
int max(int a,int b)
{
return (abs(a)>abs(b))?abs(a):abs(b);
}
int main()
{
int every_count=0;
int all_count=0;
int x,y;
cin>>x>>y;
int d=max(x,y);//计算有多少个正方形
if(x>=y)//点在y=x下方，用前d个正方形减去(x,y)到(-d,-d)的距离
{
every_count=x-(-d)+y-(-d);
all_count=8*d+d*(d-1)/2*8 -every_count;
cout<<all_count<<endl;
}
else
{
//点在y=x上方，用前d-1个正方形加上(x,y)到(-d,-d)的距离
every_count = x - (-d) + y - (-d);
all_count = 8 * (d-1) + (d-2)*(d - 1) / 2 * 8 +every_count;
cout << all_count << endl;
}
return 0;
}
题解链接：
第九届蓝桥杯--螺旋折线 - Single_Dont - 博客园www.cnblogs.com
运行结果：
8.标题：日志统计
小明维护着一个程序员论坛。现在他收集了一份"点赞"日志，日志共有N行。其中每一行的格式是：
ts id
表示在ts时刻编号id的帖子收到一个"赞"。
现在小明想统计有哪些帖子曾经是"热帖"。如果一个帖子曾在任意一个长度为D的时间段内收到不少于K个赞，小明就认为这个帖子曾是"热帖"。
具体来说，如果存在某个时刻T满足该帖在[T, T+D)这段时间内(注意是左闭右开区间)收到不少于K个赞，该帖就曾是"热帖"。
给定日志，请你帮助小明统计出所有曾是"热帖"的帖子编号。
【输入格式】
第一行包含三个整数N、D和K。
以下N行每行一条日志，包含两个整数ts和id。
【输出格式】
按从小到大的顺序输出热帖id。每个id一行。
【输入样例】
7 10 2
0 1
0 10
10 10
10 1
9 1
100 3
100 3
【输出样例】
1
3
可以考虑将每一篇帖子点赞的时刻按照从小到大排列，然后用尺取法，在长度为k的区间在其上滑动与d作比较，从而得出结果。
本题需要考虑的是如何将杂乱无章的输入数据按照帖子序号整理以及尺取法判断条件。考虑使用含有ts和id的结构体表示每篇帖子点赞的状态。再用vector<int> v[MAX_N]按顺序整理帖子点赞数。例如v[i]为第i篇帖子点赞情况。此外还需要构造sort函数中对结构体比较的函数。下面上代码：
struct Node{
int ts;
int id;
};
vector<int> v[10000];
Node no[10000];
void solve(int k,int d,int x)
{
int l=0,r=-1;
r+=k;
while(r<len){
if(v[x][r]<v[x][l]+d){
//d时刻内能否得k个赞
cout<<x<<endl;
break;
}
else{
r++;
l++;
}
}
void cmp(node a,node b)
{
return a.ts<b.ts;
}
int main()
{
int n,d,k;
cin>>n>>d>>k;
for(int i=0;i<n;i++)
cin>>no[i].ts>>no[i].id;
sort(no,no+n,cmp);
for(int i=0;i<n;i++)
v[no[i].id]=no[i].ts;
solve(int k,int d,int x);
return 0;
}
扫一扫
978
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
