Descripción del problema: entre ellos, A es la entrada, B es la salida y S es el extremo ciego de la transferencia. Todos los ferrocarriles son monorraíl y de sentido único: la dirección del tren solo puede ser de A a S, y luego de S a B; además, no se permite adelantar. Debido a que los autos pueden estacionarse en S, el orden en el que salen del extremo B puede ser diferente del orden en el que entran desde el extremo A. Sin embargo, la capacidad del S es limitada y el número de coches aparcados al mismo tiempo no puede superar los m secciones.
Suponga que un tren se compone de n vagones cuyos números son {1, 2,…, n}. El despachador desea saber, de acuerdo con las reglas de tráfico anteriores, si estos vagones se pueden reorganizar en el orden de {a1, a2,…, an} y salir por el extremo B. Si es posible, ¿en qué orden?
Función básica: la entrada contiene varios casos de prueba. Cada caso de prueba consta del número de trenes, un número entero y una cadena de caracteres. El orden de los trenes es: O1. La entrada termina al final del archivo.
La salida contiene la cadena "No". Si no puede convertir O2 en O1, o debe generar la salida de la forma en que intercambia órdenes (debe generar "push" para indicar que el tren ingresa al ferrocarril y "pop" para indicar que el tren sale del ferrocarril).
(Para obtener más información, consulte las muestras de entrada y salida)
Datos de prueba:
Entrada de muestra
5 2
1 2 3 5 4
5 5
3 1 2 4 5
Salida de muestra
push
pop
push
pop
push
pop
push
push
pop
pop
No
Lógica de implementación: para la primera entrada de muestra, dejamos entrar la primera columna y luego dejamos que salga la primera columna. Luego deje entrar la segunda columna y luego deje salir la segunda columna. Entra el tren 3, sale el tren 3. Tren No. 4, Tren No. 5 ingrese uno a uno, y finalmente salga uno por uno.
En la segunda entrada de muestra, debemos dejar que el tren n. ° 3 salga primero, por lo que debemos dejar que entre el tren n. ° 1 y luego entren los trenes n. ° 2 y n. ° 3.
Ahora podemos dejar salir el tren número 3.
Pero después de eso, no podemos dejar que el tren número 1 salga antes que el tren número 2, porque el tren número 2 se encuentra actualmente en la parte superior del ferrocarril.
Así que mostramos "No.".
Contenido del código:
//1-n编号车厢按照“栈混洗”从A->S->B，最终确认车厢B处是否可以按照某一序列排列
//一种栈结构输出不要用strcat进行字符链接输出（会TLE）
//双向链表模拟
#include<iostream>
#include<string>
using namespace std;
#define MAX 1600005
//A->S->B
/*构建双向链表*/
struct Train {
int num;
Train* up;
Train* down;
Train(int n) :num(n) {
}
}*header, * tailer;//前后哨兵
int target[MAX];
bool output[2 * MAX];
int k;
/*构建*/
void Creat_Train(int n) {
header = new Train(0);
header->up = NULL;
Train* rear = header;//定义尾针
for (int i = 1; i <= n; i++) {
Train* p = new Train(i);//新链表元素
rear->down = p;
p->up = rear;
rear = p;
}
tailer = new Train(0);
rear->down = tailer;
tailer->up = rear;
tailer->down = NULL;
}
/*删除*/
void Delete(Train* p) {
p->up->down = p->down;
p->down->up = p->up;
delete p;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++)//目标序列
cin >> target[i];
Creat_Train(n);
int counter = 0;//s站车厢数量
Train* cur = header->down;
/*开始匹配第i个目标车厢*/
for (int i = 1; i <= n; i++) {
if (cur->num == target[i]) {
//A栈顶匹配
Train* tmp = cur;
cur = cur->down;
Delete(tmp);//删除车厢结点
if (counter + 1 > m) {
//s滞留车厢过多
cout << "No\n";
return 0;
}
output[k++] = true;
output[k++] = false;
}
else if (cur->up->num == target[i]) {
//s栈顶匹配
Delete(cur->up);
output[k++] = false;
counter--;
}
else {
//A->S
cur = cur->down;
--i;
counter--;
if (cur->down == NULL || counter > m) {
//A空或s滞留车厢过多
cout << "No\n";
return 0;
}
output[k++] = true;
}
}
/*Output*/
for (int i = 0; i < k; i++) {
if (output[i]) cout << "push\n";
else cout << "pop\n";
}
return 0;
}
Referencia https://www.cnblogs.com/Inkblots/p/4950331.html