P1972 [SDOI2009]HH的项链 莫队&&树状数组

最新推荐文章于 2024-08-30 21:09:25 发布
最新推荐文章于 2024-08-30 21:09:25 发布
阅读量109 收藏
点赞数
分类专栏： 莫队 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43860866/article/details/108502700
版权

HH的项链 洛谷P1972

题意

一个长度为 n n n 的序列，共 m m m 组询问，询问区间 [ l , r ] [l,r] [l,r] 内不同数字的个数。

（ n n n , m m m , a [ i ] ≤ 1 ⋅ 1 0 6 a[i] \le 1\cdot 10^6 a[i]≤1⋅106 ）

解法

方法一（莫队）：

  • 这道题，区间 [ l , r ] [l,r] [l,r] 的答案可以 O ( 1 ) O(1) O(1) 向区间 [ l − 1 , r ] , [ l + 1 , r ] , [ l , r − 1 ] , [ l , r + 1 ] [l-1,r],[l+1,r],[l,r-1],[l,r+1] [l−1,r],[l+1,r],[l,r−1],[l,r+1] 转移，所以可以用莫队算法。
  • 只需要维护一个 c n t cnt cnt 数组，记录每个数字出现的次数，然后增加或者删除一个数字可以知道区间内不同数字的个数的变化。从而 O ( 1 ) O(1) O(1) 转移答案。
  • 复杂度为 O ( n n ) O(n \sqrt n) O(nn ​) ，只能过 5 e 5 5e5 5e5 的数据， 1 e 6 1e6 1e6 的数据会TLE。
#pragma region
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, a, n) for (int i = a; i <= n; ++i)
#define per(i, a, n) for (int i = n; i >= a; --i)
namespace fastIO {
#define BUF_SIZE 100000
#define OUT_SIZE 100000
//fread->R
bool IOerror = 0;
//inline char nc(){char ch=getchar();if(ch==-1)IOerror=1;return ch;}
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 = 1;
            return -1;
        }
    }
    return *p1++;
}
inline bool blank(char ch) { return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t'; }
template <class T>
inline bool R(T &x) {
    bool sign = 0;
    char ch = nc();
    x = 0;
    for (; blank(ch); ch = nc())
        ;
    if (IOerror)
        return false;
    if (ch == '-')
        sign = 1, ch = nc();
    for (; ch >= '0' && ch <= '9'; ch = nc())
        x = x * 10 + ch - '0';
    if (sign)
        x = -x;
    return true;
}
inline bool R(double &x) {
    bool sign = 0;
    char ch = nc();
    x = 0;
    for (; blank(ch); ch = nc())
        ;
    if (IOerror)
        return false;
    if (ch == '-')
        sign = 1, ch = nc();
    for (; ch >= '0' && ch <= '9'; ch = nc())
        x = x * 10 + ch - '0';
    if (ch == '.') {
        double tmp = 1;
        ch = nc();
        for (; ch >= '0' && ch <= '9'; ch = nc())
            tmp /= 10.0, x += tmp * (ch - '0');
    }
    if (sign)
        x = -x;
    return true;
}
inline bool R(char *s) {
    char ch = nc();
    for (; blank(ch); ch = nc())
        ;
    if (IOerror)
        return false;
    for (; !blank(ch) && !IOerror; ch = nc())
        *s++ = ch;
    *s = 0;
    return true;
}
inline bool R(char &c) {
    c = nc();
    if (IOerror) {
        c = -1;
        return false;
    }
    return true;
}
template <class T, class... U>
bool R(T &h, U &... tmp) { return R(h) && R(tmp...); }
#undef OUT_SIZE
#undef BUF_SIZE
};  // namespace fastIO
using namespace fastIO;
template <class T>
void _W(const T &x) { cout << x; }
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) { _W(x.F), putchar(' '), _W(x.S); }
template <class T>
void _W(const vector<T> &x) {
    for (auto i = x.begin(); i != x.end(); _W(*i++))
        if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &... tail) { _W(head), putchar(sizeof...(tail) ? ' ' : '\n'), W(tail...); }
