ACM学习历程——UVA11111 Generalized Matrioshkas（栈）

Description

 

Problem B - Generalized Matrioshkas

 

  Problem B - Generalized Matrioshkas 

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 mcontains 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 toy 7 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.


按照题目的意思，遵循以下：
1、负数直接入栈。
2、top为0直接入栈。
3、如果为正数：
　　1·、能与栈顶元素结合，让栈顶元素的ok值为1（ok值起始为0），并由负转正。正数值不入栈。
　　2·、能与栈顶第二个元素结合，而且可以容下栈顶ok元素（非ok不满足条件），弹出栈顶元素，此时栈顶元素ok值转1，由负转正。
　　3·、进行完上述过程，对连续的ok值进行结合。val值相加。
　　4·、对不能结合的正数，根据题目要求必然是坏值，可以入栈或者不入栈，对结果判断不影响。
4、最终只要栈中元素只有一个，并且其ok值为1，说明是好的；其余均是坏的。


代码：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <set>
#include <map>
#include <vector>
#include <queue>
#include <string>
#define inf 0x3fffffff
#define eps 1e-10

using namespace std;

struct node
{
    bool ok;
    int val;
};

node Stack[10000];
int top;

int Input()
{
    int v;
    char ch;
    top = 0;
    for (;;)
    {
        if (scanf("%d", &v) == EOF)
            return -1;
        ch = getchar();
        if (v < 0)
        {
            Stack[top].ok = 0;
            Stack[top].val = v;
            top++;
        }
        else if (top == 0)
        {
            Stack[top].ok = 0;
            Stack[top].val = v;
        }
        else if (Stack[top-1].val == -v)
        {
            Stack[top-1].ok = 1;
            Stack[top-1].val = v;
        }
        else if (top > 1 &&
                 Stack[top-1].ok == 1 &&
                 Stack[top-2].val == -v &&
                 Stack[top-1].val < v)
        {
            top--;
            Stack[top-1].ok = 1;
            Stack[top-1].val = v;
        }
        while (top > 1 &&
               Stack[top-1].ok == 1 &&
               Stack[top-2].ok == 1)
        {
            Stack[top-2].val += Stack[top-1].val;
            top--;
        }
        if (ch == '
')
        {
            if (top == 1 && Stack[top-1].ok == 1)
                return 1;
            else
                return 0;
        }
    }
}

void qt()
{
    int ans;
    for (;;)
    {
        ans = Input();
        if (ans == -1)
            break;
        if (ans == 0)
            printf(":-( Try again.
");
        else
            printf(":-) Matrioshka!
");
    }
}

int main()
{
    //freopen ("test.txt", "r", stdin);
    qt();
    return 0;
}