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 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:

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

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.

题意：有一堆玩具。小的可以放在大的肚子里。不过要满足所有直接装在大的肚子里面的小的玩具的体积加起来小于这只大的玩具的体积。

这道题其实也是类似括号匹配的问题，不过可以栈的元素可以是两个数。x，y。其中x是存放玩具的大小，y来存放玩具还剩下多少体积可以放小玩具。而每次都是负数入栈，负数其实代表的就是打开一个新的文具。所以每次负数入栈之前都要验证一下，是否小于前面的元素，并且要保证每次y（即前面剩下的体积大于打开的玩具).

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<stack>
#define maxn 10000000
using namespace std;
struct node
{
    int x;
    int q;
};
int main ()
{
    int n;
    node temp,toy;
    char ch;
    bool flag=true;
    stack<node> s;
    node first;
    first.x=maxn;
    first.q=maxn;
    s.push(first);
    while(cin>>n)
    {
        ch=getchar();
        if (flag)
        {
            if (n<0)
            {
                temp.x=n;
                temp.q=-n;
                toy=s.top();
                s.pop();
                if (toy.q>temp.q)
                {
                    toy.q-=temp.q;
                    s.push(toy);
                    s.push(temp);
                }
                else flag=false;
            }
            else
            {
                temp=s.top();
                s.pop();
                if (temp.x+n!=0) flag=false;
            }
        }
        if (ch=='\n')
        {
            if (s.size()!=1) flag=false;
            while(!s.empty())
            {
                s.pop();
            }
            if (flag) cout<<":-) Matrioshka!"<<endl;
            else cout<<":-( Try again."<<endl;
            node first;
            first.x=maxn;
            first.q=maxn;
            s.push(first);
            flag=true;
        }
    }
    return 0;
}