模板

一般图匹配带花树

#include <bits/stdc++.h>

using namespace std;
const int maxm=50100;
const int maxn=500;
char ch[200];
int t,to[maxm],head[maxn],nex[maxm],tot;



struct Blossom {
    int p[maxn], vi[maxn], tag, fl[maxn], c[maxn], pr[maxn], q[maxn], r;
    int find(int x) {
        return x == p[x] ? x : p[x] = find(p[x]);
    }
    void add(int u, int v) {
        t++;
        to[t] = v;
        nex[t] = head[u];
        head[u] = t;
    }
    int lca(int u, int v) {
        ++tag;
        u = find(u);
        v = find(v);
        for (;; swap(u, v))
            if (u) {
                if (fl[u] == tag) return u;
                fl[u] = tag;
                u = find(pr[c[u]]);
            }
    }
    void blo(int u, int v, int l) {
        for (; find(u) != l; v = c[u], u = pr[v]) {
            pr[u] = v;
            if (vi[c[u]] == 1)
                vi[q[++r] = c[u]] = 0;
            if (find(u) == u) p[u] = l;
            if (find(c[u]) == c[u]) p[c[u]] = l;
        }

    }
    bool aug(int s) {
        for (int i = 1; i <= tot; i++) {
            p[i] = i;
            vi[i] = -1;
        }
        vi[q[r = 1] = s] = 0;
        int x, y;
        for (int i = 1; i <= r; i++)
            for (int j = head[x = q[i]]; j; j = nex[j])
                if (vi[y = to[j]] == -1) {
                    pr[y] = x;
                    vi[y] = 1;
                    if (!c[y]) {
                        for (int u = x, v = y, t; u; v = t, u = pr[v]) {
                            t = c[u];
                            c[u] = v;
                            c[v] = u;
                        }
                        return 1;
                    }
                    vi[q[++r] = c[y]] = 0;
                } else if (!vi[y] && find(x) != find(y)) {
                    int l = lca(x, y);
                    blo(x, y, l);
                    blo(y, x, l);
                }
        return 0;
    }
    void init() {
        t = 0;
        memset(head, 0, sizeof(head));
        memset(c, 0, sizeof(c));
        memset(pr, 0, sizeof(pr));
    }
};
int main() {
    int _, n, m;
    scanf("%d", &_);
    while (_--) {
        Blossom blossom;
        blossom.init();
        scanf("%d%d", &n, &m);
        tot = n * 2 + m;
        for (int i = 1; i <= n; i++) {
            scanf("%s", ch + 1);
            blossom.add(i + m, i + m + n);
            blossom.add(i + m + n, i + m);
            for (int j = 1; j <= m; j++)
                if (ch[j] - '0') {
                    blossom.add(j, i + m);
                    blossom.add(i + m, j);
                    blossom.add(j, i + m + n);
                    blossom.add(i + m + n, j);
                }
        }
        int ans = 0;
        for (int i = 1; i <= tot; i++) {
            if (!blossom.c[i]) ans += blossom.aug(i);
        }
        printf("%d\n", ans - n);
    }
    return 0;
}

 array

不难看出对于每次2操作,答案最大是n+1(因为每次更新是+10000000, 永远不会占用n+1,而且k是保证<=n的). 如果某个数字被进行过1操作, 那么就代表这个数字可以用于2类操作的查询,把这个数字加到set里.对于找2类询问的答案,第一种是从a[r+1,n]里找>=k的最小值(主席树实现),第二种是从这个set里找>=k的最小值(对set进行二分查找),取两者间最小值即可.

 

#include <bits/stdc++.h>
using namespace std;
const int maxn=200100;
struct node
{
    int l,r,sum;
} hjt[maxn*40];
int cnt,root[maxn*20],n,m,book[maxn];
int a[maxn];
set<int>s;
set<int>::iterator it;
void init() {
    for (int i = 0; i <= n; i++) book[i] = 0;
    s.clear();
    root[0] = 0;
    cnt = 0;
    for (int i = 0; i < maxn * 20; i++) hjt[i].l = hjt[i].r = hjt[i].sum = 0;
}
void insert(int l,int r,int pre,int &now,int p)
{
    hjt[++cnt]=hjt[pre];
    now=cnt;
    hjt[now].sum++;
    if (l==r)
    {
        return;
    }
    int mid=(l+r)>>1;
    if (p<=mid)
    {
        insert(l,mid,hjt[pre].l,hjt[now].l,p);
    }
    else
    {
        insert(mid+1,r,hjt[pre].r,hjt[now].r,p);
    }
}
int query(int rt,int l,int r,int L,int R) {
    if (R < L) return -1;
    if (!rt) return -1;
    if (!hjt[rt].sum) return -1;
    if (l >= L && r <= R) {
        if (l == r)
            return l;
        else {
            int mid = (l + r) >> 1;
            int res = -1;
            if (L <= mid) res = query(hjt[rt].l, l, mid, L, R);
            if (R > mid && res == -1) res = query(hjt[rt].r, mid + 1, r, L, R);
            return res;
        }
    }
    int mid = (l + r) >> 1;
    int res = -1;
    if (L <= mid) res = query(hjt[rt].l, l, mid, L, R);
    if (R > mid && res == -1) res = query(hjt[rt].r, mid + 1, r, L, R);
    return res;
}
 
