考前模板整理

写在前面

考前太焦虑了。。想8出题，就来写板子吧。去年列的目录找不到了，重新列了一个。感觉不是很全，代码一点点填吧，，拜托各位大佬在下方补充目录啊~也可以帮助一下读到这篇笔记的人$qwq$。

PS:这个板子用博客园的代码插入是真的丑，不过没时间修板子了。。。凑合用吧。。。。

成功不必在我，而功力必不唐捐。 

算法

数位dp

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
using namespace std;
typedef long long ll;

ll read() {
    ll x = 0,f = 1;char c = getchar();
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - '0';c = getchar();
    }
    return x * f;
}
int a[12],f[12][10][2],cnt;//f[i][j][k]表示前i位，第i - 1位为j,是(1)否(0)有限制的方案数 
int dfs(int pos,int lst,int lim) {
    if(pos == 0) return 1;
    if(f[pos][lst][lim] != -1) return f[pos][lst][lim];    
    int ret = 0;    
    int k = 9;
    if(lim) k = a[pos];    
    for(int i = 0;i <= k;++i) {
        if(i == 4 || (lst == 6 && i == 2)) continue;
        ret += dfs(pos - 1,i,lim && (i == k));
    }
    return f[pos][lst][lim] = ret;
    
}
int solve(int x) {
    memset(f,-1,sizeof(f));
    cnt = 0;
    while(x) {
        a[++cnt] = x % 10;
        x /= 10;
    }
    return dfs(cnt,0,1);
}
int main() {
    while(1) {
        int l = read(),r = read();
        if(!l && !r) return 0;
        printf("%d
",solve(r) - solve(l - 1));
    }
    return 0;
}

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
using namespace std;
typedef long long ll;
const int mod = 1000000007;
ll read() {
    ll x = 0,f = 1;char c = getchar();
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - '0';c = getchar();
    }
    return x * f;
}
char s[110];
int a[110],f[110][10][2][2][2];//f[i][j][0/1][0/1][0/1]表示前i位第i-1位填的是j，是否有限制，是否在递增，是否为前导0 
int dfs(int pos,int lst,int flag,int lim,int rea) {
    if(!pos) return rea;
    if(f[pos][lst][flag][lim][rea] != -1) return f[pos][lst][flag][lim][rea];
    int l = 0,r = 9;
    if(lim) r = a[pos];
    if(flag) l = lst;
    int ret = 0;
    for(int i = l;i <= r;++i) {
        ret += dfs(pos - 1,i,flag || (i > lst && rea),lim && (i == r),((!rea) && (!i)) ^ 1);
        ret %= mod;
    }
    return f[pos][lst][flag][lim][rea] = ret;
}

int main() {
    int T = read();
    while(T--) {
        memset(f,-1,sizeof(f));
        scanf("%s",s + 1);
        int n = strlen(s + 1);
        for(int i = 1;i <= n;++i) a[n - i + 1] = s[i] - '0';
        cout<<dfs(n,0,0,1,0)<<endl;
    }
    return 0;
}

矩阵乘法

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
using namespace std;
typedef long long ll;
const int mod = 1e9 + 7;
ll read() {
    ll x = 0,f = 1;char c = getchar();
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - '0';c = getchar();
    }
    return x * f;
}

struct node {
    int a[10][10],n,m;
    node() {
        memset(a,0,sizeof(a));n = m = 0;
    }
    node(int x) {
        n = m = x;
        memset(a,0,sizeof(a)); for(int i = 1;i <= n;++i) a[i][i] = 1;
    }
    node(int x,int y) {
        n = x,m = y; memset(a,0,sizeof(a));
    }
};

node operator * (const node &A,const node &B) {
    int n = A.n,m = B.m,K = A.m;
    node C(n,m);
    for(int k = 1;k <= K;++k)
        for(int i = 1;i <= n;++i)
            for(int j = 1;j <= m;++j)
                C.a[i][j] += 1ll * A.a[i][k] * B.a[k][j] % mod,C.a[i][j] %= mod;

    return C;
}
node operator ^ (node A,int y) {
    node ret(A.n);
    for(;y;y >>= 1,A = A * A)
        if(y & 1) ret =ret * A;
    return ret;
}

