第1題

以下哪種功能沒有涉及 C++語言的面向?qū)ο筇匦灾С郑?）。

第2題

有 6 個元素，按照 6、5、4、3、2、1 的順序進(jìn)入棧 S，請問下列哪個出棧序列是非法的（ ）。

第3題

運(yùn)行以下代碼片段的行為是（ ）。

int x = 101;
int y = 201;
int *p = &x;
int *q = &y;
p = q;

第4題

鏈表和數(shù)組的區(qū)別包括（ ）。

第5題

對假設(shè)棧 S 和隊列 Q 的初始狀態(tài)為空。存在 e1~e6 六個互不相同的數(shù)據(jù)，每個數(shù)據(jù)按照進(jìn)棧 S、出棧 S、進(jìn)隊列 Q、出隊列 Q 的順序操作，不同數(shù)據(jù)間的操作可能會交錯。已知棧 S 中依次有數(shù)據(jù) e1、e2、e3、e4、e5 和 e6 進(jìn)棧，隊列 Q 依次有數(shù)據(jù) e2、e4、e3、 e6、e5 和 e1 出隊列。則棧 S 的容量至少是（ ）個數(shù)據(jù)。

第6題

對表達(dá)式 a+(b-c)*d 的前綴表達(dá)式為（ ），其中+、-、*是運(yùn)算符。

第7題

假設(shè)字母表 {a, b, c, d, e} 在字符串出現(xiàn)的頻率分別為 10%, 15%, 30%, 16%, 29%。若使用哈夫曼編碼方式對字母進(jìn)行不定長的二進(jìn)制編碼，字母 d 的編碼長度為 （ ）位。

第8題

一棵有 n 個結(jié)點的完全二叉樹用數(shù)組進(jìn)行存儲與表示，已知根結(jié)點存儲在數(shù)組的第 1 個位置。若存儲在數(shù)組第 9 個位置的結(jié)點存在兄弟結(jié)點和兩個子結(jié)點，則它的兄弟結(jié)點和右子結(jié)點的位置分別是（ ）。

第9題

考慮由 N 個頂點構(gòu)成的有向連通圖，采用鄰接矩陣的數(shù)據(jù)結(jié)構(gòu)表示時，該矩陣中至少存在 （ ）個非零元素。

第10題

以下對數(shù)據(jù)結(jié)構(gòu)的表述不恰當(dāng)?shù)囊豁棡椋?）。

第11題

以下哪組操作能完成在雙向循環(huán)鏈表結(jié)點 p 之后插入結(jié)點 s 的效果（其中，next 域為結(jié)點的直接后繼，prev 域為結(jié)點的直接前驅(qū)）（ ）。

第12題

以下排序算法的常見實現(xiàn)中，哪個選項的說法是錯誤的（ ）。

第13題

八進(jìn)制數(shù) 32.1 對應(yīng)的十進(jìn)制數(shù)是（ ）。

第14題

一個字符串中任意個連續(xù)的字符組成的子序列稱為該字符串的子串，則字符串 abcab 有 （ ）個內(nèi)容互不相同的子串。

第15題

以下對遞歸方法的描述中，正確的是（ ）。

第16題

#include<iostream>
using namespace std;
int main()
{
    unsigned short x, y;
    cin >> x >> y;
    x = (x | x << 2) & 0x33;
    x = (x | x << 1) & 0x55;
    y = (y | y << 2) & 0x33;
    y = (y | y << 1) & 0x55;
    unsigned short z = x | y << 1;
    cout << z << endl;
    return 0;
}

假設(shè)輸入的 x、y 均是不超過 15 的自然數(shù)，刪去第 7 行與第 13 行的 unsigned，程序行為不變。

第17題

#include<iostream>
using namespace std;
int main()
{
    unsigned short x, y;
    cin >> x >> y;
    x = (x | x << 2) & 0x33;
    x = (x | x << 1) & 0x55;
    y = (y | y << 2) & 0x33;
    y = (y | y << 1) & 0x55;
    unsigned short z = x | y << 1;
    cout << z << endl;
    return 0;
}

假設(shè)輸入的 x、y 均是不超過 15 的自然數(shù)，將第 7 行與第 13 行的 short 均改為 char，程序行為不變。

第18題

#include<iostream>
using namespace std;
int main()
{
    unsigned short x, y;
    cin >> x >> y;
    x = (x | x << 2) & 0x33;
    x = (x | x << 1) & 0x55;
    y = (y | y << 2) & 0x33;
    y = (y | y << 1) & 0x55;
    unsigned short z = x | y << 1;
    cout << z << endl;
    return 0;
}

假設(shè)輸入的 x、y 均是不超過 15 的自然數(shù)，程序總是輸出一個整數(shù)“0”。

第19題

