第一題單位變換

題目

【問題描述】
在計算機存儲中，15.125GB是多少MB？

【答案提交】
這是一道結果填空的題，你只需要算出結果後提交即可。本題的結果爲一個整數，在提交答案時只填寫這個整數，填寫多餘的內容將無法得分。

思路

1G=1024M

答案

15488

第二題約數個數

題目

【問題描述】
1200000有多少個約數（只計算正約數）。

思路

枚舉+檢查

參考代碼

#include <iostream>

using namespace std;
const int N = 1200000;

int main() {
    int ans = 0;
    for (int i = 1; i <= N; ++i) {
        if (N % i == 0)
            ans++;
    }
    cout << ans << endl;
    return 0;
}

答案

第三題葉結點數

題目

【問題描述】
一棵包含有2019個結點的二叉樹，最多包含多少個葉結點？

思路

n=n0+n1+n2，爲使葉子節點數（n0）最多，必須n1最小，設爲0，而n0=n2+1

得n2=(2019-1)/2=1009

所以n0=1010

答案

1010

第四題數字9

題目

【問題描述】
在1至2019中，有多少個數的數位中包含數字9？
注意，有的數中的數位中包含多個9，這個數只算一次。例如，1999這個數包含數字9，在計算時只是算一個數。

思路

僞代碼

for i from 9  to 2019
	if str(i).contains('9')
		ans++

參考代碼

#include <iostream>

using namespace std;
const int N = 2019;

bool check(int i) {
    char s[5];
    sprintf(s, "%d", i);
    string str(s);
    return str.find('9') != string::npos;
}

int main() {
    int ans = 0;
    for (int i = 9; i <= N; ++i) {
        if (check(i)){
            ans++;
            cout<<ans<<":"<<i<<endl;
        }
    }
    cout << ans << endl;
    return 0;
}

答案

544

第五題數位遞增的數

題目

【問題描述】
一個正整數如果任何一個數位不大於右邊相鄰的數位，則稱爲一個數位遞增的數，例如1135是一個數位遞增的數，而1024不是一個數位遞增的數。
給定正整數 n，請問在整數 1 至 n 中有多少個數位遞增的數？

【輸入格式】
輸入的第一行包含一個整數 n。

【輸出格式】
輸出一行包含一個整數，表示答案。

【樣例輸入】
30

【樣例輸出】
26

【評測用例規模與約定】
對於 40% 的評測用例，1 <= n <= 1000。
對於 80% 的評測用例，1 <= n <= 100000。
對於所有評測用例，1 <= n <= 1000000。

思路 O(kN)

迭代1~n
	轉換爲字符串
	迭代字符串的每一位，判斷是否滿足要求

參考代碼

#include <iostream>
#include <cstring>

void work();

using namespace std;

int main() {
    while (1)//死循環爲測試用
        work();
    return 0;
}

void work() {
    int n;
    cin >> n;
    int ans = 0;
    for (int i = 1; i <= n; ++i) {
        char s[8];
        sprintf(s, "%d", i);
        bool flag = 1;
        for (int j = 1; j < strlen(s); ++j) {
            if (s[j - 1] > s[j]) {
                flag = 0;
                break;
            }
        }
        if (flag)
            ans++;
    }
    cout << ans << endl;
}

第六題遞增三元組

題目

【問題描述】
在數列 a[1], a[2], …, a[n] 中，如果對於下標 i, j, k 滿足 0<i<j<k<n+1 且 a[i]<a[j]<a[k]，則稱 a[i], a[j], a[k] 爲一組遞增三元組，a[j]爲遞增三元組的中心。
給定一個數列，請問數列中有多少個元素可能是遞增三元組的中心。

【輸入格式】
輸入的第一行包含一個整數 n。
第二行包含 n 個整數 a[1], a[2], …, a[n]，相鄰的整數間用空格分隔，表示給定的數列。

【輸出格式】
輸出一行包含一個整數，表示答案。

【樣例輸入】
5
1 2 5 3 5

【樣例輸出】
2

【樣例說明】
a[2] 和 a[4] 可能是三元組的中心。

【評測用例規模與約定】
對於 50% 的評測用例，2 <= n <= 100，0 <= 數列中的數 <= 1000。
對於所有評測用例，2 <= n <= 1000，0 <= 數列中的數 <= 10000。

思路 O(N^2)

