藍橋杯突擊復習准備——部分算法匯總
一、一些庫函數
lower_bound(a,a+n,x)
//二分查找，查找大於或等於x的第一個位置，只能查找vector<>數組，返回值為vector<>::iterator指針
unique(vector1.begin(),vector1.end())
//重排元素，使得所有值提前，返回值為重排后最后一個非重復值的后面的值的迭代器，即從返回值到vector1.end()是無意義的值，也是重復值的總數量
reverse(vector1.begin(),vector1.end())
//反轉元素順序
next_permutation(p,p+n)
//求下一個全排列，枚舉用
#include <vector> 數組
定義示例：vector<int> b(5);或者vector<int> a;
賦值：b[0]=1;只有第一種定義可以這樣賦值
函數：
int size()，獲取大小
void resize(int num)，改變大小
void push_back(int x)，向尾部添加元素
void pop_back()，刪除最后一個元素
void clear()，清空
bool empty()，檢查是否為空
iterator insert(iterator x,y)，向vector數組的x位置插入元素y，x可以為v.begin()+2
iterator erase(iterator x)，刪除vector數組的x位置元素
iterator begin()，返回頭指針
iterator end()，返回尾指針
vector<>::iterator為一個可以指向其元素的指針
#include <set> 集合，其中不含重復元素，且其中元素已從小到大排序，從1開始
定義示例：set<int> a;
函數：
int size()，獲取大小
iterator find(x)，若找到x，返回該鍵值迭代器的位置，否則，返回最后一個元素后面一個位置，即s.end()
void clear()，清空
bool empty()，檢查是否為空
iterator insert(y)，向set集合插入元素y
iterator erase(iterator x)，刪除set集合的值為x的元素，返回值為下一個位置的迭代器
iterator begin()，返回頭指針
iterator end()，返回尾指針
set<>::iterator為一個可以指向其元素的指針
#include <map> 映射，索引
定義示例：map<string,int> month_name;
賦值：map[“July”]=7;
函數：
iterator find(y)，尋找索引值為y的元素，返回指向其的指針
iterator insert(map<string,int>(“July”,7))，向map映射插入元素(“July”,7)
iterator erase(iterator x)，刪除map映射的迭代器x的元素
map< string,int>::iterator l_it;;
l_it=m.find(“July”);
if(l_it==m.end())
cout<<"we do not find July"<<endl;
else m.erase(l_it); //delete July;
iterator begin()，返回頭指針
iterator end()，返回尾指針
map<>::iterator為一個可以指向其元素的指針
#include <string>
string substr(int pos = 0,int n = npos) const; //返回pos開始的n個字符組成的字符串
void swap(string &s2); //交換當前字符串與s2的值
string &insert(int p0, const char *s); //在p0位置插入字符串
string &erase(int pos = 0, int n = npos); //刪除pos開始的n個字符，返回修改后的字符串
int find(char c, int pos = 0) const; //從pos開始查找字符c在當前字符串的位置
int find(const char *s,int pos = 0) const; //從pos開始查找字符串s在當前串中的位置
二、算法
1.並查集
int p[N]; //存儲每個點的祖宗節點
// 返回x的祖宗節點
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
// 初始化，假定節點編號是1~n
for (int i = 1; i <= n; i ++ ) p[i] = i;
// 合並a和b所在的兩個集合：
p[find(a)] = find(b);
練習：POJ-2236（AC代碼）
2.二分查找
整數二分算法模板
// 檢查x是否滿足某種性質
bool check(int x) {
/* ... */
}
// 區間[l, r]被划分成[l, mid]和[mid + 1, r]時使用：
int bsearch_1(int l, int r) {
while (l < r) {
int mid = l + r >> 1;
if (check(mid)) r = mid; // check()判斷mid是否滿足性質
else l = mid + 1;
}
return l;
}
// 區間[l, r]被划分成[l, mid - 1]和[mid, r]時使用：
int bsearch_2(int l, int r) {
while (l < r) {
int mid = l + r + 1 >> 1;
if (check(mid)) l = mid;
else r = mid - 1;
}
return l;
}
浮點數二分算法模板
bool check(double x) {/* ... */} // 檢查x是否滿足某種性質
double bsearch_3(double l, double r)
{
const double eps = 1e-6; // eps 表示精度，取決於題目對精度的要求
while (r - l > eps)
{
double mid = (l + r) / 2;
if (check(mid)) r = mid;
else l = mid;
}
return l;
}
3.快速排序算法模板
void quick_sort(int a[], int l, int r)
{
if(l >= r) return ;
int i = l - 1, j = r + 1, x = a[l + r >> 1];
while(i < j)
{
do i++; while(a[i] < x);
do j--; while(a[j] > x);
if(i < j)
swap(a[i], a[j]);
}
quick_sort(a, l, j);
quick_sort(a, j + 1, r);
}
//a[]數組下標從1開始
4.歸並排序算法模板
//a[]是待排序的數組，tmp[]在排序過程中起到暫時存儲的作用
void merge_sort(int a[], int l, int r)
{
if(l >= r) return ;
int mid = l + r >> 1;
merge_sort(a, l, mid);
merge_sort(a, mid + 1, r);
int i = l, j = mid + 1, k = 0;
while(i <= mid && j <= r)
{
if(a[i] <= a[j])
tmp[k++] = a[i++];
else
tmp[k++] = a[j++];
}
while(i <= mid)
tmp[k++] = a[i++];
while(j <= r)
tmp[k++] = a[j++];
i = l, j = 0;
while(i <= r)
a[i++] = tmp[j++];
}
關於歸並排序，可以用它去求逆序對數目，例如【POJ - 2299】(AC代碼)
5.背包問題
01背包問題
//二維
int N, V;
int v[maxn], w[maxn];
int f[maxn][maxn];
int main()
{
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
cin >> N >> V;
for(int i = 1; i <= N; i++)
cin >> v[i] >> w[i];
memset(f, 0, sizeof(f));
for(int i = 1; i <= N; i++)
for(int j = 0; j <= V; j++)
{
f[i][j] = f[i-1][j];
if(j >= v[i])
f[i][j] = max(f[i][j], f[i-1][j-v[i]] + w[i]);
}
int maxx = 0;
for(int i = 0; i <= V; i++)
maxx = max(maxx, f[N][i]);
cout << maxx << endl;
}
//一維
int N, V;
int v[maxn], w[maxn];
int f[maxn];
int main()
{
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
cin >> N >> V;
for(int i = 1; i <= N; i++)
cin >> v[i] >> w[i];
for(int i = 1; i <= N; i++)
{
for(int j = V; j >= v[i]; j--)
f[j] = max(f[j], f[j-v[i]] + w[i]);
}
cout << f[V] << endl;
}
完全背包問題(每種物品都有無限件可用)
//從小到大遍歷
int N, V;
int f[maxn];
int main()
{
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
cin >> N >> V;
for(int i = 0; i < N; i++)
{
int v, w;
cin >> v >> w;
for(int j = v; j <= V; j++) //從小到大遍歷
f[j] = max(f[j], f[j-v] + w);
}
cout << f[V] << endl;
}
int N, V;
int v[maxn], w[maxn];
int f[maxn];
int main()
{
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
cin >> N >> V;
for(int i = 1; i <= N; i++)
cin >> v[i] >> w[i];
for(int i = 1; i <= N; i++)
{
for(int j = V; j >= v[i]; j--) //從大到小遍歷
{
for(int k = 0; k * v[i] <= j; k++)
f[j] = max(f[j], f[j-k*v[i]] + k*w[i]);
}
}
cout << f[V] << endl;
}
6.LIS最長上升子序列
狀態轉移方程：
//用下面一行狀態轉移方程的解法的時間復雜度為O(n*n),n為a數組的長度
f[i]先初始化為1
f[i]=max(f[i],f[j]+1) (j>=0&&j<i,a[j]<a[i])
當然，上面這個狀態轉移方程不適用於a數組長度較大的情況。比如AcWing896. 最長上升子序列 II （AC代碼，思路在代碼中）
7.LCS最長公共子序列
狀態轉移方程：
//f[i][j] 表示 a[1~i] 和 b[1~j] 的最長公共子序列
f[i][j]=max(max(f[i-1][j],f[i][j-1]),f[i-1][j-1]+1(a[i]=b[j]))
練習：
樹與圖的存儲及遍歷
樹是一種特殊的圖，與圖的存儲方式相同。
對於無向圖中的邊ab，存儲兩條有向邊a->b, b->a。
因此我們可以只考慮有向圖的存儲。
(1) 鄰接矩陣：$$g[a][b]$$ 存儲邊a->b
(2) 鄰接表：
// 對於每個點k，開一個單鏈表，存儲k所有可以走到的點。h[k]存儲這個單鏈表的頭結點
int h[N], e[N], ne[N], idx;
// 添加一條邊a->b
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
// 初始化
idx = 0;
memset(h, -1, sizeof h);
樹與圖的遍歷
(1) 深度優先遍歷 —— 模板題 AcWing 846. 樹的重心
int dfs(int u)
{
st[u] = true; //st[u]表示點u已經被遍歷過
for(int i = h[u], i != -1; i = ne[i])
{
int j = e[i];
if(!st[j])
dfs(j);
}
}
(2) 寬度優先遍歷 —— 模板題 AcWing 847. 圖中點的層次
queue<int> q;
st[1] = true; //表示1號點已經被遍歷過
q.push(1);
while(q.size())
{
int t = q.front();
q.pop();
for(int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if(!st[j])
{
st[j] = true; //表示點j已經被遍歷過
q.push(j);
}
}
}
8.Dijkstra最短路徑算法(不適用於有負邊權的圖)
朴素dijkstra算法 — 模板題 AcWing 849. Dijkstra求最短路 I
時間復雜度 $$ O({n^2} + m) $$ , n表示點數
該算法對於n比較大的時候就不適用了，可以考慮在下一個堆優化版dijkstra。
const int inf = 0x3f3f3f3f;
int g[N][N]; // 存儲每條邊
int dist[N]; // 存儲1號點到每個點的最短距離
bool st[N]; // 存儲每個點的最短路是否已經確定
// 求1號點到n號點的最短路，如果不存在則返回-1
int dijkstra()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
for (int i = 0; i < n - 1; i ++ )
{
int t = -1; // 在還未確定最短路的點中，尋找距離最小的點
for (int j = 1; j <= n; j ++ )
if (!st[j] && (t == -1 || dist[t] > dist[j]))
t = j;
// 用t更新其他點的距離
for (int j = 1; j <= n; j ++ )
dist[j] = min(dist[j], dist[t] + g[t][j]);
st[t] = true;
}
if (dist[n] == inf) return -1;
return dist[n];
}
堆優化版dijkstra — 模板題 AcWing 850. Dijkstra求最短路 II
時間復雜度 $$O(mlogn)$$ ,n表示點數，m表示邊數
typedef pair<int, int> PII;
int n; // 點的數量
int h[N], w[N], e[N], ne[N], idx; // 鄰接表存儲所有邊, e[]是權重
int dist[N]; // 存儲所有點到1號點的距離
bool st[N]; // 存儲每個點的最短距離是否已確定
// 求1號點到n號點的最短距離，如果不存在，則返回-1
int dijkstra()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
priority_queue<PII, vector<PII>, greater<PII>> heap;
heap.push({0, 1}); // first存儲距離，second存儲節點編號
while (heap.size())
{
auto t = heap.top();
heap.pop();
int ver = t.second, distance = t.first;
if (st[ver]) continue;
st[ver] = true;
for (int i = h[ver]; i != -1; i = ne[i])
{
int j = e[i];
if (!st[j] && dist[j] > distance + w[i])
{
dist[j] = distance + w[i];
heap.push({dist[j], j});
}
}
}
if (dist[n] == inf) return -1;
return dist[n];
}
9.Floyd算法
floyd算法 — 模板題 AcWing 854. Floyd求最短路
時間復雜度是 $$O({n^3})$$, n 表示點數
初始化：
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= n; j ++ )
if (i == j) d[i][j] = 0;
else d[i][j] = INF;
// 算法結束后，d[a][b]表示a到b的最短距離
void floyd()
{
for (int k = 1; k <= n; k ++ )
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= n; j ++ )
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
10.最小生成樹Prim算法
朴素版prim算法 — 模板題 AcWing 858. Prim算法求最小生成樹
時間復雜度是 $$O({n^2} + m)$$ , n表示點數，m表示邊數。
int n; // n表示點數
int g[N][N]; // 鄰接矩陣，存儲所有邊
int dist[N]; // 存儲其他點到當前最小生成樹的距離
bool st[N]; // 存儲每個點是否已經在生成樹中
// 如果圖不連通，則返回INF(值是0x3f3f3f3f), 否則返回最小生成樹的樹邊權重之和
int prim()
{
memset(dist, 0x3f, sizeof dist);
int res = 0;
for (int i = 0; i < n; i ++ )
{
int t = -1;
for (int j = 1; j <= n; j ++ )
if (!st[j] && (t == -1 || dist[t] > dist[j]))
t = j;
if (i && dist[t] == INF) return INF;
if (i) res += dist[t];
st[t] = true;
for (int j = 1; j <= n; j ++ ) dist[j] = min(dist[j], g[t][j]);
}
return res;
}
11.最小生成樹Krusal算法
Kruskal算法 — 模板題 AcWing 859. Kruskal算法求最小生成樹
時間復雜度是 $$O(mlogm)$$ , n表示點數，m表示邊數。
int n, m; // n是點數，m是邊數
int p[N]; // 並查集的父節點數組
struct Edge // 存儲邊
{
int a, b, w;
bool operator< (const Edge &W)const
{
return w < W.w;
}
}edges[M];
int find(int x) // 並查集核心操作
{
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
int kruskal()
{
sort(edges, edges + m);
for (int i = 1; i <= n; i ++ ) p[i] = i; // 初始化並查集
int res = 0, cnt = 0;
for (int i = 0; i < m; i ++ )
{
int a = edges[i].a, b = edges[i].b, w = edges[i].w;
a = find(a), b = find(b);
if (a != b) // 如果兩個連通塊不連通，則將這兩個連通塊合並
{
p[a] = b;
res += w;
cnt ++ ;
}
}
if (cnt < n - 1) return INF;
return res;
}
12.拓撲排序
拓撲排序 — 模板題 AcWing 848. 有向圖的拓撲序列
時間復雜度為$$ O(n+m)$$ , n表示點數，m表示邊數
bool topsort()
{
int hh = 0, tt = 0;
//d[i]存儲點i的入度
for(int i = 1; i <= n; i ++)
{
if(d[i] == 0)
que[tt++] = i;
}
while(hh < tt)
{
int t = que[hh++];
for(int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
d[j]--; //上一個節點被刪除，那么它下一個點入度就減1
if(!d[j])
que[tt++] = j;
}
}
// 如果所有點都入隊了，說明存在拓撲序列；否則不存在拓撲序列。
if(tt == n)
return true;
return false;
}
13.快速冪
求 m^k mod p，時間復雜度 O(logk)。
int qmi(int m, int k, int p)
{
int res = 1 % p, t = m;
while (k)
{
if (k&1) res = res * t % p;
t = t * t % p;
k >>= 1;
}
return res;
}
14.線性篩法求素數
int primes[N], cnt; // primes[]存儲所有素數
bool st[N]; // st[x]存儲x是否被篩掉
void get_primes(int n)
{
for (int i = 2; i <= n; i ++ )
{
if (st[i]) continue;
primes[cnt ++ ] = i;
for (int j = 0; primes[j] <= n / i; j ++ )
{
st[primes[j] * i] = true; //primes[j]一定是primes[j]*i的最小質因子
if (i % primes[j] == 0) break; //滿足這個條件時說明primes[j]一定是i的最小質因子，也一定是primes[j]*i的最小質因子
}
}
}
15.KMP
KMP —— 模板題 Acwing 831.KMP字符串
// s[]是長文本，p[]是模式串，n是s的長度，m是p的長度
//求模式串的Next數組：
for (int i = 2, j = 0; i <= m; i ++ )
{
while (j && p[i] != p[j + 1]) j = ne[j];
if (p[i] == p[j + 1]) j ++ ;
ne[i] = j;
}
// 匹配
for (int i = 1, j = 0; i <= n; i ++ )
{
while (j && s[i] != p[j + 1]) j = ne[j];
if (s[i] == p[j + 1]) j ++ ;
if (j == m)
{
j = ne[j];
// 匹配成功后的邏輯
}
}
三、比賽時注意規范(對於選擇C或C++語言的選手)
1.long long的輸入輸出
//在藍橋杯里面long long 的輸入輸出：
long long a;
scanf("%I64d",&a);
printf("%I64d",a);
//或者
cin >> a;
cout << a;
2.可以使用萬能頭文件
#include<bits/stdc++.h>
3.最后不要忘記return 0
4.藍橋杯最大棧空間為256MB，也就是說你最大可以開1e7的數組空間
5.各種數據類型數據范圍
unsigned int 0～4294967295 // 9及以下位數都可裝
int -2147483648～2147483647 // 9及以下位數都可裝
unsigned long 0～4294967295 // 9及以下位數都可裝
long -2147483648～2147483647 // 9及以下位數都可裝
long long的最大值：9223372036854775807 // 18及以下位數都可裝 19位也差不多
long long的最小值：-9223372036854775808 // 18及以下位數都可裝 19位也差不多
unsigned long long的最大值：18446744073709551615 //20位
// 下面用的可能沒有接觸過， 但存在， 有上面的就夠了， 下面和上面的long long 是一樣的。
__int64的最大值：9223372036854775807
__int64的最小值：-9223372036854775808
unsigned __int64的最大值：18446744073709551615
6.一些簡單的時間優化
// 位運算符的應用
// 如:
int n = 30;
int i = n * 2;
int c = n / 16;
// 可以更改為
int i = n << 1; // 相信我會快。
int c = n >> 4;
// 如：
int i = 100;
while(i % 2 == 1){// 對於for循環同樣使用。
i--;
}
// 改為
while(i & 1){ // 用位運算代替
--i;// 前自減/增 比 后自減/增快。
}
// 如：
int i = 0;
int x = i--;
// 改為
int x = i;
--i;// 這樣結果一樣， 但編譯后，會少一條匯編指令。
7.其他
對於填空題，如果有些不知道如何用代碼實現，要盡可能的利用身邊的一切資源，比如Excel，手算等等。
對於一些做不出來的題，比如有想法但不知道如何優化時間復雜度的題，暴力去解也要提交上。這樣有可能得一定的分數。
還有就是，不要忘記帶准考證、身份證、筆。~最重要的是腦子。
參考來源：