Question

求C++大师指导 这个问题的解决思路是什么？ 有源码最好啊 感谢

列车出站
每一时刻，列车可以从入口车站或直接从入口进入出口，再或者从车站进入出口。即每一时刻可以有一辆车沿着箭头a或b或c的方向行驶。
现在有一些车在入口处等待，它们要通过上述的方式从出口出来，现在你要统计出所有可能的出站序列。

例如当入口是ABC时，可能的出站序列有ABC,ACB,BAC,BCA,CBA
[基本要求]
输入
一个串，入站序列。

输出
所有可能的出站序列，按字典序从小到大排列。
每个一行

Answer 1

的代码，或解释相关的数据？

---------------------------------
代码： / a>
两个文件：
--------------------------
1。 md5.h：

＃pragma一次

typedef无符号长整型UINT32;
typedef无符号短整型UINT16;

/ * MD5上下文。 * /
typedef结构{
UINT32状态[4]; /?? *状态（ABCD）* /
UINT32计数[2]; / *数位模2 ^ 64（ LSB在前）* /
无符号的字符缓冲区[64]; /?? *输入缓冲区* /
} MD5_CTX

的无效MD5Init（MD5_CTX *）;
的无效MD5Update（MD5_CTX *，无符号的char *，无符号整数）;
无效MD5Final（无符号char [16]，MD5_CTX *）;

--- -----------------------
2。 MD5.CPP：

＃包括“md5.h的”

包括“memory.h”

定义S11 7
定义S12 12
定义S13月17日
定义S14 22
定义S21 5
定义S22
＃定义S23 14
定义S24 20
定义S31 4
定义S32 11
定义S33 16
定义S34 23
的＃define S41
定义S42 10
定义S43 15
定义S44 21

的静态无效MD5Transform（UINT32 [4]为unsigned char B [ 64]）;
静态无效的编码（无符号字符*，UINT32 *，无符号整数），
的静态无效解码（UINT32 *，无符号的char *，无符号整数）;

静态无符号字符PADDING [64] = {
80H时，0，0，0，0，0，0，0，0，0，0，0，0，0，0，0，0，0，0 ，0，0，0，
0，0，0，0，0，0，0，0，0，0，0，0，0，0，0，0，0，0，0，0 ，0，0，0，
0，0，0，0，0，0，0，0，0，0，0，0，0，0，0，0，0，0，0 />};

定义F（X，Y，Z）（（（X）和（Y））|（（X）和（Z）））
＃ G（，z）的（（（x）的＆（z）的）|（（y）的＆（?z）的））
＃定义H（下的x，，z）的（（x）的^（ Y）^（Z））
定义I（X，Y，Z）（（Y）^（（x）|（Z）））

定义ROTATE_LEFT（X，N）（（（x）的<>（32 - （正））））

＃定义FF（一，二， C，D中，x，，交流）{\
（一）+ = F（（b）和（c）中，（四））+（x）的+（UINT32）（交流）; \ />（A）= ROTATE_LEFT（（A），（S））; \
（A）+（B）; \
}
定义GG（A，B，C ，D，X，，交流）{\
（一）+ = G（（二），（三），（四））+（x）的+（UINT32）（交流）; \ （）= ROTATE_LEFT（（一），（））; \
（一）+（二）\
}
＃定义HH（，B，C， D，X，，交流）{\
（一）+ = H（（二），（三），（四））+（x）的+（UINT32）（交流）; \
（A）= ROTATE_LEFT（（），（））; \
（A）+（B）; \
}
定义II（A，B，C，D中，x，，交流）{\
（一）+ = I（（二），（三），（四））+（x）的+（UINT32）（交流）; \
（ A）= ROTATE_LEFT（（A），（S））; \
（A）+（B）; \
}

无效MD5Init（MD5_CTX *上下文）
{
上下文计数[0] =上下文计数[1] = 0;

上下文状态[0] = 0x67452301; ...... />上下文状态[1] = 0xefcdab89;
上下文>状态[2] = 0x98badcfe;
上下文>状态[3] = 0x10325476;
}
BR />
无效MD5Update（MD5_CTX的情况下，无符号的char *输入，无符号整数inputLen）
{
无符号整型我，索引，partLen;

指数= （无符号整数）（（上下文数[0] >> 3）＆0x3F）;

（（上下文计数[0] + =（（UINT32）inputLen << 3） ）
<（（UINT32）inputLen << 3））
上下文计数[1] + +;
上下文计数[1] + =（（UINT32）inputLen >> 29）;

partLen = 64 - 指数;

（inputLen> = partLen的）{
的memcpy（（无符号字符*）和上下文 - >缓冲[索引]，（无符号字符*）输入，partLen）;
MD5Transform（上下文状态，上下文缓冲区）;

（I = partLen，我+ 63 <inputLen; + = 64）
MD5Transform（上下文状态，与输入[I]）;

指数= 0;
}
其他 BR />我= 0;

用memcpy（（无符号字符*）上下文缓冲液[索引]，（无符号的char *）＆输入[I]，
inputLen-I）
}

