洛谷P3939 cdqz多校联训 数颜色

题目描述

小 C 的兔子不是雪白的，而是五彩缤纷的。每只兔子都有一种颜色，不同的兔子可能有 相同的颜色。小 C 把她标号从 1 到 nn 的 nn 只兔子排成长长的一排，来给他们喂胡萝卜吃。 排列完成后，第 ii 只兔子的颜色是 a_iai​。

俗话说得好，“萝卜青菜，各有所爱”。小 C 发现，不同颜色的兔子可能有对胡萝卜的 不同偏好。比如，银色的兔子最喜欢吃金色的胡萝卜，金色的兔子更喜欢吃胡萝卜叶子，而 绿色的兔子却喜欢吃酸一点的胡萝卜……为了满足兔子们的要求，小 C 十分苦恼。所以，为 了使得胡萝卜喂得更加准确，小 C 想知道在区间 [l_j,r_j][lj​,rj​] 里有多少只颜色为 c_jcj​ 的兔子。

不过，因为小 C 的兔子们都十分地活跃，它们不是很愿意待在一个固定的位置；与此同 时，小 C 也在根据她知道的信息来给兔子们调整位置。所以，有时编号为 x_jxj​ 和 x_j+1xj​+1 的两 只兔子会交换位置。 小 C 被这一系列麻烦事给难住了。你能帮帮她吗？

输入输出格式

输入格式：

 

从标准输入中读入数据。 输入第 1 行两个正整数 nn , mm 。

输入第 2 行 nn 个正整数，第 ii 个数表示第 ii 只兔子的颜色 a_iai​ 。

输入接下来 mm 行，每行为以下两种中的一种：

• “ 1\ l_j\ r_j\ c_j1 lj​ rj​ cj​ ” ：询问在区间 [l_j,r_j][lj​,rj​] 里有多少只颜色为 c_jcj​ 的兔子；

• “ 2\ x_j2 xj​ ”： x_jxj​ 和 x_j+1xj​+1 两只兔子交换了位置。

 

输出格式：

 

输出到标准输出中。

对于每个 1 操作，输出一行一个正整数，表示你对于这个询问的答案。

输入输出样例

输入样例：

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

输出样例：

1 
2 
2 
3 

这道题大概有两个解法

首先我们看到颜色的出现次数，我们可以考虑直接线段树或者主席树（主席树由于常数卡得比较厉害，只有90分左右）。

我们以颜色为根建立线段树，每一个颜色建立一颗线段树，线段树中的区间和表示这个颜色在这个区间的出现次数。

在建树的时候一边二分一边修改区间的值，这样就可以保证所有包含某个位置的大区间都会加上当前位置的出现次数

我们在查询的时候直接区间加法就好。

修改操作也很简单，在需要修改的两个节点的颜色的根节点上，将原来颜色所在的位置包含的区间减去1，然后把调换后的位置加上1，就可以A掉

注意空间和时间的问题，要动态开节点。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm> 
const int MAXN=3e5+5;
using namespace std;
int w[MAXN];
class Node 
{
    public:
        int ls;
        int rs;
        int sum;
        void update(void);
}node[MAXN<<5];
int root[MAXN<<5]; 
int tot;
void Node::update(void)
{
    sum=node[ls].sum+node[rs].sum;
}
void modify(int &nd,int l,int r,const int pos,int delta)
{
    if(!nd) nd=++tot;
    node[nd].sum+=delta;
    if(l==r)
    	return;
    int mid=(l+r)>>1;
    if(pos<=mid)
    {    
    	modify(node[nd].ls,l,mid,pos,delta);
    }
    else
    {
    	modify(node[nd].rs,mid+1,r,pos,delta);
    }
    return;
}
int query(int nd,int l,int r,const int L,const int R)
{
    if(!nd) return 0;
    if(L<=l&&R>=r)
    {
        return node[nd].sum;
    } 
    int mid=(l+r)>>1;
    long long ans=0;
    if(L<=mid)
    {
        ans=query(node[nd].ls,l,mid,L,R);
    }
    if(R>mid)
    {
        ans+=query(node[nd].rs,mid+1,r,L,R);		
    }
    return ans;
}
void SWAP(int& a, int& b) 
{
    a = a^b;
    b = a^b;
    a = a^b;
}
int main()
{
    //std::freopen("color.in","r",stdin);
    //std::freopen("color.out","w",stdout);
    int n,q;
    std::scanf("%d%d",&n,&q);
    for(int i=1;i<=n;i++)
    {
        std::scanf("%d",w+i);
        modify(root[w[i]],1,n,i,1);
    }
    while(q--)
    {
        int opt;
        std::scanf("%d",&opt);
        if(opt==1)
        {
            int l;
            int r;
            int c;
            std::scanf("%d%d%d",&l,&r,&c);
            std::printf("%d\n",query(root[c],1,n,l,r));
        }
        else
        {
            int x;
            std::scanf("%d",&x);
            int y=w[x];
            int z=w[x+1];
            SWAP(w[x],w[x+1]);
            modify(root[y],1,n,x,-1);			
            modify(root[y],1,n,x+1,1);
            modify(root[z],1,n,x,1);
            modify(root[z],1,n,x+1,-1);
        }
    }
    return 0;
}

以上解法虽然看似简单但是细节很麻烦，而且很没有必要，换句话说就是数据结构学傻了的写法.....->_->

因为数据比较小，我们可以直接针对每个颜色开一个vector记录其出现的位置，因为颜色的出现有序，所以每个颜色的vector中存在的数字肯定是有序的，二分一下用upper_bound和lower_bound想减就好

修改的时候直接交换其位置就可以过掉....这个解法好想而且简单.........相比之下写主席树半天写挂了的我感到非常的2...

#include<vector>
#include<cstdio>
#include<algorithm>
const int MAXN=3e5+5;
int a[MAXN];
std::vector<int>G[MAXN];
int main()
{
    //std::freopen("color.in","r",stdin);
    //std::freopen("color.out","w",stdout);
    int n,m;
    std::scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        std::scanf("%d",a+i);
        G[a[i]].push_back(i);
    }
    while(m--)
    {
        int opt;
        std::scanf("%d",&opt);
        if(opt==1)
        {
            int l,r,c;
            std::scanf("%d%d%d",&l,&r,&c);
            /*
            int p1=std::lower_bound(G[c].begin(),G[c].end(),l)-G[c];
            int p2=std::upper_bound(G[c].begin(),G[c].end(),r)-G[c];
            */
            int ans=(int)(upper_bound(G[c].begin(),G[c].end(),r)-lower_bound(G[c].begin(),G[c].end(),l));
            std::printf("%d\n",ans);
        }
        else 
        {
            int x;
            std::scanf("%d",&x);
            if (a[x]!=a[x+1]) 
            {
                (*std::lower_bound(G[a[x]].begin(),G[a[x]].end(),x))++;
                (*std::lower_bound(G[a[x+1]].begin(),G[a[x+1]].end(),x+1))--;
                std::swap(a[x],a[x + 1]);
            }
        }
    }
    return 0;
}