int main() {
    int _;
    scanf("%d", &_);
    while (_--) {
        scanf("%d%d", &n, &m);
        init();
        root[n + 1] = 0;
        for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
        for (int i = n; i >= 1; i--)
            insert(1, n, root[i + 1], root[i], a[i]);
        int lastans = 0;
        for (int i = 1; i <= m; i++) {
            int id;
            scanf("%d", &id);
            if (id == 1) {
                int t;
                scanf("%d", &t);
                int pos = t ^lastans;
                if (book[pos]) continue;
                book[pos] = 1;
                s.insert(a[pos]);
            } else {
                int t1, t2;
                scanf("%d%d", &t1, &t2);
                int R = (t1 ^lastans) + 1;
                int k = t2 ^lastans;
                int ans = n + 1;
                it = s.lower_bound(k);
                if (it != s.end()) ans = *it;
                if (R <= n) {
                    t1 = query(root[R], 1, n, k, n);
                    if (t1 != -1) ans = min(ans, t1);
                }
                printf("%d\n", ans);
                lastans = ans;
            }
        }
    }
    return 0;
}

主席树(静态查询区间第k大)

#include <bits/stdc++.h>
 
using namespace std;
const int maxn=200100;
struct node
{
    int l,r,sum;
} hjt[maxn*40];
int cnt,root[maxn*40];
vector<int>v;
int a[maxn];
int getid(int x)
{
    return lower_bound(v.begin(),v.end(),x)-v.begin()+1;
}
 
void insert(int l,int r,int pre,int &now,int p)
{
    hjt[++cnt]=hjt[pre];
    now=cnt;
    hjt[now].sum++;
    if (l==r)
    {
        return;
    }
    int mid=(l+r)>>1;
    if (p<=mid)
    {
        insert(l,mid,hjt[pre].l,hjt[now].l,p);
    }
    else
    {
        insert(mid+1,r,hjt[pre].r,hjt[now].r,p);
    }
}
 
int query(int l,int r,int L,int R,int k)
{
    if (l==r)
        return l;
    int mid=(l+r)>>1;
    int tmp=hjt[hjt[R].l].sum-hjt[hjt[L].l].sum;
    if (k<=tmp)
    {
        return query(l,mid,hjt[L].l,hjt[R].l,k);
    }
    else
    {
        return query(mid+1,r,hjt[L].r,hjt[R].r,k-tmp);
    }
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for (int i=1; i<=n; i++)
    {
        scanf("%d",&a[i]);
        v.push_back(a[i]);
    }
    sort(v.begin(),v.end());
    v.erase(unique(v.begin(),v.end()),v.end());
    for (int i=1; i<=n; i++)
    {
        insert(1,n,root[i-1],root[i],getid(a[i]));
    }
    while (m--)
    {
        int l,r,k;
        scanf("%d%d%d",&l,&r,&k);
        printf("%d\n",v[query(1,n,root[l-1],root[r],k)-1]);
    }
    return 0;
}

最近公共祖先（LCA）　　

#include<bits/stdc++.h>
using namespace std;
const int N=500010;
struct node
{
    int n,t;
} e[N*2];
int h[N],f[N][20],t,d[N],x,y;
void add(int u,int v)
{
    t++;
    e[t].t=v;
    e[t].n=h[u];
    h[u]=t;
}

void dfs(int x,int fa)
{
    d[x]=d[fa]+1;
    f[x][0]=fa;
    for (int i=1; (1<<i)<=d[x]; i++)
    {
        f[x][i]=f[f[x][i-1]][i-1];
    }
    for (int i=h[x]; i; i=e[i].n)
    {
        if (e[i].t!=fa)
        {
            dfs(e[i].t,x);
        }
    }
}

int lca(int x,int y)
{
    if (d[x]<d[y])
    {
        swap(x,y);
    }
    int h=d[x]-d[y],k=0;
    while (h)
    {
        if (h&1)
        {
            x=f[x][k];
        }
        h>>=1;
        k++;
    }
    if (x==y)
    {
        return x;
    }
    for (int k=19; k>=0; k--)
    {
        if (f[x][k]!=f[y][k])
        {
            x=f[x][k];
            y=f[y][k];
        }
    }
    return f[x][0];
}

