列车厢调度 (25分)

最新推荐文章于 2022-02-12 15:20:24 发布

原创最新推荐文章于 2022-02-12 15:20:24 发布 · 620 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构 #算法 #stack #c算法

PTA数据结构与算法题专栏收录该内容

5 篇文章

订阅专栏

这篇博客探讨了列车厢调度问题，其中涉及到三条平行轨道和特定的转移规则。文章提供了一个C语言的实现，旨在解决如何在满足条件的情况下，通过最短操作序列将车厢从1号轨道转移到2号轨道。输入包括两个字符串，分别表示初始和目标车厢顺序，输出为最短的操作序列。当无法调度时，程序会返回错误提示。

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

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

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

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

输入格式:
两行由大写字母组成的非空字符串，第一行表示停在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?

C语言代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef enum { false, true } bool;
typedef char ElementType;
typedef struct stack
{
    ElementType *top,*base;
    int MaxSize;
}*Stack;
int MaxSize=100;
Stack CreateStack();
bool Push( Stack S, ElementType X);
ElementType Pop( Stack S);
void move();
int main()
{
    move();
    return 0;
}
void move()
{
    Stack s1,s2,s3;
    char last[100],pre[100],c1,c2,c3,ch,count=0;
    int tra[30],resu[100];
    int i=0,j=0;
    s1 = CreateStack();
    s2 = CreateStack();
    s3 = CreateStack();
    while((ch=getchar())!='\n'){
        tra[ch-'A'] = 1;
        pre[i] = ch;
        i++;
    }
    for(j=i-1;j>=0;j--){
        Push(s1,pre[j]);
    }
    gets(last);
    for(j=0;j<i;j++){
        c2=last[j];
        if(tra[c2-'A'] == 1){
            while((c1=Pop(s1)) != c2){
                Push(s3,c1);
                resu[count++] = 0;
                tra[c1-'A'] = 3;
            }
            resu[count++] = 1;
            tra[c1-'A'] = 2;
        }
        if(tra[c2-'A'] == 3){
            c3 = Pop(s3);
            if(c3 == c2){
                tra[c3-'A'] = 2;
                resu[count++] = 2;
            }
            else{
                resu[count++] = 4;
                break;
            }

        }
    }
    if(resu[count-1]!=4){
        for(i=0;i<count;i++){
            switch(resu[i]){
                case 0:printf("1->3\n");break;
                case 1:printf("1->2\n");break;
                case 2:printf("3->2\n");break;
            }
        }
    }else{
        printf("Are you kidding me?");
    }
}
Stack CreateStack()
{
    Stack s = (Stack)malloc(sizeof(struct stack));
    s->base = (ElementType*)malloc(sizeof(ElementType)*MaxSize);
    s->top = s->base;
    return s;
}
bool Push( Stack s, ElementType X)
{
    if(s->top - s->base == MaxSize)
        return false;
    *(s->top++) = X;
    return true;
}
ElementType Pop( Stack s)
{
    if(s->top == s->base)
        return false;
    return *(--s->top);
}