HDU-4419-Colourful Rectangle(线段树)

最新推荐文章于 2019-01-18 20:01:19 发布
最新推荐文章于 2019-01-18 20:01:19 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： 线段树&树状数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/faithdmc/article/details/39544813
版权
Problem Description
We use Red, Green and Blue to make new colours. See the picture below:


Now give you n rectangles, the colour of them is red or green or blue. You have calculate the area of 7 different colour. (Note: A region may be covered by same colour several times, but it’s final colour depends on the kinds of different colour)
 

Input
The first line is an integer T(T <= 10), the number of test cases. The first line of each case contains a integer n (0 < n <= 10000), the number of rectangles. Then n lines follows. Each line start with a letter C(R means Red, G means Green, B means Blue) and four integers x1, y1, x2, y2(0 <= x1 < x2 < 10^9, 0 <= y1 < y2 < 10^9), the left-bottom's coordinate and the right-top's coordinate of a rectangle.
 

Output
For each case, output a line "Case a:", a is the case number starting from 1,then 7 lines, each line contain a integer, the area of each colour. (Note: You should print the areas as the order: R, G, B, RG, RB, GB, RGB).
 

Sample Input 
  
  

   
   3
2
R 0 0 2 2
G 1 1 3 3 
3
R 0 0 4 4
G 2 0 6 4
B 0 2 6 6
3
G 2 0 3 8
G 1 0 6 1
B 4 2 7 7
 

Sample Output 
  
  

   
   Case 1:
3
3
0
1
0
0
0
Case 2:
4
4
12
4
4
4
4
Case 3:
0
12
15
0
0
0
0
 

Source
2012 ACM/ICPC Asia Regional Hangzhou Online
 

思路：维护区间R,G,B三种颜色的数量，更新时判断区间的组合颜色，再考虑与左右儿子的颜色组合的情况。 

#include <cstdio>
#include <map>
#include <cmath>
#include <algorithm>
using namespace std;

map<int,int>ii;

struct S{
int r,g,b;
int cr,cg,cb,crg,crb,cgb,crgb;
}node[200000];

struct L{
int pos,l,r,type,flag;

bool operator<(const L &p) const
{
    return pos<p.pos;
}

}line[20005];

int lisan[20005],vv[20005];

void build(int idx,int s,int e)
{
    node[idx].r=node[idx].g=node[idx].b=0;

    node[idx].cr=node[idx].cg=node[idx].cb=node[idx].crg=node[idx].crb=node[idx].cgb=node[idx].crgb=0;

    if(s!=e)
    {
        int mid=(s+e)>>1;

        build(idx<<1,s,mid);
        build(idx<<1|1,mid+1,e);
    }
}

