退役诈尸（NOIP春季赛赛前复习）

线段树

//P3384 【模板】重链剖分/树链剖分 
struct Segment_Tree
{
    #define lc(x) (x << 1)
    #define rc(x) (x << 1 | 1)
    #define lzy(x) seg_tree[x].lazy
    #define val(x) seg_tree[x].val
    #define mid ((l + r) >> 1)
    struct segment_tree
    {
        ll val, lazy;
    }seg_tree[maxn << 1];
 
    void pushup(int rt)
    {
        return (void)(val(rt) = (val(lc(rt)) + val(rc(rt))) % P);
    }
    void pushdown(int rt, int l, int r)
    {
        if(lzy(rt))
        {
            lzy(lc(rt)) += lzy(rt), lzy(rc(rt)) += lzy(rt);
            (val(lc(rt)) += (mid - l + 1) * lzy(rt) % P) %= P;
            (val(rc(rt)) += (r - mid) * lzy(rt) % P) %= P; 
            lzy(rt) = 0;
        }
        return;
    }
    void Build(int rt, int l, int r)
    {
        if(l == r)
        {
            val(rt) = at[l];
            return;
        }
        Build(lc(rt), l, mid);
        Build(rc(rt), mid + 1, r);
        pushup(rt);
        return;
    }
    void Updata(int rt, int l, int r, int L, int R, int val)
    {
        if(L <= l && r <= R)
        {
            (val(rt) += val * (r - l + 1) % P) %= P, (lzy(rt) += 1ll * val) %= P;
            return;
        }
        pushdown(rt, l, r);
        if (L <= mid)
            Updata(lc(rt), l, mid, L, R, val);
        if (R > mid)
            Updata(rc(rt), mid + 1, r, L, R, val);
        pushup(rt);
        return;
    }
    ll Query(int rt, int l, int r, int L, int R)
    {
        if(L <= l && r <= R)
        {
            return val(rt);
        }
        pushdown(rt, l, r);
        ll ans = 0;
        if(L <= mid)
            (ans += Query(lc(rt), l, mid, L, R)) %= P;
        if(R > mid)
            (ans += Query(rc(rt), mid + 1, r, L, R)) %= P;
        return ans;
    }
}T;

重链剖分

///P3384 【模板】重链剖分/树链剖分 
struct SLPF
{
    int fa[maxn], dep[maxn], siz[maxn],
        id[maxn], son[maxn], top[maxn], cnt;
 
    void Dfs1(int u, int faa, int deep)
    {
        dep[u] = deep, fa[u] = faa, siz[u] = 1;
        fort(u)
        {  
            if(v == faa) continue;
            Dfs1(v, u, deep + 1);
            siz[u] += siz[v];
            if(siz[son[u]] < siz[v])
                son[u] = v;
        }
        return;
    }
    void Dfs2(int u, int topf)
    {
        top[u] = topf, at[++ cnt] = a[u], id[u] = cnt;
        if(! son[u]) return;
        Dfs2(son[u], topf);
        fort(u)
        {
            if(v == fa[u] || v == son[u])continue;
            Dfs2(v, v);
        }
        return;
    }
 
    void Updata1(int x, int y, int z)
    {
        z %= P;
        while(top[x] != top[y])
        {
            if(dep[top[x]] < dep[top[y]])
                swap(x, y);
            T.Updata(1, 1, n, id[top[x]], id[x], z);
            x = fa[top[x]];
        }
        if(dep[x] > dep[y]) swap(x, y);
        T.Updata(1, 1, n, id[x], id[y], z);
        return;
    }
    void Updata2(int rt, int z)
    {
        return (void)(z %= P, T.Updata(1, 1, n, id[rt], id[rt] + siz[rt] - 1, z));
    }
    ll Query1(int x, int y)
    {
        ll ans = 0; 
        while(top[x] != top[y])
        {
            if(dep[top[x]] < dep[top[y]])
                swap(x, y);
            (ans += T.Query(1, 1, n, id[top[x]], id[x])) %= P;
            x = fa[top[x]];
        }
        if(dep[x] > dep[y]) swap(x, y);
        (ans += T.Query(1, 1, n, id[x], id[y])) %= P;
        return ans;
    }
    ll Query2(int rt)
    {
        return T.Query(1, 1, n, id[rt], id[rt] + siz[rt] - 1);
    }
}S;

单源最短路

int dis[maxn];
bool vis[maxn];
struct node
{
    int u, dis;
    bool operator < (const int v)
    {
        return dis < v.dis;
    }
};
void Dijstra(int x)
{
    priority_queue <node> q;
    memset(dis, INF, sizeof(dis));
    dis[x] = 0;
    q.push({x, 0});
    while(! q.empty())
    {
        int u = q.top().u; q.pop();
        if(vis[u]) continue;
        vis[u] = true;
        fort(u)
        {
            if(dis[v] > dis[u] + e[i].dis)
            {
                dis[v] = dis[u] + e[i].dis;
                q.push({v, dis[v]});
            }
        }
    } 
    return;
}
void Spfa(int x)
{
    srand(time(0));
    deque <int> q;
    memset(dis, INF, sizeof(dis));
    dis[x] = 0, vis[x] = true;
    q.push_back(x);
    while(! q.empty())
    {
        int u = q.front(); q.pop_front();
        vis[u] = false;
        fort(u)
        {
            if(dis[v] > dis[u] + e[i].dis)
            {
                dis[v] = dis[u] + e[i].dis; 
                if(! vis[v])
                {
                    int op = rand() % 2;
                    if(! op)
                    {
                        q.push_back(v);
                        vis[v] = true;
                    }
                    else
                    {
                        q.push_front(v);
                        vis[v] = true;
                    }       
                }
            }
        }
    }
}

多源最短路

int f[maxn][manx];
void floyd()
{
    for (int k = 1; k <= n; ++ k)
    {
        for (int i = 1; i <= n; ++ i)
        {
            if(i == k) continue;
            for (int j = 1; j <= n; ++ j)
            {
                if(i == j || j == k) continue;
                f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
            }
        }
    }
    return;
}