精华内容
下载资源
问答
  • 2022-01-11 11:50:38
            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?

    代码段: 

    #include <iostream>
    #include <stack>
    #include <string.h>
    using namespace std;
    
    
    int main()
    {
    	char s1[27],s2[27]; //s1,s2用于存放输入的两个字符串 
    	char road[300]="";  //road用于存放路 
    	
    	stack<char> A; //与s1对应 
    	stack<char> B; //与s2对应 
    	stack<char> C; //不能直接1->2,存于C 
    	
    	
    	cin>>s1>>s2;
    	
    	for(int i=strlen(s1)-1;i>=0;i--)  //初始化堆栈A的数据,注意题干,倒存 
    	{
    		A.push(s1[i]);
    	}
    	
    	for(int i=strlen(s2)-1;i>=0;i--)  //初始化堆栈B的数据,注意题干,倒存  
    	{
    		B.push(s2[i]);
    	}
    
    	while(A.empty()==0)  //A不空 
    	{
    		if(A.top()==B.top())
    		{
    			//cout<<"1->2"<<endl;
    			strcat(road,"1->2\n");
    			A.pop();
    			B.pop();
    		}else{
    			//cout<<"1->3"<<endl;
    			strcat(road,"1->3\n");
    			C.push(A.top());
    			A.pop();
    		}
    	}
    	
    	int flag=0;
    	while(C.empty()==0)
    	{
    		if(C.top()==B.top())
    		{
    			//cout<<"3->2"<<endl;
    			strcat(road,"3->2\n");
    			C.pop();
    			B.pop();
    		}else{
    			flag=1;
    			//cout<<"Are you kidding me?"<<endl;
    			break;
    		}
    	}
    	
    	if(flag==1)
    	{
    		cout<<"Are you kidding me?"<<endl;
    	}else{
    		cout<<road;
    	}
    	
    	return 0;
    }

     


    代码应用了 #include <stack> 简化了代码繁琐程度。

    更多相关内容
  • 列车厢调度

    2020-10-31 18:48:09
    大家或许在某些数据结构教材上见到过“列车厢调度问题”(当然没见过也不要紧)。今天,我们就来实际操作一下列车厢的调度。对照上方的ASCII字符图,问题描述如下: 有三条平行的列车轨道(1、2、3)以及1-3和2-3两...

    在这里插入图片描述

    大家或许在某些数据结构教材上见到过“列车厢调度问题”(当然没见过也不要紧)。今天,我们就来实际操作一下列车厢的调度。对照上方的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?

    分析

    本质上是对栈的使用
    先判断串里是否相等再看栈中是否相等

    代码

    #include<iostream>
    #include <stack>
    #include <cstring>
    using namespace std;
    int way[100];
    char a[100],b[100];
    int main(){
        cin>>a;
        cin>>b;
        stack<char> stk;
        int len=strlen(a);
        int now=0,temp=0;//分别是第二个字符串位置和路径的位次
        bool flag=true;//是否可以完成调度
        for (int i = 0; i < len; ++i) {
            if(a[i]!=b[now]){
                if(stk.empty()||stk.top()!=b[now]){
                    stk.push(a[i]);
                    way[temp++]=1;
                } else if(stk.top()==b[now]){
                    stk.pop();
                    way[temp++]=3;
                    now++;
                    i--;//注意没有用到i,i要减,下一次判断
                }else if((!stk.empty())&&stk.top()!=b[now]){
                    flag=false;
                    break;
                }
    
            }else{
                way[temp++]=2;
                now++;
            }
        }
        while (!stk.empty()&&flag){//把栈中的输出
            if(stk.top()==b[now]){
                stk.pop();
                now++;
                way[temp++]=3;
            } else{
                flag=false;
            }
        }
        if(flag){
            for (int i = 0; i < temp; ++i) {
                if(way[i]==1)cout<<"1->3"<<endl;
                if(way[i]==2)cout<<"1->2"<<endl;
                if(way[i]==3)cout<<"3->2"<<endl;
            }
        } else{
            cout<<"Are you kidding me?"<<endl;
        }
    }
    
    展开全文
  • 【PTA】7-1 列车厢调度

    2022-01-18 15:09:27
    7-1 列车厢调度 1 ====== <--移动方向 / 3 ===== \ 2 ====== -->移动方向 有三条平行的列车轨道(1、2、3)以及1-3和2-3两段连接轨道。现有一列车厢停在1号轨道上,请利用两条连接轨道以及3号轨道,将...

    7-1 列车厢调度

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

    有三条平行的列车轨道(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中的列车进入轨道3之后,检查所要求轨道2中的列车顺序。在每一次的检查中确定列车的操作序列。根据实验要求,共可列出以下几种情况:
    1.轨道3为空,若待进入轨道3的轨道1中的列车与轨道2中的目的列车不相同,则1->3,检查轨道1中下一列车。
    2.轨道3为空,若待进入轨道3的轨道1中的列车与轨道2中的目的列车相同,则1->2,检查轨道1中下一列车和轨道2中下一列车。
    3.轨道3不为空,若待进入轨道3的轨道1中的列车与轨道2中的目的列车相同,则1->2,检查轨道1中下一列车和轨道2中下一列车。
    4.轨道3不为空,若待进入轨道3的轨道1中的列车与轨道2中的目的列车相同,则1->2,检查轨道1中下一列车和轨道2中下一列车。
    5.轨道3不为空,若待进入轨道3的轨道1中的列车与轨道2中的目的列车不相同且轨道3中最外层列车与轨道2中目的列车相同,则3->2,检查轨道2中下一列车。
    6.轨道3不为空,若轨道1中无列车且轨道3中最外层列车与轨道2中目的列车不相同,则无法实现,结束程序。
    轨道3不为空,若待进入轨道3的轨道1中的列车与轨道2中的目的列车不相同,且轨道3中最外层列车与轨道2中目的列车不相同,则1->3,检查轨道1中下一列车。

    代码:

    #include<iostream>
    using namespace std;
    
    typedef struct {
    	int stacksize;
    	char *base;
    	char *top;
    }sqstack; 
    
    void initstack(sqstack &s)
    {
    	s.base = (char*)malloc(26*sizeof(char));
    	s.top = s.base;
    	s.stacksize = 26;
    }
    
    void push(sqstack &s,char a)
    {
    	*s.top++ = a;
    }
    
    void pop(sqstack &s,char &a)
    {
    	a = *(--s.top);
    }
    
    int empty(sqstack s)   //判断栈是否为空 
    {  if(s.top==s.base) return 1;
       else return 0;
    }
    
    char gettop(sqstack s)
    {
    	return *(s.top-1);
    }
    
    void print(int a[26])
    {
      for(int i=0;a[i]!='\0';i++)
        if(a[i]==1) printf("1->3\n");
        else if(a[i]==2) printf("1->2\n");
        else if(a[i]==3) printf("3->2\n");
    } 
    
    int main()
    {
    	sqstack l3, l2;
    	initstack(l3);
    	initstack(l2);
    	string a1,a2;
    	cin>>a1;
    	cin>>a2;
    	int i=0,j=0,k=0;
        static int a[26];
    	char z;
    	while(a1[i]!='\0' || a2[j]!='\0'){
    		if(empty(l3)) 
    		{
    			if(a1[i]!=a2[j])
    			{
    				a[k++] =1;
    				push(l3,a1[i]);
    				i++;
    				continue;
    			}
    			if(a1[i]==a2[j])
    			{
    				a[k++]=2;
    				push(l2,a1[i]);
    				i++;
    				j++;
    				continue;
    			}
    		}
    		if(!empty(l3)){
    			if(a1[i]==a2[j])
    			{
    				a[k++]=2;
    				push(l2,a1[i]);
    				i++;
    				j++;
    				continue;
    			}
    			if(a1[i]!=a2[j] && gettop(l3)==a2[j])
    			{
    				a[k++]=3;
    				pop(l3,z);
    				push(l2,z);
    				j++;
    				continue;
    			}
    			if(gettop(l3)!=a2[j] && a1[i]=='\0')
    			{
    				cout<<"Are you kidding me?"<<endl;
    				return 0;
    			}
    			if(a1[i]!=a2[j] && gettop(l3)!=a2[j])
    			{
    				a[k++] =1;
    				push(l3,a1[i]);
    				i++;
    				continue;
    			}
    		}
    	}
    	print(a);
    	return 0;
    }
    

    总结

    该题的关键在于要考虑到各字符匹配的各种可能情况。要理解各字符之间相同或不同代表的意义,从而得知列车调度的最短操作序列。在检查的过程中注意将信息存入一数组,这样在输出时使用print函数通过对数组总信息的读取即可完成操作序列的打印。

    展开全文
  • 大家或许在某些数据结构教材上见到过“列车厢调度问题”(当然没见过也不要紧)。今天,我们就来实际操作一下列车厢的调度。对照上方的ASCII字符图,问题描述如下: 有三条平行的列车轨道(1、2、3)以及1-3和2-3两...
            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?
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #define MAXSIZE 26
    
    enum solution {
    	OneToTwo,
    	ThreeToTwo,
    	OneToThree
    };
    //枚举类型,代表解决方法
    
    typedef struct {
    	char base[MAXSIZE];
    	int top;
    	int stacksize; 
    }*stack,stackNode;
    
    stack initStack() {
    	stack s = (stack)malloc(sizeof(stackNode));
    	s->top = 0;
    	s->stacksize = MAXSIZE;
    	return s;
    }
    
    void push(stack s,char e) {
    	s->base[s->top++] = e;
    }
    
    char pop(stack s) {
    	char e = s->base[--s->top];
    	return e;
    }
    
    char getTop(stack s) {
    	return s->base[s->top-1];
    }
    
    int isEmpty(stack s) {
    	if (s->top==0) {
    		return 1;
    	}
    	else {
    		return 0;
    	}
    }
    
    int main() {
    	char str1[MAXSIZE+1];
    	char str2[MAXSIZE+1];
    	int record[100];
    	stack s1 = initStack();
    	stack s2 = initStack();
    	stack s3 = initStack();
    
    	scanf("%s", str1);
    	int len1 = strlen(str1);
    	for (int i = len1 - 1; i >= 0; i--) {
    		push(s1, str1[i]);
    	}
    	//根据栈的特性,将读入的序列逆序入栈
    	scanf("%s", str2);
    	int len2 = strlen(str2);
    	for (int i = len2 - 1; i >= 0; i--) {
    		push(s2, str2[i]);
    	}
    	//根据栈的特性,将读入的序列逆序入栈
    	int cnt = 0;//解决方案的计数器
    	int flag = 1;//是否满足匹配合理性的标志
    	while (!isEmpty(s2)) {
    		//当s2不为空时,循环匹配
    		if (!isEmpty(s1) && getTop(s1) == getTop(s2)) {
    			pop(s1);
    			pop(s2);
    			record[cnt++] = OneToTwo;
    		}
    		//情形一:轨道1和轨道2直接匹配
    		else if (!isEmpty(s3) && getTop(s3) == getTop(s2)) {
    			pop(s3);
    			pop(s2);
    			record[cnt++] = ThreeToTwo;
    		}
    		//情形二:轨道2和轨道3匹配,即简介匹配
    		else if (isEmpty(s1)) {
    			flag = 0;
    			break;
    		}
    		//情形三:在循环中轨道1已经完全匹配,肯定出错,跳出循环
    		else {
    			push(s3, pop(s1));
    			record[cnt++] = OneToThree;
    		}
    		//情形四:暂时不能匹配,将轨道1栈顶存入轨道3
    	}
    	if (flag == 0) {
    		printf("Are you kidding me?");
    	}
    	else {
    		for (int i = 0; i < cnt; i++) {
    			if (record[i] == OneToTwo) printf("1->2\n");
    			if (record[i] == ThreeToTwo) printf("3->2\n");
    			if (record[i] == OneToThree) printf("1->3\n");
    		}
    	}
    	//输出结果
    	return 0;
    }
    
    

    声明:代码转载,侵权即删。

    展开全文
  • 1-4 列车厢调度 (25分)

    2020-10-30 10:42:59
    1-4 列车厢调度 (25分) 大家或许在某些数据结构教材上见到过“列车厢调度问题”(当然没见过也不要紧)。今天,我们就来实际操作一下列车厢的调度。对照上方的ASCII字符图,问题描述如下: 有三条平行的列车轨道(1...
  • 1-4 列车厢调度 (25 分)

    2021-10-23 20:56:52
    大家或许在某些数据结构教材上见到过“列车厢调度问题”(当然没见过也不要紧)。今天,我们就来实际操作一下列车厢的调度。对照上方的ASCII字符图,问题描述如下: 有三条平行的列车轨道(1、2、3)以及1-3和2-3两...
  • PTA 7-1 列车厢调度 1 ====== <–移动方向 / 3 ===== 2 ====== -->移动方向 大家或许在某些数据结构教材上见到过“列车厢调度问题”(当然没见过也不要紧)。今天,我们就来实际操作一下列车厢的调度。...
  • PTA-7.1-列车厢调度(栈的应用)

    千次阅读 2020-10-23 17:17:59
    我们可以更具体地来讨论: ①假如1轨的栈顶就是C,显然C来自1轨 ②3轨栈顶就是C,则来自3轨 ③假如不是前两种情况,也不能断定调度出了错误,我们能做的只有把1轨的栈顶出栈,让他进到3轨 ④如果1轨已经空则无法...
  • 问题遇到的现象和发生背景 问题相关代码,请勿粘贴截图 运行结果及报错内容 我的解答思路和尝试过的方法 我想要达到的结果 #include #include #include #define maxsize 26 typedef struct { char *base;...
  • 数据结构 c语言 列车厢调度

    千次阅读 2020-05-14 10:10:21
    大家或许在某些数据结构教材上见到过“列车厢调度问题”(当然没见过也不要紧)。今天,我们就来实际操作一下列车厢的调度。对照上方的ASCII字符图,问题描述如下: 有三条平行的列车轨道(1、2、3)以及1-3和2-3两...
  • pta列车厢调度

    2020-10-24 17:08:04
    列车厢调度 (15分) 1 ====== <--移动方向 / 3 ===== \ 2 ====== -->移动方向 大家或许在某些数据结构教材上见到过“列车厢调度问题”(当然没见过也不要紧)。今天,我们就来实际操作一下列车厢的调度...
  • PTA(列车厢调度) 代码: Rails 题意: A顺序1-n,给出到达B的顺序。中间可以先放到station,但是从station中只能从顶端取出。 经典模拟栈: 基本思想: 一个指向A,一个指向B,如果pa=pb,直接从A移动到B。...
  • 7-2 列车厢调度(python)

    2021-09-25 14:35:29
    大家或许在某些数据结构教材上见到过“列车厢调度问题”(当然没见过也不要紧)。今天,我们就来实际操作一下列车厢的调度。对照上方的ASCII字符图,问题描述如下: 有三条平行的列车轨道(1、2、3)以及1-3和2-3两...
  • PTA7-1 列车厢调度

    2021-10-24 22:08:50
    大家或许在某些数据结构教材上见到过“列车厢调度问题”(当然没见过也不要紧)。今天,我们就来实际操作一下列车厢的调度。对照上方的ASCII字符图,问题描述如下: 有三条平行的列车轨道(1、2、3)以及1-3和2-3两...
  • 7-5 列车厢调度 (25 分)

    千次阅读 2019-07-16 14:55:55
    7-5 列车厢调度 (25 分) 1 ====== <--移动方向 / 3 ===== \ 2 ====== -->移动方向 大家或许在某些数据结构教材上见到过“列车厢调度问题”(当然没见过...
  • 列车厢调度 (25 分)

    2019-11-16 10:38:56
    #include <stdio.h> #include <string.h> #include <stdlib.h> char s1[1000], s2[1000], stack[1000], ans[3000][8]; int top = -1, cnt = 0, top1 = 0; int main(){ scanf("%s%s",s1,s2);...
  • 列车厢调度 (25分)

    2020-05-18 22:44:08
    大家或许在某些数据结构教材上见到过“列车厢调度问题”(当然没见过也不要紧)。今天,我们就来实际操作一下列车厢的调度。对照上方的ASCII字符图,问题描述如下: 有三条平行的列车轨道(1、2、3)以及1-3和2-3两...
  • 大家或许在某些数据结构教材上见到过“列车厢调度问题”(当然没见过也不要紧)。今天,我们就来实际操作一下列车厢的调度。对照上方的ASCII字符图,问题描述如下: 有三条平行的列车轨道(1、2、3)以及1-3和...
  • 7-6 列车厢调度 (25 分)

    2019-11-17 16:47:01
    大家或许在某些数据结构教材上见到过“列车厢调度问题”(当然没见过也不要紧)。今天,我们就来实际操作一下列车厢的调度。对照上方的ASCII字符图,问题描述如下: 有三条平行的列车轨道(1、2、3)以及1-3和2-3两...
  • 7-9 列车厢调度 (25 分)

    2022-04-10 21:22:56
    大家或许在某些数据结构教材上见到过“列车厢调度问题”(当然没见过也不要紧)。今天,我们就来实际操作一下列车厢的调度。对照上方的ASCII字符图,问题描述如下: 有三条平行的列车轨道(1、2、3)以及1-3和2-3两...
  • 1-4 列车厢调度 (25 分)

    千次阅读 2019-08-31 09:42:54
    1-4列车厢调度(25分) 1 ====== <--移动方向 / 3 ===== \ 2 ====== -->移动方向 大家或许在某些数据结构教材上见到过“列车厢调度问题”(当然没见过也不要紧)。今天,我们就来实际操作一下列车厢...
  • 7-11 列车厢调度(25 分)(栈)

    千次阅读 2018-03-14 09:25:09
    大家或许在某些数据结构教材上见到过“列车厢调度问题”(当然没见过也不要紧)。今天,我们就来实际操作一下列车厢的调度。对照上方的ASCII字符图,问题描述如下: 有三条平行的列车轨道(1、2、3)以及1-3和2...
  • PTA P7列车厢调度

    2019-09-18 19:26:55
    栈的简单应用 #include <stdlib.h> #include <cstdio> #include <iostream> #include <queue> #include <stack> #include <string.h> #include <...algori...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 517
精华内容 206
关键字:

列车厢调度