第三章作业1-栈-计算机17级 7-17 堆栈操作合法性 （20 分）

7-17 堆栈操作合法性 （20 分）

假设以S和X分别表示入栈和出栈操作。如果根据一个仅由S和X构成的序列，对一个空堆栈进行操作，相应操作均可行（如没有出现删除时栈空）且最后状态也是栈空，则称该序列是合法的堆栈操作序列。请编写程序，输入S和X序列，判断该序列是否合法。

输入格式:

输入第一行给出两个正整数N和M，其中N是待测序列的个数，M（≤50）是堆栈的最大容量。随后N行，每行中给出一个仅由S和X构成的序列。序列保证不为空，且长度不超过100。

输出格式:

对每个序列，在一行中输出YES如果该序列是合法的堆栈操作序列，或NO如果不是。

输入样例：

4 10
SSSXXSXXSX
SSSXXSXXS
SSSSSSSSSSXSSXXXXXXXXXXX
SSSXXSXXX

输出样例：

YES
NO
NO
NO

方法一：实现栈法 

这是用栈来模拟这个过程的，当然更简单的方法是直接模拟就好

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

#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10

#define TRUE         1
#define FALSE        0
#define OK           1
#define ERROR        0
#define INFEASIBLE  -1
//#define OVERFLOW    -2


typedef int SElemType;
typedef int Status;

typedef struct
{
    SElemType *base;
    SElemType *top;
    int stacksize;
} SqStack;

Status InitStack(SqStack &S);

Status Push(SqStack &S,char e);

Status Pop(SqStack &S,char e);

bool JudgeEmpty(SqStack &S);

int main()
{
    int n,m;
    cin>>n>>m;
    for(int i = 0; i < n; i++)
    {
        string c;
        cin>>c;
        SqStack s;
        InitStack(s);
        //int len = s.length();
        int length = 0;
        int flag = 1;//用来判断不符合题意的情况啊a：长度超限 b：栈本身就是空的造成无法出栈
        for(int i = 0; c[i]!='\0'; i++)
        {
            if(c[i] == 'S')
            {
                Push(s,c[i]);
                length++;
                if(length > m)
                {
                    cout<<"NO"<<endl;
                    flag = 0;
                    break;
                }
            }
            else
            {
                if(JudgeEmpty(s))
                {
                    cout<<"NO"<<endl;
                    flag = 0;
                    break;
                }
                else
                {
                    Pop(s,c[i]);
                    length--;
                }

            }
        }
        if(flag)
        {
            if(JudgeEmpty(s))
                cout<<"YES"<<endl;
            else
                cout<<"NO"<<endl;
        }
    }
}

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

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


Status Pop(SqStack &S,char e)
{
    if(S.base == S.top)
        return ERROR;
    e = *--S.top;
    return OK;
}

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

方法二：直接模拟法（更简单）

思路：

用sum表示栈区里的元素个数，开始sum初始化为0，然后扫描这个字符串，若字符为’S’，则代表入栈，这时只要sum ++就可以了。同理，字符为’X’时，sum –。在任何一个只要sum < 0或者sum > m，则用flag = 0表示错误，并跳出循环。最后整个字符串扫描完毕后，判断sum是否等于0，并且flag是否为0就可以看出堆栈操作是否合法了。（flag和sum定义在循环内）。

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

int main()
{
    string ss;
    int n,m;

    cin>>n>>m;
    while(n--)
    {
        int flag = 1;
        int sum = 0;
        cin>>ss;
        for(int i = 0; ss[i]; i++)
        {
            if(ss[i] == 'S')
            {
                sum++;
                if(sum > m)
                {
                    flag = 0;
                    break;
                }
            }
            else if(ss[i] == 'X')
            {
                sum--;
                if(sum < 0)
                {
                    flag = 0;
                    break;
                }
            }

        }
        if(sum||!flag)
            cout<<"NO"<<endl;
        else
            cout<<"YES"<<endl;
    }
    return 0;
}