2013年藍橋杯真題
1、題目標題: 高斯日記
大數學家高斯有個好習慣：無論如何都要記日記。
他的日記有個與眾不同的地方，他從不註明年月日，而是用一個整數代替，比如：4210
後來人們知道，那個整數就是日期，它表示那一天是高斯出生後的第幾天。這或許也是個好習慣，它時時刻刻提醒著主人：日子又過去一天，還有多少時光可以用於浪費呢？
高斯出生於：1777年4月30日。
在高斯發現的一個重要定理的日記上標註著：5343，因此可算出那天是：1791年12月15日。
高斯獲得博士學位的那天日記上標著：8113
請你算出高斯獲得博士學位的年月日。
提交答案的格式是：yyyy-mm-dd, 例如：1980-03-21
請嚴格按照格式，通過瀏覽器提交答案。
注意：只提交這個日期，不要寫其它附加內容，比如：說明性的文字。1799-07-16
#include <iostream>
using namespace std;
bool isLeapYear(int y) {
return (y % 4 == 0 && y % 100 != 0) || (y % 400 == 0);
}
int main(int argc, const char *argv[]) {
int y = 1777;
int m = 4;
int d = 30;
for (int i = 0; i < 5342; ++i) {
d++;
if (m == 12 && d == 32) {
y++;
m = 1;
d = 1;
continue;
}
if ((m == 1 || m == 3 || m == 5 || m == 7 || m == 8 || m == 10) && d == 32) {
m++;
d = 1;
continue;
}
if ((m == 4 || m == 6 || m == 9 || m == 11) && d == 31) {
m++;
d = 1;
continue;
}
if (m == 2 && isLeapYear(y) && d == 30) {
m++;
d = 1;
continue;
}
if (m == 2 && !isLeapYear(y) && d == 29) {
m++;
d = 1;
continue;
}
}
cout << y << " " << m << " " << d << endl;
return 0;
}
2、標題: 馬虎的算式
小明是個急性子，上小學的時候經常把老師寫在黑板上的題目抄錯了。
有一次，老師出的題目是：36 x 495 = ?
他卻給抄成了：396 x 45 = ?
但結果卻很戲劇性，他的答案竟然是對的！！
因為 36 * 495 = 396 * 45 = 17820
類似這樣的巧合情況可能還有很多，比如：27 * 594 = 297 * 54
假設 a b c d e 代表1~9不同的5個數字（注意是各不相同的數字，且不含0）
能滿足形如： ab * cde = adb * ce 這樣的算式一共有多少種呢？
請你利用計算機的優勢尋找所有的可能，並回答不同算式的種類數。滿足乘法交換律的算式計為不同的種類，所以答案肯定是個偶數。
答案直接通過瀏覽器提交。
注意：只提交一個表示最終統計種類數的數字，不要提交解答過程或其它多餘的內容。
#include <iostream>
using namespace std;
int main(int argc, const char *argv[]) {
int ans=0;
for (int a = 1; a < 10; ++a) {
for (int b = 1; b < 10; ++b) {
if (b != a)
for (int c = 1; c < 10; ++c) {
if (c != a && c != b)
for (int d = 1; d < 10; ++d) {
if (d != a && d != b && d != c)
for (int e = 1; e < 10; ++e) {
if (e != a && e != b && e != c && e != d) {
// ab * cde = adb * ce
if ((a*10+b)*(c*100+d*10+e)==(a*100+d*10+b)*(c*10+e)) {
printf ("(%d*10+%d)*(%d*100+%d*10+%d)==(%d*100+%d*10+%d)*(%d*10+%d)==%d\n",a,b,c,d,e,a,d,b,c,e,(a*10+b)*(c*100+d*10+e));
ans++;
}
}
}
}
}
}
}
printf("%d",ans);
return 0;
}
3、題目標題: 第39級臺階
小明剛剛看完電影《第39級臺階》，離開電影院的時候，他數了數禮堂前的臺階數，恰好是39級!
站在臺階前，他突然又想著一個問題：
如果我每一步只能邁上1個或2個臺階。先邁左腳，然後左右交替，最後一步是邁右腳，也就是說一共要走偶數步。
那麼，上完39級臺階，有多少種不同的上法呢？
請你利用計算機的優勢，幫助小明尋找答案。要求提交的是一個整數。
注意：不要提交解答過程，或其它的輔助說明文字。
//去掉一個條件：偶數步，只問只能邁上1個或2個臺階的條件下一共有多少種走法呢？
//f(n=39){return f(n-1)+f(n-2)}
#include <iostream>
using namespace std;
int ans;
/**
*
* @param n 剩下的階梯數
* @param step 已走的步數
*/
void f(int n, int step) {
if (n < 0)
return;
if (n == 0 && step % 2 == 0){
ans++;
return;
}
f(n - 1, step + 1);
f(n - 2, step + 1);
}
int main(int argc, const char *argv[]) {
f(39, 0);
cout << ans << endl;
return 0;
}
4、標題: 黃金連分數
黃金分割數0.61803... 是個無理數，這個常數十分重要，在許多工程問題中會出現。有時需要把這個數字求得很精確。對於某些精密工程，常數的精度很重要。也許你聽說過哈勃太空望遠鏡，它首次升空後就發現了一處人工加工錯誤，
對那樣一個龐然大物，其實只是鏡面加工時有比頭髮絲還細許多倍的一處錯誤而已，卻使它成了“近視眼”!!
言歸正傳，我們如何求得黃金分割數的儘可能精確的值呢？有許多方法。比較簡單的一種是用連分數：
1
黃金數 = ---------------------
1
1 + -----------------
1
1 + -------------
1
1 + ---------
1 + ...這個連分數計算的“層數”越多，它的值越接近黃金分割數。
請你利用這一特性，求出黃金分割數的足夠精確值，要求四捨五入到小數點後100位。
小數點後3位的值為：0.618
小數點後4位的值為：0.6180
小數點後5位的值為：0.61803
小數點後7位的值為：0.6180340
（注意尾部的0，不能忽略）你的任務是：寫出精確到小數點後100位精度的黃金分割值。
注意：尾數的四捨五入！ 尾數是0也要保留！
顯然答案是一個小數，其小數點後有100位數字，請通過瀏覽器直接提交該數字。
注意：不要提交解答過程，或其它輔助說明類的內容。
/*1、轉為求斐波那契數列的n和n+1項
* 2、n取多少？再增加n，小數點後的101位沒有變化
* 3、不能用c語言定義的整數型直接運算，而要手工地寫大數加法和除法（減法）*/
#include <string>
#include <iostream>
#include <sstream>
#include <algorithm>
using namespace std;
int n = 400;
void i2s(int num, string &str) {
stringstream ss;
ss << num;
ss >> str;
}
string add(string a, string b) {
a = a.substr(a.find_first_not_of('0'));
b = b.substr(b.find_first_not_of('0'));
long long lenA = a.length();
long long lenB = b.length();
long long len = max(lenA, lenB) + 10;
//翻轉，便於從低位逐步求和
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
string ans(len, '0');//初始化答案為len長，全部為字元0
// 把a拷貝到ans中
for (int i = 0; i < lenA; ++i) {
ans[i] = a[i];
}
int tmp = 0;//tmp是上一位相加後的進位
for (int i = 0; i < len; ++i) {
if (i < b.length())
tmp += (ans[i] - '0') + (b[i] - '0');//假設為18
else
tmp += (ans[i] - '0');
ans[i] = tmp % 10 + '0';//8 8+'0'
tmp /= 10;//1
}
reverse(ans.begin(), ans.end());
return ans.substr(ans.find_first_not_of('0'));
}
int cmp(string a, string b) {
unsigned long i1 = a.find_first_not_of('0');
if (i1 == string::npos)a = '0';
else a.substr(i1);
unsigned long i2 = b.find_first_not_of('0');
if (i2 == string::npos)b = '0';
else b.substr(i2);
if (a.length() > b.length())return 1;
else if (a.length() < b.length())return -1;
else {//長度相等
if (a < b)return -1;
if (a > b)return 1;
else return 0;
}
}
//此處，a一定大於等於b
string subtract(string a, string b) {
// 完整的減法裡面，a可以小於b，這時結果為負數，交換ab進行下面的程式碼
// 1.翻轉
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
// 2.按位做減法
for (int i = 0; i < b.length(); ++i) {
if (a[i] >= b[i]) {
a[i] = a[i] - b[i] + '0';
} else {//就要借
int k = 1;
while (a[i + k] == '0') {
a[i + k] = '9';
k++;
}
// 這裡可以保證i+k這一位上不是0
a[i + k] = a[i + k] - '1' + '0';
a[i] = (a[i] - '0' + 10) - (b[i] - '0') + '0';
}
}
reverse(a.begin(), a.end());
if (a.find_first_not_of('0') == string::npos)return "0";
return a.substr(a.find_first_not_of('0'));
}
/*轉換成減法*/
string divide(string a, string b) {
// 只考慮a<b的情況
string ans = "0.";
// 轉化成減法
for (int i = 0; i < 101; ++i) {//101次
a.append("0");
int t = 0;
while (cmp(a, b) >= 0) {//a>=b
a = subtract(a, b);//不停地做減法
t++;//記錄減法做了多少次
}
string t_str;
i2s(t, t_str);
ans.append(t_str);
}
return ans;
}
int main(int argc, const char *argv[]) {
string a = "1";
string b = "1";
cout << subtract(a, b) << endl;
for (int i = 3; i <= n; ++i) {
string tmp = b;
b = add(a, b);
a = tmp;
// cout << b << " " << endl;
}
// a b是斐波那契的n-1和n項
string ans = divide(a, b);
cout << ans << endl;
cout << ans.length()-2 << endl;
return 0;
}
5、 題目標題：字首判斷
如下的程式碼判斷 needle_start指向的串是否為haystack_start指向的串的字首，如不是，則返回NULL。
比如："abcd1234" 就包含了 "abc" 為字首
char* prefix(char* haystack_start, char* needle_start)
{
char* haystack = haystack_start;
char* needle = needle_start;
while(*haystack && *needle){
if(______________________________) return NULL; //填空位置
}
if(*needle) return NULL;
return haystack_start;
}
請分析程式碼邏輯，並推測劃線處的程式碼，通過網頁提交。
注意：僅把缺少的程式碼作為答案，千萬不要填寫多餘的程式碼、符號或說明文字！！
#include <iostream>
using namespace std;
/**
*
* @param haystack_start 母串
* @param needle_start 字首
* @return
*/
char *prefix(char *haystack_start, char *needle_start) {
char *haystack = haystack_start;
char *needle = needle_start;//字首
while (*haystack && *needle) {//兩個指標都沒有越界
// if(______________________________) return NULL; //填空位置
//移動指標
//並判斷
if (*(haystack++) != *(needle++))return NULL;
}
if (*needle) return NULL;
return haystack_start;
}
int main(int argc, const char *argv[]) {
cout << prefix("abcd123", "abd") << endl;
return 0;
}
6、標題：三部排序
一般的排序有許多經典演算法，如快速排序、希爾排序等。
但實際應用時，經常會或多或少有一些特殊的要求。我們沒必要套用那些經典演算法，可以根據實際情況建立更好的解法。
比如，對一個整型陣列中的數字進行分類排序：
使得負數都靠左端，正數都靠右端，0在中部。注意問題的特點是：負數區域和正數區域內並不要求有序。
可以利用這個特點通過1次線性掃描就結束戰鬥!!以下的程式實現了該目標。
其中x指向待排序的整型陣列，len是陣列的長度。
void sort3p(int* x, int len)
{
int mod = 0;
int left = 0;
int right = len-1;while(mod<=right){
if(x[mod]<0){
int t = x[left];
x[left] = x[mod];
x[mod] = t;
left++;
mod++;
}
else if(x[mod]>0){
int t = x[right];
x[right] = x[mod];
x[mod] = t;
right--;
}
else{
__________________________; //填空位置
}
}}
如果給定陣列：
25,18,-2,0,16,-5,33,21,0,19,-16,25,-3,0
則排序後為：
-3,-2,-16,-5,0,0,0,21,19,33,25,16,18,25請分析程式碼邏輯，並推測劃線處的程式碼，通過網頁提交
注意：僅把缺少的程式碼作為答案，千萬不要填寫多餘的程式碼、符號或說明文字！！
#include <iostream>
using namespace std;
void sort3p(int* x, int len)
{
int mod = 0;
int left = 0;
int right = len-1;
while(mod<=right){
if(x[mod]<0){
int t = x[left];
x[left] = x[mod];
x[mod] = t;
left++;
mod++;
}
else if(x[mod]>0){
int t = x[right];
x[right] = x[mod];
x[mod] = t;
right--;
}
else{//==0
// __________________________; //填空位置
mod++;
}
}
}
int main(int argc, const char * argv[]) {
int arr[]={25,18,-2,0,16,-5,33,21,0,19,-16,25,-3,0};
sort3p(arr,14);
for (int i = 0; i < 14; ++i) {
cout<<arr[i]<<" ";
}
return 0;
}
7、 標題：錯誤票據
某涉密單位下發了某種票據，並要在年終全部收回。
每張票據有唯一的ID號。全年所有票據的ID號是連續的，但ID的開始數碼是隨機選定的。
因為工作人員疏忽，在錄入ID號的時候發生了一處錯誤，造成了某個ID斷號，另外一個ID重號。
你的任務是通過程式設計，找出斷號的ID和重號的ID。
假設斷號不可能發生在最大和最小號。
要求程式首先輸入一個整數N(N<100)表示後面資料行數。
接著讀入N行資料。
每行資料長度不等，是用空格分開的若干個（不大於100個）正整數（不大於100000）
每個整數代表一個ID號。要求程式輸出1行，含兩個整數m n，用空格分隔。
其中，m表示斷號ID，n表示重號ID例如：
使用者輸入：
2
5 6 8 11 9
10 12 9則程式輸出：
7 9
再例如：
使用者輸入：
6
164 178 108 109 180 155 141 159 104 182 179 118 137 184 115 124 125 129 168 196
172 189 127 107 112 192 103 131 133 169 158
128 102 110 148 139 157 140 195 197
185 152 135 106 123 173 122 136 174 191 145 116 151 143 175 120 161 134 162 190
149 138 142 146 199 126 165 156 153 193 144 166 170 121 171 132 101 194 187 188
113 130 176 154 177 120 117 150 114 183 186 181 100 163 160 167 147 198 111 119則程式輸出：
105 120
資源約定：
峰值記憶體消耗 < 64M
CPU消耗 < 1000ms
請嚴格按要求輸出，不要畫蛇添足地列印類似：“請您輸入...” 的多餘內容。所有程式碼放在同一個原始檔中，除錯通過後，拷貝提交該原始碼。
注意: main函式需要返回0
注意: 只使用ANSI C/ANSI C++ 標準，不要呼叫依賴於編譯環境或作業系統的特殊函式。
注意: 所有依賴的函式必須明確地在原始檔中 #include <xxx>，
不能通過工程設定而省略常用標頭檔案。提交時，注意選擇所期望的編譯器型別。
/*原始資料連續，輸入的時候是亂序的，求出斷開的號碼和重複的號碼*/
#include <iostream>
#include <sstream>
#include <algorithm>
using namespace std;
const int MaxN = 10000;
int line;
int data[MaxN];
void s2i(string &str, int &num) {
stringstream ss;
ss << str;
ss >> num;
}
int main(int argc, const char *argv[]) {
scanf("%d", &line);
getchar();
int index = 0;
for (int i = 0; i < line; ++i) {
string s;
getline(cin, s);
istringstream iss(s);
string tmp;
while (getline(iss, tmp, ' ')) {
s2i(tmp, data[index++]);
}
}
// 最終index就是資料的個數
// cout << index << endl;
//排序
sort(data, data + index);
int a, b;
for (int i = 1; i < index; ++i) {
if (data[i] == data[i - 1] + 2)a = data[i] - 1;//printf("%d ", data[i] - 1);
if (data[i] == data[i - 1]) b = data[i];//printf("%d", data[i]);
}
printf("%d %d", a, b);
return 0;
}
8、題目標題：翻硬幣
小明正在玩一個“翻硬幣”的遊戲。
桌上放著排成一排的若干硬幣。我們用 * 表示正面，用 o 表示反面（是小寫字母，不是零）。
比如，可能情形是：**oo***oooo
如果同時翻轉左邊的兩個硬幣，則變為：oooo***oooo
現在小明的問題是：如果已知了初始狀態和要達到的目標狀態，每次只能同時翻轉相鄰的兩個硬幣,那麼對特定的局面，
最少要翻動多少次呢？
我們約定：把翻動相鄰的兩個硬幣叫做一步操作，那麼要求：程式輸入：
兩行等長的字串，分別表示初始狀態和要達到的目標狀態。每行的長度<1000程式輸出：
一個整數，表示最小操作步數例如：
使用者輸入：
**********
o****o****程式應該輸出：
5再例如：
使用者輸入：
*o**o***o***
*o***o**o***程式應該輸出：
1
資源約定：
峰值記憶體消耗 < 64M
CPU消耗 < 1000ms
請嚴格按要求輸出，不要畫蛇添足地列印類似：“請您輸入...” 的多餘內容。所有程式碼放在同一個原始檔中，除錯通過後，拷貝提交該原始碼。
注意: main函式需要返回0
注意: 只使用ANSI C/ANSI C++ 標準，不要呼叫依賴於編譯環境或作業系統的特殊函式。
注意: 所有依賴的函式必須明確地在原始檔中 #include <xxx>， 不能通過工程設定而省略常用標頭檔案。提交時，注意選擇所期望的編譯器型別。
#include <iostream>
#include <queue>
#include <set>
using namespace std;
typedef struct stateAndLevel {
string str;
int level;
} stateAndLevel;
queue<stateAndLevel> queue1;
set<string> set1;
int n;
int main(int argc, const char *argv[]) {
string src;
string target;
getline(cin, src);
getline(cin, target);
n = src.length();
stateAndLevel first = {src, 0};
queue1.push(first);//佇列的第一個元素就是原串
while (!queue1.empty()) {
//獲取並彈出佇列首部
stateAndLevel &front = queue1.front();
queue1.pop();
string basicString = front.str;
// 如果隊首元素和目標一致，可以終止程式
if (basicString.compare(target) == 0) {
cout << front.level << endl;//輸出層次，也就是變化多少次到達了這個狀態
return 0;
}
// 把已經處理過的字串加入set中備查，避免往回翻的狀態重複加入
set1.insert(basicString);
// 模擬，依次翻轉後加入佇列中
for (int i = 0; i < n - 1; ++i) {
string buff;
buff.insert(0, basicString);
// 拷貝之後，翻轉i和i+1兩個位置的字元
if (buff[i] == '*')
buff[i] = 'o';
else
buff[i] = '*';
if (buff[i + 1] == 'o')
buff[i + 1] = '*';
else
buff[i + 1] = 'o';
// string s(buff);//字元陣列轉字串
if (set1.find(buff) == set1.end()) {
stateAndLevel obj = {buff, front.level + 1};
queue1.push(obj);
}
}
// cout << queue1.size() << endl;
}
// cout << src << "\n" << target << endl;
return 0;
}
題目標題：翻硬幣
小明正在玩一個“翻硬幣”的遊戲。
桌上放著排成一排的若干硬幣。我們用 * 表示正面，用 o 表示反面（是小寫字母，不是零）。
比如，可能情形是：**oo***oooo
如果同時翻轉左邊的兩個硬幣，則變為：oooo***oooo
現在小明的問題是：如果已知了初始狀態和要達到的目標狀態，每次只能同時翻轉相鄰的兩個硬幣,那麼對特定的局面，
最少要翻動多少次呢？
我們約定：把翻動相鄰的兩個硬幣叫做一步操作，那麼要求：程式輸入：
兩行等長的字串，分別表示初始狀態和要達到的目標狀態。每行的長度<1000程式輸出：
一個整數，表示最小操作步數例如：
使用者輸入：
**********
o****o****程式應該輸出：
5再例如：
使用者輸入：
*o**o***o***
*o***o**o***程式應該輸出：
1
資源約定：
峰值記憶體消耗 < 64M
CPU消耗 < 1000ms
請嚴格按要求輸出，不要畫蛇添足地列印類似：“請您輸入...” 的多餘內容。所有程式碼放在同一個原始檔中，除錯通過後，拷貝提交該原始碼。
注意: main函式需要返回0
注意: 只使用ANSI C/ANSI C++ 標準，不要呼叫依賴於編譯環境或作業系統的特殊函式。
注意: 所有依賴的函式必須明確地在原始檔中 #include <xxx>， 不能通過工程設定而省略常用標頭檔案。提交時，注意選擇所期望的編譯器型別。
*/
#include <iostream>
#include <queue>
#include <set>
using namespace std;
int main(int argc, const char *argv[]) {
string src;
string target;
getline(cin, src);
getline(cin, target);
int n = src.length();
int ans=0;
int start=-1;
for (int i = 0; i < n; ++i) {
if(src[i]!=target[i]){
if(start==-1)//還沒標記第一個位置
{
start=i;
}else//第一個位置已經標記,現在已經找到了第二個位置
{
ans+=(i-start);
start=-1;
}
}
}
cout<<ans<<endl;
return 0;
}
9、標題：帶分數
100 可以表示為帶分數的形式：100 = 3 + 69258 / 714
還可以表示為：100 = 82 + 3546 / 197
注意特徵：帶分數中，數字1~9分別出現且只出現一次（不包含0）。
類似這樣的帶分數，100 有 11 種表示法。
題目要求：
從標準輸入讀入一個正整數N (N<1000*1000)
程式輸出該數字用數碼1~9不重複不遺漏地組成帶分數表示的全部種數。
注意：不要求輸出每個表示，只統計有多少表示法！
例如：
使用者輸入：
100
程式輸出：
11再例如：
使用者輸入：
105
程式輸出：
6
資源約定：
峰值記憶體消耗 < 64M
CPU消耗 < 3000ms請嚴格按要求輸出，不要畫蛇添足地列印類似：“請您輸入...” 的多餘內容。
所有程式碼放在同一個原始檔中，除錯通過後，拷貝提交該原始碼。
注意: main函式需要返回0
注意: 只使用ANSI C/ANSI C++ 標準，不要呼叫依賴於編譯環境或作業系統的特殊函式。
注意: 所有依賴的函式必須明確地在原始檔中 #include <xxx>， 不能通過工程設定而省略常用標頭檔案。提交時，注意選擇所期望的編譯器型別。
//生成1~9這9個數字的全排列，先在可能的位置插入+，再在可能的位置插入/，驗算等式，計數
#include <iostream>
#include <cstdlib>
#include <algorithm>
#include <string>
using namespace std;
int parse(const char *arr, int pos, int len) {
int ans = 0;
int t = 1;
for (int i = pos + len - 1; i >= pos; --i) {
ans += (arr[i] - '0') * t;
t *= 10;
}
return ans;
}
int main(int argc, const char *argv[]) {
int n, ans = 0;
scanf("%d", &n);
std::string s = "123456789";
do {
const char *str = s.c_str();
for (int i = 1; i <= 7; ++i) {//+號前的串的長度
// string a = s.substr(0, i);
int inta = parse(str, 0, i);
if (inta >= n)break;
for (int j = 1; j <= 9 - i - 1; ++j) {//+/兩個符號之間的串的長度
// string b = s.substr(i, j);
// string c = s.substr(i + j);//這是/後面的串
// int intb = atoi(b.c_str());
// int intc = atoi(c.c_str());
int intb = parse(str, i, j);
int intc = parse(str, i + j, 9 - i - j);
if (intb % intc == 0 && inta + intb / intc == n)ans++;
}
}
} while (std::next_permutation(s.begin(), s.end()));
printf("%d\n", ans);
return 0;
}
10、標題：連號區間數
小明這些天一直在思考這樣一個奇怪而有趣的問題：
在1~N的某個全排列中有多少個連號區間呢？這裡所說的連號區間的定義是：
如果區間[L, R] 裡的所有元素（即此排列的第L個到第R個元素）遞增排序後能得到一個長度為R-L+1的“連續”數列，
則稱這個區間連號區間。當N很小的時候，小明可以很快地算出答案，但是當N變大的時候，問題就不是那麼簡單了，現在小明需要你的幫助。
輸入格式：
第一行是一個正整數N (1 <= N <= 50000), 表示全排列的規模。
第二行是N個不同的數字Pi(1 <= Pi <= N)， 表示這N個數字的某一全排列。輸出格式：
輸出一個整數，表示不同連號區間的數目。示例：
使用者輸入：
4
3 2 4 1程式應輸出：
7使用者輸入：
5
3 4 2 5 1程式應輸出：
9解釋：
第一個用例中，有7個連號區間分別是：[1,1], [1,2], [1,3], [1,4], [2,2], [3,3], [4,4]
第二個用例中，有9個連號區間分別是：[1,1], [1,2], [1,3], [1,4], [1,5], [2,2], [3,3], [4,4], [5,5]
資源約定：
峰值記憶體消耗 < 64M
CPU消耗 < 5000ms
請嚴格按要求輸出，不要畫蛇添足地列印類似：“請您輸入...” 的多餘內容。所有程式碼放在同一個原始檔中，除錯通過後，拷貝提交該原始碼。
注意: main函式需要返回0
注意: 只使用ANSI C/ANSI C++ 標準，不要呼叫依賴於編譯環境或作業系統的特殊函式。
注意: 所有依賴的函式必須明確地在原始檔中 #include <xxx>， 不能通過工程設定而省略常用標頭檔案。提交時，注意選擇所期望的編譯器型別。
#include <iostream>
using namespace std;
int n;
int arr[50000];
int ans;
int main(int argc, const char *argv[]) {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &arr[i]);
}
for (int j = 0; j <= n - 1; ++j) {
int min=arr[j];
int max = arr[j];
for (int i = j; i <= n - 1; ++i) {
if(arr[i]>max)
max=arr[i];
if(arr[i]<min)
min=arr[i];
if (i == j)
ans++;
else {
if(max-min+1==i-j+1)
ans++;//j-i形成連號區間
}
}
}
printf("%d\n",ans);
return 0;
}
來源：https://blog.csdn.net/qq_39825375/article/details/86617438
相關文章
- 藍橋杯真題
- 藍橋杯真題：純質數
- 藍橋杯省賽真題2013題解
- 藍橋杯真題之錯誤票據
- 藍橋杯2019年真題:字尾表示式
- [藍橋杯][2016年第七屆真題]冰雹數
- 藍橋杯-座次問題
- 藍橋杯-日期問題
- 藍橋杯
- [藍橋杯][2014年第五屆真題]地宮取寶
- [藍橋杯][2015年第六屆真題] 移動距離
- 藍橋杯全排列專題
- 題目 1841: [藍橋杯][2017年第八屆真題]發現環
- 2015年藍橋杯六屆省賽大學B組真題
- 2020藍橋杯省賽B組C++(第二場)真題C++
- 藍橋杯15年真題奇妙的數字暴力集合去重
- 藍橋杯例題-快速分揀
- 藍橋杯題目編號1265
- 藍橋杯 2014屆真題 地宮取寶 動態規劃解法動態規劃
- 藍橋杯模擬題——長草問題
- 【題解】爬山 藍橋杯2024省B
- 【藍橋杯】練習題目彙總
- 2013藍橋杯題解c++A組C++
- Java藍橋杯14年第五題Java
- 藍橋杯刷題-乘積尾零
- 藍橋杯 買瓜
- 藍橋杯-分巧克力
- 藍橋杯-N皇后
- 藍橋杯 剪格子
- 2013藍橋杯題解c組C++C++
- 藍橋杯練習系統題目集
- 藍橋杯-長草(BFS)
- 藍橋杯-螞蟻感冒
- 藍橋杯-帶分數
- 藍橋杯-翻硬幣
- 藍橋杯 計算方程
- 藍橋杯-排列序數
- 如何準備藍橋杯