#pragma endregion
//莫队维护区间颜色 洛谷P1972
const int maxn = 1e6 + 5;
int n, m, B, a[maxn];
int pos[maxn], ANS[maxn];
int ans = 0, cnt[maxn];
struct Req {
    int l, r, id;
    bool operator<(const Req &A) const {
        if (pos[l] != pos[A.l]) return pos[l] < pos[A.l];
        return r < A.r;
    }
} q[maxn];
void update(int id, int f) {
    int x = a[id];
    cnt[x] += f;
    if (f == 1 && cnt[x] == 1) ++ans;
    if (f == -1 && cnt[x] == 0) --ans;
}
int main() {
    R(n);
    B = sqrt(n);
    rep(i, 1, n) {
        R(a[i]);
        pos[i] = i / B;  //卡常
    }
    R(m);
    rep(i, 1, m) {
        R(q[i].l, q[i].r);
        q[i].id = i;
    }
    sort(q + 1, q + 1 + m);
    int l = 1, r = 0;
    rep(i, 1, m) {
        while (l < q[i].l) update(l++, -1);
        while (l > q[i].l) update(--l, 1);
        while (r < q[i].r) update(++r, 1);
        while (r > q[i].r) update(r--, -1);
        ANS[q[i].id] = ans;
    }
    rep(i, 1, m) W(ANS[i]);
}

方法二（树状数组）：

  • 对于若干个询问的区间 [ l , r ] [l,r] [l,r] ，如果他们的 r r r 都相等的话，那么数组中出现的同一个数字，一定是只关心出现在最右边的那一个的。
  • 考虑前缀和，即区间 [ l , r ] [l,r] [l,r] 的答案为 s u m [ r ] − s u m [ l − 1 ] sum[r]-sum[l-1] sum[r]−sum[l−1] 。
  • 我们会发现一个问题，一个数可能既在区间 [ l , r ] [l,r] [l,r] 出现也在区间 [ 1 , l − 1 ] [1,l-1] [1,l−1] 出现，那么这个数字对这两个区间都贡献了答案，就不应该被减掉。
  • 我们可以把询问的区间按照右端点 r r r 进行排序，维护一个树状数组，如果一个数字在 [ 1 , r ] [1,r] [1,r] 内出现了两次，那么我们只需要关心后一次的出现即可，这样 s u m [ r ] − s u m [ l − 1 ] sum[r]-sum[l-1] sum[r]−sum[l−1] 就是这个区间的答案了。
  • 也就是说，如果数字 a [ r ] a[r] a[r] 出现了，就删除上一次的出现，即 a d d ( p [ a [ r ] ] , − 1 ) add(p[a[r]],-1) add(p[a[r]],−1) 。然后记录这一次的出现，即 a d d ( r , 1 ) add(r,1) add(r,1) ，并更新 p [ a [ r ] ] p[a[r]] p[a[r]] 。
#pragma region
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, a, n) for (int i = a; i <= n; ++i)
#define per(i, a, n) for (int i = n; i >= a; --i)
namespace fastIO {
#define BUF_SIZE 100000
#define OUT_SIZE 100000
//fread->R
bool IOerror = 0;
//inline char nc(){char ch=getchar();if(ch==-1)IOerror=1;return ch;}
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 = 1;
            return -1;
        }
    }
    return *p1++;
}
inline bool blank(char ch) { return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t'; }
template <class T>
inline bool R(T &x) {
    bool sign = 0;
    char ch = nc();
    x = 0;
    for (; blank(ch); ch = nc())
        ;
    if (IOerror)
        return false;
    if (ch == '-')
        sign = 1, ch = nc();
    for (; ch >= '0' && ch <= '9'; ch = nc())
        x = x * 10 + ch - '0';
    if (sign)
        x = -x;
    return true;
}
inline bool R(double &x) {
    bool sign = 0;
    char ch = nc();
    x = 0;
    for (; blank(ch); ch = nc())
        ;
    if (IOerror)
        return false;
    if (ch == '-')
        sign = 1, ch = nc();
    for (; ch >= '0' && ch <= '9'; ch = nc())
        x = x * 10 + ch - '0';
    if (ch == '.') {
        double tmp = 1;
        ch = nc();
        for (; ch >= '0' && ch <= '9'; ch = nc())
            tmp /= 10.0, x += tmp * (ch - '0');
    }
    if (sign)
        x = -x;
    return true;
}
inline bool R(char *s) {
    char ch = nc();
    for (; blank(ch); ch = nc())
        ;
    if (IOerror)
        return false;
    for (; !blank(ch) && !IOerror; ch = nc())
        *s++ = ch;
    *s = 0;
    return true;
}
inline bool R(char &c) {
    c = nc();
    if (IOerror) {
        c = -1;
        return false;
    }
    return true;
}
template <class T, class... U>
bool R(T &h, U &... tmp) { return R(h) && R(tmp...); }
#undef OUT_SIZE
#undef BUF_SIZE
};  // namespace fastIO
using namespace fastIO;
template <class T>
void _W(const T &x) { cout << x; }
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) { _W(x.F), putchar(' '), _W(x.S); }
template <class T>
void _W(const vector<T> &x) {
    for (auto i = x.begin(); i != x.end(); _W(*i++))
        if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &... tail) { _W(head), putchar(sizeof...(tail) ? ' ' : '\n'), W(tail...); }
