HDU 4391 Paint The Wall（分块HASH||线段树）

转载请注明出处，谢谢http://blog.csdn.net/ACM_cxlove?viewmode=contents    by---cxlove 

题目：区间染色问题，询问区间内某种颜色的数量

http://acm.hdu.edu.cn/showproblem.php?pid=4391 

这题主要是难在颜色的数量非常多。

如果颜色少的话，可以维护多棵线段树，或者结点维护多个值(- -也许行吧，沉默

但是这题的颜色太多了，离散化之后上限是10^5，明显不行

然后就用线段树暴力吧，lazy之后肯定还是过不了

然后加一点优化，保存区间的最大值，最小值，在查询的时候优化一样

忘了加一句话，还是TLE，如果区间全部为同一种颜色，就不需要往下再查询，因为查询区间肯定包含在其中，肯定也为同色，貌似这样的话就是500ms左右

其实是数据水了，那种交替的数据肯定可以卡线段树

训练之后看了题解是分块HASH，完全不懂啊，搜了题解，照着搞吧

貌似用map还是比较慢，5000ms左右，这就是偷懒的坏处啊

分块HASH便是把区间分成sqrt(n)个区间，这样对两边进行暴力，中间的区间可以直接o(1)

平均应该是sqrt(n)的复杂度吧

#include<iostream>
#include<cstdio>
#include<map>
#include<cstring>
#include<cmath>
#include<vector>
#include<algorithm>
#include<set>
#include<string>
#include<queue>
#define inf 1<<30
#define M 2005
#define N 100005
#define maxn 300005
#define eps 1e-10
#define zero(a) fabs(a)<eps
#define Min(a,b) ((a)<(b)?(a):(b))
#define Max(a,b) ((a)>(b)?(a):(b))
#define pb(a) push_back(a)
#define mp(a,b) make_pair(a,b)
#define mem(a,b) memset(a,b,sizeof(a))
#define LL long long
#define lson step<<1
#define rson step<<1|1
#define MOD 1000000009
#define sqr(a) ((a)*(a))
#define Key_value ch[ch[root][1]][0]
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
struct HashBlock
{
    int size,col;
    map<int,int>m;
}a[400];
int n,q,c[N];
int len,cnt;
void Init()
{
    len=(int)sqrt(n+1e-8);
    cnt=(n-1)/len+1;
    for(int i=0;i<cnt;i++)
    {
        a[i].size=min(n,(i+1)*len)-i*len;
        a[i].col=-1;
        a[i].m.clear();
    }
    for(int i=0;i<n;i++)
    {
        scanf("%d",&c[i]);
        a[i/len].m[c[i]]++;
    }
}
void Push_Down(int step)
{
    if(a[step].col!=-1)
    {
        a[step].m.clear();
        for(int i=step*len;i<min((step+1)*len,n);i++)
        {
            c[i]=a[step].col;
            a[step].m[c[i]]++;
        }
        a[step].col=-1;
    }
}
void Update(int l,int r,int col)
{
    int la=l/len,ra=r/len;
    for(int i=la+1;i<ra;i++) a[i].col=col;
    if(la!=ra)
    {
        Push_Down(la);Push_Down(ra);
        for(int i=l;i<len*(1+la);i++)
        {
            a[la].m[c[i]]--;a[la].m[col]++;c[i]=col;
        }
        for(int i=ra*len;i<=r;i++)
        {
            a[ra].m[c[i]]--;a[ra].m[col]++;c[i]=col;
        }
    }
    else
    {
        Push_Down(la);
        for(int i=l;i<=r;i++)
        {
            a[la].m[c[i]]--;a[la].m[col]++;c[i]=col;
        }
    }
}
int Query(int l,int r,int col)
{
    int la=l/len,ra=r/len,ans=0;
    for(int i=la+1;i<ra;i++)
    {
        if(a[i].col==col) ans+=a[i].size;
        else if(a[i].col==-1&&a[i].m.find(col)!=a[i].m.end()) ans+=a[i].m[col];
    }
    if(la!=ra)
    {
        Push_Down(la);Push_Down(ra);
        for(int i=l;i<len*(la+1);i++)
        {
            ans+=c[i]==col;
        }
        for(int i=ra*len;i<=r;i++)
        {
            ans+=c[i]==col;
        }
    }
    else
    {
        Push_Down(la);
        for(int i=l;i<=r;i++) ans+=c[i]==col;
    }
    return ans;
}
int main()
{
    while(scanf("%d%d",&n,&q)!=EOF)
    {
        Init();
        while(q--)
        {
            int k,l,r,c;
            scanf("%d%d%d%d",&k,&l,&r,&c);
            if(k==1) Update(l,r,c);
            else printf("%d\n",Query(l,r,c));
        }
    }
    return 0;
}

另外下面是线段结的代码

#include<iostream>
#include<cstdio>
#include <queue>
#include<cstring>
#include<algorithm>
#define N 100005
#define lson step<<1
#define rson step<<1|1
#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))

using namespace std;
struct Node
{
    int left,right,c;
    int mx,mn;
}L[N*4];
int n,m,val[N];
void Push_Up(int step)
{
    L[step].mx=MAX(L[lson].mx,L[rson].mx);
    L[step].mn=MIN(L[lson].mn,L[rson].mn);
    if(L[lson].c==L[rson].c) L[step].c=L[lson].c;
    else L[step].c=-1;
}
void Push_Down(int step)
{
    L[lson].c=L[lson].mx=L[lson].mn=L[step].c;
    L[rson].c=L[rson].mx=L[rson].mn=L[step].c;
    L[step].c=-1;
}
void Bulid(int step,int l,int r)
{
    L[step].left=l;
    L[step].right=r;
    if(l==r)
    {
        L[step].mx=L[step].mn=L[step].c=val[l];
        return ;
    }
    int m=(l+r)/2;
    Bulid(lson,l,m);
    Bulid(rson,m+1,r);
    Push_Up(step);
}
void Update(int step,int l,int r,int c)
{
    if(L[step].left==l&&r==L[step].right)
    {
        L[step].c=L[step].mx=L[step].mn=c;
        return;
    }
    if(L[step].c!=-1) Push_Down(step);
    int m=(L[step].left+L[step].right)/2;
    if(r<=m) Update(lson,l,r,c);
    else if(l>m) Update(rson,l,r,c);
    else
    {
        Update(lson,l,m,c);
        Update(rson,m+1,r,c);
    }
    Push_Up(step);
}
int Query(int step,int l,int r,int c)
{
    if(L[step].mx<c||L[step].mn>c) return 0;
    if(L[step].left==L[step].right) return L[step].c==c?1:0;
    //if(L[step].c!=-1) Push_Down(step);
    if(L[step].c!=-1) return (L[step].c==c)?(r-l+1):0;
    if(L[step].left==l&&L[step].right==r)
    {
        if(L[step].c!=-1) return (L[step].c==c)?(L[step].right-L[step].left+1):0;
    }
    int m=(L[step].left+L[step].right)/2;
    if(r<=m) return Query(lson,l,r,c);
    else if(l>m) return Query(rson,l,r,c);
    else return Query(lson,l,m,c)+Query(rson,m+1,r,c);
}
inline void scanf_(int &num){
    char in;
    bool neg=false;
    while(((in=getchar()) > '9' || in<'0') && in!='-') ;
    if(in=='-'){
        neg=true;
        while((in=getchar()) >'9' || in<'0');
    }
    num=in-'0';
    while(in=getchar(),in>='0'&&in<='9')
        num*=10,num+=in-'0';
    if(neg)
        num=0-num;
}
inline void printf_(int num){
    bool flag=false;
    if(num<0){
        putchar('-');
        num=-num;
    }
    int ans[10],top=0;
    while(num!=0){
        ans[top++]=num%10;
        num/=10;
    }
    if(top==0)
        putchar('0');
    for(int i=top-1;i>=0;i--){
        char ch=ans[i]+'0';
        putchar(ch);
    }
    putchar('\n');
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(int i=0;i<n;i++) scanf_(val[i]);
        Bulid(1,0,n-1);
        while(m--)
        {
            int k,l,r,c;
            scanf_(k);scanf_(l);scanf_(r);scanf_(c);
            if(k==1) Update(1,l,r,c);
            else printf_(Query(1,l,r,c));
        }
    }
    return 0;
}