莫队练习

最新推荐文章于 2024-03-31 14:08:11 发布
最新推荐文章于 2024-03-31 14:08:11 发布
阅读量113 收藏
点赞数
分类专栏： # 莫队
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Janiin/article/details/108398984
版权

文章目录

HDU-5145 NPY and girls [莫队][组合数][逆元]

HDU-5145 NPY and girls

题意

每个女孩所在的班级为 a [ i ] a[i] a[i]，NPY每次到一个班级只能拜访一个女孩，问NPY访问区间 [ l , r ] [l,r] [l,r] 里的女孩的访问方式总共有多少种

思路

NPY访问总次数应为 r − l + 1 r-l+1 r−l+1，对于每个女孩，就是在这几个位置中任意选择一个位置，即求组合数
对于在 x x x 班级的女孩，访问的次数为 C r − l + 1 c n t [ x ] C_{r-l+1}^{cnt[x]} Cr−l+1cnt[x]​
则将所有的都乘起来，即结果
由于组合数 C n + 1 m + 1 = C n m ∗ n + 1 m + 1 C_{n+1}^{m+1} = C_{n}^{m}*\frac{n+1}{m+1} Cn+1m+1​=Cnm​∗m+1n+1​
令 l e n = r − l + 1 len = r-l+1 len=r−l+1，即
若 x x x 班级的人数增加 1 1 1， p r e pre pre 为未增加前的结果，则现在的结果应为
r e s = p r e ∗ l e n ∗ 1 c n t [ i ] res = pre * len * \frac{1}{cnt[i]} res=pre∗len∗cnt[i]1​
若 x x x 班级的人数减少 1 1 1， p r e pre pre 为未减少前的结果，则现在的结果应为
r e s = p r e ∗ c n t [ x ] ∗ 1 l e n res = pre * cnt[x] * \frac{1}{len} res=pre∗cnt[x]∗len1​
利用莫队分块转移区间， O ( 1 ) O(1) O(1) 求得每次转移后的结果

代码

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
using namespace std;
typedef long long ll;
const int maxn = 3e4 + 5;;
const ll mod = 1e9 + 7;

int block;
struct node{
    int l, r, id;
    bool operator<(const node &_) const {
        return l/block == _.l/block ? r < _.r : l/block < _.l/block;
    }
}q[maxn];
int a[maxn], res[maxn], cnt[maxn];
ll inv[maxn];
ll ans;

void init() {
    inv[0] = inv[1] = 1;
    for(int i = 2; i < maxn; i++) 
        inv[i] = (mod-mod/i) * inv[mod%i] % mod;
}

void add(ll num, int x) {
    cnt[a[x]]++;
    ans = 1ll * ans * inv[cnt[a[x]]] % mod * num % mod;
}

void del(ll num, int x) {
    ans = 1ll * ans * cnt[a[x]] % mod * inv[num] % mod;
    cnt[a[x]]--;
}
 
int main() {
    int T; init();
    scanf("%d", &T);
    while(T--) {
        int n, m;
        scanf("%d%d", &n, &m);
        for(int i = 1; i <= n; ++i) scanf("%d", &a[i]);
        for(int i = 1; i <= m; ++i) {
            scanf("%d%d", &q[i].l, &q[i].r); q[i].id = i;
        }
        block = sqrt(n + 0.0);
        sort(q + 1, q + 1 + m);
        memset(cnt, 0, sizeof(cnt));
        int L = 1, R = 0; ll num = 0; ans = 1; 
        for(int i = 1; i <= m; ++i) {
            int l = q[i].l, r = q[i].r;
            while(L > l)    add(++num, --L);
            while(R < r)    add(++num, ++R);
            while(L < l)    del(num--, L++);
            while(R > r)    del(num--, R--);
            res[q[i].id] = ans;
        }
        for(int i = 1; i <= m; ++i) printf("%d\n", res[i]);
    }
    return 0;
}

SPOJ-COT2 Count on a tree II [树上莫队]

SPOJ-COT2 Count on a tree II

题意

给一棵树，问点 ( u , v ) (u, v) (u,v) 的简单路径上，有多少个不同的点值

思路

建议看洛谷题解 SP10707 COT2 - Count on a tree II 题解
第一篇挺容易理解的
就是将树转为线性结构