#include<iostream>
using namespace std;
int main()
{
    unsigned short x, y;
    cin >> x >> y;
    x = (x | x << 2) & 0x33;
    x = (x | x << 1) & 0x55;
    y = (y | y << 2) & 0x33;
    y = (y | y << 1) & 0x55;
    unsigned short z = x | y << 1;
    cout << z << endl;
    return 0;
}

假設(shè)輸入的 x、y 均是不超過 15 的自然數(shù)，當(dāng)輸入為“2 2”時，輸出為“10”。

第20題

#include<iostream>
using namespace std;
int main()
{
    unsigned short x, y;
    cin >> x >> y;
    x = (x | x << 2) & 0x33;
    x = (x | x << 1) & 0x55;
    y = (y | y << 2) & 0x33;
    y = (y | y << 1) & 0x55;
    unsigned short z = x | y << 1;
    cout << z << endl;
    return 0;
}

假設(shè)輸入的 x、y 均是不超過 15 的自然數(shù)，當(dāng)輸入為“2 2”時，輸出為“59”。

第21題

#include<iostream>
using namespace std;
int main()
{
    unsigned short x, y;
    cin >> x >> y;
    x = (x | x << 2) & 0x33;
    x = (x | x << 1) & 0x55;
    y = (y | y << 2) & 0x33;
    y = (y | y << 1) & 0x55;
    unsigned short z = x | y << 1;
    cout << z << endl;
    return 0;
}

假設(shè)輸入的 x、y 均是不超過 15 的自然數(shù)，當(dāng)輸入為“13 8”時，輸出為（ ）。

第22題

#include<algorithm>
#include<iostream>
#include<limits>
using namespace std;
const int MAXN = 105;
const int MAXK = 105;
int h[MAXN][MAXK];
int f(int n, int m)
{
    if (m == 1) return n;
    if (n == 0) return 0;
    int ret = numeric_limits::max();
    for (int i = 1; i <= n; i++)
        ret = min(ret, max(f(n - i, m), f(i - 1, m - 1)) + 1);
    return ret;
}
int g(int n, int m)
{
    for (int i = 1; i <= n; i++)
        h[i][1] = i;
    for (int j = 1; j <= m; j++)
        h[0][j] = 0;
    for (int i = 1; i <= n; i++) {
        for (int j = 2; j <= m; j++) {
            h[i][j] = numeric_limits::max();
            for (int k = 1; k <= i; k++)
            h[i][j] = min(h[i][j],max(h[i - k][j], h[k - 1][j - 1]) + 1);
        }
    }
    return h[n][m];
}
int main()
{
    int n, m;
    cin >> n >> m;
    cout << f(n, m) << endl << g(n, m) << endl;
    return 0;
}

假設(shè)輸入的 n、m 均是不超過 100 的正整數(shù)，當(dāng)輸入為“7 3”時，第 19 行用來取最小值的 min 函數(shù)執(zhí)行了 449 次。

第23題

#include<algorithm>
#include<iostream>
#include<limits>
using namespace std;
const int MAXN = 105;
const int MAXK = 105;
int h[MAXN][MAXK];
int f(int n, int m)
{
    if (m == 1) return n;
    if (n == 0) return 0;
    int ret = numeric_limits::max();
    for (int i = 1; i <= n; i++)
        ret = min(ret, max(f(n - i, m), f(i - 1, m - 1)) + 1);
    return ret;
}
int g(int n, int m)
{
    for (int i = 1; i <= n; i++)
        h[i][1] = i;
    for (int j = 1; j <= m; j++)
        h[0][j] = 0;
    for (int i = 1; i <= n; i++) {
        for (int j = 2; j <= m; j++) {
            h[i][j] = numeric_limits::max();
            for (int k = 1; k <= i; k++)
            h[i][j] = min(h[i][j],max(h[i - k][j], h[k - 1][j - 1]) + 1);
        }
    }
    return h[n][m];
}
int main()
{
    int n, m;
    cin >> n >> m;
    cout << f(n, m) << endl << g(n, m) << endl;
    return 0;
}

假設(shè)輸入的 n、m 均是不超過 100 的正整數(shù)，輸出的兩行整數(shù)總是相同的。

第24題

