NOIP前板子复习

再不复习板子我就是 [ 数据删除 ]

高精度

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int power = 4, base = 10000; //修改压位 
char a[233333], b[233333];
//初始化 
struct HP
{
    int len, p[2333];
    HP() { len = 0; memset(p, 0, sizeof(p)); }
    HP(char *s)
    {
        len = (strlen(s) + power - 1) / power;
        memset(p, 0, sizeof(p));
        for(int i = 0, t = 0, w; i < strlen(s); i++, w *= 10)
        {
            if(i % power == 0) t++, w = 1;
            p[t] += (s[i] - '0') * w;
        }
    }
    void rev() { reverse(p + 1, p + len + 1); }
    void add(int k) { if(len || k) p[++len] = k; }
    void print()
    {
        printf("%d", p[len]);
        for(int i = len - 1; i > 0; i--) printf("%0*d", power, p[i]);
        printf("
");
    }
} p, q, ans;
//重载运算符 
bool operator < (const HP &a, const HP &b)
{
    if(a.len < b.len) return true;
    if(a.len > b.len) return false;
    for(int i = a.len; i > 0; i--)
        if(a.p[i] != b.p[i]) return a.p[i] < b.p[i];
    return false;
}
HP operator + (const HP &a, const HP &b)
{
    HP c = a;
    c.len = max(a.len, b.len);
    for(int i = 1; i <= c.len; i++)
    {
        c.p[i] += b.p[i];
        c.p[i + 1] += c.p[i] / base;
        c.p[i] %= base;
    }
    if(c.p[c.len + 1]) c.len++;
    return c;
}
HP operator - (const HP &a, const HP &b)
{
    HP c = a;
    for(int i = 1; i <= c.len; i++)
    {
        c.p[i] -= b.p[i];
        if(c.p[i] < 0) c.p[i] += base, c.p[i + 1]--;
    }
    while(c.len && !c.p[c.len]) c.len--;
    return c;
}
HP operator * (const HP &a, const HP &b)
{
    HP c;
    c.len = a.len + b.len - 1;
    for(int i = 1; i <= a.len; i++)
        for(int j = 1; j <= b.len; j++)
        {
            c.p[i + j - 1] += a.p[i] * b.p[j];
            c.p[i + j] += c.p[i + j - 1] / base;
            c.p[i + j - 1] %= base;
        }
    while(c.p[c.len + 1]) c.len++;
    return c;
}
HP operator / (const HP &a, const HP &b)
{
    HP u, v;
    u.len = a.len;
    for(int i = a.len; i > 0; i--)
    {
        v.add(a.p[i]), v.rev();
        while(!(v < b)) v = v - b, u.p[i]++;
        v.rev();
    }
    while(u.len && !u.p[u.len]) u.len--;
    return u;
}
HP operator % (const HP &a, const HP &b) { return a - (a / b) * b; }
//以下是洛谷P1932主函数
int main()
{
    scanf("%s", &a), scanf("%s", &b);
    reverse(a, a + strlen(a)), reverse(b, b + strlen(b));
    p = HP(a), q = HP(b);
    ans = p + q; ans.print();
    if(p < q) { printf("-"); ans = q - p; }
    else ans = p - q;
    ans.print();
    ans = p * q; ans.print(); 
    ans = p / q; ans.print();
    ans = p % q; ans.print();
    return 0;
}

二分查找

//估计没有人写这么骚气的二分查找吧...
int l = left_limit, r = right_limit;
while(l + 1 < r)
{
    int mid = (l + r) >> 1;
    if(check(mid)) l = mid; //or r = mid;
    else r = mid; //or l = mid;
} 
st 1:
if(check(l)) ans = l;
else ans = r;
st 2:
if(check(r)) ans = r;
else ans = l;

tarjan 缩点

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;

const int N = 10006, M = 100006;
struct edge
{
    int nxt, to;
} e[M];
int n, m, ans = 0, cnt = 0, id = 0, top = 0, col = 0;
int a[N], head[N], low[N], dfn[N], c[N], st[N], s[M], t[M];
int val[N], f[N], du[N], vis[N];

inline int read()
{
    char c = getchar(); int x = 0, f = 1;
    while(c < '0' || c > '9') { if(c == '-') f = -1; c = getchar(); }
    while(c >= '0' && c <= '9') { x = x * 10 + c - 48; c = getchar(); }
    return x * f;
}

void add(int x, int y)
{
    e[++cnt] = (edge) { head[x], y };
    head[x] = cnt;
}

void dfs(int x) //板子部分
{
    dfn[x] = low[x] = ++id;
    st[++top] = x;
    vis[x] = 1;
    for(int i = head[x]; i; i = e[i].nxt)
    {
        int v = e[i].to;
        if(!dfn[v]) { dfs(v); low[x] = min(low[x], low[v]); }
        else if(vis[v]) low[x] = min(low[x], dfn[v]);
    }
    if(dfn[x] == low[x])
    {
        col++;
        st[top + 1] = -1;
        while(st[top + 1] != x)
        {
            c[st[top]] = col;
            vis[st[top--]] = 0;
        }
    }
}

void top_sort()
{
    int m = col;
    for(int i = 1; i <= col; i++) f[i] = val[i];
    queue <int> q;
    for(int i = 1; i <= col; i++) if(!du[i]) q.push(i);
    while(!q.empty())
    {
        int a = q.front();
        q.pop();
        for(int i = head[a]; i; i = e[i].nxt)
        {
            int v = e[i].to;
            du[v]--;
            f[v] = max(f[v], f[a] + val[v]);
            if(!du[v]) q.push(v);
        }
    }
    for(int i = 1; i <= col; i++) ans = max(ans, f[i]);
}

int main()
{
    n = read(), m = read();
    for(int i = 1; i <= n; i++) a[i] = read();
    for(int i = 1; i <= m; i++)
    {
        s[i] = read(), t[i] = read();
        add(s[i], t[i]);
    }
    memset(dfn, 0, sizeof(dfn));
    memset(vis, 0, sizeof(vis));
    for(int i = 1; i <= n; i++) if(!dfn[i]) dfs(i);
    memset(head, 0, sizeof(head));
    memset(val, 0, sizeof(val));
    cnt = 0;
    for(int i = 1; i <= m; i++)
        if(c[s[i]] != c[t[i]])
        {
            add(c[s[i]], c[t[i]]);
            du[c[t[i]]]++;
        }
    for(int i = 1; i <= n; i++) val[c[i]] += a[i];
    top_sort();
    printf("%d", ans);
    return 0;
}

二分图最大匹配

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 1010;
int n, m, E, ans = 0, e[N][N], girl[N], use[N];

bool find(int x)
{
    for(int j = 1; j <= m; j++)
        if(e[x][j] == 1 && use[j] == 0)
        {
            use[j] = 1;
            if(girl[j] == 0 || find(girl[j]))
            {
                girl[j] = x;
                return true;
            }
        }
    return false;
}

int main()
{
    scanf("%d%d%d", &n, &m, &E);
    memset(e, 0, sizeof(e));
    memset(girl, 0, sizeof(girl));
    for(int u, v, i = 1; i <= E; i++)
    {
        scanf("%d%d", &u, &v);
        if(u < 1 || u > n || v < 1 || v > m) continue;
        e[u][v] = 1;
    }
    for(int i = 1; i <= n; i++)
    {
        memset(use, 0, sizeof(use));
        ans += find(i);
    }
    printf("%d", ans);
    return 0;
}

状压 dp 枚举子集

for(int i = S; i; i = ((i - 1) & S))

Kruskal 最小生成树

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define LL long long
using namespace std;

const int N = 2333333;
LL n, m, ans = 0, f[N];
struct edge { LL u, v, w; } e[N];
bool cmp(edge a, edge b) { return a.w < b.w; }
LL find(LL x) { return x == f[x] ? x : f[x] = find(f[x]); }

int main()
{
    scanf("%lld%lld", &n, &m);
    for(int i = 1; i <= n; i++) f[i] = i;
    for(int i = 1; i <= m; i++)
        scanf("%lld%lld%lld", &e[i].u, &e[i].v, &e[i].w);
    sort(e + 1, e + m + 1, cmp);
    for(int i = 1; i <= m; i++)
        if(find(e[i].u) != find(e[i].v))
        {
            f[find(e[i].u)] = find(e[i].v);
            ans += e[i].w;
        }
    printf("%lld", ans);
    return 0;
} 

倍增求 LCA

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

const int N = 500010;
struct edge { int nxt, to; } e[N << 1];
int n, m, s, cnt = 0, u, v, f[N][23], deep[N], head[N];

void dfs(int x, int fa)
{
    deep[x] = deep[fa] + 1;
    f[x][0] = x, f[x][1] = fa;
    for(int i = 2; i <= 20; i++)
        f[x][i] = f[f[x][i - 1]][i - 1];
    for(int i = head[x]; i; i = e[i].nxt)
        if(e[i].to != fa) dfs(e[i].to, x);
}
int LCA(int x, int y)
{
    if(deep[x] < deep[y]) swap(x, y);
    for(int i = 20; i >= 0; i--)
        if(deep[f[x][i]] >= deep[y]) x = f[x][i];
    if(x == y) return x;
    for(int i = 20; i >= 0; i--)
        if(f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];
    return f[x][1];
}
void add(int x, int y) { e[++cnt] = (edge) { head[x], y }; head[x] = cnt; }

int main()
{
    scanf("%d%d%d", &n, &m, &s);
    memset(head, 0, sizeof(head));
    for(int i = 1; i < n; i++)
        scanf("%d%d", &u, &v), add(u, v), add(v, u);
    deep[0] = 0, dfs(s, 0);
    while(m--) scanf("%d%d", &u, &v), printf("%d
", LCA(u, v));
    return 0;
}

spfa

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#define LL long long
using namespace std;

const int N = 2333333;
struct edge { LL nxt, to, w; } e[N << 1];
LL n, m, s, cnt = 0, head[N], dis[N], vis[N];

void add(LL x, LL y, LL w)
{
    e[++cnt] = (edge) { head[x], y, w };
    head[x] = cnt;
}

void spfa()
{
    for(int i = 0; i <= n + 1; i++) dis[i] = (1 << 31) - 1;
    memset(vis, 0, sizeof(vis));
    queue <LL> q;
    q.push(s);
    vis[s] = 1, dis[s] = 0;
    while(!q.empty())
    {
        LL a = q.front();
        q.pop();
        vis[a] = 0;
        for(int i = head[a]; i; i = e[i].nxt)
        {
            LL v = e[i].to;
            if(dis[v] > dis[a] + e[i].w)
            {
                dis[v] = dis[a] + e[i].w;
                if(!vis[v]) { vis[v] = 1; q.push(v); }
            }
        }
    }
}

int main()
{
    scanf("%lld%lld%lld", &n, &m, &s);
    for(LL u, v, w, i = 1; i <= m; i++)
    {
        scanf("%lld%lld%lld", &u, &v, &w);
        add(u, v, w);
    }
    spfa();
    for(int i = 1; i <= n; i++) printf("%lld ", dis[i]);
    return 0;
}

dijkstra + 堆优化

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#define LL long long
using namespace std;

const int N = 2333333;
struct edge { LL nxt, to, w; } e[N];
LL n, m, s, cnt = 0, vis[N], dis[N], head[N];

void add(LL x, LL y, LL w)
{
    e[++cnt] = (edge) { head[x], y, w };
    head[x] = cnt;
}

struct node
{
    LL x, dis;
    friend bool operator < (node x, node y) { return x.dis > y.dis; }
};

void dijkstra()
{
    priority_queue <node> q;
    memset(dis, 0x7f7f7f, sizeof(dis));
    memset(vis, 0, sizeof(vis));
    dis[s] = 0, q.push((node) { s, 0 });
    while(!q.empty())
    {
        LL a = q.top().x;
        q.pop();
        if(vis[a]) continue;
        vis[a] = 1;
        for(int i = head[a]; i; i = e[i].nxt)
        {
            LL v = e[i].to;
            if(dis[v] > dis[a] + e[i].w)
            {
                dis[v] = dis[a] + e[i].w;
                if(!vis[v]) q.push((node) { v, dis[v] });
            }
        }
    }
}

int main()
{
    scanf("%lld%lld%lld", &n, &m, &s);
    memset(head, 0, sizeof(head));
    for(LL u, v, w, i = 1; i <= m; i++)
        scanf("%lld%lld%lld", &u, &v, &w), add(u, v, w);
    dijkstra();
    for(int i = 1; i <= n; i++) printf("%lld ", dis[i]);
    return 0;
}

并查集

用时 (mathrm{2 space min})

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 2333333;
int n, m, f[N];
int find(int x) { return x == f[x] ? x : f[x] = find(f[x]); }

int main()
{
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i++) f[i] = i;
    for(int x, y, z, i = 1; i <= m; i++)
    {
        scanf("%d%d%d", &z, &x, &y);
        if(z == 1) f[find(x)] = find(y);
        else
        {
            if(find(x) == find(y)) printf("Y
");
            else printf("N
");
        }
    }
    return 0;
}

树状数组

用时 (5 space mathrm{min})

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define LL long long
#define lowbit(x) (x & (-x))
using namespace std;

const int N = 2333333;
LL n, m, t[N];

void add(LL x, LL k) { while(x <= n) t[x] += k, x += lowbit(x); }
LL query(LL x)
{
    LL res = 0;
    while(x) res += t[x], x -= lowbit(x);
    return res;
}

int main()
{
    scanf("%lld%lld", &n, &m);
    for(LL a, i = 1; i <= n; i++) scanf("%d", &a), add(i, a);
    for(LL opt, x, y, i = 1; i <= m; i++)
    {
        scanf("%lld%lld%lld", &opt, &x, &y);
        if(opt == 1) add(x, y);
        else printf("%lld
", query(y) - query(x - 1));
    }
    return 0;
}

线段树 单点修改 + 区间查询

用时 (7 space mathrm{min})

#include <iostream>
#include <cstdio>
#include <cstring>
#define LL long long
using namespace std;

const LL N = 666666;
LL n, m, a[N], sum[N << 2];

struct Segment_Tree
{
    void push_up(LL x) { sum[x] = sum[x << 1] + sum[x << 1 | 1]; }
    void build(LL x, LL l, LL r)
    {
        if(l == r)
        {
            sum[x] = a[l];
            return ;
        }
        LL mid = (l + r) >> 1;
        build(x << 1, l, mid);
        build(x << 1 | 1, mid + 1, r);
        push_up(x);
    }
    void update(LL x, LL l, LL r, LL std, LL k)
    {
        if(r < std || l > std) return ;
        if(l == std && r == std)
        {
            sum[x] += k;
            return ;
        }
        LL mid = (l + r) >> 1;
        update(x << 1, l, mid, std, k);
        update(x << 1 | 1, mid + 1, r, std, k);
        push_up(x);
    }
    LL query(LL x, LL l, LL r, LL stdl, LL stdr)
    {
        if(l > stdr || r < stdl) return 0;
        if(stdl <= l && stdr >= r) return sum[x];
        LL mid = (l + r) >> 1;
        return query(x << 1, l, mid, stdl, stdr) + 
        query(x << 1 | 1, mid + 1, r, stdl, stdr);
        push_up(x);
    }
} tree;

int main()
{
    scanf("%lld%lld", &n, &m);
    for(int i = 1; i <= n; i++) scanf("%lld", &a[i]);
    tree.build(1, 1, n);
    for(LL opt, x, y, i = 1; i <= m; i++)
    {
        scanf("%lld%lld%lld", &opt, &x, &y);
        if(opt == 1) tree.update(1, 1, n, x, y);
        else printf("%lld
", tree.query(1, 1, n, x, y));
    }
    return 0;
}

线段树 区间修改 + 单点查询

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 2333333;
int n, m, a[N], tag[N], sum[N];

struct Segment_Tree
{
    void push_up(int x) { sum[x] = sum[x << 1] + sum[x << 1 | 1]; }
    void push_down(int x, int l, int r)
    {
        int mid = (l + r) >> 1;
        tag[x << 1] += tag[x];
        tag[x << 1 | 1] += tag[x];
        sum[x << 1] += tag[x] * (mid - l + 1);
        sum[x << 1 | 1] += tag[x] * (r - mid);
        tag[x] = 0;
    }
    void build(int x, int l, int r)
    {
        if(l == r)
        {
            sum[x] = a[l];
            return ;
        } 
        int mid = (l + r) >> 1;
        build(x << 1, l, mid);
        build(x << 1 | 1, mid + 1, r);
        push_up(x);
    }
    void update(int x, int l, int r, int stdl, int stdr, int k)
    {
        if(l > stdr || r < stdl) return ;
        if(stdl <= l && stdr >= r)
        {
            tag[x] += k, sum[x] += k * (r - l + 1);
            push_down(x, l, r);
            return ;
        }
        int mid = (l + r) >> 1;
        push_down(x, l, r);
        update(x << 1, l, mid, stdl, stdr, k);
        update(x << 1 | 1, mid + 1, r, stdl, stdr, k);
        push_up(x);
    }
    int query(int x, int l, int r, int std)
    {
        if(l > std || r < std) return 0;
        if(l == std && r == std) return sum[x];
        int mid = (l + r) >> 1;
        push_down(x, l, r);
        return query(x << 1, l, mid, std) + 
        query(x << 1 | 1, mid + 1, r, std);
        push_up(x);
    }
} tree;

int main()
{
    scanf("%d%d", &n, &m);
    memset(tag, 0, sizeof(tag));
    for(int i = 1; i <= n; i++) scanf("%d", &a[i]);
    tree.build(1, 1, n);
    for(int opt, x, y, k, i = 1; i <= m; i++)
    {
        scanf("%d", &opt);
        if(opt == 1)
        {
            scanf("%d%d%d", &x, &y, &k);
            tree.update(1, 1, n, x, y, k);
        }
        else
        {
            scanf("%d", &x);
            printf("%d
", tree.query(1, 1, n, x));
        }
    }
    return 0;
}

线段树 区间修改 + 区间查询

用时 (9 space mathrm{min})

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define LL long long
using namespace std;

const LL N = 100100;
LL n, m, a[N], sum[N << 2], tag[N << 2];
struct Segment_Tree
{
    void push_up(LL x) { sum[x] = sum[x << 1] + sum[x << 1 | 1]; }
    void push_down(LL x, LL l, LL r)
    {
        LL mid = (l + r) >> 1;
        if(!tag[x]) return ;
        tag[x << 1] += tag[x], tag[x << 1 | 1] += tag[x];
        sum[x << 1] += (mid - l + 1) * tag[x];
        sum[x << 1 | 1] += (r - mid) * tag[x];
        tag[x] = 0;
    }
    void build(LL x, LL l, LL r)
    {
        if(l == r)
        {
            sum[x] = a[l];
            return ;
        }
        LL mid = (l + r) >> 1;
        build(x << 1, l, mid);
        build(x << 1 | 1, mid + 1, r);
        push_down(x, l, r), push_up(x);
    }
    void update(LL x, LL l, LL r, LL stdl, LL stdr, LL k)
    {
        if(l > stdr || r < stdl) return ;
        if(stdl <= l && stdr >= r)
        {
            tag[x] += k;
            sum[x] += (r - l + 1) * k;
            push_down(x, l, r);
            return ;
        }
        LL mid = (l + r) >> 1;
        push_down(x, l, r);
        update(x << 1, l, mid, stdl, stdr, k);
        update(x << 1 | 1, mid + 1, r, stdl, stdr, k);
        push_down(x, l, r), push_up(x);
    }
    LL query(LL x, LL l, LL r, LL stdl, LL stdr)
    {
        if(l > stdr || r < stdl) return 0;
        if(stdl <= l && stdr >= r) return sum[x];
        LL mid = (l + r) >> 1;
        push_down(x, l, r);
        return query(x << 1, l, mid, stdl, stdr) + 
        query(x << 1 | 1, mid + 1, r, stdl, stdr);
        push_up(x);
    }
} tree;

int main()
{
    scanf("%lld%lld", &n, &m);
    for(LL i = 1; i <= n; i++) scanf("%lld", &a[i]);
    tree.build(1, 1, n);
    for(LL opt, x, y, k, i = 1; i <= m; i++)
    {
        scanf("%lld", &opt);
        if(opt == 1)
        {
            scanf("%lld%lld%lld", &x, &y, &k);
            tree.update(1, 1, n, x, y, k);
        }
        else
        {
            scanf("%lld%lld", &x, &y);
            printf("%lld
", tree.query(1, 1, n, x, y));
        }
    }
    return 0;
}

线段树 区间乘法 + 区间加法

用时 (114514 space mathrm{min})

#include <iostream>
#include <cstdio>
#include <cstring>
#define LL long long
using namespace std;

const int N = 2333333;
LL n, m, p, a[N], sum[N], mul[N], add[N];

struct Segment_Tree
{
    void push_up(LL x) { sum[x] = (sum[x << 1] + sum[x << 1 | 1] + p) % p; }
    void push_down(LL x, LL l, LL r)
    {
        LL mid = (l + r) >> 1;
        mul[x << 1] = (mul[x << 1] * mul[x] + p) % p;
        mul[x << 1 | 1] = (mul[x << 1 | 1] * mul[x] + p) % p;
        add[x << 1] = (add[x << 1] * mul[x] + add[x] + p) % p;
        add[x << 1 | 1] = (add[x << 1 | 1] * mul[x] + add[x] + p) % p;
        sum[x << 1] = (sum[x << 1] * mul[x] + add[x] * (mid - l + 1) + p) % p;
        sum[x << 1 | 1] = (sum[x << 1 | 1] * mul[x] + add[x] * (r - mid) + p) % p;
        mul[x] = 1, add[x] = 0;
    } 
    void build(LL x, LL l, LL r)
    {
        add[x] = 0, mul[x] = 1;
        if(l == r)
        {
            sum[x] = (a[l] + p) % p;
            return ;
        }
        LL mid = (l + r) >> 1;
        build(x << 1, l, mid);
        build(x << 1 | 1, mid + 1, r);
        push_up(x);
    }
    void update1(LL x, LL l, LL r, LL stdl, LL stdr, LL k)
    {
        if(l > stdr || r < stdl) return ;
        if(stdl <= l && stdr >= r)
        {
            mul[x] = (mul[x] * k + p) % p;
            add[x] = (add[x] * k + p) % p;
            sum[x] = (sum[x] * k + p) % p;
            push_down(x, l, r);
            return ;
        }
        LL mid = (l + r) >> 1;
        push_down(x, l, r);
        update1(x << 1, l, mid, stdl, stdr, k);
        update1(x << 1 | 1, mid + 1, r, stdl, stdr, k);
        push_down(x, l, r), push_up(x);
    }
    void update2(LL x, LL l, LL r, LL stdl, LL stdr, LL k)
    {
        if(l > stdr || r < stdl) return ;
        if(stdl <= l && stdr >= r)
        {
            add[x] = (add[x] + k + p) % p;
            sum[x] = (sum[x] + k * (r - l + 1) + p) % p;
            push_down(x, l, r);
            return ;
        }
        LL mid = (l + r) >> 1;
        push_down(x, l, r);
        update2(x << 1, l, mid, stdl, stdr, k);
        update2(x << 1 | 1, mid + 1, r, stdl, stdr, k);
        push_down(x, l, r), push_up(x);
    }
    LL query(LL x, LL l, LL r, LL stdl, LL stdr)
    {
        if(l > stdr || r < stdl) return 0;
        if(stdl <= l && stdr >= r) return (sum[x] + p) % p;
        LL mid = (l + r) >> 1;
        push_down(x, l, r);
        return (query(x << 1, l, mid, stdl, stdr) + 
        query(x << 1 | 1, mid + 1, r, stdl, stdr) + p) % p;
    }
} tree;

int main()
{
    scanf("%lld%lld%lld", &n, &m, &p);
    for(int i = 1; i <= n; i++) scanf("%lld", &a[i]);
    tree.build(1, 1, n);
    for(LL opt, x, y, k, i = 1; i <= m; i++)
    {
        scanf("%lld", &opt);
        if(opt == 1)
        {
            scanf("%lld%lld%lld", &x, &y, &k);
            tree.update1(1, 1, n, x, y, k);
        }
        else if(opt == 2)
        {
            scanf("%lld%lld%lld", &x, &y, &k);
            tree.update2(1, 1, n, x, y, k);
        }
        else
        {
            scanf("%lld%lld", &x, &y);
            printf("%lld
", tree.query(1, 1, n, x, y));
        }
    }
    return 0;
}

快速幂

int poww(int b, int p, int k)
{
    int ans = 1;
    while(p)
    {
        if(p & 1) ans = (ans * b) % k;
        b = (b * b) % k;
        p >>= 1;
    }
    return ans;
}

单调队列

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

const int N = 2333333;
long long n, k, head = 1, tail = 0, a[N], q[N];

int main()
{
    scanf("%lld%lld", &n, &k);
    memset(q, 0, sizeof(q));
    for(int i = 1; i <= n; i++) scanf("%lld", &a[i]);
    for(int i = 1; i <= n; i++)
    {
        while(head <= tail && q[head] <= i - k) head++;
        while(head <= tail && a[q[tail]] >= a[i]) tail--;
        q[++tail] = i;
        if(i >= k) printf("%lld ", a[q[head]]);
    }
    printf("
");
    head = 1, tail = 0, memset(q, 0, sizeof(q));
    for(int i = 1; i <= n; i++)
    {
        while(head <= tail && q[head] <= i - k) head++;
        while(head <= tail && a[q[tail]] <= a[i]) tail--;
        q[++tail] = i;
        if(i >= k) printf("%lld ", a[q[head]]);
    }
    return 0;
}

01 背包

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

const int N = 23333;
int t, n, w[N], v[N], f[N];

int main()
{
    scanf("%d%d", &t, &n);
    memset(f, 0, sizeof(f));
    for(int i = 1; i <= n; i++) scanf("%d%d", &w[i], &v[i]);
    for(int i = 1; i <= n; i++)
        for(int j = t; j >= w[i]; j--)
            f[j] = max(f[j], f[j - w[i]] + v[i]);
    printf("%d", f[t]);
    return 0;
}