代码

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <vector>
using namespace std;
typedef long long ll;
const int maxn = 1e5 + 5;;
const ll mod = 1e9 + 7;
const int MAX_LOG = 20;

int block;
struct node{
    int l, r, lc, id;
    bool operator<(const node &_) const {
        return l/block == _.l/block ? r < _.r : l/block < _.l/block;
    }
}q[maxn];
vector<int> ed[maxn];
vector<int> vv;
int fa[maxn][40], dep[maxn], dfn[maxn];
int res[maxn], cnt[maxn];
int st[maxn], en[maxn]; // 欧拉序
int vis[maxn]; // 是否在区间中
int a[maxn];
ll ans;
int tol;

int getid(int x) {
    return lower_bound(vv.begin(), vv.end(), x) - vv.begin() + 1;
}

void init(int n) {
    vv.clear(); tol = 0;
    memset(cnt, 0, sizeof(cnt));
    memset(vis, 0, sizeof(vis));
    for(int i = 1; i <= n; ++i) ed[i].clear();
}

void deal(int x) {
    if(vis[x] && --cnt[a[x]] == 0) ans--;
    else if(!vis[x] && cnt[a[x]]++ == 0) ans++;
    vis[x] ^= 1; // 是否在已计算的区间内
}

void dfs(int u, int pre, int d) {
    dep[u] = d, st[u] = ++tol;
    dfn[tol] = u, fa[u][0] = pre;
    for(int i = 1; (1<<i) <= dep[u]; ++i)
        fa[u][i] = fa[fa[u][i-1]][i-1];
    for(auto v : ed[u]) {
        if(v == pre) continue;
        dfs(v, u, d + 1);
    }
    en[u] = ++tol;
    dfn[tol] = u;
}

int lca(int u, int v) {
    if(dep[u] < dep[v]) swap(u, v);
    int x = dep[u] - dep[v];
    for(int i = 0; i <= MAX_LOG; ++i)
        if((x >> i) & 1) u=fa[u][i];
    if(u == v) return u;
    for(int i = MAX_LOG; i >= 0; --i) {
        if(fa[u][i] != fa[v][i])
            u = fa[u][i], v = fa[v][i];
    }
    return fa[u][0];
}

void solve(int n, int m) {
    dfs(1, 0, 1);
    block = sqrt(2*n + 0.0); // 点个数 2n
    for(int i = 1, u, v; i <= m; ++i) {
        scanf("%d%d", &u, &v);
        int lc = lca(u, v);
        if(st[u] > st[v]) swap(u, v);
        q[i].id = i, q[i].lc = lc;
        if(lc == u) q[i].l=st[u], q[i].r=st[v]; // 同一条链上
        else        q[i].l=en[u], q[i].r=st[v]; // 不同链上
    }
    sort(q + 1, q + 1 + m);
    sort(vv.begin(), vv.end());
    vv.erase(unique(vv.begin(), vv.end()), vv.end());
    for(int i = 1; i <= n; ++i) a[i] = getid(a[i]);
    int L = q[1].l, R = q[1].l-1;
    for(int i = 1; i <= m; ++i) {
        int l = q[i].l, r = q[i].r;
        while(L > l)    deal(dfn[--L]);
        while(R < r)    deal(dfn[++R]);
        while(L < l)    deal(dfn[L++]);
        while(R > r)    deal(dfn[R--]);
        res[q[i].id] = ans;
        if(cnt[a[q[i].lc]] == 0)    res[q[i].id]++; // 算上lca的
    }
}

int main() {
    int n, m;
    scanf("%d%d", &n, &m); init(n);
    for(int i = 1; i <= n; ++i) {
        scanf("%d", &a[i]); vv.push_back(a[i]);
    }
    for(int i = 1, u, v; i < n; ++i) {
        scanf("%d%d", &u, &v);
        ed[u].push_back(v), ed[v].push_back(u);
    }
    solve(n, m);
    for(int i = 1; i <= m; ++i) printf("%d\n", res[i]);
    return 0;
}

NBUT-1457 Sona [莫队]

NBUT-1457 Sona

题意