void pop(int idx,int s,int e)
{
    node[idx].cr=0;
    node[idx].cg=0;
    node[idx].cb=0;
    node[idx].crg=0;
    node[idx].crb=0;
    node[idx].cgb=0;
    node[idx].crgb=0;

    if(node[idx].r && node[idx].g && node[idx].b)
    {
        node[idx].crgb+=node[idx<<1].cr+node[idx<<1|1].cr;
        node[idx].crgb+=node[idx<<1].cg+node[idx<<1|1].cg;
        node[idx].crgb+=node[idx<<1].cb+node[idx<<1|1].cb;
        node[idx].crgb+=node[idx<<1].crg+node[idx<<1|1].crg;
        node[idx].crgb+=node[idx<<1].crb+node[idx<<1|1].crb;
        node[idx].crgb+=node[idx<<1].cgb+node[idx<<1|1].cgb;
        node[idx].crgb+=node[idx<<1].crgb+node[idx<<1|1].crgb;

        node[idx].crgb+=vv[e]-vv[s-1]-node[idx].cr-node[idx].cg-node[idx].cb-node[idx].crg-node[idx].crb-node[idx].cgb-node[idx].crgb;
    }

    if(!node[idx].r && node[idx].g && node[idx].b)
    {
        node[idx].crgb+=node[idx<<1].cr+node[idx<<1|1].cr;
        node[idx].cgb+=node[idx<<1].cg+node[idx<<1|1].cg;
        node[idx].cgb+=node[idx<<1].cb+node[idx<<1|1].cb;
        node[idx].crgb+=node[idx<<1].crg+node[idx<<1|1].crg;
        node[idx].crgb+=node[idx<<1].crb+node[idx<<1|1].crb;
        node[idx].cgb+=node[idx<<1].cgb+node[idx<<1|1].cgb;
        node[idx].crgb+=node[idx<<1].crgb+node[idx<<1|1].crgb;

        node[idx].cgb+=vv[e]-vv[s-1]-node[idx].cr-node[idx].cg-node[idx].cb-node[idx].crg-node[idx].crb-node[idx].cgb-node[idx].crgb;
    }

    if(node[idx].r && !node[idx].g && node[idx].b)
    {
        node[idx].crb+=node[idx<<1].cr+node[idx<<1|1].cr;
        node[idx].crgb+=node[idx<<1].cg+node[idx<<1|1].cg;
        node[idx].crb+=node[idx<<1].cb+node[idx<<1|1].cb;
        node[idx].crgb+=node[idx<<1].crg+node[idx<<1|1].crg;
        node[idx].crb+=node[idx<<1].crb+node[idx<<1|1].crb;
        node[idx].crgb+=node[idx<<1].cgb+node[idx<<1|1].cgb;
        node[idx].crgb+=node[idx<<1].crgb+node[idx<<1|1].crgb;

        node[idx].crb+=vv[e]-vv[s-1]-node[idx].cr-node[idx].cg-node[idx].cb-node[idx].crg-node[idx].crb-node[idx].cgb-node[idx].crgb;
    }

    if(node[idx].r && node[idx].g && !node[idx].b)
    {
        node[idx].crg+=node[idx<<1].cr+node[idx<<1|1].cr;
        node[idx].crg+=node[idx<<1].cg+node[idx<<1|1].cg;
        node[idx].crgb+=node[idx<<1].cb+node[idx<<1|1].cb;
        node[idx].crg+=node[idx<<1].crg+node[idx<<1|1].crg;
        node[idx].crgb+=node[idx<<1].crb+node[idx<<1|1].crb;
        node[idx].crgb+=node[idx<<1].cgb+node[idx<<1|1].cgb;
        node[idx].crgb+=node[idx<<1].crgb+node[idx<<1|1].crgb;

        node[idx].crg+=vv[e]-vv[s-1]-node[idx].cr-node[idx].cg-node[idx].cb-node[idx].crg-node[idx].crb-node[idx].cgb-node[idx].crgb;
    }

    if(node[idx].r && !node[idx].g && !node[idx].b)
    {
        node[idx].cr+=node[idx<<1].cr+node[idx<<1|1].cr;
        node[idx].crg+=node[idx<<1].cg+node[idx<<1|1].cg;
        node[idx].crb+=node[idx<<1].cb+node[idx<<1|1].cb;
        node[idx].crg+=node[idx<<1].crg+node[idx<<1|1].crg;
        node[idx].crb+=node[idx<<1].crb+node[idx<<1|1].crb;
        node[idx].crgb+=node[idx<<1].cgb+node[idx<<1|1].cgb;
        node[idx].crgb+=node[idx<<1].crgb+node[idx<<1|1].crgb;

        node[idx].cr+=vv[e]-vv[s-1]-node[idx].cr-node[idx].cg-node[idx].cb-node[idx].crg-node[idx].crb-node[idx].cgb-node[idx].crgb;
    }

    if(!node[idx].r && node[idx].g && !node[idx].b)
    {
        node[idx].crg+=node[idx<<1].cr+node[idx<<1|1].cr;
        node[idx].cg+=node[idx<<1].cg+node[idx<<1|1].cg;
        node[idx].cgb+=node[idx<<1].cb+node[idx<<1|1].cb;
        node[idx].crg+=node[idx<<1].crg+node[idx<<1|1].crg;
        node[idx].crgb+=node[idx<<1].crb+node[idx<<1|1].crb;
        node[idx].cgb+=node[idx<<1].cgb+node[idx<<1|1].cgb;
        node[idx].crgb+=node[idx<<1].crgb+node[idx<<1|1].crgb;

        node[idx].cg+=vv[e]-vv[s-1]-node[idx].cr-node[idx].cg-node[idx].cb-node[idx].crg-node[idx].crb-node[idx].cgb-node[idx].crgb;
    }

    if(!node[idx].r && !node[idx].g && node[idx].b)
    {
        node[idx].crb+=node[idx<<1].cr+node[idx<<1|1].cr;
        node[idx].cgb+=node[idx<<1].cg+node[idx<<1|1].cg;
        node[idx].cb+=node[idx<<1].cb+node[idx<<1|1].cb;
        node[idx].crgb+=node[idx<<1].crg+node[idx<<1|1].crg;
        node[idx].crb+=node[idx<<1].crb+node[idx<<1|1].crb;
        node[idx].cgb+=node[idx<<1].cgb+node[idx<<1|1].cgb;
        node[idx].crgb+=node[idx<<1].crgb+node[idx<<1|1].crgb;

        node[idx].cb+=vv[e]-vv[s-1]-node[idx].cr-node[idx].cg-node[idx].cb-node[idx].crg-node[idx].crb-node[idx].cgb-node[idx].crgb;
    }

    if(!node[idx].r && !node[idx].g && !node[idx].b)//别漏了这个
    {
        node[idx].cr+=node[idx<<1].cr+node[idx<<1|1].cr;
        node[idx].cg+=node[idx<<1].cg+node[idx<<1|1].cg;
        node[idx].cb+=node[idx<<1].cb+node[idx<<1|1].cb;
        node[idx].crg+=node[idx<<1].crg+node[idx<<1|1].crg;
        node[idx].crb+=node[idx<<1].crb+node[idx<<1|1].crb;
        node[idx].cgb+=node[idx<<1].cgb+node[idx<<1|1].cgb;
        node[idx].crgb+=node[idx<<1].crgb+node[idx<<1|1].crgb;
    }
}

