Generalized Matrioshkas UVA 11111

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 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 7contains 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 2should be paired.
On the other hand, the following sequences do not describe generalized matrioshkas:

[align=center]-9     -7     -2    2     -3     -1     -2    2    1    3    7    9[/align]

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

[align=center]-9     -7     -2    2     -3     -2     -1    1    2    3    7     -2    2    9[/align]

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

[align=center]-9     -7     -2    2     -3     -1     -2    3    2    1    7    9[/align]

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.

XX Colombian National Programming Contest

题目大意：

这题的题意比较难懂，看了好几变才明白。  就是有一个可以嵌套娃娃的娃娃，然后嵌套在里面的娃娃又可以继续嵌套娃娃。

然后要求直接嵌套在里面（内一层）的娃娃的尺寸大小之和不能超过外面的。 例如，-3 -2 2 3,代表有两层，-3和3表示一个嵌套（这个娃娃的尺寸大小为3，且负数一定要在左边先出现），里面时-2和2表示一个大小2的娃娃。 再比如-5 -2 2 -1 1 5,表示有3个娃娃，5嵌套这2和1。当有更多层的嵌套时，如-9     -7     -2    2     -3     -2     -1    1    2    3    7    9，表示9嵌套着7.然后7又嵌套着2（左边的-2，2）和3，
3又嵌套这2（右边出现的-2，2）， 这个2又嵌套着1。 只要相邻的层次，内一层的大小相加起来小于（不能等于）外一层的大小就满足条件。
我在这道题上又卡了很久，咋看一下感觉很简单，但总是无从下手，还好有小赖同学的提醒，才知道怎么做，最后在边界数据上又卡了很久，还是要每天坚持做。

#include<iostream>
#include<cstring>
#include<stack>
#include<cstdio>

using namespace std;

stack<int> team1;
stack<int> team2;
int arry[10000];

int main()
{
int n;
char ch;
while(cin>>n)
{
int i,j,k=0;
arry[0]=n;
ch=getchar();
while(ch!='\n')
{
cin>>arry[++k];
ch=getchar();
}
k++;
int flag=1,s;
for(i=0;i<k;i++)
{
if(arry[i]<0)
{
team1.push(arry[i]);
team2.push(arry[i]*(-1));
}
else if(arry[i]>0)
{
if(team2.empty())
{
flag=0;
break;
}
if(arry[i]!=team2.top())
{
flag=0;
break;
}
else
{
team2.pop();
s=0;
while(team1.top()>0)
{
s=s+team1.top();
team1.pop();
}
if(s>=arry[i])
{
flag=0;
break;
}
team1.pop();
team1.push(arry[i]);
}
}
}
if(!team2.empty()) flag=0;
if(flag) cout<<":-) Matrioshka!"<<endl;
else cout<<":-( Try again."<<endl;
while(!team1.empty())
team1.pop();
while(!team2.empty())
team2.pop();
}
return 0;
}