#include<algorithm>
#include<iostream>
#include<limits>
using namespace std;
const int MAXN = 105;
const int MAXK = 105;
int h[MAXN][MAXK];
int f(int n, int m)
{
    if (m == 1) return n;
    if (n == 0) return 0;
    int ret = numeric_limits::max();
    for (int i = 1; i <= n; i++)
        ret = min(ret, max(f(n - i, m), f(i - 1, m - 1)) + 1);
    return ret;
}
int g(int n, int m)
{
    for (int i = 1; i <= n; i++)
        h[i][1] = i;
    for (int j = 1; j <= m; j++)
        h[0][j] = 0;
    for (int i = 1; i <= n; i++) {
        for (int j = 2; j <= m; j++) {
            h[i][j] = numeric_limits::max();
            for (int k = 1; k <= i; k++)
            h[i][j] = min(h[i][j],max(h[i - k][j], h[k - 1][j - 1]) + 1);
        }
    }
    return h[n][m];
}
int main()
{
    int n, m;
    cin >> n >> m;
    cout << f(n, m) << endl << g(n, m) << endl;
    return 0;
}

假設(shè)輸入的 n、m 均是不超過 100 的正整數(shù)，當(dāng) m 為 1 時，輸出的第一行總為 n。

第25題

#include<algorithm>
#include<iostream>
#include<limits>
using namespace std;
const int MAXN = 105;
const int MAXK = 105;
int h[MAXN][MAXK];
int f(int n, int m)
{
    if (m == 1) return n;
    if (n == 0) return 0;
    int ret = numeric_limits::max();
    for (int i = 1; i <= n; i++)
        ret = min(ret, max(f(n - i, m), f(i - 1, m - 1)) + 1);
    return ret;
}
int g(int n, int m)
{
    for (int i = 1; i <= n; i++)
        h[i][1] = i;
    for (int j = 1; j <= m; j++)
        h[0][j] = 0;
    for (int i = 1; i <= n; i++) {
        for (int j = 2; j <= m; j++) {
            h[i][j] = numeric_limits::max();
            for (int k = 1; k <= i; k++)
            h[i][j] = min(h[i][j],max(h[i - k][j], h[k - 1][j - 1]) + 1);
        }
    }
    return h[n][m];
}
int main()
{
    int n, m;
    cin >> n >> m;
    cout << f(n, m) << endl << g(n, m) << endl;
    return 0;
}

假設(shè)輸入的 n、m 均是不超過 100 的正整數(shù)，算法 g(n,m)最為準(zhǔn)確的時間復(fù)雜度分析結(jié)果為（ ）。

第26題

#include<algorithm>
#include<iostream>
#include<limits>
using namespace std;
const int MAXN = 105;
const int MAXK = 105;
int h[MAXN][MAXK];
int f(int n, int m)
{
    if (m == 1) return n;
    if (n == 0) return 0;
    int ret = numeric_limits::max();
    for (int i = 1; i <= n; i++)
        ret = min(ret, max(f(n - i, m), f(i - 1, m - 1)) + 1);
    return ret;
}
int g(int n, int m)
{
    for (int i = 1; i <= n; i++)
        h[i][1] = i;
    for (int j = 1; j <= m; j++)
        h[0][j] = 0;
    for (int i = 1; i <= n; i++) {
        for (int j = 2; j <= m; j++) {
            h[i][j] = numeric_limits::max();
            for (int k = 1; k <= i; k++)
            h[i][j] = min(h[i][j],max(h[i - k][j], h[k - 1][j - 1]) + 1);
        }
    }
    return h[n][m];
}
int main()
{
    int n, m;
    cin >> n >> m;
    cout << f(n, m) << endl << g(n, m) << endl;
    return 0;
}

假設(shè)輸入的 n、m 均是不超過 100 的正整數(shù)，當(dāng)輸入為“20 2”時，輸出的第一行為（ ）。

第27題

#include<algorithm>
#include<iostream>
#include<limits>
using namespace std;
const int MAXN = 105;
const int MAXK = 105;
int h[MAXN][MAXK];
int f(int n, int m)
{
    if (m == 1) return n;
    if (n == 0) return 0;
    int ret = numeric_limits::max();
    for (int i = 1; i <= n; i++)
        ret = min(ret, max(f(n - i, m), f(i - 1, m - 1)) + 1);
    return ret;
}
int g(int n, int m)
{
    for (int i = 1; i <= n; i++)
        h[i][1] = i;
    for (int j = 1; j <= m; j++)
        h[0][j] = 0;
    for (int i = 1; i <= n; i++) {
        for (int j = 2; j <= m; j++) {
            h[i][j] = numeric_limits::max();
            for (int k = 1; k <= i; k++)
            h[i][j] = min(h[i][j],max(h[i - k][j], h[k - 1][j - 1]) + 1);
        }
    }
    return h[n][m];
}
int main()
{
    int n, m;
    cin >> n >> m;
    cout << f(n, m) << endl << g(n, m) << endl;
    return 0;
}

假設(shè)輸入的 n、m 均是不超過 100 的正整數(shù)，當(dāng)輸入為“100 100”時，輸出的第一行為（ ）。

第28題

