BZOJ 一句话题解

菜鸡刷题记录

 [题号：题解]

---

1008：简单排列组合

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

#define ll long long
const ll MOD = (ll)1e5 + 3;
ll n, m;

ll qmod(ll base, ll n)
{
    ll res = 1;
    while (n)
    {
        if (n & 1) res = res * base % MOD;
        base = base * base % MOD;
        n >>= 1;
    }
    return res; 
}

int main()
{
    while (scanf("%lld%lld", &m, &n) != EOF)
        printf("%lld
", (qmod(m, n) - (m % MOD * qmod(m - 1, n - 1) % MOD) + MOD) % MOD);
    return 0;
}

1012：BIT维护后缀最大

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

#define N 1000010
#define ll long long
int m, n; ll D;

struct BIT
{
    ll a[N];
    void Init() { memset(a, 0, sizeof a); } 
    void update(int x, ll val)
    {
        for (; x; x -= x & -x)
            a[x] = max(a[x], val);
    }
    ll query(int x)
    {
        ll res = 0;
        for (; x <= n; x += x & -x)   
            res = max(res, a[x]); 
        return res; 
    }
}bit;

void Run()
{
    scanf("%d%lld", &m, &D);
    bit.Init();
    char op; ll x, lastans = 0; n = 0;
    for (int i = 1; i <= m; ++i)
    {
        scanf(" %c%lld", &op, &x);
        if (op == 'Q') printf("%lld
", lastans = bit.query(n - x + 1));
        else bit.update(++n, (x + lastans) % D);
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin); 
    #endif 

    Run();
    return 0;

}

1051：Tarjan缩点

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

#define pii pair <int, int>
#define N 10010

int n, m;
map <pii, bool> mp;
vector <int> G[N];
int Low[N], DFN[N], Stack[N], Belong[N], sze[N], degree[N], cnt, sec, top;
bool Instack[N];

void Tarjan(int u)
{
    Low[u] = DFN[u] = ++cnt;
    Stack[top++] = u;
    Instack[u] = 1;
    for (int i = 0, len = G[u].size(); i < len; ++i)
    {
        int v = G[u][i];
        if (!DFN[v])
        {
            Tarjan(v);
            Low[u] = min(Low[u], Low[v]);
        }
        else if (Instack[v]) Low[u] = min(Low[u], DFN[v]);
    }
    if (DFN[u] == Low[u]) 
    {
        ++sec; int v;
        do
        {
            v = Stack[--top]; 
            Instack[v] = 0;
            Belong[v] = sec;
            ++sze[sec];    
        } while (v != u);
    }
}

int Run()
{
    for (int i = 1; i <= n; ++i) if (!DFN[i])
        Tarjan(i);
    for (int u = 1; u <= n; ++u)
    {
        for (int i = 0, len = G[u].size(); i < len; ++i)
        {
            int v = G[u][i];
            if (Belong[v] != Belong[u])
            ++degree[Belong[u]];
        }
    }
    int flag = 0;
    for (int i = 1; i <= sec; ++i) if (!degree[i]) ++flag; 
    if (flag > 1) return 0;
    for (int i = 1; i <= sec; ++i) if (!degree[i])
        return sze[i];
    return 0;
}

int main()
{
    while (scanf("%d%d", &n, &m) != EOF)
    {
        for (int i = 1; i <= n; ++i) G[i].clear();
        mp.clear(); cnt = 0; sec = 0; top = 0;
        memset(sze, 0, sizeof sze);
        memset(degree, 0, sizeof degree);    
        for (int i = 1, u, v; i <= m; ++i)
        {
            scanf("%d%d", &u, &v);
            if(mp.find(pii(u, v)) != mp.end()) continue;
            G[u].push_back(v);
            mp[pii(u, v)] = 1;
        }
        printf("%d
", Run());
    }
    return 0;
}

1086：树分块

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

#define N 1010

int n, b;
vector <int> G[N];
stack <int> sta;
int Belong[N], sze[N], cap[N], cnt;

void DFS(int u, int fa)
{
    sze[u] = 0;
    sta.push(u); 
    for (int i = 0, v, len = G[u].size(); i < len; ++i) if ((v = G[u][i]) != fa)
    {
        DFS(v, u);
        sze[u] += sze[v];
        if (sze[u] >= b) 
        {
            sze[u] = 0;
            cap[++cnt] = u;
            while (!sta.empty() && sta.top() != u) { Belong[sta.top()] = cnt; sta.pop(); }
        }
    } 
    ++sze[u];
}

void DFS2(int u, int fa, int sp)
{
    Belong[u] ? sp = Belong[u] : Belong[u] = sp;
    for (int i = 0, v, len = G[u].size(); i < len; ++i) if ((v = G[u][i]) != fa)
        DFS2(v, u, sp);
}

void Run()
{
    while (scanf("%d%d", &n, &b) != EOF)
    {
        if (n < b) { puts("0"); continue; }
        for (int i = 1; i <= n; ++i) G[i].clear();
        while (!sta.empty()) sta.pop();
        cnt = 0;
        memset(Belong, 0, sizeof Belong);
        for (int i = 1, u, v; i < n; ++i)
        {
            scanf("%d%d", &u, &v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        DFS(1, 1); DFS2(1, 1, cnt);
        if (!cnt) cap[cnt = 1] = 1;
        printf("%d
", cnt);
        for (int i = 1; i <= n; ++i) printf("%d%c", Belong[i], " 
"[i == n]);
        for (int i = 1; i <= cnt; ++i) printf("%d%c", cap[i], " 
"[i == cnt]);
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;

}

1216：模拟+优先队列，主要不要暴力枚举时间

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

#define N 1501000
#define ll long long
struct node
{
    int id,  pri; ll arrive, time;
    int scan() { return scanf("%d%lld%lld%d", &id, &arrive, &time, &pri); }
    void output(ll now) { printf("%d %lld
", id, now); }
    bool operator < (const node &r) const
    {
        return pri < r.pri || (pri == r.pri && id > r.id); 
    }
}arr[N];

priority_queue <node> q;

int main()
{
    int n;
    for (n = 1; ; ++n) if (arr[n].scan() == EOF) break; --n;
    while (!q.empty()) q.pop(); 
    ll t = 0;
    for (int i = 1; i <= n; ++i)
    {
        if (q.empty())
        {
            q.push(arr[i]);
            t = max(t, arr[i].arrive);
        }
        else
        {
            node tmp = q.top(); 
            while (t + tmp.time <= arr[i].arrive)
            {
                t += tmp.time;
                q.pop();
                tmp.output(t);
                if (q.empty()) break;
                tmp = q.top();
            }
            if (t < arr[i].arrive && !q.empty())
            {
                ll gap = arr[i].arrive - t;
                tmp = q.top(); q.pop();
                tmp.time -= gap;
                q.push(tmp);
                t = arr[i].arrive; 
            }
            q.push(arr[i]);
            t = max(t, arr[i].arrive);
        }
    }
    while (!q.empty())
    {
        node tmp = q.top(); q.pop();
        t += tmp.time;    
        tmp.output(t); 
    }
    return 0;
}

1635：差分+坑 有重复

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

#define N 10100
#define pii pair <int, int>
int n, i, h, q;
int ans[N];
map <pii, bool> mp;

int main()
{
    while (scanf("%d%d%d%d", &n, &i, &h, &q) != EOF)
    {
        memset(ans, 0, sizeof ans);
        mp.clear();
        for (int i = 1, l, r; i <= q; ++i)
        {
            scanf("%d%d", &l, &r);
            if (l > r) swap(l, r);
            if (mp.find(pii(l, r)) != mp.end()) continue;
            mp[pii(l, r)] = 1;
            --ans[l + 1]; ++ans[r];
        }
        for (int i = 1; i <= n; ++i) ans[i] += ans[i - 1];
        for (int i = 1; i <= n; ++i) printf("%d
", h + ans[i]);
    }
    return 0;
}

1935：排序一维，树状数组一维

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

#define N 3000010 

int n, q, m;
int ans[N], brr[N];
struct node
{
    // 0 insert
    // 1 add
    // 2 sub
    int op, x, y, id; 
    node() {}
    node(int op, int x, int y, int id) : op(op), x(x), y(y), id(id) {}
    bool operator < (const node &r) const
    { 
        return x == r.x ? id < r.id : x < r.x; 
    }
}arr[N];

struct BIT
{
    int a[N]; 

    void Init()
    {
        memset(a, 0, sizeof a);
    }

    void update(int x, int val)
    {
        while (x <= m)  
        {
            a[x] += val;
            x += x & -x;
        }
    }

    int query(int x)
    {
        int res = 0;
        while (x)
        {
            res += a[x];
            x -= x & -x;
        }
        return res;
    }
}bit;

void Hash()
{
    sort(brr + 1, brr + 1 + m);
    int    tmp = unique(brr + 1, brr + 1 + m) - brr - 1; 
    for (int i = 1; i <= m; ++i)
        arr[i].y = lower_bound(brr + 1, brr + 1 + tmp, arr[i].y) - brr; 
}

void Run()
{
    while (scanf("%d%d", &n, &q) != EOF)
    {
        m = n;
        for (int i = 1, x, y; i <= n; ++i)
        {
            scanf("%d%d", &x, &y);
            arr[i] = node(0, x, y, 0); 
            brr[i] = y; 
        }
        for (int i = 1, x[2], y[2]; i <= q; ++i)
        {
            for (int j = 0; j < 2; ++j) scanf("%d%d", x + j, y + j);
            arr[++m] = node(1, x[1], y[1], i); brr[m] = y[1]; 
            arr[++m] = node(1, x[0] - 1, y[0] - 1, i); brr[m] = y[0] - 1;
            arr[++m] = node(-1, x[1], y[0] - 1, i); brr[m] = y[0] - 1;
            arr[++m] = node(-1, x[0] - 1, y[1], i); brr[m] = y[1];
        }
        Hash();  
        sort(arr + 1, arr + 1 + m);   
        for (int i = 1; i <= m; ++i)
        {
            if (arr[i].id == 0) bit.update(arr[i].y, 1);
            else
                ans[arr[i].id] += bit.query(arr[i].y) * arr[i].op;
        }
        for (int i = 1; i <= q; ++i) printf("%d
", ans[i]); 
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin); 
    #endif 

    Run();
    return 0;
}

2014：虚树+DP

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

#define ll long long
#define INF 0x3f3f3f3f3f3f3f3f
#define N 1000010
int n, q, k, a[N];

struct Graph
{
    struct node
    {
        int to, nx;
        node() {}
        node(int to, int nx) : to(to), nx(nx) {}
    }a[N << 1];
    int head[N], pos;
    void init() { memset(head, 0, sizeof head); pos = 0; }
    void add(int u, int v)
    {
        a[++pos] = node(v, head[u]); head[u] = pos;
        a[++pos] = node(u, head[v]); head[v] = pos;
    }
}g[2];
#define erp(id, u) for (int it = g[id].head[u], v = g[id].a[it].to; it; it = g[id].a[it].nx, v = g[id].a[it].to)

int fa[N], son[N], top[N], p[N], cnt; ll deep[N], sze[N];
void DFS(int u)       
{
    sze[u] = 1;
    erp(0, u) if (v != fa[u]) 
    {
        fa[v] = u;
        deep[v] = deep[u] + 1;
        DFS(v); sze[u] += sze[v];
        if (!son[u] || sze[v] > sze[son[u]]) son[u] = v;
    }
}

void getpos(int u, int sp)
{
    top[u] = sp;
    p[u] = ++cnt;
    if (!son[u]) return;
    getpos(son[u], sp);
    erp(0, u) if (v != fa[u] && v != son[u]) 
        getpos(v, v);
}     

int querylca(int u, int v)
{
    while (top[u] != top[v])
    {
        if (deep[top[u]] < deep[top[v]]) swap(u, v);
        u = fa[top[u]];
    }
    if (deep[u] > deep[v]) swap(u, v); 
    return u;
}

ll Max[N], Min[N], sum[N], res_Max, res_Min, res_sum; int vis[N]; 
void dp(int u, int fa)
{
    Max[u] = 0; Min[u] = INF; sum[u] = 0;
    sze[u] = vis[u];
    erp(1, u) if (v != fa)
        dp(v, u), sze[u] += sze[v]; 
    if (vis[u]) Max[u] = Min[u] = sum[u] = deep[u];  
    erp(1, u) if (v != fa)
    {
        sum[u] += sum[v];
        res_sum += (sum[v] - deep[u] * sze[v]) * (sze[u] - sze[v]); 
        if (Max[u]) res_Max = max(res_Max, Max[u] + Max[v] - 2 * deep[u]); 
        Max[u] = max(Max[u], Max[v]);
        if (Min[v] != INF) res_Min = min(res_Min, Min[u] + Min[v] - 2 * deep[u]);
        Min[u] = min(Min[u], Min[v]);
    }
    vis[u] = 0;  g[1].head[u] = 0; 
}

bool cmp(int a, int b) { return p[a] < p[b]; } 

void init()
{
    g[0].init(); g[1].init(); cnt = 0;
    memset(son, 0, sizeof son);
}

int stktop, stk[N];
void Run()
{
    while (scanf("%d", &n) != EOF)
    {
        init();
        for (int i = 1, u, v; i < n; ++i)
        {
            scanf("%d%d", &u, &v);
            g[0].add(u, v);
        } deep[1] = 1; DFS(1); getpos(1, 1);  
        scanf("%d", &q);
        for (int qq = 1; qq <= q; ++qq)
        {
            scanf("%d", &k);
            for (int i = 1; i <= k; ++i) scanf("%d", a + i);
            sort(a + 1, a + 1 + k, cmp); 
            for (int i = 1; i <= k; ++i) vis[a[i]] = 1;  
            stk[stktop = 1] = 1;  g[1].pos = 0;
            for (int i = 1; i <= k; ++i)
            {
                int lca = querylca(stk[stktop], a[i]);
                while (deep[lca] < deep[stk[stktop]])
                {
                    if (deep[stk[stktop - 1]] <= deep[lca])
                    {
                        int last = stk[stktop--];
                        if (stk[stktop] != lca) stk[++stktop] = lca; 
                        g[1].add(last, lca);
                        break;
                    }
                    g[1].add(stk[stktop - 1], stk[stktop]), --stktop;
                }
                if (stk[stktop] != a[i]) stk[++stktop] = a[i];
            }
            while (stktop > 1) g[1].add(stk[stktop - 1], stk[stktop]), --stktop;
            res_Max = 0, res_Min = INF; res_sum = 0;   
            dp(1, 1);
            printf("%lld %lld %lld
", res_sum, res_Min, res_Max);  
        }
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;
}

2056：特判+不要用iostream

#include <cstdio>
#define ull unsigned long long
int t, a[10];
ull res;

int main()
{
    scanf("%d", &t);
    while (t--)
    {
        for (int i = 1; i <= 8; ++i) scanf("%d", a + i);
        scanf("%llu", &res); 
        for (int i = 1; i <= 8; ++i) res += 1ll << a[i];
        if (res == 0) res = -1;
        if (res != -1) printf("%llu
", res);    
        else 
        {
            printf("%llu", res / 10);
            puts("6");
        }
    }
    return 0;
}

2120：带修改莫队

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

#define N 100010
#define block 400

int n, q, cnt_que, cnt_op;
int arr[N], brr[N], ans[N], cnt[N * 10], res;

struct QUE
{
    int l, r, id, ti; 
    void scan(int id, int ti)
    {
        this->id = id;
        this->ti = ti;
        scanf("%d%d", &l, &r);
    }
    bool operator < (const QUE &r) const
    {
        int posl = l / block, posr = r.l / block;
        return posl == posr ? this->r < r.r : posl < posr; 
    }
}que[N];

struct OP
{
    int pre, v, id;
    void scan()
    {
        scanf("%d%d", &id, &v);
        pre = brr[id];
        brr[id] = v;
    }
}op[N];

void update(int x, int val)
{
    if (val == -1)
    {
        if (cnt[arr[x]] == 1) --res;
        --cnt[arr[x]];
    }
    else
    {
        ++cnt[arr[x]];
        if (cnt[arr[x]] == 1) ++res; 
    }
}

void change(int ti, int vis, int l, int r)
{
    int pos = op[ti].id;
    int v = vis ? op[ti].v : op[ti].pre;
    if (pos >= l && pos <= r)
    {
        update(pos, -1);
        arr[pos] = v;
        update(pos, 1);
    }
    else arr[pos] = v; 
}

void Run()
{
    while (scanf("%d%d", &n, &q) != EOF)
    {
        cnt_que = cnt_op = res = 0; 
        for (int i = 1; i <= n; ++i) scanf("%d", arr + i); 
        for (int i = 1; i <= n; ++i) brr[i] = arr[i];
        char opp;
        for (int i = 1; i <= q; ++i)
        {
            scanf(" %c", &opp); 
            if (opp == 'Q') que[++cnt_que].scan(cnt_que, cnt_op);
            else op[++cnt_op].scan();
        }
        sort(que + 1, que + 1 + cnt_que);
        for (int i = 1, l = 1, r = 0, ti = 0; i <= cnt_que; ++i)
        {
            for (; ti < que[i].ti; ++ti) change(ti + 1, 1, l, r);
            for (; ti > que[i].ti; --ti) change(ti, 0, l, r);
            for (; r < que[i].r; ++r) update(r + 1, 1);
            for (; r > que[i].r; --r) update(r, -1);
            for (; l < que[i].l; ++l) update(l, -1);
            for (; l > que[i].l; --l) update(l - 1, 1);
            ans[que[i].id] = res;
        }
        for (int i = 1; i <= cnt_que; ++i) printf("%d
", ans[i]);
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif

    Run();
    return 0;
}

 2141：分块+树状数组

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

#define N 20010
#define block 200

int n, m, q;
int arr[N], brr[N], pos[N], num[N];

struct BIT
{
    int a[N];
    void update(int x, int val)
    {
        while (x <= n)
        {
            a[x] += val;
            x += x & -x;
        }
    }

    int query(int x)
    {
        int res = 0;
        while (x)
        {
            res += a[x];
            x -= x & -x;
        }
        return res; 
    }

}bit[block];

int query(int x)
{
    int res = 0;
    for (int i = 1; i < pos[x]; ++i)
        res += num[i] - bit[i].query(arr[x]); 
    for (int i = x - 1; i >= 1 && pos[i] == pos[x]; --i) if (arr[i] > arr[x]) 
        ++res;
    for (int i = x + 1; i <= n && pos[i] == pos[x]; ++i) if (arr[i] < arr[x])
        ++res;
    for (int i = pos[x] + 1; i <= pos[n]; ++i)
        res += bit[i].query(arr[x] - 1); 
    return res;
}

void Run()
{
    while (scanf("%d", &n) != EOF)
    {
        for (int i = 1; i <= n; ++i) scanf("%d", arr + i);
        for (int i = 1; i <= n; ++i) brr[i] = arr[i]; 
        sort(brr + 1, brr + 1 + n);
        m = unique(brr + 1, brr + 1 + n) - brr - 1;
        for (int i = 1; i <= n; ++i) arr[i] = lower_bound(brr + 1, brr + 1 + m, arr[i]) - brr;
        for (int i = 1; i <= n; ++i) pos[i] = (i - 1) / block + 1, ++num[pos[i]];
        int res = 0;
        for (int i = 1; i <= n; ++i)
        {
            bit[0].update(arr[i], 1);
            res += i - bit[0].query(arr[i]);
        }
        printf("%d
", res);
        for (int i = 1; i <= n; ++i) bit[pos[i]].update(arr[i], 1);
        scanf("%d", &q);
        for (int i = 1, l, r; i <= q; ++i)
        {
            scanf("%d%d", &l, &r);
            if (l > r) swap(l, r);
            res -= query(l);
            res -= query(r);
            if (arr[l] > arr[r]) ++res;
            bit[pos[l]].update(arr[l], -1);
            bit[pos[r]].update(arr[r], -1);
            swap(arr[l], arr[r]);
            bit[pos[l]].update(arr[l], 1);
            bit[pos[r]].update(arr[r], 1);
            res += query(l); 
            res += query(r);
            if (arr[l] > arr[r]) --res;
            printf("%d
", res);
        }
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif

    Run();
    return 0;
}

2157：树剖+线段树

#include <bits/stdc++.h>
using namespace std;
 
#define N 100010
#define INF 0x3f3f3f3f
int n, q;
struct Edge { int u, v, w; Edge() {} Edge(int u, int v, int w) : u(u), v(v), w(w) {}}edge[N];
vector <int> G[N];
int p[N], fp[N], sze[N], son[N], fa[N], deep[N], top[N], cnt;
 
void DFS(int u)
{
    sze[u] = 1;
    for (int i = 0, len = G[u].size(); i < len; ++i)
    {
        int v = G[u][i];
        if (v == fa[u]) continue;
        fa[v] = u;
        deep[v] = deep[u] + 1;
        DFS(v); sze[u] += sze[v];
        if (!son[u] || sze[v] > sze[son[u]]) son[u] = v;
    }
}
 
void getpos(int u, int sp)
{
    top[u] = sp;
    p[u] = ++cnt;
    fp[cnt] = u;
    if (!son[u]) return;
    getpos(son[u], sp);
    for (int i = 0, len = G[u].size(); i < len; ++i)
    {
        int v = G[u][i];
        if (v == fa[u] || v == son[u]) continue;
        getpos(v, v);
    }
}
 
struct SEG
{
    struct node
    {
        int sum, Max, Min, lazy;
        void init() 
        {
            sum = 0;
            Max = -INF;
            Min = INF;
            lazy = 1;
        }
        node operator + (const node &r) const
        {
            node res; res.init(); 
            res.sum = sum + r.sum;
            res.Max = max(Max, r.Max);
            res.Min = min(Min, r.Min);
            return res;
        }   
        void change() 
        {
            sum *= -1;
            Max *= -1;
            Min *= -1;
            lazy *= -1;
            swap(Max, Min);
        }
    }a[N << 2], res;  
    void build(int id, int l, int r)
    {
        a[id].init();
        if (l == r) return;
        int mid = (l + r)  >> 1;
        build(id << 1, l, mid);
        build(id << 1 | 1, mid + 1, r);
    }
    void pushdown(int id)
    {
        if (a[id].lazy != 1)
        {
            a[id].lazy = 1;
            a[id << 1].change();
            a[id << 1 | 1].change();
        }
    }
    void update(int id, int l, int r, int pos, int val)
    {
        if (l == r) 
        {
            a[id].sum = a[id].Max = a[id].Min = val;
            return;
        }
        pushdown(id);
        int mid = (l + r) >> 1;
        if (pos <= mid) update(id << 1, l, mid, pos, val);
        else update(id << 1 | 1, mid + 1, r, pos, val);
        a[id] = a[id << 1] + a[id << 1 | 1];
    }
    void update(int id, int l, int r, int ql, int qr, int val)
    {
        if (l >= ql && r <= qr)
        {
            a[id].change();
            return;
        }
        pushdown(id);
        int mid = (l + r) >> 1;
        if (ql <= mid) update(id << 1, l, mid, ql, qr, val);
        if (qr > mid) update(id << 1 | 1, mid + 1, r, ql, qr, val);
        a[id] = a[id << 1] + a[id << 1 | 1];
    }
    void query(int id, int l, int r, int ql, int qr)
    {
        if (l >= ql && r <= qr) 
        {
            res = res + a[id];
            return;
        }
        pushdown(id);
        int mid = (l + r) >> 1;
        if (ql <= mid) query(id << 1, l, mid, ql, qr);
        if (qr > mid) query(id << 1 | 1, mid + 1, r, ql, qr);
        a[id] = a[id << 1] + a[id << 1 | 1];
    }
}seg;
 
void update(int u, int v)
{
    while (top[u] != top[v])
    {
        if (deep[top[u]] < deep[top[v]])
            swap(u, v);
        seg.update(1, 1, n, p[top[u]], p[u], -1);
        u = fa[top[u]];
    }
    if (u == v) return;
    if (deep[u] > deep[v]) swap(u, v);
    seg.update(1, 1, n, p[son[u]], p[v], -1); 
}
 
void query(int u, int v)
{
    while (top[u] != top[v])
    {
        if (deep[top[u]] < deep[top[v]])
            swap(u, v);
        seg.query(1, 1, n, p[top[u]], p[u]);
        u = fa[top[u]];
    }
    if (u == v) return;
    if (deep[u] > deep[v]) swap(u, v);
    seg.query(1, 1, n, p[son[u]], p[v]);
}
 
int main()
{
    while (scanf("%d", &n) != EOF)
    {
        cnt = 0;
        for (int i = 1, u, v, w; i < n; ++i)
        {
            scanf("%d%d%d", &u, &v, &w); ++u, ++v;
            edge[i] = Edge(u, v, w); 
            G[u].push_back(v);
            G[v].push_back(u);
        }
        DFS(1); 
        getpos(1, 1); 
        seg.build(1, 1, n); 
        for (int i = 1; i < n; ++i)
        {
            if (edge[i].u != fa[edge[i].v]) swap(edge[i].u, edge[i].v);
            seg.update(1, 1, n, p[edge[i].v], edge[i].w);
        }
        char op[10]; int u, v;
        scanf("%d", &q);
        for (int i = 1; i <= q; ++i)
        {
            scanf("%s%d%d", op, &u, &v); ++u, ++v;
            if (op[0] == 'N') update(u, v);
            else if (op[0] == 'C') seg.update(1, 1, n, p[edge[u - 1].v], v - 1);
            else
            {
                seg.res.init();
                query(u, v);
                if (op[0] == 'S') printf("%d
", seg.res.sum);
                else if (op[1] == 'I') printf("%d
", seg.res.Min);
                else printf("%d
", seg.res.Max);
            }
        }
    }
    return 0;
}

2286：虚数+树形DP

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

#define INFLL 0x3f3f3f3f3f3f3f3f
#define ll long long
#define N 250010
int n, q;
  
struct Edge
{ 
    struct node
    {
        int to, nx, w;
        node() {}
        node(int to, int nx, int w) : to(to), nx(nx), w(w) {}
    }a[N << 1];
    int head[N], pos;
    void add(int u, int v, int w) 
    {
        a[++pos] = node(v, head[u], w); head[u] = pos;
        a[++pos] = node(u, head[v], w); head[v] = pos; 
    }
}g[2];  
#define erp(id, u) for (int it = g[id].head[u], v = g[id].a[it].to; it; it = g[id].a[it].nx, v = g[id].a[it].to) 

int p[N], cnt, deep[N], fa[N], sze[N], son[N], top[N], vis[N]; ll val[N];
void DFS(int u)
{
    sze[u] = 1; 
    erp(0, u) if (v != fa[u])  
    {
        fa[v] = u;
        deep[v] = deep[u] + 1;
        val[v] = min(val[u], (ll)g[0].a[it].w);  
        DFS(v); sze[u] += sze[v]; 
        if (!son[u] || sze[v] > sze[son[u]]) son[u] = v;   
    }
}

void getpos(int u, int sp) 
{
    top[u] = sp;
    p[u] = ++cnt;
    if (!son[u]) return;
    getpos(son[u], sp);
    erp(0, u) if (v != fa[u] && v != son[u])
        getpos(v, v); 
}

int querylca(int u, int v)  
{
    while (top[u] != top[v]) 
    {
        if (deep[top[u]] < deep[top[v]]) swap(u, v);
        u = fa[top[u]];
    }
    if (deep[u] > deep[v]) swap(u, v);
    return u;
}

ll dp(int u, int fa) 
{
    ll tmp = 0;         
    erp(1, u) if (v != fa) tmp += dp(v, u);  
    g[1].head[u] = 0; 
    if (tmp == 0 || vis[u]) return vis[u] = 0, val[u]; 
    return min(val[u], tmp); 
}

bool cmp(int a, int b) { return p[a] < p[b]; } 

int a[N], stk[N], stktop; 
void Run()
{
    while (scanf("%d", &n) != EOF)
    {
        val[1] = INFLL;  
        for (int i = 1, u, v, w; i < n; ++i)
        {
            scanf("%d%d%d", &u, &v, &w);
            g[0].add(u, v, w);
        }DFS(1); getpos(1, 1);
        scanf("%d", &q); 
        for (int qq = 1, k; qq <= q; ++qq)
        {
            scanf("%d", &k); 
            for (int i = 1; i <= k; ++i) scanf("%d", a + i), vis[a[i]] = 1; 
            sort(a + 1, a + 1 + k, cmp);    
            stk[stktop = 1] = 1; g[1].pos = 0;
            for (int i = 1; i <= k; ++i) 
            {
                int lca = querylca(a[i], stk[stktop]);
                while (deep[lca] < deep[stk[stktop]]) 
                {
                    if (deep[stk[stktop - 1]] <= deep[lca])
                    { 
                        int last = stk[stktop--]; 
                        if (stk[stktop] != lca) stk[++stktop] = lca;
                        g[1].add(last, lca, 0);  
                        break;
                    }
                    g[1].add(stk[stktop], stk[stktop - 1], 0), --stktop; 
                } 
                if (stk[stktop] != a[i]) stk[++stktop] = a[i]; 
            } 
            while (stktop > 1) g[1].add(stk[stktop], stk[stktop - 1], 0), --stktop;  
            printf("%lld
", dp(1, 1));   
        } 
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;
}

2654：二分+Kruskal()

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

#define N 100010
struct node
{
    int u, v, clo, base, w;
    void scan() 
    { 
        scanf("%d%d%d%d", &u, &v, &base, &clo);
           ++u, ++v;
        if (clo == 1) w = base;   
    }
    bool operator < (const node &r) const
    {
        return w < r.w || (w == r.w && clo < r.clo); 
    }
}edge[N];
int n, m, need;
int pre[N];
int find(int x) { return pre[x] == 0 ? x : pre[x] = find(pre[x]); }

#define pii pair <int, int> 
pii Kruskal(int add)
{
    memset(pre, 0, sizeof pre);
    for (int i = 1; i <= m; ++i) if (edge[i].clo == 0) edge[i].w = add + edge[i].base;
    sort(edge + 1, edge + 1 + m); 
    int cnt = 1, cnt_white = 0; 
    int res = 0;
    for (int i = 1; i <= m; ++i)
    {
        int u = edge[i].u, v = edge[i].v; 
        int fu = find(u), fv = find(v);
        if (fu == fv) continue;
        ++cnt; if (edge[i].clo == 0) ++cnt_white; 
        res += edge[i].w; 
        pre[fu] = fv; 
        if (cnt == n) break; 
    }
    return pii(res, cnt_white); 
}

int main()
{
    while (scanf("%d%d%d", &n, &m, &need) != EOF)
    {
        for (int i = 1; i <= m; ++i) edge[i].scan();
        int l = -100, r = 100, res = 0;
        while (r - l >= 0)
        {
            int mid = (l + r) >> 1;
            pii tmp = Kruskal(mid); 
            if (tmp.second >= need) res = tmp.first - mid * need, l = mid + 1;   
            else r = mid - 1;
        }
        printf("%d
", res);
    }    
    return 0;
}

2724：$F[i][j] 表示 第i块到第j块的众数是什么，cntblock[i][j]表示前i块中j这个数出现几次，然后分块维护即可$

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

#define N 100010
#define block 650
#define pii pair <int, int>
int n, m, q;
int arr[N], brr[N], cnt[N]; 
int cntblock[block][N], sze; 
pii f[block][block];

void Hash()
{
    for (int i = 1; i <= n; ++i) brr[i] = arr[i];
    sort(brr + 1, brr + 1 + n);
    m = unique(brr + 1, brr + 1 + n) - brr - 1;
    for (int i = 1; i <= n; ++i) arr[i] = lower_bound(brr + 1, brr + 1 + m, arr[i]) - brr;
} 

void Init() 
{
    memset(cntblock, 0, sizeof cntblock); 
    memset(f, 0, sizeof f);
    memset(cnt, 0, sizeof cnt); 
}

void clean(int l, int r)
{
    for (int i = l; i <= r; ++i)
        cnt[arr[i]] = 0;
}

void Run()
{
    while (scanf("%d%d", &n, &q) != EOF)
    {
        Init(); sze = (n - 1) / block + 1;
        for (int i = 1; i <= n; ++i) scanf("%d", arr + i); Hash();
        for (int i = 1; i <= n; ++i)
        {
            int now = (i - 1) / block + 1;
            if (i != 1 && (i - 2) / block + 1 != now)
                for (int j = 1; j <= m; ++j)
                    cntblock[now][j] = cntblock[now - 1][j];
            ++cntblock[now][arr[i]];
        }
        for (int i = 1; i <= sze; ++i) 
        {
            for (int j = i; j <= sze; ++j)
            {
                f[i][j] = f[i][j - 1];
                int l = (j - 1) * block + 1, r = j * block;
                for (int k = l; k <= r; ++k)
                {
                    int num = arr[k];
                    if (!cnt[num])
                        cnt[num] += cntblock[j - 1][num] - cntblock[i - 1][num];
                    ++cnt[num]; 
                    if (cnt[num] > f[i][j].first || cnt[num] == f[i][j].first && brr[num] < f[i][j].second)
                        f[i][j] = pii(cnt[num], brr[num]); 
                }
                clean(l, r);
            }
        }
        int ans = 0;
        for (int i = 1, l, r; i <= q; ++i)
        {
            scanf("%d%d", &l, &r);
            l = (l + ans - 1) % n + 1; 
            r = (r + ans - 1) % n + 1;
            if (l > r) swap(l, r); 
            int posl = (l - 1) / block + 1, posr = (r - 1) / block + 1;
            pii res = pii(0, 0);  
            if (posl == posr)
            {
                for (int j = l; j <= r; ++j)
                {
                    int num = arr[j];
                    ++cnt[num];
                    if (cnt[num] > res.first || cnt[num] == res.first && brr[num] < res.second)
                        res = pii(cnt[num], brr[num]); 
                }
                clean(l, r);
            }
            else
            {
                res = f[posl + 1][posr - 1];   
                for (int j = l; j <= posl * block; ++j)
                {
                    int num = arr[j];
                    if (!cnt[num]) cnt[num] += cntblock[posr - 1][num] - cntblock[posl][num];
                    ++cnt[num];
                    if (cnt[num] > res.first || cnt[num] == res.first && brr[num] < res.second)
                        res = pii(cnt[num], brr[num]);
                }
                for (int j = (posr - 1) * block + 1; j <= r; ++j)
                {
                    int num = arr[j];
                    if (!cnt[num]) cnt[num] += cntblock[posr - 1][num] - cntblock[posl][num];
                    ++cnt[num];
                    if (cnt[num] > res.first || cnt[num] == res.first && brr[num] < res.second)
                        res = pii(cnt[num], brr[num]);
                }
                clean(l, posl * block);
                clean((posr - 1) * block + 1, r);
            }
            printf("%d
", res.second);
            ans = res.second; 
        }
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;
}

2729：先排男生和老师，老师相邻和不相邻，相邻的话需要插入一个女生

import java.io.BufferedInputStream;
import java.util.Scanner;
import java.math.*;

public class Main {

    static BigInteger fac[] = new BigInteger[4100];
    public static void init()
    {
        fac[0] = BigInteger.ONE;
        for (int i = 1; i < 4100; ++i)
            fac[i] = fac[i - 1].multiply(BigInteger.valueOf(i));
    }

    public static BigInteger C(int n, int m)
    {
        if (n < m || n < 0 || m < 0) return BigInteger.ZERO;
        return fac[n].divide(fac[m]).divide(fac[n - m]);
    }

    public static void main(String[] args)
    {
        init();
        Scanner in = new Scanner(new BufferedInputStream(System.in));
        int n, m;
        while (in.hasNext())
        {
            n = in.nextInt();
            m = in.nextInt();
            BigInteger a, b;
            a = BigInteger.valueOf(2).multiply(fac[n + 1]).multiply(fac[m]).multiply(C(n + 2, m - 1));
            b = BigInteger.valueOf(2).multiply(fac[n]).multiply(fac[m]).multiply(C(n + 1, 2)).multiply(C(n + 3, m));
            System.out.println(a.add(b));
        }
        in.close();
    }
}

2738：整体二分

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

#define N 510
#define M 60010
#define INF 0x3f3f3f3f
int n, q, m;
struct node
{
    int x, y, v;
    void scan(int x, int y)
    {
        this->x = x; this->y = y;
        scanf("%d", &v);
    }
    bool operator < (const node &r) const { return v < r.v; }
}arr[N * N];

struct BIT
{
    int a[N][N];
    void Init() { memset(a, 0, sizeof a); }
    void update(int x, int y, int val) 
    {
        for (int i = x; i <= n; i += i & -i)
            for (int j = y; j <= n; j += j & -j)
                a[i][j] += val;
    }
    int query(int x, int y)
    {
        int res = 0;
        for (int i = x; i; i -= i & -i)
            for (int j = y; j; j -= j & -j)
                res += a[i][j];
        return res;
    }
    int query(int x[], int y[])
    {
        int res = 0;
        res += query(x[0] - 1, y[0] - 1);
        res += query(x[1], y[1]);
        res -= query(x[0] - 1, y[1]);
        res -= query(x[1], y[0] - 1);
        return res; 
    }
}bit;

struct qnode
{
    int x[2], y[2], k, id;
    void scan(int id)
    {
        this->id = id;
        for (int i = 0; i < 2; ++i)
            scanf("%d%d", x + i, y + i);
        scanf("%d", &k);
    } 
}que[M], ql[M], qr[M]; int ans[M];

void CDQ(int L, int R, int l, int r)
{
    if (L > R) return;
    if (l == r)
    {
        for (int i = L; i <= R; ++i)
            ans[que[i].id] = arr[l].v; 
        return;  
    }
    int mid = (l + r) >> 1;
    for (int i = l; i <= mid; ++i) bit.update(arr[i].x, arr[i].y, 1);
    int posl = 0, posr = 0;  
    for (int i = L; i <= R; ++i)
    {
        int sze = bit.query(que[i].x, que[i].y);
        if (sze < que[i].k)  
        {
            que[i].k -= sze;
            qr[++posr] = que[i];    
        }
        else
            ql[++posl] = que[i];
    }
    for (int i = 1; i <= posl; ++i) que[L + i - 1] = ql[i];
    for (int i = 1; i <= posr; ++i) que[L + posl + i - 1] = qr[i];
    for (int i = l; i <= mid; ++i) bit.update(arr[i].x, arr[i].y, -1);
    CDQ(L, L + posl - 1, l, mid);
    CDQ(L + posl, R, mid + 1, r);
}

int main()
{
    while (scanf("%d%d", &n, &q) != EOF)
    {
        m = 0; bit.Init();
        for (int i = 1; i <= n; ++i) for (int j = 1; j <= n; ++j) arr[++m].scan(i, j);
        sort(arr + 1, arr + 1 + m);
        for (int i = 1; i <= q; ++i) que[i].scan(i);
        CDQ(1, q, 1, m); 
        for (int i = 1; i <= q; ++i) printf("%d
", ans[i]);
    }
    return 0;
}

2750：$f[u] 表示st -> u的路径数，g[v] 表示 v所能到达的点数  那么一条边<u, v> 提供的贡献就是 f[u] cdot g[v]$

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

#define ll long long
#define N 5010
#define INF 0x3f3f3f3f
const ll MOD = (ll)1e9 + 7;
int n, m; ll ans[N];

struct Graph
{
    struct node
    {
        int to, nx, w, id;
        node() {}
        node(int to, int nx, int w, int id) : to(to), nx(nx), w(w), id(id) {}
    }a[N << 1]; int head[N], pos;
    void init()
    {
        memset(head, -1, sizeof head);
        pos = 0;
    }
    void add(int u, int v, int w, int id)
    {
        a[++pos] = node(v, head[u], w, id); head[u] = pos;
    }
}G[2];
#define erp(G, u) for (int it = G.head[u], v = G.a[it].to, w = G.a[it].w, id = G.a[it].id; ~it; it = G.a[it].nx, v = G.a[it].to, w = G.a[it].w, id = G.a[it].id)

namespace Dijkstra
{
    struct node
    {
        int to, w;
        node() {}
        node(int to, int w) : to(to), w(w) {}
        bool operator < (const node &r) const { return w > r.w; }
    };
    int dist[N]; bool used[N];
    void work(int st)
    {
        for (int i = 1; i <= n; ++i) dist[i] = INF, used[i] = false;
        priority_queue <node> q; q.push(node(st, 0)); dist[st] = 0;
        while (!q.empty())
        {
            int u = q.top().to; q.pop();
            erp(G[0], u) if (!used[v] && dist[v] > dist[u] + w)
            {
                dist[v] = dist[u] + w;
                q.push(node(v, w)); 
            } 
        }
    }
}

int f[N], g[N], in[N];
void Topo(int p, int *x)
{
    G[1].init(); 
    for (int i = 1; i <= n; ++i) x[i] = p, in[i] = 0;
    for (int u = 1; u <= n; ++u) if (Dijkstra::dist[u] != INF)
    {
        erp(G[0], u) if (Dijkstra::dist[u] + w <= Dijkstra::dist[v])
        {
            if (!p)
            {
                G[1].add(u, v, w, id);
                ++in[v];
            }
            else
            {
                G[1].add(v, u, w, id);
                ++in[u];
            }
        }
    }
    
    queue <int> q;
    for (int u = 1; u <= n; ++u) if (Dijkstra::dist[u] != INF && !in[u])
    {
        x[u] = 1;
        q.push(u);
    }

    while (!q.empty())
    {
        int u = q.front(); q.pop();
        erp(G[1], u) 
        {
            x[v] += x[u]; 
            --in[v];
            if (!in[v]) q.push(v);
        }
    }    
}

void Run()
{
    while (scanf("%d%d", &n, &m) != EOF)
    {
        G[0].init();
        memset(ans, 0, sizeof ans);
        for (int i = 1, u, v, w; i <= m; ++i)
        {
            scanf("%d%d%d", &u, &v, &w);
            G[0].add(u, v, w, i);
        }
        for (int i = 1; i <= n; ++i)
        {
            Dijkstra::work(i);
            Topo(1, g);
            Topo(0, f);
            for (int u = 1; u <= n; ++u) erp(G[1], u)
                ans[id] = (ans[id] + 1ll * f[u] * g[v]) % MOD;
        }
        for (int i = 1; i <= m; ++i) printf("%lld
", ans[i]);
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0; 
}

2752：线段树维护，注意区间的合并

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

#define N 100010
#define ll long long 
int n, q;

ll calc(ll x) { return x * (x + 1) / 2; } 
ll base[N]; 
struct SEG
{
    struct node
    {
        ll sum, res, lsum, rsum, lazy, cnt, sze;
        node() {}
        node(ll sum, ll res, ll lsum, ll rsum, ll lazy, ll cnt, ll sze) : sum(sum), res(res), lsum(lsum), rsum(rsum), lazy(lazy), cnt(cnt), sze(sze) {}
        node operator + (const node &r) const
        {
            node ans = node(0, 0, 0, 0, 0, 0, 0); 
            ans.sum = sum + r.sum;
            ans.res = res + r.res + rsum * r.cnt + r.lsum * cnt;
            ans.lsum = lsum + r.lsum + sum * r.cnt;
            ans.rsum = rsum + r.rsum + r.sum * cnt;
            ans.cnt = cnt + r.cnt; 
            ans.sze = sze + r.sze + cnt * r.cnt;  
            return ans;
        }
    }a[N << 2], res;
    void change(int id, ll val)
    {
        a[id].sum += a[id].cnt * val;
        a[id].res += base[a[id].cnt] * val;  
        a[id].lsum += calc(a[id].cnt) * val;
        a[id].rsum += calc(a[id].cnt) * val;
        a[id].lazy += val; 
    }
    void pushdown(int id)
    {
        if (!a[id].lazy) return;
        change(id << 1, a[id].lazy);
        change(id << 1 | 1, a[id].lazy);
        a[id].lazy = 0; 
    }
    void build(int id, int l, int r)
    {
        if (l == r)
        {
            a[id] = node(0, 0, 0, 0, 0, 1, 1);
            return;
        }
        int mid = (l + r) >> 1;
        build(id << 1, l, mid);
        build(id << 1 | 1, mid + 1, r);
        a[id] = a[id << 1] + a[id << 1 | 1]; 
    }
    void update(int id, int l, int r, int ql, int qr, ll val) 
    {
        if (l >= ql && r <= qr)
        {
            change(id, val);
            return; 
        }
        pushdown(id);
        int mid = (l + r) >> 1;
        if (ql <= mid) update(id << 1, l, mid, ql, qr, val);
        if (qr > mid) update(id << 1 | 1, mid + 1, r, ql, qr, val);
        a[id] = a[id << 1] + a[id << 1 | 1];
        return;
    }
    node query(int id, int l, int r, int ql, int qr)
    {
        if (l >= ql && r <= qr) return a[id];
        pushdown(id);
        int mid = (l + r) >> 1;
        node res = node(0, 0, 0, 0, 0, 0, 0); 
        if (ql <= mid) res = query(id << 1, l, mid, ql, qr);
        if (qr > mid) res = res.cnt ? res + query(id << 1 | 1, mid + 1, r, ql, qr) : query(id << 1 | 1, mid + 1, r, ql, qr);
        a[id] = a[id << 1] + a[id << 1 | 1];
        return res;
    }
}seg;

ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }

void Run()
{
    for (int i = 1; i <= 100000; ++i) base[i] = base[i - 1] + calc(i);
    while (scanf("%d%d", &n, &q) != EOF)
    {
        seg.build(1, 1, n);
        char op; int l, r, v; 
        for (int i = 1; i <= q; ++i)
        {
            scanf(" %c%d%d", &op, &l, &r); ++l;
            if (op == 'C')
            {
                scanf("%d", &v);
                seg.update(1, 1, n, l, r, v);
            }
            else
            {
                seg.res = seg.query(1, 1, n, l, r); 
                ll a = seg.res.res, b = seg.res.sze;
                ll t = gcd(a, b);
                a /= t, b /= t;
                printf("%lld/%lld
", a, b);
            }
        }
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;
}

3100：单调队列维护左端点，枚举右端点

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

#define N 1000001
int n, res;
int arr[N], pre[N], q[N]; 

void check(int l, int r, int pos)
{
    if (pos > r) return;
    if (r - l + 1 == arr[pos]) res = max(res, r - l + 1);
}

void Run()
{
    while (scanf("%d", &n) != EOF)
    {
        res = 0; 
        int l = 1, r = 0, L = 1;
        for (int i = 1; i <= n; ++i)
        {
            scanf("%d", arr + i);
            L = max(L, pre[arr[i]] + 1);
            while (l <= r && q[l] <= pre[arr[i]])
            {
                check(q[l] + 1, i - 1, q[l + 1]);
                ++l;
            }
            pre[arr[i]] = i;
            while (l <= r && arr[i] >= arr[q[r]])
            {
                check(max(L, q[r - 1] + 1), i - 1, q[r]);  
                --r; 
            }
            q[++r] = i;
            check(L, i, q[l]);
        }
        printf("%d
", res);
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;

}

3110：整体二分+线段树

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

#define N 50010
#define ll long long

int n, q, m;
ll ans[N];

struct SEG
{
    struct node
    {
        ll cnt, lazy, sum;
        node() {}
        node(int l, int r)
        {
            cnt = r - l + 1;
            lazy = sum = 0;
        }
    }a[N << 2];

    void pushup(int id)
    {
        a[id].sum = a[id << 1].sum + a[id << 1 | 1].sum;
    }
    
    void pushdown(int id)
    {
        if (a[id].lazy)
        {
            int lazy = a[id].lazy; a[id].lazy = 0;
            a[id << 1].lazy += lazy;
            a[id << 1 | 1].lazy += lazy;
            a[id << 1].sum += lazy * a[id << 1].cnt;
            a[id << 1 | 1].sum += lazy * a[id << 1 | 1].cnt;
        }
    }

    void build(int id, int l, int r)
    {
        a[id] = node(l, r);
        if (l == r) return;
        int mid = (l + r) >> 1;
        build(id << 1, l, mid);
        build(id << 1 | 1, mid + 1, r);
    }


    void update(int id, int l, int r, int ql, int qr, ll val)
    {
        if (l >= ql && r <= qr)
        {
            a[id].lazy += val;
            a[id].sum += val * a[id].cnt;
            return;
        }
        pushdown(id);
        int mid = (l + r) >> 1;
        if (ql <= mid) update(id << 1, l, mid, ql, qr, val);
        if (qr > mid) update(id << 1 | 1, mid + 1, r, ql, qr, val);
        pushup(id);
    }

    ll query(int id, int l, int r, int ql, int qr)
    {
        if (l >= ql && r <= qr) return a[id].sum;
        pushdown(id);
        int mid = (l + r) >> 1;
        ll res = 0;
        if (ql <= mid) res += query(id << 1, l, mid, ql, qr);
        if (qr > mid) res += query(id << 1 | 1, mid + 1, r, ql, qr);
        pushup(id);
        return res;
    }
}segtree;

struct QUE
{
    int op, x, y, id; ll c;
    void scan()
    {
        scanf("%d%d%d%lld", &op, &x, &y, &c);
        if (op == 2) id = ++m;
    }
}que[N], quel[N], quer[N];


void solve(int ql, int qr, int l, int r)
{
    if (ql > qr) return; 
    if (l == r)
    {
        for (int i = ql; i <= qr; ++i) if (que[i].op == 2) 
            ans[que[i].id] = l;
        return;
    }
    int mid = (l + r) >> 1, cnt_ql = 0, cnt_qr = 0;
    for (int i = ql; i <= qr; ++i)
    {
        if (que[i].op == 1)
        {
            if (que[i].c > mid) segtree.update(1, 1, n, que[i].x, que[i].y, 1), quer[++cnt_qr] = que[i];
            else quel[++cnt_ql] = que[i];
        }
        else
        {
            ll tmp = segtree.query(1, 1, n, que[i].x, que[i].y);
            if (tmp < que[i].c) que[i].c -= tmp, quel[++cnt_ql] = que[i];
            else quer[++cnt_qr] = que[i];
        }
    }
    for (int i = 1; i <= cnt_qr; ++i) if (quer[i].op == 1) segtree.update(1, 1, n, quer[i].x, quer[i].y, -1); 
    for (int i = 1; i <= cnt_ql; ++i) que[ql + i - 1] = quel[i];
    for (int i = 1; i <= cnt_qr; ++i) que[ql + cnt_ql + i - 1] = quer[i];
    solve(ql, ql + cnt_ql - 1, l, mid);
    solve(ql + cnt_ql, qr, mid + 1, r);
}

void Run()
{
    while (scanf("%d%d", &n, &q) != EOF)
    {
        for (int i = 1; i <= q; ++i) que[i].scan(); 
        segtree.build(1, 1, n);
        solve(1, q, -N, N);
        for (int i = 1; i <= m; ++i) printf("%lld
", ans[i]);
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin); 
    #endif

    Run();
    return 0;
}

3155：硬核线段树

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

#define ll long long
#define N 100010
int n, m;
ll arr[N];

struct SEG
{
    ll sum[N << 2][2];
    int cnt[N << 2];
    void pushup(int id)
    {
        sum[id][0] = sum[id << 1][0] + sum[id << 1 | 1][0];
        sum[id][1] = sum[id << 1][1] + sum[id << 1 | 1][1] + cnt[id << 1 | 1] * sum[id << 1][0];
    }
    void build(int id, int l, int r)
    {
        cnt[id] = r - l + 1;
        if (l == r)
        {
            sum[id][0] = sum[id][1] = arr[l];
            return;
        }
        int mid = (l + r) >> 1;
        build(id << 1, l, mid);
        build(id << 1 | 1, mid + 1, r);
        pushup(id);
    }
    void update(int id, int l, int r, int pos, ll val) 
    {
        if (l == r)
        {
            sum[id][0] = sum[id][1] = val;
            return;
        }
        int mid = (l + r) >> 1;
        if (pos <= mid) update(id << 1, l, mid, pos, val);
        else update(id << 1 | 1, mid + 1, r, pos, val);
        pushup(id);
    }
    ll query(int id, int l, int r, int ql, int qr)
    {
        if (l >= ql && r <= qr) return sum[id][0] * (qr - r) + sum[id][1];
        int mid = (l + r) >> 1;
        ll res = 0;
        if (ql <= mid) res += query(id << 1, l, mid, ql, qr);
        if (qr > mid) res += query(id << 1 | 1, mid + 1, r, ql, qr);
        return res;
    }
}seg;

void Run() 
{
    while (scanf("%d%d", &n, &m) != EOF)
    {
        for (int i = 1; i <= n; ++i) scanf("%lld", arr + i);
        seg.build(1, 1, n);
        char op[10]; int x, y;
        for (int i = 1; i <= m; ++i)
        {
            scanf("%s%d", op, &x);
            if (op[0] == 'Q') printf("%lld
", seg.query(1, 1, n, 1, x));
            else
            {
                scanf("%d", &y);
                seg.update(1, 1, n, x, y);
            }
        }
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;

}

3173：离线+BIT+二分

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

#define N 100010
int n;
int a[N], b[N], ans[N];

struct BIT_Max
{
    int a[N];
    void init() { memset(a, 0, sizeof a); }
    void update(int x, int val) { for (; x <= n; x += x & -x) a[x] = max(a[x], val); }
    int query(int x) { int res = 0; for (; x; x -= x & -x) res = max(res, a[x]); return res; }  
}bit_max;

struct BIT_sum
{
    int a[N];
    void init() { memset(a, 0, sizeof a); }
    void update(int x, int val) { for (; x <= n; x += x & -x) a[x] += val; }
    int query(int x) { int res = 0; for (; x; x -= x & -x) res += a[x]; return res; }
}bit_sum;

void Run() 
{
    while (scanf("%d", &n) != EOF)
    {
        for (int i = 1; i <= n; ++i) scanf("%d", a + i), ++a[i]; 
        bit_sum.init(); 
        for (int i = 1; i <= n; ++i) bit_sum.update(i, 1);  
        for (int i = n; i >= 1; --i) 
        { 
            int l = 1, r = n, pos; 
            while (r - l >= 0)
            {
                int mid = (l + r) >> 1; 
                int num = bit_sum.query(mid);
                if (num == a[i])
                    pos = mid;
                if (num >= a[i]) r = mid - 1; 
                else l = mid + 1; 
            }
            b[i] = pos;   
            bit_sum.update(pos, -1); 
        }
        bit_max.init();  
        for (int i = 1; i <= n; ++i)
        {
            int res = bit_max.query(b[i]) + 1; 
            bit_max.update(b[i], res);
            ans[i] = bit_max.query(n);  
        }  
        for (int i = 1; i <= n; ++i) printf("%d
", ans[i]);
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;

}

3262：CDQ分治解决一维，考虑有重复的，将id加入形成四关键字排序使得排序顺序固定，然后前后各扫一遍更新最大答案

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

#define N 200010

int n, k;
int ans[N], cnt[N];

struct node
{
    int x, y, z, id; 
    bool isleft;
    void scan(int id)
    {
        this->id = id;
        scanf("%d%d%d", &x, &y, &z);
    }
    bool operator < (const node &r) const
    {
        return x == r.x ? (y == r.y ? (z == r.z ? id < r.id : z < r.z) : y < r.y) : x < r.x;
    }
    bool operator == (const node &r) const { return x == r.x && y == r.y && z == r.z; }
}arr[N], tarr[N];

struct BIT
{
    int a[N];

    void update(int x, int val)
    {
        while (x <= k)
        {
            a[x] += val;
            x += x & -x;
        }
    }

    int query(int x)
    {
        int res = 0;
        while (x)
        {
            res += a[x];
            x -= x & -x;
        }
        return res;
    }
}bit;

bool cmp(node a, node b)
{
    return a.y == b.y ? (a.z == b.z ? (a.x == b.x ? a.id < b.id : a.x < b.x) : a.z < b.z) : a.y < b.y;  
} 

void CDQ(int l, int r)
{
    if (l == r) return; 
    int mid = (l + r) >> 1;
    CDQ(l, mid); CDQ(mid + 1, r);
    for (int i = l; i <= r; ++i)
    {
        tarr[i] = arr[i];
        if (i <= mid) tarr[i].isleft = true;  
        else tarr[i].isleft = false;   
    }
    sort(tarr + l, tarr + r + 1, cmp);
    for (int i = l; i <= r; ++i)
    {
        if (tarr[i].isleft) bit.update(tarr[i].z, 1);  
        else ans[tarr[i].id] += bit.query(tarr[i].z);   
    }  
    for (int i = l; i <= r; ++i) if (tarr[i].isleft) bit.update(tarr[i].z, -1);    
}

void Run()
{
    while (scanf("%d%d", &n, &k) != EOF)
    {
        for (int i = 1; i <= n; ++i) arr[i].scan(i), ans[i] = 0;  
        sort(arr + 1, arr + 1 + n);
        CDQ(1, n);
        for (int i = n - 1; i >= 1; --i) if (arr[i] == arr[i + 1])
            ans[arr[i].id] = max(ans[arr[i].id], ans[arr[i + 1].id]);
        for (int i = 2; i <= n; ++i) if (arr[i] == arr[i - 1])
            ans[arr[i].id] = max(ans[arr[i].id], ans[arr[i - 1].id]);
        for (int i = 1; i <= n; ++i) ++cnt[ans[i]];  
        for (int i = 0; i < n; ++i) printf("%d
", cnt[i]);
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin); 
    #endif 

    Run();
    return 0;
}

3295：考虑(t, p, x) 三维偏序问题，分别表示删除的时间，删除的位置，删除的值  用CDQ分治干掉t, 排序干掉p，树状数组干掉x

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

#define N 100010
#define ll long long

int n, m, ttm;
int arr[N], pos[N];
ll ans[N];
bool flag[N];

struct QUE
{
    int t, p, x;
    QUE() {}
    QUE(int t, int p, int x) : t(t), p(p), x(x) {}
    bool operator < (const QUE &r) const
    {
        return p < r.p;
    }
}q[N], tq[N];

struct BIT
{
    int a[N];

    void Init()
    {
        memset(a, 0, sizeof a);
    }

    void update(int x, int val)
    {
        while (x <= n)
        {
            a[x] += val;
            x += x & -x;
        }
    }

    int query(int x)
    {
        int res = 0;
        while (x)
        {
            res += a[x];
            x -= x & -x;
        }
        return res;
    }
}bit;

void CDQ(int l, int r)
{
    if (l == r) return;
    int mid = (l + r) >> 1;
    CDQ(l, mid); CDQ(mid + 1, r); 
    for (int i = l; i <= r; ++i)
    {
        tq[i] = q[i];
        if (i > mid) tq[i].t = 0;
    }
    sort(tq + l, tq + r + 1);
    for (int i = l; i <= r; ++i)
    {
        if (!tq[i].t) bit.update(tq[i].x, 1);
        else ans[tq[i].t] += bit.query(n) - bit.query(tq[i].x);
    }
    for (int i = l; i <= r; ++i) if (!tq[i].t) bit.update(tq[i].x, -1);
    for (int i = r; i >= l; --i)
    {
        if (!tq[i].t) bit.update(tq[i].x, 1);
        else ans[tq[i].t] += bit.query(tq[i].x);
    }
    for (int i = l; i <= r; ++i) if (!tq[i].t) bit.update(tq[i].x, -1);
}

void Run()
{
    while (scanf("%d%d", &n, &m) != EOF)
    {
        ttm = m; bit.Init(); 
        memset(ans, 0, sizeof ans);
        memset(flag, 0, sizeof flag);
        for (int i = 1; i <= n; ++i)
        {
            scanf("%d", arr + i);
            pos[arr[i]] = i;
        }
        for (int i = 1, x; i <= m; ++i)
        {
            scanf("%d", &x);
            flag[x] = 1;
            q[i] = QUE(i, pos[x], x);
        }
        for (int i = 1; i <= n; ++i) if (!flag[i])
            q[++ttm] = QUE(ttm, pos[i], i); 
        CDQ(1, n);
        for (int i = n - 1; i >= 1; --i) ans[i] += ans[i + 1];
        for (int i = 1; i <= m; ++i) printf("%lld
", ans[i]); 
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin); 
    #endif 

    Run();
    return 0;
}

3319：考虑一个黑点产生的影响，即只对它的子树产生影响，再用并查集缩点，这样一个点只会处理一次,加了IO优化才过的，应该不是正解。

#include <bits/stdc++.h>
using namespace std;
 
#define N 1000010
int n, q;
int lp[N], rp[N], pos[N], deep[N], fa[N], cnt;
struct Edge { int to, nx; }edge[N << 1]; 
int head[N], cntedge;
void add(int u, int v) { edge[++cntedge] = Edge{ v, head[u] }; head[u] = cntedge; }
 
void DFS(int u)
{
    lp[u] = ++cnt;
    for (int it = head[u]; it; it = edge[it].nx)
    {
        int v = edge[it].to;
        if (v == fa[u]) continue; 
        pos[v] = it >> 1;
        deep[v] = deep[u] + 1;
        fa[v] = u;
        DFS(v);
    }
    rp[u] = cnt;
}
 
struct SEG
{
    int Max[N << 2];
    int max(int x, int y)
    {
        if (deep[x] < deep[y]) return y;
        return x;
    }
    void update(int id, int l, int r, int ql, int qr, int val)
    {
        if (l >= ql && r <= qr)
        {
            Max[id] = max(Max[id], val);
            return;
        }
        int mid = (l + r) >> 1;
        if (ql <= mid) update(id << 1, l, mid, ql, qr, val);
        if (qr > mid) update(id << 1 | 1, mid + 1, r, ql, qr, val);
    } 
    int query(int id, int l, int r, int pos)
    { 
        if (l == r) return Max[id];
        int mid = (l + r) >> 1;
        if (pos <= mid) return max(Max[id], query(id << 1, l, mid, pos));
        else return max(Max[id], query(id << 1 | 1, mid + 1, r, pos));
    }
}seg;
 
int pre[N];
int find(int x) { return pre[x] == 0 ? x : pre[x] = find(pre[x]); } 
 
void modify(int u, int v)
{
    u = find(u), v = find(v);
    while (u != v) 
    {
        if (deep[find(fa[u])] < deep[find(fa[v])])  
            swap(u, v);
        seg.update(1, 1, n, lp[u], rp[u], u);
        pre[u] = fa[u]; u = find(u); 
    }
}
 
namespace FastIO
{
    #define BUF_SIZE 10000005
    bool IOerror = false;
    inline char NC()
    {
        static char buf[BUF_SIZE], *p1 = buf + BUF_SIZE, *pend = buf + BUF_SIZE;
        if (p1 == pend)
        {
            p1 = buf;
            pend = buf + fread(buf, 1, BUF_SIZE, stdin);
            if (pend == p1)
            {
                IOerror = true;
                return -1;
            }
        }
        return *p1++;
    }
    inline bool blank(char ch)
    {
        return ch == ' ' || ch == '
' || ch == '
' || ch == '	';
    }
    template <typename T>
    inline void read(T &x)
    {
        char ch;
        while (blank(ch = NC()));
        if (IOerror)
        {
            x = -1;
            return;
        }
        bool flag = false;
        if (ch == '-')
        {
            flag = true;
            ch = NC();
        }
        if (!isdigit(ch)) while (!isdigit(ch = NC()));
        for (x = ch - '0'; isdigit(ch = NC()); x = x * 10 + ch - '0');
        if (flag) x *= -1;
    }
    inline void out(int x)
    {
        if (x / 10) out(x / 10);
        putchar(x % 10 + '0');
    }
    inline void output(int x) { out(x), putchar('
'); }
    #undef BUF_SIZE
}using namespace FastIO;
 
void Run()
{
    while (read(n), n != EOF)
    {
        read(q);
        deep[1] = 1; cntedge = 1;
        for (int i = 1, u, v; i < n; ++i)
        {
            read(u), read(v);
            add(u, v); add(v, u);
        }
        DFS(1); 
        for (int i = 1, op, u, v; i <= q; ++i)
        {
            read(op), read(v);
            if (op == 1) output(pos[seg.query(1, 1, n, lp[v])]);
            else
            {
                read(u);
                modify(u, v);
            }
        }
    }
}
 
int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 
 
    Run();
    return 0;
}

3524：主席树

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

#define N 500010
int n, q, m;
int arr[N], brr[N];

void Hash()
{
    for (int i = 1; i <= n; ++i) brr[i] = arr[i];
    sort(brr + 1, brr + 1 + n);
    m = unique(brr + 1, brr + 1 + n) - brr - 1;
    for (int i = 1; i <= n; ++i) arr[i] = lower_bound(brr + 1, brr + 1 + m, arr[i]) - brr;
}

int T[N];
struct CHAIR
{
    #define M N * 40
    int a[M], ls[M], rs[M], cnt;
    void build(int &id, int l, int r)
    {
        id = ++cnt;
        a[id] = 0;
        if (l == r) return;
        int mid = (l + r) >> 1;
        build(ls[id], l, mid);
        build(rs[id], mid + 1, r);
    }
    int update(int pre, int pos)
    {
        int now = ++cnt, tmp = now;
        a[now] = a[pre] + 1;
        int l = 1, r = m;
        while (l < r)
        {
            int mid = (l + r) >> 1;
            if (pos <= mid)
            {
                ls[now] = ++cnt; rs[now] = rs[pre];
                now = ls[now], pre = ls[pre]; 
                r = mid;
            }
            else
            {
                ls[now] = ls[pre], rs[now] = ++cnt;
                now = rs[now], pre = rs[pre];
                l = mid + 1;
            }
            a[now] = a[pre] + 1;
        }
        return tmp;
    }
    int query(int lt, int rt, int cnt)
    {
        lt = T[lt], rt = T[rt];
        int l = 1, r = m;
        while (l < r)
        {
            int mid = (l + r) >> 1;
            int szel = a[ls[rt]] - a[ls[lt]];
            int szer = a[rs[rt]] - a[rs[lt]];
            if (szel > cnt)
            {
                lt = ls[lt];
                rt = ls[rt];
                r = mid;
            }
            else if (szer > cnt)
            {
                lt = rs[lt];
                rt = rs[rt];
                l = mid + 1;
            }
            else
                return 0;
        }
        return l;
    }
}chair;


void Run()
{
    while (scanf("%d%d", &n, &q) != EOF)
    {
        for (int i = 1; i <= n; ++i) scanf("%d", arr + i); Hash();
        chair.build(T[0], 1, m);
        for (int i = 1; i <= n; ++i) T[i] = chair.update(T[i - 1], arr[i]);
        for (int i = 1, l, r; i <= q; ++i)
        {
            scanf("%d%d", &l, &r);
            printf("%d
", brr[chair.query(l - 1, r, (r - l + 1) >> 1)]);
        }
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;
}

3578：集合Hash : 给每个点随机Hash权值，所有点权异或起来便是集合Hash值， 插入删除均是异或，然后线段树维护有效人数

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

#define N 100010
int n, m, q, ran;
int Hash[N], loc[N];
map <int, bool> mp;

struct SEG
{
    int Set[N << 2], sum[N << 2], peo[N << 2], lazy[N << 2];
    void init()
    {
        memset(Set, 0, sizeof Set);
        memset(sum, 0, sizeof sum);
        memset(peo, 0, sizeof peo);
        memset(lazy, 0, sizeof lazy);
    }
    void pushup(int id) { sum[id] = sum[id << 1] + sum[id << 1 | 1]; }
    void clear(int id, int l, int r)
    {
        lazy[id] = 1; sum[id] = 0;
        if (l == r) 
            mp[Set[id]] = 1;
    }
    void pushdown(int id, int l, int r, int mid)
    {
        if (lazy[id])
        {
            if (l == r)
            {
                lazy[id] = 0;
                return;
            }
            clear(id << 1, l, mid);
            clear(id << 1 | 1, mid + 1, r);
            lazy[id] = 0; 
        }
    }
    void update(int id, int l, int r, int pos, int p, int val)
    {
        if (l == r)
        {
            Set[id] ^= p;
            peo[id] += val;  
            sum[id] = (mp.find(Set[id]) == mp.end() ? peo[id] : 0); 
            return;
        }
        int mid = (l + r) >> 1;
        pushdown(id, l, r, mid);
        if (pos <= mid) update(id << 1, l, mid, pos, p, val);
        else update(id << 1 | 1, mid + 1, r, pos, p, val);
        pushup(id);
    }
    
    int query(int id, int l, int r, int ql, int qr)
    {
        int res = 0;
        if (l >= ql && r <= qr)
        {
            res = sum[id]; 
            clear(id, l, r);  
            return res;   
        }
        int mid = (l + r) >> 1;
        pushdown(id, l, r, mid);
        if (ql <= mid) res += query(id << 1, l, mid, ql, qr);
        if (qr > mid) res += query(id << 1 | 1, mid + 1, r, ql, qr);
        pushup(id);
        return res;
    }
}seg;

void Run()
{
    while (scanf("%d%d%d", &n, &m, &q) != EOF)
    {
        seg.init(); mp.clear();
        for (int i = 1; i <= n; ++i)
        {
            ran *= 233;
            ran += 17;  
            seg.update(1, 1, m, loc[i] = 1, Hash[i] = ran, 1);    
        }
        char op; int x, y;
        for (int i = 1; i <= q; ++i)
        {
            scanf(" %c%d%d", &op, &x, &y); 
            if (op == 'C')
            {
                seg.update(1, 1, m, loc[x], Hash[x], -1); 
                seg.update(1, 1, m, loc[x] = y, Hash[x], 1);
            }
            else
                printf("%d
", seg.query(1, 1, m, x, y));
        }
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;
}

3589：可持久化线段树+树剖

#include <bits/stdc++.h>
using namespace std;
 
#define N 200010
#define ll long long
ll const MOD = (ll)1ll << 31;  
int n, q;
struct Edge { int to, nx; }edge[N << 1];
int head[N], cntedge;
void addedge(int u, int v) { edge[++cntedge] = Edge{ v, head[u] }; head[u] = cntedge; }
int p[N], lp[N], rp[N], sze[N], son[N], fa[N], deep[N], top[N], cntdfs;
 
void DFS(int u)
{
    sze[u] = 1;
    for (int it = head[u]; ~it; it = edge[it].nx)
    {
        int v = edge[it].to;
        if (v == fa[u]) continue;
        deep[v] = deep[u] + 1;
        fa[v] = u;
        DFS(v); sze[u] += sze[v];
        if (son[u] == -1 || sze[v] > sze[son[u]]) son[u] = v;
    }
}
 
void getpos(int u, int sp)
{
    top[u] = sp; 
    p[u] = ++cntdfs; 
    lp[u] = cntdfs;
    if (son[u] == -1)
    {
        rp[u] = cntdfs;
        return;
    }
    getpos(son[u], sp); 
    for (int it = head[u]; ~it; it = edge[it].nx)
    {
        int v = edge[it].to; 
        if (v == fa[u] || v == son[u]) continue;
        getpos(v, v); 
    }
    rp[u] = cntdfs;
}
 
int T[5];
struct SEG
{
    #define M N * 60
    int cnt;
    struct node
    {
        int ls, rs, pre;
        ll sum, lazy;
        node() {}
        node(int ls, int rs, int pre, ll sum, ll lazy) : ls(ls), rs(rs), pre(pre), sum(sum), lazy(lazy) {}
    }a[M];
    void pushup(int id)
    {
        int ls = a[id].ls, rs = a[id].rs;
        a[id].sum = (a[ls].sum + a[rs].sum) % MOD;
    }
    void createson(int &now, int pre)
    {
        now = ++cnt; 
        a[now] = node(-1, -1, pre, 0, -1);  
        return;
    }
    void pushdown(int id, int l, int r)    
    { 
        if (a[id].lazy == 0) return; 
        int mid = (l + r) >> 1; 
        if (a[id].ls == -1 || a[id].rs == -1)
        {
            int pre = a[id].pre;
            createson(a[id].ls, a[pre].ls);
            createson(a[id].rs, a[pre].rs);
        }
        int ls = a[id].ls, rs = a[id].rs; 
        if (a[id].lazy == -1)
        {
            a[id].lazy = 0;
            a[ls].lazy = a[rs].lazy = -1;
            a[ls].sum = a[rs].sum = 0;
            return;
        }
        ll lazy = a[id].lazy; a[id].lazy = 0;   
        a[ls].lazy = (a[ls].lazy + lazy) % MOD; a[ls].sum = (a[ls].sum + lazy * (mid - l + 1) % MOD) % MOD;
        a[rs].lazy = (a[rs].lazy + lazy) % MOD; a[rs].sum = (a[rs].sum + lazy * (r - mid) % MOD) % MOD;
    } 
    void build(int &id, int l, int r)  
    {
        id = ++cnt; 
        a[id] = node(-1, -1, -1, 0, 0);
        if (l == r) return;
        int mid = (l + r) >> 1;
        build(a[id].ls, l, mid);
        build(a[id].rs, mid + 1, r);
    } 
    void update(int id, int l, int r, int ql, int qr, ll val)
    {
        if (l >= ql && r <= qr)
        {
            a[id].lazy = (a[id].lazy + val) % MOD;
            a[id].sum = (a[id].sum + val * (r - l + 1) % MOD) % MOD;
            return;
        }
        pushdown(id, l, r);
        int mid = (l + r) >> 1;
        if (ql <= mid) update(a[id].ls, l, mid, ql, qr, val);
        if (qr > mid) update(a[id].rs, mid + 1, r, ql, qr, val);
        pushup(id);
    }
    void update(int &now, int pre, int l, int r, int ql, int qr, ll val) 
    {
        now = ++cnt;
        a[now] = node(-1, -1, pre, a[pre].sum, a[pre].lazy);  
        if (l >= ql && r <= qr) 
        {
            a[now].lazy = -1;
            a[now].sum = 0; 
            return;
        }
        pushdown(pre, l, r);    
        int mid = (l + r) >> 1;
        if (ql <= mid) update(a[now].ls, a[pre].ls, l, mid, ql, qr, val);
        else a[now].ls = a[pre].ls;  
        if (qr > mid) update(a[now].rs, a[pre].rs, mid + 1, r, ql, qr, val);
        else a[now].rs = a[pre].rs;
        pushup(now);
    }
    ll query(int id, int l, int r, int ql, int qr)
    {
        if (l >= ql && r <= qr) return a[id].sum;
        pushdown(id, l, r);  
        int mid = (l + r) >> 1;
        ll res = 0;
        if (ql <= mid) res = (res + query(a[id].ls, l, mid, ql, qr)) % MOD;
        if (qr > mid) res = (res + query(a[id].rs, mid + 1, r, ql, qr)) % MOD;
        pushup(id);
        return res;
    }
}seg;
 
ll query(int u, int v, int now)
{
    ll res = 0;
    while (top[u] != top[v])
    {
        if (deep[top[u]] < deep[top[v]]) swap(u, v); 
        res = (res + seg.query(now, 1, n, p[top[u]], p[u])) % MOD;
        u = fa[top[u]];
    }
    if (deep[u] > deep[v]) swap(u, v);
    res = (res + seg.query(now, 1, n, p[u], p[v])) % MOD; 
    return res;
}
 
void update(int u, int v, int &now, int pre)    
{
    while (top[u] != top[v])
    {
        if (deep[top[u]] < deep[top[v]]) swap(u, v);
        seg.update(now, pre, 1, n, p[top[u]], p[u], 0); 
        pre = now; 
        u = fa[top[u]];
    }
    if (deep[u] > deep[v]) swap(u, v);
    seg.update(now, pre, 1, n, p[u], p[v], 0); 
}  
 
void init()
{
    memset(head, -1, sizeof head);
    memset(son, -1, sizeof son);
    cntedge = 0;
    cntdfs = 0;
    seg.cnt = 0;  
    seg.build(T[0], 1, n);
}
 
void Run() 
{
    while (scanf("%d", &n) != EOF)
    {
        init();
        for (int i = 1, u, v; i < n; ++i)
        {
            scanf("%d%d", &u, &v);
            addedge(u, v);
            addedge(v, u);
        }
        DFS(1); getpos(1, 1); 
        scanf("%d", &q);
        for (int i = 1, op; i <= q; ++i)   
        {
            scanf("%d", &op);
            if (op == 0)
            {
                int u; ll x;
                scanf("%d%lld", &u, &x);   
                if (x == 0) continue;  
                seg.update(T[0], 1, n, lp[u], rp[u], x); 
            }
            else
            {
                int k, u, v;
                scanf("%d", &k); 
                ll res = 0;
                int tmp = seg.cnt;   
                for (int j = 0; j < k; ++j)
                {
                    scanf("%d%d", &u, &v);
                    res = (res + query(u, v, T[j])) % MOD;  
                    T[j + 1] = 0; 
                    if (j != k - 1) update(u, v, T[j + 1], T[j]);  
                } 
                printf("%lld
", res); 
                seg.cnt = tmp;
            }
        }
    }
}
 
int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 
 
    Run();
    return 0;
}

3626：差分+离线+树剖

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

#define N 50010
int n, q;
vector <int> G[N];
struct qnode { int root, id, vis; };
vector <qnode> que[N];
int ans[N];
int p[N], sze[N], son[N], top[N], deep[N], fa[N], cnt;

void DFS(int u)
{
    sze[u] = 1;
    for (int i = 0, len = G[u].size(); i < len; ++i)
    {
        int v = G[u][i];
        deep[v] = deep[u] + 1;
        fa[v] = u;
        DFS(v); sze[u] += sze[v];
        if (son[u] == -1 || sze[v] > sze[son[u]]) son[u] = v;
    }
}

void getpos(int u, int sp)
{
    top[u] = sp;
    p[u] = ++cnt;
    if (son[u] == -1) return;
    getpos(son[u], sp);
    for (int i = 0, len = G[u].size(); i < len; ++i)
    {
        int v = G[u][i];
        if (v == son[u]) continue;
        getpos(v, v);
    }
}

struct SEG
{
    int sum[N << 2], lazy[N << 2];
    void pushup(int id) { sum[id] = sum[id << 1] + sum[id << 1 | 1]; }
    void init()
    {
        memset(sum, 0, sizeof sum);
        memset(lazy, 0, sizeof lazy);
    }
    void pushdown(int id, int l, int r)
    {
        if (!lazy[id]) return;
        lazy[id << 1] += lazy[id];
        lazy[id << 1 | 1] += lazy[id];
        int mid = (l + r) >> 1;
        sum[id << 1] += lazy[id] * (mid - l + 1);   
        sum[id << 1 | 1] += lazy[id] * (r - mid);
        lazy[id] = 0;
    }
    void update(int id, int l, int r, int ql, int qr)
    {
        if (l >= ql && r <= qr)
        {
            sum[id] += (r - l + 1); 
            ++lazy[id];
            return;
        }
        pushdown(id, l, r);
        int mid = (l + r) >> 1;
        if (ql <= mid) update(id << 1, l, mid, ql, qr);
        if (qr > mid) update(id << 1 | 1, mid + 1, r, ql, qr);
        pushup(id);
    }
    int query(int id, int l, int r, int ql, int qr)
    {
        if (l >= ql && r <= qr) return sum[id];
        pushdown(id, l, r);
        int mid = (l + r) >> 1;
        int res = 0;
        if (ql <= mid) res += query(id << 1, l, mid, ql, qr);
        if (qr > mid) res += query(id << 1 | 1, mid + 1, r, ql, qr);
        pushup(id);
        return res;
    }
}seg;

void update(int u)
{
    while (top[u] != 1)
    {
        seg.update(1, 1, n, p[top[u]], p[u]);
        u = fa[top[u]];
    }
    seg.update(1, 1, n, p[1], p[u]);
}

int query(int u)
{
    int res = 0;
    while (top[u] != 1)
    {
        res += seg.query(1, 1, n, p[top[u]], p[u]);
        u = fa[top[u]];
    }
    res += seg.query(1, 1, n, p[1], p[u]);
    return res;
}

void init()
{
    for (int i = 1; i <= n; ++i) G[i].clear(), que[i].clear();
    memset(ans, 0, sizeof ans);
    memset(son, -1, sizeof son);
    seg.init();
    cnt = 0;
}

void Run() 
{
    while (scanf("%d%d", &n, &q) != EOF)
    {
        init();
        for (int i = 2, u; i <= n; ++i)
        {
            scanf("%d", &u); ++u;
            G[u].push_back(i);
        }
        for (int i = 1, l, r, z; i <= q; ++i)
        {
            scanf("%d%d%d", &l, &r, &z); ++r; ++z;
            que[l].push_back(qnode{ z, i, -1 });
            que[r].push_back(qnode{ z, i, 1 });
        }
        DFS(1); getpos(1, 1);
        for (int i = 1; i <= n; ++i)
        {
            update(i);
            for (int j = 0, len = que[i].size(); j < len; ++j)
            {
                int z = que[i][j].root, vis = que[i][j].vis, id = que[i][j].id;
                ans[id] += vis * query(z);
            }
        }
        for (int i = 1; i <= q; ++i) printf("%d
", ans[i] % 201314);
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;

}

3694：最短路树上枚举非树边+树剖

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

#define N 4010
#define M 100010
#define INF 0x3f3f3f3f
int n, m;

struct Graph
{
    struct node
    {
        int to, nx, w, vis;
        node () {}
        node(int to, int nx, int w, int vis) : to(to), nx(nx), w(w), vis(vis) {}
    }a[M << 1]; int head[N], pos;
    void init()
    {
        memset(head, -1, sizeof head);
        pos = 0;
    }
    void add(int u, int v, int w, int vis)
    {
        a[++pos] = node(v, head[u], w, vis); head[u] = pos;
        a[++pos] = node(u, head[v], w, vis); head[v] = pos;
    }
}G[2];
#define erp(G, u) for (int it = G.head[u], v = G.a[it].to, w = G.a[it].w, vis = G.a[it].vis; ~it; it = G.a[it].nx, v = G.a[it].to, w = G.a[it].w, vis = G.a[it].vis)

int fa[N], dis[N], deep[N], sze[N], son[N], top[N], p[N], fp[N], cnt;
void DFS(int u)
{
    sze[u] = 1;
    erp(G[1], u) if (v != fa[u])
    {
        fa[v] = u;
        dis[v] = dis[u] + w; 
        deep[v] = deep[u] + 1;
        DFS(v); sze[u] += sze[v];
        if (!son[u] || sze[v] > sze[son[u]]) son[u] = v;
    } 
}

void getpos(int u, int sp)
{
    top[u] = sp;
    p[u] = ++cnt;
    fp[cnt] = u;
    if (!son[u]) return;
    getpos(son[u], sp);
    erp(G[1], u) if (v != fa[u] && v != son[u])
        getpos(v, v);
}

struct SEG
{
    int Min[N << 2];
    void build(int id, int l, int r)
    {
        Min[id] = INF;
        if (l == r) return;
        int mid = (l + r) >> 1;
        build(id << 1, l, mid);
        build(id << 1 | 1, mid + 1, r);
    }
    void update(int id, int l, int r, int ql, int qr, int val)
    {
        if (l >= ql && r <= qr)
        {
            Min[id] = min(Min[id], val);
            return;
        }
        int mid = (l + r) >> 1;
        if (ql <= mid) update(id << 1, l, mid, ql, qr, val);
        if (qr > mid) update(id << 1 | 1, mid + 1, r, ql, qr, val);
    }
    int query(int id, int l, int r, int pos)
    {
        if (l == r) return Min[id];
        int mid = (l + r) >> 1;
        int res = Min[id];
        if (pos <= mid) res = min(res, query(id << 1, l, mid, pos));
        else res = min(res, query(id << 1 | 1, mid + 1, r, pos));
        return res;
    }
}seg;

int querylca(int u, int v)
{
    while (top[u] != top[v])
    {
        if (deep[top[u]] < deep[top[v]]) swap(u, v); 
        u = fa[top[u]];
    }
    if (deep[u] > deep[v]) swap(u, v);
    return u;
}

void update(int u, int v, int val)
{
    if (u == v) return;
    while (top[u] != top[v])
    {
        if (deep[top[u]] < deep[top[v]]) swap(u, v);
        seg.update(1, 1, n, p[top[u]], p[u], val);
        u = fa[top[u]];
    }
    if (u == v) return;
    if (deep[u] > deep[v]) swap(u, v);
    seg.update(1, 1, n, p[son[u]], p[v], val);
}

void init()
{
    memset(son, 0, sizeof son);
    cnt = 0;
    G[0].init(); G[1].init();
}

void Run()
{
    while (scanf("%d%d", &n, &m) != EOF)
    {
        init();
        for (int i = 1, u, v, w, vis; i <= m; ++i)
        {
            scanf("%d%d%d%d", &u, &v, &w, &vis);
            G[0].add(u, v, w, vis);
            if (vis) G[1].add(u, v, w, vis);
        } DFS(1); getpos(1, 1); seg.build(1, 1, n);
        for (int i = 2; i <= n; ++i)
        {
            erp(G[0], i) if (!vis)
            {
                int lca = querylca(i, v); 
                update(i, lca, dis[i] + dis[v] + w);  
            } 
        }
        for (int i = 2; i <= n; ++i)
        {
            int res = seg.query(1, 1, n, p[i]); 
            printf("%d%c", res == INF ? -1 : res - dis[i], " 
"[i == n]); 
        }
        
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;
}

3744：分块+树状数组+主席树

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

#define N 50010
#define block 250

int n, m, q;
int arr[N], brr[N], f[block + 10][N];

struct BIT
{
    int a[N];
    void init() { memset(a, 0, sizeof a); } 
    void update(int x, int val) { for (; x <= m; x += x & -x) a[x] += val; }
    int query(int x) { int res = 0; for (; x; x -= x & -x) res += a[x]; return res; }
}bit;

void Hash()
{
    for (int i = 1; i <= n; ++i) brr[i] = arr[i];
    sort(brr + 1, brr + 1 + n);
    m = unique(brr + 1, brr + 1 + n) - brr - 1;
    for (int i = 1; i <= n; ++i) arr[i] = lower_bound(brr + 1, brr + 1 + m, arr[i]) - brr; 
}

struct CHAIR
{
    #define M N * 50
    int T[N], L[M], R[M], C[M], cnt;
    void init(){ cnt = 0; }
    int build(int l, int r)
    {
        int root = cnt++;
        C[root] = 0;
        if (l < r)
        {
            int mid = (l + r) >> 1;
            L[root] = build(l, mid);
            R[root] = build(mid + 1, r);
        }
        return root;
    }
    int update(int root, int pos)
    {
        int newroot = cnt++, tmp = newroot;
        C[newroot] = C[root] + 1;
        int l = 1, r = m;
        while (l < r)
        {
            int mid = (l + r) >> 1;
            if (pos <= mid)
            {
                L[newroot] = cnt++; R[newroot] = R[root];
                newroot = L[newroot], root = L[root];
                r = mid;
            }
            else
            {
                L[newroot] = L[root], R[newroot] = cnt++;
                newroot = R[newroot], root = R[root];
                l = mid + 1;
            }
            C[newroot] = C[root] + 1;
        }
        return tmp;
    }
    int query(int left, int right, int pos)
    {
        int res = 0;
        int l = 1, r = m;
        while (l < r)
        {
            int mid = (l + r) >> 1;
            if (pos <= mid)
            {
                left = L[left];
                right = L[right];
                r = mid;
            }
            else
            {
                res += C[L[right]] - C[L[left]];
                left = R[left];
                right = R[right];
                l = mid + 1;
            }
        }
        return res; 
    }
}chair;

void Run()
{
    while (scanf("%d", &n) != EOF)
    {
        for (int i = 1; i <= n; ++i) scanf("%d", arr + i); Hash();
        for (int i = 1; (i - 1) * block + 1 <= n; ++i) 
        {
            int st = (i - 1) * block + 1;
            bit.init();  
            for (int j = st; j <= n; ++j)   
            {
                bit.update(arr[j], 1);
                f[i][j] = f[i][j - 1] + (j - st + 1) - bit.query(arr[j]);  
            }
        }
        chair.T[0] = chair.build(1, m);
        for (int i = 1; i <= n; ++i) chair.T[i] = chair.update(chair.T[i - 1], arr[i]);   
        scanf("%d", &q);  bit.init();
        int res = 0;
        for (int i = 1, l, r; i <= q; ++i)
        {
            scanf("%d%d", &l, &r);
            l ^= res, r ^= res;
            res = 0;
            if ((l - 1) / block == (r - 1) / block)
            {
                for (int j = l; j <= r; ++j)
                {
                    bit.update(arr[j], 1);
                    res += (j - l + 1) - bit.query(arr[j]);
                }
                for (int j = l; j <= r; ++j) bit.update(arr[j], -1); 
            }
            else
            {
                int nx = (l - 1) / block + 1; 
                res += f[nx + 1][r];  
                for (int j = l; j <= nx * block; ++j) res += chair.query(chair.T[j], chair.T[r], arr[j]); 
            }
            printf("%d
", res);
        }
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;
}

3809：莫队+分块

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

#define N 100010
#define block 450

int n, q;
int arr[N];
struct qnode
{
    int l, r, a, b, id;
    void scan(int id) { this->id = id; scanf("%d%d%d%d", &l, &r, &a, &b); }
    bool operator < (const qnode &r) const
    {
        int posl = l / block, posr = r.l / block;
        return posl == posr ? this->r < r.r : posl < posr;
    }
}que[N * 10]; int ans[N * 10];

int cnt[N], cntblock[block]; 
void update(int x, int val)
{
    if (val == 1)
    {
        if (cnt[arr[x]] == 0) ++cntblock[(arr[x] - 1) / block];
        ++cnt[arr[x]];
    }
    else
    {
        if (cnt[arr[x]] == 1) --cntblock[(arr[x] - 1) / block];
        --cnt[arr[x]];
    }
}

int query(int l, int r)
{
    int posl = (l - 1) / block, posr = (r - 1) / block;
    int res = 0;
    if (posl == posr)
    {
        for (int i = l; i <= r; ++i) if (cnt[i])
            ++res;
    }
    else
    {
        for (int i = l; i <= (posl + 1) * block; ++i) if (cnt[i])
            ++res;
        for (int i = posl + 1; i < posr; ++i)
            res += cntblock[i];
        for (int i = posr * block + 1; i <= r; ++i) if (cnt[i])
            ++res;
    }
    return res;
}

void Run()
{
    while (scanf("%d%d", &n, &q) != EOF)
    {
        for (int i = 1; i <= n; ++i) scanf("%d", arr + i);
        for (int i = 1; i <= q; ++i) que[i].scan(i); 
        sort(que + 1, que + 1 + q);
        memset(cnt, 0, sizeof cnt); 
        memset(cntblock, 0, sizeof cntblock);
        for (int i = 1, l = 1, r = 0; i <= q; ++i)
        {
            for (; r < que[i].r; ++r) update(r + 1, 1);
            for (; r > que[i].r; --r) update(r, -1);
            for (; l < que[i].l; ++l) update(l, -1);
            for (; l > que[i].l; --l) update(l - 1, 1);
            ans[que[i].id] = query(que[i].a, que[i].b);
        }
        for (int i = 1; i <= q; ++i) printf("%d
", ans[i]);
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;
}

3910：树剖

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

#define ll long long
#define N 500010

int n, q, st;
vector <int> G[N];
int arr[N];

struct SEG
{
    struct node
    {
        int l, r, vis, lazy;  
        node() {}
        node(int l, int r)
        {
            this->l = l;
            this->r = r;  
            vis = lazy = 0;
        }
    }a[N << 2];
    void pushdown(int id) 
    {
        if (a[id].lazy)
        {
            a[id].lazy = 0; 
            a[id << 1].vis = 1;
            a[id << 1].lazy = 1;
            a[id << 1 | 1].vis = 1;
            a[id << 1 | 1].lazy = 1;
        }
    }
    void build(int id, int l, int r)
    {
        a[id] = node(l, r);
        if (l == r) return; 
        int mid = (l + r) >> 1;
        build(id << 1, l, mid);
        build(id << 1 | 1, mid + 1, r); 
    }
    void update(int id, int l, int r)
    {
        if (a[id].l >= l && a[id].r <= r)
        {
            a[id].vis = 1;
            a[id].lazy = 1;  
            return;
        }
        pushdown(id); 
        int mid = (a[id].l + a[id].r) >> 1;
        if (l <= mid) update(id << 1, l, r);
        if (r > mid) update(id << 1 | 1, l, r); 
    } 
    int query(int id, int pos)
    {
        if (a[id].l == a[id].r) return a[id].vis;
        pushdown(id); 
        int mid = (a[id].l + a[id].r) >> 1;
        return (pos <= mid ? query(id << 1, pos) : query(id << 1 | 1, pos));
    } 
}seg;

int p[N], fp[N], sze[N], son[N], top[N], fa[N], deep[N], cnt;
void DFS(int u)
{
    sze[u] = 1; 
    for (int i = 0, v, len = G[u].size(); i < len; ++i)
    {
        v = G[u][i];
        if (v != fa[u])
        {
            fa[v] = u;
            deep[v] = deep[u] + 1;
            DFS(v);
            sze[u] += sze[v]; 
            if (son[u] == -1 || sze[v] > sze[son[u]]) son[u] = v;
        }
    }
}

void getpos(int u, int sp)
{
    top[u] = sp; 
    p[u] = ++cnt;
    fp[cnt] = u;
    if (son[u] == -1) return;  
    getpos(son[u], sp);   
    for (int i = 0, v, len = G[u].size(); i < len; ++i)
    {
        v = G[u][i]; 
        if (v != fa[u] && v != son[u])  
            getpos(v, v);   
    }
}

int modify(int u, int v)
{
    int fu = top[u], fv = top[v]; 
    while (fu != fv)
    {
        if (deep[fu] < deep[fv])
        {
            swap(fu, fv);
            swap(u, v);
        }
        seg.update(1, p[fu], p[u]); 
        u = fa[fu]; fu = top[u];
    }
    if (u == v) return u;
    if (deep[u] > deep[v]) swap(u, v); 
    seg.update(1, p[u], p[v]);
    return u;
}

void Run()
{
    while (scanf("%d%d%d", &n, &q, &st) != EOF) 
    {
        seg.build(1, 1, n); 
        memset(son, -1, sizeof son);  
        cnt = 0;
        for (int i = 1; i <= n; ++i) G[i].clear();
        for (int i = 1, u, v; i < n; ++i)
        {
            scanf("%d%d", &u, &v);
            G[u].push_back(v); 
            G[v].push_back(u);
        }
        for (int i = 1; i <= q; ++i) scanf("%d", arr + i);
        DFS(1); getpos(1, 1);       
        ll res = 0;
        for (int i = 1; i <= q; ++i)
        {
            if (seg.query(1, p[arr[i]]) == 0)
            {
                int LCA = modify(st, arr[i]);
                res += deep[st] + deep[arr[i]] - 2 * deep[LCA]; 
                st = arr[i];
            }
        }
        printf("%lld
", res);  
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin); 
    #endif 

    Run();
    return 0;

}

4012：树剖+可持久化线段树（标记永久化）

#include <bits/stdc++.h>
using namespace std;
 
#define N 150010
#define ll long long
#define pii pair <int, int> 
int n, q, a[N], age[N]; ll A;
ll sum[N];
 
struct Graph
{
    struct node
    {
        int to, nx; int w;
        node() {}
        node(int to, int nx, int w) : to(to), nx(nx), w(w) {}
    }a[N << 1];
    int head[N], pos;
    void Init() { memset(head, 0, sizeof head); pos = 0; }
    void add(int u, int v, int w)
    {
        a[++pos] = node(v, head[u], w); head[u] = pos;
        a[++pos] = node(u, head[v], w); head[v] = pos;
    }
}G;
#define erp(u) for (int it = G.head[u], v = G.a[it].to, w = G.a[it].w; it; it = G.a[it].nx, v = G.a[it].to, w = G.a[it].w)
 
ll dis[N], arr[N], prefix[N]; 
int p[N], fp[N], fa[N], deep[N], sze[N], son[N], top[N], cnt;
void DFS(int u)
{
    sze[u] = 1;
    erp(u) if (v != fa[u])
    {
        fa[v] = u;  
        deep[v] = deep[u] + 1;
        dis[v] = dis[u] + w;
        arr[v] = w; 
        DFS(v); sze[u] += sze[v];
        if (!son[u] || sze[v] > sze[son[u]]) son[u] = v;
    }
}
 
void getpos(int u, int sp) 
{
    top[u] = sp;
    p[u] = ++cnt;
    fp[cnt] = u;
    if (!son[u]) return;
    getpos(son[u], sp);
    erp(u) if (v != fa[u] && v != son[u])
        getpos(v, v); 
}
 
int T[N];
struct SEG
{
    #define M N * 75
    struct node
    {
        int ls, rs; ll lazy, sum;  
        node() {}  
        node (int ls, int rs, ll lazy, ll sum) : ls(ls), rs(rs), lazy(lazy), sum(sum) {}
    }a[M]; int cnt; 
    void build(int &now, int l, int r)
    {
        now = ++cnt;
        a[now] = node(-1, -1, 0, 0);
        if (l == r) return;  
        int mid = (l + r) >> 1; 
        build(a[now].ls, l, mid);
        build(a[now].rs, mid + 1, r);
    }
    void update(int &now, int pre, int l, int r, int ql, int qr)
    {  
        now = ++cnt;
        a[now] = a[pre];
        a[now].sum += prefix[qr] - prefix[ql - 1];
        if (l >= ql && r <= qr)  
        {
            ++a[now].lazy;  
            return;
        }
        int mid = (l + r) >> 1;
        if (ql <= mid) update(a[now].ls, a[pre].ls, l, mid, ql, min(mid, qr));
        if (qr > mid) update(a[now].rs, a[pre].rs, mid + 1, r, max(mid + 1, ql), qr);
    } 
    ll query(int lt, int rt, int l, int r, int ql, int qr)
    {
        if (l >= ql && r <= qr) return a[rt].sum - a[lt].sum;    
        int mid = (l + r) >> 1;  
        ll res = (a[rt].lazy - a[lt].lazy) * (prefix[qr] - prefix[ql - 1]);  
        if (ql <= mid) res += query(a[lt].ls, a[rt].ls, l, mid, ql, min(mid, qr));  
        if (qr > mid) res += query(a[lt].rs, a[rt].rs, mid + 1, r, max(mid + 1, ql), qr);
        return res;
    }   
}seg;
 
void update(int u, int v, int &now, int pre) 
{
    now = pre; 
    while (top[u] != top[v])
    {
        if (deep[top[u]] < deep[top[v]]) swap(u, v);
        seg.update(now, pre, 1, n, p[top[u]], p[u]);
        pre = now;  
        u = fa[top[u]];
    } 
    if (u == v) return; 
    if (deep[u] > deep[v]) swap(u, v);
    seg.update(now, pre, 1, n, p[son[u]], p[v]); 
}
 
ll query(int u, int v, int lt, int rt)
{ 
    ll res = 0;
    while (top[u] != top[v])
    {
        if (deep[top[u]] < deep[top[v]]) swap(u, v);
        res += seg.query(lt, rt, 1, n, p[top[u]], p[u]); 
        u = fa[top[u]];
    }
    if (u == v) return res;
    if (deep[u] > deep[v]) swap(u, v); 
    return res + seg.query(lt, rt, 1, n, p[son[u]], p[v]); 
} 
 
bool cmp(int a, int b) { return age[a] < age[b]; }
 
void init()
{
    G.Init(); cnt = 0; dis[1] = 0; deep[1] = 0;
    seg.cnt = 0; sum[0] = 0; arr[1] = 0;
    memset(son, 0, sizeof son);
} 
 
void Run()
{
    while (scanf("%d%d%lld", &n, &q, &A) != EOF)
    {
        init();
        for (int i = 1; i <= n; ++i) scanf("%d", age + i), a[i] = i;
        sort(a + 1, a + 1 + n, cmp); 
        sort(age + 1, age + 1 + n);
        for (int i = 1, u, v, w; i < n; ++i)
        {
            scanf("%d%d%d", &u, &v, &w);
            G.add(u, v, w); 
        }
        DFS(1); getpos(1, 1); 
        seg.build(T[0], 1, n); 
        for (int i = 1; i <= n; ++i) prefix[i] = prefix[i - 1] + arr[fp[i]];
        for (int i = 1; i <= n; ++i) 
        {
            update(1, a[i], T[i], T[i - 1]);  
            sum[i] = sum[i - 1] + dis[a[i]];  
        }
        ll res = 0; int u; ll l, r; 
        for (int i = 1; i <= q; ++i)
        {
            scanf("%d%lld%lld", &u, &l, &r);
            l = (l + res) % A; 
            r = (r + res) % A;
            if (l > r) swap(l, r);  
            int ql = lower_bound(age + 1, age + 1 + n, l) - age;  
            int qr = upper_bound(age + 1, age + 1 + n, r) - age - 1; 
            if (ql > qr) res = 0;  
            else
            {
                res = sum[qr] - sum[ql - 1] + dis[u] * (qr - ql + 1); 
                res -= 2 * query(1, u, T[ql - 1], T[qr]);  
            }
            printf("%lld
", res); res %= A;
        }
    }
}
 
int main()
{
    Run();
    return 0;
}

4236：考虑拆成两个等式判断L, R是否满足，再借助map快速找答案

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

#define N 200010
int n, pos[N], J[N], O[N], I[N]; 
char s[N];
map <int, int> mp[N]; 
int Hasharr[N], m;

void Hash()
{
    for (int i = 0; i <= n; ++i) Hasharr[i] = pos[i];
    sort(Hasharr, Hasharr + 1 + n);
    m = unique(Hasharr, Hasharr + 1 + n) - Hasharr;
    for (int i = 0; i <= n; ++i) pos[i] = lower_bound(Hasharr, Hasharr + 1 + m, pos[i]) - Hasharr;
}

void Run()
{
    while (scanf("%d", &n) != EOF)
    {
        scanf("%s", s + 1);  
        for (int i = 1; i <= n; ++i) 
        {
            J[i] = J[i - 1];
            O[i] = O[i - 1];
            I[i] = I[i - 1];
            if (s[i] == 'J') ++J[i];
            else if (s[i] == 'O') ++O[i]; 
            else ++I[i];
        }
        for (int i = 0; i <= n; ++i) pos[i] = J[i] - O[i];  Hash();
        int res = 0;
        for (int i = 0; i <= n; ++i)  
        {
            int need = O[i] - I[i]; 
            if (mp[pos[i]].find(need) != mp[pos[i]].end())
                res = max(res, i - mp[pos[i]][need]);   
            else
                mp[pos[i]][need] = i;
        }
        printf("%d
", res);
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;
}

4260：可持久化trie+DP

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

#define N 400010
int n;
int arr[N], dp[N];

int T[N];
struct TRIE
{
    struct node
    {
        int son[2], cnt;
    }a[N * 50]; int cnt;
    void Insert(int &now, int pre, int x)
    {
        bitset <32> b; b = x;
        now = ++cnt;
        a[now] = a[pre];
        int root = now;
        for (int i = 31; i >= 0; --i)
        {
            a[++cnt] = a[a[root].son[b[i]]];  
            ++a[cnt].cnt; 
            a[root].son[b[i]] = cnt;
            root = cnt; 
        }
    }
    int query(int lt, int rt, int x)
    {
        bitset <32> b; b = x;
        lt = T[lt], rt = T[rt];
        int res = 0;
        for (int i = 31; i >= 0; --i)
        {
            int id = b[i] ^ 1;
            bool flag = true;
            if (a[a[rt].son[id]].cnt - a[a[lt].son[id]].cnt <= 0)
            {
                flag = false;
                id ^= 1;
            }
            if (flag) res += 1 << i;
            lt = a[lt].son[id];
            rt = a[rt].son[id];
        }
        return res;
    }
}trie;

void Run()
{
    while (scanf("%d", &n) != EOF)
    {
        for (int i = 1; i <= n; ++i) scanf("%d", arr + i);
        for (int i = 1; i <= n; ++i) arr[i] ^= arr[i - 1];
        trie.cnt = 0; trie.Insert(T[0], T[0], 0);  
        for (int i = 1; i <= n; ++i) trie.Insert(T[i], T[i - 1], arr[i]); 
        for (int i = n; i >= 1; --i) dp[i] = max(dp[i + 1], trie.query(i - 1, n, arr[i - 1]));
        int res = 0;
        for (int i = 1; i <= n; ++i)
            res = max(res, trie.query(0, i, arr[i]) + dp[i + 1]);
        printf("%d
", res);
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;
}

4291：考虑如何构造偶数

#include <bits/stdc++.h>
using namespace std;
 
#define ll long long
#define N 1000010
 
int n;
 
void Run()
{
    while (scanf("%d", &n) != EOF)
    {
        ll res = 0; int cnt = 0, Min = 0x3f3f3f3f;
        for (int i = 1, num; i <= n; ++i)
        {
            scanf("%d", &num);
            if (num & 1)
            {
                ++cnt;
                Min = min(Min, num);
            }
            res += num;
        }
        if (cnt & 1) res -= Min;
        if (res == 0)
        {
            puts("NIESTETY");
            continue;
        }
        printf("%lld
", res);
         
    }
}
 
int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin); 
    #endif 
 
    Run();
    return 0;
 
}

4300：对每一位考虑，$b[i] And b[i - 1] != 0$ 即至少有一位都是1

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

#define N 100010
int n, arr[N], Max[32];

void Run()
{
    while (scanf("%d", &n) != EOF)
    {
        for (int i = 1; i <= n; ++i) scanf("%d", arr + i);
        memset(Max, 0, sizeof Max);
        int ans = 0;
        for (int i = 1; i <= n; ++i) 
        {
            bitset <32> b; b = arr[i];
            int res = 0;
            for (int j = 31; j >= 0; --j) if (b[j])
                res = max(res, Max[j]); 
            ans = max(res + 1, ans);
            for (int j = 31; j >= 0; --j) if (b[j])
                Max[j] = max(Max[j], res + 1);
        }
        printf("%d
", ans);
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;
}

4326：二分+树剖+线段树

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

#define ll long long
#define N 300010
#define pii pair <int, int> 
int n, m;  
vector <pii> G[N]; pii que[N];
struct Edge { int u, v; ll w; Edge() {} Edge(int u, int v, ll w) : u(u), v(v), w(w) {} } edge[N];
int p[N], fp[N], fa[N], deep[N], sze[N], son[N], top[N], cnt;   
ll dis[N], arr[N];     

void DFS(int u) 
{
    sze[u] = 1;
    for (int i = 0, len = G[u].size(); i < len; ++i) 
    { 
        int v = G[u][i].first; 
        if (v == fa[u]) continue;  
        fa[v] = u; 
        deep[v] = deep[u] + 1; 
        dis[v] = dis[u] + G[u][i].second;  
        DFS(v); sze[u] += sze[v]; 
        if (!son[u] || sze[v] > sze[son[u]]) son[u] = v;
    }
}

void getpos(int u, int sp) 
{
    top[u] = sp;
    p[u] = ++cnt;           
    fp[cnt] = u;
    if (!son[u]) return; 
     getpos(son[u], sp);
    for (int i = 0, len = G[u].size(); i < len; ++i)
    {
        int v = G[u][i].first;
        if (v == fa[u] || v == son[u]) continue;
        getpos(v, v);
    }
}

struct SEG
{
    int a[N << 2], lazy[N << 2];
    void Init()
    {
        memset(a, 0, sizeof a);
        memset(lazy, 0, sizeof lazy);  
    }
    void pushdown(int id, int l, int r, int mid)
    {
        if (!lazy[id]) return;
        lazy[id << 1] += lazy[id];  
        a[id << 1] += lazy[id] * (mid - l + 1);  
        lazy[id << 1 | 1] += lazy[id];
        a[id << 1 | 1] += lazy[id] * (r - mid);
        lazy[id] = 0;
    }
    void pushup(int id) { a[id] = a[id << 1] + a[id << 1 | 1]; }
    void update(int id, int l, int r, int ql, int qr)
    {
        if (l >= ql && r <= qr)
        {
            a[id] += r - l + 1;
            ++lazy[id]; 
            return;
        }
        int mid = (l + r) >> 1;
        pushdown(id, l, r, mid);
        if (ql <= mid) update(id << 1, l, mid, ql, qr);
        if (qr > mid) update(id << 1 | 1, mid + 1, r, ql, qr);
        pushup(id);
    }
    int query(int id, int l, int r, int pos)
    {
        if (l == r) return a[id];
        int mid = (l + r) >> 1;
        pushdown(id, l, r, mid);
        int res = 0;
        if (pos <= mid) res = query(id << 1, l, mid, pos);
        else res = query(id << 1 | 1, mid + 1, r, pos);
        pushup(id);
        return res;
    }
}seg; 

int querylca(int u, int v)
{
    while (top[u] != top[v])
    {
        if (deep[top[u]] < deep[top[v]]) swap(u, v);
        u = fa[top[u]];  
    }
    if (deep[u] > deep[v]) swap(u, v);
    return u;
}

void update(int u, int v)
{
    while (top[u] != top[v]) 
    {
        if (deep[top[u]] < deep[top[v]]) swap(u, v);
        seg.update(1, 1, n, p[top[u]], p[u]);   
        u = fa[top[u]];   
    }
    if (u == v) return;  
    if (deep[u] > deep[v]) swap(u, v);  
    seg.update(1, 1, n, p[son[u]], p[v]);    
}
 
bool check(ll x)
{
    seg.Init(); vector <ll> vec;     
    for (int i = 1; i <= m; ++i)   
    {
        int u = que[i].first, v = que[i].second;
        ll tot = dis[u] + dis[v] - 2 * dis[querylca(u, v)];
        if (tot <= x) continue;  
        update(u, v);  
        vec.push_back(tot); 
    }
    ll Max = -1; int tot = vec.size(); 
    if (tot == 0) return true;  
    for (int i = 2; i <= n; ++i) if (seg.query(1, 1, n, i) == tot)  
        Max = max(Max, arr[fp[i]]);  
    if (Max == -1) return false; 
    for (int i = 0; i < tot; ++i)   
        if (vec[i] - Max > x) return false;  
    return true; 
}  

void Run()
{
    while (scanf("%d%d", &n, &m) != EOF) 
    {
        ll tot = 0; 
        for (int i = 1, u, v, w; i < n; ++i)
        {
            scanf("%d%d%d", &u, &v, &w);  
            edge[i] = Edge(u, v, w);
            G[u].push_back(pii(v, w)); 
            G[v].push_back(pii(u, w));  
            tot += w;
        }
        for (int i = 1; i <= m; ++i) 
            scanf("%d%d", &que[i].first, &que[i].second);   
        DFS(1); getpos(1, 1);    
        for (int i = 1; i < n; ++i)
        {
            if (fa[edge[i].v] != edge[i].u) swap(edge[i].u, edge[i].v); 
            arr[edge[i].v] = edge[i].w;  
        } 
        ll l = 0, r = tot, res = tot; 
        while (r - l >= 0)
        {
            ll mid = (l + r) >> 1;    
            if (check(mid))
            {
                res = mid;
                r = mid - 1;
            }
            else
                l = mid + 1;
        }
        printf("%lld
", res); 
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;
}

4397：前缀

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

#define N 100010
int n, q;
int sum[3][N];

void Run()
{
    while (scanf("%d%d", &n, &q) != EOF)
    {
        memset(sum, 0, sizeof sum);
        for (int i = 1, x; i <= n; ++i)
        {
            scanf("%d", &x);
            ++sum[x - 1][i];
            for (int j = 0; j < 3; ++j)
                sum[j][i] += sum[j][i - 1];
        }
        for (int i = 1, l, r; i <= q; ++i)
        {
            scanf("%d%d", &l, &r);
            for (int j = 0; j < 3; ++j)
                printf("%d%c", sum[j][r] - sum[j][l - 1], " 
"[j == 2]);
        }
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;
}

4423：对偶图+并查集 建图需要多建一圈

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

#define N 1510
int n, q, S, ans;
int pos[N][N], pre[N * N];

int find(int x) { return pre[x] == 0 ? x : pre[x] = find(pre[x]); }

void Run()
{
    while (scanf("%d%d", &n, &q) != EOF)
    {
        memset(pre, 0, sizeof pre);
        S = (n - 1) * (n - 1) + 1;
        for (int i = 1; i <= n + 1; ++i) for (int j = 1; j <= n + 1; ++j) pos[i][j] = S;
        for (int i = 2, tot = 0; i <= n; ++i) for (int j = 2; j <= n; ++j) pos[i][j] = ++tot; 
        char op; int a, b, x, y; ans = 0; 
        while (q--)
        {
            scanf("%d%d %c", &a, &b, &op);
            if (ans) scanf("%d%d %c", &a, &b, &op);
            if (op == 'N') x = pos[a][b + 1], y = pos[a + 1][b + 1];
            else x = pos[a + 1][b], y = pos[a + 1][b + 1];
            if (!ans) scanf("%d%d %c", &a, &b, &op);
            int fx = find(x), fy = find(y);
            ans = fx == fy; 
            if (!ans) pre[fx] = fy; 
            puts(ans ? "NIE" : "TAK");   
        }
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;
}

4448：可持久化线段树+树链剖分

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

#define N 200010
#define pii pair <int, int>
int n, q;
vector <int> G[N];
int p[N], fp[N], sze[N], fa[N], deep[N], top[N], son[N], cnt;

void DFS(int u)
{
    sze[u] = 1;
    for (int i = 0, len = G[u].size(); i < len; ++i)
    {
        int v = G[u][i];
        if (v == fa[u]) continue;
        fa[v] = u; deep[v] = deep[u] + 1;
        DFS(v); sze[u] += sze[v];
        if (!son[u] || sze[v] > sze[son[u]]) son[u] = v;
    }
}

void getpos(int u, int sp)
{
    top[u] = sp;
    p[u] = ++cnt;
    fp[cnt] = u;
    if (!son[u]) return;
    getpos(son[u], sp);
    for (int i = 0, len = G[u].size(); i < len; ++i)
    {
        int v = G[u][i];
        if (v == fa[u] || v == son[u]) continue;
        getpos(v, v);
    }
}

int T[N];
struct SEG 
{
    #define M N * 40
    int a[M], ls[M], rs[M], cnt;
    void build(int &id, int l, int r)
    {
        id = ++cnt;
        a[id] = 0;
        if (l == r) return;
        int mid = (l + r) >> 1;
        build(ls[id], l, mid);
        build(rs[id], mid + 1, r);
    } 
    void pushup(int id) { a[id] = a[ls[id]] + a[rs[id]]; }
    void update(int &now, int pre, int l, int r, int pos)
    {
        now = ++cnt;
        a[now] = a[pre]; ls[now] = ls[pre]; rs[now] = rs[pre];
        if (l == r)
        {
            ++a[now];
            return;
        }
        int mid = (l + r) >> 1;
        if (pos <= mid) update(ls[now], ls[pre], l, mid, pos);
        else update(rs[now], rs[pre], mid + 1, r, pos);
        pushup(now);
    }
    int query(int now, int l, int r, int ql, int qr)
    {
        if (l >= ql && r <= qr) return a[now];
        int mid = (l + r) >> 1;
        int res = 0;
        if (ql <= mid) res += query(ls[now], l, mid, ql, qr);
        if (qr > mid) res += query(rs[now], mid + 1, r, ql, qr);
        return res;
    }
}seg;

pii query(int u, int v, int c)
{
    int res = 0;
    while (top[u] != top[v])
    {
        if (deep[top[u]] < deep[top[v]])
            swap(u, v);
        res += seg.query(T[c], 1, n, p[top[u]], p[u]);
        u = fa[top[u]]; 
    }
    if (deep[u] > deep[v]) swap(u, v);
    res += seg.query(T[c], 1, n, p[u], p[v]);
    return pii(u, res);
}

void Run()
{
    while (scanf("%d", &n) != EOF)
    {
        for (int i = 1, u; i <= n; ++i)
        {
            scanf("%d", &u);
            if (u)
            {
                G[u].push_back(i);
                G[i].push_back(u);
            }
        }
        DFS(1); getpos(1, 1);
        seg.build(T[0], 1, n);
        scanf("%d", &q);
        int op, x, y, c;
        for (int i = 1; i <= q; ++i)
        {
            scanf("%d%d", &op, &x);
            if (op == 2) seg.update(T[i], T[i - 1], 1, n, p[x]);
            else
            {
                T[i] = T[i - 1]; 
                scanf("%d%d", &y, &c);
                pii res = query(x, y, max(0, i - c - 1)); 
                res.first = deep[x] + deep[y] - 2 * deep[res.first] + 1;
                printf("%d %d
", res.first, res.second);
            }
        }
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;
}

4551：树剖

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

#define ll long long
#define N 100010 

int n, q;
vector <int> G[N];

struct SEG
{
    int Max[N << 2];
    void pushup(int id) { Max[id] = max(Max[id << 1], Max[id << 1 | 1]); }
    void build(int id, int l, int r)
    {
        Max[id] = 0;
        if (l == r) return;
        int mid = (l + r) >> 1;
        build(id << 1, l, mid);
        build(id << 1 | 1, mid + 1, r);
    }
    void update(int id, int l, int r, int pos)
    {
        if (l == r)
        {
            Max[id] = pos;
            return;
        }
        int mid = (l + r) >> 1;
        pos <= mid ? update(id << 1, l, mid, pos) : update(id << 1 | 1, mid + 1, r, pos);
        pushup(id);
    }
    int query(int id, int l, int r, int ql, int qr)
    {
        if (l >= ql && r <= qr) return Max[id];
        int mid = (l + r) >> 1, res = 0;
        if (ql <= mid) res = max(res, query(id << 1, l, mid, ql, qr));
        if (qr > mid) res = max(res, query(id << 1 | 1, mid + 1, r, ql, qr));
        return res;
    }
}seg;

int p[N], fp[N], sze[N], son[N], top[N], fa[N], deep[N], cnt;
void DFS(int u)
{
    sze[u] = 1; 
    for (int i = 0, v, len = G[u].size(); i < len; ++i)
    {
        v = G[u][i];
        if (v != fa[u])
        {
            fa[v] = u;
            deep[v] = deep[u] + 1;
            DFS(v);
            sze[u] += sze[v]; 
            if (son[u] == -1 || sze[v] > sze[son[u]]) son[u] = v;
        }
    }
}

void getpos(int u, int sp)
{
    top[u] = sp; 
    p[u] = ++cnt;
    fp[cnt] = u;
    if (son[u] == -1) return;  
    getpos(son[u], sp);   
    for (int i = 0, v, len = G[u].size(); i < len; ++i)
    {
        v = G[u][i]; 
        if (v != fa[u] && v != son[u])  
            getpos(v, v);   
    }
}

int query(int u, int v)
{
    int fu = top[u], fv = top[v]; 
    int res = 0;
    while (fu != fv)
    {
        if (deep[fu] < deep[fv])
        {
            swap(fu, fv);
            swap(u, v);
        }
        res = max(res, seg.query(1, 1, n, p[fu], p[u])); 
        u = fa[fu]; fu = top[u];
    }
    if (deep[u] > deep[v]) swap(u, v); 
    res = max(res, seg.query(1, 1, n, p[u], p[v])); 
    return res;
}

void Run()
{
    while (scanf("%d%d", &n, &q) != EOF) 
    {
        seg.build(1, 1, n); 
        memset(son, -1, sizeof son);  
        cnt = 0; 
        for (int i = 1; i <= n; ++i) G[i].clear();
        for (int i = 1, u, v; i < n; ++i)
        {
            scanf("%d%d", &u, &v);
            G[u].push_back(v); 
            G[v].push_back(u);
        }
        DFS(1); getpos(1, 1);       
        seg.update(1, 1, n, 1);
        char op;
        for (int i = 1, u; i <= q; ++i)
        {
            scanf(" %c%d", &op, &u);
            if (op == 'Q') printf("%d
", fp[query(u, 1)]); 
            else seg.update(1, 1, n, p[u]);
        }
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin); 
    #endif 

    Run();
    return 0;

}

4552：二分答案+线段树 考虑把 >x 的数标为0，<x 的数标为1

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

#define N 100010
int n, m, q;
int arr[N];

struct qnode
{
    int op, l, r;
    void scan() { scanf("%d%d%d", &op, &l, &r); }
}que[N];

struct SEG
{
    int lazy[N << 2], sum[N << 2];
    void init()
    {
        memset(lazy, -1, sizeof lazy);
        memset(sum, 0, sizeof sum);
    }
    void pushup(int id) { sum[id] = sum[id << 1] + sum[id << 1 | 1]; }
    void pushdown(int id, int l, int r, int mid)
    {
        if (lazy[id] == -1) return;
        lazy[id << 1] = lazy[id];
        sum[id << 1] = lazy[id] * (mid - l + 1);
        lazy[id << 1 | 1] = lazy[id];
        sum[id << 1 | 1] = lazy[id] * (r - mid);
        lazy[id] = -1;
    }
    void update(int id, int l, int r, int ql, int qr, int val)
    {
        if (ql > qr) return;
        if (l >= ql && r <= qr)
        {
            lazy[id] = val;
            sum[id] = val * (r - l + 1);
            return;
        }
        int mid = (l + r) >> 1;
        pushdown(id, l, r, mid);
        if (ql <= mid) update(id << 1, l, mid, ql, qr, val);
        if (qr > mid) update(id << 1 | 1, mid + 1, r, ql, qr, val);
        pushup(id);
    }
    int query(int id, int l, int r, int ql, int qr)
    {
        if (l >= ql && r <= qr) return sum[id];
        int mid = (l + r) >> 1;
        pushdown(id, l, r, mid);
        int res = 0;
        if (ql <= mid) res += query(id << 1, l, mid, ql, qr);
        if (qr > mid) res += query(id << 1 | 1, mid + 1, r, ql, qr);
        pushup(id);
        return res;
    }
}seg;

bool check(int x)
{
    seg.init();
    for (int i = 1; i <= n; ++i)
        seg.update(1, 1, n, i, i, arr[i] > x);
    for (int i = 1; i <= m; ++i)
    {
        int l = que[i].l, r = que[i].r; 
        int cnt_one = seg.query(1, 1, n, l, r), cnt_zero = (r - l + 1) - cnt_one;
        if (que[i].op == 0)
        {
            seg.update(1, 1, n, l, l + cnt_zero - 1, 0);
            seg.update(1, 1, n, l + cnt_zero, r, 1);
        }
        else
        {
            seg.update(1, 1, n, l, l + cnt_one - 1, 1);
            seg.update(1, 1, n, l + cnt_one, r, 0); 
        }
    }
    return !seg.query(1, 1, n, q, q); 
}

void Run()
{
    while (scanf("%d%d", &n, &m) != EOF)
    {
        for (int i = 1; i <= n; ++i) scanf("%d", arr + i);
        for (int i = 1; i <= m; ++i) que[i].scan();
        scanf("%d", &q);
        int l = 1, r = n, res = 0;
        while (r - l >= 0)
        {
            int mid = (l + r) >> 1;
            if (check(mid))
            {
                res = mid;
                r = mid - 1;
            }
            else
                l = mid + 1;
        }
        printf("%d
", res);
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;
}

4553：将一个点拆分成两个，找不等关系，CDQ分治

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

#define N 100010

struct node
{
    int v, Max, Min;
    void scan()
    {
        scanf("%d", &v);
        Max = Min = v;
    }
    void update()
    {
        int tmp;
        scanf("%d", &tmp);
        Max = max(Max, tmp); 
        Min = min(Min, tmp);
    }
}arr[N];

struct qnode
{
    int op, x, y, id; 
    qnode() {}
    qnode(int op, int id, int x, int y) : op(op), id(id), x(x), y(y) {}
    bool operator < (const qnode &r) const { return x == r.x ? (y == r.y ? (id == r.id ? op > r.op : id < r.id) : y < r.y) : x < r.x; } 
}q[N << 1], tq[N << 1];  

struct BIT
{
    int a[N];
    void init() { memset(a, 0, sizeof a); }
    void update(int x, int val) { for (; x < N; x += x & -x) a[x] = max(a[x], val); }
    int query(int x) { int res(0); for (; x; x -= x & -x) res = max(res, a[x]); return res; }
    void clear(int x) { for (; x < N; x += x & -x) a[x] = 0; }    
}bit;

int n, m, res; 
int dp[N]; 

void CDQ(int l, int r)
{
    if (l >= r) return;
    int mid = (l + r) >> 1;
    CDQ(l, mid);
    for (int i = l; i <= r; ++i) 
    {
        tq[i] = q[i];
        if (i <= mid)
        {
            if (tq[i].op == 1)
                tq[i].op = 0;
            else
                tq[i].op = 3;
        }
    } 
    sort(tq + l, tq + r + 1); 
    for (int i = l; i <= r; ++i)
    {
        if (!tq[i].op) bit.update(tq[i].y, dp[tq[i].id]);  
        else if (tq[i].op == 2) dp[tq[i].id] = max(dp[tq[i].id], bit.query(tq[i].y) + 1);   
    }
    for (int i = l; i <= r; ++i) if (!tq[i].op) bit.clear(tq[i].y);  
    CDQ(mid + 1, r);  
}


void Run()
{
    while (scanf("%d%d", &n, &m) != EOF)
    {
        bit.init();
        for (int i = 1; i <= n; ++i) dp[i] = 1;
        for (int i = 1; i <= n; ++i) arr[i].scan(); 
        for (int i = 1, x; i <= m; ++i)
        {
            scanf("%d", &x); 
            arr[x].update();
        } 
        for (int i = 1; i <= n; ++i) 
        { 
            q[(i << 1) - 1] = qnode(2, i, arr[i].Min, arr[i].v); 
            q[i << 1] = qnode(1, i, arr[i].v, arr[i].Max); 
        }
        CDQ(1, n << 1); res = 1; 
        for (int i = 1; i <= n; ++i) res = max(res, dp[i]);
        printf("%d
", res); 
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;
}

4999：树链剖分+线段树 （离散化后对每一个x开线段树，动态开点）

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

#define N 100010
#define M 3500010

int n, m, q;
int arr[N], brr[N << 2];
vector <int> G[N];

int Get(int x)
{
    return lower_bound(brr + 1, brr + 1 + m, x) - brr;
}

struct QUE
{
    int op, u, v, x;
    void scan()
    {
        char s[10];
        scanf("%s", s);
        if (s[0] == 'Q')
        {
            op = 0;
            scanf("%d%d%d", &u, &v, &x);
            brr[++m] = x;  
        }
        else
        {
            op = 1;
            scanf("%d%d", &u, &x);
            brr[++m] = x;
        }
    }
}que[N << 1];

int top[N], num[N], deep[N], fa[N], son[N], p[N], fp[N], pos;

void DFS(int u)
{
    num[u] = 1;
    for (int i = 0, len = G[u].size(); i < len; ++i) 
    {
        int v = G[u][i];
        if (v == fa[u]) continue;
        deep[v] = deep[u] + 1;
        fa[v] = u;
        DFS(v); num[u] += num[v];
        if (son[u] == -1 || num[v] > num[son[u]])
            son[u] = v; 
    }
}

void getpos(int u, int sp) 
{
    top[u] = sp;
    p[u] = ++pos;
    fp[pos] = u;
    if (son[u] == -1) return;
    getpos(son[u], sp);
    for (int i = 0, len = G[u].size(); i < len; ++i)
    {
        int v = G[u][i];
        if (v != son[u] && v != fa[u])
            getpos(v, v);
    }
}

struct SEG
{
    int T[N << 2], lson[M], rson[M], c[M], cnt;
    
    void pushup(int id)
    {
        c[id] = c[lson[id]] + c[rson[id]];
    }

    void update(int &x, int l, int r, int pos, int val)
    {
        if (!x)
        {
            x = ++cnt;
            lson[x] = rson[x] = c[x] = 0;
        }
        if (l == r)
        {
            c[x] += val;
            return;
        }
        int mid = (l + r) >> 1;
        if (pos <= mid) update(lson[x], l, mid, pos, val);
        else update(rson[x], mid + 1, r, pos, val);
        pushup(x);
    }

    int query(int x, int l, int r, int ql, int qr)
    {
        if (l >= ql && r <= qr) return c[x];
        int mid = (l + r) >> 1;
        int res = 0;
        if (ql <= mid) res += query(lson[x], l, mid, ql, qr);
        if (qr > mid) res += query(rson[x], mid + 1, r, ql, qr);
        return res;
    }
    
}segtree;

int query(int u, int v, int x)
{
    int fu = top[u], fv = top[v];
    x = segtree.T[x];
    int res = 0;
    while (fu != fv)
    {
        if (deep[fu] < deep[fv])
        {
            swap(u, v);
            swap(fu, fv);
        }
        res += segtree.query(x, 1, n, p[fu], p[u]);
        u = fa[fu];
        fu = top[u];
    }
    if (deep[u] > deep[v]) swap(u, v);
    res += segtree.query(x, 1, n, p[u], p[v]);
    return res;
}

void Run()
{
    while (scanf("%d%d", &n, &q) != EOF)
    {
        m = 0; fa[1] = 1; deep[1] = 0; pos = 0; 
        memset(son, -1, sizeof son);
        for (int i = 1; i <= n; ++i) scanf("%d", arr + i), brr[++m] = arr[i];
        for (int i = 1, u, v; i < n; ++i)
        {
            scanf("%d%d", &u, &v);
            G[u].push_back(v);
            G[v].push_back(u);
        } DFS(1); getpos(1, 1);
        for (int i = 1; i <= q; ++i) que[i].scan();
        sort(brr + 1, brr + 1 + m);
        m = unique(brr + 1, brr + 1 + m) - brr - 1;  
        for (int i = 1; i <= n; ++i) arr[i] = Get(arr[i]); 
        for (int i = 1; i <= q; ++i) que[i].x = Get(que[i].x);
        for (int i = 1; i <= n; ++i) segtree.update(segtree.T[arr[i]], 1, n, p[i], 1);  
        for (int i = 1; i <= q; ++i)
        {
            if (que[i].op == 0)
                printf("%d
", query(que[i].u, que[i].v, que[i].x));
            else
            {
                int u = que[i].u, x = que[i].x;
                segtree.update(segtree.T[arr[u]], 1, n, p[u], -1);  
                arr[u] = x;
                segtree.update(segtree.T[arr[u]], 1, n, p[u], 1);
            }
        }
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif

    Run();
    return 0;
}

5204：水。

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

#define N 100010
int t, n, m, a[N], b[N], cnt[N];

void Hash()
{
    for (int i = 1; i <= n; ++i) b[i] = a[i];
    sort(b + 1, b + 1 + n);
    m = unique(b + 1, b + 1 + n) - b - 1;
    for (int i = 1; i <= n; ++i) a[i] = lower_bound(b + 1, b + 1 + m, a[i]) - b;
}

bool ok()
{
    for (int i = 2; i <= m; ++i) if (cnt[i] != cnt[i - 1])
        return true;
    return false; 
}

void Run()
{
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n);
        memset(cnt, 0, sizeof cnt);
        for (int i = 1; i <= n; ++i) scanf("%d", a + i); Hash();
        for (int i = 1; i <= n; ++i) ++cnt[a[i]];
        if (!ok()) puts("-1");
        else
        {
            int Max = *max_element(cnt + 1, cnt + 1 + m);
            int tot = 0;
            for (int i = 1; i <= m; ++i) if (cnt[i] == Max)
                ++tot;
            printf("%d
", tot);
            for (int i = 1, j = 0; i <= m; ++i) if (cnt[i] == Max)
                printf("%d%c", b[i], " 
"[(++j) == tot]);
        }
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;
}

5293：lca+前缀点权和

#include <bits/stdc++.h>
using namespace std;
 
#define ll long long
#define N 300010
const ll MOD = (ll)998244353;
int n, q;
vector <int> G[N];
int p[N], fp[N], deep[N], fa[N], sze[N], top[N], son[N], cnt;
ll dis[N][55];
 
void DFS(int u)
{
    sze[u] = 1;
    for (int i = 0, len = G[u].size(); i < len; ++i) 
    {
        int v = G[u][i];
        if (v == fa[u]) continue;
        fa[v] = u; deep[v] = deep[u] + 1;
        dis[v][1] = deep[v];
        dis[v][0] = 1;
        for (int i = 2; i <= 50; ++i)
            dis[v][i] = (dis[v][i - 1] * deep[v]) % MOD;
        for (int i = 0; i <= 50; ++i)
            dis[v][i] = (dis[v][i] + dis[u][i]) % MOD;
        DFS(v); sze[u] += sze[v];  
        if (son[u] == -1 || sze[v] > sze[son[u]]) son[u] = v;
    }
}
 
void getpos(int u, int sp)
{
    top[u] = sp;
    p[u] = ++cnt;
    fp[cnt] = u;
    if (son[u] == -1) return; 
    getpos(son[u], sp); 
    for (int i = 0, len = G[u].size(); i < len; ++i) 
    {
        int v = G[u][i];
        if (v == fa[u] || v == son[u]) continue;
        getpos(v, v);
    }
}
 
int querylca(int u, int v)
{
    while (top[u] != top[v])
    {
        if (deep[top[u]] < deep[top[v]])
            swap(u, v);
        u = fa[top[u]];
    }
    if (deep[u] > deep[v]) swap(u, v);
    return u;
}
 
 
void Init()
{
    for (int i = 1; i <= n; ++i) G[i].clear();
    memset(son, -1, sizeof son);
    cnt = 0; dis[1][0] = 1;
}
 
void Run()
{
    while (scanf("%d", &n) != EOF)
    {
        Init();
        for (int i = 1, u, v; i < n; ++i)
        {
            scanf("%d%d", &u, &v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        DFS(1); getpos(1, 1);
        scanf("%d", &q);
        for (int i = 1, u, v, k; i <= q; ++i)
        {
            scanf("%d%d%d", &u, &v, &k);
            int lca = querylca(u, v);
            printf("%lld
", (dis[u][k] + dis[v][k] - dis[lca][k] - dis[fa[lca]][k] + 2 * MOD) % MOD); 
        }
    }
}
 
int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 
 
    Run();
    return 0;
}

5301：莫队

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

#define N 100010
#define unit 450
#define ll long long 

struct qnode
{
    int l, r, id;
    void scan(int id)
    {
        scanf("%d%d", &l, &r); --l;
        this->id = id;
    }
    bool operator < (const qnode &r) const
    {
        int posl = l / unit, posr = r.l / unit;
        return posl < posr || posl == posr && this->r < r.r;
    }
}que[N];
int n, m, k, a[N], ans[N], cnt[N];
ll res;

void add(int x)
{
    if (x == -1) return;
    int pos = a[x] ^ k;
    res += cnt[pos];
    ++cnt[a[x]];
}

void del(int x)
{
    if (x == -1) return;
    int pos = a[x] ^ k;
    --cnt[a[x]];
    res -= cnt[pos];
}

void Run()
{
    while (scanf("%d%d%d", &n, &m, &k) != EOF)
    {
        memset(cnt, 0, sizeof cnt); 
        for (int i = 1; i <= n; ++i) scanf("%d", a + i), a[i] ^= a[i - 1];
        for (int i = 1; i <= m; ++i) que[i].scan(i);
        sort(que + 1, que + 1 + m); cnt[0] = 1;
        for (int i = 1, l = 0, r = 0; i <= m; ++i)
        {
            for (; r < que[i].r; ++r) add(r + 1);  
            for (; r > que[i].r; --r) del(r);
            for (; l < que[i].l; ++l) del(l); 
            for (; l > que[i].l; --l) add(l - 1);
            ans[que[i].id] = res;
        }
        for (int i = 1; i <= m; ++i) printf("%d
", ans[i]);
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;
}

5313：循环节

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

int f[30];

void Run()
{
    f[1] = 1, f[2] = 1;
    for (int i = 3; i < 30; ++i) f[i] = (f[i - 1] + f[i - 2]) % 5;
    int q, x;
    while (scanf("%d", &q) != EOF)
    {
        while (q--)
        {
            scanf("%d", &x);
            printf("%d
", f[(x - 1) % 20 + 1]); 
        }
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;
}

5338：树剖+可持久化Trie

#include <bits/stdc++.h>
using namespace std;
 
#define N 100010
int n, q;
int arr[N];
vector <int> G[N];
int p[N], fp[N], lp[N], rp[N], sze[N], son[N], top[N], deep[N], fa[N], cnt;
 
void DFS(int u)
{
    sze[u] = 1;
    for (int i = 0, len = G[u].size(); i < len; ++i)
    {
        int v = G[u][i];
        if (v == fa[u]) continue;
        fa[v] = u; deep[v] = deep[u] + 1;
        DFS(v); sze[u] += sze[v];
        if (son[u] == -1 || sze[v] > sze[son[u]]) son[u] = v;
    }
}
 
void getpos(int u, int sp)
{
    top[u] = sp;
    p[u] = ++cnt;
    fp[cnt] = u;
    lp[u] = cnt;
    if (son[u] == -1)
    {
        rp[u] = cnt;
        return;
    }
    getpos(son[u], sp);
    for (int i = 0, len = G[u].size(); i < len; ++i)
    {
        int v = G[u][i];
        if (v == fa[u] || v == son[u]) continue;
        getpos(v, v);
    }
    rp[u] = cnt;
}
 
int T[N];
struct TRIE
{
    struct node
    {
        int son[2], cnt;
        node() { memset(son, 0, sizeof son); cnt = 0; }
    }a[N * 50]; int cnt;
    void Init()
    {
        a[1] = node();
        cnt = 0;
    }
    void Insert(int now, int pre, int val)
    {
        bitset <30> b; b = val;
        T[now] = ++cnt;  
        pre = T[pre]; 
        now = T[now];
        a[now] = a[pre]; 
        for (int i = 29; i >= 0; --i)
        {
            a[++cnt] = a[a[now].son[b[i]]];  
            ++a[cnt].cnt;
            a[now].son[b[i]] = cnt;
            now = cnt;
        }  
    }
    int query(int lt, int rt, int val)
    {
        bitset <30> b; b = val;
        lt = T[lt], rt = T[rt];
        int res = 0;
        for (int i = 29; i >= 0; --i)
        {
            int id = b[i] ^ 1;
            bool flag = true;
            if (a[a[rt].son[id]].cnt - a[a[lt].son[id]].cnt <= 0) 
            {
                id ^= 1;
                flag = false;
            }
            if (flag) res += 1 << i;
            rt = a[rt].son[id];
            lt = a[lt].son[id];
        }
        return res;
    }
}trie;
 
int query(int u, int v, int x)
{
    int res = 0;
    while (top[u] != top[v])
    {
        if (deep[top[u]] < deep[top[v]])
            swap(u, v);
        res = max(res, trie.query(p[top[u]] - 1, p[u], x));
        u = fa[top[u]];
    }
    if (deep[u] > deep[v]) swap(u, v);
    res = max(res, trie.query(p[u] - 1, p[v], x));
    return res;
}
 
void Init()
{
    memset(son, -1, sizeof son);
    trie.Init();
}
 
void Run()
{
    while (scanf("%d%d", &n, &q) != EOF)
    {
        Init();
        for (int i = 1; i <= n; ++i) scanf("%d", arr + i);
        for (int i = 1, u, v; i < n; ++i)
        {
            scanf("%d%d", &u, &v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        DFS(1); getpos(1, 1);
        for (int i = 1; i <= n; ++i) trie.Insert(i, i - 1, arr[fp[i]]);
        for (int i = 1, op, x, y, z; i <= q; ++i)
        {
            scanf("%d%d%d", &op, &x, &y);
            if (op == 1) printf("%d
", trie.query(lp[x] - 1, rp[x], y));
            else
            {
                scanf("%d", &z);
                printf("%d
", query(x, y, z));
            }
        }
    }
}
 
int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 
 
    Run();
    return 0;
}

end.