Google STEP

去年 11 月中去美國的時候填了 2025 Google STEP 的實習，最後在 12 月底收到了進面試的通知，當時信件說會在近期安排面試，然後面試結果會等大約一個月，也就是 2025 一月的時候出來，結果最後拖到了 12/31 號才通知。原本 Google 安排 1/13 早上跟下午進行兩次面試，結果好像是面試官不夠還是怎樣，二面換了兩次時間，從 1/13 下午改到 1/16 又改到 1/21，缺面試官可以直接錄取我沒關係。

面試

面試流程基本上都差不多，不會有自我介紹的環節，面試官也不會看到履歷，面試就是單純的 coding interview，Google 會提供一個類似 Google Docs 但是比較高級的編輯器，面試時就是直接在上面寫 Code 或是標記想法，可以自己選要什麼語言，我兩場都是直接選 C++。

面試過程其實跟清大特選面試蠻像的，只差在 Google 需要寫 Code，所以我就用平常跟別人討論題目的心態跟想法去面對，沒想到一面一點進去是一個印度人。原本就有聽說可能會是一次英文一次中文的面試，雖然我英文很爛但是如果是講題目的話還勉強可以，可是印度人就完全是兩回事了，印度腔根本聽不懂，一句話可能只能聽出個位數個關鍵字，還好他廢話蠻多的，大概有一半的時間都在復述我說的想法，然後自言自語說 emm this makes sense 之類的，所以還算勉強應付得過去。

題目 Google 說不能公開，但基本上就是一些基本的算法題，我遇到的是一題 DP 跟一題 Greedy，DP 那題超級水，他講完題目基本上我就直接開始講做法了，所以他後來給了好像三四種變種，才把 45 分鐘的時間填滿。二面就是台灣人的中文面試了，題目有稍微難一點，但原題還是蠻簡單的，也是給了兩三種變種，有個版本我講了一個線段樹的版本，現場刻了一顆懶標線段樹。身為很久沒認真打競程的我根本就快忘記懶標模板怎麼寫了，只能根據我對於線段樹以及懶標的理解，一邊完整解釋概念給面試官聽，一邊依照概念實作。面試官看起來也是知道這東西，有指出我一個地方有小 bug，不過很快就發現並修正了，無傷大雅。

面試的過程我基本上都是當作我是在講課，把完整的思路、利用到什麼性質等細節都講得很清楚，二面結束後我有問面試官我有什麼可以改進的地方，他說我講得很好很清楚，看來這個策略是正確的，不過大家都說 STEP 只收女生，所以就隨緣吧，結果據說會在三月出來。

HPC-Camp

清大超算團隊在寒暑假都會舉辦訓練營，在三天的寒假營隊裡會教雖然是基礎但還是不簡單的超算知識，包含叢集電腦的架構與操作、程式編譯、Profiling、平行程式等等，去年我也是因為這個寒假訓練營才正式踏入了超算的領域。

而今年就換我當工作人員了，起初我以為我應該只是幫忙當助教或是隊輔之類的，沒想到看到教授的籌劃，我是行政總籌之一，原本想說辦完 IONC 就再也不碰營隊行政的，看來還是逃不過，但還好有學長的支援，教授的規劃也蠻明確的，所以工作進行得還蠻順利。此外，因為去年教 Profiling 的學長今年不能來，所以老師就問我說要不要試試看講課，我回說如果沒其他人的話可以試試看，結果老師毫無猶豫的說：「Ok，那就讓你試試看了」，怕爆 XD。

後來我就負責了 Profiling 的課程跟 Benchmark 的作業，Profiling 基本上就是根據去年的內容微調，原本想說今年的時間多一點點，所以加了一點內容，原本想說我的腳本幾乎都寫好了，應該操作起來會蠻順利的，不過好像還是太多了，對於第一次接觸超級電腦的同學來說還是有點太難，看來我對於難度的掌握能力還有待加強：（

不過 Benchmark 就順利很多了，這次是規劃在限制 CPU、RAM 資源以及執行時間的情況下，讓他們 tune 出最佳的 HPL 結果，除此之外還使用了平程使用到的計分版系統，讓學員之間互相競爭，有趣的是因為平程計分版是以時間從小到大排序，但是 HPL 要看 GFLops 從大到小排序，所以我就把 GFlops 加一個負號直接填到 time 的欄位，這樣計分板就是從大排到小了，不過他們看到的都會是負數，還蠻好笑的，後來半夜看到他們還一直卷結果，感覺很有成就感（x

另外有一個 OpenMP 的作業，剛好是平程的 Lab2，要算一個半徑為 R 的圓裡面有幾個 Pixel（對，就是我卷到 Rank1 然後忘記交上去的那次。），一般的算法是直接算 $\frac{1}{4}$ 個圓然後再 $\times 4$，不果我那時候想到了沿著輪廓算 $\frac{1}{8}$ 個園然後再 $\times 8$ 的做法。除了複雜度是一半之外，連常數也優化了好幾倍，所以我就丟了當時的程式碼，速度大概是一班實作的兩三倍以上，為了激發他們的鬥志，我就跟他們說比我快的我請他吃飯，果然這招有奏效，那天晚上聽說還有學弟卷到半夜三四點，最後成功想到了跟我當初差不多的算法，蠻好玩的 XD 學弟有潛力。

台積電黑客松

其實原本沒有要參加的，因為我以為決賽是在學期間，結果報名結束前兩天有朋友來問我，我才知道原來還在寒假期間，所以就報了。

預賽

每隊四個人都要進行 coding test，據說台積電 IT 面試的第一關也是這個，最後要錯一題以內或是一題多然後時間夠快才能夠進到決賽，我自己是覺得我抽到的題目蠻簡單的，好像花不久時間就破台了

決賽

決賽是兩天的黑客松，題目跟範例測資會在一周前公布，我們抽到的題目是跨國界即時會議翻譯系統，簡單來說就是要能夠在會議期間即時將講英文、德文、日文的使用者的語音辨識成中文，同時要辨識出裡面的專有名詞，然後還要能夠在會議結束後自動產生會議記錄。

我們做的成果可以參考我們的發表簡報，原始碼也有公開在 GitHub 上。簡單來說就是寫一個網頁，具有 CPU Server 以及 GPU Server，透過自架的 Whisper 模型將語音辨識成文字，然後再透過 DeepL 以及 Mistral API 將文字翻譯成中文的一套系統，比較特別的是我運用平程的知識，在 GPU Server 上寫了 MPI 的程式，同時執行八個 Whisper 端點來達到 load balancing，而每次辨識都只需要花不到 1 秒鐘的時間，最多 1 ~ 2 秒，因此我將我們的逐字稿生成頻率調成了每秒一次，再加上 DeepL 的快速翻譯，我們的系統應該是全場最接近即時翻譯的。

但不料的是，在現場 Demo 的時候，不知道為什麼受到了資料集污染的影響，跑出了奇怪的簡體中文（什麼貢獻者之類的），然後貌似受到了網路還是 Microsoft Teams 的影響（沒錯，投影其實是使用會議室直播，所以延遲相當大），導致後端快速生成的資料並沒有快速地出現在前端，讓我們的完整成果並沒有辦法好好地呈現出來，最後應該是只拿到了第四名。不過以最年輕隊伍的身份能拿到這個名次也是很不錯了，而且這是我第一次寫網頁就直接上戰場，雖然肝了一個禮拜但真的學到蠻多東西的，好玩 XD。

ASC

中國的超算比賽，要在 2/21 前交出預賽的報告，這部分就等之後再更新了。

課業

這學期原本點了 23 學分，後來退了兩門課：

• 硬體實驗與設計 - 李濬屹 (CS 210401, 3)
• 線性代數 - 李哲榮 (CS 233401, 3)
• 資料結構 - 沈之涯 (CS 235101, 3)
• 獨立研究一 (CS 390500, 2)
• 平行程式 - 周志遠 (CS 542200, 3)
• 進階高效能計算叢集電腦實務 - 周志遠 (CS 543400, 3)
• 計算機網路概論 - 徐正忻 (EECS302001, 3)
• 重量訓練 - 邱晨然 (PE 205063, 0)
• 計算機系統管理 - 蔡孟勳（交大, 3）

硬體實驗與設計 - 李濬屹

配分

• 12x Lab: 40%
  • 6x Basic lab: 10%
  • 6x Advanced lab: 30%
• Final Project: 20%
• Midterm Exam: 20%
• Final Exam: 20%

心得

跟課名一樣，真的很硬。整堂課需要應用上一個學期邏輯設計所學，利用 Verilog 這個硬體描述語言\
來設計硬體，並將設計好的電路燒到 FPGA 上面。

Lab 總共有六個單元：

1. Gate-Level Verilog
2. Advanced Gate-Level Verilog
3. Sequential Circuits
4. Finite State Machines（期中考範圍到這）
5. Keyboard and Audio Modules
6. Peripheral Components: VGA, Mouse, and Dual FPGA（期末考範圍到這）

每次 Lab 都分成 Basic 跟 Advanced：
Basic 基本上就是在上機教室依照所給的簡報實作就可以了，通常都能夠拿滿。
Advanced 則是兩人一組，通常會有 4 ~ 5 題並包含一個 FPGA 題，前面幾題會以 Verilog 題目為主，提交上去後助教會使用 testbench 測試你的程式碼輸出的波形圖是不是跟答案一樣；而 FPGA 題則是要在 FPGA 上實現某些功能（例如開關、按鈕、LED 的互動等等）

每次 Lab 跟考試其實分數都挺慘烈的，所以會公布三個基本的調分方案，並要求在第一次期中考成績出來後選擇要哪一種，大部分人都會穩穩選擇第一種，但也有些人覺得他的期末考會很高／低分，而選擇其他方案來當賭狗，而我則是選第一種：

1. Midterm += (Lab5 20% + Lab6 30%) / 100 * (100 - Midterm)
2. Final -> 15%, Midterm -> 30%
3. Midterm -> 30%, Final -> 15%

每次考試的題目量跟一次 Advanced Lab 差不多，通常 FPGA 題會是比較可做的，每次考試平均都差不多三四十分，所以最後還會再調分。

這門課需要花費大量的時間練習與寫作業、報告，我最久一個禮拜花了 4、50 個小時在寫 Verilog 跟 LaTeX，不過其實蠻好玩的，學到很多東西，可惜教授跑去台大了，今年是最後一次開。

結果

• Basic Lab: 全滿
• Advanced Lab: 66, 100.5, 60, 79.35, 96, 109
• Midterm Exam: 36
• Advanced Exam: 100
• Final Project: 88.37
• 基礎調分方案加分：5.9
• 期末調分：7.5

最後成績：97/A+，T 分數 66.10，百分制排名 5/69

線性代數 - 李哲榮

期中考日期把 10/7 看成 1017，考試當天才發現要考試，所以就二退了。

資料結構 - 沈之涯 (CS 235101, 3)

配分

• Coding Assignments: 20%
• Coding Quiz: 20%
• Midterm Exam: 20%
• Final Exam: 20%
• In-class Quiz: 5%
• Final Project: 15%

心得

作業通常都很難，沒有相關基礎的會比較難寫出來，但是上機都蠻簡單的，而且拿到一個測資就有很多分數。

期中考大概考前一兩天把所有簡報讀過一次。考試會有很多題目，每次都差點寫不完。

Final Project 要寫一個論文搜尋系統，基本上就是在寫 Trie，有效能分。所以我把 Final Project 寫成平行程式，最後只有 Report 被扣一分，拿 99。

結果

• Coding Assignments: 全滿
• Coding Quiz: 20
• Midterm: 64
• Final: 80
• In-class Quiz: 有一次出國沒考到，除了那次之外都滿分，不知道最後到底算幾分
• Final Project: 99

最後成績：91.1/A+，T 分數 60.31，等地制排名 1/89

獨立研究一

跟著周百祥老師做之前特選生的研究計劃，主要是跟 Python 課程的出題指引有關。

結果：A+，T 分數 50，等第制排名 1/7

平行程式 - 周志遠

配分

• Homework: 80%
  • Parallel Odd-Even Transposition Sort (MPI): 20%
  • Mandelbort Set (MPI & OpenMP): 20%
  • All-Pairs Shortest Path (GPU): 20%
  • FlashAttention Implementation (GPU): 10%
  • Network Benchmark (Ibverbs & UCX): 10%
• Labs: 6%
  • Pixels in circle
  • Approximate pixels
  • CUDA, OpenACC, HIPCUDA-Advance: Memory Optimization
  • FlashAttention
  • Nvidia DLI
• Final Project: 15%

心得

因為平行程式很好玩，所以來修了這門課，好課大推。

整門課基本就是寫各種 CPU 跟 GPU 的平行程式，每次作業都會給 Sequential 的 code，我們只要把他們寫成平行的版本就好。