枚舉每個元素
	該元素與前面的元素比較，找到小的即可
	該元素與後面的元素比較，找到大的即可
	上面兩項爲真，即說明當前元素可以作爲三元組的中心

O(N^2)，因爲N最大爲1000，所以1秒內可以解決戰鬥。

參考代碼

#include <iostream>

void work();

using namespace std;

int main() {
    while(1)//死循環爲測試用
        work();
    return 0;
}

void work() {
    int n, ans = 0;
    cin >> n;
    int *data = new int[n];
    for (int i = 0; i < n; ++i) {
        cin>>data[i];
    }
    for (int j = 1; j < n-1; ++j) {
        int hasSmall=0;
        for (int i = 0; i <j ; ++i) {
            if(data[i]<data[j]){
                hasSmall=1;
                break;
            }
        }
        int hasBig=0;
        for (int k = j+1; k < n; ++k) {
            if(data[j]<data[k]){
                hasBig = 1;
                break;
            }
        }
        if(hasSmall&&hasBig)
            ans++;
    }
    cout << ans << endl;
    delete[] data;
}

第七題音節判斷

題目

【問題描述】
小明對類似於 hello 這種單詞非常感興趣，這種單詞可以正好分爲四段，第一段由一個或多個輔音字母組成，第二段由一個或多個元音字母組成，第三段由一個或多個輔音字母組成，第四段由一個或多個元音字母組成。
給定一個單詞，請判斷這個單詞是否也是這種單詞，如果是請輸出yes，否則請輸出no。

元音字母包括 a, e, i, o, u，共五個，其他均爲輔音字母。

【輸入格式】
輸入一行，包含一個單詞，單詞中只包含小寫英文字母。

【輸出格式】
輸出答案，或者爲yes，或者爲no。

【樣例輸入】
lanqiao

【樣例輸出】
yes

【樣例輸入】
world

【樣例輸出】
no

【評測用例規模與約定】
對於所有評測用例，單詞中的字母個數不超過100。

思路

找到第一個元音的下標index1，必須大於0，且能找到
沿着index1繼續找下一個非元音得到index2，必須能找到
沿着index2繼續找下一個元音得到index3，必須能找到
最後判斷index3-1位置的字符應該是從後往前第一個非元音（因爲index3及以後的字符都必須是元音了）

參考代碼

#include <iostream>

int work();

using namespace std;

int main() {
    while (1) { //死循環是爲了測試
        if (work())
            cout << "yes" << endl;
        else
            cout << "no" << endl;
    }
    return 0;
}

int work() {
    string word;
    const string yuan = "aeiou";
    getline(cin, word);
    if (word.size() < 4)
        return 0;

    //第一個元音字符的pos
    int index1 = word.find_first_of(yuan, 0);
    if (index1 == 0 || index1 == string::npos) {
        return 0;
    }
    //之後第一個非元音
    int index2 = word.find_first_not_of(yuan, index1 + 1);
    if (index2 == word.size() - 1 || index2 == string::npos) {
        return 0;
    }
    //之後第一個元音
    int index3 = word.find_first_of(yuan, index2 + 1);
    if (index3 == string::npos) {
        return 0;
    }
    if (index3 - 1 != word.find_last_not_of(yuan)) {
        return 0;
    }
    return 1;
}

第八題長草問題

題目

【問題描述】
小明有一塊空地，他將這塊空地劃分爲 n 行 m 列的小塊，每行和每列的長度都爲 1。
小明選了其中的一些小塊空地，種上了草，其他小塊仍然保持是空地。
這些草長得很快，每個月，草都會向外長出一些，如果一個小塊種了草，則它將向自己的上、下、左、右四小塊空地擴展，這四小塊空地都將變爲有草的小塊。
請告訴小明，k 個月後空地上哪些地方有草。

【輸入格式】
輸入的第一行包含兩個整數 n, m。
接下來 n 行，每行包含 m 個字母，表示初始的空地狀態，字母之間沒有空格。如果爲小數點，表示爲空地，如果字母爲 g，表示種了草。
接下來包含一個整數 k。

【輸出格式】
輸出 n 行，每行包含 m 個字母，表示 k 個月後空地的狀態。如果爲小數點，表示爲空地，如果字母爲 g，表示長了草。

【樣例輸入】
4 5
.g…
…
…g…
…
2

【樣例輸出】
gggg.
gggg.
ggggg
.ggg.