#pragma endregion
//离线树状数组维护区间颜色 洛谷P1972
const int maxn = 1e6 + 5;
int n, Q, a[maxn], c[maxn];
int ANS[maxn];
struct node {
    int l, r, id;
    bool operator<(const node &A) const { return r < A.r; }
} q[maxn];
void add(int pos, int x) {
    while (pos <= n) c[pos] += x, pos += pos & -pos;
}
int getsum(int pos) {
    int ans = 0;
    while (pos) ans += c[pos], pos -= pos & -pos;
    return ans;
}
int p[maxn];
int main() {
    R(n);
    rep(i, 1, n) R(a[i]);
    R(Q);
    rep(i, 1, Q) R(q[i].l, q[i].r), q[i].id = i;
    sort(q + 1, q + 1 + Q);
    int r = 0;
    rep(i, 1, Q) {
        while (r < q[i].r) {
            ++r;
            if (p[a[r]]) add(p[a[r]], -1);
            add(r, 1);
            p[a[r]] = r;
        }
        ANS[q[i].id] = getsum(q[i].r) - getsum(q[i].l - 1);
    }
    rep(i, 1, Q) W(ANS[i]);
}
bandiaoz_cjl
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
P1972 树状数组求区间种类数
Link_Ray的博客
03-13 426
https://www.luogu.org/problemnew/show/P1972 题解 给定一段序列，每次询问一个区间[l,r]里有多少个不相同的数。经典的做法便是，离线处理，将这些区间按照r关键字从小到达排序。然后遍历这个序列，如果当前数x在之前的pre位置出现过，那么c[pre[x]]-1，c[now[x]]+1，当到达r时，答案便是sum[r]-sum[l-1]，其中sum[i]是前缀...
【洛谷】P1972 [SDOI2009]HH的项链 离线预处理 + 树状数组
待到山花烂漫时
03-30 157
题目描述 HH 有一串由各种漂亮的贝壳组成的项链。HH 相信不同的贝壳会带来好运，所以每次散步完后，他都会随意取出一段贝壳，思考它们所表达的含义。HH 不断地收集新的贝壳，因此，他的项链变得越来越长。 有一天，他突然提出了一个问题：某一段贝壳中，包含了多少种不同的贝壳？这个问题很难回答…… 因为项链实在是太长了。于是，他只好求助睿智的你，来解决这个问题。 输入格式 一行一个正整数 nn，表示项链长...
P1972 [SDOI2009] HH的项链（莫队）
weixin_34221332的博客
03-29 107
https://www.luogu.org/problem/show?pid=1972#sub 时间复杂度证明： 右端点移动： 首先我们考虑一个块里面的转移情况 由于一个块里面的询问都按右端点排序 所以我们右端点在一个块里面最多移动n次 有 O(n√)O(n)个块，那么同一个块内的右端点移动最多就是O(nn√)O(nn) 然后考虑从一个块到另一个块导致的右端点变化...
【P1972 [SDOI2009]HH的项链】莫队1000ms卡过
我是谁 --- 卡比兽
04-16 149
P1972 鉴于这种问题应该离线或者树状数组处理线段树处理 根据的原则是如果一个项链中要元素 那么我们一定是取最右边的那个 但是写了发莫队水过去了 当复习莫队了 /* if you can't see the repay Why not just work step by step rubbish is relaxed to ljq */ //biubiubiuAK...
洛谷 P1972 [SDOI2009]HH的项链
我要吃熊猫
09-05 637
莫队算法
Luogu P1972 [SDOI2009]HH的项链
linjiayang2016的博客
06-25 275
题目大意 (略) 题解 离线计算。区间按照右端点排序。 代码
洛谷 P1972 [SDOI2009]HH的项链 (可持久化线段树)
Ab.Ever
04-18 701
可持久化线段树模版题，其实也可以用莫队来做（当然O(nlognn\log{n})比O(nn√n\sqrt{n})要划算，且代码也非常简洁。）差点忘了放题目了。。。=。=题目背景无题目描述HH 有一串由各种漂亮的贝壳组成的项链。HH 相信不同的贝壳会带来好运，所以每次散步完后，他都会随意取出一段贝壳，思考它们所表达的含义。HH 不断地收集新的贝壳，因此，他的项链变得越来越长。有一天，他突然提出了一个问
洛谷P1972 [SDOI2009]HH的项链 离线+树状数组 主席树
独钓门前月
06-29 296
题目链接：https://www.luogu.com.cn/problem/P1972 题意：区间不同数的个数。 思路：第一种写法：离线询问，将其按照r大小排序，然后对于ai，将当前位置+1，上一次出现位置-1，求前缀和就是答案。 #include<bits/stdc++.h> using namespace std; typedef long long ll; #define fi first #define se second #define ls rt << 1 #def
HH的项链 题解（离线思想+链表+树状数组）
fjyyc的博客
06-18 249
              本人第一篇博客重磅推出！！！希望各位朋友以后多多捧场也多给写意见（我个人喜欢把题解写得啰嗦一点，因为这样方便理解，各位巨佬勿喷）来讲一道提高+/省选-的骚题：HH的项链（这个HH你理解成皇后呵呵哈哈嘿嘿花花红红还是蛤蛤都可以）                  题目来源：洛谷 P1972 [SDOI2009]HH的项链   题面如下：题目描述HH 有一串由各种漂亮的贝壳...
