-
前言
大菜雞 Rainy7 的總結。
於 2020/09/25 完成。
- 選擇題
1.若有定義：int a=7； float x=2.5，y=4.7；則表達式x+a%3*(int)(x+y)%2的值是:( )
A.0.000000 B.2.750000
C.2.500000 D.3.500000
故選 D 。
2.下列屬於圖像文件格式的有（ ）
A.WMV B.MPEG
C.JPEG D.AVI
除了 C 其他都是視頻。
補充一下：除了 JPEG 圖片后綴還有 JPG、GIF、BMP。
故選 C 。
3.二進制數11 1011 1001 0111 和 01 0110 1110 1011 進行邏輯或運算的結果是（ ）。
A.11 1111 1111 1101
B.11 1111 1111 1101
C.10 1111 1111 1111
D.11 1111 1111 1111
或：有一個是 \(1\) 就是 \(1\) ，否則為 \(0\) 。
\(1|1=1,1|0=1,0|1=1,0|0=0\)
故選 D 。
4.編譯器的功能是（ ）
A.將源程序重新組合
B.將一種語言(通常是高級語言)翻譯成另一種語言(通常是低級語言)
C.將低級語言翻譯成高級語言
D.將一種編程語言翻譯成自然語言
B 是百科原話。一字未改（……）。
故選 B 。
5.設變量x為float型且已賦值，則以下語句中能將x中的數值保留到小數點后兩位，並將第三位四舍五入的是（ ）
A.x=(x*100+0.5)/100.0;
B.x=(int)(x*100+0.5)/100.0;
C.x=(x/100+0.5)*100.0;
D.x=x*100+0.5/100.0;
例如一個數 \(\overline{ab.cdef}\) 。
\(\overline{ab.cdef} \times 100=\overline{abcd.ef}\)
進位操作 +0.5 ，可以四舍五入。
然后去掉后面沒用的小數 \((int)\overline{abcd.ef}=\overline{abcd}\)
還原 \(\overline{abcd} / 100 =\overline{ab.cd}\)
故選 B 。
6.由數字1，1，2，4，8，8所組成的不同的4位數的個數是（ ）
A.104 B.102
C.98 D.100
\(A_4^4=24\)
\(24+24/2*3+24/2/2=102\)
故選 B 。
7.排序的算法很多，若按排序的穩定性和不穩定性分類，則( )是不穩定排序。
A.冒泡排序
B.直接插入排序
C.快速排序
D.歸並排序
算是概念知識了（……），另補充一些其它的知識。
故選 C 。
8.G是一個非連通無向圖(沒有重邊和自環)，共有28條邊，則該圖至少有( )個頂點。
A.10 B.9
C.11 D.8
因為至少和非連通無向圖。所以很明顯可以想到，孤立一個點，然后剩余的點組成一個完全圖。
設有 \(n\) 個點。
故選 B 。
9.一些數字可以顛倒過來看，例如0、1、8顛倒過來看還是本身，6顛倒過來是9，9顛倒過來看還是6，其他數字顛倒過來都不構成數字。類似的，一些多位數也可以顛倒過來看，比如106顛倒過來是901。假設某個城市的車牌只有5位數字，每一位都可以取0到9。請問這個城市有多少個車牌倒過來恰好還是原來的車牌，並且車牌上的5位數能被3整除？( )
A.40 B.25
C.30 D.20
好就是這道題我去年原地白給。
首先是一個五位數，第一位可以確定第五位，第二位可以確認第四位。
所以先不看四，五位。一二位置可以放 \(0,1,8,6,9\) 而中間只能放 \(0,1,8\) 。
注意到 \(2\times 1\equiv2\pmod{3}\) 與 \(2\times 8\equiv1\pmod{3}\) 。
所以前兩位確定可以確定第三位。
\(5 \times 5=25\)
故選 B 。
10.一次期末考試，某班有15人數學得滿分，有12人語文得滿分，並且有4人語、數都是滿分，那么這個班至少有一門得滿分的同學有多少人？( )
A.23 B.21
C.20 D.22
容斥， \(15+12-4=23\)
故選 A 。
11.設A和B是兩個長為n的有序數組，現在需要將A和B合並成一個排好序的數組，請問任何以元素比較作為基本運算的歸並算法，在最壞情況下至少要做多少次比較？( )
A.\(n^2\) B.\(n log n\)
C.\(2n\) D.\(2n-1\)
考慮最壞情況，為了比較次數最多，所以兩個序列輪流取數。
注意到，最后一個數沒有的可比。
故選 D 。
12.以下哪個結構可以用來存儲圖？（ ）
A.棧 B.二叉樹
C.隊列 D.鄰接矩陣
（……）
故選 D 。
13.以下哪些算法不屬於貪心算法（ ）。
A.Di.jkstra算法
B.Floyd算法
C.Prim算法
D.Kruskal算法
Floyd 是 DP 思想。
故選 B 。
14.有一個等比數列，共有奇數項，其中第一項和最后一項分別是2和118098，中間一項是486，請問一下哪個數是可能的公比？（ ）。
A.5 B.3
C.4 D.2
易得，是 \(3\) 的倍數。
故選 B 。
15.有正實數構成的數字三角形排列形式如圖所示。第一行的數為 \(a(1,1)\) ，第二行 \(a(2,1)\) ，\(a(2,2)\) ，第 \(n\) 行的數為 \(a(n,1)\) ，$ a(n,2)$ ，…，\(a(n,n)\) 。從 \(a(1,1)\) 開始，每一行的數 \(a(i,j)\) 只有兩條邊可以分別通向下一行的兩個數 \(a(i+1,j)\) 和\(a(i+1,j+1)\)。用動態規划算法找出一條從 \(a(1,1)\) 向下通道 \(a(n,1)\)，\(a(n,2)\)，…，\(a(n,n)\) 中某個數的路徑，使得該路徑上的數之和最大。
令 \(C_{i,j}\) 是從 \(a(1,1)\) 到 \(a(i,j)\) 的路徑上的數的最大和，並且 \(C_{i,0}= C_{0,j}=0\) ，則\(C_{i,j}\) =( )
A.\(\max(C_{i-1,j-1},C_{i-1,j})+ a(i,j)\)
B.\(C_{i-1,j-1}+C_{i-1,j}\)
C.\(\max(C_{i-1,j-1},C_{i-1,j})+1\)
D.\(\max(C_{i,j-1},C_{i-1,j})+ a(i,j)\)
（……）數字三角形。
故選 A 。
- 閱讀程序
我覺得要采取居中碼風。
#include <cstdio>
using namespace std;
int n;
int a[100];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
scanf("%d", &a[i]);
int ans = 1;
for (int i = 1; i <= n; ++i) {
if (i > 1 && a[i] < a[i - 1])
ans = i;
while (ans < n && a[i] >= a[ans + 1])
++ans;
printf("%d\n", ans);
}
return 0;
}
1.第16行輸出ans時，ans的值一定大於i。（ ）
考慮反例，當 \(ans=i=n\) 時，while 不會跑，所以此時 \(ans=i\) 。
故判錯 。
2.程序輸出的ans小於等於n。（ ）
顯然。因為在for中， ans 最多賦值到 n ,while 中也是。
故判對。
3.若將第12行的
<改為!=，程序輸出的結果不會改變。（ ）4.當程序執行到第16行時，若 \(ans - i> 2\) ,則\(a_{i+1} < a_i\)。 （ ）
先大致跑一遍，大概知道是這個東西：
\(| >x_i | x_i | \le x_i | \le x_i | \le x_i |\)
所以第四題成立。判對。
第三題，如果不看 \(<\) 就有 \(>\) 和 \(=\) 。但根據題意只要考慮前者。
\(| <x_i | x_i | \le x_i | \le x_i | \le x_i |\)
考慮的就是 ans 結果是否改變。
不影響。
故判對。
5.若輸入的a數組是一個嚴格單調遞增的數列, 此程序的時間復雜度（ ）
A. O(logn) B. O(\(n^2\))
C. O(nlogn) D. O(n)
若是嚴格單調遞增，那if就無法執行，ans也不會重置。
故選 D 。
6.最壞情況下，此程序的時間復雜度是( )。
A. O(\(n^2\))
B. O(logn)
C. O(n)
D. O(nlogn)
嚴格單調遞減，每次 if 都要重置 ans 。每次都要跑一邊 while 。
故復雜度為 \(n^2\) ，選 A。
#include <iostream>
using namespace std;
const int maxn = 1000;
int n;
int fa[maxn], cnt[maxn];
int getRoot(int v) {
if (fa[v] == v) return v;
return getRoot(fa[v]);
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
fa[i] = i;
cnt[i] = 1;
}
int ans = 0;
for (int i = 0; i < n - 1; ++i) {
int a, b, x, y;
cin >> a >> b;
x = getRoot(a);
y = getRoot(b);
ans += cnt[x] * cnt[y];
fa[x] = y;
cnt[y] += cnt[x];
}
cout << ans << endl;
return 0;
}
首先，很顯然的看出來是並查集。
所以 \(fa[]\) 指的是所在集合，\(cnt[]\) 指的是集合大小。
1.輸入的a和b值應在[0, n-1]的范圍內。()
集合的編號范圍就是 $ [0,n) $ ，不在這個范圍肯定不行對吧（
故判對。
2.第16行改成
fa[i] = 0；，不影響程序運行結果。( )
如果都設為 \(0\) ，那就都在一個集合里了。判錯。
3.若輸入的 \(a\) 和 \(b\) 值均在 \([0, n-1]\) 的范圍內，則對於任意 \(0 \le i<n\) 都有 \(0 \le fa[i] <n\) ( )
無論指向那個集合，也只是賦值來賦值去，而初始值就在 \([0,n-1]\) 中，所以判對。
4.若輸入的 \(a\) 和 \(b\) 值均在 \([0, n-1]\) 的范圍內，則對於任意 \(0 \le i<n\) 都有 \(1 \le cnt[i] \le n\) ( )
按道理說集合大小不可能超過 \(n\) 的。
但是如果 \(a\) 和 \(b\) 所在的集合是同一個，那就是同一個集合合並兩次 （我 並 我 自 己） 。
所以有可能會大於 \(n\) 。
故判錯。
5.當 \(n\) 等於 \(50\) 時，若 \(a,b\) 的值都在 \([0,49]\) 的范圍內，且在第 \(25\) 行時 \(x\) 總是不等於 \(y\) ,那么輸出為()。
A. 1276 B. 1176 C. 1225 D. 1250
你看這個選擇題說明怎么合並結果都是一樣的。
所以不妨假設，一個一個合並。
故選 C 。
6.此程序的時間復雜度是()。
A. \(O(n)\) B. \(O(logn)\) C. \(O(n^2)\) D. \(O(nlogn)\)
注意到，並查集沒有壓縮路徑。
故選 C 。
\(t\) 是 \(s\) 的子序列的意思是：從 \(s\) 中刪去若干個字符，可以得到 \(t\)；特別的，如果 \(s=t\) ,那么 \(t\) 也是 \(s\) 的子序列；空串是任何串的子序列。
例如: \(\texttt{acd}\) 是 \(\texttt{abcde}\) 的子序列， \(\texttt{acd}\) 是 \(\texttt{acd}\) 的子序列，但 \(\texttt{acd}\) 不是 \(\texttt{abcde}\) 的子序列。
\(s[x..y]\) 表示 \(s[x] ...s[y]\) 共 \(y-x+l\) 個字符構成的字符串，若 \(x>y\) 則 \(s[x..y]\) 是空串。\(t[x..y]\) 同理。
#include <iostream>
#include <string>
using namespace std;
const int max1 = 202;
string s, t;
int pre[max1], suf[max1];
int main() {
cin >> s >> t;
int slen = s.length(), tlen = t.length();
for (int i = 0, j = 0; i < slen; ++i) {
if (j < tlen && s[i] == t[j]) ++j;
pre[i] = j; // t[0..j-1] 是 s[0..i] 的子序列
}
for (int i = slen - 1 , j = tlen - 1; i >= 0; --i) {
if(j >= 0 && s[i] == t [j]) --j;
suf[i]= j; // t[j+1..tlen-1] 是 s[i..slen-1] 的子序列
}
suf[slen] = tlen -1;
int ans = 0;
for (int i = 0, j = 0, tmp = 0; i <= slen; ++i){
while(j <= slen && tmp >= suf[j] + 1) ++j;
ans = max(ans, j - i - 1);
tmp = pre[i];
}
cout << ans << endl;
return 0;
}
/*
提示： t[0..pre[i] -1]是 s[0..i]的子序列；
t[suf[i]+1..tlen-1]是 s[i..slen-1]的子序列。
*/
本題是求 \(s\) 中連續刪除至多幾個字母后，\(t\) 仍然是 \(s\) 的子序列。
但是其實這點不好看。但是做題的時候能大致猜出一個方向（
1.程序輸出時，\(suf\) 數組滿足：對任意 \(0 \le i < slen\) , \(suf[i] \le suf[i + 1]\) 。 （）
在循環中，可以看出隨着 \(i\) 的減少， \(j\) 從未遞增。
故判對。
2.當 \(t\) 是 \(s\) 的子序列時，輸出一定不為 \(0\) 。（）
考慮舉反例。
當兩個都為空串的時候，答案就是 \(0\) 。
但是不能有空串（要輸入）；所以退一步。
假設 \(t=s=\texttt{a}\) ，結果為 \(0\) 。
故判錯。
3.程序運行到第 \(23\) 行時，
j-i-1一定不小於 \(0\) 。（）
還是考慮舉反例。
想到為了讓其危負數，那 while 就不執行。
設 \(s=\texttt{a}, t=\texttt{b}\) ，所以 \(j-i-1=0-0-1=-1<0\) 。
故判錯。
4.當 \(t\) 是 \(s\) 的子序列時，\(pre\) 數組和 \(suf\) 數組滿足：對任意 $0 \le i < slen, pre[i] > suf[i + 1] + 1 $ 。 （）
因為 \(t[0..pre[i]-1],t[sub[i+1]+1..lent-1]\) 是 \(s[0..i],s[i+1..lens-1]\) 的子序列。
所以不會重疊。
故判錯。
5.若 \(tlen=10\) ,輸出為 \(0\) ,則 \(slen\) 最小為（）
A. 10 B. 12 C. 0 D. 1
首先，當 \(s\) 為空串的時候，輸出也是為 \(0\) 。
但是不能為空串，所以退一步，當 \(s\) 長度為 \(1\) 。
故選 D 。
6.若 \(tlen=10\) ,輸出為 \(2\) ,則 \(slen\) 最小為（）。
A. 0 B. 10 C. 12 D. 1
\(t\) 有10個字母，\(s\) 為 含子序列 \(t\) 的一串東西 和刪除的 \(2\) 個字母。
考慮最小，那串東西就是 \(t\) ，所以 \(10+2=12\) 。
故選 C 。
- 完善程序
（匠人的自我修養）一個匠人決定要學習 \(n\) 個新技術。要想成功學習一個新技術，他不僅要擁有一定的經驗值，而且還必須要先學會若干個相關的技術。學會一個新技術之后，他的經驗值會增加一個對應的值。給定每個技術的學習條件和習得后獲得的經驗值，給定他已有的經驗值，請問他最 多能學會多少個新技術。
輸入第一行有兩個數，分別為新技術個數 \(n(1 \le n \le 10^3)\) ,以及己有經驗值\((\le 10^7)\)接下來n行。第i行的兩個正整數，分別表示學習第i個技術所需的最低經驗值 \((\le 10^7)\),以及學會第i個技術后可獲得的經驗值 \((\le 10^7)\) 。
接下來 \(n\) 行。第 \(i\) 行的第一個數 \(m_i(1 \le m_i < n)\) ,表示第 \(i\) 個技術的相關技術數量。緊跟着 \(m\) 個兩兩不同的數，表示第 \(i\) 個技術的相關技術編號。
輸出最多能學會的新技術個數。
下面的程序以 \((n^2)\) 的時間復雜度完成這個問題，試補全程序。
#include<cstdio>
using namespace std;
const int maxn = 1001;
int n;
int cnt[maxn];
int child [maxn][maxn];
int unlock[maxn];
int threshold[maxn], bonus[maxn];
int points;
bool find(){
int target = -1;
for (int i = 1; i <= n; ++i)
if(① && ②){
target = i;
break;
}
if(target == -1)
return false;
unlock[target] = -1;
③
for (int i = 0; i < cnt[target]; ++i)
④
return true;
}
int main(){
scanf("%d%d", &n, &points);
for (int i = 1; i <= n; ++i){
cnt[i] = 0;
scanf("%d%d", &threshold[i], &bonus[i]);
}
for (int i = 1; i <= n; ++i){
int m;
scanf("%d", &m);
⑤
for (int j = 0; j < m; ++j){
int fa;
scanf("%d", &fa);
child[fa][cnt[fa]] = i;
++cnt[fa];
}
}
int ans = 0;
while(find())
++ans;
printf("%d\n", ans);
return 0;
}
①處應填（）
A. unlock[i] <= 0
B. unlock[i] >= 0
C. unlock[i] == 0
D. unlock[i] == -1
②處應填（）
A. threshold[i] > points
B. threshold[i] >= points
C. points > threshold[i]
D. points >= threshold[i]
③處應填（）
A. target = -1
B. --cnt[target]
C. bonus[target] = 0
D. points += bonus[target]
④處應填（）
A. cnt[child[target][i]] -= 1
B. cnt[child[target][i]] = 0
C. unlock[child[target][i]] -= 1
D. unlock[child[target][i]] = 0
⑤處應填（）
A. unlock[i] = cnt[i]
B. unlock[i] = m
C. unlock[i] = 0
D. unlock[i] = -1
大致看完程序，發現其實是一個拓撲排序。每次 \(find()\) 找的是可以選擇的課程。
根據第②題，可以推出， \(points\) 是總經驗值。
而 \(unlock[]\) ，根據⑤，因為如果為 \(0\) 等於沒有這行。再看①，可以推測出 \(unlock_i\) 表示第 \(i\) 個學科還差幾個學科。
所以⑤選 B ，①選 C 。
看③，首先排除 A 和 B 。而刪除 \(bonus\) 的沒有用，\(points\) 反而要加上所得經驗值。故選 D 。
看④，推測要改變 \(unlock\) 要學的科目數減一，故選 C 。
(取石子)Alice和Bob兩個人在玩取石子游戲。他們制定了 \(n\) 條取石子的規則，第 \(i\) 條規則為：如果剩余石子的個數大於等於 \(a[i]\) 且大於等於 \(b[il\) ，那么他們可以取走 \(b[i]\) 個石子。
他們輪流取石子。如果輪到某個人取石子， 而他無法按照任何規則取走石子，那么他就輸了。一開始石子有 \(m\) 個。請問先取石子的人是否有必勝的方法？
輸入第一行有兩個正整數，分別為規則個數 \(n (1<n<64)\) ,以及石子個數 \(m (<=10^7)\) 。
接下來 \(n\) 行。第 \(i\) 行有兩個正整數 \(a[i]\) 和 \(b[i]\) 。\((1 \le a[i] \le 10^7,1 \le b[i] \le 64)\) 。
如果先取石子的人必勝，那么輸出
Win，否則輸出Loss。提示：
可以使用動態規划解決這個問題。由於 \(b[i]\) 不超過 \(64\) ,所以可以使用 \(64\) 位無符號整數去壓縮必要的狀態。
\(status\) 是勝負狀態的二進制壓縮，\(trans\) 是狀態轉移的二進制壓縮。
#include <cstdio>
#include<algorithm>
using namespace std;
const int maxn = 64;
int n, m;
int a[maxn], b[maxn];
unsigned long long status, trans;
bool win;
int main(){
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i)
scanf("%d%d", &a[i], &b[i]);
for(int i = 0; i < n; ++i)
for(int j = i + 1; j < n; ++j)
if (aa[i] > a[j]){
swap(a[i], a[j]);
swap(b[i], b[j]);
}
status = ①;
trans = 0;
for(int i = 1, j = 0; i <= m; ++i){
while (j < n && ②){
③;
++j;
}
win = ④;
⑤;
}
puts(win ? "Win" : "Loss");
return 0;
}
①處應填( )
A. 0 B. ~0ull C. ~0ull^1 D. 1
因為是 DP ，所以可以看出來 DP 的有一維被壓掉了。
我感覺， 其實 \(status\) 本來是一維數組。
所以初始狀態時，石頭數量為 \(0\) 。
所以無論如何先手必勝。
故選 C 。
②處應填( )
A. a[j] < i B. a[j] == i C. a[j] !=i D. a[j]>1
while 中要判斷的是能滿足條件的。
其實應是 \(a_j \le i\) ，但開頭有排序過，所以等價於 \(a_j=i\) 。
故選 B 。
③處應填( )
A. trans |=1ull << (b[j] - 1)
B. status |=1ull << (b[j] - 1)
C. status +=1ull << (b[j] - 1)
D. trans +=1ull << (b[j] - 1)
首先，位運算咋有 + 呢？所以排除 C 和 D 。
有已知得， \(trans\) 是 DP 轉移中的變量，而這個空顯然在轉移中（，所以排除 B 。
故選 A 。
④處應填( )
A. ~status| trans B. status & trans
C. status | trans D. ~status & trans
轉移完了。
所以是當前狀態（轉移狀態 \(trans\) ）和上次狀態 \(status\) 合並。
所以如果上次先手輸了，這次就可以先取這次的石頭。上次取完了這波石頭是后手先取。
所以 \(status\) 狀態取反。
所以是與操作，選 D 。
⑤處應填( )
A. trans =status | trans ^ win
B. status = trans >> 1 ^ win
C. trans =status ^ trans | win
D. status = status << 1 ^ win
首先肯定是 \(status\) 轉移，排除 A 和 C 。
要轉入下一個更多石子的局面，肯定是從當前局面輸贏起步，所以不可能是 B 。
選 D 。