【算法笔记】莫队算法（基础莫队，带修莫队，回滚莫队，树上莫队，二次离线莫队）

2020-11-23 22:38:47 189 收藏 3
分类专栏： 【ACM模板】 数据结构 - 莫队
最后发布:2020-11-23 22:38:47首次发布:2020-11-23 22:38:47
版权声明：本文为博主原创文章，遵循<a href="http://creativecommons.org/licenses/by-sa/4.0/" target="_blank" rel="noopener"> CC 4.0 BY-SA </a>版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45697774/article/details/110006549
版权

整理的算法模板合集： ACM模板

目录

来这里学习莫队以及神奇的证明：莫队算法 --算法竞赛专题解析（26）

我们首先考虑双指针的暴力法，发现很容易就会被卡成 O ( n m ) O(nm) O(nm)，这时候我们的莫队出现了，莫队说，我可以像变魔术一样，把 O ( n m ) O(nm) O(nm)的算法通过一个神奇的排序方式，使得我们最坏的情况下，时间复杂度也会非常优秀： O ( n n ) O(n\sqrt{n}) O(nn ​)。

莫队算法是一个离线的算法，我们先将所有的询问全部存下来，然后排序。我们的每一个询问都是一个左右区间， ( l , r ) (l ,r) (l,r)

我们的排序方法为双关键字排序，我们将每个询问的左端点 l l l 分块。
第一关键字为左端点分块的编号从小到大，第二关键字为右端点的下标从小到大。
在这里插入图片描述

编码时，还可以对排序做一个小优化：奇偶性排序，让奇数块和偶数块的排序相反。例如左端点L都在奇数块，则对R从大到小排序；若L在偶数块，则对R从小到大排序（反过来也可以：奇数块从小到大，偶数块从大到小）。

1. 基础莫队

AcWing 2492. HH的项链
在这里插入图片描述
在这里插入图片描述

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <iostream>
#include <cmath>

using namespace std;
const int N = 50007, M = 200007, S = 1000007;

int n, m;
int w[N];
int block;
int cnt[S];
int ans[M];

struct Query{
    int id, l, r;
}q[M];

int get_block(int x){
    return x / block;//这里是从0开始
}

bool cmp(const Query& x, const Query& y){
    int a = get_block(x.l);
    int b = get_block(y.l);
    if(a != b)return a < b;
    return x.r < y.r;
}

void add(int x, int &res){
    if(cnt[x] == 0)res ++ ;
    cnt[x] ++ ;
}

void del(int x, int &res){
    cnt[x] -- ;
    if(cnt[x] == 0)res -- ;
}

int main()
{
    scanf("%d", &n);
    
    for(int i = 1; i <= n; ++ i) scanf("%d", &w[i]);
    
    scanf("%d", &m);
    block = sqrt((double)n * n / m);//1488 ms
    //block = sqrt(n);             //1700 ms
    
    for(int i = 0; i < m; ++ i){
        int l, r;
        scanf("%d%d", &l, &r);
        q[i] = {i, l, r};
    }
    sort(q, q + m, cmp);
    
    for(int k = 0, i = 0, j = 1, res = 0; k < m; ++ k){
        int id = q[k].id, l = q[k].l, r = q[k].r;
        while(i < r)add(w[ ++ i], res);
        while(i > r)del(w[i -- ], res);
        while(j < l)del(w[j ++ ], res);
        while(j > l)add(w[ -- j], res);//注意这里的细节，自己模拟一遍
        ans[id] = res;
    }
    
    for(int i = 0; i < m; ++ i)
        printf("%d\n", ans[i]);
    return 0;
}

玄学优化版，成功卡过了洛谷上的这道题

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <iostream>
#include <cmath>

using namespace std;
const int N = 1000007, M = 1000007, S = 1000007;

int n, m;
int w[N];
int block;
int cnt[S];
int ans[M];

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

