hdu 1199 Color the Ball

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

Color the Ball

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 5135    Accepted Submission(s): 1262

Problem Description

There are infinite balls in a line (numbered 1 2 3 ....), and initially all of them are paint black. Now Jim use a brush paint the balls, every time give two integers a b and

follow by a char 'w' or 'b', 'w' denotes the ball from a to b are painted white, 'b' denotes that be painted black. You are ask to find the longest white ball sequence.

 

Input

First line is an integer N (<=2000), the times Jim paint, next N line contain a b c, c can be 'w' and 'b'.
There are multiple cases, process to the end of file.

 

Output

Two integers the left end of the longest white ball sequence and the right end of longest white ball sequence (If more than one output the small number one). All the input

are less than 2^31-1. If no such sequence exists, output "Oh, my god".

 

Sample Input

3
1 4 w
8 11 w
3 5 b

 

Sample Output

8 11

 

开始看到这道题以为要用到线段树会很难，仔细一想发现并不是多难，用一般方法就可以解决正常模拟一下染色，

0为黑色1位白色，然后循环统计每一段的白色个数，并将其起点和终点记录到结构体中，

通过排序找到白色个数最多的那一段，输出其起点和终点，即为该题结果

#include<stdio.h>
#include<string.h>
#include<algorithm>
#define N 200010//这里注意开大点

using namespace std;

struct st
{
    int x, y, ans;//x表示白色部分的起点，y表示终点，ans表示这段区间的白色的数量
} node[N];

int G[N];//G[i] 0表示黑色  1表示白色

int cmp(const void *a, const void *b)
{
    st *s1 = (st *)a, *s2 = (st *)b;
    if(s1->ans == s2->ans)
        return s1->x - s2->x;
    else
        return s2->ans - s1->ans;
}

int main()
{
    int n, a, b, i, f, k, j, Max;
    char ch;
    while(~scanf("%d", &n))
    {
        f = k = j = Max = ;
        memset(G, , sizeof(G));
        memset(node, , sizeof(node));
        while(n--)
        {
            scanf("%d%d %c", &a, &b, &ch);
            Max = max(max(a, b), Max);
            if(ch == 'w')
                for(i = a ; i <= b ; i++)
                    G[i] = ;
            else
                for(i = a ; i <= b ; i++)
                    G[i] = ;
        }
        for(i =  ; i < Max ; i++)
        {
            if(G[i] == )
            {
                f = ;
                break;
            }
        }
        if(f == )
        {
            printf("Oh, my god\n");
            continue;
        }
        for(i =  ; i <= Max ; i++)
        {
            if(G[i] == )
            {
                node[j].ans++;
                if(k == )
                {
                    node[j].x = i;
                    k = ;
                }
            }
            if(G[i] ==  && k == )
            {
                node[j].y = i - ;
                k = ;
                j++;
            }
            if(G[i] ==  && i == Max && k == )
            {
                node[j].y = i;
                k = ;
                j++;
            }
        }
        qsort(node, j, sizeof(node[]), cmp);
        printf("%d %d\n", node[].x, node[].y);
    }
    return ;
}

/*
3
1 4 w
8 11 w
3 5 b
4
1 4 w
8 11 w
3 5 b
6 8 w*/