int n,m,s;
int main()
{
    scanf("%d%d%d",&n,&m,&s);
    for (int i=1; i<n; i++)
    {
        scanf("%d%d",&x,&y);
        add(x,y);
        add(y,x);
    }
    dfs(s,0);
    for (int i=1;i<=m;i++){
        scanf("%d%d",&x,&y);
        printf("%d\n",lca(x,y));
    }
}

 

LCT

#include <iostream>
#include <ctime>
#include <cstdio>
#include <cctype>
namespace FastIO
{
char buf[1 << 21], buf2[1 << 21], a[20], *p1 = buf, *p2 = buf, hh = '\n';
int p, p3 = -1;
void read() {}
void print() {}
inline int getc()
{
    return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2) ? EOF : *p1++;
}
inline void flush()
{
    fwrite(buf2, 1, p3 + 1, stdout), p3 = -1;
}
template <typename T, typename... T2>
inline void read(T &x, T2 &... oth)
{
    int f = 0;
    x = 0;
    char ch = getc();
    while (!isdigit(ch))
    {
        if (ch == '-')
            f = 1;
        ch = getc();
    }
    while (isdigit(ch))
    {
        x = x * 10 + ch - 48;
        ch = getc();
    }
    x = f ? -x : x;
    read(oth...);
}
template <typename T, typename... T2>
inline void print(T x, T2... oth)
{
    if (p3 > 1 << 20)
        flush();
    if (x < 0)
        buf2[++p3] = 45, x = -x;
    do
    {
        a[++p] = x % 10 + 48;
    } while (x /= 10);
    do
    {
        buf2[++p3] = a[p];
    } while (--p);
    buf2[++p3] = hh;
    print(oth...);
}
} // namespace FastIO
#define read FastIO::read
#define print FastIO::print
//======================================
const int maxn = 1e5+5;
struct Node
{
    int fa,ch[2],val,res;   //res是异或结果
    bool tag;               //翻转懒标记
}spl[maxn];
//因为被毒瘤数据卡得TLE一个点，所以全部换成了#define。都是字面意思
#define ls(x) (spl[x].ch[0])
#define rs(x) (spl[x].ch[1])
#define fa(x) (spl[x].fa)
#define ident(x,f) (rs(f)==x)       //和下面的connect都是Splay的辅助函数
#define connect(x,f,s) spl[fa(x)=f].ch[s]=x
#define update(x) spl[x].res=spl[ls(x)].res^spl[rs(x)].res^spl[x].val
#define ntroot(x) (ls(fa(x))==x||rs(fa(x))==x)  //判断结点是否为Splay的根
#define reverse(x) std::swap(ls(x),rs(x)),spl[x].tag^=1
inline void pushdw(int x)           //懒标记下传
{
    if(spl[x].tag)
    {
        if(ls(x)) reverse(ls(x));
        if(rs(x)) reverse(rs(x));
    }
    spl[x].tag=0;
}
void pushall(int x)                 //头递归，从上到下下传所有懒标记
{
    if(ntroot(x)) pushall(fa(x));
    pushdw(x);
}
inline void rotate(int x)           //Splay基操
{
    int f=fa(x),ff=fa(f),k=ident(x,f);
    connect(spl[x].ch[k^1],f,k);
    fa(x)=ff;
    if(ntroot(f)) spl[ff].ch[ident(f,ff)]=x;//※重要，不能忘记判断，关系到虚实边
    connect(f,x,k^1);
    update(f),update(x);
}
inline void splaying(int x)         //Splay基操，都是伸展到根结点
{
    pushall(x);                     //要先把上面的懒标记全都下传
    while(ntroot(x))
    {
        int f=fa(x),ff=fa(f);
        if(ntroot(f)) ident(f,ff)^ident(x,f)?rotate(x):rotate(f);
        rotate(x);
    }
}
inline void access(int x)           //从x到原树根结点拉一条实链
{
    for(int y=0;x;x=fa(y=x))        //y为上一个Splay的根
    {
        splaying(x);                //伸展到当前Splay的根
        rs(x)=y;                    //右儿子连上上一个Splay的根
        update(x);                  //别忘更新＞﹏＜
    }
}
inline void mkroot(int x)           //给原树换根
{
    access(x);                      //先拉实链，拉好后x一定在Splay的最右（深度最大）
    splaying(x);                    //再伸展，伸展后x必定没有右儿子
    reverse(x);                     //翻转拉出来这条实链，使深度顺序翻转
}
inline int findroot(int x)          //寻找结点在原树的根
{
    access(x);                      //先拉实链
    splaying(x);                    //再伸展
    while(ls(x))                    //因为根结点必定深度最小，所以不停往左找就OK了
    {
        pushdw(x);                  //别忘了下传，第一个儿子是没问题的但是第二个往后……
        x=ls(x);
    }
    splaying(x);                    //用来保证时间复杂度，防止卡链
    return x;
}
inline void link(int x,int y)       //连边，不保证数据合法
{
    mkroot(x);                      //换根
    if(findroot(y)==x) return;      //如果y所在的树的根结点是x，那说明两者在一棵树上
    fa(x)=y;
}
inline void cut(int x,int y)        //断边，不保证数据合法
{
    mkroot(x);                      //换根
    //? 如果y跟x不在一棵树上 or x和y之间不是紧紧挨着的，return
    //! 注意这里findroot后由于保证复杂度的一句伸展，导致刚才被换成根的x成为了Splay的根结点
    //* 又因为x在原树中是根结点，深度最小，所以在Splay中一定是x为根结点y为其右儿子
    if(findroot(y)!=x||fa(y)!=x||ls(y)) return;
    fa(y)=rs(x)=0;                  //双向断边
    update(x);                      //别忘更新＞﹏＜
}
inline void split(int x,int y)      //把x--y的路径拆出来
{
    mkroot(x);                      //换根
    access(y);                      //拉实链
    splaying(y);                    //伸展
    //? 此时y必定没有右儿子且左儿子是一条到x的实链，所以访问y就可以作任何关于这条链的操作了
}
int main(int argc, char const *argv[])
{
#ifndef ONLINE_JUDGE
    freopen("in.in", "r", stdin);
    freopen("out.out", "w", stdout);
#endif
    clock_t c1 = clock();
    //======================================
    int n,m;
    read(n,m);
    //? 刚开始的时候所有点之间都没连着
    for(int i=1;i<=n;i++) read(spl[i].val);
    while(m--)
    {
        int opt,x,y;
        read(opt,x,y);
        switch(opt)
        {
        case 0:
            split(x,y);
            print(spl[y].res);      //访问y就相当于访问这条链了
            break;
        case 1:
            link(x,y);
            break;
        case 2:
            cut(x,y);
            break;
        case 3:
            splaying(x);            //注意要先伸展到根，否则会很麻烦
            spl[x].val=y;
            update(x);              //不更新也没啥问题，加不加都行
            break;
        }
    }
    //======================================
    FastIO::flush();
    std::cerr << "Time:" << clock() - c1 << "ms" << std::endl;
    return 0;
}