int main() {
    int T = read();
    node A(1,3);
    A.a[1][1] = A.a[1][2] = A.a[1][3] = 1;

    node C(3,3);
    C.a[1][1] = C.a[1][2] = C.a[2][3] = C.a[3][1] = 1;
    
    while(T--) {
        int n = read();
        if(n <= 3) {puts("1");continue;}
        printf("%d
",(A * (C ^ (n - 3))).a[1][1]);
        
    }
    return 0;
}

manacher

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
using namespace std;
typedef long long ll;
const int N = 31000000;
ll read() {
    ll x = 0,f = 1;char c = getchar();
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - '0';c = getchar();
    }
    return x * f;
}
int f[N],id,mx;
char s[N],t[N];
int main() {
    scanf("%s",t + 1);
    int n = strlen(t + 1);
    int m = 0;
    s[++m] = '#';
    for(int i = 1;i <= n;++i) {
        s[++m] = t[i];
        s[++m] = '#';
    }
    n = m;
    int ans = 0;
    for(int i = 1;i <= n;++i) {
        
        if(i <= id + mx) f[i] = min(f[id * 2 - i],id + mx - i);
        while(i - f[i] - 1 >= 1 && i + f[i] + 1 <= n && s[i + f[i] + 1] == s[i - f[i] - 1]) ++f[i];
        if(i + f[i] > id + mx) {
            id = i;mx = f[i];
        }
        ans = max(ans,f[i]);
    }
    cout<<ans;
    
    return 0;
}

kmp

//n-nxt[n]为最小循环节的长度 
#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
using namespace std;
typedef long long ll;
const int N = 2000100;
ll read() {
    ll x = 0,f = 1;char c = getchar();
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - '0';c = getchar();
    }
    return x * f;
}
int n,m,nxt[N];
char s[N],t[N];
void get_nxt() {
    
    int p = 0;
    for(int i = 2;i <= m;++i) {
        while(p && t[i] != t[p + 1]) p = nxt[p];
        if(t[i] == t[p + 1]) ++p;
        nxt[i] = p;
    }
    
}
int main() {
    scanf("%s",s + 1);
    scanf("%s",t + 1);
    n = strlen(s + 1);
    m = strlen(t + 1);
    
    get_nxt();
    
    int p = 0;
    for(int i = 1;i <= n;++i) {
        while(p && s[i] != t[p + 1]) p = nxt[p];
        if(s[i] == t[p + 1]) {
            ++p;
            if(p == m) {
                printf("%d
",i - m + 1);
                p = nxt[p];
            }
        }
    }
    for(int i = 1;i <= m;++i) printf("%d ",nxt[i]);
    return 0;
}

AC自动机

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
using namespace std;
typedef long long ll;
const int N = 2000100;
ll read() {
    ll x = 0,f = 1;char c = getchar();
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - '0';c = getchar();
    }
    return x * f;
}
int trie[N][26],tot,ans[N],bz[N];
void ins(char *s,int pos) {//插入字符串 
    int now = 0,len = strlen(s + 1);
    for(int i = 1;i <= len;++i) {
        int k = s[i] - 'a';
        if(!trie[now][k]) trie[now][k] = ++tot;
        now = trie[now][k];
    }    
    bz[pos] = now;
}
queue<int>q;
vector<int>e[N];
int fail[N];
void pre() { //构造trie图 
    for(int i = 0;i < 26;++i) if(trie[0][i]) q.push(trie[0][i]);
    while(!q.empty()) {
        int u = q.front();q.pop();
        
        for(int i = 0;i < 26;++i) {
            if(!trie[u][i]) trie[u][i] = trie[fail[u]][i];
            else fail[trie[u][i]] = trie[fail[u]][i],q.push(trie[u][i]);
        }
    }
    
    for(int i = 1;i <= tot;++i) e[fail[i]].push_back(i);//构建fail树 

}
char s[N];
void solve() {
    int len = strlen(s + 1);
    int now = 0;
    for(int i = 1;i <= len;++i) {
        now = trie[now][s[i] - 'a'];
        ans[now]++;
    }
}
void dfs(int u) {
    for(vector<int>::iterator it = e[u].begin();it != e[u].end();++it) {
        dfs(*it);
        ans[u] += ans[*it];//某个节点在母串中出现的次数是fail树上其子树答案之和。 
    }
}
int main() {
    int T = read();
    for(int i = 1;i <= T;++i) {
        scanf("%s",s + 1);
        ins(s,i);
    }
    pre();
    scanf("%s",s + 1);
    solve();
    dfs(0);
    
    for(int i = 1;i <= T;++i) printf("%d
",ans[bz[i]]);

    return 0;
}

线性基

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
using namespace std;
typedef long long ll;
const int N = 110;
ll read() {
    ll x = 0,f = 1;char c = getchar();
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - '0';c = getchar();
    }
    return x * f;
}
ll p[N];
void ins(ll x) {
    for(int i = 50;i >= 0;--i) {
        if(!((x >> i) & 1)) continue;
        if(!p[i]) {p[i] = x;break;}
        else x ^= p[i];
    }
}
int main() {
    int n = read();
    for(int i = 1;i <= n;++i) {
        ll x = read();
        ins(x);
    }
    ll ans = 0;
    for(int i = 50;i >= 0;--i)
        if((ans ^ p[i]) > ans) ans ^= p[i];
    cout<<ans;
    return 0;
}