#include<iostream>
using namespace std;
int n, k;
int solve1()
{
    int l = 0, r = n;
    while (l <= r) {
        int mid = (l + r) / 2;
        if (mid * mid <= n) l = mid + 1;
        else r = mid - 1;
    }
    return l - 1;
}
double solve2(double x)
{
    if (x == 0) return x;
    for (int i = 0; i < k; i++)
        x = (x + n / x) / 2;
    return x;
}
int main() 
{
    cin >> n >> k;
    double ans = solve2(solve1());
    cout << ans << ' ' << (ans * ans == n) << endl;
    return 0;
}

假設(shè) int 為 32 位有符號整數(shù)類型，輸入的 n 是不超過 47000 的自然數(shù)、k 是不超過 int 表示范圍的自然數(shù)，該算法最準(zhǔn)確的時間復(fù)雜度分析結(jié)果為?(log? + ?)。

第29題

#include<iostream>
using namespace std;
int n, k;
int solve1()
{
    int l = 0, r = n;
    while (l <= r) {
        int mid = (l + r) / 2;
        if (mid * mid <= n) l = mid + 1;
        else r = mid - 1;
    }
    return l - 1;
}
double solve2(double x)
{
    if (x == 0) return x;
    for (int i = 0; i < k; i++)
        x = (x + n / x) / 2;
    return x;
}
int main() 
{
    cin >> n >> k;
    double ans = solve2(solve1());
    cout << ans << ' ' << (ans * ans == n) << endl;
    return 0;
}

假設(shè) int 為 32 位有符號整數(shù)類型，輸入的 n 是不超過 47000 的自然數(shù)、k 是不超過 int 表示范圍的自然數(shù)，當(dāng)輸入為“9801 1”時，輸出的第一個數(shù)為“99”。

第30題

#include<iostream>
using namespace std;
int n, k;
int solve1()
{
    int l = 0, r = n;
    while (l <= r) {
        int mid = (l + r) / 2;
        if (mid * mid <= n) l = mid + 1;
        else r = mid - 1;
    }
    return l - 1;
}
double solve2(double x)
{
    if (x == 0) return x;
    for (int i = 0; i < k; i++)
        x = (x + n / x) / 2;
    return x;
}
int main() 
{
    cin >> n >> k;
    double ans = solve2(solve1());
    cout << ans << ' ' << (ans * ans == n) << endl;
    return 0;
}

假設(shè) int 為 32 位有符號整數(shù)類型，輸入的 n 是不超過 47000 的自然數(shù)、k 是不超過 int 表示范圍的自然數(shù)，對于任意輸入的 n，隨著所輸入 k 的增大，輸出的第二個數(shù)會變成“1”。

第31題

#include<iostream>
using namespace std;
int n, k;
int solve1()
{
    int l = 0, r = n;
    while (l <= r) {
        int mid = (l + r) / 2;
        if (mid * mid <= n) l = mid + 1;
        else r = mid - 1;
    }
    return l - 1;
}
double solve2(double x)
{
    if (x == 0) return x;
    for (int i = 0; i < k; i++)
        x = (x + n / x) / 2;
    return x;
}
int main() 
{
    cin >> n >> k;
    double ans = solve2(solve1());
    cout << ans << ' ' << (ans * ans == n) << endl;
    return 0;
}

假設(shè) int 為 32 位有符號整數(shù)類型，輸入的 n 是不超過 47000 的自然數(shù)、k 是不超過 int 表示范圍的自然數(shù)，該程序有存在缺陷。當(dāng)輸入的 n 過大時，第 12 行的乘法有可能溢出，因此應(yīng)當(dāng)將 mid 強(qiáng)制轉(zhuǎn)換為 64 位整數(shù)再計算。

第32題

#include<iostream>
using namespace std;
int n, k;
int solve1()
{
    int l = 0, r = n;
    while (l <= r) {
        int mid = (l + r) / 2;
        if (mid * mid <= n) l = mid + 1;
        else r = mid - 1;
    }
    return l - 1;
}
double solve2(double x)
{
    if (x == 0) return x;
    for (int i = 0; i < k; i++)
        x = (x + n / x) / 2;
    return x;
}
int main() 
{
    cin >> n >> k;
    double ans = solve2(solve1());
    cout << ans << ' ' << (ans * ans == n) << endl;
    return 0;
}

假設(shè) int 為 32 位有符號整數(shù)類型，輸入的 n 是不超過 47000 的自然數(shù)、k 是不超過 int 表示范圍的自然數(shù)，當(dāng)輸入為“2 1”時，輸出的第一個數(shù)最接近（ ）。

第33題

