最短路
SPFA
#include <bits/stdc++.h>
using namespace std;
#define N 10001
#define M 500001
struct node{
int to, w, next;
}edge[M];
int cut = 0;
int head[N];
int dis[N];
int n,m,k;
bool vis[N];
queue <int> q;
void ini () {
fill (dis + 1, dis + N + 1, INT_MAX);
memset (head, -1, sizeof (head));
}
void add (int u, int v, int w) {//建边
cut ++;
edge[cut].w = w;
edge[cut].to = v;
edge[cut].next = head[u];
head[u] = cut;
}
void SPFA (int x) {
dis[x] = 0;
q.push (x);//头入队
vis[x] = 1;
while (! q.empty ()) {
int u = q.front(); q.pop(); vis[u] = false;
for (int j = head[u]; ~ j; j = edge[j].next) {//调用邻接表
if (dis[edge[j].to] > dis[u] + edge[j].w) {
dis[edge[j].to] = dis[u] + edge[j].w;//松弛操作
if (! vis[edge[j].to]) {//判断标记
q.push (edge[j].to);//入队边上的点
vis[edge[j].to] = 1;//标记
}
}
}
}
}
int main () {
ini ();
scanf ("%d %d %d", &n, &m, &k);
for (int i = 1, u, v, w; i <= m; i ++) {
scanf ("%d %d %d", &u, &v, &w);
add (u, v, w);
}
SPFA (k);
for (int i = 1; i <= n; i ++) {
printf ("%d ", dis[i]);
}
return 0;
}
Dijkstra（堆优化）
#include <bits/stdc++.h>
using namespace std;
#define N 10001
#define M 500001
#define P pair<int,int>
#define Fi first
#define Se second
struct node{
int to, w, next;
}edge[M];
int cut = 0;
int head[N];
int dis[N];
int n, m, k;
bool vis[N];
priority_queue <P, vector<P>, greater<P> > q;//优先队列
void ini () {
fill (dis + 1, dis + N + 1, INT_MAX);
memset (head, -1, sizeof (head));
}
void add (int u, int v, int w) {
cut ++;
edge[cut].w = w;
edge[cut].to = v;
edge[cut].next = head[u];
head[u] = cut;
}
void Dij (int x) {
dis[x] = 0;
vis[x] = 1;
q.push (P (0, x));//头入队
while (! q.empty ()) {
P u = q.top(); q.pop(); vis[u.Se] = 1;
for (int j = head[u.Se]; ~ j; j = edge[j].next) {//邻接表遍历
if (! vis[edge[j].to] && dis[edge[j].to] > dis[u.Se] + edge[j].w) {//判断标记和松弛操作
dis[edge[j].to] = dis[u.Se] + edge[j].w;//松弛
q.push (P (dis[edge[j].to], edge[j].to));//入队
}
}
}
}
int main () {
ini ();
scanf ("%d %d %d", &n, &m, &k);
for (int i=1, u, v, w; i <= m; i ++) {
scanf ("%d %d %d", &u, &v, &w);
add (u, v, w);
}
Dij (k);
for (int i = 1; i <= n; i ++) {
printf ("%d ", dis[i]);
}
return 0;
}
最小生成树
Kruskal
#include <bits/stdc++.h>
using namespace std;
#define N 5001
#define M 200001
struct node {
int u, v, w;
}edge[M];
int fa[N], n, m;
int find (int x) {//并查集找爸爸
return fa[x] == x ? x : fa[x] = find (fa[x]);
}
void un (int x, int y) {//并查集连接
x = find (x);
y = find (y);
fa[x] = y;
}
void ini () {//初始化
for (int i = 1; i <= 5000; i ++) fa[i] = i;
}
bool cmp (node a, node b) {
return a.w < b.w;
}
int main () {
ini ();
scanf ("%d %d", &n, &m);
for (int i = 1; i <= m; i ++) {
scanf ("%d %d %d", &edge[i].u, &edge[i].v, &edge[i].w);
}
sort (edge + 1, edge + m + 1, cmp);
int k = 0;
int ans = 0;
for (int i = 1; i <= m; i ++) {
if (find (edge[i].u) != find (edge[i].v)){//判断是否在一个集合里
un (edge[i].u,edge[i].v);
k ++;
ans += edge[i].w;//累加答案
}
if(k == n - 1) break;
}
if (k == n - 1) printf ("%d", ans);
else printf ("orz");//不连通
return 0;
}
排序
归并排序（求逆序对）
#include<bits/stdc++.h>
using namespace std;
int n;
int ans = 0;
int v[500001];
int t[500001];
void Qsort (int l, int r) {//归并
if(l == r)return ;
int mid = (l + r) >> 1;
Qsort (1, mid);
Qsort (mid + 1, r);//递归
int i = l; int j = mid + 1; int k = l;
while (i <= mid && j <= r) {
if (v[i] <= v[j]) t[k ++] = v[i ++];
else t[k ++] = v[j ++], ans += mid - i + 1;//数学规律
}
while (i <= mid) t[k ++] = v[i ++];
while (j <= r) t[k ++] = v[j ++];
for (int i = l; i <= r; i ++) v[i] = t[i];
}
int main () {
scanf ("%d", &n);
for(int i = 1; i <= n; i ++) scanf ("%d", &v[i]);
Qsort (1, n);
printf ("%d", ans);
return 0;
}
数据结构
树状数组（区间查询，区间修改）
#include<bits/stdc++.h>
using namespace std;
int a[500001], b[500001], c[500001];
int n, m;
int lowbit (int x) {
return x & (-x);
}
void updata (int i, int k) {
int x = i;
while (i <= n) {
c[i] += k;
b[i] += k * (x - 1);
i += lowbit (i);
}
}
int getsum (int i) {
int sum = 0, x = i;
while (i > 0) {
sum += x * c[i] - b[i];
i -= lowbit (i);
}
return sum;
}
//1：区间修改，2：区间查询
int main () {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i ++) {
scanf ("%d", &a[i]);
updata (i, a[i] - a[i-1]);
}
for (int i = 1, d, x, y, z; i <= m; i ++) {
scanf ("%d", &d);
if (d == 1) {
scanf ("%d%d%d", &x, &y, &z);
updata (x, z);
updata (y+1, -z);
} else {
scanf ("%d%d", &x, &y);
printf ("%d
", getsum (y) - getsum (x - 1));
}
}
return 0;
}
链表（尾部插入，遍历）
struct node {
int data;
node *next;
};
struct list {
node *head;
int length;
};
void add (list &List, int n) {
node *pcur = new node;
pcur -> data = n;
pcur -> next = NULL;
if (List.head == NULL) {
List.head = pcur;
List.length = 1;
} else {
node *pt = List.head;
while (pt -> next != NULL) pt = pt -> next;
pt -> next = pcur;
List.length ++;
}
}
int main () {
list L;
L.head = NULL;
L.length = 0;
int n;
cin >> n;
for (int i = 1; i <= n; i ++) {
int du;
cin >> du;
add (L, du);
}
node *bl;
bl = L.head;
while (bl != NULL) {
cout << bl -> data << " ";
bl = bl -> next;
}
return 0;
}
链表 （数组模拟，头尾插，随机插）
#include <bits/stdc++.h>
#define LL long long
using namespace std;
struct FastIO {
template <typename T> FastIO& operator >> (T& In) {
In = 0;
char Ch = getchar ();
int Flag = 1;
for (; ! std :: isdigit (Ch); Ch = getchar ()) if (Ch == '-') Flag = -1;
for (; std :: isdigit (Ch); Ch = getchar ()) In = (In << 3) + (In << 1) + (Ch ^ 48);
In *= Flag;
return *this;
}
}fin;
const int MaxN = 2010;
int Val[MaxN], Nxt[MaxN];
int Head, Size;
void AddHead (int x) {
Val[Size] = x;
Nxt[Size] = Head;
Head = Size;
Size ++;
}
void Init () {
Head = -1;
Size = 0;
AddHead (0);
}
void AddTail (int x) {
Val[Size] = x;
Nxt[Size] = Nxt[Size - 1];
Nxt[Size - 1] = Size;
Size ++;
}
void AddRy (int k, int x) {
Val[Size] = x;
Nxt[Size] = Nxt[k];
Nxt[k] = Size;
Size ++;
}
void Delete (int k) {
Nxt[k] = Nxt[Nxt[k]];
}
void Write () {
int i = Nxt[Head];
for (; i != -1; i = Nxt[i]) printf ("%d ", Val[i]);
}
int main () {
Init ();
int n;
fin >> n;
for (int i = 1; i <= n; i ++) {
int x;
fin >> x;
AddTail (x);
}
int m;
fin >> m;
for (int i = 1; i <= m; i ++) {
int k, x;
fin >> k >> x;
AddRy (k, x);
}
Write ();
return 0;
}
线段树 （区间修改，区间查询）
#include <bits/stdc++.h>
#define ls (root << 1)
#define rs (root << 1 | 1)
#define int long long
using namespace std;
struct FastIO {
template <typename T> FastIO& operator >> (T& in) {
in = 0;
char ch = getchar ();
int flag = 1;
for (; ! isdigit (ch); ch = getchar ()) if (ch == '-') flag = -1;
for (; isdigit (ch); ch = getchar ()) in = (in << 3) + (in << 1) + (ch ^ 48);
in *= flag;
return *this;
}
}fin;
const int MaxN = 1e5 + 100;
int sum[MaxN << 2], l[MaxN << 2], r[MaxN << 2], lz[MaxN << 2], arr[MaxN];
int n, m;
void pushup (int root) {
sum[root] = sum[ls] + sum[rs];
}
void pushdown (int root) {
if (lz[root]) {
lz[ls] += lz[root];
lz[rs] += lz[root];
sum[ls] += lz[root] * (r[ls] - l[ls] + 1);
sum[rs] += lz[root] * (r[rs] - l[rs] + 1);
lz[root] = 0;
}
}
void build (int root, int L, int R) {
l[root] = L;
r[root] = R;
lz[root] = 0;
if (L == R) {
sum[root] = arr[L];
return ;
}
int mid = (L + R) >> 1;
build (ls, L, mid);
build (rs, mid + 1, R);
pushup (root);
}
void add (int root, int L, int R, int k) {
if (l[root] >= L && r[root] <= R) {
sum[root] += (r[root] - l[root] + 1) * k;
lz[root] += k;
return ;
}
if (r[root] < L || l[root] > R) return ;
pushdown (root);
if (r[ls] >= L) add (ls, L, R, k);
if (l[rs] <= R) add (rs, L, R, k);
pushup (root);
}
int search (int root, int L, int R) {
if (l[root] >= L && r[root] <= R) return sum[root];
if (r[root] < L || l[root] > R) return 0;
pushdown (root);
int s = 0;
if (r[ls] >= L) s += search (ls, L, R);
if (l[rs] <= R) s += search (rs, L, R);
return s;
}
main () {
fin >> n >> m;
for (int i = 1; i <= n; ++ i) fin >> arr[i];
build (1, 1, n);
for (int i = 1; i <= m; ++ i) {
int id;
fin >> id;
if (id == 1) {
int x, y, z;
fin >> x >> y >> z;
add (1, x, y, z);
} else {
int x, y;
fin >> x >> y;
printf ("%lld
", search (1, x, y));
}
}
return 0;
}
Treap
#include <bits/stdc++.h>
#define Reg register
#define RI Reg int
#define RL Reg LL
#define RU Reg ull
#define Con const
#define CI Con int&
#define CL Con LL&
#define CU Con ull&
#define I inline
#define W while
#define LL long long
#define ull unsigned long long
using namespace std;
struct FastIO {
template <typename T> FastIO& operator >> (T& in) {
in = 0;
char ch = getchar ();
int flag = 1;
for (; ! std :: isdigit (ch); ch = getchar ()) if (ch == '-') flag = -1;
for (; std :: isdigit (ch); ch = getchar ()) in = (in << 3) + (in << 1) + (ch ^ 48);
in *= flag;
return *this;
}
}fin;
const int MaxN = 1e6 + 100, INF = 1e9;
int tot = 0, root = 0;
struct NODE {
int val;
int dat;
int size;
int cnt;
int ch[2];
}nd[MaxN];
int NewNode (int x) { // 创建新节点
++ tot;
nd[tot].val = x;
nd[tot].dat = rand ();
nd[tot].cnt = 1;
nd[tot].size = 1;
nd[tot].ch[0] = 0;
nd[tot].ch[1] = 0;
return tot;
}
void PushUp (int x) { // 更新
nd[x].size = nd[nd[x].ch[0]].size + nd[nd[x].ch[1]].size + nd[x].cnt;
}
void Build () { // 初始化
root = NewNode (-INF);
nd[root].ch[1] = NewNode (INF);
PushUp (root);
}
void Rotate (int &id, int d) { // 旋转 0：左旋 1：右旋
int Tmp = nd[id].ch[d ^ 1];
nd[id].ch[d ^ 1] = nd[Tmp].ch[d];
nd[Tmp].ch[d] = id;
id = Tmp;
PushUp (nd[id].ch[d]);
PushUp (id);
}
void Insert (int &id, int x) { // 插入
if (! id) {
id = NewNode (x);
return ;
}
if (x == nd[id].val) ++ nd[id].cnt;
else {
int d = x < nd[id].val ? 0 : 1;
Insert (nd[id].ch[d], x);
if (nd[id].dat < nd[nd[id].ch[d]].dat) Rotate (id, d ^ 1);
}
PushUp (id);
}
void Remove (int &id, int x) { // 删除
if (! id) return ;
if (x == nd[id].val) {
if (nd[id].cnt > 1) {-- nd[id].cnt; PushUp (id); return ;}
if (nd[id].ch[0] || nd[id].ch[1]) {
if (! nd[id].ch[1] || nd[nd[id].ch[0]].dat > nd[nd[id].ch[1]].dat) {
Rotate (id, 1);
Remove (nd[id].ch[1], x);
} else {
Rotate (id, 0);
Remove (nd[id].ch[0], x);
}
PushUp (id);
} else id = 0;
return ;
}
if (x < nd[id].val) Remove (nd[id].ch[0], x);
else Remove (nd[id].ch[1], x);
PushUp (id);
}
int Rank (int id, int x) { // 查找x的排名
if (! id) return -2;
if (x == nd[id].val) return nd[nd[id].ch[0]].size + 1;
else if (x < nd[id].val) return Rank (nd[id].ch[0], x);
else return nd[nd[id].ch[0]].size + nd[id].cnt + Rank (nd[id].ch[1], x);
}
int Val (int id, int rank) { // 查找排名为rank的数
if (! id) return INF;
if (rank <= nd[nd[id].ch[0]].size) return Val (nd[id].ch[0], rank);
else if (rank <= nd[nd[id].ch[0]].size + nd[id].cnt) return nd[id].val;
else return Val (nd[id].ch[1], rank - nd[nd[id].ch[0]].size - nd[id].cnt);
}
int Pre (int x) { // 查找x的前驱
int id = root, pre;
while (id) {
if (nd[id].val < x) pre = nd[id].val, id = nd[id].ch[1];
else id = nd[id].ch[0];
}
return pre;
}
int Next (int x) { // 查找x的后继
int id = root, next;
while (id) {
if (nd[id].val > x) next = nd[id].val, id = nd[id].ch[0];
else id = nd[id].ch[1];
}
return next;
}
int n;
int opt, x;
//1：插入 2:删除 3：查找x的排名 4：查找排名为rank的数 5：查找x的前驱 6：查找x的后继
int main () {
Build ();
fin >> n;
for (int i = 1; i <= n; ++ i) {
fin >> opt >> x;
if (opt == 1) Insert (root, x);
else if (opt == 2) Remove (root, x);
else if (opt == 3) printf ("%d
", Rank (root, x) - 1);
else if (opt == 4) printf ("%d
", Val (root, x + 1));
else if (opt == 5) printf ("%d
", Pre (x));
else if (opt == 6) printf ("%d
", Next (x));
}
return 0;
}
fhq_treap
#include <bits/stdc++.h>
using namespace std;
struct FastIO {
template <typename T> FastIO& operator >> (T& in) {
in = 0;
char ch = getchar ();
int flag = 1;
for (; ! isdigit (ch); ch = getchar ()) if (ch == '-') flag = -1;
for (; isdigit (ch); ch = getchar ()) in = (in * 10) + (ch ^ 48);
in *= flag;
return *this;
}
}fin;
const int MaxN = 5e5 + 100;
int ch[MaxN][2], val[MaxN], rnd[MaxN], size[MaxN], cnt = 0;
int x, y, z, root = 0;
int n;
void pushup (int root) {size[root] = size[ch[root][0]] + size[ch[root][1]] + 1;}
int newnode (int v) {
++ cnt;
size[cnt] = 1;
val[cnt] = v;
ch[cnt][0] = ch[cnt][1] = 0;
rnd[cnt] = rand ();
return cnt;
}
void split (int now, int k, int &x, int &y) {
if (! now) x = y = 0;
else {
if (val[now] <= k) x = now, split (ch[now][1], k, ch[now][1], y);
else y = now, split (ch[now][0], k, x, ch[now][0]);
pushup (now);
}
}
int merge (int A, int B) {
if (! A || ! B) return A + B;
if (rnd[A] < rnd[B]) {ch[A][1] = merge (ch[A][1], B); pushup (A); return A;}
else {ch[B][0] = merge (A, ch[B][0]); pushup (B); return B;}
}
void Insert (int &now, int v) {
split (now, v, x, y);
now = merge (merge (x, newnode (v)), y);
}
void Del (int &now, int v) {
split (now, v, x, z);
split (x, v - 1, x, y);
y = merge (ch[y][0], ch[y][1]);
now = merge (merge (x, y), z);
}
int Rank (int &now, int v) {
split (now, v - 1, x, y);
int res = size[x] + 1;
now = merge (x, y);
return res;
}
int Val (int now, int rank) {
while (1) {
if (rank <= size[ch[now][0]]) now = ch[now][0];
else if (rank == size[ch[now][0]] + 1) return val[now];
else rank -= size[ch[now][0]] + 1, now = ch[now][1];
}
}
int Pre (int &now, int v) {
split (now, v - 1, x, y);
int res = Val (x, size[x]);
now = merge (x, y);
return res;
}
int Next (int &now, int v) {
split (now, v, x, y);
int res = Val (y, 1);
now = merge (x, y);
return res;
}
int main () {
srand (time (0));
fin >> n;
for (int i = 1; i <= n; ++ i) {
int opt, v;
fin >> opt >> v;
switch (opt) {
case 1: Insert (root, v); break;
case 2: Del (root, v); break;
case 3: printf ("%d
", Rank (root, v)); break;
case 4: printf ("%d
", Val (root, v)); break;
case 5: printf ("%d
", Pre (root, v)); break;
case 6: printf ("%d
", Next (root, v)); break;
}
}
return 0;
}
子序列
LCS（最长公共子序列）
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
#define N 100001
int dp[2][N], a[N], b[N];
int n;
int main(){
scanf ("%d", &n);
for (int i = 1; i <= n; i ++){
scanf ("%d", &a[i]);
}
for (int i = 1; i <= n; i ++){
scanf ("%d", &b[i]);
}
for (int i = 1; i <= n; i ++){
for (int j = 1; j <= n; j ++){
if (a[i] != b[j]){
dp[i & 1][j] = max (dp[1 - i & 1][j], dp[i & 1][j - 1]);//状态转移方程式
}else{
dp[i & 1][j] = dp[1 - i & 1][j - 1] + 1;
}
}
}
printf ("%d", dp[n & 1][n]);//滚动数组
return 0;
}
LIS（最长上升子序列)
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int a[100001], d[100001], n, len;
int main (){
scanf ("%d", &n);
for(int i = 1; i <= n; i ++){
scanf ("%d", &a[i]);
}
d[1] = a[1];
len = 1;
for(int i = 2; i <= n; i ++){
if (a[i] > d[len]) d[++ len] = a[i];
else{
int j = upper_bound (d + 1, d + len + 1, a[i]) - d;
d[j] = a[i];
}
}
printf ("%d", len);
return 0;
}
LCA
倍增
#include <bits/stdc++.h>
#define DEBUG 0
using namespace std;
struct FastIO {
template <typename T> FastIO& operator >> (T& in) {
in = 0;
char ch = getchar ();
int flag = 1;
for (; ! isdigit (ch); ch = getchar ()) if (ch == '-') flag = -1;
for (; isdigit (ch); ch = getchar ()) in = (in << 3) + (in << 1) + (ch ^ 48);
in *= flag;
return *this;
}
}fin;
const int MaxN = 5e5 + 100;
int n, m, s;
int head[MaxN], to[MaxN << 1], nxt[MaxN << 1], cnt;
int lg[MaxN], dep[MaxN], fa[MaxN][25];
void add (int u, int v) {++ cnt; to[cnt] = v; nxt[cnt] = head[u]; head[u] = cnt;}
void dfs (int now, int fath) {
fa[now][0] = fath; dep[now] = dep[fath] + 1;
for (int i = 1; i <= lg[dep[now]]; ++ i) fa[now][i] = fa[fa[now][i - 1]][i - 1];
for (int i = head[now]; i; i = nxt[i]) {
if (to[i] != fath) dfs (to[i], now);
}
}
int LCA (int x, int y) {
if (dep[x] < dep[y]) swap (x, y);
while (dep[x] > dep[y]) x = fa[x][lg[dep[x] - dep[y]] - 1];
if (x == y) return x;
for (int i = lg[dep[x]] - 1; i >= 0; -- i) {
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
}
return fa[x][0];
}
int main () {
fin >> n >> m >> s;
for (int i = 1; i <= n - 1; ++ i) {
int x, y;
fin >> x >> y;
add (x, y); add (y ,x);
}
for (int i = 1; i <= n; ++ i) lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
dfs (s, 0);
for (int i = 1; i <= m; ++ i) {
int x, y;
fin >> x >> y;
printf ("%d
", LCA (x, y));
}
return 0;
}