uva11111

题目：
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 n1, n2, …, nr, it must be true that n1+n2+…+nr <
m. And if this is the case, we say that toy m contains directly the toys n1, n2, …, nr. It should be
clear that toys that may be contained in any of the toys n1, n2, …, nr 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:
a1 a2 … aN
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 107
.
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.

大概意思：
有点类似括号匹配，但是没括号匹配那么简单，相反数的匹配，且在其所嵌套的数不能大于它本身。

思路：
利用两个栈，一个栈存放负数，一个栈用来判断是否嵌套的会大于外围。

代码：

#include<iostream>
#include <stack>
#include <string>
#include <cstring>
#include <sstream>
using namespace std;
int main()
{
    string s;
    int sum=0;
    int flag = 1,j=0;
    stack<int> sta1,sta2;
    while (getline(cin,s)) //使用getline将整个串输进来
    {
        if (s[0] == '\0')  //缺少这一句会出现错误的答案
            continue;
        flag = 1;
        while (!sta1.empty())
            sta1.pop();
        while (!sta2.empty())
            sta2.pop();
        istringstream is(s);//利用istringstream将串化为一个一个数字
        while (is >> j)//J<0分为两种情况 一种是栈中没有元素 一种是栈中有元素 有元素的要判断其外围是否大于嵌套的
        {                   //j>0也分为两种情况  一种是栈中没有元素 证明没有匹配的相反数 一种是有元素 判断栈顶元素是否为其相反数
            if (sta1.empty()) 
            {
                if (j < 0)
                {
                    sta1.push(j);
                    sta2.push(j);
                }
                else
                {
                    flag = 0;
                    break;
                }
            }
            else if (j > 0)
            {
                if ((j + sta2.top()) != 0)
                {
                    flag = 0;
                    break;
                }
                sta2.pop();
                sta1.pop();
            }
            else //栈中有负数 且当前数为负数时
            {
                sum = sta1.top() - j;
                if (sum >= 0)
                {
                    flag = 0;
                    break;
                }
                sta1.pop();  //这几部想不出来 没想到要把num push进去。。
                sta1.push(sum);
                sta1.push(j);
                sta2.push(j);
            }


        }

        if (flag == 1 && sta2.empty())
            printf(":-) Matrioshka!\n");
        else
            printf(":-( Try again.\n");
    }
    return 0;
}