CodeForces - 1000F One Occurrence（莫队+分块 | 线段树 | 主席树）

最新推荐文章于 2022-03-11 20:37:20 发布
最新推荐文章于 2022-03-11 20:37:20 发布
阅读量456 收藏 1
点赞数
分类专栏： ————ACM相关———— ——数据结构—— ACM - 线段树 ACM - 主席树 ——算法技巧—— ACM -莫队算法
Why is everything so heavy?
本文链接：https://blog.csdn.net/lzc504603913/article/details/83310266
版权

F. One Occurrence

time limit per test

3 seconds

memory limit per test

768 megabytes

input

standard input

output

standard output

You are given an array aa consisting of nn integers, and qq queries to it. ii-th query is denoted by two integers lili and riri. For each query, you have to find any integer that occurs exactly once in the subarray of aa from index lili to index riri (a subarray is a contiguous subsegment of an array). For example, if a=[1,1,2,3,2,4]a=[1,1,2,3,2,4], then for query (li=2,ri=6)(li=2,ri=6) the subarray we are interested in is [1,2,3,2,4][1,2,3,2,4], and possible answers are 11, 33 and 44; for query (li=1,ri=2)(li=1,ri=2) the subarray we are interested in is [1,1][1,1], and there is no such element that occurs exactly once.

Can you answer all of the queries?

Input

The first line contains one integer nn (1≤n≤5⋅1051≤n≤5⋅105).

The second line contains nn integers a1,a2,…,ana1,a2,…,an (1≤ai≤5⋅1051≤ai≤5⋅105).

The third line contains one integer qq (1≤q≤5⋅1051≤q≤5⋅105).

Then qq lines follow, ii-th line containing two integers lili and riri representing ii-th query (1≤li≤ri≤n1≤li≤ri≤n).

Output

Answer the queries as follows:

If there is no integer such that it occurs in the subarray from index lili to index riri exactly once, print 00. Otherwise print any such integer.

Example

input

Copy

6
1 1 2 3 2 4
2
2 6
1 2

output

Copy

4
0

 

题意：区间查询只出现了一次的数字，输出一个即可。

解题思路：三种算法。

1.莫队+优化 （2510ms）

可以O(1)的转移，用一个数组记录数字出现的次数即可。关键在于统计答案。这里用set维护只出现了一次的数字貌似会超时（常数大）。所以这里直接用分块处理。块内维护出现了一次的数字的个数。每次统计答案的时候我们遍历每一个块，一旦块内答案>0，那么我们就暴力查找这一个块内，出现了一次的数字。最后的复杂度还是N*根号N级别的。按照出题者原话，直接用莫队还是会超时，因为N有50w。你这里用到了一个莫队的小优化才能过，就是在对查询的时候，我们对右边界按照爬坡那样排序，即一高一低，具体看代码。

2.线段树维护前一次出现的位置的最小值（873ms）

对于每一个数字我们可以预处理出他前一次出现的位置。然后我们对所有查询按照右端点排序，然后暴力插入。然后区间查询前一次出现的最小值，如果最小值<l，那么证明有答案，否则没答案。这里要用pair，分别记录前一次出现的位置，和指向这一个位置的位置，方便统计答案。具体细节看代码。

3.主席树（1809ms）

跟线段树一样，但是不用排序了，因为主席树可以在线做。这里要注意每次更新都要重新计算根节点。

 

 

莫队代码

#include <iostream>
#include <algorithm>
#include <string.h>
#include <vector>
#include <memory.h>
#include <bitset>
#include <map>
#include <deque>
#include <math.h>
#include <stdio.h>
using namespace std;
typedef long long int ll;
const int MAXN = 500005;

int N,Q;
int a[MAXN];

int block[MAXN];
int blocksize;
int blocknum;
int bl[MAXN],br[MAXN];//每一块的左右边界
int tot=0;

struct query{
    int l,r,id;
}q[MAXN];
bool cmp(const query &a,const query &b){
    if(block[a.l]!=block[b.l])
        return a.l<b.l;
    if(block[a.l]&1)//莫队优化
        return a.r<b.r;
    return a.r>b.r;
}