Lab 有一個禮拜的時間可以寫，基本上只要有 AC 就會拿到分數。

作業的部分會有數週可以寫，除了 AC 之外也會要求效能，分數會包含正確率、效能、報告以及 demo 等等。最後一個作業比較特別的是要去 trace UCX 的 code 然後修改並回答問題。

Final Project 則是自己選一個主題，然後優化他的平行效能或是把原本不平行的部分平行化，我是選了一個圖論的題目做。

很智障的是我的 Lab2 優化到全班最快，結果我忘記交了 = =，還好最後沒有影響到成績。

結果

• Lab: 100, X, 100, X, 100, 100
• Homework: 95.41, 97.3, 96.75, 80, 77.5
• Final Project: 87

結果：91/A+，T 分數 56.49，等第制排名 1/105

A+ 38.1% (40人)
A 28.6% (30人)
A- 14.3% (15人)
B+ 6.7% (7人)
B 4.8% (5人)
B- 3.8% (4人)
C- 1.% (1人)
D 1.% (1人)
F 1.9% (2人)

進階高效能計算叢集電腦實務 - 周志遠

只有超算隊員才能修的課，其實就是選手培訓跟比賽

結果：A+，T 分數 50，等地制排名 1/14

計算機網路概論 - 徐正忻

第一次期中考發現考一堆計算題，不是我要學的所以就退了。

重量訓練 - 邱晨然

就是重訓，期中考抽考器材跟使用到的肌群，期末考考硬舉

計算機系統管理 - 蔡孟勳

配分

• Homework: 70%
• Midterm Exam: 15%
• Final Exam: 15%

心得

交大著名的 SA，因為高三有做過教授在成大開的 SA，作業都拿了滿分所以就把交大的修一修。

幾次作業的主題是：

1. Install FreeBSD/Ubuntu & WireGuard
2. Shell script & System Info
3. File Server
4. Web Service

基本上就是在架一些服務之類的，完整的介紹可以參考課程網站：https://nasa.cs.nycu.edu.tw/sa/2024/，大家都說要花幾十個小時寫，之前看到 Threads 上看到有 80 個小時拿不到分數，但我寫起來是沒那麼誇張，花個幾天的一些時間寫就可以拿到滿分了。

期考都只是考很簡單的東西，畢竟這堂課的重點是作業，而且作業基本上只有會寫／不會寫，會寫幾乎都會 100，所以代表期考可以被扣 66 分還是有 A+，甜課大推。

結果

• Homework: 100, 105, 100, 117
• Midterm: 82
• Final: 52

結果：A+

總成績

GPA: 4.3
T 分數: 57.05

其他

HPC-AI APAC

這場是由 HPC-AI 委員會舉辦的比賽，獲得冠軍者可以直接得到 6 月德國 ISC 的參賽資格，我們學校派了兩隊參加，我是其中一隊的隊長。

總共有兩個題目：Llama 跟 HOOMD-Blue，我負責的是 Llama。這題基本上就是要我們在兩個節點上 finetune Llama2 7B 的模型。這其實是我第一次接觸到這種大型模型的訓練，學到蠻多的。

HOOMD-Blue 後來我也有參與討論，基本上就是一個分子模擬軟體，我們找到了一些參數能夠大幅優化效能。最後我們 Llama 跟 HOOMD-Blue 速度都蠻快的，可惜報告時沒有發揮好，只拿到第三名，清大的另一隊拿到冠軍，超強 orz

SC24

SC24 是全球最大的超級電腦年會，今年辦在亞特蘭大，很幸運能夠跟著學長的隊伍觀摩學習。

印象最深刻的就是那個超大的會場了，會場由 ABC 三個館串聯再一起，從 A 的另外一堆走到 C 需要超過 20 分，感覺台灣所有場館加起來都沒有他們大 XD。

因為 SC24 SCC (Student Cluster Competition) 的比賽算是 Conference 展覽的一部分，所以在裝機的環節時，展場也同時在佈置，場面超級盛大。

除了會場超大超豪華之外，主辦單位跟贊助商還舉辦了好幾場 reception，像是有一場就是包下整個亞特蘭大水族館，超級酷，算是開眼界了。

這次去美國真的學到超多東西，不管是拆裝機還是現場可能遇到的狀況，也讓我知道我還有一堆東西得學，希望明年的 SC25 能夠有好的結果。

程設一助教

這學期當程設一的出題助教，唯一的工作就是出題，挺單純的。不過有趣的是我編了一個大橘貓的故事，然後拿這個故事出了快要十題 XD，還有一次補充 rolling hash 被 po 上 Dcard，有趣。

以下的內容我可能不會馬上寫完，會不定時更新。然後畢竟大一上都還沒讀完，所以有些成績我不會直接放上來，並且會以我「讀到現在」的感受為主，所以不保證這會是我讀四年之後的感想，而有一些需要等到大二、大三才會知道的就沒辦法寫了。

然後這篇文會以真實情況來描述，不會裝弱。希望看到的人不會以此文的內容攻擊我或是吹捧我。

課業

參考對象

先簡單說明一下我自己的背景，這樣可能比較好參考。

我自認自己數學不好，但邏輯是可以的。國中資優班沒有考上，然後就國中沒什麼在讀書，比較多就是理化有補習所以有先學到一些高中的東西。高中考上數資班，但因為會考準備得很少，數學跟自然都沒有 A++，所以是全班唯一有考初試的。啊考上數資班也不是因為數學，根據我們當初一大群人的成績比較，我的數學 T 分數大概 30 幾，完全是靠自然科進的，啊自然科也沒有很厲害，很多都只是靠邏輯推理出正確的答案。而高中幾乎沒有讀書（至於為什麼是這樣之後再考慮寫一篇出來），靠著國中吃的老本勉強拿到畢業證書（只差幾學分就拿不到了），最終透過特殊選才上清大資工。

數學能力：

數學能力大概是幾乎沒有、微積分只會最基本的多項式微分，所以大學微積分基本上就是從頭學。

自然能力：

自然能力的話大概是只會必修範圍，但經過幾年也忘得差不多了。

英文能力：

國中時還可以，但高中就整個爛掉了，其中一個主要原因是上高中後記憶力大衰退，單字量超級爛然後又沒有什麼時間好好背。

其他

前面有提到，我的記憶力真的很差（跟我比較熟的人都可以公證），大概是過幾秒就會忘掉的那種，所以需要背的東西我都特別不擅長。不過對於知識之間的連結算是還可以，所以學習模式大概是利用記下最少的東西來理解最多東西，以上供參。

清大修課介紹

建議可以參考我們挺會長的資工系選課指南，裡面有很完整的資訊。

選課的話基本上就分成幾個階段，詳細日程可以參考清大官網：

1. 預排：課程總表公開，學生可以先規劃自己想修的課程
2. 第一次選課
3. 第二次選課
4. 新生選課（只有新生入學的那個學期有）
5. 第三次選課
6. 加退選（加簽、退選）：這個階段可以去找教授加簽或是退掉某堂課，在這個階段退選的話成績單是不會寫的
7. 停修（二退）：通常在第一次期中考之後，如果發現自己會不過或者不如自己預期等原因，可以選擇二退。成績單上會寫二退但不會影響到你的成績計算、二一之類的。

有些學校是採先選先得的機制，很考驗網速跟手速，但清大是採抽籤的機制，如果那個階段選的人數 > 名額，那就會從選的人中抽出符合名額的數量。此外，某些課程也會有限制優先的系級，例如有的課就是前兩次選課只開放大一，第三次才開放其他人。或是優先開放資工系之類的。這也是為什麼網路上會有外系搶名額的爭議，因為根據清大的規定，不分系還有學士班二專的選課優先序是跟本系相當的，所以偶爾會出現本系選不到必修課的情況。

然後對於特選生來說，需要特別注意的是清大有英文必修，會透過學測英文的成績或是你考多益、托福等等的檢定成績來幫你分級，如果沒有提交成績，也就是沒有考學測也沒有考檢定如我的話，就會被分到前標英文。雖然有轉級制度但必須先修了一學期之後，成績在 C- 以下才可以申請轉級。

清大資工修課介紹

清大資工的畢業學分表可以參考清大資工畢業學分表，然後全校的課程總表可以參考清大課程總表

裡面大概分成幾個部分：校定必修、系定必修、選修。校定必修就那些，沒什麼好說的，頂多通識課程可以參考上面的課程總表看有沒有自己喜歡的。至於系定必修跟選修的部分，跟其他學校資工系比較不一樣的地方是，清大硬體相關課程的比例是蠻高的，像是必修就有邏輯設計跟硬體實驗設計（分別是大一下跟大二上修，據說後者很硬）。

心得

詳細的修課心得會等大一上成績出來之後再寫，這邊就寫一些比較特別的東西。

這學期總共選了 22 學分：

• 大一體育（校定必修，0 學分）
• 中高級英文一（校定必修，2 學分）
• 大學中文（校定必修，2 學分）
• 普通物理 B 一（系定必修，3 學分）
• 微積分 B 一（系定必修，3 學分）
• 離散數學（系定必修，3 學分）
• 計算機程式設計一（系定必修，3 學分）
• Python 程式語言入門（選修，3 學分）
• 競技程式設計一（選修，3 學分）

這些科目裡，跟高中比較相關的就屬微積分跟離散數學了，微積分的話教授是從最基本的極限定義開始教，然後所有課程都有錄影，再加上不看出席率，所以基本上都可以自己讀就好。課程速度不快、雖然考四次期考但每次都只會有 1 ~ 2 題證明題，所以基本上計算有一定的熟悉度就可以了，對高中數學不熟悉的應該不用太擔心，頂多多花一點點時間寫而已。

但普物就很麻煩了，首先講義的佈局跟英文其實不太好懂，加上計算過程比高中物理還要複雜很多，也會用到比同期微積分還要複雜的計算，所以我覺得讀起來特別燥，需要花特別多時間再上面，如果是高中沒有讀書的可能要特別注意。

其他的離散數學、計算機程式設計、Python、競程，都算是對競程選手比較友善的科目。

離散數學我是修當時面試教授之一的韓永楷教授的課，分成三次期考，第一次主要是邏輯與數學證明，第二次是排列組合、集合論、函數，第三次則是圖論，離散數學大部分都是學習演算法的先備知識，所以我的話大概就是考試前幾天去翻講義跟寫作業練手感（然後考試因為粗心在中等題掉分拿不到 A+…）。

程設的話，特選生如果選楊舜仁教授的課的話，有一個福利是 85% 免修，不需要考任何考試跟作業，只需要做最後 15% 的 Final Project 就好（今年是要使用 Allegro 這個遊戲引擎，跟給定的模板寫一個 Pacman 遊戲）。

至於 Python 就有點看人了，因為考試是採筆試 + 上機，上機雖然幾乎每次都能提早破台，但筆試會考一些蠻細的語法，雖然有一些很重要，但也考了不少不知道為什麼要背起來的東西。然後還會有三次的 demo，目標是要寫出一個 CLI 的記帳程式，其實寫這個難度不高，但麻煩的是他會有規定的格式，像是需要寫成幾個 class、用到什麼函式等等，所以有時候會發現需要推翻以前的設計。像是我因為要拿每次 demo 多出來的 5 分 bonus，在第一次 demo 時就無意將後兩次要做的東西全部做完了，但又跟後來的要求不一樣，所以要改寫就十分痛苦。

競程分成一、二，一會從最基本的演算法開始教，對於高中競程選手來說，只要花時間把作業寫完、有去多多參加各種比賽像是 ICPC、CF 等等，基本上就接近滿分了。

競賽

ICPC

因為 ICPC 跟高中的 OI 規則差蠻大的，所以先簡單講解一下 ICPC 的規則。

首先是計分方式，大學的 ICPC 沒有部份分、不會依照難度排序。排名會用題數、罰時來排序，罰時的算法是 AC 的分鐘數 + 20 $\times$ (AC 前的嘗試次數)。因此不僅考驗解題能力，也考驗手速跟穩定性。

比賽本身是團體賽，三人一組，需要是同校的學生。基本上比賽幾乎都集中在下半年，也就是上學期。最終目標是進入 ICPC World Final。

NCPC

大約在剛開學時，會舉辦校內賽選出 NCPC 的六個隊伍參加 NCPC，以往 NCPC 拿到好名次就會得到 ICPC Regional 的門票，但因為今年開始賽制改變，NCPC 理論上將會來不及報名 Regional，所以可以看成是一個獨立的比賽就好，跟 ICPC 大致無關，但如果有牽扯到 ICPC 海外站的補助資格的話，好像就會採計 NCPC 校內賽的排名。

TOPC

TOPC 是 ICPC 官方承認的 ICPC Taiwan Regional（這裡用 Taiwan 是因為每年不一定都在同一個地方舉辦，2023 在桃園、2024 則是台中），採線上賽的形式，大約會辦在 9 月中。以今年的情況來看，大約前 50 名 + 各校第一名就會得到 ICPC Taiwan Regional 的門票。