可持久化并查集

#include <iostream>
#include <ctime>
#include <cstdio>
#include <cctype>
namespace FastIO
{
char buf[1 << 21], buf2[1 << 21], a[20], *p1 = buf, *p2 = buf, hh = '\n';
int p, p3 = -1;
void read() {}
void print() {}
inline int getc()
{
    return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2) ? EOF : *p1++;
}
inline void flush()
{
    fwrite(buf2, 1, p3 + 1, stdout), p3 = -1;
}
template <typename T, typename... T2>
inline void read(T &x, T2 &... oth)
{
    int f = 0;
    x = 0;
    char ch = getc();
    while (!isdigit(ch))
    {
        if (ch == '-')
            f = 1;
        ch = getc();
    }
    while (isdigit(ch))
    {
        x = x * 10 + ch - 48;
        ch = getc();
    }
    x = f ? -x : x;
    read(oth...);
}
template <typename T, typename... T2>
inline void print(T x, T2... oth)
{
    if (p3 > 1 << 20)
        flush();
    if (x < 0)
        buf2[++p3] = 45, x = -x;
    do
    {
        a[++p] = x % 10 + 48;
    } while (x /= 10);
    do
    {
        buf2[++p3] = a[p];
    } while (--p);
    buf2[++p3] = hh;
    print(oth...);
}
} // namespace FastIO
#define read FastIO::read
#define print FastIO::print
//======================================
const int maxn = 2e5+5;
int n;
struct Node
{
    int l,r,val;
}hjt[maxn*40*2];
int cnt,rootfa[maxn],rootdep[maxn],tot;
void build(int l,int r,int &now)
{
    now = ++cnt;
    if(l==r)
    {
        hjt[now].val=++tot;
        return;
    }
    int m = (l+r)>>1;
    build(l,m,hjt[now].l);
    build(m+1,r,hjt[now].r);
}
void modify(int l,int r,int ver,int &now,int pos,int val)
{
    hjt[now=++cnt]=hjt[ver];
    if(l==r)
    {
        hjt[now].val=val;
        return;
    }
    int m = (l+r)>>1;
    if(pos<=m) modify(l,m,hjt[ver].l,hjt[now].l,pos,val);
    else modify(m+1,r,hjt[ver].r,hjt[now].r,pos,val);
}
int query(int l,int r,int now,int pos)
{
    if(l==r) return hjt[now].val;
    int m = (l+r)>>1;
    if(pos<=m) return query(l,m,hjt[now].l,pos);
    else return query(m+1,r,hjt[now].r,pos);
}
int find(int ver,int x)
{
    int fx = query(1,n,rootfa[ver],x);
    return fx==x?x:find(ver,fx);
}
void merge(int ver,int x,int y)
{
    x = find(ver-1,x);          //ver-1
    y = find(ver-1,y);
    if(x==y)
    {
        rootfa[ver]=rootfa[ver-1];
        rootdep[ver]=rootdep[ver-1];
    }
    else
    {
        int depx = query(1,n,rootdep[ver-1],x);
        int depy = query(1,n,rootdep[ver-1],y);
        if(depx<depy)
        {
            modify(1,n,rootfa[ver-1],rootfa[ver],x,y);
            rootdep[ver]=rootdep[ver-1];
        }
        else if(depx>depy)
        {
            modify(1,n,rootfa[ver-1],rootfa[ver],y,x);
            rootdep[ver]=rootdep[ver-1];
        }
        else
        {
            modify(1,n,rootfa[ver-1],rootfa[ver],x,y);
            modify(1,n,rootdep[ver-1],rootdep[ver],y,depy+1);
        }
    }
}
int main(int argc, char const *argv[])
{
#ifndef ONLINE_JUDGE
    freopen("in.in", "r", stdin);
    freopen("out.out", "w", stdout);
#endif
    clock_t c1 = clock();
    //======================================
    int m;
    read(n,m);
    build(1,n,rootfa[0]);
    for(int ver=1;ver<=m;ver++)
    {
        int opt,x,y;
        read(opt);
        switch(opt)
        {
        case 1:
            read(x,y);
            merge(ver,x,y);
            break;
        case 2:
            read(x);
            rootfa[ver]=rootfa[x];
            rootdep[ver]=rootdep[x];
            break;
        case 3:
            read(x,y);
            rootfa[ver]=rootfa[ver-1];
            rootdep[ver]=rootdep[ver-1];
            int fx = find(ver,x);
            int fy = find(ver,y);
            print(fx==fy?1:0);
            break;
        }
    }
    //======================================
    FastIO::flush();
    std::cerr << "Time:" << clock() - c1 << "ms" << std::endl;
    return 0;
}