inline void write(int res){
	if(res<0){
		putchar('-');
		res=-res;
	}
	if(res>9)
		write(res/10);
	putchar(res%10+'0');
}

struct Query{
    int id, l, r;
}q[M];

inline int get_block(int x){
    return x / 2000;//这里是从0开始
}

bool cmp(const Query& x, const Query& y){
    int a = get_block(x.l);
    int b = get_block(y.l);
    //int a = x.l / block, b = y.l / block;
    if(a != b)return a < b;
    if(a & 1)return x.r < y.r;
    return x.r > y.r;
}

inline void add(int x, int &res){
    if(cnt[x] == 0)res ++ ;
    cnt[x] ++ ;
}

inline void del(int x, int &res){
    cnt[x] -- ;
    if(cnt[x] == 0)res -- ;
}

int main()
{
    n = read();

    for(register int i = 1; i <= n; ++ i) w[i] = read();

    m = read();
    block = sqrt((double)n * n / m);//1488 ms
    //block = sqrt(n);             //1700 ms
    //block = 2000;
    for(register int i = 0; i < m; ++ i){
        int l = read(), r = read();
        q[i] = {i, l, r};
    }
    sort(q, q + m, cmp);

    for(register int k = 0, i = 0, j = 1, res = 0; k < m; ++ k){
        int id = q[k].id, l = q[k].l, r = q[k].r;
        while(i < r)add(w[ ++ i], res);
        while(i > r)del(w[i -- ], res);
        while(j < l)del(w[j ++ ], res);
        while(j > l)add(w[ -- j], res);//注意这里的细节，自己模拟一遍
        /*
        while(i < r)res += ++ cnt[w[ ++ i]] == 1;
        while(i > r)res -= -- cnt[w[i -- ]] == 0;
        while(j < l)res -= -- cnt[w[j ++ ]] == 0;
        while(j > l)res += ++ cnt[w[ -- j]] == 1;
*/
        ans[id] = res;
    }

    for(register int i = 0; i < m; ++ i)
        write(ans[i]), puts("");
    return 0;
}

2. 带修莫队

AcWing 2521. 数颜色
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
我发现直接把块的大小开成一个常数跑的最快…

//#pragma GCC optimize(2)
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <iostream>
#include <cmath>
using namespace std;

const int N = 1000007, M = 1000007, S = 1000007;

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

inline void write(int res){
	if(res<0){
		putchar('-');
		res=-res;
	}
	if(res>9)
		write(res/10);
	putchar(res%10+'0');
}

int n, m;
int block = 2589;//n ^ (2 / 3)
int w[N];
int cnt[S];
int ans[N];
int bi[N];
struct Query{
    int id, l, r, t;
}q[M];

struct Modify{
    int pos, col, lst;
}c[M];

bool cmp(const Query &a, const Query &b){
    int al = bi[a.l], ar = bi[a.r];
    int bl = bi[b.l], br = bi[b.r];
    if(al != bl)return a.l < b.l;
    if(ar != br)return a.r < b.r;
    return a.t < b.t;
}

void add(int x, int& res){
    if(cnt[x] == 0)res ++ ;
    cnt[x] ++ ;
}

void del(int x, int& res){
    cnt[x] -- ;
    if(cnt[x] == 0)res -- ;
}