求区间元素种类数的几种方法
zjy_code的博客
05-04 639
P1972 [SDOI2009] HH的项链https://www.luogu.com.cn/problem/P1972 本博客将以该题目为例进行介绍 方法1：树状数组 树状数组需要结合离散化处理，我们观察到一个性质，随着右端点的右移，每一种元素的贡献位置（这里指存在贡献的位置，如：1 2 3 1 这组数据，内1元素的贡献可以用4位置提供1次贡献，而1位置的元素贡献为0），因为右端点不断右移，所以不需要考虑查询区间存在如下情况： 在上图中，假设7位置的1提供了贡献，此时肯定右端点位置，故上图区间..
算法典题 ---- 持续更新中
weixin_73936404的博客
02-08 571
目录字符串哈希：单调队列优化dp： 线段树（单点更新、区间查询最大最小值）： 线段树（查询区间最大子线段和变形）：01字典树： C-智乃的前缀、后缀、回文_牛客寒假算法基础集训营3 （AtCoder Beginner Contest 331）F - Palindrome Query F - Product Equality (atcoder.jp) D. Blocking Elements Codeforces Round 922 (Div.
洛谷P1972(树状数组+离线)
塞满箱子的过程
08-19 221
题目描述 HH 有一串由各种漂亮的贝壳组成的项链。HH 相信不同的贝壳会带来好运，所以每次散步完后，他都会随意取出一段贝壳，思考它们所表达的含义。HH 不断地收集新的贝壳，因此，他的项链变得越来越长。有一天，他突然提出了一个问题：某一段贝壳中，包含了多少种不同的贝壳？这个问题很难回答……因为项链实在是太长了。于是，他只好求助睿智的你，来解决这个问题。 输入格式 第一行：一个整数N，表示项链的长度。...
离线树状数组【洛谷P1972】
KIKO_caoyue的博客
11-15 325
传送门：https://www.luogu.org/problemnew/show/P1972 离线的题目，并且是求区间问题。我们就离线树状数组吧。 线段树也是可以的，这题莫队70分，分块是和莫队一样的，就没写，估计也就70分。 我们来分析一下这个题目吧。 询问一段区间的种类数，并且没有更新操作。我们就分析一下怎么离线。 ... (五分钟后) 好了，经过分析可知，我们按询问区间的右端...
线段树/莫队——BZOJ1878/Luogu1972 [SDOI2009]HH的项链
2333：jzqjzq的博客专栏
04-11 381
http://www.lydsy.com/JudgeOnline/problem.php?id=1878 https://www.luogu.org/problem/show?pid=1972 隔了一段时间用新方法重做此题。。。 这个可以看做离线区间查询问题，一段时间以前，我把这题当做是线段树来做 具体思路：把询问按照右端点从小到大排序，然后一个一个插入 意思是说按照项链的真实情况插入
1878: [SDOI2009]HH的项链
月下沙茶树
12-14 410
看见题目第一眼就想到莫队了，为什么看网上一堆题解都是树状数组，果然我智商低吗QAQ。 算了，反正莫队乱搞就好了。 很明显，我们用一个数组记录编号为i的贝壳有多少个，增减的时候处理一下维护答案，即在O(1)的时间内从[L,R]到[L-1,R]或[L+1,R]或[L,R-1]或[L,R+1]，然后就可以莫队了。 #include #include #include #include #inclu
(洛谷)[SDOI2009]HH的项链
dxyinme-Zz
09-14 428
题目描述HH 有一串由各种漂亮的贝壳组成的项链。HH 相信不同的贝壳会带来好运，所以每次散步完后，他都会随意取出一段贝壳，思考它们所表达的含义。HH 不断地收集新的贝壳，因此，他的项链变得越来越长。有一天，他突然提出了一个问题：某一段贝壳中，包含了多少种不同的贝壳？这个问题很难回答……因为项链实在是太长了。于是，他只好求助睿智的你，来解决这个问题。输入格式：第一行：一个整数N，表示项链的长度。 第
【bzoj1878】[SDOI2009]HH的项链
GEOTCBRL
11-20 946
莫队裸题。#include <bits/stdc++.h> #define rep(i,a,b) for(int i=a,_=b;i<=_;i++) #define per(i,a,b) for(int i=a,_=b;i>=_;i--) #define maxn 50007 #define maxm 200007inline int rd() { char c = getchar();
洛谷P1972：[SDOI2009]HH的项链（莫队/线段树）
KsCla
04-18 1450
题目传送门：https://www.luogu.org/problem/show?pid=1972 分析：本题有很多种做法，有O(n*log(n))的线段树，也有O(n*sqrt(n))的莫队。线段树的做法： http://blog.csdn.net/kscla/article/details/70227098 下面贴一下莫队的代码（其实就是个暴力，注意每一次要先让R指针右移，再移动L指针，
树、二叉树
最新发布
2301_79909332的博客
08-30 160
1、满二叉树：满二叉树是一种特殊的二叉树，其中每个层级的节点数都是最大值，即每个层级都是完全填充的。深度： 从根节点出发到达节点的分支节点个数称为该节点的深度。高度：从叶子节点出发到该节点最大的节点个数称为该节点的高度。树的高度：整个树形结构中高度最高的节点的高度称为树的高度。树的深度：整个树形结构中深度最深的节点的深度称为树的深度。3、二叉树特点：叶子节点、只有左孩子、只有右孩子、左右孩子都有。树的层数 == 树的高度 == 树的深度。3.叶子节点：没有后继的节点。节点的度： 叶子节点度数为0。
const hh\\&a
07-28
根据提供的引用内容，无法找到与问题相关的信息。请提供更多的上下文或明确的问题，以便我可以帮助您。 #### 引用[.reference_title] ...common_search_pc_result","utm_medium":"distribute.pc_search_result.none-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值