ICPC Taiwan Regional

大約在 10 月中舉辦，整個亞太區有五個 Regional，包含台灣桃園、韓國首爾、日本橫濱、越南順化、印尼雅加達，每個區域的第一名會直接晉級 World Final，而其他隊伍，會根據權重公式，選出約 60 名隊伍晉級隔年 2~3 月的季後賽（Playoff），比較特別的是已經有 World Final 門票的大學不會再晉級 Playoff，且每校最多晉級三隊。然後 Playoff 會再選出 10 幾隊晉級 World Final，一樣最終一校只會有一隊前往。

其他 & 總結

然後有人問到我練習的方式，其實我覺得我練得沒有很多，時間上大概是禮拜一固定會去競程讀書會，然後清大會有少數隊伍約禮拜四跟禮拜日團練，但都不是固定的，如果有考試或是其他事情就會跳過一次，團練記錄在這裡。

然後有關於培訓的部分，清大目前有兩堂競技程式設計的課，然後每週一會有三個小時的競程讀書會，讓大家可以互相分享題目跟聊天。另外，在資電館裡有一間行政助教的助教室，算是一個給競程選手的空間之一，有時候會有人在那邊討論東西之類的。雖然清大的競程從強度、人數來看都不及交大，但我覺得清大競程的氛圍是很好的，學長們都很友善，然後行政助教也幫了我們很多事情。

超算

算是清大的特色之一（？），每年都在很多全球範圍的比賽拿到很好的成績，目前已知寒假會舉辦營隊，如果表現不錯的就可以加簽下學期的超算課，但因為我不熟悉所以就沒辦法講太多，可以參考他們的網頁。

書院（宿舍）

書院算是清大的特殊制度，基本來說你可以把它想像成是比較多活動的宿舍。以我申請的載物書院來說，每個人都會被分成一家，每一家會不定期舉辦家聚（可能是吃飯、吃宵夜、煮東西、看電影等等），然後每年也會有家體（家族體驗，基本上就是一起出去玩），另外像是載營（載物的迎新營隊）、載耶（耶誕晚會）都是書院的活動。

我覺得比起一般宿舍，書院更容易接觸到不同領域的人。雖然活動很多但是其實要不要參加都是自己決定的，加上書院的宿舍有更多公共空間，所以我自己是還蠻推薦申請書院的，詳細資訊可以參考書院官網。

生活

食物

清大的學餐主要有三棟：小吃部、風雲樓、水木生活中心，分別有什麼店可以參考清大官網，個人覺得風雲樓算是平均比較好吃的，另外像是小吃部的 711、麥當勞，水木的鬆餅、自助餐，也都還算是蠻常吃的，另外交大的二餐也還蠻近的，算是多了一些選擇。

除了學餐之外，清大門口那一區被稱作是「清大夜市」，雖然被叫作夜市其實只是一個街區然後有蠻多店家。除了餐廳之外，也有飲料店、藥局、寶雅等等，詳細可以參考 Google 地圖。清夜的存在算是大大提升了清大的生活機能，交大那邊就比較沒有這種東西了，這部分清大完勝。

交通

清大門口有公車站牌可以直達市區、火車站、高鐵站，也有客運站可以搭到台北，清大完勝。

其他

有人問到的問題

• 放掉課業會有嚴重的銜接問題嗎？高職會跟不上嗎？
  我覺得銜接問題一定有，最明顯的就是普物。但就看你對大學成績的規劃是怎樣，如果你覺得那些科目沒有一定要拿高分的話，那其實還好。其實換個角度想，如果你放掉了高中課業去研究其他資訊領域的東西，雖然會缺少一部分學科的基礎，但同時你也在某些科目上比其他同學多出不少基礎，所以其實是互補的。

  比起你在高中學過什麼東西，我認為更重要的是你是否有養成適合資工的思考習慣、自學能力。高中學的東西可能只能影響你幾學分，但思考跟自學是會影響整個大學生涯的。

• 清大的課很硬嗎？哪些會用到高中知識
  目前看起來，清大的課其實不硬，但要每科都拿 A+ 還是蠻難的。

  用到高中知識的話，目前確定的是普物微積分，至於機率、線性代數，可能跟高中有關，但我猜以高中教的深度應該還是有很多要學的。

• 大概花多久時間在讀書上？
  其實我不太知道，但以大一上的課程來說，幾乎是每一週都有期考，所以每週都有穩定的 deadline 要趕，所以花的時間大概就是 1 ~ 2 科期中需要讀的時間

前言

上禮拜讀書會時老鼠講到了這題，之前有遇到過一次，覺得很有趣，但過太久忘了所以就想把想法記錄下來。

背包問題

先複習一下什麼是背包問題：

有 $n$ 個物品，第 $i$ 個物品有重量 $w_i$ 與價值 $v_i$，背包最多能裝重量 $W$ 的物品，求背包能裝的最大價值。因為每個物品只有 0 or 1 個，所以稱作是 0-1 背包問題。

至於解法，我們可以令 $f(i)$ 為當背包內物品總重為 $i$ 時的最大價值，則 $f(i) = \max(f(i), f(i - w_j) + v_j)$，其中 $j$ 為第 $j$ 個物品。

上面這個是最典型的求最佳解背包問題，但有一另外一種背包問題是求解法數，也就是不管價值，問有幾種方法可以使背包內物品的總重加起來為 $W$。

帶刪除背包問題

其實我不太確定這個問題的正式名稱，如果有人知道可以跟我說一聲。

簡單來說，就是在剛剛求解法數的 0-1 背包問題上多加了一個刪除某個物品的操作，並且在操作後需要馬上輸出答案。

解法

先考慮不帶修改的情況：我們可以令 $f(i)$ 為湊出背包內物品總重為 $i$ 的方法數，則轉移式就是：$f(i) = f(i) + f(i - w_j),\ (f(0) = 1)$，至於帶修改要怎麼做呢？

我們思考一下 $f(i)$ 有什麼特別的地方，假設 $w = \{1, 1, 1, 3\}$，那麼 $f(4) = 3$，因為 $f(4)$ 可由一個 $3$ 與一個 $1$ 組成，而 $1$ 有三種。

雖然 $f(4)$ 看起來只是一個數字，但其實他的背後隱藏著三個集合，分別代表著三種組成 $4$ 的方法：$\{w_1, w_4\}, \{w_2, w_4\}, \{w_3, w_4\}$，我們將這些 $f(i)$ 代表的集合們稱作是 $S(i)$。

那其他 $i$ 呢？我們觀察一下：

• $f(0) = 1, S(0) = \{\}$
• $f(1) = 3, S(1) = \{w_1\}, \{w_2\}, \{w_3\}$
• $f(2) = 3, S(2) = \{w_1, w_2\}, \{w_1, w_3\}, \{w_2, w_3\}$
• $f(3) = 2, S(3) = \{w_1, w_2, w_3\}, \{w_4\}$

那如果我們要將 $w_4$ 刪掉，$S(i)$ 會變成什麼呢？

仔細觀察我們的轉移過程可以發現，$S(i)$ 的組成其實就是所有 $S(i - w_j)$ 加上 $w_j$ 的集合，所以如果我們要刪掉 $w_4$，就是將所有 $S(i - w_4)$ 的集合刪掉，也就是說 $S(i)$ 會變成 $S(i) - S(i - w_4)$。

所以我們要刪掉一個元素的轉移式，其實就是加上一個元素的轉移式反過來！也就是 $f(i) = f(i) - (i - w_j)$。

例題 & Code

題目可以參考 ABC 321F

Code 如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

#include <bits/stdc++.h>
#define Weakoying ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define int long long
#define ll long long
#define pii pair<int, int>
#define vi vector<int>
#define vii vector<pair<int, int>>
#define pqueue priority_queue
#define pb push_back
#define F first
#define S second
#define max(a, b) (a > b ? a : b)
#define min(a, b) (a < b ? a : b)
#define cmax(a, b) a = (a > b ? a : b)
#define cmin(a, b) a = (a < b ? a : b)
#define put(x) cout << x << endl;
#define DB(x) cerr << #x << " " << x << endl
#define all(v) v.begin(), v.end()
#define stop system("pause");
#define MEM(x, n) memset(x, n, sizeof(x));
#define lowbit(x) x &(-x)
#define SZ(v) ((int)v.size())
#if !LOCAL
#define endl "\n"
#pragma GCC optimize("Ofast", "unroll-all-loops")
#endif
const int INF = 0x3f3f3f3f;
const ll INFLL = 0x3f3f3f3f3f3f3f3f;
const int P = 998244353;

using namespace std;
/******************************************************************************/
#define MAXN 5005
#define MAXM 1000005 
int n, m;
int dp[MAXN];

void sol() {
    cin >> n >> m;
    dp[0] = 1;
    char c;
    int x;
    for (int i = 0; i < n; i++) {
        cin >> c >> x;
        if (c == '+') {
            for (int i = m; i >= x; i--) {
                dp[i] += dp[i - x];
                dp[i] %= P;
            }
        }
        else {
            for (int i = x; i <= m; i++) {
                dp[i] -= dp[i - x];
                dp[i] = (dp[i] % P + P) % P;
            }
        }
        cout << dp[m] << endl;
    }
}

signed main() {
    Weakoying;
    int t = 1;
    //while (cin >> t)
{
    while (t--) {
            sol();
        }
    }
        
    return 0;
}

題目：

解法

1. 根據第一句話，因為 $xy$ 不能得出 $(x, y)$，代表有多組 $(\alpha_i, \beta_i)$ 滿足 $\alpha_i \cdot \beta_i = xy$，也就是：$$\exists (\alpha_1, \beta_1), (\alpha_2, \beta_2), \ldots, (\alpha_n, \beta_n) : \left\{ \begin{array}{l}\alpha_1 \cdot \beta_1 = xy, \\alpha_2 \cdot \beta_2 = xy, \\dots , \\alpha_n \cdot \beta_n = xy\end{array} , n > 1\right\}$$
2. 因為 Sam 早就知道 Peter 無法利用 $xy$ 得知 $(x, y)$，代表同樣有多組 $(\alpha_i, \beta_i)$ 滿足 $\alpha_i + \beta_i = x + y$，也就是：$$\exists (\alpha_1, \beta_1), (\alpha_2, \beta_2), \ldots, (\alpha_n, \beta_n) : \left\{ \begin{array}{l}\alpha_1 + \beta_1 = x + y, \\alpha_2 + \beta_2 = x + y, \\dots , \\alpha_n + \beta_n = x + y\end{array} , n > 1\right\}$$
3. 根據 1.，我們可以知道當 $x, y$ 都是質數時，$xy$ 一定有唯一解 $(x, y)$
4. 根據 2.、3.，代表所有滿足 $\alpha_i, \beta_i = x + y$ 的解中，$\nexists (\alpha_i, \beta_i)$ 滿足 $\alpha_i, \beta_i$ 同時為質數
5. 根據 4. 中提到，兩個質數相加後的值必定不是 $x + y$ 的結論，我們可以將 $x + y$ 可能的值限縮到：$S = \left\{ 11, 17, 23, 27, 29, 35, 37, 41, 47, 51, 53, 57, 59, 65\right\}$（以上還有其他性質可以再進一步限縮範圍，但這邊其實已經夠少了）
6. 以上是前兩句話結束後可以得出的結論，而 Peter 依據以上條件就可以得到真正的 $(x, y)$ ，代表：$\forall (\alpha_i, \beta_i): \alpha_i \cdot \beta_i = xy$，$\nexists$ 任意兩組可能的 $(\alpha_i, \beta_i), (\alpha_j, \beta_j)$ 滿足 $\alpha_i + \beta_i, \alpha_j + \beta_j$ 各自對應到 $S$ 中的不同元素
7. 根據 6. 枚舉可能，可以得到一組合法的解 $(x, y) = (4, 13)$

備註

• 筆者對於數學符號的運用還不是很熟練，如果有更好的方式或表達方式，歡迎提出建議！

前言

交大今年是最晚的，總共十個名額，較去年增加三個，算是增加三個比較彈性的資安名額，基本上就是大魔王，特別緊張

面試進行

進行方式

三位教授，坐在他們前面（有一段距離）

自我介紹

只有一分鐘，反而講得很卡

問答時間

• 請舉出一個比較熟悉的演算法
  • 我：其實學過的都差不多，比較喜歡的是矩陣快速冪
• 可以講解一下嗎？
  • 如果我們今天有一個線性遞迴的 DP 轉移式，那麼就可以推出一個轉移矩陣，並利用快速冪在 $\mathcal{O}(n\log n)$ 的時間算出來
