第一题：第几天
2000年的1月1日，是那一年的第1天。
那么，2000年的5月4日，是那一年的第几天？
注意：需要提交的是一个整数，不要填写任何多余内容。
直接算，125
第二题：明码
题目描述
汉字的字形存在于字库中，即便在今天，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
十进制改二进制那里需要注意一下 ，答案387420489
#include<bits/stdc++.h>
using namespace std;
bitset<8> word;//将存放一个字节的二进制数字0,1.
string s;
int num,arr[40][10];
int main(){
for(int i = 0; i < 10;i++){//10行
//每行32个字节
for(int i = 0;i < 32;i++) {
cin>>num;
word = num;
s = word.to_string();
for(int j = 0;j < 8;j++){
arr[i][j] = s[j] - '0';//0==>0 1==>1
}
}
//打印输出
for(int i = 0;i < 32;i++) {
for(int j = 0;j <8;j++){
if(arr[i][j]){
cout<<"*";
}else{
cout<<" ";
}
}
if((i+1)%2==0){
cout<<endl;
}
}
cout<<endl;
}
long long int ans = pow(9,9);
cout<<ans<<endl;
return 0;
}
第四题：测试次数
题目描述
x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。
各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。
x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。
如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。
特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。
如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n
为了减少测试次数，从每个厂家抽样3部手机参加测试。
某次测试的塔高为1000层，如果我们总是采用最佳策略，在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢？
请填写这个最多测试次数。
注意：需要填写的是一个整数，不要填写任何多余内容。
遍历每层和手机数，在低层时手机没碎则测试次数加一，若碎了，则测试次数加一，手机数减一
#include<bits/stdc++.h>
using namespace std;
const int N = 1010;//最多N个手机 和N层
const int INF = 0x7fffffff;
int n,m,dp[N][N] = {0};//dp[i][j]表示的是i层的j个手机,最坏情况下需要仍的次数
int main() {
cin>>n>>m; //n层 m个手机
//当只有一个鸡蛋的时候,至少需要i次向下仍.
for(int i = 1; i<=n; i++) {
dp[i][1] = i;
}
//当只有一层的时候,只需要仍一次就可
for(int j = 1; j <= m; j++) {
dp[1][j] = 1;
}
//进行递推
for(int i = 2; i <= n; i++) {
for(int j = 2; j<=m; j++) {
dp[i][j] = INF;
for(int k = 1; k<=i; k++) {
dp[i][j] = min(dp[i][j],max(dp[k-1][j-1],dp[i-k][j])+1);
}
}
}
cout<<dp[n][m]<<endl;
return 0;
}
第六题：递增三元组
题目描述
给定三个整数数组
A = [A1, A2, … AN],
B = [B1, B2, … BN],
C = [C1, C2, … CN]，
请你统计有多少个三元组(i, j, k) 满足：
1 <= i, j, k <= N
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
【输出格式】
一个整数表示答案
#include<iostream>
#include<algorithm>
using namespace std;
int a[100010];
int b[100010];
int c[100010];
int n;
long long ans = 0;
int main(){
cin>>n;
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+1,a+n+1);
sort(b+1,b+n+1);
sort(c+1,c+n+1);
//定义两个指针（下标）
int j = 1;
int k = 1;
//以b为中间值 在a数组 c数组中查找
for(int i=1;i<=n;i++){
while(j<=n && a[j] < b[i]) j++; //在a数组中查找第一个大于等于b[i]的数
while(k<=n && c[k] <= b[i]) k++; //在c数组中查找第一个大于b[i]的数
ans += (long long)(j-1) * (n-k+1); //计算公式 可以自己举例推导出来
}
cout<<ans<<endl;
}第七题：螺旋折线
题目描述
如下图所示的螺旋折线经过平面上所有整点恰好一次。
对于整点(X, Y)，我们定义它到原点的距离dis(X, Y)是从原点到(X, Y)的螺旋折线段的长度。
例如dis(0, 1)=3, dis(-2, -1)=9
给出整点坐标(X, Y)，你能计算出dis(X, Y)吗？
对于整点 (X, Y)(X,Y)，我们定义它到原点的距离 dis(X, Y)dis(X,Y) 是从原点到 (X, Y)(X,Y) 的螺旋折线段的长度。
例如 dis(0, 1)=3, dis(-2, -1)=9dis(0,1)=3,dis(−2,−1)=9。
给出整点坐标 (X, Y)(X,Y)，你能计算出 dis(X, Y)dis(X,Y) 吗？
【输入格式】
对于40%的数据，-1000 <= X, Y <= 1000
对于70%的数据，-100000 <= X， Y <= 100000
对于100%的数据, -1000000000 <= X, Y <= 1000000000
【输出格式】
输出dis(X, Y）
将处于左下角的那条横线旋转90度往下放，作为一个正方形，方便求周长，为n*2*4,n为所在正方形的位置，即为它的边长
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
using namespace std;
typedef long long LL;
const int Max_n=100005;
int f(int x,int y,int n){
if(x==-n){
if(y==-n)
return 8*n;//n*2*4;
return y+n;//1+(y+n-1);
}
if(y==n){
return 3*n+x;//1+2*n-1+x+n;
}
if(x==n){
return 5*n-y;//1+2*n-1+2*n+n-y;
}
if(y==-n){
return 7*n-x;//1+2*n-1+2*n+2*n+n-x;
}
}
int main(){
int x,y;
scanf("%d%d",&x,&y);
int n=max(abs(x),abs(y));
LL ans=1LL*n*(n-1)*4+f(x,y,n);
printf("%lld\n",ans);
return 0;
}第八题：日志统计
题目描述
小明维护着一个程序员论坛。现在他收集了一份"点赞"日志，日志共有N行。其中每一行的格式是：
ts id
表示在ts时刻编号id的帖子收到一个"赞"。
现在小明想统计有哪些帖子曾经是"热帖"。如果一个帖子曾在任意一个长度为D的时间段内收到不少于K个赞，小明就认为这个帖子曾是"热帖"。
具体来说，如果存在某个时刻T满足该帖在[T, T+D)这段时间内(注意是左闭右开区间)收到不少于K个赞，该帖就曾是"热帖"。
给定日志，请你帮助小明统计出所有曾是"热帖"的帖子编号。
【输入格式】
第一行包含三个整数N、D和K。
以下N行每行一条日志，包含两个整数ts和id。
对于50%的数据，1 <= K <= N <= 1000
对于100%的数据，1 <= K <= N <= 100000 0 <= ts <= 100000 0 <= id <= 100000
【输出格式】
按从小到大的顺序输出热帖id。每个id一行。
类似于滑动窗口
#include<bits/stdc++.h>
using namespace std;
const int MAXSIZE = 100005;//定义数组最大长度
int n,d,k,ts,id,st,en,cnt;//cnt:d时间段内的最大点赞数.
vector<int> arr[MAXSIZE],res;
void judge(vector<int>& V,int x){
if(V.size()<k){//如果总的点赞数 < k ,则直接结束.
return;
}
sort(V.begin(),V.end());//进行排序
st = 0;
en = 1;
cnt = 0;
while(st<=en&&en<V.size()){
if(V[en]-V[st] < d){// vec[en] < vec[st]+d
cnt = max(cnt,en-st+1);//更新 d时间段内的最大点赞数.
en++;
}else{
st++;//左边界右移动
}
if(cnt>=k){//判断点赞数是否已经够了,如果够了 则加入结果集.
res.push_back(x);
return;
}
}
}
int main(){
cin>>n>>d>>k;
for(int i = 0;i < n;i++) {
cin>>ts>>id;
arr[id].push_back(ts);
}
for(int i=0;i<n;i++){
if(arr[i].size()!=0){
judge(arr[i],i);
}
}
//遍历输出
for(int i = 0;i < res.size();i++) {
cout<<res[i]<<endl;
}
return 0;
}
第九题：全球变暖
你有一张某海域NxN像素的照片，".“表示海洋、”#"表示陆地，如下所示
.......
.##....
.##....
....##.
..####.
...###.
.......
其中"上下左右"四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有2座岛屿。
由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。
例如上图中的海域未来会变成如下样子：
.......
.......
.......
.......
....#..
.......
.......
#include<bits/stdc++.h>
using namespace std;
char map1[1005][1005];
int n, num1, num2;//num1:未淹没前的岛屿个数 num2:淹没后剩余的岛屿个数
int NEXT[4][2] = {//方向数组:上下左右
-1,0,
1,0,
0,-1,
0,1
};
void dfs1(int x, int y) { //第一次遍历:统计海岛的总个数 // ! $
//结束条件(海洋/已经遍历过了)
if (map1[x][y] == '.' || map1[x][y] == '!' || map1[x][y] == '$') {
return;
}
//修改当前陆地的标记
//判断其周围是否有海洋,做出对应的标记修改
if (map1[x-1][y] == '.' || map1[x + 1][y] == '.' || map1[x][y - 1] == '.' || map1[x][y + 1] == '.') {
map1[x][y] = '!';
}
else {
map1[x][y] = '$';
}
//进行继续搜索
for (int i = 0; i < 4; i++) {
int tx = x + NEXT[i][0];
int ty = y + NEXT[i][1];
//判断是否越界
if (tx<1 || tx>n || ty<1 || ty>n) {
continue;
}
//继续深搜
dfs1(tx, ty);
}
}
void dfs2(int x, int y) { //第二次遍历:统计 淹没后海岛的总个数
//结束条件(如果周围是海洋.,或者已经遍历过了-># !和.此时效果一样)
if (map1[x][y] == '.' || map1[x][y] == '!' || map1[x][y] == '#') {//统计$的块数.
return;
}
//修改标记
if(map1[x][y]=='$')
map1[x][y] = '#';//如果是$,则将其转换为#
else
map1[x][y]='.';
//继续进行搜索
for (int i = 0; i < 4; i++) {
int tx = x + NEXT[i][0];
int ty = y + NEXT[i][1];
//判断是否越界
if (tx<1 || tx>n || ty<1 || ty>n) {
continue;
}
dfs2(tx, ty);
}
}
int main() {
cin >> n;
//初始化地图
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> map1[i][j];
}
}
//进行第一次搜寻
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (map1[i][j] == '#') {
num1++;
dfs1(i, j);
}
}
}
//打印第一次搜索后的图案
//for (int i = 1; i <= n; i++) {
// for (int j = 1; j <= n; j++) {
// cout << map1[i][j] << " ";
// }
// cout << endl;
//}
//进行第二次搜寻
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (map1[i][j] == '$') {
num2++;
dfs2(i, j);
}
}
}
cout << num1-num2 << endl;
return 0;
}
第十题：乘积最大
#include<iostream>
#include<algorithm>
using namespace std;
const int N=1e5+10;
long long int st[N];
int main()
{
int n,k;
cin>>n>>k;
int ft=0;
for(int i=0;i<n;i++)
{
cin>>st[i];
if(st[i]<0)ft++;
}
sort(st,st+n);
long long int ans=1;
if(k%2!=0&&ft==n)
{
for(int i=0;i<k;i++)
{
ans=ans*st[n-1-i]%1000000009;
ans=ans%1000000009;
}
cout<<ans%1000000009;
return 0;
}
if(k%2!=0)
{
ans=st[n-1];
k--;
n--;
}
int tt=0;
int u=0,v=n-1;
while(tt<k)
{
if(st[u]*st[u+1]>=st[v]*st[v-1])
{
long long pp=st[u]*st[u+1]%1000000009;
ans=ans*pp%1000000009;
ans=ans%1000000009;
u+=2;
tt+=2;
}
else
{
long long oo=st[v]*st[v-1]%1000000009;
ans=ans*oo%1000000009;
ans=ans%1000000009;
v=v-2;
tt=tt+2;
}
}
cout<<ans%1000000009;
}
3191
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
