10:括號畫家

總時間限制: 

1000ms

記憶體限制: 

262144kB

描述

Candela是一名漫畫家，她有一個奇特的愛好，就是在紙上畫括號。這一天，剛剛起床的Candela畫了一排括號序列，其中包含小括號()、中括號[]和大括號{}，總長度為N。這排隨意繪製的括號序列顯得雜亂無章，於是Candela定義了什麼樣的括號序列是美觀的：
(1) 空的括號序列是美觀的；
(2) 若括號序列A是美觀的，則括號序列(A)、[A]、{A}也是美觀的；
(3) 若括號序列A、B都是美觀的，則括號序列AB也是美觀的；
例如 [(){}]() 是美觀的括號序列，而 )({)[}]( 則不是。
現在Candela想知道她畫出的括號序列是不是美觀的。你能幫幫她嗎？

輸入

一個括號序列，長度不超過10000。

輸出

如果它是美觀的，輸出Yes，否則輸出No。

樣例輸入

{}[(){}]()

樣例輸出

Yes

思路：

1.在演算法中設定一個棧

2.每讀入一個括號，若是右括號，則要看是否匹配。當棧不空時，如果匹配，則棧頂元素出棧，如果不匹配，則不合法。若是左括號，則壓入棧中。

3.演算法的開始於結束，棧都應該為空

4.題目當中沒有考慮輸入為())這種情況，所以要在輸出時加一些判斷，實現自己看程式碼

方法一：c++直接寫

#include <iostream>
#include <bits/stdc++.h>
using namespace std;

stack<char> sta;
string ss;
int main()
{
    int i;
    bool flag = true;
    cin>>ss;
    for(int i = 0; ss[i]; i++)
    {
        if(ss[i]=='('||ss[i]=='['||ss[i]=='{')
        {
            sta.push(ss[i]);
        }
        else if(ss[i]==')'||ss[i]=='}'||ss[i]==']')
        {
            if(sta.empty())
            {
                flag = false;
                break;
            }
            char tmp = sta.top();//一定要先判空再取頂
            if((ss[i]==')'&&tmp!='(') || (ss[i]==']'&&tmp!='[') || (ss[i]=='}'&&tmp!='{') )
            {
                flag = false;
                break;
            }
            else
            {
                sta.pop();
            }
        }
    }
    if(flag)
    {
        if(sta.empty())
            cout<<"Yes"<<endl;
        else if(i<ss.size())//排除())這種情況
            cout<<"No"<<endl;
    }
    else
        cout<<"No"<<endl;
}
 

方法2：實現棧來寫

#include<cstdio>
#include<bits/stdc++.h>
#define STACK_INIT_SIZE 10000
#define STACKINCREMENT 10
#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE -1
//#define OVERFLOW   -2
using namespace std;
typedef char SElemType,Status;
typedef struct
{
    SElemType *base;
    SElemType *top;
    int stacksize;
} SqStack;

Status InitStack(SqStack &S)
{
    S.base=(SElemType *)malloc(sizeof(SElemType)*STACK_INIT_SIZE);
    if(!S.base)
        exit(OVERFLOW);
    S.top=S.base;
    S.stacksize=STACK_INIT_SIZE;
    return OK;
}

Status Push(SqStack &S,SElemType e)
{
    if(S.top-S.base>=S.stacksize)
    {
        S.base=(SElemType*)malloc(sizeof(SElemType)*(S.stacksize+STACKINCREMENT));
        if(!S.base)
            exit(OVERFLOW);
        S.top=S.base+S.stacksize;
        S.stacksize+=STACKINCREMENT;
    }
    *S.top++=e;
    return OK;
}
Status Pop(SqStack &S,SElemType &e)
{
    if(S.top==S.base)
        return ERROR;
    e = *S.top--;
    return OK;
}
Status GetTop(SqStack &S,SElemType &e)
{
    if(S.base==S.top)
        return ERROR;
    e=*(S.top-1);
    return OK;
}

bool JudgeEmpty(SqStack &S)
{
    if(S.top == S.base)
        return true;
    else
        return false;
}

string ss;

int main()
{
    SqStack S;
    InitStack(S);
    int flag = 1,i;
    cin>>ss;
    for(i = 0; ss[i]; i++)
    {
        if(ss[i]=='('||ss[i]=='['||ss[i]=='{')
        {
            Push(S,ss[i]);
        }
        else if(ss[i]==')')
        {
            SElemType e;
            GetTop(S,e);
            if(S.top != S.base)
            {
                if(e=='(')
                {
                    Pop(S,e);
                }
                else if(flag)
                {
                    flag = 0;
                    break;
                }
            }
            else if(flag)
            {
                flag = 0;
                break;
            }
        }
        else if(ss[i]==']')
        {
            SElemType e;
            GetTop(S,e);
            if(S.top != S.base)
            {
                if(e=='[')
                {
                    Pop(S,e);
                }
                else if(flag)
                {
                    flag = 0;
                    break;
                }
            }
            else if(flag)
            {
                flag = 0;
                break;
            }
        }
        else if(ss[i]=='}')
        {
            SElemType e;
            GetTop(S,e);
            if(S.top != S.base)
            {
                if(e=='{')
                {
                    Pop(S,e);
                }
                else if(flag)
                {
                    flag = 0;
                    break;
                }
            }
            else if(flag)
            {
                flag = 0;
                break;
            }
        }
    }
    if(flag)
    {
        if(S.base == S.top)//最後如果棧空說明都匹配
            cout<<"Yes"<<endl;
        else if(i<ss.size())//排除())這種情況
        {
            cout<<"No"<<endl;
        }
        else//否則不匹配
        {
            cout<<"No"<<endl;
        }
    }
    else
        cout<<"No"<<endl;
    return 0;
}