• 可以講一下上禮拜的比賽嗎？
  • 全國賽的部分嗎？我覺得題目還蠻有趣的，可惜有兩題沒有把握好，一題是 $\mathcal{O}(n\log n)$ 被卡常，一題計算錯誤，原本能拿到三等獎，有點可惜
  • 教授：所以是連佳作都沒有嗎？
  • 我：對，因為光是卡常就少了 5、60 分了
• 矩陣快速冪在實務上的難點在哪裡？（其實我沒有聽清楚是難點還是運作上的瓶頸）
  • 主要是矩陣乘法的複雜度是 $n^3$，這會造成在矩陣本身比較大的時候，光是乘法的部分就會爛掉，像是之前寫過一題有 $C^6_2$ 的狀態數（其實是 $6^2$，優化後才會變 $C^6_2$ QQ），這樣光是在做乘法的時候就會爆掉，所以這部分算是比較有瓶頸的地方
• 知道矩陣快速冪可以用在圖論上嗎？
  • 有聽說過 😅
  • 教授：可以描述一下嗎？
  • 我：因為只有聽說過，所以不太了解😅
  • 教授：矩陣快速冪可以用在圖論上
  • 我：哦哦，是利用存圖的矩陣去做運算
  • 教授：對
  • 我：哦哦那大概知道
• 知道可以用矩陣快速冪推一般式嗎？像是費式數列
  • 這個不太知道😅
  • 教授：沒關係，這個你上大學就會學到了
  • 我：豪
• 除了競程以外，有研究其他東西嗎？
  • 資安跟開發都有碰一點點，資安的部分有參加過 T 貓盃，開發的部分主要有寫過兩個小專案，一個是 Discord Bot，裡面有一些專為競程選手打造的功能，像是比賽通知跟題目池的推薦，另一個則是 YTP 的專題，收集了各大 OJ 的題目，結合一些 Todolist 的功能
  • 教授：講一下題目池那個怎麼做的
  • 我：他有兩種模式，一種模式是利用使用者綁定的 Codeforces 帳號，設定一個難度區間，並且從這個區間中篩選出 AC 數較多的幾題出來
  • 教授：那另外一個，跟 vjudge 的有什麼不一樣
  • 我：我們的主要會有一個 todolist 的功能，可以像是 OI Checklist 一樣，標記一個題目的狀態。另外，我們會開發筆記以及白板的功能，使用者可以在平台上利用 markdown 甚至是白板，紀錄解題的過程，甚至是將這些東西分享出去，變相地變成一個題解平台，也可以彙整這些學習資源
• 這時候外面敲門了
  • 中間的教授：那你的在校成績怎麼樣
  • 我：因為我們班的目標是指考，進度比較快…..（講不完）
  • 教授：看來是答不出來
  • 😅
• 我下去 QQ

心得

果然是大魔王，整體氣場很強大，問題也都很硬。

競賽成績不夠強跟在校沒顧真的是硬傷，大概是凶多吉少。

前言

面試進行

進行方式

總共有兩間教室，第一間是自我介紹跟教授問答，第二間則是專業問題，抽兩題回答。

自我介紹

跟其他間差不多，就不多說了

第一間的問答時間

教授的問題主要有三個：社群貢獻、一題課業跟一題競賽

• 你是怎麼招集出那麼多人的社群的？

  以 CISC 為例，我一開始有找了不少社團協助我們推廣，接著我會在社群裡擔任領導者的角色，帶動討論。久了之後他們當裡面的成員發覺這個社群可以帶來幫助，就會互相分享，最終越來越多人加入

• 你的在校成績好像沒有很理想

  對，因為我們班的目標是指考，所以當我知道自己需要什麼、有了方向之後，就沒有花心思在學校課業上了

• NPSC 的隊友是？怎麼認識的

  一個同屆跟一個學弟，基本上是在社團認識的

• 那他們的區賽成績呢？

  都是佳作

• 有沒有什麼問題想問的？
  • 因為其實有很多學生跟我一樣，對資訊有很大的興趣，但是他並不知道有哪些入學管道，像是特殊選才，所以我希望可以跟他們分享，讓他們知道這個管道，然後可以勇敢的去追求夢想、學習程式，所以我好奇的是，對於這些特選的學生，有著很強的學術能力跟很豐富的經歷，教授會比較看重哪個部分？

第二間的問答時間

• 給兩個陣列 A, B，求 A 的每個元素在 B 中的位置
  • 排序後二分搜
  • 排序後雙指針
  • 後來發現他互為 permutation
  • 排序後 index = index
  • 開值域大小的陣列，存原始位置
    • 教授：在實務上呢？如果他是大數或是小數呢？
  • 開 map
• 冰塊線（TIOJ 1994）
  • 我一開始說我對這題不太熟悉，但是我看到時想到的做法是先用一階的，接著把每個線段都切半，再遞迴下去做二階，一直到 n 階
  • 教授：這題我好像也不太知道可以問什麼，那如果是給一個範圍，可以求出圖形嗎？
    • 假設剛剛的算法是正確的，那麼就可以對這個區間求出他是從哪個線段改過來的，往回推就可以了
    • 教授：所以這樣的時間複雜度是？
    • 這樣的話，每回推一次是少一階，所以應該是 $\mathcal{O}(n)$
• 有沒有什麼問題想問？
  • 我：可以問跟剛剛那間一樣的問題嗎？
  • 教授：可以呀
  • 我：因為我一直有在做社群貢獻，發現到很多學生其實他跟我依樣是對資訊很有興趣的，但是不知道特殊選才這個管道，想讓他們多多認識，讓他們可以放心地去追求夢想，學習這些資訊領域，所以想問，如果有學術能力很強的學生，跟對資訊有很豐富想法的學生，教授對這兩種學生的看法是什麼？
  • 教授：因為學生在這裡的時間很短，其實不能就這樣看出學術能力之類的，所以我們會想的是這個學生在進來之後，他的潛力是怎樣，畢業之後可以變得多強，這會是我們思考的點。

這是面試完趕出來的，細節我會再找時間補上，先去吃飯開溜，清大面試讚讚

心得

雖然全國賽打得很爛，但是跟朋友一起玩很開心，面試過程中也沒有甚麼被刁難的問題，整體來說體驗很好，但聽說清大教授本來就比較友善，所以與看不來出來到底是好還是不好，就等結果吧！

12/22 更：
清大是唯一一間有問到教授關於選才問題的（我覺得在考試中問風險超大，但既然教授有留時間讓我問我就大膽問了）。
基本上硬實力是一定要的，畢竟是選讀大學嘛，但也不是說教授只關心你的實力（當然不同學校可能有些微差異），既然這個入學管道是特殊選才，那麼考生們就應該回歸特選的本質，在展現實力的同時，可以多多展現自己的特質，以及特殊經歷，發揮出自己的價值所在，其實都可能是加分項。

前言

今年師大的名額為 5+3，一般組的面試比較單純，不過資安組的面試完還要進行上機考，這部分比較特別一點，但我不是資安組的，就不多做介紹。

面試的順序基本上應該是按照地區排序，越遠的會越晚面試，報到時間基本上就是面試前半小時左右就可以了。

面試進行

進行方式

總共有兩間教室，第一間教室有兩位比較年輕的教授，第二間教室有一位比較年長的教授。

第一間教室進去會先做自我介紹，可以用簡報也可以不用簡報，而第二間則是先問你有沒有剛剛第一間教室沒講到的要補充，然後才是問問題。

自我介紹

我想挑戰不用簡報講，所以就直接口述

問答時間

教授的問題幾乎都著重在社群貢獻的部分，細節有點忘記了，以下列出幾個比較印象深刻的問題，順序不一定準：

• 第一間教室
  1. 這些社群規模好像都蠻大的，要辦起來應該會有一些難度，你覺得最難的地方是什麼
     • 我們這些選手或是講師通常都比較善於解題或是講課，對於行政流程上會比較生疏一點，所以把這些行政流程做好，讓學員的報名、課程體驗做好算是比較難的。
  2. 如果初學者的部分已經有資源補足了，那更高難度的部分該如何提升？
     • 高難度的部分還是得靠社群的力量，但不是一般的講課而已，而是大家聚再一起討論題目、打比賽，透過這樣的方式來提升水準。
  3. 我記得還有一個問題，但我忘記了，希望我會想起來 QQ
• 第二間教室
  1. 我先補充了 SITCON 學生計算機年會的部分，教授問我內容是什麼
     • 2021 年透過開放式議程跟大家討論所謂南部資訊沙漠，還有其他區域所遇到的瓶頸，該如何去解決等等。
     • Q：那最後結論是什麼？
     • A：最後結論是需要透過社群的力量，這也是為什麼我致力於投入於社群貢獻，並投稿今年的 SITCON，向大家分享我們的努力以及經驗。
  2. 辦這些比賽是不是需要自己架 OJ 那些的，你們是怎麼解決？
     • 我們利用國外的 Codeforces 平台來建置，他有一些能讓我們自己出題、架比賽的功能。
     • 不過因為這平台是 ICPC 導向的，高中比賽大多是 OI 制，所以我們有跟 YTP 合作，利用 CMS 來辦一些額外的比賽。
  3. 辦這些比賽真的需求很高嗎？因為感覺比賽已經很多了
     • 其實市面上的比賽雖然很多，但難度大多都比較不利於初學者，以 Codeforces 為例，就有兩個問題：全英文、題目較難。
  4. 三年前來面試的特招生好像就已經在說要提升南部資訊沙漠了，怎麼現在還是在提升 XDD
     • 其實這三年來已經有很大的提升了，我們希望能夠持續提升，並且將範圍擴大到全台灣。
  5. 你們辦比賽最大的規模是什麼？
     • 其實每個月都有辦比賽，參與人數大多是數十人到百人，賽後會有更多人來補寫題目。
  6. 上大學之後有什麼目標？
     • 高中有蠻多東西是比較難接觸到的，像是一些底層的計算機結構等等，我希望可以在大學補足這些知識。

小插曲

在第二間教室的時候，問到一個問題時教室外傳來兩聲敲門聲。我跟教授：OAO。教授：他剛剛是敲兩聲嗎 OAO。我：好像是欸 0.0。教授：哇怎麼那麼快，那你先把這個問題答完。結束後教授：好吧，那今天就先聊到這裡。

系主任來找我們聊天

在等朋友面試的過程，系主任跑來跟我們聊天，系主任還蠻活潑的，還得到了一些內幕XD

1. 逕取：其實逕取沒大家想得那麼單純，其實逕取是認為那些人會重榜，想要增加面試能面的人才設的名額，如果面試量能夠大那就不會有逕取。
2. 因為師大的面試問題跟其他大學比起來很特別，幾乎每個人被問的都是不太一樣的問題，教授們都很針對每個人的特殊專長來問問題，所以看不太出來教授是比較喜歡什麼樣的人，所以我就問系主任師大究竟會比較喜歡哪一類的學生。主任的回答其實還蠻讓我驚豔的，他提到師大認為學術能力或是某項指標並不是最重要的，不同特點、專長的人其實都可以很好的發揮出他的潛力，且師大有很完善的輔導制度，不管是甚麼類型的學生進來都會努力的輔導他們，我想這也是為甚麼教授問的問題都比較少一般的學術問題，而是注重在學生的特殊經歷上。

心得

1. 印象中教授好像有提到，我的程式能力應該是沒什麼問題，所以才著重在社群的經歷上。
2. 師大教授友善多了 XDD，而且是很認真在翻閱資料，聊得很開心，也講得還蠻順的。

一些小小建議

老實說教授都還蠻認真在問問題的，導致其實看不太出來教授會比較喜歡哪個領域的人才，所以我想就是盡力將自己的特點發揮出來就沒問題了 ouob。

題序

解法

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175

#include <bits/stdc++.h>
#define Weakoying ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define int long long
#define pii pair<int, int>
#define vi vector<int>
#define vii vector<pair<int, int>>
#define pqueue priority_queue
#define pb push_back
#define F first
#define S second
#define max(a, b) (a > b ? a : b)
#define min(a, b) (a < b ? a : b)
#define cmax(a, b) a = (a > b ? a : b)
#define cmin(a, b) a = (a < b ? a : b)
#define put(x) cout << x << endl;
#define DB(x) cerr << #x << " " << x << endl
#define all(v) v.begin(), v.end()
#define stop system("pause");
#define MEM(x, n) memset(x, n, sizeof(x));
#define lowbit(x) x &(-x)
#define SZ(v) ((int)v.size())
#if !LOCAL
#define endl "\n"
#pragma GCC optimize("Ofast", "unroll-all-loops")
#endif
const int INF = 0x3f3f3f3f3f3f3f3f;
const int P = 1e9+7;

using namespace std;
/******************************************************************************/
#define MAXN 200005
#define MAXM 1000005 
int n, m;
vector<int> G[MAXN];

int rev(int i) {
    return (i + m) % (m * 2);
}

