qwq
為SCP初賽選手（我）收集的各種定理qwq
更新：
1、為了初賽都能用，不限於定理了
2、主旨為在短時間內復習各算法，備初賽
3、請確定你學習（學懂了）了 \(\texttt{oi}\) 的基礎知識。
可能會一直更新下去qwq
最新：2021/9/11 10:03
@
1、主定理
在求某一分治（遞推？）算法時間復雜度中適用。
規模為 \(n\) 的問題通過分治，得到 \(a\) 個規模為 \(\dfrac{n}{b}\) 的問題，每次遞歸帶來的額外計算為 \(O(n^d)\)
即 \(T(n)=aT(\dfrac{n}{b})+O(n^d)\)。
求執行 \(T(n)\) 的時間復雜度。
定理：
若 \(a=b^d\)，\(T(n) = O(n^d \log{n})\)
若 \(a<b^d\)，\(T(n) = O(n^d)\)
若 \(a>b^d\)，\(T(n) = O(n^{\log_ba})\)
套就完事兒了 證明請bdfs
2、等比數列
指一個數列所有數有公共比。
比如：\(1\)，\(2\)，\(4\)，\(8\)，\(...\)
此時公比為 \(2\)。
等比數列通項公式為
\(a_1\) 即為數列首項，\(q\) 就是公比。
比如說，求上面那個等比數列的第五個數。
\(a_5=1\times (2^{5-1})\)
求得 \(a_5=16\)。
根據通項公式，我們可以輕松得到前 \(n\) 項的求和公式。
還是比如：求上面那個數列的前五項之和。
\(S_5=\dfrac{1\times (2^5-1)}{2-1}\)
求得 \(S_5=31=1+2+4+8+16\)。
至於推導嘛，它來了！
2.1 等比數列求和公式推導
首先，先將通項公式列出來。
提 \(a_1\)。
添一個 \((q-1)\)。
乘開，
消掉一大堆，
此時要求 \(q\neq 0\) 且 \(q\neq 1\)
最終得到
應用嘛，其實很廣的。
2.2 應用：h層滿k叉樹求節點個數
第 \(0\) 層 \(k^0\) 個；
第 \(1\) 層 \(k^1\) 個；
第 \(2\) 層 \(k^2\) 個；
第 \(3\) 層 \(k^3\) 個；
...
第 \(h\) 層 \(k^h\) 個。
這不就等比數列嗎。上求和公式！
\(N=\dfrac{k^{h+1}-1}{k-1}\)
注意！ 這里其實有 \(h+1\) 層，所以為什么是 \(h+1\)。
題目鏈接：Noip2018提高 - 第四題
3、貪心
貪心算法（英語：greedy algorithm），是用計算機來模擬一個 “貪心”的人 做出決策的過程。這個人十分貪婪， 每一步行動總是按某種指標選取最優的操作。 而且他目光短淺，總是只看眼前，並不考慮以后可能造成的影響。
可想而知，並不是所有的時候貪心法都能獲得最優解，所以一般使用貪心法的時候，都要確保自己能證明其正確性。
——Copy by OI-WIKI
從中可以看出，貪心所講究的，是思維的 貪度和正確，二者一樣重要。 （貪度，即為貪心的層次，越貪心，貪度越高 我瞎掰扯的， 理解就好）
首先，貪度的提高並不是一次思考就能完成的。
就好比時間復雜度需要一步步優化。
貪心的主要內容，證明等皆在OI-Wiki中有講述，可以到oi-wiki找到詳細的講述。
4、二分
二分，可以理解為分成兩半。在二分基礎應用中，二分是用來在一 有序 數列中尋找數的快速方法。
注：必須有序！
比如，\(V=\{1,2,3,3,5\}\)
我需要在 \(V\) 中尋找第一個比 \(a\) 大於（等於）的數。
比如說 \(a=3\)，則找到的數下標為 \(3\)。
4.1 基本實現
1、令 \(\texttt{l}=1,\texttt{r}=|V|.\)
2、又令 \(\texttt{mid}=(l+r)/2.\)
3、對於 \(V_{mid}\)，
若 \(V_{mid}\leq a\)，因為整體有序，所以 \(a\) 一定在 \(\texttt{mid}\) 左邊（或它本身）。
這里等於號放在這里，是因為即使等於了，第一個說不定還在前面。
若 \(V_{mid}< a\)，同理，\(a\) 一定在 \(\texttt{mid}\) 右邊。
持續進行步驟二和步驟三，當 \(l=r\) 時，就找到了。
這就是最基本的實現。
實現代碼：（arr為有序序列）
int binary_search(int start, int end, int key) {
int ret = -1; // 未搜索到數據返回-1下標
int mid;
while (start <= end) {
mid = start + ((end - start) >> 1); // 直接平均可能會溢出，所以用這個算法
if (arr[mid] <= key)
start = mid + 1;
else if (arr[mid] > key)
end = mid - 1;
}
return ret; // 單一出口
}
4.2 進階實現
首先，二分一般實現於最值最化。
簡化最值最化的要求：
1、答案在一個固定區間內；
2、查找不容易，判斷容易（比如說找數）；
3、可行解對於區間滿足一定的單調性。
如果一個數組中的左側或者右側都滿足某一種條件，而另一側都不滿足這種條件，也可以看作是一種有序（如果把滿足條件看做 ，不滿足看做 ，至少對於這個條件的這一維度是有序的）
這就是指某一個數組的左邊 或 右邊都滿足某一條件，即單調性
可以理解為上上上上面的例子中， V[3] 左邊都滿足小於 3 這個條件。
4.3 實際應用
見二分答案
5、三分（待填坑）
6、哈希
對於初賽來說，只需理解哈希函數以及哈希碰撞即可。
哈希列表的概念是差不多的
哈希函數 & 哈希碰撞
簡單來說，就是將某一難處理的數值、字符串通過某一處理函數處理成簡單的數字。
看例子就可以學懂了：
設哈希函數為：\(H(x)=\lfloor x/5\rfloor\)，
則 \(1\) 的哈希值為 \(H(1)=0\)，\(2\) 的哈希值也為 \(H(2)=0\)。
此時 \(1\) 和 \(2\) 的哈希值相同，有同樣的哈希值保存，會導致碰撞，稱為哈希碰撞
7、KMP（待填坑）
8、最小生成樹（待填坑）
9、最短路
這里只講 Floyd，Dijkstra，SPFA
提醒： 除了 Floyd 算法以外，都建議使用鄰接表。鄰接矩陣時間復雜度為O(n^2)，等同於沒優化
9.1 Floyd
時間復雜度：\(O(n^3)\)
評價：最簡單的最短路算法，最高的時間復雜度，最划算的多源最短路。
注意事項：中間節點k一定要放在最外層，至於后果，需按數據手推（
思路：一一枚舉每兩個點的最短路。
樣例代碼：
cin>>n>>m;
memset(f,63,sizeof(f));
for(int i=1;i<=m;i++)
{
cin>>x>>y>>dist;
f[x][y]=dist;
}
//Floyd
for(int k=1;k<=n;k++)
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
f[i][j]=min(f[i][j],f[i][k]+f[k][j]);
9.2 Dijkstra
時間復雜度：
在稀疏圖中，使用二叉堆實現的 Dijkstra 法的 \(O((n+m)\log n)\) 即 \(O(m\log n)\) 較 Bellman-Ford (SPFA) 算法的 \(O(nm)\) 具有較大的效率優勢；
而在稠密圖中，這時候使用暴力做法 \(O(n^2+m)\) 較二叉堆實現更優。
但一般只使用優先隊列法 \(O(m\log m)\) ，代碼最清晰簡短，但時間復雜度在稀疏圖上比二叉堆略差。
評價：十分經典的單源最短路，在單源最短路中時間復雜度最強，但不能處理負環。各種方法形成不同的時間復雜度，容易考到。
注意事項：不能處理負環！
思路：推薦這篇博客
樣例代碼：
struct edge {
int v, w;
};
struct node {
int dis, u;
bool operator>(const node& a) const { return dis > a.dis; }
};
vector<edge> e[maxn]; //方便的鄰接表？
int dis[maxn], vis[maxn];
priority_queue<node, vector<node>, greater<node> > q;
//優先隊列，其實可以直接priority_queue<node> q;
void dijkstra(int n, int s) {
memset(dis, 63, sizeof(dis));
dis[s] = 0;
q.push({0, s});
while (!q.empty()) {
int u = q.top().u;
q.pop();
if (vis[u]) continue;
vis[u] = 1;
for (auto ed : e[u]) { //C++11新語法，建議沒見過的bdfs
int v = ed.v, w = ed.w;
if (dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
q.push({dis[v], v});
}
}
}
}
對於上面 vector<edge> e[maxn]，是鄰接表的一種實現，內存消耗是動態的，並且最方便，但時間復雜度 可能 偏高。
9.3 SPFA
時間復雜度：隨機數據中表現優秀，但平均時間復雜度為 \(O(nm)\)。
評價：最好理解的最短路，最容易Cu卡爆的最短路。
注意事項：能處理負環。
思路：有點類似BFS，是BF的隊列優化版本。
樣例代碼：
struct edge {
int v, w;
};
vector<edge> e[maxn];
int dis[maxn], cnt[maxn], vis[maxn];
queue<int> q;
bool spfa(int n, int s) {
memset(dis, 63, sizeof(dis));
dis[s] = 0, vis[s] = 1;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop(), vis[u] = 0;
for (auto ed : e[u]) {
int v = ed.v, w = ed.w;
if (dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
cnt[v] = cnt[u] + 1; // 記錄最短路經過的邊數
if (cnt[v] >= n) return false;
// 在不經過負環的情況下，最短路至多經過 n - 1 條邊
// 因此如果經過了多於 n 條邊，一定說明經過了負環
if (!vis[v]) q.push(v), vis[v] = 1;
}
}
}
return true;
}
-by oi-wiki
10、位運算
這位大佬的博客
寫的不好，勿噴