求区间 [ l , r ] [l, r] [l,r] 中， ∑ c n t [ x ] 3 ( x ∈ { a [ j ] ∣ l ≤ j ≤ r } ) \sum cnt[x]^3(x \in \{a[j] | l \leq j \leq r\}) ∑cnt[x]3(x∈{a[j]∣l≤j≤r})， c n t [ x ] cnt[x] cnt[x] 表示 x x x 的个数

思路

题意读懂的话就是简单的莫队模板，稍微改一下
（其实我也没读题，看样例猜的
先扣除当前的 c n t [ x ] cnt[x] cnt[x] 的贡献，再加上更改后的贡献
这题时间卡的有点紧，如果超时可以加加看快读，都开int然后再取模

代码

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <vector>
using namespace std;
typedef long long ll;
const int maxn = 1e5 + 5;
const ll mod = 1e9 + 7;

int block;
struct node{
    int l, r, id;
    bool operator<(const node &_) const {
        return l/block == _.l/block ? r < _.r : l/block < _.l/block;
    }
}q[maxn];
vector<int> vv;
ll res[maxn], cnt[maxn];
int a[maxn];
ll ans;

inline int getid(int x) {
    return lower_bound(vv.begin(), vv.end(), x) - vv.begin() + 1;
}

ll cal(ll x) {
    return x * x * x;
}

void add(int x) {
    ans -= cal(cnt[a[x]]);
    cnt[a[x]] += 1;
    ans += cal(cnt[a[x]]);
}

void del(int x) {
    ans -= cal(cnt[a[x]]);
    cnt[a[x]] -= 1;
    ans += cal(cnt[a[x]]);
}

void solve(int n, int m) {
    block = sqrt(n + 0.0); 
    sort(q + 1, q + 1 + m);
    sort(vv.begin(), vv.end());
    vv.erase(unique(vv.begin(), vv.end()), vv.end());
    for(int i = 1; i <= n; ++i) a[i] = getid(a[i]);
    int L = q[1].l, R = q[1].l-1;
    for(int i = 1; i <= m; ++i) {
        int l = q[i].l, r = q[i].r;
        while(L > l)    add(--L);
        while(R < r)    add(++R);
        while(L < l)    del(L++);
        while(R > r)    del(R--);
        res[q[i].id] = ans;
    }
}

int main() {
    int n, m;
    while(~scanf("%d", &n)) {
        vv.clear(); ans = 0;
        for(int i = 1; i <= n; ++i) cnt[i]=0;
        for(int i = 1; i <= n; ++i) {
            scanf("%d", &a[i]); vv.push_back(a[i]);
        }
        scanf("%d", &m);
        for(int i = 1; i <= m; ++i) {
            scanf("%d%d", &q[i].l, &q[i].r); q[i].id = i;
        }
        solve(n, m);
        for(int i = 1; i <= m; ++i) printf("%lld\n", res[i]);
    }
    return 0;
}

HDU-5213 Lucky [莫队][容斥]

HDU-5213 Lucky

题意

每次询问给两个区间 [ l , r ] , [ u , v ] [l, r], [u, v] [l,r],[u,v]
x ∈ [ l , r ] , y ∈ [ u , v ] , x + y = = k x \in [l, r], y \in [u, v], x+y == k x∈[l,r],y∈[u,v],x+y==k，问这样的对数存在多少对， ( l ≤ r < u ≤ v ) (l \leq r < u \leq v) (l≤r<u≤v)
比如 [1 2 1 2], k = 3 k = 3 k=3
[ l , r ] = [ 1 , 3 ] , [ u , v ] = [ 2 , 4 ] [l,r]=[1,3], [u, v]=[2, 4] [l,r]=[1,3],[u,v]=[2,4]
存在的对有（这里写下标，看起来比较清晰） ( 1 , 2 ) ( 1 , 4 ) ( 2 , 3 ) ( 3 , 2 ) ( 3 , 4 ) (1, 2)(1,4)(2,3)(3,2)(3,4) (1,2)(1,4)(2,3)(3,2)(3,4)

思路

考虑莫队，但莫队每次计算的都是一个区间内的组合，那么将这两个区间先合并起来看
区间 [ l , v ] [l, v] [l,v] 这段的值可以看做以下几个部分组成
在这里插入图片描述
其实也就是容斥求解

