第三章栈与队列练习题 10:括号画家

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;
}

第三章 栈与队列 练习题 10:括号画家

10:括号画家

猜你喜欢

第三章栈与队列练习题 10:括号画家