#include<iostream>
using namespace std;
int n, k;
int solve1()
{
    int l = 0, r = n;
    while (l <= r) {
        int mid = (l + r) / 2;
        if (mid * mid <= n) l = mid + 1;
        else r = mid - 1;
    }
    return l - 1;
}
double solve2(double x)
{
    if (x == 0) return x;
    for (int i = 0; i < k; i++)
        x = (x + n / x) / 2;
    return x;
}
int main() 
{
    cin >> n >> k;
    double ans = solve2(solve1());
    cout << ans << ' ' << (ans * ans == n) << endl;
    return 0;
}

假設(shè) int 為 32 位有符號整數(shù)類型，輸入的 n 是不超過 47000 的自然數(shù)、k 是不超過 int 表示范圍的自然數(shù)，當(dāng)輸入為“3 10”時，輸出的第一個數(shù)最接近（ ）。

第34題

#include<iostream>
using namespace std;
int n, k;
int solve1()
{
    int l = 0, r = n;
    while (l <= r) {
        int mid = (l + r) / 2;
        if (mid * mid <= n) l = mid + 1;
        else r = mid - 1;
    }
    return l - 1;
}
double solve2(double x)
{
    if (x == 0) return x;
    for (int i = 0; i < k; i++)
        x = (x + n / x) / 2;
    return x;
}
int main() 
{
    cin >> n >> k;
    double ans = solve2(solve1());
    cout << ans << ' ' << (ans * ans == n) << endl;
    return 0;
}

假設(shè) int 為 32 位有符號整數(shù)類型，輸入的 n 是不超過 47000 的自然數(shù)、k 是不超過 int 表示范圍的自然數(shù)，當(dāng)輸入為“256 11”時，輸出的第一個數(shù)（ ）。

第35題

（枚舉因數(shù)）從小到大打印正整數(shù) n 的所有正因數(shù)，試補(bǔ)全枚舉程序。

#include<bits/stdc++.h>
using namespace std;
int main() {
    int n;
    cin >> n;
    vectorfac;
    fac.reserve((int)ceil(sqrt(n)));
    int i;
    for (i = 1; i * i < n; ++i) {
        if (①) {
            fac.push_back(i);
        }
    }
    for (int k = 0; k < fac.size(); ++k) {
        cout << ② << " ";
    }
    if (③) {
        cout << ④ << " ";
    }
    for (int k = fac.size() - 1; k >= 0; --k) {
        cout << ⑤ << " ";
    }
}

①處應(yīng)填（ ）。

第36題

（枚舉因數(shù)）從小到大打印正整數(shù) n 的所有正因數(shù)，試補(bǔ)全枚舉程序。

#include<bits/stdc++.h>
using namespace std;
int main() {
    int n;
    cin >> n;
    vectorfac;
    fac.reserve((int)ceil(sqrt(n)));
    int i;
    for (i = 1; i * i < n; ++i) {
        if (①) {
            fac.push_back(i);
        }
    }
    for (int k = 0; k < fac.size(); ++k) {
        cout << ② << " ";
    }
    if (③) {
        cout << ④ << " ";
    }
    for (int k = fac.size() - 1; k >= 0; --k) {
        cout << ⑤ << " ";
    }
}

②處應(yīng)填（ ）。

第37題

（枚舉因數(shù)）從小到大打印正整數(shù) n 的所有正因數(shù)，試補(bǔ)全枚舉程序。

#include<bits/stdc++.h>
using namespace std;
int main() {
    int n;
    cin >> n;
    vectorfac;
    fac.reserve((int)ceil(sqrt(n)));
    int i;
    for (i = 1; i * i < n; ++i) {
        if (①) {
            fac.push_back(i);
        }
    }
    for (int k = 0; k < fac.size(); ++k) {
        cout << ② << " ";
    }
    if (③) {
        cout << ④ << " ";
    }
    for (int k = fac.size() - 1; k >= 0; --k) {
        cout << ⑤ << " ";
    }
}

③處應(yīng)填（ ）。

第38題

（枚舉因數(shù)）從小到大打印正整數(shù) n 的所有正因數(shù)，試補(bǔ)全枚舉程序。

#include<bits/stdc++.h>
using namespace std;
int main() {
    int n;
    cin >> n;
    vectorfac;
    fac.reserve((int)ceil(sqrt(n)));
    int i;
    for (i = 1; i * i < n; ++i) {
        if (①) {
            fac.push_back(i);
        }
    }
    for (int k = 0; k < fac.size(); ++k) {
        cout << ② << " ";
    }
    if (③) {
        cout << ④ << " ";
    }
    for (int k = fac.size() - 1; k >= 0; --k) {
        cout << ⑤ << " ";
    }
}

④處應(yīng)填（ ）。

第39題

（枚舉因數(shù)）從小到大打印正整數(shù) n 的所有正因數(shù)，試補(bǔ)全枚舉程序。

