PTA 7-1 列车厢调度

题目：

        1  ======   <--移动方向
         /
 3 =====  
         \
        2  ======   -->移动方向 

大家或许在某些数据结构教材上见到过“列车厢调度问题”（当然没见过也不要紧）。今天，我们就来实际操作一下列车厢的调度。对照上方的ASCII字符图，问题描述如下：

有三条平行的列车轨道（1、2、3）以及1-3和2-3两段连接轨道。现有一列车厢停在1号轨道上，请利用两条连接轨道以及3号轨道，将车厢按照要求的顺序转移到2号轨道。规则是：

• 每次转移1节车厢；
• 处在1号轨道的车厢要么经过1-3连接道进入3号轨道（该操作记为"1->3"），要么经过两条连接轨道直接进入2号轨道（该操作记为"1->2"）；
• 一旦车厢进入2号轨道，就不可以再移出该轨道；
• 处在3号轨道的车厢，只能经过2-3连接道进入2号轨道（该操作记为"3->2"）；
• 显然，任何车厢不能穿过、跨越或绕过其它车厢进行移动。

对于给定的1号停车顺序，如果经过调度能够实现2号轨道要求的顺序，则给出操作序列；如果不能，就反问用户 Are(你) you(是) kidding(凯丁) me(么)?

输入格式:

两行由大写字母组成的非空字符串，第一行表示停在1号轨道上的车厢从左到右的顺序，第二行表示要求车厢停到2号轨道的进道顺序（输入样例1中第二行CBA表示车厢在2号轨道的停放从左到右是ABC，因为C最先进入，所以在最右边）。两行字符串长度相同且不超过26（因为只有26个大写字母），每个字母表示一节车厢。题目保证同一行内的字母不重复且两行的字母集相同。

输出格式:

如果能够成功调度，给出最短的操作序列，每个操作占一行。所谓“最短”，即如果1->2可以完成的调度，就不要通过1->3和3->2来实现。如果不能调度，输出 "Are you kidding me?"

输入样例1:

ABC
CBA

输出样例1:

1->3
1->3
1->2
3->2
3->2

输入样例2:

ABC
CAB

输出样例2:

Are you kidding me?

 实现思路：

这道题主要是考查栈的使用，我认为这道题的难点在于你要弄清楚整个执行过程以及终止条件，我就是一开始没想清楚终止条件，然后就错了，所以写这道题的时候我建议画个流程图。

以下，我将1、2、3列车轨道叫A、B、C，

流程图如下：

我将A、B当作两个队列，C当作栈，比较的时所给的两个序列，但其实代码中并不存在这两个队列，只是用数组替代，这里只是便于理解，也是我写代码之前的想法，所以应该是先有这个流程图，后来再弄出的代码，我认为大家可以借鉴一下这种想法。

这里的圈1相当于函数1，圈2相当于函数2，我一开始是两个都弄了个终止条件，所以就乱七八糟了，因此这个终止条件一定要弄好，哪怕多判断一下也行。

C要存储列车必须用栈，其他两个无要求，我还设置一个队列来存储路线， 1 代表1->3  2代表1->2  3代表3->2，这里用数组也行。我是因为一直++很麻烦所以才用的队列，顺道还写了个出队时的输出函数，当然需要有一个标志位看看是否能匹配。

实现代码：

//1 队列  先入先出  出去的车厢不能再回来
//2 队列  遍历与要求相同    只进不出  一旦车厢进入2号轨道，就不可以再移出该轨道
//3 栈    先入后出
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 1024
#define N 26
int c = 0;
int n = 0;
char A[N];
char B[N];
int length;
int flag = 0;
//栈
typedef struct {
	char data[MAX];
	int top;
} SeqStack;
SeqStack *s;
//初始化
SeqStack *initSeqStack() {
	SeqStack *q;
	q = (SeqStack*)malloc(sizeof(SeqStack));
	q->top = -1;
	return q;
}
//入栈
void enSeqStack(SeqStack* q, char x) {
	q->top += 1;
	q->data[q->top] = x;
}
//出栈
void outSeqStack(SeqStack* q) {
	q->top--;
}
//读取栈顶元素
char readSeqStack(SeqStack *q) {
	return q->data[q->top];
}
//判断为空
int empty(SeqStack* q) {
	if (q->top == -1) return 1;
	else return 0;
}
//队列
typedef struct {
	int data[MAX];
	int rear;
	int front;
} SeQueue;
SeQueue *sq;
//初始化
SeQueue* intiSeQueue() {
	SeQueue *q;
	q = (SeQueue*)malloc(sizeof(SeQueue));
	q->rear = q->front = -1;
	return q;
}
//入队
void enSeQueue(int x) {
	sq->rear += 1;
	sq->data[sq->rear] = x;
}
//出队并输出
void outSeQueue() {          //1 代表1->3  2代表1->2  3代表3->2
	int x, i;
	for (i = sq->front + 1; i < sq->rear; i++) {
		x = sq->data[i];
		if (x == 1) printf("1->3\n");
		else if (x == 2) printf("1->2\n");
		else if (x == 3) printf("3->2\n");
	}
	x = sq->data[i];
	if (x == 1) printf("1->3");
	else if (x == 2) printf("1->2");
	else if (x == 3) printf("3->2");
}
//函数
void hanshu1();
void hanshu2();
void hanshu1() {
	if (c == length ) {  //判断所有元素均已遍历
		if (empty(s)) {     //若栈同时为空，则说明成功
			outSeQueue();
			return ;
		} else {     //若栈不为空
			char ch = readSeqStack(s);
			if (ch == B[n])   hanshu2();//栈中元素与所给序列相等
			else {
				printf("Are you kidding me?");   //不等，失败
				return ;
			}
		}
	}
	if (A[c] != B[n]) { //不相等，入栈，看下一个元素
		enSeQueue(1);
		enSeqStack(s, A[c]);
		c++;
		hanshu1();
	} else {
		enSeQueue(2);   //出现相等的元素，直接到2中
		c++;
		n++;
		hanshu2();   //判断停留在3的车厢是否相等
	}
}
void hanshu2() {
	int x = empty(s);
	if (x == 1) {      //为空
		hanshu1();
	}
	if (x == 0) {
		char ch = readSeqStack(s);
		if (ch == B[n]) {    //相等
			enSeQueue(3);
			outSeqStack(s);
			n++;
			hanshu2();
		} else   hanshu1();   //不等
	}
}
int main() {
	scanf("%s", A);
	scanf("%s", B);
	s = initSeqStack();
	sq = intiSeQueue();
	length = strlen(A);
	hanshu1();
	return 0;
}