int main()
{
    n = read(), m = read();

    for(register int i = 1; i <= n; ++ i) w[i] = read();

    int mq = 0, mc = 0;
    for(register int i = 1; i <= m; ++ i){
        char op[2];
        int l, r;
        scanf("%s", op);
        l = read(), r = read();
        if(op[0] == 'Q'){
            q[ ++ mq] = (Query){mq, l, r, mc};
        }
        else {
            c[ ++ mc] = (Modify){l, r};
        }
    }
    //这里block一定要加1，可能出现0的情况导致除0发生浮点错误
    //block=ceil(exp((log(n)+log(mc))/3));//分块大小
    //block = cbrt(n * mc);
    //block = pow(n * n, 1.0 / 3);
    //block = pow(n, 2.0 / 3);
    for(int i = 1; i <= n; ++ i){
        bi[i] = (i - 1) / block;
    }
    sort(q + 1, q + 1 + mq, cmp);

    for(register int k = 1, i = 0, j = 1, t = 0, res = 0; k <= mq; ++ k){
        int id = q[k].id, l = q[k].l, r = q[k].r, tim = q[k].t;
        //先处理x轴
        /*
        while(i < r)add(w[ ++ i], res);
        while(i > r)del(w[i -- ], res);
        while(j < l)del(w[j ++ ], res);
        while(j > l)add(w[ -- j], res);
        */

        while(i < r)res += ++ cnt[w[ ++ i]] == 1;
        while(i > r)res -= -- cnt[w[i -- ]] == 0;
        while(j < l)res -= -- cnt[w[j ++ ]] == 0;
        while(j > l)res += ++ cnt[w[ -- j]] == 1;
        //再处理y轴
        while(t < tim){
            t ++ ;
            if(c[t].pos >= j && c[t].pos <= i){
                del(w[c[t].pos], res);
                add(c[t].col, res);
                //res -= !--cnt[w[c[t].pos]] - !cnt[c[t].col]++;
            }
            swap(w[c[t].pos], c[t].col);
        }
        while(t > tim){
            if(c[t].pos >= j && c[t].pos <= i){
                del(w[c[t].pos], res);
                add(c[t].col, res);
                //res -= !--cnt[w[c[t].pos]] - !cnt[c[t].col]++;
            }
            swap(w[c[t].pos], c[t].col);
            t -- ;
        }
        ans[id] = res;
    }

    for(register int i = 1; i <= mq; ++ i)
        write(ans[i]), puts("");
    return 0;
}

3. 回滚莫队

AcWing 2523. 历史研究

在这里插入图片描述
在这里插入图片描述
左指针j，右指针i。

对于块外的情况，左端点一定是在块内的，如果有的询问的右端点是在块外，我们把i右定在right，j左端点定在right+1，我们i右端点一定只会一直向右走，因为我们是按照右端点升序排序的，块外的时候j往左走到实际位置左端点，只有增加操作，维护答案。

还是要删除的，但是删除的时候只需要维护cnt即可，res已经更新过了。

注意res只是当前块的右端点到中间的res，但是我们的答案是整个区间，所以我们备份一下中间到右端的res，往左走更新res，更新答案以后res回档为备份，相当于一个 O ( 1 ) O(1) O(1)删除操作，我们每次更新所有左端点在一个块的好多个询问区间，所以每次cnt需要每次清零。

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
typedef long long ll;
const int N = 200007;

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

int n, m;
int bi[N];
int v[N];
int block;
ll ans[N];

struct Query
{
    int id, l, r;
}q[N];

bool cmp(const Query& x, const Query& y) {
    int a = bi[x.l], b = bi[y.l];
    if(a != b) return a < b;
    return x.r < y.r;
}

vector<int>nums;
int cnt[N];

int get_block(int x)
{
    return x / block;
}

void add(int x, ll& res)
{
    cnt[x] ++ ;
    res = max(res, (ll)cnt[x] * nums[x]);
}