【評測用例規模與約定】
對於 30% 的評測用例，2 <= n, m <= 20。
對於 70% 的評測用例，2 <= n, m <= 100。
對於所有評測用例，2 <= n, m <= 1000，1 <= k <= 1000。

思路 O(N*M)

典型的bfs，基本是個模板題。時間複雜度最多爲O(N*M)。

參考代碼

#include <iostream>
#include <queue>

#define loop(i, x, y) for(register int i = x;i <= y;i++)
using namespace std;

//草地上的一塊
struct block {
    int i;
    int j;
    int month;
};

const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
int vis[1000][1000]{};
int N, M, K;

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    //freopen("in", "r", stdin);
    //freopen("out", "w", stdout);
    int a = clock();
    cin >> N >> M;
    queue<block> q;
    char next_char;
    cin.get(next_char);
    while (next_char != '\n')cin.get(next_char);

    loop(i, 0, N - 1) {
        loop(j, 0, M - 1) {
            cin.get(next_char);
            if (next_char == 'g') {
                q.push({i, j, 0});
                vis[i][j] = 1;
            }
        }
        cin.get(next_char);
        while (next_char != '\n')cin.get(next_char);
    }
    cin >> K;

    while (!q.empty()) {
        block b = q.front();
        q.pop();
        int month = b.month;
        if (month < K) {
            loop(i, 0, 3) {
                int nx = b.i + dx[i];
                int ny = b.j + dy[i];
                if (0 <= nx && nx < N && 0 <= ny && ny < M && vis[nx][ny] == 0) {
                    vis[nx][ny] = 1;
                    q.push({nx, ny, month + 1});
                }
            }
        }
    }
    loop(i, 0, N - 1) {
        loop(j, 0, M - 1) {
            if (vis[i][j] == 1) cout << 'g';
            else cout << '.';
        }
        cout << endl;
    }
    clog << clock() - a << endl;
    return 0;
}

第九題序列計數題目

題目

【問題描述】
小明想知道，滿足以下條件的正整數序列的數量：

第一項爲 n；
第二項不超過 n；
從第三項開始，每一項小於前兩項的差的絕對值。
請計算，對於給定的 n，有多少種滿足條件的序列。

【輸入格式】
輸入一行包含一個整數 n。

【輸出格式】
輸出一個整數，表示答案。答案可能很大，請輸出答案除以10000的餘數。

【樣例輸入】
4

【樣例輸出】
7

【樣例說明】
以下是滿足條件的序列：
4 1
4 1 1
4 1 2
4 2
4 2 1
4 3
4 4

【評測用例規模與約定】
對於 20% 的評測用例，1 <= n <= 5；
對於 50% 的評測用例，1 <= n <= 10；
對於 80% 的評測用例，1 <= n <= 100；
對於所有評測用例，1 <= n <= 1000。

思路：記憶型遞歸 O(N^3)

題幹第三點，是一個遞歸定義，可以得到遞歸式：

f(pre,cur) = f(cur,1) + f(cur,2) + ... +f(cur,abs(pre-cur)-1) + 1
pre表示前一個數，cur代表當前的數，
選定之後，序列種數等於以cur爲前序，以1到abs-1爲當前的序列數的總和再加1.
如f(5,2) = f(2,1)+f(2,2).

但是暴力遞歸的複雜度是指數級，輸入1000時，實測運行時間爲1000~2000ms；
基本的優化方案是加狀態記憶：

參考代碼

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <ctime>

#define _for(i, x, y) for(register int i = x;i <= y;i++)
#define _fordw(i, x, y) for(register int i = x;i >= y;i--)
typedef long long LL;
using namespace std;

int N;
LL ans;
const int MOD = 10000;
int mem[1001][1000];

LL dfs(int pre, int cur) {
    // 詢問狀態
    if (mem[pre][cur] != 0)
        return mem[pre][cur];
    LL ans = 1;
    _for(j, 1,abs(pre-cur) - 1) {
        ans = (ans + dfs(cur, j)) % MOD;
    }
    //記錄狀態
    mem[pre][cur] = ans;
    return ans;
}

void work() {
    ans = 0;
    cin >> N;
//    f(pre,cur) = sum(f(cur,_new))|_new from 1 to abs(pre-cur)-1
    _for(x, 1, N) ans = (ans + dfs(N, x)) % MOD;
    cout << ans << endl;
}

進一步優化

