試題A:組隊
本題總分:5分
作爲籃球隊教練,你需要從以下名單中選出 1 號位至 5 號位各一名球員, 組成球隊的首發陣容。
每位球員擔任 1 號位至 5 號位時的評分如下表所示。請你計算首發陣容 1 號位至 5 號位的評分之和最大可能是多少?
解題思路:
這道題就是取某個位置中分數最高的隊員,當然要注意一個隊員只能在一個位置,不能同時佔多個位置。
答案:
490
試題B:年號字串
本題總分:5分
小明用字母 A 對應數字 1,B 對應 2,以此類推,用 Z 對應 26。對於 27 以上的數字,小明用兩位或更長位的字符串來對應,例如 AA 對應 27,AB 對 應 28,AZ 對應 52,LQ 對應 329。 請問 2019 對應的字符串是什麼?
這是一道結果填空的題,你只需要算出結果後提交即可。本題的結果爲一 個大寫英文字符串,在提交答案時只填寫這個字符串,注意全部大寫,填寫多 餘的內容將無法得分。
解題思路:
這道題就是一個26進制的問題,例如329,先除以26,得到的是12,餘數是17,那麼17對應的是字母Q,接下來再用12除以26,得到的是0,餘數是12,而12對應的字母是L,所以答案就是LQ。要逆序表示,所以我用遞歸來實現!!!
程序代碼:
#include<stdio.h>
void solve(int n)
{
if(!n)
return ;
solve(n/26);
printf("%c",(char)(n%26+64));
}
int main()
{
solve(2019);
return 0;
}
答案:
BYQ
試題C:數列求值
本題總分:10分
給定數列 1, 1, 1, 3, 5, 9, 17, …,從第 4 項開始,每項都是前 3 項的和。求 第 20190324 項的最後 4 位數字。
這是一道結果填空的題,你只需要算出結果後提交即可。本題的結果爲一 個 4 位整數(提示:答案的千位不爲 0),在提交答案時只填寫這個整數,填寫 多餘的內容將無法得分。
解題思路:
類似於斐波那契額數列的規律,因爲題中說要得到最後四位數字,所以將結果對10000求餘即可!!!
程序代碼:
#include<stdio.h>
int a[20190325];
int main()
{
a[1]=1;
a[2]=1;
a[3]=1;
for(int i=4;i<=20190324;i++)
{
a[i]=(a[i-1]+a[i-2]+a[i-3])%10000;
}
printf("%d\n",a[20190324]);
return 0;
}
答案:
4659
試題D:數的分解
本題總分:10分
把 2019 分解成 3 個各不相同的正整數之和,並且要求每個正整數都不包 含數字 2 和 4,一共有多少種不同的分解方法? 注意交換 3 個整數的順序被視爲同一種方法,例如 1000+1001+18 和 1001+1000+18 被視爲同一種。
這是一道結果填空的題,你只需要算出結果後提交即可。本題的結果爲一 個整數,在提交答案時只填寫這個整數,填寫多餘的內容將無法得分。
解題思路:
這道題我想的就是純暴力解題,三個數各不相同,最少爲一位數,最多爲四位數,然後依次使得i,j,k的個十百千位不等於2和4就可以了,但是由於題中說的交換三個整數的順序被視爲同一種方法,而三個整數一共有3!=6種情況,所以我們要對最後的結果除以6纔是正確的!!!
程序代碼:
#include<stdio.h>
int main()
{
int ans=0;
for(int i=1;i<2019;i++)
{
for(int j=1;j<2019;j++)
{
for(int k=1;k<2019;k++)
{
if(i+j+k==2019&&i%10!=2&&i%10!=4&&(i/10)%10!=2&&
(i/10)%10!=4&&(i/100)%10!=2&&(i/100)%10!=4&&
(i/1000)%10!=2&&(i/1000)%10!=4&&j%10!=2&&j%10!=4&&(j/10)%10!=2&&
(j/10)%10!=4&&(j/100)%10!=2&&(j/100)%10!=4&&
(j/1000)%10!=2&&(j/1000)%10!=4&&k%10!=2&&k%10!=4&&(k/10)%10!=2&&
(k/10)%10!=4&&(k/100)%10!=2&&(k/100)%10!=4&&
(k/1000)%10!=2&&(k/1000)%10!=4&&i!=j&&i!=k&&j!=k)
ans++;
}
}
}
printf("%d\n",ans/6);
return 0;
}
答案:
40785
試題E:迷宮
本題總分:15分
下圖給出了一個迷宮的平面圖,其中標記爲 1 的爲障礙,標記爲 0 的爲可 以通行的地方。
010000 000100 001001 110000
迷宮的入口爲左上角,出口爲右下角,在迷宮中,只能從一個位置走到這 個它的上、下、左、右四個方向之一。 對於上面的迷宮,從入口開始,可以按DRRURRDDDR 的順序通過迷宮, 一共 10 步。其中 D、U、L、R 分別表示向下、向上、向左、向右走。 對於下面這個更復雜的迷宮(30 行 50 列),請找出一種通過迷宮的方式, 其使用的步數最少,在步數最少的前提下,請找出字典序最小的一個作爲答案。 請注意在字典序中D<L<R<U。(如果你把以下文字複製到文本文件中,請務 必檢查複製的內容是否與文檔中的一致。在試題目錄下有一個文件 maze.txt, 內容與下面的文本相同)
01010101001011001001010110010110100100001000101010 00001000100000101010010000100000001001100110100101 01111011010010001000001101001011100011000000010000 01000000001010100011010000101000001010101011001011 00011111000000101000010010100010100000101100000000 11001000110101000010101100011010011010101011110111 0001101101010100100100101000000100010100111000000010100000101000100110101010111110011000010000111010 00111000001010100001100010000001000101001100001001 11000110100001110010001001010101010101010001101000 00010000100100000101001010101110100010101010000101 11100100101001001000010000010101010100100100010100 00000010000000101011001111010001100000101010100011 10101010011100001000011000010110011110110100001000 10101010100001101010100101000010100000111011101001 10000000101100010000101100101101001011100000000100 10101001000000010100100001000100000100011110101001 00101001010101101001010100011010101101110000110101 11001010000100001100000010100101000001000111000010 00001000110000110101101000000100101001001000011101 10100101000101000000001110110010110101101010100001 00101000010000110101010000100010001001000100010101 10100001000110010001000010101001010101011111010010 00000100101000000110010100101001000001000000000010 11010000001001110111001001000011101001011011101000 00000110100010001000100000001000011101000000110011 10101000101000100010001111100010101001010000001000 10000010100101001010110000000100101010001011101000 00111100001000010000000110111000000001000000001011 10000001100111010111010001000110111010101101111000
這是一道結果填空的題,你只需要算出結果後提交即可。本題的結果爲一 個字符串,包含四種字母 D、U、L、R,在提交答案時只填寫這個字符串,填 寫多餘的內容將無法得分。
解題思路:
看到這種題,我們就應該想到DFS和BFS了,搜索遍歷,遍歷的時候按照字典序從小到大的順序進行四個方向遍歷進行了。
程序代碼:
#include<stdio.h>
#include<string.h>
#define N 30
#define M 50
struct node
{
int x;
int y;
int s;//路程
int f;//上一個位置下標
char ch;//上一個走向
};
node que[N*M];
int map[N][M]=
{
0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0,
0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1,
0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1,
0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1,
0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1,
1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0,
0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1,
1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0,
0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1,
1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0,
1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1,
1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1,
0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1,
1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0,
0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1,
1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1,
0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1,
1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0,
0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1,
1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0,
0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1,
1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0
};
int book[N][M],head,tail;
int next1[4][2]=
{//按照字典序
{1,0},//下 Down
{0,-1},//左 Left
{0,1},//右 Right
{-1,0}//上 Up
};
void print(int ans)
{
if(!ans)
return ;
print(que[ans].f);
printf("%c",que[ans].ch);
}
void bfs()
{
que[tail].x=0;
que[tail].y=0;
que[tail].s=0;
que[tail].f=0;
que[tail++].ch=0;
book[0][0]=1;
int flag=0;
while(head<tail)
{
int tx,ty;
for(int i=0;i<4;i++)
{
tx=que[head].x+next1[i][0];
ty=que[head].y+next1[i][1];
if(tx<0||tx>=N||ty<0||ty>=M)
continue;
if(map[tx][ty]==0&&book[tx][ty]==0)
{
book[tx][ty]=1;
que[tail].x=tx;
que[tail].y=ty;
que[tail].s=que[head].s+1;
que[tail].f=head;
if(next1[i][0])
{
que[tail].ch=(next1[i][0]==1 ? 'D':'U');
}
else if(next1[i][1])
{
que[tail].ch=(next1[i][1]==1 ? 'R':'L');
}
tail++;
if(tx==N-1&&ty==M-1)
{
flag=1;
break;
}
}
}
if(flag==1)
break;
head++;
}
print(tail-1);
}
int main()
{
bfs();
return 0;
}
答案:
DDDDRRURRRRRRDRRRRDDDLDDRDDDDDDDDDDDDRDDRRRURRUURRDDDDRDRRRRRRDRRURRDDDRRRRUURUUUUUUULULLUUUURRRRUULLLUUUULLUUULUURRURRURURRRDDRRRRRDDRRDDLLLDDRRDDRDDLDDDLLDDLLLDLDDDLDDRRRRRRRRRDDDDDDRR
試題F:特別數的和
時間限制: 1.0s 內存限制: 256.0MB 本題總分:15 分
【問題描述】 小明對數位中含有 2、0、1、9 的數字很感興趣(不包括前導 0),在 1 到 40 中這樣的數包括 1、2、9、10 至 32、39 和 40,共 28 個,他們的和是 574。 請問,在 1 到 n 中,所有這樣的數的和是多少?
【輸入格式】
輸入一行包含兩個整數 n。
【輸出格式】
輸出一行,包含一個整數,表示滿足條件的數的和。
【樣例輸入】 40
【樣例輸出】 574
【評測用例規模與約定】 對於 20% 的評測用例,1≤n≤10。 對於 50% 的評測用例,1≤n≤100。 對於 80% 的評測用例,1≤n≤1000。 對於所有評測用例,1≤n≤10000。
解題思路:
這道題主要就是找出在一定範圍內數位中出現 2、0、1、9 這四個數字之一的所有數字,既然這樣那就直接暴力吧!!!
程序代碼:
#include<iostream>
#include<cstdio>
using namespace std;
int main()
{
int n,num=0;
cin>>n;
for(int i=1;i<=n;i++)
{
int x=i;
while(x)
{
if(x%10==2||x%10==0||x%10==1||x%10==9)
{
num+=i;
break;
}
x/=10;
}
}
cout<<num<<endl;
return 0;
}
試題G:完全二叉樹的權值
時間限制: 1.0s 內存限制: 256.0MB 本題總分:20 分
【問題描述】 給定一棵包含 N 個節點的完全二叉樹,樹上每個節點都有一個權值,按從 上到下、從左到右的順序依次是 A1, A2, ··· AN,如下圖所示:
現在小明要把相同深度的節點的權值加在一起,他想知道哪個深度的節點 權值之和最大?如果有多個深度的權值和同爲最大,請你輸出其中最小的深度。 注:根的深度是 1。
【輸入格式】
第一行包含一個整數 N。 第二行包含 N 個整數 A1, A2, ··· AN 。
【輸出格式】
輸出一個整數代表答案。
【樣例輸入】 7 1 6 5 4 3 2 1【樣例輸出】 2
【評測用例規模與約定】 對於所有評測用例,1≤ N ≤100000,−100000≤ Ai ≤100000。
解題思路:
這道題如果學過完全二叉樹的性質就不難了,完全二叉樹的第 i 層的最大節點數爲 2^(i-1) 個,那麼對於某個下標的元素,我們只需要知道它屬於哪一層就行了,因爲題中所求的是相同深度的節點的權值,節點的數據範圍N最大爲100000,而具有n個節點的完全二叉樹的深度公式爲:向下取整(log2(n))+1,也就是向下取整(log2(100000))+1=17,又因爲題中所說根的深度爲1,所以此完全二叉樹的深度應該爲17+1=18層,下面我們來看代碼吧,必要的註釋已在其中標註!!!
程序代碼:
#include<iostream>
#include<cstdio>
using namespace std;
#define MAX 18//二叉樹的最大層數
long long a[MAX];
int deep(int x)//獲取下標爲x的節點的深度
{
int ans=0;
while(x>0)
{
x/=2;//代表同一層
ans++;
}
return ans;
}
int main()
{
int n,t;
cin>>n;
for(int i=1;i<=n;i++)
{
scanf("%d",&t);
a[deep(i)]+=t;//樹的同一層節點權值相加
}
int res=-99999999,tree;
for(int i=1;i<=MAX;i++)
{
if(a[i]>res)//比較
{
res=a[i];//更新
tree=i;//深度i賦值給變量tree
}
}
cout<<tree<<endl;
return 0;
}
試題H:等差數列
時間限制: 1.0s 內存限制: 256.0MB 本題總分:20 分
【問題描述】
數學老師給小明出了一道等差數列求和的題目。但是粗心的小明忘記了一 部分的數列,只記得其中 N 個整數。 現在給出這 N 個整數,小明想知道包含這 N 個整數的最短的等差數列有 幾項?
【輸入格式】
輸入的第一行包含一個整數 N。 第二行包含 N 個整數 A1,A2,··· ,AN。(注意 A1 ∼ AN 並不一定是按等差數 列中的順序給出)
【輸出格式】
輸出一個整數表示答案。
【樣例輸入】 5 2 6 4 10 20
【樣例輸出】 10
【樣例說明】 包含 2、6、4、10、20 的最短的等差數列是 2、4、6、8、10、12、14、16、 18、20。
【評測用例規模與約定】 對於所有評測用例,2≤ N ≤100000,0≤ Ai ≤109。
解題思路:
這道題首先應該考慮公差等不等於0的情況,公差不爲0的時候,我們先所給數組序列排序之後,求出相鄰數字差值的最大公約數,最終得到的就是公差;公差爲0的時候,不用多想,最少就是n項。
程序代碼:
#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
int a[100001];
int gcd(int a,int b)
{
int r;
while(b!=0)
{
r=a%b;
a=b;
b=r;
}
return a;
}
int main()
{
int n,d;
int maxn=0,minn=0x3f3f3f;
cin>>n;
for(int i=0;i<n;i++)
{
cin>>a[i];
maxn=max(maxn,a[i]);
minn=min(minn,a[i]);
}
sort(a,a+n);
d=a[1]-a[0];
for(int i=2;i<n;i++)
d=gcd(d,a[i]-a[i-1]);
if(d==0)
cout<<n<<endl;
else
cout<<((maxn-minn)/d+1)<<endl;
return 0;
}
試題I:後綴表達式
時間限制: 1.0s 內存限制: 256.0MB 本題總分:25 分
【問題描述】 給定 N 個加號、M 個減號以及 N + M + 1 個整數 A1,A2,··· ,AN+M+1,小 明想知道在所有由這 N 個加號、M 個減號以及 N + M +1 個整數湊出的合法的 後綴表達式中,結果最大的是哪一個?
請你輸出這個最大的結果。 例如使用1 2 3 + -,則 “2 3 + 1 -” 這個後綴表達式結果是 4,是最大的。
【輸入格式】
第一行包含兩個整數 N 和 M。 第二行包含 N + M + 1 個整數 A1,A2,··· ,AN+M+1。
【輸出格式】
輸出一個整數,代表答案。
【樣例輸入】 1 1 1 2 3
【樣例輸出】 4
【評測用例規模與約定】 對於所有評測用例,0≤ N,M ≤100000,−109 ≤ Ai ≤109。
解題思路:
這道題一開始有點懵,還是被後綴表達式這個概念整懵了,從概念上講,後綴表達式的意義和中綴表達式應該是一樣的,想想我們熟悉的中綴表達式,我們可以自由定製數字運算的順序,那麼後綴表達式也應該有這種能力,即能隨意組合運算順序,我們知道這個概念就行。第二點是如果只有 + 、- 運算符,那麼所有的數字都可以看成是相加的,-運算符可以看成負號。那麼題目就可以看成有 N + M + 1 個數字進行相加,但是必須要有 M 個數字變成其本身的相反數,我們很容易想到可以把負數變成它的相反數,就成了正數,順序應該是先將絕對值最大的負數變成正數,再是其他的數字。我們還需要討論負數的個數和 M 的關係:1、給定的數字本身中負數的個數小於 M,這種情況下剩下絕對值最小的幾個負數。2、給定的數字本身中負數的個數大於 M, 這種情況和 1 相似。3、給定的數字本身中負數的個數等於 M,這種情況全是正數,最後做加法就行了。
程序代碼:
#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
#define MAXN 200001
int num[MAXN];
int cmp(int a,int b)
{
return abs(a)>abs(b);//按絕對值從大到小排序
}
int main()
{
int N,M;
cin>>N>>M;
int n=N+M+1;
long long ans=0;
for(int i=0;i<n;i++)
cin>>num[i];
sort(num,num+n,cmp);
for(int i=0;i<n&&M>0;i++)
{
if(num[i]<0)
{//將負數變成正數
num[i]=-num[i];
M--;
}
}
if(M)//如果還存在負號,則將最後的數字變成負數
{
for(int i=n-M;i<n;i++)
num[i]=-num[i];
}
for(int i=0;i<n;i++)
ans+=num[i];
cout<<ans<<endl;
return 0;
}
附:好了,暫時就寫到這裏吧,最後一題不太明白就不寫了,總的來說,當時坐在考場的我還是有些緊張的,畢竟這是我第一次參加藍橋杯,而且有些題看似簡單,實則帶有坑。。。繼續努力吧,如有不理解的地方,歡迎在下方進行評論留言!!!