#include<bits/stdc++.h>
using namespace std;
int main() {
    int n;
    cin >> n;
    vectorfac;
    fac.reserve((int)ceil(sqrt(n)));
    int i;
    for (i = 1; i * i < n; ++i) {
        if (①) {
            fac.push_back(i);
        }
    }
    for (int k = 0; k < fac.size(); ++k) {
        cout << ② << " ";
    }
    if (③) {
        cout << ④ << " ";
    }
    for (int k = fac.size() - 1; k >= 0; --k) {
        cout << ⑤ << " ";
    }
}

⑤處應(yīng)填（ ）。

第40題

（洪水填充）現(xiàn)有用字符標(biāo)記像素顏色的 8x8 圖像。顏色填充的操作描述如下：給定起始像素的位置和待填充的顏色，將起始像素和所有可達(dá)的像素（可達(dá)的定義：經(jīng)過一次或多次的向上、下、左、右四個方向移動所能到達(dá)且終點和路徑上所有像素的顏色都與起始像素顏色相同），替換為給定的顏色。

#include<bits/stdc++.h>
using namespace std;
const int ROWS = 8;
const int COLS = 8;
struct Point {
    int r, c;
    Point(int r, int c) : r(r), c(c) {}
};
bool is_valid(char image[ROWS][COLS], Point pt,int prev_color, int new_color) {
    int r = pt.r;
    int c = pt.c;
    return (0 <= r && r < ROWS && 0 <= c && c < COLS && ① && image[r][c] != new_color);
}
void flood_fill(char image[ROWS][COLS], Point cur, int new_color) {
    queuequeue;
    queue.push(cur);
    int prev_color = image[cur.r][cur.c];
    ②;
    while (!queue.empty()) {
        Point pt = queue.front();
        queue.pop();
        Point points[4] = {③, Point(pt.r - 1, pt.c),Point(pt.r, pt.c + 1), Point(pt.r, pt.c - 1)};
        for (auto p : points) {
            if (is_valid(image, p, prev_color, new_color)) {
                ④;
                ⑤;
            }
        }
    }
}
int main() {
    char image[ROWS][COLS] = {{'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g'},
                              {'g', 'g', 'g', 'g', 'g', 'g', 'r', 'r'},
                              {'g', 'r', 'r', 'g', 'g', 'r', 'g', 'g'},
                              {'g', 'b', 'b', 'b', 'b', 'r', 'g', 'r'},
                              {'g', 'g', 'g', 'b', 'b', 'r', 'g', 'r'},
                              {'g', 'g', 'g', 'b', 'b', 'b', 'b', 'r'},
                              {'g', 'g', 'g', 'g', 'g', 'b', 'g', 'g'},
                              {'g', 'g', 'g', 'g', 'g', 'b', 'b', 'g'}};
    Point cur(4, 4);
    char new_color = 'y';
    flood_fill(image, cur, new_color);
    for (int r = 0; r < ROWS; r++) {
        for (int c = 0; c < COLS; c++) {
            cout << image[r][c] << " ";
        }
        cout << endl;
    }
    // 輸出：
    // g g g g g g g g
    // g g g g g g r r
    // g r r g g r g g
    // g y y y y r g r
    // g g g y y r g r
    // g g g y y y y r
    // g g g g g y g g
    // g g g g g y y g
    return 0;
}

①處應(yīng)填（ ）。

第41題

（洪水填充）現(xiàn)有用字符標(biāo)記像素顏色的 8x8 圖像。顏色填充的操作描述如下：給定起始像素的位置和待填充的顏色，將起始像素和所有可達(dá)的像素（可達(dá)的定義：經(jīng)過一次或多次的向上、下、左、右四個方向移動所能到達(dá)且終點和路徑上所有像素的顏色都與起始像素顏色相同），替換為給定的顏色。