void update(int idx,int s,int e,int l,int r,int val,int flag)
{
    if(l==s && r==e)
    {
        switch(val)
        {
            case 1:node[idx].r+=flag;break;
            case 2:node[idx].g+=flag;break;
            case 3:node[idx].b+=flag;break;
        }

        pop(idx,s,e);
    }
    else
    {
        int mid=(s+e)>>1;

        if(r<=mid) update(idx<<1,s,mid,l,r,val,flag);
        else if(l>mid) update(idx<<1|1,mid+1,e,l,r,val,flag);
        else
        {
            update(idx<<1,s,mid,l,mid,val,flag);
            update(idx<<1|1,mid+1,e,mid+1,r,val,flag);
        }

        pop(idx,s,e);
    }
}

int main()
{
    int T,n,i,cnt,x1,y1,x2,y2,num,last,cases=1;
    long long ar,ag,ab,arg,arb,agb,argb;
    char s[5];

    scanf("%d",&T);

    while(T--)
    {
        ii.clear();

        ar=ag=ab=arg=arb=agb=argb=0;

        scanf("%d",&n);

        cnt=0;

        num=0;

        while(n--)
        {
            scanf("%s%d%d%d%d",s,&x1,&y1,&x2,&y2);

            if(!ii[y1]) lisan[num++]=y1,ii[y1]=1;
            if(!ii[y2]) lisan[num++]=y2,ii[y2]=1;

            line[cnt].pos=x1;
            line[cnt].l=y1;
            line[cnt].r=y2;

            line[cnt+1].pos=x2;
            line[cnt+1].l=y1;
            line[cnt+1].r=y2;

            if(s[0]=='R')
            {
                line[cnt].flag=1;
                line[cnt++].type=1;
                line[cnt].flag=-1;
                line[cnt++].type=1;
            }
            else if(s[0]=='G')
            {
                line[cnt].flag=1;
                line[cnt++].type=2;
                line[cnt].flag=-1;
                line[cnt++].type=2;
            }
            else
            {
                line[cnt].flag=1;
                line[cnt++].type=3;
                line[cnt].flag=-1;
                line[cnt++].type=3;
            }
        }

        sort(line,line+cnt);
        sort(lisan,lisan+num);

        for(i=0;i<num;i++)
        {
            ii[lisan[i]]=i+1;
            vv[i]=lisan[i];
        }

        build(1,1,num);

        for(i=0;i<cnt;i++)
        {
            if(i)
            {
                ar+=(long long)(line[i].pos-last)*(node[1].cr);
                ag+=(long long)(line[i].pos-last)*(node[1].cg);
                ab+=(long long)(line[i].pos-last)*(node[1].cb);
                arg+=(long long)(line[i].pos-last)*(node[1].crg);
                arb+=(long long)(line[i].pos-last)*(node[1].crb);
                agb+=(long long)(line[i].pos-last)*(node[1].cgb);
                argb+=(long long)(line[i].pos-last)*(node[1].crgb);
            }

            update(1,1,num,ii[line[i].l],ii[line[i].r]-1,line[i].type,line[i].flag);

            last=line[i].pos;
        }

        printf("Case %d:\n",cases++);

        printf("%I64d\n",ar);
        printf("%I64d\n",ag);
        printf("%I64d\n",ab);
        printf("%I64d\n",arg);
        printf("%I64d\n",arb);
        printf("%I64d\n",agb);
        printf("%I64d\n",argb);
    }
}
「已注销」
关注
专栏目录
HDU-1828(扫描线+线段树)
qq_44641782的博客
01-13 365
Problem Description A number of rectangular posters, photographs and other pictures of the same shape are pasted on a wall. Their sides are all vertical or horizontal. Each rectangle can be partially ...
HDU---4819：Mosaic【二维线段树】
KobeDuu
05-21 329
题意： 给定一个Ｎ＊Ｎ的矩阵，每个格子都有一个数，再给出Ｑ个询问，每次询问以（ｘ，ｙ）为中心的边长为Ｌ的正方形矩阵中的最大值和最小值，并修改（ｘ，ｙ）的值为（ＭＡＸ＋ＭＩＮ）／２ 分析： １）四叉树 对于查询矩阵的最值＋修改问题，考虑二维线段树，参照一维线段树的写法：每次将区间二分成两个子区间，对应矩阵应对Ｘ，Ｙ同时二分，也就是４个子矩阵，即左上、右上、左下，右下四部分，所以要建一颗四叉树...
HDU 4419 Colourful Rectangle（12年杭州 线段树+离散化+扫描线）
窝不是爱酱,喵~~~~
09-24 2357
转载请注明出处，谢谢http://blog.csdn.net/acm_cxlove/article/details/7854526       by---cxlove  题目：给出3种颜色，重叠会生成新的颜色，然后有一些矩形，求出每种颜色的面积 http://acm.hdu.edu.cn/showproblem.php?pid=4419  很明显的矩形面积并，线段树+离散化+扫描线，
HDU 4419 Colourful Rectangle (线段树扫描线)
fcbruce
09-24 1941
题意： 给出R，G，B三种颜色的矩形的数据，求最后7种颜色(R,G,B,RG,RB,GB,RGB)的面积是多少？ 分析： 显然的线段树扫描线，可以说这题非常考验对线段树扫描线的理解，如果只会用模板，恐怕很难做出来。 R，G，B三种颜色最后会产生7种颜色(无色不算)，可以预见本题对编码质量要求相当之高。 update()操作和一般的线段树扫描线并无太大的不同，本题的精髓在于query()！ 一般的简单扫描线甚至不用写query，因为根结点维护的区间覆盖长度就是我们所需要的。但是本题需要从复杂的信息中分出7种信
hdu 4419 Colourful Rectangle
Go.To.AC的专栏
09-26 570
题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=4419 题目大意:      给定n个矩形,矩形的长平行于x轴,宽平行于y轴,每个矩形的颜色可能是R,G或B,矩形可能重叠,如果R和G(或G,R)重叠变为RG,如果三色重叠就是RGB,求所有颜色块(R,G,B,RG,RB,GB,RGB)的面积. 题目思路:      很容易想到扫
HDU 4419 Colourful Rectangle 扫描线
九野的博客
01-30 1204
题目链接：点击打开链接 题意:给定由红绿蓝组成的一些矩阵 输出每种颜色对应的面积。 思路： 如果颜色只有一种就是扫描线。 这里先求出包含各类颜色的面积，然后容斥一下得到答案。 画个图就能快速得到答案了 #include #include #include #include #include #include #include using namespace std; t
hdu - 4419 - Colourful Rectangle - 线段树
Julyana_Lin_夜
10-29 547
求http://acm.hdu.edu.cn/showproblem.php?pid=4419 求不同颜色的覆盖面积。 #include #include #include using namespace std; typedef __int64 lld; #define lson l,m,rt<<1 #define rson m+1,r,rt<<1|1 const int max
HDU-2000-2099.rar_hdu
09-19
这个名为"HDU-2000-2099.rar_hdu"的压缩包包含了该平台从2000到2099共100道题目的源代码。这些题目涵盖了初级到高级的各种算法，对于学习和提升编程技能非常有帮助。 首先，我们来看看这些题目可能涉及到的基础知识...
HDU-2000-2099.zip_hdu2000
09-23
【标题】"HDU-2000-2099.zip_hdu2000" 是一个包含杭电（Hangzhou Dianzi University）ACM竞赛题目解题报告的压缩包，覆盖了编号从2000到2099的题目。这个资源对于学习算法、提高编程技巧以及准备ACM/ICPC（国际大学...
HDU-GO-crx插件
04-02
HDU-GO是一款专为杭州电子科技大学（HDU）学生设计的Chrome浏览器插件，它极大地简化了学生的选课流程并提供了多项实用功能。这款插件以中文简体界面呈现，便于国内用户使用，尤其对杭电的学生来说，是他们日常学习...
Hdu 4419 Colourful Rectangle(矩形颜色交)
_zidaoziyan的博客
09-13 480
传送门:Hdu 4419 Colourful Rectangle 题意:给你10000个三种颜色的矩形，不同颜色的矩形相互覆盖会形成不同的颜色，问形成的七种颜色的面积是多少。 思路:很显然,一种颜色的时候是很容易解决的(面积并) 两种颜色或以上的时候,我们可以在线段树的每个节点开三个标记(表示对应区间的某一种颜色是否出现) 利用二进制状态维护线段树中的面积交 后面利用容斥减
HDU4419 Colourful Rectangle(矩形面积并+线段树)
fire__ice的专栏
04-09 801
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4419 解析：跟一般矩形面积并有一点的区别，就是每条线的状态要用一个数组来维护，这里的depth[ i ] 表示当前状态第i中颜色的已覆盖的长度，三种基本颜色可以分别用1，2，4表示，然后通过二进制运算得到其他颜色的标号，其他也没什么了。 参考代码： #include #include #incl
hdu 4419 Colourful Rectangle 杭州赛区 1010 （解题报告）
CSUST_ACM的专栏
09-25 1996
杭州赛区最后一题。。。。 最近看线段树还是有收获的·~~~ #include #include #include #include #define ls rt<<1 #define rs rt<<1|1 #define lson l,m,ls #define rson m+1,r,rs #define sf scanf #define pf printf using
hdu-4419-Colourful Rectangle-线段树求面积并
青竹梦
06-10 932
这道题目很有意思，写的麻烦了，估计得写很长时间。 幸好，我一开始就想出来了比较简单的方法。。。 利用位运算，把颜色RGB分别用1,2,4,表示。 那么就可以根据当前区间的状态来求当前区间每一种状态的长度了。 #include #include #include #include #include #include #include #include #pragma comment(link
Colourful Rectangle【扫描线】
既然弱小，就只顾变强就是了
01-18 259
We use Red, Green and Blue to make new colours. See the picture below:  Now give you n rectangles, the colour of them is red or green or blue. You have calculate the area of 7 different colour. (N...
hdu 4419
寂斜
08-02 354
Colourful Rectangle Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1165    Accepted Submission(s): 463 Problem Description We use
HDU-4947-GCD Array(树状数组+莫比乌斯反演)
青春无悔
08-18 2020
Problem Description Teacher Mai finds that many problems about arithmetic function can be reduced to the following problem: Maintain an array a with index from 1 to l. There are two kinds of ope
POJ-2528-Mayor's posters(线段树)
青春无悔
07-04 1714
Description The citizens of Bytetown, AB, could not stand that the candidates in the mayoral election campaign have been placing their electoral posters at all places at their whim. The city counci
RMQ with Shifts(线段树单点跟新)
青春无悔
03-16 1634
Problem Description In the traditional RMQ (Range Minimum Query) problem, we have a static array A. Then for each query (L, R) (L In this problem, the array A is no longer static: we need to suppo
A - LOOPS HDU - 3853
最新发布
07-28
回答: 引用\[1\]和引用\[2\]是关于解决HDU - 3853问题的AC代码。这段代码使用了动态规划的思路，通过计算每个点的期望能量来解决问题。其中，f\[i\]\[j\]表示走到(i, j)这个点的期望能量。代码中还有一些特殊情况的处理，比如停留在原地的花费为2点，停留在原地的概率为1的情况下期望能量为0。\[1\]\[2\] 引用\[3\]是关于Akemi Homura的描述，她是一个魔法少女，想要帮助她的朋友Madoka拯救世界。但由于Boss孵化器的情节，她被困在一个叫做LOOPS的迷宫中。\[3\] 所以，问题A - LOOPS HDU - 3853是关于解决迷宫问题的一个题目。 #### 引用[.reference_title] - *1* *3* [期望DP——C - LOOPS HDU - 3853](https://blog.csdn.net/GreyBtfly/article/details/80534173)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [HDU 3853-LOOPS【期望DP】](https://blog.csdn.net/qq_41785863/article/details/102570840)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值