¿Podemos resolver el problema DISHOWN usando C ++ STL? ¿Si es así, entonces cómo?

#include

usando el espacio de nombres estándar;

Unión vacía (std :: vector & score, std :: vector & chefs, int x, int y);

int parent (std :: vector & chefs, int index);

int main (int argc, char const * argv [])

{

/ * código * /

int t, no_of_chefs, temp, consultas;

cin >> t;

mientras que (t–)

{

std :: vector puntaje;

std :: vector cocineros;

// cin >> no_of_chefs;

scanf (“% d”, & no_of_chefs);

para (int i = 0; i <no_of_chefs; ++ i)

{

/ * código * /

chefs.push_back (i + 1);

}

para (int i = 0; i <no_of_chefs; ++ i)

{

/ * código * /

// cin >> temp;

scanf (“% d”, & temp);

score.push_back (temp);

}

// cin >> consultas;

scanf (“% d”, & consultas);

int estado, x, y;

para (int i = 0; i <consultas; ++ i)

{

/ * código * /

// cin >> estado;

scanf (“% d”, & estado);

si (estado == 1)

{

// 1 significa salida padre

// cin >> x;

scanf (“% d”, & x);

int t = padre (chefs, x);

// cout << t << endl;

printf (“% d \ n”, t);

}más{

// 0 significa unirlos

// cin >> x >> y;

scanf (“% d% d”, & x, & y);

Unión (puntaje, chefs, x, y);

}

}

}

devuelve 0;

}

Unión nula (std :: vector & score, std :: vector & chefs, int x, int y) {

int px = padre (chefs, x);

int py = padre (chefs, y);

si (px == py)

{

// cout << "¡Consulta inválida!" << endl;

printf (“Consulta inválida! \ n”);

}más{

if (puntaje [px-1]> puntaje [py-1])

{

// puntuación [px-1] + = puntuación [py-1];

cocineros [py-1] = px;

} else if (puntaje [px-1] <puntaje [py-1]) {

// puntuación [py-1] + = puntuación [px-1];

cocineros [px-1] = py;

}más{

//hacer nada

}

}

}

int parent (std :: vector & chefs, int index) {

if (chefs [index-1] == index)

{

índice de retorno;

}

chefs [index-1] = padre (chefs, chefs [index-1]);

chefs de retorno [index-1];

}

// PS => cin y cout están dando TLE, así que usa printf y scanf.