「CSP-S 2020」初賽解析

• 前言

  upt2020/10/24：補上了代碼。

  如何評價 Rainy7 白給 6 分。

  好丟人啊嗚嗚嗚。

  主要參考：link。還有大佬同學的分析。（wtcl）

  注：由於Rainy7太菜，部分觀點全靠口胡/胡扯/跳過。如果出現解釋/知識錯誤，歡迎指出。

---

• 選擇題

1.請選出以下最大的數

A.\((556)_{10}\)

B.\((777)_8\)

C.\(2^{10}\)

D.\((22F)_{16}\)

\((777)_8=551\)

\(2^{10}=1024\)

\((22F)_{16}=559\)

故選 C 。

2.操作系統的功能是()

A.負責外設與主機之間的信息交換

B.控制和管理計算杋系統的各種硬件和軟件資源的使用

C.負責診斷機器的故障

D.將源程序編譯成目標程序

操作系統(Operating System，簡稱OS)是管理計算機硬件與軟件資源的計算機程序。操作系統需要處理如管理與配置內存、決定系統資源供需的優先次序、控制輸入設備與輸出設備、操作網絡與管理文件系統等基本事務。操作系統也提供一個讓用戶與系統交互的操作界面。 ——百度百科

概念性知識點。選 B 。

3.現有一段 \(8\) 分鍾的視頻文件,它的播放速度是每杪 \(24\) 幀圖像,每幀圖像是幅分辨率為 \(2048 \times 1024\) 像素的 \(32\) 位真彩色圖像。請問要存儲這段原始無壓縮視頻,需要多大的存儲空間?

A. 30G B. 90G C.150G D.450G

一幀的空間為 \(2048 \times 1024 \times 32\) bit 。

所以整個文件為總幀數的空間。

\[2048 \times 1024 \times 32 \times 8 \times 60 \times 24 (bit) \]

\[=90(GB) \]

故選 B 。

今有一空棧S,對下列待進棧的數據元素序列a,b,c,d,e,f依次進行：進棧，進棧，出棧，進棧，進棧，出棧的操作，則此操作完成后，棧底元素為

A.b B.a C.d D.c

棧內元素依次為 \(a \to a,b \to a \to a,c \to a,c,d \to a,c\) 。

選 B 。

5.將(2,7,10,18)分別存儲到某個地址區間為0~10的哈希表中,如果哈希函數h(x)=(),將不會產生沖突,其中 \(a \mod b\) 表示 a 除以 b 的余數。

A. \(x^2 \mod 11\)

B. \(2x \mod 11\)

C. \(x \mod 11\)

D.\(\left\lfloor\dfrac{x}{2}\right\rfloor \mod 11\) ,其中 \(\left\lfloor\dfrac{x}{2}\right\rfloor\) 表示下取整

A 中各個數為 \(4,5,1,5\)

B 中各個數為 \(4,3,9,3\)

C 中各個數為 \(2,7,10,7\)

D 中各個數為 \(1,3,5,9\)

故選 D 。

6.下列哪些問題不能用貪心法精確求解?()

A. 霍夫曼編碼

B. 0-1背包問題

C. 最小生成樹

D. 單源最短路問題

A 為貪心。 C 的 prim 和 kruskal 為貪心。 D 的 dijsktra 為貪心。

故選 B 。

7.具有η個頂點,e條邊的圖采用鄰接表存儲結構,進行深度優先遍歷運算的時間復雜度為()。

A. \(O(n+e)\) B.\(O(n^2)\) C.\(O(e^2)\) D.\(O(n)\)

每個點，跑所連的每一個邊。一次。

故選 A。

8.二分圖是指能將頂點划分成兩個部分,每一部分內的頂點間沒有邊相連的簡單無向圖。那么,24個頂點的二分圖至多有()條邊

A.144 B.19 C.48 D.122

考慮最大情況，兩邊個數都為 \(12\) 。

答案即 \(12^2=144\) 。

故選 A 。

9.廣度優先搜索時,一定需要用到的數據結構是()

A.棧

B.二叉樹

C.隊列

D.哈希表

選 C 。

10.一個班學生分組做游戲,如果每組三人就多兩人,每組五人就多三人,每組七人就多四人,問這個班的學生人數n在以下哪個區間?已知n<60。

A.30<n<40

B.40<n<50

C.50<n<60

D.20<n<30

通過暴力，可得當 \(n=53\) 的時候滿足。

故選 C 。