代码

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <vector>
using namespace std;
typedef long long ll;
const int maxn = 3e4 + 5;
const ll mod = 1e9 + 7;

int block;
struct node{
    int l, r, id, op;
    bool operator<(const node &_) const {
        return l/block == _.l/block ? r < _.r : l/block < _.l/block;
    }
}q[maxn<<2];
int cnt[maxn<<2];
int a[maxn];
ll res[maxn];
ll ans;
int k;


void add(int x) {
    if(x >= k)  return ;
    ans -= cnt[x] * cnt[k-x];
    cnt[x]++;
    ans += cnt[x] * cnt[k-x];
}

void del(int x) {
    if(x >= k)  return ;
    ans -= cnt[x] * cnt[k-x];
    cnt[x]--;
    ans += cnt[x] * cnt[k-x];
}

void solve(int n, int m) {
    block = sqrt(n + 0.0); 
    sort(q + 1, q + 1 + m);
    int L = q[1].l, R = q[1].l-1;
    for(int i = 1; i <= m; ++i) {
        int l = q[i].l, r = q[i].r;
        while(L > l)    add(a[--L]);
        while(R < r)    add(a[++R]);
        while(L < l)    del(a[L++]);
        while(R > r)    del(a[R--]);
        res[q[i].id] += ans * q[i].op;
    }
}

int main() {
    int n, m;
    while(~scanf("%d", &n)) {
        scanf("%d", &k);
        for(int i = 1; i <= n; ++i) scanf("%d", &a[i]);
        scanf("%d", &m);
        for(int i = 1, j = 1; i <= m; i++) {
            int l, r, u, v;
            scanf("%d%d%d%d", &l, &r, &u, &v);
            q[j].l = l, q[j].r = v, q[j].id = i, q[j].op = 1; j++;
            q[j].l = l, q[j].r = u-1, q[j].id = i, q[j].op = -1; j++;
            q[j].l = r+1, q[j].r = v, q[j].id = i, q[j].op = -1; j++;
            q[j].l = r+1, q[j].r = u-1, q[j].id = i, q[j].op = 1; j++;
        }
        ans = 0;
        memset(cnt, 0, sizeof(cnt));
        memset(res, 0, sizeof(res));
        solve(n, m*4);
        for(int i = 1; i <= m; ++i) printf("%lld\n", res[i]);
    }
    return 0;
}