int bonenum[MAXN];
int num[MAXN];

void add(int x){
    num[x]++;
    if(num[x]==1)
        bonenum[block[x]]++,tot++;
    else if(num[x]==2)
        bonenum[block[x]]--,tot--;
}

void remove(int x){
    num[x]--;
    if(num[x]==1)
        bonenum[block[x]]++,tot++;
    else if(num[x]==0)
        bonenum[block[x]]--,tot--;
}

int getans(){
    if(tot==0)//剪枝
        return 0;
    for(int b=1;b<=blocknum;b++){
        if(bonenum[b]>0)//暴力找
        {
            for(int i=bl[b];i<=br[b];i++){
                if(num[i]==1){
                    return i;
                }
            }
        }
    }
    return 0;
}


int ans[MAXN];
void solve(){
    int l=1,r=1;
    add(a[1]);
    for(int i=0;i<Q;i++){
        while(q[i].l>l)
            remove(a[l++]);
        while(q[i].l<l)
            add(a[--l]);
        while(q[i].r>r)
            add(a[++r]);
        while(q[i].r<r)
            remove(a[r--]);
        ans[q[i].id]=getans();
    }
}


int main()
{
    //预处理
    blocksize=sqrt(MAXN);
    for(int i=1;i<MAXN;i++){
        block[i]=(i-1)/blocksize+1;
        if(blocknum!=block[i]){
            br[blocknum]=i-1;
            blocknum=block[i];
            bl[blocknum]=i;
        }
    }
    br[blocknum]=MAXN-1;
    
    scanf("%d",&N);
    for(int i=1;i<=N;i++)
        scanf("%d",&a[i]);
    scanf("%d",&Q);
    for(int i=0;i<Q;i++){
        scanf("%d%d",&q[i].l,&q[i].r);
        q[i].id=i;
    }
    sort(q,q+Q,cmp);
    solve();
    for(int i=0;i<Q;i++)
        printf("%d\n",ans[i]);
    
    return 0;
}

 

线段树代码

#include <iostream>
#include <algorithm>
#include <string.h>
#include <vector>
#include <memory.h>
#include <bitset>
#include <map>
#include <deque>
#include <math.h>
#include <stdio.h>
using namespace std;
typedef long long int ll;
const int MAXN = 500005;
const int INF=0x3f3f3f3f;

int N,Q;
int a[MAXN];
int pos[MAXN];
int ans[MAXN];

struct query{
    int l,r,id;
}q[MAXN];
bool cmp(const query &a,const query &b){
    if(a.r==b.r)
        return a.l<b.l;
    return a.r<b.r;
}

pair<int,int> tree[MAXN<<2];//前一个的位置，指向它的位置
void pushup(int rt){
    tree[rt]=min(tree[rt<<1],tree[rt<<1|1]);
}

void update(int L,int C,int l,int r,int rt){
    if(l==r){
        tree[rt].first=C;
        tree[rt].second=L;
        return;
    }
    int m=(l+r)/2;
    if(L<=m)
        update(L,C,l,m,rt<<1);
    else
        update(L,C,m+1,r,rt<<1|1);
    pushup(rt);
}

pair<int,int> query(int L,int R,int l,int r,int rt){
    if(L<=l&&r<=R)
        return tree[rt];
    pair<int,int> ans;
    ans.first=INF;
    int m=(l+r)/2;
    if(L<=m)
        ans=min(ans,query(L,R,l,m,rt<<1));
    if(R>m)
        ans=min(ans,query(L,R,m+1,r,rt<<1|1));
    return ans;
}


void solve(){

    int cur=1;
    for(int i=0;i<Q;i++){
        
        for(cur;cur<=q[i].r;cur++){
            if(pos[a[cur]])//之前已经出现过，记得把之前那个位置的答案置为正无穷
                update(pos[a[cur]],INF,1,N,1);
            update(cur,pos[a[cur]],1,N,1);
            pos[a[cur]]=cur;
        }
        
        pair<int,int> t=query(q[i].l,q[i].r,1,N,1);
        if(t.first<q[i].l)
            ans[q[i].id]=a[t.second];//用second来计算答案，因为前一次出现位置可能为0
    }
}