11.小眀想通過走樓梯來鍛煉身體,假設從第 \(1\) 層走到第 \(2\) 層消耗 \(10\) 卡熱量,接着從第 \(2\) 層走到第 \(3\) 層消耗 \(20\) 卡熱量,再從第 \(3\) 層走到第 \(4\) 層消耗 \(30\) 卡熱量,依此類推,從第 \(k\) 層走到第 \(k+1\) 層消耗 \(10k\) 卡熱量 \((k>1)\) 。如果小明想從 \(1\) 層開始,通過連續向上爬樓梯消耗 \(1000\) 卡熱量,至少要爬到第幾層樓?

A.14 B.16 C.15 D.13

設爬到 \(x\) 層。

\[10\times (1+2+3+...+x-1) \ge 1000 \]

\[x=15 \]

故選 C 。

12.表達式a*(b+c)-d的后綴表達形式為()

A. abc*+d-

B. -+*abcd

C. abcd*+-

D. abc+*d-

各種方法都可以做出來，選 D 。

13. 從一個4×4的棋盤中選取不在同一行也不在同一列上的兩個方格,共有()種方法。

A.68 B.72 C.86 D.64

\(16 \times 9 \times \frac{1}{2}=72\)

故選 B 。

14.對一個n個頂點、m條邊的帶權有向簡單圖用 Dijkstra算法計算單源最短路時,如果不使用堆或其它優先隊列進行優化,則其時間復雜度為

A. \(O((m+n^2) \log n)\)

B. \(O(mn+n^3)\)

C. \(O((m+n) \log n)\)

D. \(0(n^2)\)

沒優化的 dijkstra ，每次枚舉找 \(n\) 個點，枚舉 \(n\) 次。

故選 D。

15.1948年,()將熱力學中的熵引入信息通信領域,標志着信息論研究的開端。

A.歐拉( Leonhard Euler)

B.馮·諾伊曼(John von Neumann)

C.克勞德·香農(Claude shannon)

D.圖靈(Alan turing）

克勞德·艾爾伍德·香農（Claude Elwood Shannon ，1916年4月30日—2001年2月24日）是美國數學家、信息論的創始人。1936年獲得密歇根大學學士學位 [1] 。1940年在麻省理工學院獲得碩士和博士學位，1941年進入貝爾實驗室工作。香農提出了信息熵的概念，為信息論和數字通信奠定了基礎。 ——百度百科

故選 C 。

---

• 閱讀程序

所有程序題，包括完善程序，的程序會在網絡上有可以復制版的時候搬過來。

手寫一遍？不可能（（

(1)

#include <iostream>
using namespace std;

int n;
int d[1000];

int main() {
  cin >> n;
  for (int i = 0; i < n; ++i)
    cin >> d[i];
  int ans = -1;
  for (int i = 0; i < n; ++i)
    for (int j = 0; j < n; ++j)
      if (d[i] < d[j])
         ans = max(ans, d[i] + d[j] - (d[i] & d[j]));
    cout << ans;
    return 0;
}

1.n必須小於1000,否則程序可能會發生運行錯誤。()

代碼下標從 \(0\) 開始存，若 \(n=1000\) ，程序不會運行錯誤。

故判錯。

2. 輸出一定大於等於0。()

看上去 ans 一定會大於等於 0 。

但是 ans 初始為 \(-1\) 。

當所有 \(d[i]\) 相等時，ans 不會改變。

故判錯。

3. 若將第13行的j=0改為j=i+1,程序輸出可能會改變。()

若程序為嚴格單調遞減，輸出變為 \(-1\) 實際是有解的。

故判對。

4. 將第14行的d[i]<d[j]改為d[i]!=d[j],程序輸出不會改變。()

改完后， \(d[i]>d[j]\) 的情況也會執行。但是對結果沒影響。

故判對。

5)若輸入n為100,且輸出為127,則輸入的d[i]中不可能有()

A. 127 B.126 C.128 D.125

如果有比 \(127\) 大的，結果也一定比 127 大。

所以選 C 。

6)若輸出的數大於,則下面說法正確的是()

A.若輸出為偶數,則輸入的d[i]中最多有兩個偶數。

B.若輸出為奇數,則輸入的d[i]中至少有兩個奇數。

C.若輸出為偶數,則輸入的d[i]中至少有兩個偶數。

D.若輸出為奇數,則輸入的d[i]中最多有兩個奇數。

用奇偶性判斷。