meet in the middle

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<unordered_map>
#include<vector>
#include<queue>
#include<set>
using namespace std;
typedef long long ll;

ll read() {
    ll x = 0,f = 1;char c = getchar();
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - '0';c = getchar();
    }
    return x * f;
}
unordered_map<ll,ll>ma[30];
ll a[30],n,K,S,jc[30];
void dfs1(int pos,ll now,int k) {
    if(pos == n / 2 + 1) {
        ma[k][now]++;return;
    }
    
    dfs1(pos + 1,now,k);
    dfs1(pos + 1,now + a[pos],k);
    if(a[pos] <= 19 && jc[a[pos]] <= S && k + 1 <= K) dfs1(pos + 1,now + jc[a[pos]],k + 1);
}
ll ans;
void dfs2(int pos,ll now,int k) {
    if(pos == n / 2) {
        for(int j = 0;j + k <= K;++j) ans += ma[j][S - now];
        return;
    }
    dfs2(pos - 1,now,k);
    dfs2(pos - 1,now + a[pos],k);
    if(a[pos] <= 19 && jc[a[pos]] <= S && k + 1 <= K) dfs2(pos - 1,now + jc[a[pos]],k + 1);
    
}
int main() {
    n = read(),K = read(),S = read();
    for(int i = 1;i <= n;++i) a[i] = read();
    jc[0] = 1;
    for(int i = 1;i <= 19;++i) jc[i] = jc[i - 1] * i;
    
    dfs1(1,0,0);
    dfs2(n,0,0);
    cout<<ans;
    return 0;
}

tarjan

点双

边双

割点

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
using namespace std;
typedef long long ll;
const int N = 200100;
ll read() {
    ll x = 0,f = 1;char c = getchar();
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - '0';c = getchar();
    }
    return x * f;
}
int dfn[N],low[N],tot;
struct node {
    int v,nxt;
}e[N << 1];
int head[N],ejs;
void add(int u,int v) {
    e[++ejs].v = v;e[ejs].nxt = head[u];head[u] = ejs;
}
int du,ans[N],root;
void tarjan(int u,int fa) {
    if(!dfn[u]) dfn[u] = low[u] = ++tot;
    for(int i = head[u];i;i = e[i].nxt) {
        int v = e[i].v;
        if(v == fa) continue;
        if(!dfn[v]) {
            tarjan(v,u);
            low[u] = min(low[u],low[v]);
            if(u == root) du++;
            if(low[v] >= dfn[u] && u != root) ans[u] = 1;
        }
        else low[u] = min(low[u],low[v]);
    }
    if(du >= 2 && u == root) ans[u] = 1;
}