int main()
{
    scanf("%d",&N);
    for(int i=1;i<=N;i++)
        scanf("%d",&a[i]);
    scanf("%d",&Q);
    for(int i=0;i<Q;i++){
        scanf("%d%d",&q[i].l,&q[i].r);
        q[i].id=i;
    }
    sort(q,q+Q,cmp);
    solve();
    for(int i=0;i<Q;i++)
        printf("%d\n",ans[i]);

    return 0;
}

 

主席树代码1，题解的新建节点打法

#include <iostream>
#include <algorithm>
#include <string.h>
#include <vector>
#include <memory.h>
#include <bitset>
#include <map>
#include <deque>
#include <math.h>
#include <stdio.h>
using namespace std;
typedef long long int ll;
const int MAXN = 500005;
const int INF=0x3f3f3f3f;
int N,Q;
int a[MAXN];
int pos[MAXN];
pair<int,int> tree[MAXN*60];//前一个的位置，指向它的位置
int ls[MAXN*60];
int rs[MAXN*60];
int T[MAXN];
int tot=0;

int newnode(int l,int r){
    ++tot;
    ls[tot]=l;
    rs[tot]=r;
    if(tree[l]<tree[r])//顺便pushup
        tree[tot]=tree[l];
    else
        tree[tot]=tree[r];
    return tot;
}

int build(int l,int r){
    if(l==r){
        ++tot;
        tree[tot].first=INF;
        tree[tot].second=0;
        return tot;
    }
    int m=(l+r)/2;
    return newnode(build(l,m),build(m+1,r));
}


int update(int L,int C,int l,int r,int rt){

    if(l==r){
        ++tot;
        tree[tot].first=C;
        tree[tot].second=L;
        return tot;
    }
    int m=(l+r)/2;
    if(L<=m)
         return newnode(update(L,C,l,m,ls[rt]),rs[rt]);
    else
        return newnode(ls[rt],update(L,C,m+1,r,rs[rt]));
}

pair<int,int> query(int L,int R,int l,int r,int rt){
    if(L<=l&&r<=R)
        return tree[rt];
    pair<int,int> ans;
    ans.first=INF;
    int m=(l+r)/2;
    if(L<=m)
        ans=min(ans,query(L,R,l,m,ls[rt]));
    if(R>m)
        ans=min(ans,query(L,R,m+1,r,rs[rt]));
    return ans;
}


int main()
{

    scanf("%d",&N);
    int cur=0;
    T[cur]=build(1,N);
    for(int i=1;i<=N;i++){
        scanf("%d",&a[i]);
        cur=T[i-1];
        if(pos[a[i]])
            cur=update(pos[a[i]],INF,1,N,cur);//根节点要重新计算
        cur=update(i,pos[a[i]],1,N,cur);
        T[i]=cur;
        pos[a[i]]=i;
    }

    scanf("%d",&Q);
    int l,r;
    for(int i=0;i<Q;i++){
        scanf("%d%d",&l,&r);
        pair<int,int> t=query(l,r,1,N,T[r]);
        if(t.first<l)
            printf("%d\n",a[t.second]);
        else
            printf("0\n");
    }

    return 0;
}

 

主席树，引用打法，时间跟上面那个一样

#include <iostream>
#include <algorithm>
#include <string.h>
#include <vector>
#include <memory.h>
#include <bitset>
#include <map>
#include <deque>
#include <math.h>
#include <stdio.h>
using namespace std;
typedef long long int ll;
const int MAXN = 500005;
const int INF=0x3f3f3f3f;
int N,Q;
int a[MAXN];
int pos[MAXN];

pair<int,int> tree[MAXN*60];//前一个的位置，指向它的位置
int ls[MAXN*60];
int rs[MAXN*60];
int T[MAXN];
int tot=0;

void pushup(int rt){
    tree[rt]=min(tree[ls[rt]],tree[rs[rt]]);
}