首先 A 和 D 明顯不對（……） 。

如果兩個數為偶數，與完還是偶數。

如果兩個數一奇一偶，與完是偶數。

如果兩個數為奇數，與完還是奇數。

所以若結果為奇數，偶+奇+（偶&奇）=奇 ，也就是說 B 不對。

看 C ，偶+偶+（偶&偶）=偶，奇+奇+（奇&奇）=奇。

故選 C 。

(2)

#include <iostream>
#include <cstdlib>
using namespace std;

int n;
int d[10000];

int find(int L, int R, int k) {
    int x = rand() % (R - L + 1) + L;
    swap(d[L], d[x]);
    int a = L + 1, b = R;
    while (a < b) {
        while (a < b && d[a] < d[L])
            ++a;
        while (a < b && d[b] >= d[L])
            --b;
        swap(d[a], d[b]);
    }
    if (d[a] < d[L])
        ++a;
    if (a - L == k)
        return d[L];
    if (a - L < k)
        return find(a, R, k - (a - L));
    return find(L + 1, a - 13, k);
}

int main() {
    int k;
    cin >> n;
    cin >> k;
    for (int i = 0; i < n; ++i)
        cin >> d[i];
    cout << find(0, n - 1, k);
    return 0;
}             

假設輸入的n,k和都是不超過100的正整數,且k不超過n,並假設rand()函數產生的是均勻的隨機數,完成下面的判斷題和單選題:

1. 第9行的x的數值范圍是L+1到R,即[L+1,R]。()

這題看上去很 nth_element 。

如果正好隨機到倍數，是可以取到 L 的。

故判錯。

2. 將第19行的d[a]改為d[b],程序不會發生運行錯誤。()

可以發現，無論如何 \(a\) 都不會越界。

故判對。

3.(2.5分)當輸入的d[i]是嚴格單調遞增序列時,第17行的swap平均執行次數是()。

A.\(O(n \log n)\)

B.\(O(n)\)

C.\(O( \log n)\)

D.\(O(n^2)\)

官方：答案為 \(O(( \log n)^2)\) ,無正確選項,因此無論選擇哪個選項都算對。

但是這個結果是怎么算的呢（……）

4.(2.5分)當輸入的d[i]是嚴格單調遞減序列時,第17行的“swap”平均執行次數是()

A. \(O(n^2)\)

B. \(O(n)\)

C. \(O(n \log n)\)

D. \(O( \log n)\)

（戰術胡扯）

大概隨機選一個，隨機選完兩邊的數都要兩兩交換，即 \(O(n)\) 。

但是往下已經交換，所以結果最后最多 \(O(n)\) 。

故選 B 。

5.(2.5分)若輸入的 \(d[i]\) 為 \(i\) ,此程序①平均的時間復雜度和②最壞情況下的時間復雜度分別是

A. \(O(n),O(n^2)\)

B. \(O(n),(n \log n)\)

C. \(O(n \log n),O(n^2)\)

D. \(O(n \log n),O(n \log n)\)

平均復雜度 \(O(n)\) 。

以下 by @ifndef

期望時間復雜度為 \(T(n) = T(\dfrac{n}{2}) + n = \Theta(n)\)

以下 by @Konnyaku_LXZ
:

最壞情況的時候，比如你真的太非了（霧），每次 rand() 出的 \(x\) 都是 \(L\)，那么 \(b\) 會從 \(R\) 一直跑到 \(L+1\)，時間復雜度就是 \(T(n) = T(n-1) + n = \Theta(n^2)\) 了

故選 A 。

6)(2.5分)若輸入的d[i]都為同一個數,此程序平均的時間復雜度是

A. \(O(n)\)

B. \(O( \log n)\)

C. $O(n \log n) $

D. \(O(n^2)\)

隨機了個寂寞。

每次 \(a\) 不變，\(b\) 要從 \(R\) 跑到 \(L\) 。然后在跑子程序。

所以結果為 \(O(n^2)\) 。

故選 D 。

(3)

#include <iostream>
#include <queue>
using namespace std;

const int maxl = 20000000;

class Map {
    struct item {
        string key; int value;
    } d[maxl];
    int cnt;
  public:
    int find(string x) {
        for (int i = 0; i < cnt; ++i)
            if (d[i].key == x)
                return d[i].value;
        return -1;
    }
    static int end() { return -1; }
    void insert(string k, int v) {
        d[cnt].key = k; d[cnt++].value = v;
    }
} s[2];