#include<bits/stdc++.h>
using namespace std;
const int ROWS = 8;
const int COLS = 8;
struct Point {
    int r, c;
    Point(int r, int c) : r(r), c(c) {}
};
bool is_valid(char image[ROWS][COLS], Point pt,int prev_color, int new_color) {
    int r = pt.r;
    int c = pt.c;
    return (0 <= r && r < ROWS && 0 <= c && c < COLS && ① && image[r][c] != new_color);
}
void flood_fill(char image[ROWS][COLS], Point cur, int new_color) {
    queuequeue;
    queue.push(cur);
    int prev_color = image[cur.r][cur.c];
    ②;
    while (!queue.empty()) {
        Point pt = queue.front();
        queue.pop();
        Point points[4] = {③, Point(pt.r - 1, pt.c),Point(pt.r, pt.c + 1), Point(pt.r, pt.c - 1)};
        for (auto p : points) {
            if (is_valid(image, p, prev_color, new_color)) {
                ④;
                ⑤;
            }
        }
    }
}
int main() {
    char image[ROWS][COLS] = {{'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g'},
                              {'g', 'g', 'g', 'g', 'g', 'g', 'r', 'r'},
                              {'g', 'r', 'r', 'g', 'g', 'r', 'g', 'g'},
                              {'g', 'b', 'b', 'b', 'b', 'r', 'g', 'r'},
                              {'g', 'g', 'g', 'b', 'b', 'r', 'g', 'r'},
                              {'g', 'g', 'g', 'b', 'b', 'b', 'b', 'r'},
                              {'g', 'g', 'g', 'g', 'g', 'b', 'g', 'g'},
                              {'g', 'g', 'g', 'g', 'g', 'b', 'b', 'g'}};
    Point cur(4, 4);
    char new_color = 'y';
    flood_fill(image, cur, new_color);
    for (int r = 0; r < ROWS; r++) {
        for (int c = 0; c < COLS; c++) {
            cout << image[r][c] << " ";
        }
        cout << endl;
    }
    // 輸出：
    // g g g g g g g g
    // g g g g g g r r
    // g r r g g r g g
    // g y y y y r g r
    // g g g y y r g r
    // g g g y y y y r
    // g g g g g y g g
    // g g g g g y y g
    return 0;
}

②處應(yīng)填（ ）。

第42題

（洪水填充）現(xiàn)有用字符標(biāo)記像素顏色的 8x8 圖像。顏色填充的操作描述如下：給定起始像素的位置和待填充的顏色，將起始像素和所有可達(dá)的像素（可達(dá)的定義：經(jīng)過一次或多次的向上、下、左、右四個方向移動所能到達(dá)且終點和路徑上所有像素的顏色都與起始像素顏色相同），替換為給定的顏色。

#include<bits/stdc++.h>
using namespace std;
const int ROWS = 8;
const int COLS = 8;
struct Point {
    int r, c;
    Point(int r, int c) : r(r), c(c) {}
};
bool is_valid(char image[ROWS][COLS], Point pt,int prev_color, int new_color) {
    int r = pt.r;
    int c = pt.c;
    return (0 <= r && r < ROWS && 0 <= c && c < COLS && ① && image[r][c] != new_color);
}
void flood_fill(char image[ROWS][COLS], Point cur, int new_color) {
    queuequeue;
    queue.push(cur);
    int prev_color = image[cur.r][cur.c];
    ②;
    while (!queue.empty()) {
        Point pt = queue.front();
        queue.pop();
        Point points[4] = {③, Point(pt.r - 1, pt.c),Point(pt.r, pt.c + 1), Point(pt.r, pt.c - 1)};
        for (auto p : points) {
            if (is_valid(image, p, prev_color, new_color)) {
                ④;
                ⑤;
            }
        }
    }
}
int main() {
    char image[ROWS][COLS] = {{'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g'},
                              {'g', 'g', 'g', 'g', 'g', 'g', 'r', 'r'},
                              {'g', 'r', 'r', 'g', 'g', 'r', 'g', 'g'},
                              {'g', 'b', 'b', 'b', 'b', 'r', 'g', 'r'},
                              {'g', 'g', 'g', 'b', 'b', 'r', 'g', 'r'},
                              {'g', 'g', 'g', 'b', 'b', 'b', 'b', 'r'},
                              {'g', 'g', 'g', 'g', 'g', 'b', 'g', 'g'},
                              {'g', 'g', 'g', 'g', 'g', 'b', 'b', 'g'}};
    Point cur(4, 4);
    char new_color = 'y';
    flood_fill(image, cur, new_color);
    for (int r = 0; r < ROWS; r++) {
        for (int c = 0; c < COLS; c++) {
            cout << image[r][c] << " ";
        }
        cout << endl;
    }
    // 輸出：
    // g g g g g g g g
    // g g g g g g r r
    // g r r g g r g g
    // g y y y y r g r
    // g g g y y r g r
    // g g g y y y y r
    // g g g g g y g g
    // g g g g g y y g
    return 0;
}

③處應(yīng)填（ ）。

第43題

（洪水填充）現(xiàn)有用字符標(biāo)記像素顏色的 8x8 圖像。顏色填充的操作描述如下：給定起始像素的位置和待填充的顏色，將起始像素和所有可達(dá)的像素（可達(dá)的定義：經(jīng)過一次或多次的向上、下、左、右四個方向移動所能到達(dá)且終點和路徑上所有像素的顏色都與起始像素顏色相同），替換為給定的顏色。

