牛客网 暑期ACM多校训练营（第一场）J.Different Integers-区间两侧不同数字的个数-离线树状数组 or 可持久化线段树(主席树)

J.Different Integers

题意就是给你l,r，问你在区间两侧的[1,l]和[r,n]中，不同数的个数。

两种思路:

1.将数组长度扩大两倍,for(int i=n+1;i<=2*n;i++) a[i]=a[i-n]；就可以将两个分开的区间合并成一个区间[r,l+n]，然后就可以通过主席树求解，套模板就可以了。

但是用主席树有风险，容易写超时，超内存，只能通过50%，初始化数组memset少写一个就过了，而且while(scanf("%d%d",&n,&m)==2)要写成这样，我赛后试了一下while(~scanf("%d%d",&n,&m))，过不了，只能过50%，所以主席树正好卡过去。

代码:

 //J-主席树刚好卡过
 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<vector>
 #include<algorithm>
 #include<cmath>
 #include<cstdlib>
 #include<queue>
 using namespace std;
 const int maxn=*1e5+;

 struct Node
 {
     int l,r,sum;

 }p[maxn*];
 int la[maxn],a[maxn],root[maxn];
 int n,q,cnt;

 int build(int l,int r)
 {
     int nc=++cnt;
     p[nc].sum=;
     p[nc].l=p[nc].r=;
     if(l==r){
         return nc;
     }

     int m=l+r>>;
     p[nc].l=build(l,m);
     p[nc].r=build(m+,r);
     return nc;
 }
 int update(int pos,int c,int v,int l,int r)
 {
     int nc=++cnt;
     p[nc]=p[c];
     p[nc].sum+=v;
     if(l==r){
         return nc;
     }

     int m=l+r>>;
     if(m>=pos)
         p[nc].l=update(pos,p[c].l,v,l,m);
     else
         p[nc].r=update(pos,p[c].r,v,m+,r);
     return nc;
 }
 int query(int pos,int c,int l,int r)
 {
     if(l==r) return p[c].sum;
     int m=l+r>>;
     if(m>=pos)
         return p[p[c].r].sum + query(pos,p[c].l,l,m);
     else
         return query(pos,p[c].r,m+,r);
 }
 int main()
 {
     while(scanf("%d%d",&n,&q)==){
         memset(la,-,sizeof(la));
         cnt=;
         for (int i=;i<=n;i++){
             scanf("%d",a+i);
         }
         for(int i=n+;i<=*n;i++)
             a[i]=a[i-n];
         n=n*;
         root[]=build(,n);
         for (int i=;i<=n;i++){
             int v=a[i];
             if(la[v]==-)
                 root[i]=update(i,root[i-],,,n);
             else{
                 int t=update(la[v],root[i-],-,,n);
                 root[i]=update(i,t,,,n);
             }
             la[v]=i;
         }
         while(q--){
             int x,y;
             scanf("%d%d",&x,&y);
             printf("%d\n",query(y,root[n/+x],,n));
         }
     }
 }

2.叉姐官方题解思路是树状数组，离线按照 r 从小到大处理询问，考虑没出现的数字个数，假设 r = last[x]，那么当 l < first[x] 时，x 没出现，用树状数组维护即可。

唉，真的是长的帅又厉害代码写的还优美，代码写的真的是好看，羡慕(✧◡✧)

代码:(叉姐代码)

 #include <bits/stdc++.h>

 struct Query
 {
     int l, r, id;
 };

 bool operator < (const Query& u, const Query& v)
 {
     return u.r < v.r;
 }

 int main()
 {
     int n, q;
     while (scanf("%d%d", &n, &q) == ) {
         std::vector<int> a(n), first(n, -), last(n);
         int total = ;
         for (int i = ; i < n; ++ i) {
             scanf("%d", &a[i]);
             a[i] --, last[a[i]] = i;
             if (first[a[i]] == -) {
                 total ++, first[a[i]] = i;
             }
         }
         std::vector<Query> queries;
         for (int i = , l, r; i < q; ++ i) {
             scanf("%d%d", &l, &r);
             queries.push_back(Query {l - , r - , i});
         }
         std::sort(queries.begin(), queries.end());
         std::vector<int> count(n), result(q);
         for (int i = , k = ; i < n; ++ i) {
             while (k < q && queries[k].r == i) {
                 int& ref = result[queries[k].id] = total;
                 for (int j = queries[k].l; j < n; j += ~j & j + ) {
                     ref -= count[j];
                 }
                 k ++;
             }
             if (last[a[i]] == i) {
                 for (int j = first[a[i]] - ; ~j; j -= ~j & j + ) {
                     count[j] ++;
                 }
             }
         }
         for (int i = ; i < q; ++ i) {
             printf("%d\n", result[i]);
         }
     }
 }

自己改了一下叉姐代码加了一点注释的代码:

 //J-离线树状数组处理
 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<cmath>
 #include<algorithm>
 #include<queue>
 #include<map>
 #include<vector>
 using namespace std;
 const int maxn=1e5+;
 const int inf=0x3f3f3f3f;
 const double eps=1e-;
 struct node
 {
     int l,r,id;
     bool operator< (const node &a) const{   //结构体内嵌比较函数
         return r<a.r;
     }
 };
 int main()
 {
     int n,q;
     while(~scanf("%d%d",&n,&q)){
         vector<int>a(n),first(n, -),last(n);
         int total=;
         for (int i=;i<n;i++){
             scanf("%d",&a[i]);
             a[i]--,last[a[i]]=i;//记录元素最后出现的位置
             if(first[a[i]]==-){//如果元素之前未出现，则记录第一次出现的位置
                 total++；
                 first[a[i]]=i;
             }
         }
         vector<node> queries;
         for (int i=;i<q;i++) {
             int l,r;
             scanf("%d%d",&l,&r);
             queries.push_back(node {l-,r-,i});//将区间和id存到容器内
         }
         sort(queries.begin(),queries.end());//区间右边界升序排序(结构体内内嵌了比较函数)
         vector<int>count(n),result(q);
         for (int i=,k=;i<n;i++){//树状数组维护
             while(k<q&&queries[k].r==i){
                 int &ref=result[queries[k].id]=total;
                 for(int j=queries[k].l;j<n;j+=~j&j+){//~j&j+1 +的优先级比&高
                     ref-=count[j];
                 }
                 k++;
             }
             if(last[a[i]]==i){
                 for(int j=first[a[i]]-;~j;j-=~j&j+){
                     count[j]++;//统计没有出现过的元素个数
                 }
             }
         }
         for (int i=;i<q;i++) {
             printf("%d\n",result[i]);
         }
     }
 }

讲道理，我是真的菜，难受。