class Queue {
    string q[maxl];
    int head, tail;
  public:
    void pop() { ++head; }
    string front() { return q[head + 1]; }
    bool empty() { return head == tail; }
    void push(string x) { q[++tail] = x;  }
} q[2];

string st0, st1;
int m;

string LtoR(string s, int L, int R) {
    string t = s;
    char tmp = t[L];
    for (int i = L; i < R; ++i)
        t[i] = t[i + 1];
    t[R] = tmp;
    return t;
}

string RtoL(string s, int L, int R) {
    string t = s;
    char tmp = t[R];
    for (int i = R; i > L; --i)
        t[i] = t[i - 1];
    t[L] = tmp;
    return t;
}

bool check(string st , int p, int step) {
    if (s[p].find(st) != s[p].end())
        return false;
    ++step;
    if (s[p ^ 1].find(st) == s[p].end()) {
        s[p].insert(st, step);
        q[p].push(st);
        return false;
    }
    cout << s[p ^ 1].find(st) + step << endl;
    return true;
}

int main() {
    cin >> st0 >> st1;
    int len = st0.length();
    if (len != st1.length()) {
        cout << -1 << endl;
        return 0;
    }
    if (st0 == st1) {
        cout << 0 << endl;
        return 0;
    }
    cin >> m;
    s[0].insert(st0, 0); s[1].insert(st1, 0);
    q[0].push(st0); q[1].push(st1);
    for (int p = 0;
            !(q[0].empty() && q[1].empty());
            p ^= 1) {
        string st = q[p].front(); q[p].pop();
        int step = s[p].find(st);
        if ((p == 0 &&
                (check(LtoR(st, m, len - 1), p, step) ||
                 check(RtoL(st, 0, m), p, step)))
                ||
                (p == 1 &&
                 (check(LtoR(st, 0, m), p, step) ||
                  check(RtoL(st, m, len - 1), p, step))))
            return 0;
    }
    cout << -1 << endl;
    return 0;
}

這個程序手寫了一些數據結構。

每次操作旋轉一段字符串([0,m]或[m,n])。問幾次 \(st0\) 可以和 \(st1\) 相等。

用的是雙向搜索。

1.輸出可能為0。()

若 \(st0=st1\) 會被程序特判為 \(0\) 。

故判對。

2.若輸入的兩個字符串長度均為101時,則m=0時的輸出與m=100時的輸出是一樣的()

一個像左，一個像右，故不一樣。

3.若兩個字符串的長度均為n,則最壞情況下,此程序的時間復雜度為0(n!)。()

最劣復雜度應該為 \(O((n!)^2 ·n)\) 。

4.(2.5分)若輸入的第一個字符串長度由100個不同的字符構成,第個字符串是第一個字符串的倒序,輸入的m為0,則輸出為()

A.49 B.50 C.100 D.-1

手玩可得，不可能，故選 D 。

5)(4分)已知當輸入為0123\n32\n1時輸出為4,當輸入為812345\n54321\n1時輸出為14,當輸入為61234567\n76543210\n1時輸出為28,則當輸入為0123456789\n9876543210\n1輸出為()。其中\n為換行符。

A.56 B.84 C.102 D.68

RP game（霧

以下直接摘自前言的link。

容易構造一個比較劣的耗費 \(\mathcal{O}(n^2)\) 步的操作序列，於是可以猜想當 \(n\) 足夠大時答案為關於 \(n\) 的二次多項式，用給出的三個值進行插值即可得到答案為 \(68\) 。

以下 by @chen_03

發現字符串長度為 \(4\) 時答案為 \(4\) ，長度為 \(6\) 時答案為 \(14\) ，長度為 \(8\) 時答案為 \(28\) ，差分別為 \(10,14\) 。於是猜測接下來的兩個差分別為 \(18,22\) ，於是長度為 \(12\) 時答案為 \(28+18+22=68\)。

故選 D 。

6. (4分)若兩個字符串的長度均為 \(n\) ,且 \(0<m<n-1\) ,且兩個字符串的構成相同(即任何一個字符在兩個字符串中出現的次數均相同),則下列說法正確的是()。提示:考慮輸入與輸出有多少對字符前后順序不樣

A.若n、m均為奇數,則輸出可能小於0。

B.若n、m均為偶數,則輸出可能小於0。

C.若n為奇數、m為偶數,則輸出可能小於0。

D.若n為偶數、m為奇數,則輸出可能小於0。