int main()
{
    n = read(), m = read();
    block = sqrt(n);
    for(int i = 1 ; i <= n; ++ i) {
        v[i] = read();
        nums.push_back(v[i]);
        bi[i] = i / block;
    }
    sort(nums.begin(), nums.end());
    for(int i = 1; i <= n; ++ i) {
        v[i] = lower_bound(nums.begin(), nums.end(), v[i]) - nums.begin();
    }
    
    for(int i = 0; i < m; ++ i) {
        int l = read(), r = read();
        q[i] = {i, l, r};
    }
    sort(q, q + m, cmp);
    
    for(int x = 0; x < m;) {
        //先找同一个块里的左右询问区间左x右y;
        int y = x;
        while(y < m && bi[q[y].l] == bi[q[x].l]) y ++ ;
        int right = bi[q[x].l] * block + block - 1; //当前块的右界
        while(x < y && q[x].r <= right) {
            ll res = 0;
            int id = q[x].id, l = q[x].l, r = q[x].r;
            for(int k = l; k <= r; ++ k)//O(sqrt(n))
                add(v[k], res);
            ans[id] = res;
            for(int k = l; k <= r; ++ k)
                cnt[v[k]] -- ;
            x ++ ;
        }
        ll res = 0;
        int i = right, j = i + 1;//j是左指针i是右指针
        while(x < y){
            int id = q[x].id, l = q[x].l, r = q[x].r;
            while(i < r) add(v[ ++ i], res);
            ll backup = res;//res只是当前块的右端点到右指针的答案，所以要备份
            while(j > l) add(v[ -- j], res);//这个询问区间的左端点一定在左块内部，我们就是这么排序的
            ans[id] = res;
            while(j < right + 1) cnt[v[j ++ ]] -- ;
            res = backup;
            x ++ ;
        }
        memset(cnt, 0, sizeof cnt);
    }
    
    for(int i = 0; i < m; ++ i)
        printf("%lld\n", ans[i]);
    return 0;
}

4. 树上莫队

AcWing 2534. 树上计数2

在这里插入图片描述

在这里插入图片描述

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <iostream>
#include <vector>
#include <cmath>
//如果顺序有关系，涉及修改，需要用树链剖分
using namespace std;
//不涉及修改，没有顺序关系的可以用欧拉序列
const int N = 500007, M = 500007, INF = 0x3f3f3f3f;
int n, m;
int cnt[N], vis[N];
vector<int>v;
int f[N][20], dep[N];
int head[N], ver[M], nex[M], tot;
int w[M];
int seq[N], top, first[N], last[N];
int block;
int ans[N];

void add_edge(int x, int y)
{
    ver[tot] = y;
    nex[tot] = head[x];
    head[x] = tot ++ ;
}

struct Query{
    int id, l, r, p;
}q[N];

int get_block(int x)
{
    return x / block;
}

bool cmp(Query &a, Query &b)
{
    int x = get_block(a.l);
    int y = get_block(b.l);
    if(x != y)return x < y;
    return a.r < b.r;
}

void dfs(int x, int fa){
    seq[ ++ top] = x;
    first[x] = top;
    for(int i = head[x]; ~i; i = nex[i]){
        int y = ver[i];
        if(y == fa) continue;
        dfs(y, x);
    }
    seq[ ++ top] = x;
    last[x] = top;
}

int que[N];

void bfs()
{
    memset(dep, 0x3f, sizeof dep);
    int hh = 0, tt = 0;
    que[0] = 1;
    dep[0] = 0, dep[1] = 1;
    while(hh <= tt){
        int x = que[hh ++ ];
        if(hh == N) hh = 0;
        for(int i = head[x]; ~i; i = nex[i]){
            int y = ver[i];
            if(dep[y] > dep[x] + 1){
                dep[y] = dep[x] + 1;
                f[y][0] = x;
                for(int k = 1; k <= 15; ++ k){
                    f[y][k] = f[f[y][k - 1]][k - 1];
                }
                que[ ++ tt] = y;
                if(tt == N) tt = 0;
            }
        }
    }
}

int lca(int x, int y)
{
    if(dep[x] < dep[y]) swap(x, y);
    for(int k = 15; k >= 0; -- k){
        if(dep[f[x][k]] >= dep[y]){
            x = f[x][k];
        }
    }
    if(x == y) return x;
    for(int k = 15; k >= 0; -- k){
        if(f[x][k] != f[y][k]){
            x = f[x][k];
            y = f[y][k];
        }
    }
    return f[x][0];
}