可持久化数组

#include <iostream>
#include <ctime>
#include <cstdio>
#include <cctype>
namespace FastIO
{
char buf[1 << 21], buf2[1 << 21], a[20], *p1 = buf, *p2 = buf, hh = '\n';
int p, p3 = -1;
void read() {}
void print() {}
inline int getc()
{
    return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2) ? EOF : *p1++;
}
inline void flush()
{
    fwrite(buf2, 1, p3 + 1, stdout), p3 = -1;
}
template <typename T, typename... T2>
inline void read(T &x, T2 &... oth)
{
    int f = 0;
    x = 0;
    char ch = getc();
    while (!isdigit(ch))
    {
        if (ch == '-')
            f = 1;
        ch = getc();
    }
    while (isdigit(ch))
    {
        x = x * 10 + ch - 48;
        ch = getc();
    }
    x = f ? -x : x;
    read(oth...);
}
template <typename T, typename... T2>
inline void print(T x, T2... oth)
{
    if (p3 > 1 << 20)
        flush();
    if (x < 0)
        buf2[++p3] = 45, x = -x;
    do
    {
        a[++p] = x % 10 + 48;
    } while (x /= 10);
    do
    {
        buf2[++p3] = a[p];
    } while (--p);
    buf2[++p3] = hh;
    print(oth...);
}
} // namespace FastIO
#define read FastIO::read
#define print FastIO::print
//======================================
const int maxn = 1e6+5;
int a[maxn];
struct Node
{
    int l,r,val;
}hjt[maxn*40];
int cnt,root[maxn];
void build(int l,int r,int &now)
{
    now=++cnt;
    if(l==r)
    {
        hjt[now].val=a[l];
        return;
    }
    int m = (l+r)>>1;
    build(l,m,hjt[now].l);
    build(m+1,r,hjt[now].r);
}
void modify(int l,int r,int ver,int &now,int &pos,int &num)
{
    hjt[now=++cnt]=hjt[ver];
    if(l==r)
    {
        hjt[now].val=num;
        return;
    }
    int m = (l+r)>>1;
    if(pos<=m) modify(l,m,hjt[ver].l,hjt[now].l,pos,num);
    else modify(m+1,r,hjt[ver].r,hjt[now].r,pos,num);
}
int query(int l,int r,int now,int &pos)
{
    if(l==r) return hjt[now].val;
    int m = (l+r)>>1;
    if(pos<=m) return query(l,m,hjt[now].l,pos);
    else return query(m+1,r,hjt[now].r,pos);
}
int main(int argc, char const *argv[])
{
#ifndef ONLINE_JUDGE
    freopen("in.in", "r", stdin);
    freopen("out.out", "w", stdout);
#endif
    clock_t c1 = clock();
    //======================================
    int n,m,ver,opt,x,y;
    read(n,m);
    for(int i=1;i<=n;i++) read(a[i]);
    build(1,n,root[0]);
    for(int i=1;i<=m;i++)
    {
        read(ver,opt);
        switch(opt)
        {
        case 1:
            read(x,y);
            modify(1,n,root[ver],root[i],x,y);
            break;
        case 2:
            read(x);
            print(query(1,n,root[ver],x));
            root[i]=root[ver];
            break;
        }
    }
    //======================================
    FastIO::flush();
    std::cerr << "Time:" << clock() - c1 << "ms" << std::endl;
    return 0;
}

 次小生成树

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;