至此，能通過80%的數據（在1000ms限制下）；

解空間是N的平方（詳細爲N*N）表格，但是每次都要循環加總，所以成了N的立方，在同樣的解空間下，避免循環加總，即可優化到N的平方

重新考慮狀態的轉移：

如果我們用f(i,j)表示前一個數是i，當前數是1到j的合法序列的個數；有f(i,j) = 1 + f(i,j-1) + f(j,abs(i-j)-1)即分爲兩個部分1）i作爲前一個數，從1j-1爲當前數的合法序列的個數已經計算好，2）求以j爲尾數，後面選擇1abs(i-j)-1的合法序列的個數。

如 f(10,5)=f(10,4)+f(5,4);而不是枚舉1到5；這樣每次解答樹只展開兩個節點，相當於減少一層循環，雖然解答樹的層次還是很深，但是由於記憶的存在，解空間仍然是N的平方。可在100ms內解決。

參考代碼

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <ctime>

typedef long long LL;
using namespace std;

int N;
const int MOD = 10000;
int mem[1001][1000];

int dfs(int pre, int cur) {
    if (cur <= 0) return 0;
    if (mem[pre][cur] != 0) return mem[pre][cur];
    return mem[pre][cur] = (1 + dfs(pre, cur - 1) + dfs(cur, abs(pre - cur) - 1)) % MOD;
}

void work() {
    cin >> N;
    cout << dfs(N, N) << endl;
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int a = clock();
    work();
    int b = clock();
    clog << (b - a) << endl;
    return 0;
}

第十題晚會節目單

題目

【問題描述】
小明要組織一臺晚會，總共準備了 n 個節目。然後晚會的時間有限，他只能最終選擇其中的 m 個節目。
這 n 個節目是按照小明設想的順序給定的，順序不能改變。
小明發現，觀衆對於晚會的喜歡程度與前幾個節目的好看程度有非常大的關係，他希望選出的第一個節目儘可能好看，在此前提下希望第二個節目儘可能好看，依次類推。
小明給每個節目定義了一個好看值，請你幫助小明選擇出 m 個節目，滿足他的要求。

【輸入格式】
輸入的第一行包含兩個整數 n, m ，表示節目的數量和要選擇的數量。
第二行包含 n 個整數，依次爲每個節目的好看值。

【輸出格式】
輸出一行包含 m 個整數，爲選出的節目的好看值。

【樣例輸入】
5 3
3 1 2 5 4

【樣例輸出】
3 5 4

【樣例說明】
選擇了第1, 4, 5個節目。

【評測用例規模與約定】
對於 30% 的評測用例，1 <= n <= 20；
對於 60% 的評測用例，1 <= n <= 100；
對於所有評測用例，1 <= n <= 100000，0 <= 節目的好看值 <= 100000。

錯誤思路

如果用兩次排序求解，那就錯了。因爲並不是要選出的方案的好看值總和最大，而是要從前往後儘量好看。

思路 O(N^2)

此題關鍵在於“第一個節目儘可能好看”並希望“第二個節目儘可能好看”……那麼我們選擇的第一節目就是max(g[0]~g[n-m])閉區間，要選擇的第二個節目是max(g[lastMax+1],g[n-m+1])及從上一個節目往下到n-m+1這個區間裏面選最好看的，直到剩下的必須全部選擇。

算法用尺取法，雙指針移動。理論上的複雜度是O(M*(N-M))，極端情況是M=N/2，整體達到(N^2)/2。如果輸入數據爲：

100000 50000
100000 99999 ...

實測運行時間爲：10秒以上

參考代碼

int N, M;
void work() {
    cin >> N >> M;
    vector<int> games(N);
    for (int i = 0; i < N; i++) {
        cin >> games[i];
    }
    int pos_max = 0, pos_1 = 0, pos_2 = N - M;
    while (pos_1 < pos_2 && pos_2 < N) {
        while (pos_1 < pos_2)
            if (games[++pos_1] > games[pos_max])pos_max = pos_1;
        cout << games[pos_max] << " ";
        pos_1 = pos_max + 1;
        pos_2++;
        pos_max = pos_1;
    }
    while (pos_2 != N) {
        cout << games[pos_2++] << " ";
    }
    cout << endl;
}

優化：區間最值查詢 O(NlogN)

while (pos_1 < pos_2)
	if (games[++pos_1] > games[pos_max])pos_max = pos_1;