int main() {
    int n = read(),m = read();
    for(int i = 1;i <= m;++i) {
        int u = read(),v = read();
        add(u,v);add(v,u);
    }
    
    for(int i = 1;i <= n;++i) {
        if(!dfn[i]) {
            root = i;
            du = 0;
            tarjan(i,0);
        }
    }
    int cnt = 0;
    for(int i = 1;i <= n;++i) cnt += ans[i];
    printf("%d
",cnt);
    for(int i = 1;i <= n;++i) if(ans[i]) printf("%d ",i);

    return 0;
}

强连通分量

莫队

朴素莫队

待带修莫队

树上莫队

分数规划

匈牙利

差分约束

分层图

欧拉回路

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
using namespace std;
typedef long long ll;
const int N = 100100;
ll read() {
    ll x = 0,f = 1;char c = getchar();
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - '0';c = getchar();
    }
    return x * f;
}
int rc() {
    char c = getchar();
    while(c < 'A' || c > 'z') c = getchar();
    if(c > 'Z') c -= 6;
    return c - 'A';
}
int n,a[100][100],du[100],ans[N],cnt;
void dfs(int u) {
    for(int i = 0;i < 52;++i)
        if(a[u][i]) a[u][i]--,a[i][u]--,dfs(i);
    ans[++cnt] = u;
}

int main() {
    n = read();
    int rt = 52;
    for(int i = 1;i <= n;++i) {
        int u = rc(),v = rc();
        if(!a[u][v]) {
            a[u][v]++;
            a[v][u]++;
            du[u]++;du[v]++;
            
        }
    }

    int js = 0;
    for(int i = 0;i < 52;++i)
        if(du[i] & 1) js++;

    if(js == 0) {
        for(int i = 0;i < 52;++i) if(du[i]) rt = min(rt,i);
    }
    else if(js == 2) {
        for(int i = 0;i < 52;++i) if(du[i] & 1) rt = min(rt,i);
    }
    else {puts("No Solution");return 0;}
    
    dfs(rt);
    
    for(int i = cnt;i >= 1;--i) putchar(ans[i] + 'A' > 'Z' ? ans[i] + 'A' + 6 : ans[i] + 'A');
    
    return 0;
}

数学

高斯消元

线性筛

线性筛素数

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
using namespace std;
typedef long long ll;
const int N = 10000010;
ll read() {
    ll x = 0,f = 1;char c = getchar();
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - '0';c = getchar();
    }
    return x * f;
}
int dis[N],vis[N],cnt;
int main() {
    int n = read(),m = read();
    vis[1] = 1;
    for(int i = 2;i <= n;++i) {
        if(!vis[i]) dis[++cnt] = i; 
        for(int j = 1;j <= cnt && dis[j] * i <= n;++j) {
            vis[dis[j] * i] = 1;
            if(i % dis[j] == 0) break;
        }
    }
    while(m--) puts(vis[read()] ? "No" : "Yes");
    return 0;
}

线性筛欧拉函数

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstdlib>
#include<ctime>
#include<queue>
#include<map>
using namespace std;
typedef long long ll;
const int N = 10000100;
ll read() {
    ll x = 0,f = 1;char c = getchar();
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - '0';c = getchar();
    }
    return x * f;
}
int vis[N],pri[N],phi[N],cnt;
int main() {
    int n = read();
    phi[1] = 1;
    for(int i = 2;i <= n;++i) {
        if(!vis[i]) {
            phi[i] = i - 1;
            pri[++cnt] = i;
        }
        for(int j = 1;j <= cnt && pri[j] * i <= n;++j) {
            vis[pri[j] * i] = 1;
            if(i % pri[j] == 0) {
                phi[pri[j] * i] = pri[j] * phi[i];break;
            }
            phi[pri[j] * i] = (pri[j] - 1) * phi[i];
        }
        printf("phi(%d) = %d
",i,phi[i]);
    }
    return 0;
}

欧拉函数

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
using namespace std;
typedef long long ll;

ll read() {
    ll x = 0,f = 1;char c = getchar();
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - '0';c = getchar();
    }
    return x * f;
}
int phi(int x) {
    int ret = 1;
    for(int i = 2;i * i <= x;++i) {
        if(x % i == 0) {
            ret *= i - 1;
            x /= i;
        }
        while(x % i == 0) {
            ret *= i;
            x /= i;
        }
    }
    if(x != 1) ret *= x - 1;
    return ret;
}
ll mod,a;
ll qm(ll x,ll y) {
    ll ret = 1;
    for(;y;y >>= 1,x = x * x % mod)
    if(y & 1) ret = ret * x % mod;
    return ret;
}
int main() {
    a = read(),mod = read();
    cout<<qm(a,phi(mod) - 1);
    return 0;
}