const int maxn=1e5+10;
const ll inf=0x3f3f3f3f;

int n,m,fa[maxn],val1,val2,dp[3][maxn][20],t,head[maxn],f[maxn][20],deep[maxn];
ll ans,ans_max;
struct edge1 {
    int v, next,w;
}e[maxn*2];
struct edge2 {
    int u, v, w, vis;

    bool operator<(const edge2 &b) const {
        return w < b.w;
    }
}a[maxn*3];

void add(int u,int v,int w) {
    t++;
    e[t].v = v;
    e[t].w = w;
    e[t].next = head[u];
    head[u] = t;
}

int fin(int x){
    return x==fa[x]?x:fa[x]=fin(fa[x]);
}
void Kruskal() {
    sort(a + 1, a + m + 1);
    for (int i = 1; i <= m; i++) {
        int u = fin(a[i].u);
        int v = fin(a[i].v);
        if (u == v) continue;
        fa[u] = v;
        a[i].vis = 1;
        ans += 1ll*a[i].w;
        add(a[i].u, a[i].v, a[i].w);
        add(a[i].v, a[i].u, a[i].w);
    }
}

void dfs(int u,int fa) {

    for (int i = 1; (1 << i) <= deep[u]; i++) {
        f[u][i] = f[f[u][i - 1]][i - 1];

        dp[0][u][i] = max(dp[0][u][i - 1], dp[0][f[u][i - 1]][i - 1]);
        if (dp[0][u][i - 1] != dp[0][f[u][i - 1]][i - 1]) {
            dp[1][u][i] = min(dp[0][u][i - 1], dp[0][f[u][i - 1]][i - 1]);
            dp[1][u][i] = max(dp[1][u][i], dp[1][u][i - 1]);
            dp[1][u][i] = max(dp[1][u][i], dp[1][f[u][i - 1]][i - 1]);
        }
        else
            dp[1][u][i] = max(dp[1][u][i - 1], dp[1][f[u][i - 1]][i - 1]);
    }

    for (int i = head[u]; i; i = e[i].next) {
        int v = e[i].v;
        if (v == fa) continue;
        f[v][0] = u;
        dp[0][v][0] = e[i].w;
        dp[1][v][0] = -inf;
        deep[v] = deep[u] + 1;
        dfs(v, u);
    }
}

void update2(int x) {
    if (x > val1) {
        val2 = val1;
        val1 = x;
    } else if (x > val2 && x != val1)
        val2 = x;
}

void update(int x,int i) {
    update2(dp[0][x][i]);
    update2(dp[1][x][i]);
}

void lca(int x,int y) {
    val1 = val2 = -inf;
    if (deep[x] < deep[y]) {
        swap(x, y);
    }
    int h = deep[x] - deep[y], k = 0;
    while (h) {

        if (h & 1) {
            update(x,k);
            x = f[x][k];
        }
        h >>= 1;
        k++;
    }
    if (x == y) return;
    for (int k = 19; k >= 0; k--) {
        if (f[x][k] != f[y][k]) {
            update(x, k);
            x = f[x][k];
            update(y, k);
            y = f[y][k];
        }
    }
    update(x,0);
    update(y,0);
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i=1;i<=n;i++){
        fa[i]=i;
    }
    for (int i = 1; i <= m; i++) {
        scanf("%d%d%d", &a[i].u, &a[i].v, &a[i].w);
    }
    Kruskal();
    dfs(1, 0);
    ans_max = 0x3f3f3f3f3f3f3f3f;
    for (int i = 1; i <= m; i++) {
        if (!a[i].vis) {
            lca(a[i].u, a[i].v);
            if (val1 != a[i].w)
                ans_max = min(ans_max, ans - val1 + a[i].w);
            else ans_max = min(ans_max, ans - val2 + a[i].w);
        }
    }
    printf("%lld\n", ans_max);
}

 割点模板

