出栈序列的合法性

给定一个最大容量为 M 的堆栈，将 N 个数字按 1, 2, 3, ..., N 的顺序入栈，允许按任何顺序出栈，则哪些数字序列是不可能得到的？例如给定 M=5、N=7，则我们有可能得到{ 1, 2, 3, 4, 5, 6, 7 }，但不可能得到{ 3, 2, 1, 7, 5, 6, 4 }。

输入格式：

输入第一行给出 3 个不超过 1000 的正整数：M（堆栈最大容量）、N（入栈元素个数）、K（待检查的出栈序列个数）。最后 K 行，每行给出 N 个数字的出栈序列。所有同行数字以空格间隔。

输出格式：

对每一行出栈序列，如果其的确是有可能得到的合法序列，就在一行中输出YES，否则输出NO。

输入样例：

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

结尾无空行

输出样例：

YES
NO
NO
YES
NO

代码长度限制 16 KB

时间限制  400 ms（注意一下，如果是最大值1000，有超时的风险）

内存限制  64 MB

一开始没有注意到超时，用的是栈的思想方法，唯独最大值的测试点没有过，后来算了一下，一个测试点需要3ms，1000个确实超过了400ms，看了一下网上写的，原来是用数组的方法，这才恍然大悟，还是没有更近一步想一想啊！以下用的是C语言版代码，可自行参考。

思想方法

方法是一致的，判断出栈序列是否合法：每次取一个出栈数，与栈顶的数判断大小关系。

1.如果栈顶的数小，就压栈至与出栈数相等，判断是否超过最大容量，若超过，则非法；反之，则弹出（注意top-1）。取下一个出栈数。

2.如果出栈数和栈顶数相等，弹出，取下一个出栈数。

3.如果出栈数小于栈顶数，则不合法。

代码

栈版（超时）：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef struct NUM{
    int *n;
    int len;
}stack;

bool InitStack(stack &s){
    s.n = (int*)malloc(9*sizeof(int));
    if (!s.n) {
        return false;
    }
    s.len = -1;
    return true;
}

bool isempty(stack s){
    if(s.len == -1) return true;
    else return false;
}

bool isfull(stack s){
    if (s.len == 8) {
        return true;
    }
    else return false;
}

bool push(stack &s,int n){
    if (isfull(s)) {
        return false;
    }
    s.n[++s.len] = n;
    return true;
}

int pop(stack &s){
    if (isempty(s)) {
        return -1;
    }
    else return s.n[s.len--];
}

int top(stack s){
    if (isempty(s)) {
        return 0;
    }
    else return s.n[s.len];
}

int destroy(stack &s){
    free(s.n);
    return 1;
}

int main() {
    int count,num,temp,pop_num,flag;
    int i = 0,M,N,K,maxsize;
    stack s;
    scanf("%d %d %d",&M,&N,&K);
    while (i < K) {
        maxsize = 1;
        InitStack(s);
        flag = 1;temp = 1;count = 1;
        while (scanf("%d",&num) && count < N) {
            if(top(s) < num){
                while (top(s) < num) {
                    push(s, temp);
                    temp++;
                }
                if (s.len > M - 1) maxsize = 0;
                pop(s);
            }
            else if(top(s) > num) flag = 0;
            else pop(s);
            count++;
        }
        if(temp > N + 1)flag = 0;
        if ((flag == 1) && (maxsize == 1)) {
            printf("YES\n");
        }
        else printf("NO\n");
        destroy(s);
        i++;
    }
    return 0;
}

数组版：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

int contrast(int *out,int M,int N){
    int In[1002]={0},top=0;
    int i,j=0;
    for (i = 0; i < N; i++) {
        if (In[top] < out[i]) {
            while(In[top] < out[i]){
                In[++top] = ++j;
            }
            if(top > M) return 0;
            top--;
        }
        else if(out[i] < In[top]) return 0;
        else top--;
    }
    return 1;
}

int main() {
    int M,N,K;
    int Out[1001]={0};
    int i,j;
    scanf("%d %d %d",&M,&N,&K);
    for (i=0; i<K; i++) {
        for (j=0; j < N; j++) {
            scanf("%d",&Out[j]);
        }
        if(contrast(Out, M, N)) printf("YES\n");
        else printf("NO\n");
    }
    
    return 0;
}