欧拉降幂

扩展欧几里得

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
using namespace std;
typedef long long ll;

ll read() {
    ll x = 0,f = 1;char c = getchar();
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - '0';c = getchar();
    }
    return x * f;
}
ll exgcd(ll a,ll b,ll &x,ll &y) {
    if(!b) {
        x = 1,y = 0;
        return a;
    }
    ll ret = exgcd(b,a % b,y,x);
    y -= a / b * x;
    return ret;
}
int main() {
    ll x = read(),y = read(),m = read(),n = read(),L = read();
    ll A = L,B = n - m,C = x - y;
    if(B < 0) B = -B,C = -C;
    ll X,Y;
    int k = exgcd(A,B,X,Y);
    if(C % k != 0) return puts("Impossible"),0;
    int t = L / k;
    cout<<(C / k * Y % t + t) % t;
    return 0;
}

卢卡斯

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
using namespace std;
typedef long long ll;
const int N = 200100;
ll read() {
    ll x = 0,f = 1;char c = getchar();
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - '0';c = getchar();
    }
    return x * f;
}
int jc[N],inv[N],mod;
ll qm(ll x,ll y) {
    ll ret = 1;
    for(;y;y >>= 1,x = x * x % mod)
    if(y & 1) ret = ret * x % mod;
    return ret;
}
ll C(ll n,ll m) {
    
    if(n < m) return 0;
    
    if(n < mod && m < mod) 
    return 1ll * jc[n] * inv[m] % mod * inv[n - m] % mod;
    
    return C(n / mod,m / mod) * C(n % mod,m % mod) % mod;
    
}
int main() {
    int T = read();
    while(T--) {
        int n = read(),m = read();mod = read();
        n += m;
        jc[0] = 1;
        
        for(int i = 1;i < mod;++i) 
        jc[i] = 1ll * jc[i - 1] * i % mod;
        
        inv[mod - 1] = qm(jc[mod - 1],mod - 2);
        
        for(int i = mod - 2;i >= 0;--i) inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
        cout<<C(n,m)<<endl;
        
    }
    return 0;
}

线性求逆元

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
using namespace std;
typedef long long ll;