QAQ!
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
莫队算法完整总结（普通莫队、带修莫队、树上莫队、回滚莫队）
Gene_I must wait for the sunrise
09-05 2673
普通莫队 带修改莫队 树上带修改莫队 回滚莫队
Java练习题
09-13
Java练习题，包含Java各个阶段的练习题，对学习Java知识很有帮助，面对各面试题也有一定帮助。
莫队练习题
蒲公英殇的博客
09-06 229
莫队刷题
基础莫队练习
ayyyyy_zc的博客
05-14 129
vj练习网址 A - D-query #include<bits/stdc++.h> using namespace std; const int maxn = 3e4 + 50; const int maxm = 2e5 + 50; const int MAX = 1e6 + 50; int s[maxn], ans[maxm], cnt[MAX]; int unit, num; s...
莫队练习之基础练习：P2709小B的询问
Fighter_sky的博客
07-01 70
文章目录题意思路代码 题意 给定一数列，给定多个询问，询问中给定l、r，求l到r中每个数出现次数的平方的和 思路 询问之间不互相影响，考虑离线，考虑莫队，维护每个数出现的次数cnt[i]，根据完全平方展开，可以得到更新后sum=sum+2*cnt[i]+1，离线时间复杂度O（n√n），查询O（1） 代码 #include<bits/stdc++.h> #define N 50005 #define ll long long using namespace std; inline ll read(
超全的莫队算法一遍过
GROZAX的博客
04-10 3798
莫队的基本思想、回滚莫队、树上莫队、二次离线，一文搞定。什么？你还不会莫队？看完这篇文章你就会了
牛客练习赛8 F题 莫队算法
新熊君的博客
12-27 481
题目链接题意： 给一个长为 nn 的只含小写字母的字符串 每次查询一个区间 [l,r][l,r] 内，有多少子区间可以重排为一个回文串。思路： 首先对于一个可以重排为回文串的区间，一定满足至多一个字母的出现次数为奇数，其余字母的出现次数为偶数。因为只有26个小写字母其只考虑出现次数的奇偶性，故可以考虑压位2262^{26} 表示每一个字母的出现情况。 对每一位求一个前缀和。对于一个新加入第x
莫队算法
christ_lrs的博客
03-31 1821
莫队算法，是由莫涛队长提出的，能够以玄学的复杂度处理区间查询类的问题。也可以说，他使用来解决线段树等数据结构不好维护的区间查询问题。
牛客练习赛10 E 数列查找 [莫队+分块]
ACTerminate的博客
01-20 400
牛客练习赛10 E 数列查找 [莫队+分块]
莫队
weixin_33951761的博客
03-05 670
莫队 莫队算法的本质是一种暴力。 在一些区间（或树）上的问题，没有强制要求在线时，将区间（或树）上问题转换为离线去做。 1.普通莫队 算法介绍： 普通莫队，就是可离线，没有修改的莫队。这一类莫队算法的核心思想是：将整个数列区间划分$\sqrt{n}$块。再将多个询问进行升序$sort()$，改变处理问题的顺序，即第一关键字为询问左区间l所在第几个块，第二关键字为询问右区间r。 用两个指...
莫队算法小介绍——看似暴力的莫队算法
lqybzx的专栏
08-17 7124
摘要：        莫队算法是一个对于区间、树或其他结构离线（在线）维护的算法，此算法基于一些基本算法，例如暴力维护，树状数组，分块，最小曼哈顿距离生成树，对其进行揉合从而产生的一个简单易懂且短小好写的算法。此算法在很多情况下可以很轻松的切掉一些复杂而且难写的数据结构问题。 关键词：程序设计、算法、算法优化，暴力算法，分块算法，最小曼哈顿距离生成树。 背景：        众所周知，
读书莫放拦路虎练习题精选.doc
09-25
读书莫放拦路虎练习题精选.doc
成语分类练习 虚词.rar
12-11
两套关于“虚词”的成语分类练习，每套6组，每组8个成语。训练价值远高于“成语接龙”。例如： 　＿名其妙　名副其＿ 　其貌不＿　若＿其事 　＿厌其烦　郑重其＿ 　其乐＿穷　＿行其是 〔各 不 扬 无 实 事 无...
蒙德莫
02-12
开始一个新的演示练习MERN
计算机应用基础随堂练习+答案.docx
06-05
莫奇莱 B. 艾仑·图灵 C. 乔治·布尔 D. 冯·诺依曼 参考答案：D 9.(单选题) 第3代计算机采用（ ）作为主存储器。　A. 磁芯 B. 微芯片 C. 半导体存储器 D. 磁盘 参考答案：C 问题解析：计算机发展过程 10.(单选题) ...
node-v6.3.1-linux-ppc64.tar.xz
05-10
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
计算机专业词汇+英语+计算机能不学英语吗？
05-10
计算机专业英语词汇非常丰富，涉及计算机硬件、软件、网络、程序设计语言等多个方面。由于篇幅限制，我无法直接列出完整的1000个计算机专业英语词汇，但我可以为您提供一些常见的计算机专业英语词汇作为示例： file - 文件 command - 命令，指令 use - 使用，用途 program - 程序 line - (数据，程序)行，线路 if - 如果（连词） display - 显示，显示器 set - 设置（动词），集合（名词） key - 键，关键字，关键码 list - 列表，显示（名词），打印（动词） by - 凭，靠，沿（介词） press - 按，压（动词） with - 用，与，随着（介词） format - 格式 change - 更换，改变，变动（动词）
35-35.渗透测试SQL注入之SQL注入防御
05-10
35-35.渗透测试SQL注入之SQL注入防御
node-v6.3.1-linux-armv7l.tar.xz
最新发布
05-10
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
springboot练习
08-18
如果你想进行Spring Boot的练习，以下是一些建议： 1. 创建一个简单的Spring Boot项目：使用Spring Initializr（https://start.spring.io/）创建一个基本的Spring Boot项目，选择合适的依赖项（如Spring Web、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值