无效MD5Final（无符号字符文摘[16]，MD5_CTX *上下文）
{
位无符号的字符[8];
unsigned int类型指数，padLen

编码（位，上下文计数，8）;

指数=（无符号整数）（（上下文计数[0] >> ）＆0x3f）;
padLen =（指数<56）？ （56 - 指数）：（120 - 指数）;
MD5Update（背景，填充，padLen）;

MD5Update（上下文，位，8）;

编码（摘要，上下文状态，16）;

memset的（（无符号字符*）的情况下，0，sizeof（上下文）的）;
}

静态无效的MD5Transform（UINT32状态[4]，无符号??的字符块[64]）
{
UINT32 =状态[0]，B =状态[1]，C =状态[ 2]，D =状态[3]，X [16];

解码（X，块，64）;

/ *第1轮* /
FF（A，B，C，D，X [0]，S11，0xd76aa478）; / * 1 * /
FF（D，A，B，C，X [1]，S12，0xe8c7b756）; / * 2 * /
FF（C，D，A，B，X [2]，S13，0x242070db）的; / * 3 * /
FF（B，C，D，A，X [3 ，S14，0xc1bdceee）; / * 4 * /
FF（A，B，C，D，X [4]，S11，0xf57c0faf）; / * 5 * /
FF（D，一，B，C，X [5]，S12，0x4787c62a）; / * 6 * /
FF（C，D，A，B，X [6]，S13，0xa8304613）; / * 7 * / BR /> FF（B，C，D，A，X [7]，S14，0xfd469501）; / * 8 * /
FF（A，B，C，D，X [8]，S11，0x698098d8 ）; / * 9 * /
FF（D，A，B，C，X [9]，S12，0x8b44f7af）; / * 10 * /
FF（C，D，A，B， X [10]，S13，0xffff5bb1）; / * 11 * /
FF（B，C，D，A，X [11]，S14，0x895cd7be）; / * 12 * /
FF（ A，B，C，D，X [12]，S11，0x6b901122）; / * 13 * /
FF（D，A，B，C，X [13]，S12，0xfd987193）; / * 14 * /
FF（C，D，A，B，X [14]，S13，0xa679438e）; / * 15 * /
FF（B，C，D，A，X [15] S14，0x49b40821）; / * 16 * /

/ *第2轮* /
GG（A，B，C，D，X [1]，S21，0xf61e2562）; / * 17 * /
GG（D，A，B，C中，x [6]，S22中，0xc040b340）/ * 18 * /
GG（三，D，一，B中，x [11]; ，S23，0x265e5a51）; / * 19 * /
GG（B，C，D，A，X [0]，S24，0xe9b6c7aa）; / * 20 * /
GG（A，B， C，D，X [5]，S21，0xd62f105d）; / * 21 * /
GG（D，A，B，C，X [10]，S22，0x2441453）; / * 22 *?? /
GG（C，D，一，B中，x [15]，S23中，0xd8a1e681），/ * 23 * /
GG（二，C，D，一个中，x [4]，S24， 0xe7d3fbc8）; / * 24 * /
GG（A，B，C，D，X [9]，S21，0x21e1cde6）; / * 25 * /
GG（D，A，B，C中，x [14]，S22中，0xc33707d6）/ * 26 * /
GG（三，D，一，B中，x [3]，S23中，0xf4d50d87），/ * 27 * /
GG （B，C，D，A，X [8]，S24，0x455a14ed）; / * 28 * /
GG（A，B，C，D，X [13]，S21，0xa9e3e905）; / * 29 * /
GG（D，A，B，C中，x [2]，S22中，0xfcefa3f8）/ * 30 * /
GG（三，D，一，B中，x [7]; ，S23，0x676f02d9）; / * 31 * /
GG（B，C，D，A，X [12]，S24，0x8d2a4c8a）; / * 32 * /

/ *第3轮* /
HH（A，B，C，D，X [5]，S31，0xfffa3942）; / * 33 * /
HH（D，A，B，C，X [8 ，S32，0x8771f681）; / * 34 * /
HH（C，D，A，B，X [11]，S33，0x6d9d6122）; / * 35 * /
HH（B，C ，D，A，X [14]，S34，0xfde5380c）; / * 36 * /
HH（A，B，C，D，X [1]，S31，0xa4beea44）; / * 37 * / BR /> HH（D，A，B，C，X [4]，S32，0x4bdecfa9）; / * 38 * /
HH（C，D，A，B，X [7]，S33，0xf6bb4b60的）; / * 39 * /
HH（B，C，D，A，X [10]，S34，0xbebfbc70）; / * 40 * /
HH（A，B，C，D， X [13]，S31，0x289b7ec6）; / * 41 * /
HH（D，A，B，C，X [0]，S32，0xeaa127fa）; / * 42 * /
HH（ C，D，A，B，X [3]，S33，0xd4ef3085）; / * 43 * /
HH（B，C，D，A，X [6]，S34，0x4881d05）; / * 44 * /
HH（A，B，C，D，X [9]，S31，0xd9d4d039）; / * 45 * /
HH（D，A，B，C，X [12] S32，0xe6db99e5）; / * 46 * /
HH（C，D，A，B，X [15]，S33，0x1fa27cf8）; / * 47 * /
HH（B，C，D ，A，X [2]，S34，0xc4ac5665的）; / * 48 * /

/ *第4轮* /
II（A，B，C，D，X [0] S41，0xf4292244）; / * 49 * /
II（D，A，B，C，X [7]，S42，0x432aff97的）; / * 50 * /
II（C，D， A，B，X [14]，S43，0xab9423a7）; / * 51 * /
II（B，C，D，A，X [5]，S44，0xfc93a039）; / * 52 * / /> II（A，B，C，D，X [12]，S41，0x655b59c3）; / * 53 * /
II（D，A，B，C，X [3]，S42，0x8f0ccc92） / * 54 * /
II（C，D，A，B，X [10]，S43，0xffeff47d）; / * 55 * /
II（B，C，D，A，X [1]，S44，0x85845dd1的）; / * 56 * /
II（A，B，C，D，X [8]，S41，0x6fa87e4f）; / * 57 * /
II（D ，A，B，C，X [15]，S42，0xfe2ce6e0）; / * 58 * /
II（C，D，A，B，X [6]，S43，0xa3014314）; / * 59 * /
II（B，C，D，A，X [13]，S44，0x4e0811a1）; / * 60 * /
II（A，B，C，D，X [4]，S41 0xf7537e82）; / * 61 * /
II（D，A，B，C，X [11]，S42，0xbd3af235）; / * 62 * /
II（C，D，， B，X [2]，S43，0x2ad7d2bb）; / * 63 * /
II（B，C，D，A，X [9]，S44，0xeb86d391）; / * 64 * /

状态[0] + = A;
状态[1] + = B;
状态[2] + = C;
状态[3] + = D; ...... / a>
memset的（（unsigned char型）X，0，sizeof（X）的）;
}

静态无效的编码（无符号字符*输出，UINT32 *输入，无符号LEN）
{
无符号整数I，J;

为（我= 0，J = 0，J <LEN，我+ +，J + = 4）{
输出[J] =（unsigned char型）（输入[I]＆0xff）的;
输出[J +1] =（unsigned char型）（（输入[I] >> 8）＆0xff的）
输出[J +2] =（unsigned char型）（（输入[I] >> 16）＆0xff）的;
输出[J +3] =（unsigned char型）（（输入[ >> 24）＆0xff）的;
}
}

的静态无效解码（UINT32 *输出，输入，无符号整型无符号的char * LEN） /> {
无符号整数I，J;

（I = 0，J = 0; J <长度，我+ +，J + = 4）
输出我] =（（UINT32）输入[J]）|（（（UINT32）输入[J +1]）<< 8）|
（（（UINT32）输入[J +2]）<< 16） |（UINT32（（中）输入[J +3]）<< 24）;
}

----------- ---------------
这两个文件。在他们参加的项目或makefile文件称为包含md5.h可以举一个简单的例子，输入一个字符串，然后计算出的MD5值和输出，VC6.0和GCC4.4测试通过：

/>＃包括
包括中

＃包括“md5.h的”

（） {
字符tmp目录[128];
无符号的字符文摘[16];

MD5_CTX范围内;

scanf函数（“％s”，TMP ）;

MD5Init（上下文）;
MD5Update（上下文，（无符号字符*）TMP，strlen的（TMP））;
MD5Final（摘要，及上下文）;

printf的（“MD5Value：”）;
（INT I = 0; I <16; + + i）
{
printf的（“％02X”摘要[我]）;
}
printf的（“\ n”）;

返回0;
}

Answer 2

递归算法。假定车辆的序列是个英文字母序列（每个车用一个字母代表）。
选择第一辆车，进入子过程。
子过程：
遍历该车可用的路线：从a路线通过，让a路线的旗标置为0（不允许其它车选择该通道）；从b路线通过，同理；从c路线通过，同理。当它抵达目的地（包括车站）时，让旗标重置为1。并判断该车所在位置是否是出口，是则记录应该输出的信息（字符串记录）。选择下一辆车，直到下一辆车为空，当下一辆车不存在时输出输出信息。进入子过程。

追问

不是很懂 能上代码么？
好的加分

追答

……早讲啊……现在我要忙着准备考试，一直到1月18日都没空。要不你先写，不懂的地方我可以教你，QQ：1194315273