struct Tarjan {
    int tt, sccId;
    int dep[MAXN], low[MAXN], scc[MAXN];
    int opp[MAXN];
    bitset<MAXN> inSt;
    stack<int> st;

    void dfs(int i, int pa) {
        dep[i] = low[i] = ++tt;
        st.push(i);
        inSt[i] = true;

        for (int e: G[i]) {
            if (!dep[e]) {
                dfs(e, i);
                cmin(low[i], low[e]);
            }
            else if (inSt[e]) {
                cmin(low[i], dep[e]);
            }
        }

        if (low[i] == dep[i]) {
            int p;
            sccId++;
            do {
                p = st.top();
                st.pop();
                inSt[p] = false;
                scc[p] = sccId;
            } while (p != i);
        }
    }

    void main() {
        for (int i = 0; i < 2 * m; i++) {
            if (!dep[i])
                dfs(i, i);
        }
    }

    bool check() {
        for (int i = 0; i < m; i++) {
            if (scc[i] == scc[rev(i)])
                return false;
            opp[scc[i]] = scc[rev(i)];
            opp[scc[rev(i)]] = scc[i];
        }
        return true;
    }
} Tarjan;

struct Solver {
    vector<int> G2[MAXN];
    int in[MAXN];
    int ans[MAXN];

    void build() {
        for (int i = 0; i < 2 * m; i++) {
            for (int e: G[i]) if (Tarjan.scc[i] != Tarjan.scc[e]) {
                G2[Tarjan.scc[e]].pb(Tarjan.scc[i]);
                in[Tarjan.scc[i]]++;
            }
        }
    }

    void topo() {
        queue<int> q;
        for (int i = 1; i <= Tarjan.sccId; i++) {
            if (!in[i])
                q.push(i);
        }

        while (q.size()) {
            auto now = q.front();
            q.pop();

            if (!ans[now]) {
                ans[now] = 1;
                ans[Tarjan.opp[now]] = 2;
            }

            for (int e: G2[now]) {
                in[e]--;
                if (!in[e])
                    q.push(e);
            }
        }

        for (int i = 0; i < m; i++)
            cout << (ans[Tarjan.scc[i]] == 1 ? "+ " : "- ");

        cout << endl;
    }
} Solver;

void sol() {
    cin >> n >> m;


    for (int i = 0; i < n; i++) {
        char c1, c2;
        int a1, a2;
        cin >> c1 >> a1 >> c2 >> a2;
        a1--, a2--;
        if (c1 == '-')
            a1 += m;
        if (c2 == '-')
            a2 += m;

        G[rev(a1)].pb(a2);
        G[rev(a2)].pb(a1);
    }

    Tarjan.main();
    if (!Tarjan.check()) {
        cout << "IMPOSSIBLE" << endl;
        return;
    }

    Solver.build();
    Solver.topo();
}

signed main() {
    Weakoying;
    int t = 1;
    //while (cin >> t)
{
    while (t--) {
            sol();
        }
    }
        
    return 0;
}

題序

見原題

解法

不難看出這是一題矩陣快速冪的題目。

由於轉移點會有兩排，因此狀態數共 $2^6 \times 2^6 = 2^{12}$ 種，用這樣的狀態數下去做矩陣乘法的複雜度就會是 $\mathcal{O}(2^{36})$，顯然不符合需求。

觀察到題目有給一個限制：每排都需要鑽兩個洞，因此每一排的狀態數就減少到了 $C^6_2$ 種，再扣掉不合法的狀態，就剩下 $69$ 種。

接著我們可以枚舉狀態，利用合法或不合法來建構出轉移矩陣 $T$，最後做 $T^{n-2}$ 就可以得到答案了。

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196

#include <bits/stdc++.h>
#define Weakoying ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define int long long
#define pii pair<int, int>
#define vi vector<int>
#define vii vector<pair<int, int>>
#define pqueue priority_queue
#define pb push_back
#define F first
#define S second
#define max(a, b) (a > b ? a : b)
#define min(a, b) (a < b ? a : b)
#define cmax(a, b) a = (a > b ? a : b)
#define cmin(a, b) a = (a < b ? a : b)
#define put(x) cout << x << endl;
#define DB(x) cerr << #x << " " << x << endl
#define all(v) v.begin(), v.end()
#define stop system("pause");
#define MEM(x, n) memset(x, n, sizeof(x));
#define lowbit(x) x &(-x)
#define SZ(x) ((int)x.size())
#if !LOCAL
#define endl "\n"
#pragma optimize("Ofast", "unroll-all-loops")
#endif
const int INF = 0x3f3f3f3f3f3f3f3f;
const int P = 10000;

using namespace std;
/******************************************************************************/
#define MAXN 200005
#define MAXM 1000005 
int n, m;
vector<int> masks;

struct matrix {
    vector<vector<int>> cont;

    matrix(const int _n, const int _m) {
        for (int i = 0; i < _n; i++)
            cont.emplace_back(vector<int>(_m, 0));

    }

    matrix(const int _n) {
        for (int i = 0; i < _n; i++)
            cont.emplace_back(vector<int>(_n, 0));
        for (int i = 0; i < _n; i++)
            cont[i][i] = 1;
    }

    matrix operator *(const matrix &_a) {
        matrix res(SZ(cont), SZ(_a.cont[0]));

        for (int i = 0; i < SZ(cont); i++) {
            for (int j = 0; j < SZ(_a.cont[0]); j++) {
                res.cont[i][j] = 0;
                for (int k = 0; k < SZ(_a.cont); k++) {
                    res.cont[i][j] += cont[i][k] * _a.cont[k][j];
                }
                res.cont[i][j] %= P;
            }
        }

        return res;
    }

    void operator %=(const int P) {
        for (auto &col: cont)
            for (auto &it: col)
                it %= P;
    }


    int operator () (){
        int res = 0;
        for (auto &col: cont)
            for (auto &it: col) {
                res += it;
            }
        res %= P; 
        return res;
    }
};

bool check(int i) {
    return (i >= 0 && i < 6);
}

matrix make_T() {
    matrix res(SZ(masks), SZ(masks));

    for (int i = 0; i < SZ(masks); i++) {
        int mask1 = (masks[i] >> 6); // i - 1
        int mask2 = masks[i] & 0b111111; // i
        for (int j = 0; j < SZ(masks); j++) {
            int mask3 = (masks[j] >> 6); // i - 2
            int mask4 = masks[j] & 0b111111; // i - 1

            res.cont[i][j] = (mask4 == mask1);
            

            for (int x = 0; x < 6; x++) if (mask3 & (1 << x)) {
                for (int y = 0; y < 6; y++) if (mask4 & (1 << y)) {
                    for (int z = 0; z < 6; z++) if (mask2 & (1 << z)) {
                        if (abs(x - z) == 1 || abs(x - y) == 2 || abs(y - z) == 2) {
                            res.cont[i][j] = 0;
                            goto fin;
                        }
                    }
                } 
            }
            fin:;
        }
    }
    return res;
}

template<typename T>
T fpow(T a, int b, const int P) {
    T res(SZ(masks));
    
    while (b) {
        if (b % 2) {
            res = res * a;
            // res %= P;
        }
        a = a * a;
        // a %= P;
        b >>= 1;
    }
    return res;
}

void sol() {
    cin >> n;

    if (n == 1) {
        int ans = 0;
        for (int mask = 0; mask < (1 << 6); mask++)
            ans += __builtin_popcount(mask) == 2;
        cout << ans << endl;
        return;
    }
    
    for (int mask1 = 0; mask1 < (1 << 6); mask1++) {
        if (__builtin_popcount(mask1) != 2)
            continue;
        for (int mask2 = 0; mask2 < (1 << 6); mask2++) {
            if (__builtin_popcount(mask2) != 2)
                continue;

            bool legal = true;

            for (int x = 0; x < 6; x++) if (mask1 & (1 << x)) {
                for (int y = 0; y < 6; y++) if (mask2 & (1 << y)) {
                    if (abs(x - y) == 2)
                        legal = false;
                }
            }

            if (legal) {
                masks.emplace_back((mask1 << 6) + mask2);
            }

        }
    }


    auto T = make_T();
    matrix A(SZ(masks), 1);
    for (int i = 0; i < SZ(masks); i++)
        A.cont[i][0] = 1;

    T = fpow(T, n - 2, 10000);
    A = T * A;

    if (n >= 6) {
        cout << string(4 - to_string(A()).size(), '0');
    }

    cout << A() % 10000 << endl;
}

signed main() {
    Weakoying;
    int t = 1;
    //while (cin >> t)
{
    while (t--) {
            sol();
        }
    }
        
    return 0;
}

題序

見原題

解法

對於每個點有兩種狀態：

1. 在環裡：答案就是環的大小
2. 不在環裡：距離最近的環的大小 + 距離

所以一開始可以先將所有環求出來，對於環內的所有點可以直接求出答案。

至於不在環裡的，可以用遞迴暴力搜到答案，可以證明這樣的時間複雜度會在 $\mathcal{O}(n)$

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

#include <bits/stdc++.h>
#define Weakoying ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define int long long
#define pii pair<int, int>
#define vi vector<int>
#define vii vector<pair<int, int>>
#define pqueue priority_queue
#define pb push_back
#define F first
#define S second
#define max(a, b) (a > b ? a : b)
#define min(a, b) (a < b ? a : b)
#define cmax(a, b) a = (a > b ? a : b)
#define cmin(a, b) a = (a < b ? a : b)
#define put(x) cout << x << endl;
#define DB(x) cerr << #x << " " << x << endl
#define all(v) v.begin(), v.end()
#define stop system("pause");
#define MEM(x, n) memset(x, n, sizeof(x));
#define lowbit(x) x &(-x)
#define SZ(v) ((int)v.size())
#if !LOCAL
#define endl "\n"
#pragma GCC optimize("Ofast", "unroll-all-loops")
#endif
const int INF = 0x3f3f3f3f3f3f3f3f;
const int P = 1e9+7;

using namespace std;
/******************************************************************************/
#define MAXN 200005
#define MAXM 1000005 
int n, m;
int nxt[MAXN];
int vis[MAXN];
int ans[MAXN];
vector<vector<int>> cycle;
vector<int> path;

void dfs(int i) {
    path.pb(i);
    vis[i] = 2;

    int e = nxt[i];
    if (vis[e] == 2) {
        vector<int> tmp;
        for (int j = SZ(path) - 1; j >= 0; j--) {
            tmp.pb(path[j]);
            if (path[j] == e)
                break;
        }
        cycle.push_back(tmp);
    }
    else if (!vis[e])
        dfs(e);

    vis[i] = 1;
    path.pop_back();
}

int cal(int i) {
    if (ans[i])
        return ans[i];
    return ans[i] = cal(nxt[i]) + 1;
}

void sol() {
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> nxt[i];

    for (int i = 1; i <= n; i++) if (!vis[i]) {
        dfs(i);
    }

    for (auto &cyc: cycle) {
        for (auto it: cyc) {
            ans[it] = cyc.size();
        }
    }
    
    MEM(vis, 0);

    for (int i = 1; i <= n; i++) if (!ans[i]) {
        ans[i] = cal(i);
    }

    for (int i = 1; i <= n; i++)
        cout << ans[i] << " \n"[i == n];
}

signed main() {
    Weakoying;
    int t = 1;
    //while (cin >> t)
{
    while (t--) {
            sol();
        }
    }
        
    return 0;
}

前言

海大採取單獨面試的方式，總共有三個教授，然後會問一堆問題

面試進行

自我介紹

根本沒有讓我講。

問答時間

總共有三個教授，一個負責數學，一個負責資安，一個負責程式

• 數學：

  • 給一個三角形，求某個角的 $cos$
  • $\lvert x - 4 \rvert + \lvert x + 2 \rvert$ 求最小值
  • 給一個直線跟圓，求直線跟圓的相交關係
  • 甲乙丙丁戊，甲乙排一起、丙丁排一起，求排列組合數
  • 給 $\log2, \log3$，求 $6^{100}$

• 程式：

  • 問 $1 \sim N$ 中，$3$ 的倍數的總和
    • 需要到白板寫下 Code
    • 我寫了 for 迴圈，還被說編譯不會過 = =
  • 簡述建構子（constructor）、跟函式初始化有什麼關係
• 資安：
  • RSA 的特性
  • 四個攻擊的特點
    • 病毒跟蠕蟲的差別
    • DOS、DDOS 的差別
    • 字典序攻擊
    • 暴力攻擊
    • Zeroday

心得

問題非常多，沒有很充分的時間可以回答，好幾個問題還沒講完就被卡掉了 =w=。

然後海大有夠遠，他給的地圖把兩個校區合在一起，害我們搭到另外一個校區，還得走快一公里到資工系館。

題序

解法

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#define MAXN 500005
#define MAXM 1000005 
int n, k;
int x[MAXN], pre[MAXN], dp[MAXN];

