11111 - Generalized Matrioshkas

Problem B - Generalized Matrioshkas 

Time limit: 3.000 seconds

Vladimir worked for years making matrioshkas, those nesting dolls that certainly represent truly Russian craft. A matrioshka is a doll that may be opened in two halves, so that one finds another doll inside. Then this doll may be opened to find another one inside it. This can be repeated several times, till a final doll -that cannot be opened- is reached.

Recently, Vladimir realized that the idea of nesting dolls might be generalized to nesting toys. Indeed, he has designed toys that contain toys but in a more general sense. One of these toys may be opened in two halves and it may have more than one toy inside it. That is the new feature that Vladimir wants to introduce in his new line of toys.

Vladimir has developed a notation to describe how nesting toys should be constructed. A toy is represented with a positive integer, according to its size. More precisely: if when opening the toy represented by m we find the toys represented by n₁, n₂, ..., n_r, it must be true that n₁ + n₂ + ... + n_r < m. And if this is the case, we say that toy m contains directly the toys n₁, n₂, ..., n_r . It should be clear that toys that may be contained in any of the toys n₁, n₂, ..., n_r are not considered as directly contained in the toy m.

A generalized matrioshka is denoted with a non-empty sequence of non zero integers of the form:

a₁    a₂    ...    a_N

such that toy k is represented in the sequence with two integers - k and k, with the negative one occurring in the sequence first that the positive one.

For example, the sequence

-9     -7     -2    2     -3     -2     -1    1    2    3    7    9

represents a generalized matrioshka conformed by six toys, namely, 1, 2 (twice), 3, 7 and 9. Note that toy7 contains directly toys 2 and 3. Note that the first copy of toy 2 occurs left from the second one and that the second copy contains directly a toy 1. It would be wrong to understand that the first -2 and the last 2 should be paired.

On the other hand, the following sequences do not describe generalized matrioshkas:

•  -9     -7     -2    2     -3     -1     -2    2    1    3    7    9

  because toy 2 is bigger than toy 1 and cannot be allocated inside it.

•  -9     -7     -2    2     -3     -2     -1    1    2    3    7     -2    2    9

  because 7 and 2 may not be allocated together inside 9.

•  -9     -7     -2    2     -3     -1     -2    3    2    1    7    9

  because there is a nesting problem within toy 3.

Your problem is to write a program to help Vladimir telling good designs from bad ones.

 

Input 

The input file contains several test cases, each one of them in a separate line. Each test case is a sequence of non zero integers, each one with an absolute value less than 10⁷.

 

Output 

Output texts for each input case are presented in the same order that input is read.

For each test case the answer must be a line of the form

:-) Matrioshka!

if the design describes a generalized matrioshka. In other case, the answer should be of the form

:-( Try again.

Sample Input 

-9 -7 -2 2 -3 -2 -1 1 2 3 7 9
-9 -7 -2 2 -3 -1 -2 2 1 3 7 9
-9 -7 -2 2 -3 -1 -2 3 2 1 7 9
-100 -50 -6 6 50 100
-100 -50 -6 6 45 100
-10 -5 -2 2 5 -4 -3 3 4 10
-9 -5 -2 2 5 -4 -3 3 4 9

 

Sample Output 

:-) Matrioshka!
:-( Try again.
:-( Try again.
:-) Matrioshka!
:-( Try again.
:-) Matrioshka!
:-( Try again.

 

---

XX Colombian National Programming Contest

 

 

// Address：Uva 11111 - Generalized Matrioshkas (许愿套娃）
// level: unconfident
// Classify：Data Structure （stack） 
// Verdict: Accepted [five times] 
// UVa Run Time: 0.120s 
// Submission Date: 2012-12-05 12:33:17  
// My ID: xueying 
// Usetime：2 hours
// [解题方法]  
// 建立两个栈，一个栈实现的功能是输入进行匹配，另一个栈的功能进行判断（一个套娃
// 中能够存储足够的套娃，判断错误的情况） 
// 错误情况根据flag和栈底是否存在元素进行判断 


#include<stdio.h>
#include<string.h>
#define MAXN 100000

// 第二个栈的存储形式，num存储正整数m，flag == 1 表示两个 -m和m已匹配 
typedef struct{
    int num, flag;
}consist;

consist ristack[MAXN];  //第二个栈 
int stack[MAXN], temp[MAXN];   //stack是第一个栈，temp存储输入的内容 

int main()
{
    int i, flag, rear, n, top, num;
    char ch;
    memset(stack, 0, sizeof(stack));
    memset(temp, 0, sizeof(temp));
    for(i=0; i<MAXN; ++i) ristack[i].num = ristack[i].flag = 0;
    top = rear = flag = n = num = 0;
    while(scanf("%d", &temp[n++]) == 1)
    {
        if(scanf("%c", &ch) == EOF || ch == '\n')   // 判断换行和结束 
        {
            for(i=0; i<n; ++i)
            {
                if(temp[i] < 0)
                {
                    if(top != 0 || !i)  // 避免栈空（除了第一个元素外）而再次存入负数的情况 
                    {
                        stack[top++] = temp[i];
                        ristack[rear++].num = -temp[i];
                    }
                    else
                    {
                        flag = 1;
                        break;
                    }
                }
                else  // 输入为正数时 
                {
                    if(top == 0) // 栈空时停止for循环 
                    {
                        flag = 1;
                        break;
                    } 
                    if(temp[i] + stack[top-1] == 0) // 判断输入的元素是否匹配栈顶的元素，符合则删除栈顶元素后转入栈二判断 
                    {
                        stack[--top] = 0;
                        if(ristack[rear-1].num == temp[i] && ristack[rear-1].flag == 0)
                        ristack[rear-1].flag = 1;
                        else // 主要判断此时此元素（temp[i]）里内的元素，即套娃中存在的套娃的数量和大小是否满足条件 
                        {
                            while(ristack[rear-1].flag == 1)
                            {
                                num += ristack[rear-1].num;
                                ristack[--rear].num = ristack[rear].flag = 0;
                            }
                            if(ristack[rear-1].num == temp[i]) 
                            {
                                ristack[rear-1].flag = 1;
                                if(num >= ristack[rear-1].num)
                                {
                                    flag = 1;
                                    break;
                                }
                                num = 0;
                            }
                            else if(ristack[rear-1].flag != 1)
                            {
                                flag = 1;
                                break;
                            }
                        }
                        
                    }
                    else 
                    {
                        flag = 1;
                        break;
                    } 
                }
            }
            
            if(flag  || top) printf(":-( Try again.\n");
            else printf(":-) Matrioshka!\n");
            
            memset(stack, 0, sizeof(stack));
            memset(temp, 0, sizeof(temp));
            for(i=0; i<MAXN; ++i) ristack[i].num = ristack[i].flag = 0;
            top = rear = flag = n = num = 0;
        }

        
        
    }
    return 0;    
}


//Learn from it: 
//重要的是严谨的思维，要注意判断各种情况的出现，善于利用各种数据结构 
//解题的目的是什么，怎样才能实现，理出一条思路再进行敲代码