02-线性结构4 Pop Sequence (25分)

Given a stack which can keep M numbers at most. Push N numbers in the order of 1, 2, 3, …, N and pop randomly. You are supposed to tell if a given sequence of numbers is a possible pop sequence of the stack. For example, if M is 5 and N is 7, we can obtain 1, 2, 3, 4, 5, 6, 7 from the stack, but not 3, 2, 1, 7, 5, 6, 4.

Input Specification:

Each input file contains one test case. For each case, the first line contains 3 numbers (all no more than 1000): M (the maximum capacity of the stack), N (the length of push sequence), and K (the number of pop sequences to be checked). Then K lines follow, each contains a pop sequence of N numbers. All the numbers in a line are separated by a space.

Output Specification:

For each pop sequence, print in one line “YES” if it is indeed a possible pop sequence of the stack, or “NO” if not.

Sample Input:

5 7 5
1 2 3 4 5 6 7
3 2 1 7 5 6 4
7 6 5 4 3 2 1
5 6 4 3 7 2 1
1 7 6 5 4 3 2

Sample Output:

YES
NO
NO
YES
NO

#include <stdio.h>
#include <stdlib.h>
typedef int Position;
typedef int ElementType;
struct SNode {
    ElementType *Data; /* 存储元素的数组 */
    Position Top;      /* 栈顶指针 */
    int MaxSize;       /* 堆栈最大容量 */
};
typedef struct SNode *Stack;
typedef int bool;
#define TRUE 1
#define FALSE 0
#define ERROR -1
#define MAXSIZE 1000
/*初始化创建堆栈*/
Stack CreateStack( int MaxSize )
{
    Stack s =(Stack)malloc(sizeof(struct SNode));
    s->Data = (ElementType *)malloc(MaxSize*sizeof(ElementType));
    s->Top = -1;
    s->MaxSize = MaxSize;
    return s;
}
/*判断堆栈是否已满*/
bool IsFull( Stack S )
{
    return (S->Top ==S->MaxSize-1);
}
/*压栈*/
bool Push( Stack S, ElementType X )
{
    if(IsFull(S)){
        return FALSE;
    }else{
        S->Data[++S->Top] = X;
        return TRUE;
    }
}
/*判断堆栈是否为空*/
bool IsEmpty( Stack S )
{
     return (S->Top == -1);
}
/*清空堆栈的方法*/
void Empty( Stack S )
{
     S->Top = -1;
}
/*弹出数据*/
ElementType Pop( Stack S )
{
     if(IsEmpty(S)){
        return NULL;
    }else{
       return S->Data[S->Top--];

    }
}
/*校验堆栈中是否可以生成响应序列*/
bool Check(int a[],Stack s,int NMax){
    int i = 0,next = 1;
    while(i<NMax){//确保序列中的所有数据参与比较
        while(a[i]>=next){//序列数大于或等于要压栈数据循环压栈
            bool b = Push(s,next);
            next++;
            if(!b){
                Empty(s);
                return b;
            }
        }
        while(a[i] < next && i<=NMax-1 ){//要压栈数据小于序列数据时候，循环弹出，后一个控制别数组越界
            if(a[i]==Pop(s) ){
               i++;
            }else{
                Empty(s);
                return FALSE;
            }
        }
    }
    return TRUE;
}
int main(){
    int capacity,NMax,popSeq;//堆栈最大容量，最大数，弹出序列个数, result 代表
    scanf("%d%d%d",&capacity,&NMax,&popSeq);
    int pops [popSeq][NMax];//二维数组盛放检验序列，result数组用来存放结果
    for(int i=0;i<popSeq;i++){
        for(int j=0;j<NMax;j++){
            scanf("%d",&pops[i][j]);
        }
    }
   Stack s = CreateStack(capacity);
   for(int i=0;i<popSeq;i++){
     if(Check(pops[i],s,NMax)){
        printf("YES");
     }else{
        printf("NO");
     }
     if(i!=popSeq-1){
        printf("\n");
     }
   }
    return 0;
}