#include<bits/stdc++.h>
using namespace std;
const int ROWS = 8;
const int COLS = 8;
struct Point {
    int r, c;
    Point(int r, int c) : r(r), c(c) {}
};
bool is_valid(char image[ROWS][COLS], Point pt,int prev_color, int new_color) {
    int r = pt.r;
    int c = pt.c;
    return (0 <= r && r < ROWS && 0 <= c && c < COLS && ① && image[r][c] != new_color);
}
void flood_fill(char image[ROWS][COLS], Point cur, int new_color) {
    queuequeue;
    queue.push(cur);
    int prev_color = image[cur.r][cur.c];
    ②;
    while (!queue.empty()) {
        Point pt = queue.front();
        queue.pop();
        Point points[4] = {③, Point(pt.r - 1, pt.c),Point(pt.r, pt.c + 1), Point(pt.r, pt.c - 1)};
        for (auto p : points) {
            if (is_valid(image, p, prev_color, new_color)) {
                ④;
                ⑤;
            }
        }
    }
}
int main() {
    char image[ROWS][COLS] = {{'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g'},
                              {'g', 'g', 'g', 'g', 'g', 'g', 'r', 'r'},
                              {'g', 'r', 'r', 'g', 'g', 'r', 'g', 'g'},
                              {'g', 'b', 'b', 'b', 'b', 'r', 'g', 'r'},
                              {'g', 'g', 'g', 'b', 'b', 'r', 'g', 'r'},
                              {'g', 'g', 'g', 'b', 'b', 'b', 'b', 'r'},
                              {'g', 'g', 'g', 'g', 'g', 'b', 'g', 'g'},
                              {'g', 'g', 'g', 'g', 'g', 'b', 'b', 'g'}};
    Point cur(4, 4);
    char new_color = 'y';
    flood_fill(image, cur, new_color);
    for (int r = 0; r < ROWS; r++) {
        for (int c = 0; c < COLS; c++) {
            cout << image[r][c] << " ";
        }
        cout << endl;
    }
    // 輸出：
    // g g g g g g g g
    // g g g g g g r r
    // g r r g g r g g
    // g y y y y r g r
    // g g g y y r g r
    // g g g y y y y r
    // g g g g g y g g
    // g g g g g y y g
    return 0;
}

④處應(yīng)填（ ）。

第44題

（洪水填充）現(xiàn)有用字符標(biāo)記像素顏色的 8x8 圖像。顏色填充的操作描述如下：給定起始像素的位置和待填充的顏色，將起始像素和所有可達(dá)的像素（可達(dá)的定義：經(jīng)過一次或多次的向上、下、左、右四個方向移動所能到達(dá)且終點和路徑上所有像素的顏色都與起始像素顏色相同），替換為給定的顏色。

#include<bits/stdc++.h>
using namespace std;
const int ROWS = 8;
const int COLS = 8;
struct Point {
    int r, c;
    Point(int r, int c) : r(r), c(c) {}
};
bool is_valid(char image[ROWS][COLS], Point pt,int prev_color, int new_color) {
    int r = pt.r;
    int c = pt.c;
    return (0 <= r && r < ROWS && 0 <= c && c < COLS && ① && image[r][c] != new_color);
}
void flood_fill(char image[ROWS][COLS], Point cur, int new_color) {
    queuequeue;
    queue.push(cur);
    int prev_color = image[cur.r][cur.c];
    ②;
    while (!queue.empty()) {
        Point pt = queue.front();
        queue.pop();
        Point points[4] = {③, Point(pt.r - 1, pt.c),Point(pt.r, pt.c + 1), Point(pt.r, pt.c - 1)};
        for (auto p : points) {
            if (is_valid(image, p, prev_color, new_color)) {
                ④;
                ⑤;
            }
        }
    }
}
int main() {
    char image[ROWS][COLS] = {{'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g'},
                              {'g', 'g', 'g', 'g', 'g', 'g', 'r', 'r'},
                              {'g', 'r', 'r', 'g', 'g', 'r', 'g', 'g'},
                              {'g', 'b', 'b', 'b', 'b', 'r', 'g', 'r'},
                              {'g', 'g', 'g', 'b', 'b', 'r', 'g', 'r'},
                              {'g', 'g', 'g', 'b', 'b', 'b', 'b', 'r'},
                              {'g', 'g', 'g', 'g', 'g', 'b', 'g', 'g'},
                              {'g', 'g', 'g', 'g', 'g', 'b', 'b', 'g'}};
    Point cur(4, 4);
    char new_color = 'y';
    flood_fill(image, cur, new_color);
    for (int r = 0; r < ROWS; r++) {
        for (int c = 0; c < COLS; c++) {
            cout << image[r][c] << " ";
        }
        cout << endl;
    }
    // 輸出：
    // g g g g g g g g
    // g g g g g g r r
    // g r r g g r g g
    // g y y y y r g r
    // g g g y y r g r
    // g g g y y y y r
    // g g g g g y g g
    // g g g g g y y g
    return 0;
}

⑤處應(yīng)填（ ）。