struct Line {
    int a, b;
    int operator ()(int _x) {
        return a * _x + b;
    }
};

bool check(Line l1, Line l2, Line l3, int _x) {
    // double v12 = (l1.b - l2.b) / (l2.a - l1.a);
    // double v23 = (l2.b - l3.b) / (l3.a - l2.a);
    // return v12 >= v23
    return ((l1.b - l2.b) * (l3.a - l2.a) > (l2.a - l1.a) * (l2.b - l3.b) && (_x + k) * (l3.a - l2.a) > (l2.b - l3.b));
}

void sol() {
    cin >> n >> k;
    for (int i = 1; i <= n; i++)
        cin >> x[i];
    reverse(x + 1, x + n + 1);
    for (int i = 1; i <= n; i++)   
        pre[i] = pre[i - 1] + x[i];

    deque<pair<Line, int>> dq;
    dq.push_back({{0, 0}, 0});

    for (int i = 1; i <= n; i++) {
        while (dq.size() && dq.front().S < i - k)
            dq.pop_front();
        while (dq.size() >= 2 && dq[0].F(i) < dq[1].F(i))
            dq.pop_front();

        dp[i] = -i * i + dq.front().F(i);

        Line now = {2 * i, dp[i] - i * i + pre[i]};
        while (dq.size() >= 2 && check(dq[dq.size() - 2].F, dq[dq.size() - 1].F, now, dq[dq.size() - 2].S))
            dq.pop_back();
        dq.push_back({now, i});
    }
    cout << dp[n] << endl;
}

前言

中山大學採取集體面試，一間大概 5 ~ 6 個，時間為 5 + 1（自我介紹簡報 + 教授問達），簡報需要自己攜帶裝置去撥放，平板筆電也可以，但也不一定要用電子簡報就是了，如果你願意的話也可以用紙本資料。

跟其它間比較不一樣的地方是，面試會有兩間教室，因此某一間在面試的時候，另外一間的考生可以先進去準備，等待教授進來（也因此我解鎖了在面試現場玩遊戲的成就）。

面試進行

進行方式

面試的教室是一個小型的會議室，有一個口字型的環形桌子。教授總共有兩組，每組有兩位教授跟兩位工作人員，他們會一個一個巡迴，等到教授們走到你的位置時，再站起來跟教授報告就可以了。由於教授有兩組，所以也必須報告兩次。

自我介紹簡報

因為簡報是 5 分鐘，所以我簡報直接拿中央的然後加一點點東西。我以為 5 分鐘很多，所以就多補充了不少東西，結果兩輪都沒有講完 QAQ。有別於其他人都是用筆電，然後放在桌上操控，我是拿了我的 iPad 進去拿著講，不確定效果有沒有比較好。

問答時間

因為總共有兩輪，每一輪兩個教授，所以下面會用 a-b 來表示第 a 輪第 b 個教授，然後因為面試時間很長，所以可能沒有記得很準確

• 1-1：說明一下程式在未來還能有什麼發展、運用
  我其實忘記，或是沒聽懂教授是問程式本身，還是我自己在大學學習更多東西之後能有什麼運用了，所以我就說我自己升上大學的期許。

我：資訊這方面有很多領域，我希望升上大學之後能夠多多探索不同領域，將不同領域的知識學起來之後，將這些知識結合起來，以自己的力量去改變社會上的一些問題。

• 1-2：你有考過 CPE 嗎？
  我：由於 CPE 的舉辦地點還有時間對我來說比較不方便，所以就沒有參加了

教授：嘉義大學有考場

我：嗯嗯我知道

• 2-1：可以再描述一下專案開發那邊嗎？（我專案那邊簡單帶過而已）

我就描述了一下 Discord Bot 那邊，然後就沒然後了

• 2-2：你講的程式競賽是…..？代表學校的那種嗎？
  感覺像是不知道程式競賽是甚麼 0.0

我：比較常見的就像是資訊奧林匹亞、學科能力競賽之類的，所以不一定是代表學校，大大小小的其實都有。

教授：所以你就是對程式設計很有興趣就對了

我：對

心得

從 5 + 1 的配置就可以大概猜到教授大概也問不了什麼了，事實也確實是如此。

不過高雄是真的熱，光是從捷運站走到中山大學就汗流浹背了 =w=

結果（更）

最後正取，拿到獎學金推薦資格，我猜是正取一的意思（？
回頭看看問的問題，我不懂特選…

題序

給定一個區間 $[a, b](a, b \le 10^{18})$，求區間內有幾個合法的整數，合法的定義為：任兩個相鄰的數字皆不相同，如 $123$ 是一個合法的整數，但 $555$ 不是。

解法

狀態定義

令 $dp_{i ,j}$ 為區間 $[j \times 10^i, (j+1) \times 10^i)$ 內合法的整數個數。

轉移式

可發現，對於所有合法的數字滿足長度為 $i$ 且前端數字為 $j$，那麼這些數字就可以透過在前端加上除了 $j$ 以外的所有正整數來得到一個新的合法整數，因此轉移式便是：$dp_{i, j} = \displaystyle\sum_{k=0, k \neq j}^{9}{dp_{i-1, k}}$

合法個數求法

拿 $2345$ 為例，對於 $\le 2345$ 的所有數字可分為三種：

1. $< 2000$
2. $2000 \sim 2344$
3. $2345$

對於第一種情況答案應該很好算，那就是：$dp_{4, 1} + \sum_{i=0}^{9}{dp_{3, i}} + \sum_{i=0}^{9}{dp_{2, i}} + \sum_{i=0}^{9}{dp_{1, i}}$，而第三種也很簡單，直接判斷就可以了。

至於第二種的部分，我們可以再分成幾種情況：

1. $2000 \sim 2299$：前一位數字貼合上限
2. $2300 \sim 2339$：前兩位數字貼合上限
3. $2340 \sim 2344$：前三位數字貼合上限

假設 $s_i$ 為從前面數來的第 $i$ 位數字（1-based），那麼我們就可以枚舉是前 $i$ 位數字貼合上限，那麼合法的整數數量便是：$\displaystyle\sum_{i=1}^{\log_{10}-1}{\sum_{j=0}^{s_{i+1}}{dp_{i+1, j}}}$

需要額外注意的是像 $555$ 這種數字，如果貼合前兩位的話就已經是不合法的了，這時就需要停止計算

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

int n, m;
int dp[20][10], sum[20];

void pre() {
    for (int i = 0; i < 10; i++)
        dp[1][i] = 1;
    sum[1] = 10;
    for (int i = 2; i < 20; i++) {
        for (int j = 0; j < 10; j++) {
            for (int k = 0; k < 10; k++) if (j != k)
                dp[i][j] += dp[i - 1][k];
            if (j)
                sum[i] += dp[i][j];
        }
    }
}

int cal(string s) {
    int res = 0;

    if (stoll(s) < 0)
        return 0;
    if (stoll(s) <= 1)
        return 1;

    for (int i = 1; i < s.size(); i++)
        res += sum[s.size() - i];
    for (int j = 1; j < s[0] - '0'; j++)
        res += dp[s.size()][j];

    for (int i = 1; i < s.size(); i++) {
            
        for (int j = 0; j < s[i] - '0'; j++) if (j != s[i - 1] - '0')
            res += dp[s.size() - i][j];
        if (s[i] == s[i - 1])
            break;
    }
    bool legal = true;
    for (int j = 1; j < s.size(); j++) {
        if (s[j] == s[j - 1])
            legal = false;
    }
    res += legal;
    return res;
}


void sol() {
    pre();
    cin >> n >> m;
    cout << cal(to_string(m)) - cal(to_string(n - 1)) << endl;
}

前言

成大資工特選分為兩個組別：甲組（演算法）、乙組（開發），各有 4 個名額，且複試都是採取上機考的方式，最終成績算法為甲組備審 / 上機考 50、50，乙組 20、80。

甲組複試時間是 11/19，10:30 開始報到、11:00 測機、13:30 ~ 16:30 考試。在測機的時候因為網路沒關，所以我就以為可以裝插件，因此就下載了 code runner 還有 One Dark 的主題（現場有提供 VS Code），，結果後來才得知其實是他們忘記關了，回來之後那些插件就通通被他們刪掉了：（。

賽制

今年的賽制是很特殊的，雖然一樣是有部分分，但有別於以往比賽的 OI、ICPC 制，幾乎都是考有”標準答案”的題目，這次考的是「最佳化演算法」，題目本身幾乎都是 NP-Hard 問題，以現今的電腦沒有辦法求出標準答案，因此算分方式是依照你寫得夠不夠好來評分，答案越接近官方準備的最佳解，分數就越高，會利用題目提供的公式算出一個 % 數（因為官方也無法求出真正的最好答案，所以是有可能超過 100 % 的）。

除了題目本身很特殊以外，評測方法採取的是全 output-only，題目所有的測試資料都會附在題目裡，在賽中需要將程式輸出的結果放進資料夾中，最後會用 output 資料夾中的檔案去跟官方提供的答案比較。

據主辦方所述，由於計分方式特殊的關係，他們無法將這些題目放到 Online Judge 上，因此在每一題的檔案中，都有一個用於驗證輸出檔的可執行檔（.exe），當我們生成完答案之後，可以自己在本機評測，看看自己拿到了幾 %。但賽中所知道的 % 數其實也不是最終的成績，賽後每一題都會將參賽者的完成程度排名，然後再依照排名給分，所以如果有一題最高就是 50%，那麼那個人就會拿到該題的滿分。

題目

PA：超大背包問題 - 0%

基本上就是 0-1 背包問題，但是範圍超級大，所以無法使用傳統的 DP 來做，據說可以限制範圍，在某個範圍以內使用貪心，然後再使用 DP 填充剩下的重量，但我賽中沒有做出來，因此沒拿到分數。

PB：n 分圖問題 - 0%

n 分圖的定義是，將每個點畫成 n 種顏色，如果每條邊所連接的兩個點顏色都不相同，那麼這張圖就是一個 n 分圖，題目目標是要找到一個最小的 n。

我的作法基本上跟其他有撈到分數的人都一樣：在 DFS 的過程中去貪心分配每個點的顏色，但我不知道哪裡出錯了，最後還是 0%。

PC：平均最短路 - Accepted

這是唯一有標準答案的題目：有一張有向圖，求對於所有滿足 u 可到達 v 的點對 (u, v)，求出其最短路的平均值，點數 = 100。

這題算是最水的一題，直接用每個點當起點 BFS，然後暴力枚舉點對，最後算平均值即可。

但是這題有一個很大的陷阱：如果有自環的話，那麼就需要考慮 u = v 的點對（印象中題本是寫另外一個點啊…），所以如果沒有算到自環的話，答案就會偏離 0.001 ~ 0.002。起初我以為是浮點數的誤差，因此就手動將每個答案都加上正負 0.001 or 0.002，然後再去跑驗證程式，就 AC 了 hehe，賽中才知道是自環的問題。

PD：集合問題 - 99.86%

有數個集合，每個集合中有一些數字以及一個權重，要求選出一些集合，使得這些集合的聯集包含所有數字，且權重和最小。

這題我一開始在思考是否能用背包的概念去思考，但寫了許久一直沒有突破，在時間壓力下我直接使用貪心，將每個集合利用權重由小到大排序，接著一個一個掃，如果加入這個集合能夠讓聯集大小增加，那就加上去，沒想到就拿到 99.86% 了@@，不知道有沒有人拿到 100%。

PE：斯坦納樹 - 0%

這題我沒有看，根據其他人的描述：給一張圖和指定點集 T，求包含 T 的最小邊權和斯坦納樹。

最終成績

最後是拿到了原始分數 40 分的成績，由於 PD 是 99.86%，所以不意外的話最終成績應該也不會差太多，就看到時候放榜如何了。

心得

這次的賽制很有趣，脫離了高中比賽的題型，改成較貼近實際生活中會遇到的最佳化問題，這個方向我覺得是好的，或許可以選到更不一樣的人才，但我也觀察出了幾個問題：