void add(int x, int &res)
{
    //!欧拉序列中出现两次就不是路径上的点了!要删掉
    //要删掉的点一定是只出现一次的，添加的时候add一次，删除的时候add一次，两次即为删除
    vis[x] ^= 1;//需要的是点的编号
    if(vis[x] == 0){
        cnt[w[x]] -- ;//需要的是点的权值（离散化过了）
        if(cnt[w[x]] == 0) res -- ;
    }
    else {
        cnt[w[x]] ++ ;
        if(cnt[w[x]] == 1) res ++ ;
    }
}

int main()
{
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; ++ i){
        scanf("%d", &w[i]);
        v.push_back(w[i]);
    }
    sort(v.begin(), v.end());
    v.erase(unique(v.begin(), v.end()), v.end());
    for(int i = 1; i <= n; ++ i){
        w[i] = lower_bound(v.begin(), v.end(), w[i]) - v.begin();
    }
    
    memset(head, -1, sizeof head);
    
    for(int i = 1; i <= n - 1; ++ i){
        int x, y;
        scanf("%d%d", &x, &y);
        add_edge(x, y);
        add_edge(y, x);
    }

    
    dfs(1, -1);//得到欧拉序列
    
    bfs();//lca预处理
    
    for(int i = 0; i < m; ++ i){
        int a, b;
        scanf("%d%d", &a, &b);
        //a,b是树上的点
        //first[a], first[b], last[a], last[b]才是数列上的点，也是我们莫队要处理的点
        if(first[a] > first[b]) swap(a, b);
        int p = lca(a, b);
        if(a == p)
            q[i] = {i, first[a], first[b]};
        else q[i] = {i, last[a], first[b], p}; 
    }
    block = sqrt(top);//这里应该是欧拉序列里的点的个数
    sort(q, q + m, cmp);
    //右指针i左指针j, 右指针先冲左指针跟上
    //左指针在1，右指针在0，初始状态形成一个空集
    for(int k = 0, i = 0, j = 1, res = 0; k < m; ++ k){
        int l = q[k].l, r = q[k].r, id = q[k].id, p = q[k].p;
        //这里走的应该是欧拉序列里的点了
        while(i < r) add(seq[ ++ i], res);//add
        while(i > r) add(seq[i -- ], res);//del
        while(j < l) add(seq[j ++ ], res);//del
        while(j > l) add(seq[ -- j], res);//add
        if(p) add(p, res);
        ans[id] = res;
        if(p) add(p, res);//最后一定要删除p，因为它不属于 i 到 i 这一连续序列中
    }
    
    for(int i = 0; i < m; ++ i)
        printf("%d\n", ans[i]);
    return 0;
}

5. 二次离线莫队

AcWing 2535. 二次离线莫队

6. 在线莫队

大佬链接