void build(int l,int r,int &rt){
    rt=++tot;
    if(l==r){
        tree[rt].first=INF;
        return;
    }
    int m=(l+r)/2;
    build(l,m,ls[rt]);
    build(m+1,r,rs[rt]);
    pushup(rt);
}

void update(int L,int C,int l,int r,int &rt,int lrt){
    rt=++tot;
    ls[rt]=ls[lrt];
    rs[rt]=rs[lrt];
    if(l==r){
        tree[rt].first=C;
        tree[rt].second=L;
        return;
    }
    int m=(l+r)/2;
    if(L<=m)
        update(L,C,l,m,ls[rt],ls[lrt]);
    else
        update(L,C,m+1,r,rs[rt],rs[lrt]);
    pushup(rt);
}

pair<int,int> query(int L,int R,int l,int r,int rt){
    if(L<=l&&r<=R)
        return tree[rt];
    pair<int,int> ans;
    ans.first=INF;
    int m=(l+r)/2;
    if(L<=m)
        ans=min(ans,query(L,R,l,m,ls[rt]));
    if(R>m)
        ans=min(ans,query(L,R,m+1,r,rs[rt]));
    return ans;
}

int main()
{
    scanf("%d",&N);
    int cur=0;
    build(1,N,T[0]);
    tree[0].first=INF;//坑
    for(int i=1;i<=N;i++){
        scanf("%d",&a[i]);
        cur=T[i-1];
        int newrt;
        if(pos[a[i]]){
            update(pos[a[i]],INF,1,N,newrt,cur);//记得重新计算根节点
            int c;
            update(i,pos[a[i]],1,N,c,newrt);
            newrt=c;
        }
        else
            update(i,pos[a[i]],1,N,newrt,cur);
        T[i]=newrt;
        pos[a[i]]=i;
    }

    scanf("%d",&Q);
    int l,r;
    for(int i=0;i<Q;i++){
        scanf("%d%d",&l,&r);
        pair<int,int> t=query(l,r,1,N,T[r]);
        if(t.first<l)
            printf("%d\n",a[t.second]);
        else
            printf("0\n");
    }
    return 0;
}

 