ll read() {
    ll x = 0,f = 1;char c = getchar();
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - '0';c = getchar();
    }
    return x * f;
}
int inv[3000001];
int main() {
    int n = read(),mod = read();
    
    inv[1] = 1;
    puts("1");
    for(int i = 2;i <= n;++i) {
        inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;
        printf("%d
",inv[i]);
    }
     
    return 0;
}

数据结构

st表

/*
* @Author: wxyww
* @Date: 2019-11-16 16:48:36
* @Last Modified time: 2019-11-16 16:54:26
*/
#include<cstdio>
#include<iostream>
#include<cstdlib>
#include<cmath>
#include<ctime>
#include<bitset>
#include<cstring>
#include<algorithm>
#include<string>
#include<queue>
#include<vector>
using namespace std;
typedef long long ll;
const int N = 1000100,logN = 20;
ll read() {
    ll x=0,f=1;char c=getchar();
    while(c<'0'||c>'9') {
        if(c=='-') f=-1;
        c=getchar();
    }
    while(c>='0'&&c<='9') {
        x=x*10+c-'0';
        c=getchar();
    }
    return x*f;
}
int a[N],st[N][logN + 1],cf[N],lg[N];
int query(int l,int r) {
    int len = r - l + 1;
    return max(st[l][lg[len]],st[r - cf[lg[len]] + 1][lg[len]]); 
}
int main() {
    int n = read(),m = read();
    for(int i = 2;i <= n;++i) lg[i] = lg[i >> 1] + 1;
    cf[0] = 1;
    for(int i = 1;i <= logN;++i) cf[i] = cf[i - 1] << 1;

    for(int i = 1;i <= n;++i) st[i][0] = read();

    for(int j = 1;j <= lg[n];++j) {
        for(int i = 1;i <= n;++i) {
            st[i][j] = max(st[i][j - 1],st[i + cf[j - 1]][j - 1]);
        }
    }
    while(m--) {
        int l = read(),r = read();
        printf("%d
",query(l,r));
    }
    return 0;
}

lca

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
using namespace std;
typedef long long ll;
const int N = 500010,logN = 22;
ll read() {
    ll x = 0,f = 1;char c = getchar();
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - '0';c = getchar();
    }
    return x * f;
}
struct node {
    int v,nxt;
}e[N << 1];
int head[N],ejs;
void add(int u,int v) {
    e[++ejs].v = v;e[ejs].nxt = head[u];head[u] = ejs; 
}
int n,m,S,lca[N][logN + 1],dep[N];
void dfs(int u,int fa) {
    dep[u] = dep[fa] + 1;
    for(int i = 1;i <= logN;++i)
        lca[u][i] = lca[lca[u][i - 1]][i - 1];
    for(int i = head[u];i;i = e[i].nxt) {
        int v = e[i].v;
        if(v == fa) continue;
        lca[v][0] = u;
        dfs(v,u);
    }
}

int LCA(int x,int y) {
    if(dep[x] < dep[y]) swap(x,y);
    for(int i = logN;i >= 0;--i)
        if(dep[lca[x][i]] >= dep[y]) x = lca[x][i];
    for(int i = logN;i >= 0;--i)
        if(lca[x][i] != lca[y][i]) x = lca[x][i],y = lca[y][i];
    if(x != y) return lca[x][0];
    return x;
}
int main() {
    n = read(),m = read(),S = read();
    for(int i = 1;i < n;++i) {
        int u = read(),v = read();
        add(u,v);add(v,u);
    }
    
    dfs(S,0);
    
    while(m--) {
        int x = read(),y = read();
        printf("%d
",LCA(x,y));
    }
    
    return 0;
}

树剖

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
using namespace std;
typedef long long ll;
const int N = 200100;
ll read() {
    ll x = 0,f = 1;char c = getchar();
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - '0';c = getchar();
    }
    return x * f;
}

struct node {
    int v,nxt;
}e[N << 1];
int head[N],ejs;
void add(int u,int v) {
    e[++ejs].v = v;e[ejs].nxt = head[u];head[u] = ejs;
}
int son[N],dep[N],top[N],fa[N],siz[N],id[N],w[N],ww[N];
int tree[N << 2],lazy[N << 2],mod;
void build(int rt,int l,int r) {
    if(l == r) {
        tree[rt] = w[l];return;
    }
    int mid = (l + r) >> 1;
    build(rt << 1,l,mid);
    build(rt << 1 | 1,mid + 1,r);
    tree[rt] = (tree[rt << 1] + tree[rt << 1 | 1]) % mod;
}
void pushdown(int rt,int ln,int rn) {
    if(lazy[rt]) {
        int k = lazy[rt];
        tree[rt << 1] += 1ll * k * ln % mod;tree[rt << 1] %= mod;
        tree[rt << 1 | 1] += 1ll * k * rn % mod;tree[rt << 1 | 1] %= mod;
        lazy[rt << 1] += k;lazy[rt << 1] %= mod;
        lazy[rt << 1 | 1] += k;lazy[rt << 1 | 1] %= mod;
        lazy[rt] = 0;
    }
}
void update(int rt,int l,int r,int L,int R,int c) {
    if(L <= l && R >= r) {
        lazy[rt] += c;
        tree[rt] += 1ll * c * (r - l + 1) % mod;
        return;
    }
    int mid = (l + r) >> 1;
    pushdown(rt,mid - l + 1,r - mid);
    if(L <= mid) update(rt << 1,l,mid,L,R,c);
    if(R > mid) update(rt << 1 | 1,mid + 1,r,L,R,c);
    tree[rt] = (tree[rt << 1] + tree[rt << 1 | 1]) % mod;
}
int query(int rt,int l,int r,int L,int R) {
    if(L <= l && R >= r) return tree[rt];
    int mid = (l + r) >> 1;
    pushdown(rt,mid - l + 1,r - mid);
    ll ret = 0;
    if(L <= mid) ret += query(rt << 1,l,mid,L,R),ret %= mod;
    if(R > mid) ret += query(rt << 1 | 1,mid + 1,r,L,R),ret %= mod;
    return ret;
}


void dfs1(int u,int father) {
    dep[u] = dep[father] + 1;
    siz[u] = 1;
    fa[u] = father;
    for(int i = head[u];i;i = e[i].nxt) {
        int v = e[i].v;
        if(v == father) continue;
        dfs1(v,u);
        siz[u] += siz[v];
        if(siz[v] > siz[son[u]]) son[u] = v;
    }
}
int tot;
void dfs2(int u,int father,int ttop) {
    id[u] = ++tot;
    w[id[u]] = ww[u];
    top[u] = ttop;
    if(!son[u]) return;
    dfs2(son[u],u,ttop);
    for(int i = head[u];i;i = e[i].nxt) {
        int v = e[i].v;
        if(v == father || v == son[u]) continue;
        dfs2(v,u,v);
    }
}
int n,m,root;
void LCA(int x,int y,int c) {
    int fx = top[x],fy = top[y];
    while(fx != fy) {
        if(dep[fx] > dep[fy]) {
            update(1,1,n,id[fx],id[x],c);
            x = fa[fx]; fx = top[x];
        }
        else {
            update(1,1,n,id[fy],id[y],c);
            y = fa[fy]; fy = top[y];
        }
    }
    if(dep[x] > dep[y]) swap(x,y);
    update(1,1,n,id[x],id[y],c);
}
int LCA(int x,int y) {
    int fx = top[x],fy = top[y];ll ret = 0;
    while(fx != fy) {
        if(dep[fx] > dep[fy]) {
            ret += query(1,1,n,id[fx],id[x]);
            ret %= mod;
            x = fa[fx];
            fx = top[x];
        }
        else {
            ret += query(1,1,n,id[fy],id[y]);
            ret %= mod;
            y = fa[fy];
            fy = top[y];
        }
    }
    if(dep[x] > dep[y]) swap(x,y);
    ret += query(1,1,n,id[x],id[y]);
    return ret % mod;
}
int main() {
    n = read(),m = read(),root = read();mod = read();
    for(int i = 1;i <= n;++i) ww[i] = read();
    for(int i = 1;i < n;++i) {
        int u = read(),v = read();
        add(u,v);add(v,u);
    }
    dfs1(root,0);
    dfs2(root,0,root);
    build(1,1,n);
    while(m--) {
        int opt = read();
        if(opt == 1) {
            int x = read(),y = read(),z = read();
            LCA(x,y,z);
        }
        else if(opt == 2) {
            int x = read(),y = read();
            printf("%d
",LCA(x,y));
        }
        else if(opt == 3) {
            int x = read(),y = read();
            update(1,1,n,id[x],id[x] + siz[x] - 1,y);
        }
        else {
            int x = read();
            printf("%d
",query(1,1,n,id[x],id[x] + siz[x] - 1));
        }
    }    
    return 0;
}

set

线段树

/*
* @Author: wxyww
* @Date: 2019-11-15 15:25:47
* @Last Modified time: 2019-11-15 15:49:54
*/
#include<cstdio>
#include<iostream>
#include<cstdlib>
#include<cmath>
#include<ctime>
#include<bitset>
#include<cstring>
#include<algorithm>
#include<string>
#include<queue>
#include<vector>
using namespace std;
typedef long long ll;
const int N = 200100;
ll read() {
    ll x=0,f=1;char c=getchar();
    while(c<'0'||c>'9') {
        if(c=='-') f=-1;
        c=getchar();
    }
    while(c>='0'&&c<='9') {
        x=x*10+c-'0';
        c=getchar();
    }
    return x*f;
}
ll a[N],tree[N << 1],mod,lazy1[N << 2],lazy2[N << 2];//lazy1存乘，lazy2存加

void pushup(int rt) {
    tree[rt] = (tree[rt << 1] + tree[rt << 1 | 1]) % mod;
}

void pushdown(int rt,int ln,int rn) {
    if(lazy1[rt] != 1) {
        lazy2[rt << 1] = lazy2[rt << 1] * lazy1[rt] % mod;
        lazy2[rt << 1 | 1] = lazy2[rt << 1 | 1] * lazy1[rt] % mod;

        lazy1[rt << 1] = lazy1[rt << 1] * lazy1[rt] % mod;
        lazy1[rt << 1 | 1] = lazy1[rt << 1 | 1] * lazy1[rt] % mod;

        tree[rt << 1] = tree[rt << 1] * lazy1[rt] % mod;
        tree[rt << 1 | 1] = tree[rt << 1 | 1] * lazy1[rt] % mod;
        lazy1[rt] = 1;
    }
    if(lazy2[rt]) {
        lazy2[rt << 1] += lazy2[rt];lazy2[rt << 1] % mod;
        lazy2[rt << 1 | 1] += lazy2[rt];lazy2[rt << 1 | 1] %= mod;
        tree[rt << 1] += lazy2[rt] * ln % mod;tree[rt << 1] %= mod;
        tree[rt << 1 | 1] += lazy2[rt] * rn % mod;tree[rt << 1 | 1] %= mod;
        lazy2[rt] = 0;
    }
}

void build(int rt,int l,int r) {
    lazy1[rt] = 1;
    if(l == r) {
        tree[rt] = a[l];return;
    }
    int mid = (l + r) >> 1;
    build(rt << 1,l,mid);
    build(rt << 1 | 1,mid + 1,r);
    pushup(rt);
}

void update1(int rt,int l,int r,int L,int R,int c) {
    if(L <= l && R >= r) {
        tree[rt] = tree[rt] * c % mod;
        lazy1[rt] = lazy1[rt] * c % mod;
        lazy2[rt] = lazy2[rt] * c % mod;
        return;
    }
    int mid = (l + r) >> 1;
    pushdown(rt,mid - l + 1,r - mid);
    if(L <= mid) update1(rt << 1,l,mid,L,R,c);
    if(R > mid) update1(rt << 1 | 1,mid + 1,r,L,R,c);
    pushup(rt);
}
void update2(int rt,int l,int r,int L,int R,int c) {
    if(L <= l && R >= r) {
        tree[rt] += 1ll * (r - l + 1) * c % mod;tree[rt] %= mod;
        lazy2[rt] += c;lazy2[rt] %= mod;
        return;
    }
    int mid = (l + r) >> 1;
    pushdown(rt,mid - l + 1,r - mid);
    if(L <= mid) update2(rt << 1,l,mid,L,R,c);
    if(R > mid) update2(rt << 1 | 1,mid + 1,r,L,R,c);
    pushup(rt);
}
int query(int rt,int l,int r,int L,int R) {
    if(L <= l && R >= r) return tree[rt];
    int mid = (l + r) >> 1;
    pushdown(rt,mid - l + 1,r - mid);
    int ret = 0;
    if(L <= mid) ret += query(rt << 1,l,mid,L,R),ret %= mod;
    if(R > mid) ret += query(rt << 1 | 1,mid + 1,r,L,R),ret %= mod;
    return ret;
}
int main() {
    int n = read(),m = read();mod = read();
    for(int i = 1;i <= n;++i) a[i] = read();
    build(1,1,n);
    while(m--) {
        int opt = read();
        if(opt == 1) {
            int x = read(),y = read(),c = read();
            update1(1,1,n,x,y,c);
        }
        else if(opt == 2) {
            int x = read(),y = read(),c = read();
            update2(1,1,n,x,y,c);
        }
        else {
            int x = read(),y = read();
            printf("%d
",query(1,1,n,x,y));
        }
    }
    return 0;
}

其他

bat批量重命名文件

数据生成器

bat对拍

lemon下的SPJ