模板库（图树相关）

二分图匹配（匈牙利）（4000ms+）

#include<cstdio>
#include<cstring> 
const int N = 1000 + 10;
bool match[N][N], use[N];
int n, m, e, x, y, ans, result[N];
bool dfs(int now) {
    for(int i = 1; i <= m; ++i)
        if(match[now][i] && !use[i]) {
            use[i] = true;
            if(!result[i] || dfs(result[i])) {
                result[i] = now;
                return true;
            }
        }
    return false;
}
int main() {
    scanf("%d%d%d", &n, &m, &e);
    for(int i = 1; i <= e; ++i) {
        scanf("%d%d", &x, &y);
        if(x > n || y > m) continue;
        match[x][y] = true;
    }
    for(int i = 1; i <= n; ++i) {
        memset(use, 0, sizeof(use));
        if(dfs(i)) ans++;
    }
    printf("%d\n", ans);
    return 0;
}

二分图匹配（dinic）（1900ms+）

#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
using namespace std;
const int inf = 0x6fffffff;
const int N = 20000000 + 10;
queue<int> que;
int n, m, en, s, e, dep[N], E;
struct edge {
    int e, f; edge* nxt; edge* op;
}*v[N], ed[N*2];
void add_edge(int s, int e, int d) {
    ed[++en].nxt = v[s];
    v[s] = ed+en; ed[en].e = e; ed[en].f = d;
    ed[++en].nxt = v[e];
    v[e] = ed+en; ed[en].e = s; ed[en].f = 0;
    ed[en].op = ed+en-1;
    ed[en-1].op = ed+en;
}
bool bfs() {
    memset(dep, -1, sizeof(dep));
    que.push(s);
    dep[s] = 1;
    while(!que.empty()) {
        int now = que.front(); que.pop();
        for(edge* e = v[now]; e; e = e->nxt) {
            if(e->f && dep[e->e] == -1) {
                dep[e->e] = dep[now]+1;
                que.push(e->e);
            }
        }
    }
    return dep[e] != -1;
}
int dfs(int now, int cur_flow) {
    if(now == e || cur_flow == 0) return cur_flow;
    int rest = cur_flow;
    for(edge* e = v[now]; e; e = e->nxt) {
        if(e->f && rest && dep[e->e] == dep[now]+1) {
            int new_flow = dfs(e->e, min(rest, e->f));
            e->f -= new_flow;
            e->op->f += new_flow;
            rest -= new_flow;
        }
    }
    return cur_flow - rest;
}
int main() {
    freopen("3386.in", "r", stdin);
    scanf("%d%d%d", &n, &m, &E);
    s = 0, e = 2001;
    for(int i = 1; i <= E; ++i) {
        int x, y;
        scanf("%d%d", &x, &y);
        add_edge(x, y+n, 1);
    }
    for(int i = 1; i <= n; ++i) {
        add_edge(s, i, 1);
    }
    for(int i = n+1; i <= n+m; ++i) {
        add_edge(i, e, 1);
    }
    int ans = 0;
    while(bfs()) ans += dfs(s, inf);
    printf("%d\n", ans);
    return 0;
} 

最小生成树（kruskal）

#include<cstdio>
#include<algorithm>
using namespace std;
const int N = 5000 + 10;
const int M = 200000 + 10;
int n, m, sum, f[N];
struct edge {int s, e, d;}ed[M];
bool cmp(const edge& a, const edge& b) {return a.d < b.d;}
int find(int x) {
    int r = x;
    while(r != f[r]) r = f[r];
    int i = x, j;
    while(f[i] != r) {
        j = f[i];
        f[i] = r;
        i = j;
    }
    return r;
}
int main() {
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= m; ++i) 
        scanf("%d%d%d", &ed[i].s, &ed[i].e, &ed[i].d);
    for(int i = 1; i <= n; ++i) f[i] = i;
    sort(ed+1, ed+m+1, cmp);
    for(int i = 1; i <= m; ++i) {
        int fa = find(ed[i].s), fb = find(ed[i].e);
        if(fa != fb) {
            f[fa] = fb;
            sum += ed[i].d;
            n--;
        }
    }
    if(n > 1) printf("orz\n");
    else printf("%d\n", sum);
    return 0;
}

单源最短路（Dijkstra+Heap）

#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
const int N = 1e4 + 10;
const int M = 500000 + 10;
const long long inf = 0x7fffffff;
int n, m, s, en;
long long dist[N];
bool vis[N]; 
struct edge {
    int e, d;
    edge* nxt;
    edge(){e = d = 0;}
    edge(int a, int b) {e = a, d = b;}
    bool operator < (const edge& b) const {return d>b.d;}
}*v[N], ed[M*2];
priority_queue<edge> heap;
void add_edge(int s, int e, int d) {
    ed[++en].nxt = v[s];
    v[s] = ed+en;
    ed[en].e = e; ed[en].d = d;
}
void Dijkstra_heap(int s) {
    memset(vis, 0, sizeof(vis));
    for(int i = 1; i <= n; ++i) dist[i] = inf;
    dist[s] = 0;
    heap.push(edge(s, dist[s]));
    while(!heap.empty()) {
        int now = heap.top().e; heap.pop();
        if(vis[now]) continue;
        vis[now] = true;
        for(edge* e = v[now]; e; e = e->nxt) {
            if(dist[e->e] >dist[now] + e->d) {
                dist[e->e] = dist[now] + e->d;
                heap.push(edge(e->e, dist[e->e]));
            }
        }
    }
}
int main() {
    scanf("%d%d%d", &n, &m, &s);
    for(int i = 1; i <= m; ++i) {
        int x, y, z;
        scanf("%d%d%d", &x, &y, &z);
        add_edge(x, y, z);
    }
    Dijkstra_heap(s);
    for(int i = 1; i <= n; ++i) printf("%lld ", dist[i]);
    return 0;
}

单源最短路（SPFA）

#include<cstdio>
#include<cstring>
const int N = 1e4 + 10;
const int M = 500000 + 10;
const long long inf = 0x7fffffff;
int n, m, s, q[M], head, tail, en;
long long dist[N];
bool inq[N];
struct edge {
    int e, d;
    edge* nxt;
}*v[N], ed[M*2];
void add_edge(int s, int e, int d) {
    ed[++en].nxt = v[s];
    v[s] = ed+en;
    ed[en].e = e; ed[en].d = d;
}
void SPFA(int s) {
    for(int i = 1; i <= n; ++i) dist[i] = inf; 
    memset(inq, 0, sizeof(inq));
    head = tail = 0;
    q[tail++] = s;
    inq[s] = true;
    dist[s] = 0;
    while(head != tail) {
        int now = q[head++];
        if(head == N) head = 0;
        inq[now] = false;
        for(edge* e = v[now]; e; e = e->nxt) {
            if(dist[e->e] > dist[now] + e->d) {
                dist[e->e] = dist[now] + e->d;
                if(!inq[e->e]) {
                    q[tail++] = e->e;
                    if(tail == N) tail = 0;
                    inq[e->e] = true;
                }
            }
        }

    }
}
int main() {
    scanf("%d%d%d", &n, &m, &s);
    for(int i = 1; i <= m; ++i) {
        int x, y, z;
        scanf("%d%d%d", &x, &y, &z);
        add_edge(x, y, z);
    }
    SPFA(s);
    for(int i = 1; i <= n; ++i) printf("%lld ", dist[i]);
    return 0;
}