這一段代碼是區間內查詢最大值，反覆多次，且數據是靜態的，所以選擇ST做RMQ。

f[i][j]表示以 i 爲起點，連續 2^j 個數中的最大值（的下標）；

轉移方程就是：f[i][j] = data[f[i][j-1]] >= data[f[i+pow_2(j-1)][j-1]]?f[i][j-1]:f[i+pow_2(j-1)][j-1];

注：比較原始數據，記錄下標

由於預處理是O(nlogn)，M次查詢是O(M)，每次查詢是O(1)，所以整體複雜度爲O(nlogn)。

下列代碼實測運行時間100ms以內

參考代碼

#include <iostream>
#include <vector>

using namespace std;
int N, M;
vector<int> data;
/*===st rmq的數據 begin===*/
const int MAX_N = 100005;
const int MAX_POW = 20;
int f[MAX_N][MAX_POW], Log[MAX_N];
/*===st rmq的數據 end===*/

/*===st rmq的函數 begin===*/
void initLog() {
    Log[1] = 0;//2的0次方爲1，log2_1 = 0;
    for (int i = 2; i <= N; ++i) {
        Log[i] = Log[i / 2] +1;
    }
}
//2的p次方
int pow_2(int p) {
    return 1 << p;
}

void initSt() {
    int i, j;
    for (i = 0; i < N; ++i) {
        f[i][0] = i;//注意這裏存的是下標，而不是值
    }

    for (j = 1; pow_2(j) < N; ++j) {
        for (i = 0; i + pow_2(j-1) < N; ++i) {
            int index1 = f[i][j - 1];
            int index2 = f[i + pow_2(j - 1)][j - 1];
            f[i][j] = data[index1] > data[index2] ? index1 : index2;
        }
    }
}

int query(int l,int r){
    int len = r-l+1;
    int k = Log[len];
    int index1 = f[l][k];
    int index2 = f[r - pow_2(k) + 1][k];
    return data[index1] > data[index2] ? index1 : index2;
}
/*===st rmq的函數 end===*/

void work() {
    std::ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin >> N >> M;
    data = vector<int>(N);
    for (int i = 0; i < N; i++) {
        cin >> data[i];
    }
    /*===初始化st rmq相關數據===*/
    initLog();
    initSt();

    int pos_max = 0, pos_1 = 0, pos_2 = N - M;
    while (pos_1 < pos_2 && pos_2 < N) {
/*        while (pos_1 < pos_2)
            if (data[++pos_1] > data[pos_max])pos_max = pos_1;*/
        pos_max = query(pos_1,pos_2);
        cout << data[pos_max] << " ";
        pos_1 = pos_max + 1;
        pos_2++;
        //pos_max = pos_1;
    }
    while (pos_2 != N) {
        cout << data[pos_2++] << " ";
    }
    cout << endl;
}

int main() {
/* 造數據
    freopen("E:\\data\\my10_1.in", "w", stdout);
    cout<<100000<<" "<<50000<<endl;
    for (int i = 0; i < 100000; ++i) {
        cout<<100000-i<<" ";
    }
    cout<<endl;*/
    freopen("E:\\data\\my10_1.in", "r", stdin);
    int a = clock();
    work();
    int b = clock();
    clog << (b - a) << endl;
    return 0;
}

2020年藍橋杯模擬賽解題報告（CPP版本）——轉載自官方解析

文章目錄

第一題 單位變換

題目

思路

答案

第二題 約數個數

題目

思路

參考代碼

答案

第三題 葉結點數

題目

思路

答案

第四題 數字9

題目

思路

參考代碼

答案

第五題 數位遞增的數

題目

思路 O(kN)

參考代碼

第六題 遞增三元組

題目

思路 O(N^2)

參考代碼

第七題 音節判斷

題目

思路

參考代碼

第八題 長草問題

題目

思路 O(N*M)

參考代碼

第九題 序列計數題目

題目

思路：記憶型遞歸 O(N^3)

參考代碼

進一步優化

參考代碼

第十題 晚會節目單

題目

錯誤思路

思路 O(N^2)

參考代碼

優化：區間最值查詢 O(NlogN)

參考代碼

第一題單位變換

第二題約數個數

第三題葉結點數

第四題數字9

第五題數位遞增的數

第六題遞增三元組

第七題音節判斷

第八題長草問題

第九題序列計數題目

第十題晚會節目單