已标记关键词 清除标记
【BZOJ2120】数颜色，带修莫队
xiaoyimi的博客
09-08 1769
翘文科课到机房来_(:зゝ∠)_
莫队算法入门 BZOJ 2038
fufck
04-01 924
目前的题型概括为三种：普通莫队，树形莫队以及带修莫队。下面介绍普通莫队算法：普通莫队算法是一种离线算法，不带修改 操作。其通过对询问操作的执行顺序进行更改，然后使用最暴力的方法，可以达到很好的复杂度。首先,如果要用莫队算法，则必须满足已知ans[l,r]可以得到ans[l,r+1]，ans[l,r-1],ans[l+1,r],ans[l-1,r]莫队算法的实现步骤为： 1、先对原序列进行分块。(s...
表情包
插入表情
还能输入1000个字符 “速评一下”
莫队+带修莫队模板与总结
weixin_30900589的博客
05-05 43
以下总结参考了许多大佬们的博客，开篇先（大佬）% 莫队的入门题目主要为莫队和带修莫队在，这里就先在这里总结一下这两类题目的一些属性。 我认为莫队本质是一种比较优化的暴力查找法。在通过分块操作后把复杂度降低。这个降低的复杂度的大小主要和你分块的方法有着巨大的关系。 普通的莫队，n个元素m个区间询问，他的最佳分块大小为 n/√m ，如果默认n==m的话 复杂度会降到 O(n*√...
莫队和带修莫队 学习笔记
forever_shi的博客
07-24 388
哎，很纠结，我刚学这个东西，感觉好像本身自己理解得就不深刻，所以好像不知道该怎么写这个学习笔记了，估计是我思路最凌乱，语言最没逻辑的一篇学习笔记吧。（如果看到这儿觉得作者会坑就关掉吧。。） 好，我来尝试讲明白我可能明白的莫队知识。 莫队，通常是用来解决一些区间询问的问题，是一种离线算法。它适用于在知道区间[l,r][l,r][l,r]的答案后能在O(1)O(1)O(1)或者O(logn)O(l...
JZOJ4594 Dynamic Len 带修莫对
YxuanwKeith的博客
07-10 895
莫对的升级，可带修改操作的莫对算法，带修莫队
树上莫队算法
RBS的专栏
01-05 3191
江湖传闻，莫队算法能够解决一切区间查询问题。这样说来，莫队算法也能够解决一切树上路径查询问题，将树上操作转化为DFS序列上的区间操作即可。当然考虑到，树上路径在DFS序列中的性质，还要会求LCALCA。考虑上图中的树，其DFS序为其任意点对aa、bb之间的路径，具有如下性质，令lcalca为aa、bb的最近公共祖先： 若lcalca是aa、bb之一，则aa、bb之间的InIn时刻的区间或者OutOu
树上莫队
Destiny
03-14 468
树上莫队 引入 树上莫队看名字就知道，其实是把莫队搬到了树上。一般来说，这种问题有几个特征： 询问可以离线 答案并不好用树形DP或者数据结构维护，往往只能暴力跑到所有的点求。 我们拿一道例题：SP10707 COT2 这样的话，我们很容易就想到需要用莫队。可是莫队算法是基于一个序列的，我们怎么在树上跑莫队呢？ 把树整成一个序列不就好了。一般来说，有dfs序和欧拉序两种情况。 什...
莫队，带修莫队（总结+例题）
不二君
07-28 375
学习了莫队，感觉这个算法是一个很玄学的的算法，分块的大小和排序方式就能决定这个算法的效率，现在就对莫队，和带修莫队做一个简单的总结。 适用环境： 莫队算法使用分块的思想，可以解决一类离线区间询问问题，在使用莫队算法的时候就需要将区间询问离线（在线也可以，但是那样复杂度很高，就没有必要使用这个算法了）。 算法核心： 莫队算法离线首先是按左端点分块，然后在同一个块当中区间右端点要递增（...
[学习笔记]树上莫队
weixin_34220963的博客
03-24 43
远古博客：莫队算法——暴力出奇迹 https://blog.csdn.net/u012061345/article/details/54093879 树上莫队也就一句话： 把树上路径用欧拉序（入栈出栈序）变成区间，区间莫队即可 思想就是利用遍历构造出路径，入栈出栈相互抵消处理多余的点。 多了细节和讨论： 1.某个点存在一次贡献为1，存在两次贡献为0， 2.莫队的l，r要通过是否...
带修莫队算法
立志变成java巨头
08-15 238
#include&lt;stdio.h&gt; #include&lt;algorithm&gt; #include&lt;math.h&gt; #define go(i,a,b) for(int i=a;i&lt;=b;i++) using namespace std;const int N=10003; struct Query{int l,r,Tim,ID;}q[N]; struct Ch...
ACM信息学竞赛算法总结
正月看雪花的博客
02-02 2302
基础知识 位运算 递推与递归 前缀与差分 二分 排序 倍增 贪心 尺取法 数据结构 栈与队列 ： 单调栈 单调队列 双端队列 Hash: 字符串Hash 与Hash表 字符串处理： KMP算法，-- Rabin-Karp 算法 — 最小表示法 Tire（字典树） AC自动机 二叉堆 并查集 树状数组 线段树 分块 拓扑排序 点分治 离线分治算法 二叉查找树与二叉平衡树 可持久化数据结...
洛谷1903 带修莫队
甦萌的博客
06-06 74
/*洛谷1903 */ #include<cstdio> #include<algorithm> #include<iostream> #include<cmath> #include<cstdlib> #include<cstring> #include<string> #include<map&gt...
信息学(OI)竞赛—常用算法网站
Tham 在思索中前行！
04-15 3478
算法竞赛网站归纳： 以下大部分也都是表现形式为刷题的算法学习网站~ 求职面试看这个：结构之法 算法之道 推荐的讲解算法的网站、好博客： http://www.csie.ntnu.edu.tw/~u91029/讲解、代码格式、图表都很规范，覆盖广http://www.matrix67.com/informatics.hMatrix67 的一些算法讲
技术破局：AI程序员2021如何跳出舒适圈？！
CSDN学院
01-05 2万+
近日，IDC调研机构与浪潮联合发布《2020-2021 中国人工智能计算力发展评估报告 》。报告显示，预计2020 年中国AI市场规模将达到 62.7亿美元，2019~2024 年的年复合增长率为 30.4%，中国成为全球各个区域里面AI的投资发展最快的一个国家。 报告从AI算力产业发展趋势、市场规模、区域算力分布和行业AI算力保有程度等多个角度进行全面综合评估，旨在评估中国人工智能发展的现状，为推动产业AI化发展提供极具价值的参考依据和行动建议。 同时小编注意到据 BOSS直聘发布的《2020人才资.
莫队算法及应用
剑锋OI SharpSwordOI
11-08 370
该文章非原创，原创地址为：https://www.cnblogs.com/Paul-Guderian/p/6933799.html 莫队算法 ·目前的题型概括为三种：普通莫队，树形莫队以及带修莫队。 若谈及入门，那么BZOJ2038的美妙袜子一题堪称顶尖。 【例题一】袜子 传输门 ·述大意： 进行区间询问[l,r]，输出该区间内随机抽两次抽到相同颜色袜子的概率...
学习笔记——带修莫队
Fizzmy的博客
02-25 1286
简介 普通的莫队算法相信大家都熟悉，那么如果有些问题加上修改操作是否可以用莫队维护呢？下面就介绍一种O(n53)O(n53)O(n^{\frac 5 3})的带修莫队算法。 算法详解 只需要再维护一维表示操作的时间即可 然后我们按照左边界所在块为第一关键字、右边界所在块为第二关键字，操作时间为第三关键字排序 在算答案时再维护一个记录修改操作的指针即可 这样排序所产生的复杂度为： ...
BZOJ 3052 带修改的树上莫队
捡起回忆碎片
08-13 222
Candyland 有一座糖果公园，公园里不仅有美丽的风景、好玩的游乐项目，还有许多免费糖果的发放点，这引来了许多贪吃的小朋友来糖果公园玩。 糖果公园的结构十分奇特，它由 nn 个游览点构成，每个游览点都有一个糖果发放处，我们可以依次将游览点编号为 11 至 nn。有 n−1n−1 条双向道路连接着这些游览点，并且整个糖果公园都是连通的，即从任何一个游览点出发都可以通过这些道路到达公园里
SPOJ COT2 （树上莫队）
Chen.Jr的博客
05-22 69
传送门 题意： 给你一棵大小为nnn的树，每个点都有点权。现在有mmm个询问，每个询问给你一个两个数a,ba,ba,b，问你从点aaa到点bbb之间的路径中不同的点权的个数。 分析： 万恶的spoj并没有写点权的数据范围，害我我先re（此题需要离散化点权） 求解带有询问的不同数的个数这类题，一看就相当莫队 ，但是因为莫队只能够在一个序列上进行操作，因此我们考虑如何让树的树形结构转化为线性的结构。 ...
©️2020 CSDN 皮肤主题: 撸撸猫 设计师:设计师小姐姐 返回首页