LP_Cong
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CodeForces_1348EF – Phoenix and Memory 贪心+线段树找区间最小值
01-03
这题如果没有输出2个解就很简单。 是个之前做过的类型： 把所有限制按R排序， 然后每次取出R最小的，然后从其L开始选，尽量选能选的中最小的。 这样选如果能选完，就说明有解。 贪心正确性显然：R大的至少可以选则R...
26.CF1000F One Occurrence
HeartFireY的博客
09-08 265
给定序列，要求支持查询区间内只出现一次的数字 可以离线，那么离线所有询问后按右端点排序，然后加入贡献回答即可
Problem - 220B - Codeforces(莫队)
qq_53629286的博客
01-13 233
Problem - 220B - Codeforces 题目大意:给定长度为n的数组,m次查询,求每次查询的区间中,aia_iai​=num[ai]num[a_i]num[ai​]的个数. 解题思路:n的范围是1e5,基本就确定了这是一个莫队的题. 莫队用来处理离线问题,通过把长度为nnn的数组分块成n\sqrt{n}n​块来进行处理,处理之前进行一个排序,对于起点,用所在块来决定先后顺序,对于处在相同块的,用n来决定先后顺序. 复杂度的证明:对于右指针的每一块而言,它一定是单调递增的去移动,那么复杂
CodeForces - 935A Fafa and his Company [带修改莫队]
ACTerminate的博客
03-03 553
CodeForces - 935A Fafa and his Company [带修改莫队]
codeforces 700D 哈夫曼树 莫队
make_it_for_good的博客
08-19 962
题意：给一个长度为n的数列a，q组询问，每组询问求将li到ri的区间中的数哈夫曼编码的长度。莫队，对于每一个询问处理该区间内出现次数为x的字符个数。 对于次数小于n√\sqrt{n} 的字符，从小到大枚举出现次数，对于一种出现次数x两两配对，在x∗2x*2 插入x的个数/2。 对于出现次数大于n√\sqrt{n} 的字符，用构建哈夫曼树的方法处理。时间复杂度O(nn√logn)O(n
Codeforces 633H. Fibonacci-ish II (Mo's Algorithm(莫队算法) + 线段树 + 离散化)
岩之痕
03-10 2785
题意： 给定一个长度最大为3万的序列，和最多3万个询问，每个询问问某区间[L,R]里的数，去掉重复然后排序之后，依次乘上斐波那契数列然后求和，结果对m取余的值。 区间优化用Mo's Algorithm（莫队算法），莫队算法的Add和Remove中使用线段树，所以整体复杂度是O(n*sqrt(n)*log2(n)). 这题一路TLE，从TLE26到TLE27到TLE29到TLE35都快绝
Codeforces 765F Souvenirs - 莫队算法 - 链表 - 线段树
adx33526的博客
07-07 161
题目传送门 　　神速的列车 　　光速的列车 　　声速的列车 题目大意 　　给定一个长度为$n$的序列，$m$次询问区间$[l, r]$内相差最小的两个数的差的绝对值。 Solution 1 Mo's Algorithm & Linked List 　　不会。。果断莫队（orz mcfx，一讲“值域”链表就明白可以干什么了）。 　　当插入一个数的时候，如...
Codeforces-Solution
05-03
Codeforces是一个知名的在线编程竞赛平台，它吸引了众多程序员和编程爱好者参与解决各种算法问题，以提升编程技能和逻辑思维能力。"Codeforces-Solution"很可能是一个包含针对Codeforces上问题的解题代码库，主要...
PDF-CodeForces-Problems:PDF文件中的CodeForces问题
05-12
PDF-CodeForces问题 PDF文件中的CodeForces问题 利用CodeForces提取在这个库中的文件 ，文件夹名代表来自CodeForces网址contests`的ID，每个文件夹包含比赛的问题。 有关CodeForces竞赛的疯狂事实 CodeForces上有937...
leetcode卡-codeforces-stats:codeforces-stats
07-06
leetcode卡Codeforces 统计 一个工具可以帮助您显示 CF 统计信息。 灵感来自 . 范围 范围 默认 必需的 处理 空值 真的 贡献 错误的 错误的 朋友们 错误的 错误的 主题 默认 错误的 主题选择：默认、黑暗 例子 默认 ...
codeforces-cli：使用CLI的简单解析和检查工具，可解决来自Codeforce的问题
02-04
codeforces-cli 在python和bash中使用简单的解析和检查实现，以解决Codeforce中的竞赛。\ 安装 git clone " https://github.com/siddharth17196/codeforces-cli.git " cd codeforces-cli/scripts bash install.sh ...
Codeforces 840D 回滚莫队
neweryyy的博客
03-11 558
题意 传送门 Codeforces 840D Destiny 题解 区间中严格大于 (r−l+1)/k(r-l+1)/k(r−l+1)/k 的数不超过 k−1k-1k−1 个，维护区间最大的 k−1k-1k−1 个数即可。区间新增元素可以 O(k)O(k)O(k) 地维护最大的 k−1k-1k−1 个数，删除操作可能要使用基于值域维护的数据结构，效率不如新增操作。应用不带删除的回滚莫队即可，总时间复杂度 O(knn)O(kn\sqrt{n})O(knn​)。 #include <bits/stdc++
CF1000F One Occurrence___离线+线段树
生如夏花之绚烂
11-21 437
题目大意： 给出长度为nnn的序列aaa,mmm个询问，每次询问一段区间内仅出现了一次的数，多个则输出任意一个，否则输出0 n,m,ai<=5e5n,m,a_i<=5e5n,m,ai​<=5e5 分析： 将询问离线，限制询问左指针 考虑将所有数字当前对应的合法右端点区间处理出来 每次左端点右移的时候将其对应数字的合法区间更新 过程用线段树维护 对于线段树上任一节点对应区间，记录其能被覆盖的时候，覆盖他的区间的左端点，并对这个左端点取maxmaxmax，因为如果这个区间不合法，肯定是过了左端
Codeforces1000 F. One Occurrence（可持久化线段树）
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
09-17 254
题意： 给定长度为n的序列a， q组询问，每次询问给出[L,R]， 要求输出a[L,R]中任意一个只出现一次的数， 如果没有满足要求的数则输出-1。 数据范围：n,q<=5e5，a(i)<=5e5
CodeForces 1000F :One Occurrence 主席树
tlyzxc的博客
10-23 248
传送门 题意 分析 主席树进行区间维护 我们维护每一个位置上的数字，上一次出现的位置在哪里，只要区间有数字的lastlastlast小于左端点即可，主席树暴力维护 代码 #pragma GCC optimize(3) #include <bits/stdc++.h> #define debug(x) cout<<#x<<":"<<x<<endl; #define dl(x) printf("%lld\n",x); #define di(x) pr
One Occurrence CodeForces - 1000F （思维+主席树）
矮纸斜行闲作草
03-15 197
题目链接 题意：给定序列a ,q次询问 每次询问要求[l,r]区间任意一个只出现过一次的数 没有则输出0 。 分析：这题和这题十分类似， 我们先分析对于右端点固定的区间，求出[1,r]内任意的[l,r]区间只出现过一次的数。 我们用last[i]维护i上一次出现的位置，那么对于序列last[a[i]] （i映射成last[a[i]]）,我们查询[l,r]内是否存在只出现过一次的数就等价于last[a[i]]在[l,r]区间是否存在小于l的值， 根据贪心我们可以用线段树维护序列last[a[i]]的区间最小
Educational Codeforces Round 46 F. One Occurrence（主席树）
sancpp的博客
09-07 95
传送门 求任意一个区间中只出现一次的数 区间问题用主席树维护，对前缀建主席树。 主席树需要维护该元素上一次出现的位置， 如果[l,r]中元素上一次出现的位置小于l，则说明有解（并且解就是这个元素） 所以主席树需要维护区间最小值，顺带维护最小值出现的下标。 如果一个元素在区间中出现了很多次： eg:5,6,5,7,5,8 则元素5上一次出现的位置会不断被后面新出现的5更新。故答案是正确的。 每个版本相较于上一个版本：1.将此位置的值更改为last[i] 2.如果这个数之前出现过，则将last[i]这个位置重新
CodeForces 1000F One Occurrence（ 离线处理+线段树解法）
alpc_qleonardo
07-07 1117
大致题意：给你一个固定的数列a，然后q个询问，每个询问给出一个区间，问你区间内是否有恰好出现一次的数字，如果有输出任意一个，否则输出0。 这题主要方法就是仿照17年HDU多校有一道题的做法，HDU 6070。其实也只是用了其中的一个思想，也即用每一个数字把区间分段。对于每一个区间[1,r]中的最右边的一个数字i，我都可以记录一个pos[i]，表示数字i在区间[1,r]中上一个出现的位置。这里最右边指的是，同一个数字i，可能在区间中出现多次，最后那次是我们想要的。求出了这个pos，我们可以发
CodeForces 1000F One Occurrence（ 莫队解法）
alpc_qleonardo
07-07 699
题意就不再次陈述了…… 其实这题首先想到的还是用莫队伍去水过，但是这一水到也是学到了东西。首先说一说莫队的朴素做法。用一个set记录当前包含区间的出现次数为一次的数字，然后每次改变区间的时候维护每个数字出现的次数t[i]还有集合set，可以用unordered_set加速。但是即便如此还是TLE，而且不是一点。 分析原因。首先，用set的好处就是最后求解答案的时候很方便，只需要输出set里面随便一个数字即可，但区间变动频繁，即便使用了unordered_set，时间也会在
CodeForces - 982C 树形DP
最新发布
07-25
引用\[1\]中提到了一种树形动态规划的方法来解决CodeForces - 982C问题。在这个问题中，subtree指的是子连通块，而不是子树。为了使cnt_white - cnt_black尽可能大，可以使用两次树形动态规划来求解。第一次是自底...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值