#include <bits/stdc++.h>

using namespace std;
const int maxn=20010;
int cnt[maxn],t,tim,sta[maxn],dfn[maxn],low[maxn],top,head[maxn],flag,root;
struct edge{
    int to,next;
}e[maxn*5];
void add(int u,int v){
    t++;
    e[t].to=v;
    e[t].next=head[u];
    head[u]=t;
}

void tarjan(int u) {
    low[u] = dfn[u] = ++tim;
    int flag=0;
    for (int i = head[u]; i; i = e[i].next) {
        int v = e[i].to;
        if (!dfn[v]) {//不曾访问过,也就是没有标记,可以认为是儿子节点了
            tarjan(v);//访问儿子节点y,并且设置边为当前边
            low[u] = min(low[u], low[v]);//看看能不能更新,也就是定义中的,subtree(x)中的节点最小值为low[x]
            //subtree(x)表示搜索树中以x节点为根的子树节点集合
            if (low[v] >= dfn[u]) {//这就是割点的判定
                flag++;//割点数量++
                if (u != root || flag > 1) //不能是根节点,或者说是根节点,但是有至少两个子树节点是割点
                    cnt[u] = 1;
            }
        } else
            low[u] = min(low[u], dfn[v]);//第二类定义,也就是通过1跳不在搜索树上的边,能够抵达subtree(x)的节点
    }
}
int main() {
    int n,m, ans=0;
    scanf("%d%d", &n, &m);
    for (int i = 1, u, v; i <= m; i++) {
        scanf("%d%d", &u, &v);
        add(u, v);
        add(v, u);
    }
    for (int i = 1; i <= n; i++) {
        if (!dfn[i]) {        //一个无向图,可能由多个搜索树构成
            root = i;
            tarjan(i);
        }
    }
    for (int i = 1; i <= n; i++) {//统计割点个数
        if (cnt[i]) ans++;
    }
    int num=0;
    printf("%d\n", ans);
    for (int i = 1; i <= n; i++) {
        if (cnt[i]) {
            num++;
            printf("%d", i);
            if (num < ans) printf(" "); else printf("\n");
        }//顺序遍历,康康哪些点是割点
    }
    return 0;
}

割边模板

#include <bits/stdc++.h>

using namespace std;
const int maxn=100010;
int cnt[maxn],t,tim,bridge[maxn*6],dfn[maxn],low[maxn],top,head[maxn],flag,root;
struct edge{
    int to,next;
}e[maxn*6];
void add(int u,int v){
    t++;
    e[t].to=v;
    e[t].next=head[u];
    head[u]=t;
}

void tarjan(int u,int edge) {
    low[u] = dfn[u] = ++tim;
    for (int i = head[u]; i; i = e[i].next) {
        int v = e[i].to;
        if (!dfn[v]) {//不曾访问过,也就是没有标记,可以认为是儿子节点了
            tarjan(v, i);//访问儿子节点y,并且设置边为当前边
            low[u] = min(low[u], low[v]);//看看能不能更新,也就是定义中的,subtree(x)中的节点最小值为low[x]
            //subtree(x)表示搜索树中以x节点为根的子树节点集合
            if (low[v] > dfn[u]) //这就是割点的判定
                bridge[i] = bridge[i ^ 1] = 1;//重边也是桥
        } else if (i != (edge ^ 1))
            low[u] = min(low[u], dfn[v]);//第二类定义,也就是通过1跳不在搜索树上的边,能够抵达subtree(x)的节点
    }
}
int main() {
    t = 1;
    int n, m, ans = 0;
    scanf("%d%d", &n, &m);
    for (int i = 1, u, v; i <= m; i++) {
        scanf("%d%d", &u, &v);
        add(u, v);
        add(v, u);
    }
    for (int i = 1; i <= n; i++) {
        if (!dfn[i])       //一个无向图,可能由多个搜索树构成
            tarjan(i, 0);
    }
    int num=0;
    for (int i = 2; i <= t; i+=2) {
        if (bridge[i])
            num++;
    }
    printf("%d\n",m-num);
}

 Tarjan