1. 根據上面的描述可以發現到，其實題目本身還是偏向於學術研究的類型，並沒有比較貼近於生活，甚至容易有一種在寫論文題的感覺。結果便是更加劇了考生狀態的起伏，這樣是否有可能會讓成大反而沒招到他們想要的人呢？（當然這是建立在我認為成大想要較貼近現實的猜想，或許他們另有想法，我單純提出了我的擔憂）
2. 題目是 output only，需要利用 freopen + loop 或是其他類似作法來讀檔案，這個在考試辦法規定時可以看得出來，但 PB 由於某些緣故（可能是有字串，或是藏了什麼奇怪的不可視字元），導致整題是沒有辦法利用迴圈讀檔的，我問到的所有參賽者都有遇到這個問題，都造成了不少的時間損耗，像是我就至少花了一小時在尋找無法迴圈讀檔的原因，最後也花了不少時間在複製貼上測資當中。這個問題相比於一般比賽中會出現的測資太弱，我認為是更嚴重的，假設出題者有驗題，那他又是怎麼讀檔的呢？難不成本來就希望我們複製貼上測資嗎？
3. （11/21 更）據說 UTF-8 以外的編碼格式是無法被讀取的，這件事似乎沒被公告過，主辦方好像也不知道這件事，導致參賽者會因為編輯器預設編碼的差異而拿不到成績（有的參賽者是利用編譯參數，如 ./a.exe > 1_out.txt，而這樣出來的編碼格式會是 UTF16LE 或是其它種），這就又衍伸出了另外一個問題：在參賽者不知道編碼格式會影響評判程式的情況下，再加上主辦方沒有提供統一的讀檔方式，參賽者便無法知道自己的編碼格式是錯誤的，一定程度的影響了比賽公平性。

撇除掉上述的問題，我覺得主辦方做得不錯了，新的賽制也十分新奇。但或許是題型的少見，導致幾乎全場燒雞，這點是比較可惜的。如果明年要繼續辦理這種賽制，希望可以在細節上做得更完整，才能夠真正的發揮出這個賽制的價值。

一些小小建議

根據新聞報導，成大資工希望透過上機考來招收能夠解決實際問題的人才，而這或許也是採用這種賽制的原因，因此學習演算法千萬不要只停留在解題上，也要多多思考如何將演算法應用在實際問題中，如果能夠將演算法及實際情境融合，那麼不管是在學術上或是實務上都會有很大的幫助。（但這好難 QQ）

題序

給一棵樹，對於每次詢問輸入 $a, b$，求有幾個點 $x$ 到 $a, b$ 的距離相同。

解法

• $x$ 有兩種情況： 1. $x$ 在 $a \rightarrow b$ 的路徑上：那麼 $x$ 介於 $a \rightarrow b$ 的路徑中點 $mid(a, b)$，也就是 $dis(a, x) = dis(x, b) = \frac{dis(a, b)}{2}$
  1. $x$ 不在 $a \rightarrow b$ 的路徑上：那麼一定存在一條道路使得 $x$ 能夠到達 $a \rightarrow b$ 的路徑中點 $mid(a, b)$
• 可以發現，不管是哪一種情況，都會跟路徑中點有關，且必須符合 $2 \mid dis(a, b)$ 才會有答案
• 要求出路徑中點，就需要先求出 $dis(a, b)$，這部分可以用 $LCA $ + 倍增法求出
• 有了 $dis(a, b)$ 之後，就可以利用求 LCA 的倍增表格，將 $a \text{ or } b$ 往上跳 $\frac{dis(a, b)}{2}$ 求出
• 至於求點數的部分，就是 $n - \displaystyle\sum_{i \in path(a, b)}{sizeof(subtree_i)}$：

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

#define MAXN 200005
#define MAXM 1000005 
int n, m;
vector<int> G[MAXN];

struct Euler_Tour {
    int tt = 0;
    int in[MAXN], out[MAXN], d[MAXN], sz[MAXN];
    int arr[25][MAXN];

    bool isAnc(int i, int j) {
        return (in[i] <= in[j] && out[i] >= out[j]);
    }

    void init() {
        out[0] = INF;
    }

    void dfs(int i, int dep) {
        in[i] = ++tt;
        d[i] = dep;
        for (int e: G[i]) {
            if (!in[e]) {
                arr[0][e] = i;
                dfs(e, dep + 1);
                sz[i] += sz[e];
            }
        }
        out[i] = ++tt;
        sz[i]++;
    }

    void buildST() {        
        for (int i = 1; i <= __lg(n); i++) {
            for (int j = 1; j <= n; j++) {
                arr[i][j] = arr[i - 1][arr[i - 1][j]];
            }
        }
    }
} ET;

struct LCA {
    int find(int a, int b) {
        if (ET.in[a] > ET.in[b])
            swap(a, b);

        if (ET.isAnc(a, b)) {
            return a;
        }

        for (int i = 20; i >= 0; i--) {
            if (!ET.isAnc(ET.arr[i][a], b)) {
                a = ET.arr[i][a];
            }
        }

        return ET.arr[0][a];
    }

    int mv(int a, int dis) {
        for (int i = 20; i >= 0; i--) {
            if (dis >= (1 << i)) {
                a = ET.arr[i][a];
                dis -= (1 << i);
            }
        }
        return a;
    }
} LCA;

void sol() {
    cin >> n;
    for (int i = 1, a, b; i < n; i++) {
        cin >> a >> b;
        G[a].pb(b);
        G[b].pb(a);
    }

    ET.init();
    ET.dfs(1, 1);
    ET.buildST();

    cin >> m;
    while (m--) {
        int a, b;
        cin >> a >> b;

        if (a == b) {
            cout << n << endl;
            continue;
        }

        int lca = LCA.find(a, b);
        int disa = ET.d[a] - ET.d[lca];
        int disb = ET.d[b] - ET.d[lca];

        if ((disa + disb) % 2 == 0) {
            int mid = LCA.mv((disa > disb) ? a : b, (disa + disb) / 2);
            int ans = n;

            if (ET.isAnc(mid, a))
                ans -= ET.sz[LCA.mv(a, (disa + disb) / 2 - 1)];
            else
                ans -= n - ET.sz[mid];

            if (ET.isAnc(mid, b))
                ans -= ET.sz[LCA.mv(b, (disa + disb) / 2 - 1)];
            else
                ans -= n - ET.sz[mid];
                
            cout << ans << endl;
        }
        else {
            cout << 0 << endl;
        }
    }
}

前言

中央資工今年是取一般組與資安組合在一起面試的方式，等最終成績出來之後再依照志願錄取。

面試當天是 11/01 早上 9:00 ~ 9:30 開始報到，當場會得到一個面試順序，基本上就是你的初審成績排名，像我就是第 16 名 \|/ (85.64 / 84.7)。

報到後會有一間教室讓特選生在裡面休息，雖然我都是跑出來外面跟別人聊天，順便推銷特選群組。等快換你的時候（大概是你的前兩位在面試時），工作人員會來通知你前往樓上的面試教室外準備。

面試進行

進行方式

面試是採取 3 + 3 的形式進行（自我介紹簡報 + 教授問答），進去之後會有三個教授坐在前面，然後告訴你點開自己的檔案，如果準備好就可以開始了。

自我介紹簡報

由於放簡報的筆電在最旁邊，然後沒有簡報筆之類的東西，所以我全程都站在最旁邊，等講完之後才走到中間的投影幕旁。由於時間真的很短，所以基本上這個環節就是把你的簡歷還有一些成績再描述一遍就好了，教授都蠻和善的，也會認真聽你講了甚麼（至少這屆是這樣）。

問答時間

我被問了四個問題，好像是全場數一數二多的，希望這是好事。
以下的內容可能不是完全準確，畢竟我是金魚腦，但我盡力記住了。

1. 你的在校成績如何？

   這問題應該是大部分人都有被問到的，也是歷屆常問的問題。我分別以個人規劃、班級進度下手，說明為什麼我要選擇不顧課業，而是需要用到才學的策略。

2. 你報了幾間學校？

   這個我幾乎沒有聽到有人被問到，不過我就是老實回答，說我報了 7~8 間，但原因我覺得我說得很爛（大概是完全沒想到會問這個的關係），我說因為每間學校各有特色，再加上希望能夠增加能上大學繼續鑽研資訊的機會，所以報了蠻多間的。

3. 我看你好像參加了很多活動，你都是怎麼辦這些活動的阿，有沒有經費來源？

   我們活動大多都是以線上為主，因為這樣就可以不受地域限制，不過也是有辦少數的實體活動，像是今年暑假就有辦實體賽，這方面經費我們是跟精誠資訊合作。

4. 我看了你們營隊的課表，裡面有蠻多演算法的，你們都是怎麼準備這些課程，還有怎麼進行的？

   課程的內容、講義都是全部由我們自己規劃的，我們會利用 LaTeX 這個標記語言，來編纂講義，每堂課幾乎都是超過百頁，需要花十幾個小時來準備。除此之外，我們也準備了上百題的題單給學員們練習，最終學員們都蠻肯定我們的努力，也有一些很不錯的迴響。

心得

1. 在面試之前其實有聽聞歷屆面試教授的問題都沒有問得很深入，所以初審成績可能會超重要。但是這次完全不一樣，從面試簡報開始，其實就有感受到教授們其實蠻認真在聽的，甚至後面的問答感覺也是有備而來，甚至是”看我們的課表”，代表備審的內容有認真看，也有紀錄下來，或許會增加翻盤的機率。

2. 從我蒐集到的面試問題，還有進複試的很多都不是競賽圈常見的人，可以得出一個結論：教授對競賽（不管是哪一種）沒有非常大的興趣，像是我完全沒有被問到競賽相關的問題，其他有參加競賽的人也是一樣，問完非競賽的內容就結束了。反而是一些比較特別的經歷，像是我的活動、營隊，或是有些人有實習、量子演算法的研究等等，這些比較特別的東西才有被問到。看來特選已經無法以單純的競賽成績或是能力去評估好壞了，這或許是一件好事（？

3. 作為第一間面試，在教室外等待的時候其實還蠻緊張的，但進去之後教授看起來都很和善，開始講了之後就不緊張了，甚至比較像是在聊天，蠻愉快的體驗 XD，希望 11/21 放榜後能夠有好結果。

一些小小建議（11/02 UPD）

1. 中央蠻看重在校成績的（尤其是數學），如果你在校成績不好，就盡量不要提到校成績，等教授問再說。同時也要準備好一個好的理由，讓教授能夠接受你在校不好（像我就是說班上進度跟方向不同，然後也有證明自己數理學習能力是算快的，所以才選擇放棄課業）。

2. 中央很看重特殊經歷，雖然競賽固然重要，但那些東西就是看了能夠證明你的水準，不夠特殊的話教授不會有興趣，所以如果你有一些很特別的經歷一定要說。

3. 面試前不要想太多，特殊選才就是這樣，教授喜歡就喜歡，想太多也不會讓教授更喜歡你，所以只要穩穩的把該說的說完，教授問問題時不要亂回答、態度正確就好。

1. 結果已經全部出來，最後會去就讀清大資工
2. 如果你也是今年特選生想要多多認識其他特選生，或是歷屆的學長想要分享經驗，歡迎加入我設立的 2022 特選群，內有今年的交叉查榜表格（之後可能會規劃為跨屆的分享群組）
3. 想認識更多對資訊有興趣的學生，歡迎加入中學資訊討論群
4. 心得整理的部分，都是站在紀錄過程以及讓更多人能夠認識特選的公益性質，所以如果你覺得我的文章對你有幫助，歡迎多多分享！
5. 為避免產生跟去年一樣的爭議，先聲明此系列沒有跟任何營利機構合作

結果（以面試日期排序）

至於為什麼選清大而不是交大呢？簡單來說最主要是因為我認為兩邊其實都足夠好了，而我希望在上大學之後能夠接觸更多不同領域的人或是課程，所以便選了跨領域資源相對豐富的清大。

各校心得

• 11/01 中央資工
• 11/19 成大資工甲組
• 11/25 中山資工
• 12/02 海洋資工
• 12/09 師大資工
• 12/18 清大資工

• 12/21 交大資工

• 學校後面的括號為：面試成績、名額，如有加號代表資安外加名額

• 成績表示方法：我的成績 / 門檻

12/22 更

目前每間都已經面試完了，在面試的過程中其實也收穫了很多，如果有時間的話我會再整理一下最後的心得，或是釋出一些備審資料，希望可以對未來的特選生有幫助。

特選經驗分享

「特選不是一種制度，而是一種態度」

其實在投入社群的過程中，有看到一些學生其實對資訊很有熱忱，但是並不知道特選這個管道，再加上缺少同儕的互相討論，導致不敢很放心地去追逐自己喜歡的東西。因此我希望在下學期能夠有機會到各個高中或是社團分享一下投入特殊選才的經驗，希望藉由我這三年的所見所聞，能夠對一些同學有所幫助。

內容不會全部都是特選，而是偏向於生涯探索，畢竟特選是一個窄門，不見得適合所有學生。我會藉由我的經驗，幫助大家找到適合自己的方向！

如果有學校或是社團有興趣的話，歡迎聯絡我！我的聯絡方式可以在 “關於” 頁中找到（這個計畫是基於公益的，所以不會收取任何的講師費，但畢竟我還是學生，如果可以補助我的交通費我會很感謝的 ><）

祭品文

以拉麵當作籌碼，以下列出正取之後的拉麵數量，如果正取發 $n$ 碗拉麵，那備取上就是 $\lfloor \frac{n}{2} \rfloor$ 碗拉麵，可能會看心情加碼。

