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>
#define MAXN 1001


// 栈部分
typedef struct SqStack {
	int Data[MAXN];
	int Top;
}*Stack;

Stack initStack(void) {
	Stack S = (Stack)malloc(sizeof(struct SqStack));
	S->Top = 0;
	return S;
}

int getLength(Stack S) {
	return S->Top;
}

int isEmpty(Stack S) {
	if (getLength(S) == 0)
		return 1;
	return 0;
}

int Push(Stack S, int data, int maxSize) {
	if (getLength(S) == maxSize)
		return 0;
	S->Data[S->Top++] = data;
	return 1;
}

int Pop(Stack S) {
	if (isEmpty(S))
		return NULL;
	return S->Data[--S->Top];
}

int getTop(Stack S) {
	if (isEmpty(S))
		return NULL;
	return S->Data[S->Top - 1];
}


// 队列部分
typedef struct Queue {
	int Data;
	struct Queue *Next;
}*QueueNode;

typedef struct LQueue {
	QueueNode Head;
	QueueNode Rear;
}*LinkQueue;

LinkQueue initQueue(void) {
	LinkQueue Q = (LinkQueue)malloc(sizeof(struct LQueue));
	Q->Head = (QueueNode)malloc(sizeof(struct Queue));
	Q->Head->Next = NULL;
	Q->Rear = Q->Head;
	return Q;
}

void enQueue(LinkQueue Q, int data) {
	QueueNode temp = (QueueNode)malloc(sizeof(struct Queue));
	temp->Data = data;
	temp->Next = NULL;
	Q->Rear->Next = temp;
	Q->Rear = Q->Rear->Next;
}

int isQueueEmpty(LinkQueue Q) {
	if (Q->Head == Q->Rear)
		return 1;
	return 0;
}

int deQueue(LinkQueue Q) {
	QueueNode temp;
	int data;
	if (isQueueEmpty(Q))
		return NULL;
	temp = Q->Head->Next;
	data = temp->Data;
	Q->Head->Next = Q->Head->Next->Next;
	if (Q->Head->Next == NULL)
		Q->Rear = Q->Head;
	free(temp);
	return data;
}

int getQueueTop(LinkQueue Q) {
	if (isQueueEmpty(Q))
		return NULL;
	return Q->Head->Next->Data;
}

int main(void) {
	LinkQueue mainQueue, subQueue, inputQueue;
	mainQueue = initQueue();
	subQueue = initQueue();
	Stack tempStack;
	int M, N, K, i, j, temp, err = 0;
	scanf("%d %d %d", &M, &N, &K);

	// 构造mainQueue
	for (i = 0; i < N; i++) {
		enQueue(mainQueue, i + 1);
	}

	// 主循环
	for (i = 0; i < K; i++) {
		tempStack = initStack();
		inputQueue = initQueue();
		for (j = 0; j < N; j++) {
			scanf("%d", &temp);
			enQueue(inputQueue, temp);
		}
		while (1) {
			// tempStack 为空
			if (isEmpty(tempStack)) {
				// inputQueue 为空
				if (isQueueEmpty(inputQueue)) {
					break;
				}
				// mainQueue 非空
				if (!isQueueEmpty(mainQueue)) {
					temp = deQueue(mainQueue);
					enQueue(subQueue, temp);
					if (!Push(tempStack, temp, M)) {
						err = 1;
						break;
					}
				}
				// mainQueue 为空
				else {
					err = 1;
					break;
				}
			}
			// 判断tempStack栈顶和input队头是否相等
			else if (getTop(tempStack) != getQueueTop(inputQueue)) {
				temp = deQueue(mainQueue);
				if (temp == NULL) {
					err = 1;
					break;
				}
				enQueue(subQueue, temp);
				if (!Push(tempStack, temp, M)) {
					err = 1;
					break;
				}
			}
			else if (getTop(tempStack) == getQueueTop(inputQueue)) {
				temp = Pop(tempStack);
				if (temp == NULL) {
					err = 1;
					break;
				}
				temp = deQueue(inputQueue);
			}
		}
		// 还原mainQueue和subQueue
		while (!isQueueEmpty(mainQueue)) {
			enQueue(subQueue, deQueue(mainQueue));
		}
		while (!isQueueEmpty(subQueue)) {
			enQueue(mainQueue, deQueue(subQueue));
		}
		// 输出结果
		if (err == 1) {
			printf("NO\n");
			free(tempStack);
			free(inputQueue);
			err = 0;
			continue;
		}
		else {
			printf("YES\n");
			free(tempStack);
			free(inputQueue);
			continue;
		}
	}
}