[Copa Blue Bridge] ALGO-380 dibuja un mapa

Entrenamiento del algoritmo de preguntas de prueba y mapa de dibujo

Límite de recursos

Límite de tiempo: 1,0 s Límite de memoria: 256,0 MB

Descripción del problema

　　Recientemente, WYF se está preparando para visitar su fábrica de tarjetas. El gerente de WYF Group Cyanide Waste necesita ayudar a WYF a diseñar la ruta de "vista". Ahora, el desperdicio de cianuro sabe algunas cosas:
　　1. La fábrica de tarjetas de puntos de WYF constituye un árbol binario.
　　2. Hay un total de n fábricas.
　　3. Necesita enumerar los puntos en el árbol para poder recorrer el método para dibujar el mapa.
　　Afortunadamente, recientemente sus subordinados le dieron los datos para el recorrido de primer orden y el recorrido de orden medio. Sin embargo, los desechos de cianuro tienen que ayudar a Nazawa a resolver algunos problemas recientemente, por lo que no hay tiempo. Por favor ayúdelo y complete esta tarea por él. Debido a algunos requisitos especiales de los desechos de cianuro, la ruta del recorrido de WYF será el cruce posterior de este árbol.

Formato de entrada

　　Un número entero n en la primera línea representa un total de n fábricas.
　　Hay n números enteros en la segunda línea, lo que significa recorrido de preorden.
　　Los n enteros en la tercera línea representan el recorrido de orden medio.

Formato de salida

　　La salida es una línea que contiene n números enteros, que es un recorrido posterior al pedido.

Entrada de muestra

8
1 2 4 5 7 3 6 8
4 2 7 5 1 8 6 3

Salida de muestra

4 7 5 2 8 6 3 1

Tamaño de datos y convención

　　0 <n <100000 ,. Asegúrese de que el recorrido de preorden y el recorrido de orden medio sean legales, y que ambos sean de 1 an.

 

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std; 

unordered_map<int, int> index;

struct TreeNode {
	int val;
  	TreeNode *left;
	TreeNode *right;
	TreeNode() : val(0), left(NULL), right(NULL) {}
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
	TreeNode(int x, TreeNode *left, TreeNode *right){
		this->val = val;
		this->left = left;
		this->right = right;
	}
};

TreeNode* myBuildTree(const vector<int>& preorder, const vector<int>& inorder, int pre_left, int pre_right, int in_left, int in_right){
	if (pre_left > pre_right){
		return NULL;
	} 	
	int pre_root = pre_left;
	int in_root = index[preorder[pre_root]];
	
	TreeNode* root = new TreeNode(preorder[pre_root]);
	int size_left_subTree = in_root - in_left;
	
	root->left = myBuildTree(preorder, inorder, pre_left+1, pre_left+size_left_subTree, in_left, in_root-1);
	root->right = myBuildTree(preorder, inorder, pre_left+size_left_subTree+1, pre_right, in_root+1, in_right);
	return root;
}

void backTraverse(TreeNode* root, vector<int>& res){
	if(root == NULL){
		return ;
	}
	backTraverse(root->left, res);
	backTraverse(root->right, res);
	res.push_back(root->val);
}
	
	
int main() {
	int n;
	cin >> n;
	vector<int>  preorder(n);
	vector<int>  inorder(n);
	for(int i = 0; i < n; i++){
		cin >> preorder[i];
	}	
	for(int i = 0; i < n; i++){
		cin >> inorder[i];
	}	

	for(int i = 0; i < n; i++){
		index[inorder[i]] = i;
	}
	TreeNode* root = myBuildTree(preorder, inorder, 0, n-1, 0, n-1);
	vector<int> res;
	backTraverse(root, res);
	for(int i = 0; i < n; i ++){
		cout << res[i] << " ";
	}

	
	return 0;
}