void tarjan(int u) {
    low[u] = dfn[u] = ++index;
    stack[top++] = u;
    for (int i = head[u]; i; i = e[i].next) {
        int v = e[i].to;
        if (!dfn[v]) {
            tarjan(v);
            low[u] = min(low[u], low[v]);
        } else {
            if (!blong[v]) {
                low[u] = min(low[u], dfn[v]);
            }
        }
    }
    if (dfn[u] == low[u]) {
        scc++;
        for (;;) {
            v = stack[--top];
            belong[v] = scc;
            if (v == u) break;
        }
    }
}

 

动态查询区间第k大

#include <bits/stdc++.h>

using namespace std;

const int maxn=250000;
const int M=250000*400;
int n,q,m,tot;
int a[maxn],t[maxn];
int T[maxn],lson[M],rson[M],c[M];
int S[maxn];
struct Query{
    int kind;
    int l,r,k;
}query[100100];
void init_hash(int k){
    sort(t,t+k);
    m=unique(t,t+k)-t;
}
int hash1(int x){
    return lower_bound(t,t+m,x)-t;
}

int build(int l,int r) {
    int root = tot++;
    c[root] = 0;
    if (l != r) {
        int mid = (l + r) >> 1;
        lson[root] = build(l, mid);
        rson[root] = build(mid + 1, r);
    }
    return root;
}

int insert(int root,int pos,int val) {
    int newroot = tot++, tmp = newroot;
    int l = 0, r = m - 1;
    c[newroot] = c[root] + val;
    while (l < r) {
        int mid = (l + r) >> 1;
        if (pos <= mid) {
            lson[newroot] = tot++;
            rson[newroot] = rson[root];
            newroot = lson[newroot];
            root = lson[root];
            r = mid;
        } else {
            rson[newroot] = tot++;
            lson[newroot] = lson[root];
            newroot = rson[newroot];
            root = rson[root];
            l = mid + 1;
        }
        c[newroot] = c[root] + val;
    }
    return tmp;
}

int lowbit(int x) {
    return x & -x;
}

int use[maxn];

int sum(int x) {
    int ret = 0;
    while (x) {
        ret += c[lson[use[x]]];
        x -= lowbit(x);
    }
    return ret;
}

int Query(int left,int right,int k) {
    int left_root = T[left - 1];
    int right_root = T[right];
    int l = 0, r = m - 1;
    for (int i = left - 1; i; i -= lowbit(i)) use[i] = S[i];
    for (int i = right; i; i -= lowbit(i)) use[i] = S[i];
    while (l < r) {
        int mid = (l + r) >> 1;
        int tmp = sum(right) - sum(left - 1) + c[lson[right_root]] - c[lson[left_root]];
        if (tmp >= k) {
            r = mid;
            for (int i = left - 1; i; i -= lowbit(i)) use[i] = lson[use[i]];
            for (int i = right; i; i -= lowbit(i)) use[i] = lson[use[i]];
            left_root = lson[left_root];
            right_root = lson[right_root];
        } else {
            l = mid + 1;
            k -= tmp;
            for (int i = left - 1; i; i -= lowbit(i)) use[i] = rson[use[i]];
            for (int i = right; i; i -= lowbit(i)) use[i] = rson[use[i]];
            left_root = rson[left_root];
            right_root = rson[right_root];
        }
    }
    return l;
}

void Modify(int x,int p,int d) {
    while (x <= n) {
        S[x] = insert(S[x], p, d);
        x += lowbit(x);
    }
}

int main() {
    scanf("%d%d", &n, &q);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
        t[m++] = a[i];
    }
    char op[10];
    for (int i = 0; i < q; i++) {
        scanf("%s", op);
        if (op[0] == 'Q') {
            query[i].kind = 0;
            scanf("%d%d%d", &query[i].l, &query[i].r, &query[i].k);
        } else {
            query[i].kind = 1;
            scanf("%d%d", &query[i].l, &query[i].r);
            t[m++] = query[i].r;
        }
    }
    init_hash(m);
    T[0] = build(0, m - 1);
    for (int i = 1; i <= n; i++) {
        T[i] = insert(T[i - 1], hash1(a[i]), 1);
    }
    for (int i = 1; i <= n; i++) {
        S[i] = T[0];
    }
    for (int i = 0; i < q; i++) {
        if (query[i].kind == 0) {
            printf("%d\n", t[Query(query[i].l, query[i].r, query[i].k)]);
        } else {
            Modify(query[i].l, hash1(a[query[i].l]), -1);
            Modify(query[i].l, hash1(query[i].r), 1);
            a[query[i].l] = query[i].r;
        }
    }
    return 0;
}