小於 \(0\) 就是無解。

C中，湊偶數，就有可能無法湊成奇數。

故選 C 。

---

• 完善程序、

1.(分數背包)小S有 \(n\) 塊蛋糕,編號從 \(1\) 到 \(n\) 。第 \(i\) 塊蛋糕的價值是 \(w\) 體積是 \(v\) 。他有一個大小為 \(B\) 的盒子來裝這些蛋糕,也就是說裝入盒子的蛋糕的體積總和不能超過 \(B\) 。

他打算選擇一些蛋糕裝入盒子,他希望盒子里裝的蛋糕的價值之和盡量大。為了使盒子里的蛋糕價值之和更大,他可以任意切割蛋糕。具體來說,他可以選擇一個 $ \alpha (0< \alpha <1) $,並將一塊價值是 \(w\) ,體積為 \(ⅴ\) 的蛋糕切割成兩塊,其中一塊的價值是 \(\alpha·w\) ,體積是 $ \alpha·v$ ,另一塊的價值是 \((1-\alpha)·w\) ,體積是 \((1-\alpha)·ⅴ\) 。

他可以重復無限次切割操作現要求編程輸岀最大可能的價值,以分數的形式輸出比如 \(n=3,B=8\) 三塊蛋糕的價值分別是4、4、2,體積分別是5、3、2。那么最優的方案就是將體積為5的蛋糕切成兩份,一份體積是3,價值是4,另一份體積是2,價值是1.6,然后把體積是3的那部分和后兩塊蛋糕打包進盒子。最優的價值之和是 \(8.4\) ,故程序輸出 \(42/5\)

輸入的數據范圍為: \(1 \le n \le 1000,1 \le B \le 10^5;1 \le \frac{w_i}{v_i} \le 100\) 。提示:將所有的蛋糕按照性價比w/v從大到小排序后進行貪心選擇。試補全程序。

#include <cstdio>
using namespace std;

const int maxn = 1005;

int n, B, w[maxn], v[maxn];

int gcd(int u, int v) {
    if (v == 0)
        return u;
    return gcd(v, u % v);
}

void print(irrt w, int v) {
    int d = gcd(w, v);
    w = w / d;
    v = v / d;
    if (v == 1)
        printf("%d\n", w);
    else
        printf("%d/%d\n" w, v);
}
void swap(int &x, int &y) {
    int t = x; x = y; y = t;
}

int main() {
    scanf("%d %d" &n, &B);
    for (int i = 1; i <= n; i ++) {
        scanf("%d %d", &w[i], &v[i]);
    }
    for (int i = 1; i < n; i ++)
        for (int j = 1; j < n; j ++)
            if (①) {
                swap(w[j], w[j + 1]);
                swap(v[j], v[j + 1]);
            }
    int curV, curW;
    if  (②) {
        ③
    } else {
        print(B * w[1] > v[1]);
        return 0;
    }
    for (int i = 2; i <= n; i ++)
        if (curV + v[i] <= B) {
            curV += v[i];
            curW += w[i];
        } else {
            print (④);
            return 0;
        }
    print(⑤);
    return 0;
}

1.①處應填().

A. w[j]/v[j] < w[j+1] /v[j+1]

B. w[j]/v[j] > w[j+1] /v[j+1]

C. v[j] * w[j+1] < v[j+1] * w[j]

D. w[j] * v[j+1] < w[j+1] * v[j]

按照提示所說的排序。

但是因為不是 double ，所以要轉換為乘法。

故選 D 。

2.②中應填()

A. w[1]<=B

B. v[1]<=B

C. w[1]>=B

D. v[1]>=B

看 else 反推，else 直接 return 0 +輸出。說明是v[1]>B 的情況。故選 B 。

3.③中應填()

A. print(v[1],w[1]);return 0;

B. curV=0;curW=0;

C. print(w[1],v[1]);return 0;

D. curV=v[1];curW=w[1];

A 和 C 在干啥……

注意到下面 for 從 2 開始，故選 D。

4.④中應填()

A. curW * v[i]+curV[i] * w[i],v[i]

B. (curW-w[i])*v[i]+(B-curV)*w[i],v[i]

C. curW+v[i],w[i]

D. curW*v[i]+(B-curV)*w[i],v[i]

首先，排除 B 和 C 。

(B-curV) 的目的是求這塊蛋糕切成幾分之幾。

curW*v[i] 是使這部分已經求好的整塊蛋糕的價值和，即分子，和分母一起擴大。最后結果不受分母影響。