• $n=3$：交大資工、清大資工、清大不分系
• $n=2$：成大資工、中央資工
• $n=1$：中山資工、中興資工、師大資工、海大資工
• 目前拉麵數量：$7$（交大備上、清大備上、成大備上、中山正取、海大正取、師大正取、中央備上）

心得文

說實在我能夠踏入特選這條路是真的還蠻神奇的，我在升上高一前沒有學過程式語言，因不知名的原因考進數資班之後，在高一上首次在資訊課上到了 C++ 這個程式語言，也逐漸地產生了興趣。

至於為什麼會將大部分的時間都投入在資訊上呢？這部分其實有一點賭氣的成分。在升上高中之前，我對於高中數資班的想像大概是能夠有更多的時間進行科學研究或是自主學習，但實際就讀之後發現不一樣，或許是升學考試緊迫的緣故，數資的課程大多都圍繞在學習大考會考的知識居多。很快的我便發現這樣的環境並不是很適合我，也逐漸的沒辦法在學科上提起勁。為了不要變成一個什麼都很爛的人，我便開始將重心轉往了更有興趣的資訊這條路，也恰巧數資的資訊課比較難，也算是間接的推動我探索更多的資訊領域，真的很幸運能夠遇見高中的資訊老師。

但很快的，我發現我們班（我們學校也是），對於程式有興趣的人非常少。一面是嘉義沒什麼機會接觸，另一方面是嘉義也不太注重生涯探索，導致學生們大多會將大部分的精力投入在學科上。因此我跟一位同學共同創立了 CISC 中學資訊討論群，希望能夠透過社群的力量，將各地對資訊有興趣的人都聚集起來，透過討論的方式，不僅增進彼此的能力，同時也能夠達成資源的流動。經過了兩年多的努力，目前群組已經達到了 2500 人，雖然還不是很完美，但至少也或多或少的幫助了不少人，算是有達成當時的期許吧。

在之後的時間，我投入了大量的時間參與社群討論，也因此學到了不少東西、認識許多電神。在參與社群討論的過程，我看見了各種領域的佼佼者，甚至發現「學科」在這個圈子裡面似乎沒有那麼被重視。或許是資訊本身或是其所需的知識，本來就跟傳統學科有所差異，再加上資訊領域的廣大與快速更迭，因此相較於被課綱綁死的高中學科，要在這個圈子活下去更重要的是自學、邏輯、專業知識等更實際的能力，在學習新知識上也經常是「用到再學」的路線，可說是看見了另外一個世界。正因為如此，這讓我不禁思考，我真的得讀這些東西嗎？我如果已經有明確的方向，那麼將精力放在自己想學的東西上，是不是對我來說更有幫助？而這也促使了我之後踏上了特選這條路。

「相信一定也有很多人跟我一樣，對資訊很有興趣但是資源不足、不知道怎麼學習」，憑藉著在腦中不斷迴盪的這句話，在累積了一些實力之後，我開始大量的投入社群貢獻。像是擔任 NHDK、SCIST 的總召，舉辦比賽、課程甚至是營隊，後來也協助推動了資訊之芽在南部的課程。老實說投入這些事情的過程並不是過得很順利，除了需要大量的時間投入之外，在處理很多事務上也會因能力及經驗不足導致做得不是很好，甚至需要學長的幫忙才能夠解決，再加上各種事情幾乎都會撞在一起，導致我的心理狀況真的很差，每天幾乎都在懷疑自己，也沒辦法花費很多時間或心力在競程或是其他事情上。我會後悔嗎？其實不會，雖然因此犧牲了一些東西，但在過程中我也收穫了不少、得到了很多獨特的經驗，如果再來一次我應該也是會做一樣的選擇吧。

老實說當時在決定投入特選時，並沒有設定說一定要上哪裡，或是以我的經歷應該要上哪，畢竟資工本來就很吃自學，所以不必對學校有太大的得失心（當然還是有個目標啦，只不過我是以這樣的心態來面對的，也不會太緊張）。很多人會害怕面試，擔心教授會像在審問你，但其實不用擔心，面試其實就是教授在透過對談確立你的人格特質，以及了解你的備審內容，所以在面對教授時只需要以一個輕鬆聊天的心態來面對，問什麼就認真回答，展現自己就好，反正那些內容也都會是你實際做過的，所以也不用太擔心。

或許有人好奇，特選到底要看什麼，是學術能力嗎？還是比賽成績？其實都不完全正確，而是「潛力」（這是在與各校教授對談以及實際詢問部分教授後得出的結論），清大的一位教授提到：「你這裡的時間那麼短，我們其實沒有辦法直接看出你的能力如何，我們能做的就只有從你的表現中評估你的潛力，或是進來到我們系學習之後會有怎樣的成就」，可見即使有著很好的學術能力或是比賽成績，如果沒有辦法在備審或是面試中傳達給教授、讓教授看見你的未來，那麼一切也只是白談。

回顧高中三年，大概可以用兩個字「如果」來代表吧。如果我沒考上數資班、如果我沒有讀不下書、如果我們沒有創立群組、如果沒有許多學長們的提攜、但凡任意一個如果沒有成真，或許我都不會踏上特選這條路，更別說錄取清交了。

我認為特選最寶貴的並不是制度，而是精神。特選這條路真的很不好走，除了要有足夠的興趣與熱忱之外，還需要承擔特選所帶來的超大風險、旁人的質疑等壓力，而這也造就了特選生們總是有著「無所畏懼、朝著自己的理想前進」的精神。或許不是人人都能夠透過特選這條道路升學，但這並不妨礙我們追尋自己的理想呀！在現今注重考試成績、學歷的環境下，有不少學生都因此忘記思考了「自己究竟要的是什麼？」，希望大家在為升學努力的同時，也不要忘記自己的理想，保持著初衷向前邁進！

我深知自己不是天才型的學生，無論是經歷還是能力，都有很多人比我更強，但也因為如此，讓我的高中生活多了一番風采，也比別人多出了不少不一樣的經驗。在社群參與的過程中，我發現到有很多學生其實是保有著一顆有如特選生一般努力追求理想的心，但並不知道相關制度，或是不確定自己的努力是否會看到成果。因此我希望有機會的話，能夠到其他學校或是社團辦理經驗分享的免費講座，將自己高中三年的所見所聞分享出來，看能不能幫助到更多人，同時也認識更多臺灣各地的朋友。如果有人有興趣的話都可以聯絡我，應該會以資訊向為主軸，但如果是全面向的我也會試著準備看看。

如果有人好奇我的備審長怎樣，或是希望獲得一些靈感的話，我將我清大的備審公開出來，希望能夠幫助到別人！（也可以幫我按個星星 ouob）
https://github.com/Koyingtw/spec-share

以下是 QA 中比較多人問到的問題：

1. 甚麼時候確定要特選的：高一時有聽說 APCS 跟特選這兩個管道，不過因為我是高中才碰程式，我覺得我應該沒辦法跟一些北部的人競爭，所以原先的目標其實是 APCS 組（畢竟只看自然數學英文，而自然數學這兩科我沒有認真讀應該也都能考 10 級以上）。但後來我發現我好像應該專注在某一邊，才能發揮更好的效果，所以萌生了特選的想法。但由于還沒有實績，所以其實很擔心最後兩邊都很爛（這也導致了我心理狀態很不穩定，經常荒廢了一段時間），最後是到二上能力競賽，進了全國之後才真正確定要特選（而全國爛掉又是另外一回事了）。
2. 關於在校成績的相關問題：特選本質上不看在校成績，因為特選的宗旨是給那些有特殊才能或是逆境向上的學生升學的，所以基本上只看你的備審，也就是上面提到的潛力。但畢竟入學之後還是要上大學的課，所以教授會利用你的在校成績評估你進到大學之後是否能夠負擔基本的課業。至於放掉學科的話，如果是國文、社會這些放掉基本上是沒影響，不過如果是數學英文這些我建議是謹慎考慮，不要隨便就不讀。
3. 特選要準備什麼：這個可以去看各校的簡章，都會說明得很清楚。至於面試嘛，我自己是完全沒有準備，也沒有找別人模擬面試，就當做是一般的訪談跟教授聊天。當然每個人狀況也有所不同，如果真的擔心表現不好的話，可以先預想一些問題，或是找人模擬面試（這同樣適用於個申）。
4. 如果特選沒上怎麼辦：在特選前我是有經過簡單的評估，認為自己應該排在第 10 ~ 20 名這個區間，中字輩甚至是成大應該都是很有機會，所以我是沒有很擔心最後沒上。當時告訴自己，如果真的沒上的話，那其實也沒關係，反正資工的東西很多也是自學，網路上也能夠找到很多資源，相信我只要充實自己的能力，那未來還是有無限可能。雖說我的心態是這樣，但同樣的我不推薦大家抱持著這樣的心態，盡量還是幫自己留個後路會比較好，除非你真的有辦法負荷這個風險。

如果還有其他問題想問的，我的 QA 表單一樣會開著，如果之後有機會到其他地方分享我可能會再回答吧，希望這篇文章能夠幫助到你！

題敘

有一個無向圖 $(n \le 2000, m \le \frac{n \cdot (n-1)}{2})$ ，求有幾個點對 $(u, v)$，將其移除之後此圖不連通。

解法

核心概念是：枚舉 $u$，然後將剩下的圖跑 Tarjan’s Find AP Algorithm，找到的 AP 就會是 $v$。除此之外，原圖中任兩個 AP 刪除也會是合法的點對。

但是這樣會有一個問題，就是它有可能是一個完全圖，這會導致我們跑一次 Tarjan’s 時的複雜度來到 $\mathcal{O}(n^2)$，而我們跑 $n$ 次 Tarjan’s 的複雜度就會來到 $\mathcal{O}(n^3)$。

這時候就得拿出一個超酷的縮邊技巧了（據說是選訓教授教的），我們可以對原圖做三次 BFS，其中三次 BFS 所用的邊皆不重複，然後接下來的 Tarjan’s 通通都用這三個 BFS 生成樹所使用的邊去找，就可以將單次 Tarjan’s 的複雜度壓到 $\mathcal{O}(n)$ 了。至於這樣做為什麼會對我也還看不懂，不過 Wiwihorz 有將證明過程放在這裡，有興趣的可以去看看。

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

#define MAXN 2005
#define MAXM 1000005 
int n, m;
vector<int> G[MAXN];
vector<pii> g[MAXN];
vector<pii> E;
bitset<MAXN * MAXN> used;
bool ans[MAXN][MAXN];

struct Tarjan_AP {
    int low[MAXN], dep[MAXN], timestamp = 0;
    bitset<MAXN> isAP;
    vector<int> AP;

    void dfs(int i, int fa, int rm) {
        dep[i] = low[i] = ++timestamp;
        int chdcnt = 0;

        for (int e: G[i]) {
            if (e == rm)
                continue;

            if (!dep[e] || dep[e] > timestamp) {
                dfs(e, i, rm);
                chdcnt++;
                cmin(low[i], low[e]);
                if (low[e] >= dep[i])
                    isAP[i] = true;
            }
            cmin(low[i], dep[e]);
        }

        if (i == fa && chdcnt < 2)
            isAP[i] = false;
        if (isAP[i])
            AP.pb(i);
    }

    void main(int rm) {
        timestamp = 0;
        MEM(dep, 0);
        isAP.reset();
        AP.clear();

        dfs(rm % n + 1, rm % n + 1, rm);
    }
} AP;


void sol() {
    cin >> n >> m;
    for (int i = 0, a, b; i < m; i++) {
        cin >> a >> b;
        g[a].pb({b, i});
        g[b].pb({a, i});
        E.pb({a, b});
    }


    for (int i = 0; i < 3; i++) {
        bitset<MAXN> vis;
        for (int j = 1; j <= n; j++) {
            if (vis[j])
                continue;
            queue<int> q;
            q.push(j);
            vis[j] = true;

            while(q.size()) {
                auto now = q.front();
                q.pop();
                for (auto e: g[now]) {
                    if (used[e.S] || vis[e.F])
                        continue;
                    q.push(e.F);
                    vis[e.F] = true;
                    used[e.S] = true;
                }
            }
        }
    }

    for (int i = 0; i < m; i++) {
        if (!used[i])
            continue;
        G[E[i].F].pb(E[i].S);
        G[E[i].S].pb(E[i].F);
    }

    int cnt = 0;

    AP.main(0);
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j < i; j++) {
            if (AP.isAP[j] && AP.isAP[i]) {
                cnt += !ans[j][i];
                ans[j][i] = true;
            }
        }
    }


    for (int i = 1; i <= n; i++) {
        AP.main(i);
        for (int it: AP.AP) {
            cnt += !ans[min(it, i)][max(it, i)];
            ans[min(it, i)][max(it, i)] = true;
        }
    }

    cout << cnt << endl;
}