(curW-w[i]) 意義不明（……？）

故選 D 。

5.⑤中應填()

A. curW,curV

B. curW,1

C. curV,curW

D. curV,1

注意到此時沒有任何蛋糕被切掉。

所以分母為 \(1\) 。

故選 B 。

2.(最優子序列)取 \(m=16\) ,給出長度為 \(n\) 的整數序列 \(a_1,a_2,...,a_n(0 \le a_i < 2^m)\) 。對於一個二進制數 \(x\) ,定義其分值 \(w(x)\) 為 \(x+ popcnt(x)\) ,其中$ popcnt(x)$ 表示 \(x\) 二進制表示中 \(1\) 的個數。對於一個子序列 \(b_1,b_2,...,b_k,\) 定義其子序列分值 \(S\) 為 \(w(b1 \oplus b2)+w(b2 \oplus b3)+W(b3 \oplus b4)+ ... +w(b_{k-1} \oplus b_k)\) 。其中 \(\oplus\) 表示按位異或。對於空子序列,規定其子序列分值為0。

求一個子序列使得其子序列分值最大,輸出這個最大值。

輸入第一行包含一個整數 \(n(1 \le n \le 40000)\)。接下來一行包含 \(n\) 個整數 \(a_1,a_2,...,a_n\) 。

提示:考慮優化朴素的動態規划算法,將前位和后位分開計算 \(Max[x][y]\) 表示當前的子序列下一個位置的高 \(8\)位是\(x\)、最后一個位置的低 \(8\) 位是 \(y\) 時的最大價值。

#inelude <iostream>

using namespace std;

typedef long long LL;

const int MAXN = 40000, M = 16, B = M >> 1, MS = (1 << B) - 1;
const LL INF = 1000000000000000LL;
LL Max[MS + 4][MS + 4];

int w(int x) 
{
    int s = x;
    while(x) 
    {
        ①;
        s++;
    }
    return s;
}

void to_max(LL &x, LL y) 
{
    if(x < y)
        x = y;
}

int main() 
{
    int n;
    LL ans = 0;
    cin >> n;
    for(int x = 0; x <= MS; x++)
        for(int y = 0; y <= MS; y++)
            Max[x][y] = -INF;
    for(int i = 1; i <= n ; i++) 
    {
        LL a;
        cin >> a;
        int x = ② , y = a & MS;
        LL v = ③;
        for(int z = 0; z < = MS; z++)
            to_max(v, ④);
        for(int z = 0; z < = MS; z++)
            ⑤;
        to_max(ans , v);
    }
    cout << ans << endl;
    return 0;
}

1.①處應填().

A. x>>=1

B. x^=x&(x^(x+1))

C. x-=x|-x

D. x^=x&(x^(x-1))

很 lowbit 。

可以手動嘗試（（，選 D 。

2.②中應填()

A. (a&MS)<<B

B. a>>B

C. a&(1<<B)

D. a&(Ms<<B)

第二題，根據題目中 \(x\) 的定義。

那么 x 為 a 的 B 位的數。

故選 B 。

3.③中應填()

A. -INF

B. Max[y][x]

C. 0

D. Max[x][y]

此時 Max 並未賦值。排除 B 和 D 。

空串的值為 \(0\) 。

故選 C 。

4.④中應填()

A. Max[x][z]+w(y^z)

B. Max[x][z]+w(a^z)

C. Max[x][z]+w(x^(z<<B))

D. Max[x][z]+w(x^z)

根據 \(Max[x][z]\) 可得，這次是在變換 \(y\) 。

而 y^z 就是補充 z 剩下的 \(1\) 的貢獻。

故選 A 。

5.⑤中應填()

A. to_max(Max[y][z],v+w(a^(z<<B)))

B. to_max(Max[z][y],v+w((x^z)<<B)

C. to_max(Max[z][y],v+w(a^(z<<B)))

D. to_max(Max[x][z],v+w(y^z))

易得，這次是固定 \(y\) ，變換 \(x\) 。

故排除 A 和 D 。

變換 \(x\) 的值也時時更新。

和上一題一樣，x^z 是補充 z 剩下的 \(1\) 的貢獻。

再回題目看概念，下一個位置的高 \(8\) 位是\(x\) 。

所以 \(x\) 需要恢復到高位的貢獻，再與 \(v\) 相加。

故選 B 。

---

\[\text{by Rainy7} \]