/** @brief El progrma utilizara las clases Especie, Area, Cjt_especies y Cjt_areas
*/
int main() {
Cjt_especies c;
c.leer_cjt_especies();
int R = readint();
int n = c.num_especies();
Cjt_areas E(R,n) ;
E.leer_cjt_areas();
int accion = readint();
while (accion != -6) {
if (accion == -1) {
E.lucha_especies(c);
}
else if (accion == -2) {
int t = readint();
int r = readint();
int e = readint();
int h = readint();
int g = readint();
Arbre<int> b = E.arbol_areas();
if (t == 1) {
if (r != b.arrel()) {
Arbre <int> a1;
Arbre <int> a2;
b.fills(a1, a2);
while (a1.arrel() != r and a2.arrel() != r) {
Arbre <int> a3;
a1 = a3;
a2 = a3;
b.fills(a1, a2);
}
if (a1.arrel() == r) b = a1;
else b = a2;
}
E.anade_especimenes(r, e, h*(-1));
E.migracion_a(b, r, e, h, g);
}
else {
pair<bool, int> x;
x = E.migracion_b(b, r, e, h, g);
}
}
else if (accion == -3) {
int m = readint();
int e = readint();
int r = readint();
E.anade_especimenes(r, e, m);
}
else if (accion == -4) {
int e = readint();
int n = readint();
c.cambia_preferencias(e, n);
}
else if (accion == -5) {
E.escribir_cjt_areas();
}
cin >> accion;
}
}
Arbre* Syntaxe::niv0() {
// std::wcout << "niv 0" << std::endl;
Arbre *a;
switch (lex.GetId()) {
case PGAUCHE :
lex.Read();
a = nivn(7);
if (lex.GetId() != PDROITE) {
// ERREUR : PDROITE
std::wcerr << L"Erreur ligne " << lex.GetLine() << L" colonne " << lex.GetColumn() << L"\u00a0: " << L"')' attendu." << std::endl;
err = true;
} else lex.Read();
break;
case ID :
if (isData) {
// ERREUR
std::wcerr << L"Erreur ligne " << lex.GetLine() << L" colonne " << lex.GetColumn() << L"\u00a0: " << L"la taille des zones de données ne doivent pas dépendre de labels." << std::endl;
err = true;
if (lex.GetSymb().GetInit())
a = new Arbre(NOMBRE, lex.GetSymb().GetValue(), lex.GetLine(), lex.GetColumn());
else
a = new Arbre(UNDEFINED, 0, lex.GetLine(), lex.GetColumn());
break;
}
a = new Arbre(ID, 0, lex.GetLine(), lex.GetColumn());
a->SetSymbole(lex.GetSymb());
lex.Read();
break;
case NOMBRE :
a = new Arbre(NOMBRE, lex.GetIdbis(), lex.GetLine(), lex.GetColumn());
lex.Read();
break;
case MOINS:
a = new Arbre(MOINS, 0, lex.GetLine(), lex.GetColumn());
lex.Read();
a->SetFilsGauche(new Arbre(NOMBRE, 0, 0, 0)); // car -x = 0-x
a->SetFilsDroit(niv0());
break;
case NON:
a = new Arbre(NON, 0, lex.GetLine(), lex.GetColumn());
lex.Read();
a->SetFilsGauche(niv0());
break;
default :
err = true;
std::wcerr << L"Erreur ligne " << lex.GetLine() << L" colonne " << lex.GetColumn() << L"\u00a0: " << L"nombre attendu." << std::endl;
a = new Arbre(UNDEFINED, 0, lex.GetLine(), lex.GetColumn());
}
return a;
}
Arbre* Syntaxe::nivnbis(Arbre *prec, int niveau) {
Arbre* res; // résultat a envoyer
Arbre* suiv; // pour l'associativité à gauche
bool b = false;
unsigned int t = lex.GetId();
// std::wcout << "niv " << niveau << "'" << std::endl;
switch(niveau) {
case 1:
b = (t == EXP);
break;
case 2:
switch (t) {
case FOIS:
case DIV:
case MODULO:
b = true;
}
break;
case 3:
switch (t) {
case PLUS:
case MOINS:
b = true;
}
break;
case 4:
switch (t) {
case DECG:
case DECD:
b = true;
}
break;
case 5:
b = (t == ET);
break;
case 6:
b = (t == OUX);
break;
case 7:
b = (t == OU);
break;
}
if (b) {
lex.Read();
suiv = new Arbre(t, 0, lex.GetLine(), lex.GetColumn());
suiv->SetFilsGauche(prec);
suiv->SetFilsDroit(nivn(niveau-1));
res = nivnbis(suiv, niveau);
} else res = prec;
return res;
}
void ManagerArbre::add(Arbre &node)
{
if(node.feuille())
{
if(node.parent())
{
Arbre parent(node.parent());
get(parent);
if(parent.feuille())
{
if(node.num())
throw std::invalid_argument("Le premier descendnat doit avoir un numéro nul.");
else
ManagerSqlArbre::add(node);
parent.setFeuille(false);
ManagerSqlArbre::modify(parent);
}
else
{
int max = fonctionAgrega<int>(bdd::Agrega::Max,Arbre::Num,Arbre::Parent,node.parent());
if(node.num() < 0 || node.num() > max)
{
node.setNum(max+1);
ManagerSqlArbre::add(node);
}
else
{
ListPtr<Arbre> nodes(getList(Arbre::Parent,node.parent(),
Arbre::Num,node.num(),
Arbre::Num,
bdd::Condition::Egal,bdd::Condition::SupEgal,
false));
for(ListPtr<Arbre>::iterator i = nodes.begin(); i != nodes.end(); ++i)
{
(*i).setNum((*i).num() + 1);
ManagerSqlArbre::modify(*i);
}
ManagerSqlArbre::add(node);
}
}
}
else
{
if(node.num())
throw std::invalid_argument("Une racine doit avoir un numéro nul.");
else
ManagerSqlArbre::add(node);
}
}
else
throw std::invalid_argument("Le nouveau noeud ajouté doit être une feuille.");
}
int Organigrama::assign_offi_less_level(Arbre<int> &a, Agenda &agenda, int day, int& level_aux, int level, bool &found, int& depth)
{
int id;
if (level_aux <= level and not a.es_buit()) {
int root = a.arrel();
int id_cita;
agenda.consultar_cita(root, day, id_cita);
if (id_cita == 0) {
found = true;
depth = 0;
id = root;
}
else {
++level_aux;
Arbre<int> a1, a2;
a.fills(a1, a2);
int depth1, depth2;
bool found1, found2;
int id_1, id_2;
id_1 = assign_offi_less_level(a1, agenda, day, level_aux, level, found1, depth1);
id_2 = assign_offi_less_level(a2, agenda, day, level_aux, level, found2, depth2);
if (found1 and found2) {
depth1 = depth1 + 1;
depth2 = depth2 + 1;
if (depth1 <= depth2) {
depth = depth1;
id = id_1;
}
else {
depth = depth2;
id = id_2;
}
}
else if (found1) {
depth = depth1 + 1;
id = id_1;
}
else if (found2) {
depth = depth2 + 1;
id = id_2;
}
found = found1 or found2;
--level_aux;
a.plantar(root, a1, a2);
}
}
else found = false;
if (found) return id;
else return -1;
}
void escriure_arbre_int( Arbre<int> &a) {
if (not a.es_buit()) {
Arbre<int> a1;
Arbre<int> a2;
int x = a.arrel();
a.fills(a1,a2);
escriure_arbre_int(a1);
cout << " " << x;
escriure_arbre_int(a2);
a.plantar(x,a1,a2);
}
}
void ManagerArbre::modifyUnstable(const Arbre & node)
{
Arbre nodeBdd(node.id());
get(nodeBdd);
int max = fonctionAgrega<int>(bdd::Agrega::Max,Arbre::Num,Arbre::Parent,node.parent());
if(node.num() < 0 || node.num() > max)
ManagerSqlArbre::modify(Arbre(nodeBdd.feuille(),max+1,node.parent(),node.id()));
else
{
if(deplace(node))
ManagerSqlArbre::modify(node);
}
if(node.parent() != nodeBdd.parent())
{
if(!exists(Arbre::Parent,nodeBdd.parent()))
{
Arbre nodeBddParent(nodeBdd.parent());
get(nodeBddParent);
nodeBddParent.setFeuille(true);
ManagerSqlArbre::modify(nodeBddParent);
}
Arbre nodeParent(node.parent());
get(nodeParent);
if(nodeParent.feuille())
{
nodeParent.setFeuille(false);
ManagerSqlArbre::modify(nodeParent);
}
}
}
void Syntaxe::lignesdonnees() {
Symbole s;
Arbre *a;
while (lex.GetId() == FIN_LIGNE) {
lex.Read();
}
switch (lex.GetId()) {
case ID :
// initialisation de la valeur de l'ID
s = lex.GetSymb();
if (s.GetInit()) {
// Erreur : symbole déjà rencontré
std::wcerr << L"Erreur ligne " << lex.GetLine() << L" colonne " << lex.GetColumn() << L"\u00a0: " << L"le label " << s.GetText() << " est déjà déclaré." << std::endl;
err = true;
} else s.SetValue(cData);
lex.Read();
if (lex.GetId() != DEUX_POINTS) {
// ERREUR : il faut :
std::wcerr << L"Erreur ligne " << lex.GetLine() << L" colonne " << lex.GetColumn() << L"\u00a0: " << L"':' attendu." << std::endl;
err = true;
} else lex.Read();
lignesdonnees();
break;
case NOMBRE :
case MOINS:
case NON:
case PGAUCHE :
a = nivn(7);
a->Evaluate();
if (a->GetType() != UNDEFINED)
cData += a->GetValue(); // met à jour le compteur de données.
delete a;
if (lex.GetId() != FIN_LIGNE) {
// ERREUR : il faut un saut de ligne
std::wcerr << L"Erreur ligne " << lex.GetLine() << L" colonne " << lex.GetColumn() << L"\u00a0: " << L"la déclaration d'une zone de données doit être suivie d'un saut de ligne." << std::endl;
err = true;
while (lex.GetId() != FIN_LIGNE) lex.Read();
}
lex.Read();
lignesdonnees();
break;
default :
// cas epsilon
break;
}
}
bool ManagerArbre::deplace(const Arbre & node)
{
Arbre nodeBdd(node.num(),node.parent());
if(existsUnique(nodeBdd))
{
if(nodeBdd.id() != node.id())
{
nodeBdd.setNum(-nodeBdd.num());
ManagerSqlArbre::modify(nodeBdd);
return true;
}
else
return false;
}
else
return true;
}
void ManagerArbre::modifyStableUnstable(const Arbre & node)
{
Arbre nodeBdd(node.id());
get(nodeBdd);
int max = fonctionAgrega<int>(bdd::Agrega::Max,Arbre::Num,Arbre::Parent,node.parent());
if(node.num() < 0 || node.num() > max)
ManagerSqlArbre::modify(Arbre(nodeBdd.feuille(),max+1,node.parent(),node.id()));
else
{
if(deplace(node))
ManagerSqlArbre::modify(node);
}
if(nodeBdd.parent() != 0 && nodeBdd.parent() != node.parent())
{
if(exists(Arbre::Parent,nodeBdd.parent()))
{
ListPtr<Arbre> nodes(getList(Arbre::Parent,nodeBdd.parent(),Arbre::Num,nodeBdd.num(),Arbre::Num,bdd::Condition::Egal,bdd::Condition::Sup));
for(ListPtr<Arbre>::iterator i = nodes.begin(); i != nodes.end(); ++i)
{
(*i).setNum((*i).num() - 1);
ManagerSqlArbre::modify((*i));
}
}
else
{
Arbre parent(nodeBdd.parent());
get(parent);
parent.setFeuille(true);
ManagerSqlArbre::modify(parent);
}
}
}
bool ManagerArbre::del(const Arbre & node)
{
if(!node.feuille() || !ManagerSqlArbre::del(node.id()))
return false;
if(node.parent())
{
if(exists(Arbre::Parent,node.parent()))
{
ListPtr<Arbre> nodes(getList(Arbre::Num,node.num(),Arbre::Parent,node.parent(),Arbre::Num,bdd::Condition::Sup));
for(ListPtr<Arbre>::iterator i = nodes.begin(); i != nodes.end(); ++i)
{
(*i).setNum((*i).num() - 1);
ManagerSqlArbre::modify(*i);
}
}
else
{
Arbre parent(node.parent());
get(parent);
parent.setFeuille(true);
ManagerSqlArbre::modify(parent);
}
}
return true;
}
void Organigrama::leer_arbol(Arbre<int> &a, int marca) {
int r;
cin >> r;
if (r != marca) {
Arbre<int> hi, hd;
leer_arbol(hi,marca);
leer_arbol(hd,marca);
a.plantar(r,hi,hd);
}
}
void llegir_arbre_int(Arbre<int>& a, int marca)
//Pre: a es buit
//Post: a conté l'abre llegit de l'entrada
{
Arbre<int> a1;
Arbre<int> a2;
int x;
cin >> x;
if (x!= marca) {
llegir_arbre_int(a1, marca);
llegir_arbre_int(a2, marca);
a.plantar(x,a1,a2);
}
}
void Red::leer_red_recursivo(Arbre<int> &a, vector<int> &estaciones, int id_estacion, int tiempo_acumulado) {
int tiempo = readint();
if (tiempo >= 0) {
tiempo_acumulado += tiempo;
estaciones[id_estacion] = tiempo_acumulado;
Arbre<int> a1, a2;
leer_red_recursivo(a1, estaciones, id_estacion * 2 + 1, tiempo_acumulado);
leer_red_recursivo(a2, estaciones, id_estacion * 2 + 2, tiempo_acumulado);
a.plantar(tiempo_acumulado, a1, a2);
}
}
void ManagerArbre::addUnstable(Arbre &node)
{
if(node.feuille())
{
if(node.parent())
{
Arbre parent(node.parent());
get(parent);
if(parent.feuille())
{
if(node.num())
throw std::invalid_argument("Le premier descendnat doit avoir un numéro nul.");
else
ManagerSqlArbre::add(node);
parent.setFeuille(false);
ManagerSqlArbre::modify(parent);
}
else
{
int max = fonctionAgrega<int>(bdd::Agrega::Max,Arbre::Num,Arbre::Parent,node.parent());
if(node.num() < 0 || node.num() > max)
{
node.setNum(max+1);
ManagerSqlArbre::add(node);
}
else
{
deplace(node);
ManagerSqlArbre::add(node);
}
}
}
else
{
if(node.num())
throw std::invalid_argument("Une racine doit avoir un numéro nul.");
else
ManagerSqlArbre::add(node);
}
}
else
throw std::invalid_argument("Le nouveau noeud ajouté doit être une feuille.");
}
void ManagerArbre::modify(const Arbre & node)
{
Arbre nodeBdd(node.id());
get(nodeBdd);
int idParentBdd = nodeBdd.parent();
int numBdd = nodeBdd.num();
if(node.parent())
{
if(nodeBdd.parent() == node.parent())
{
int max = fonctionAgrega<int>(bdd::Agrega::Max,Arbre::Num,Arbre::Parent,node.parent());
int num = node.num();
if(num < 0 || num > max)
num = max;
if(numBdd != num)
{
nodeBdd.setNum(-numBdd);
ManagerSqlArbre::modify(nodeBdd);
if(std::abs(numBdd - num) == 1)
{
Arbre nodeSuivant(num,node.parent());
getUnique(nodeSuivant);
nodeSuivant.setNum(numBdd);
ManagerSqlArbre::modify(nodeSuivant);
}
else if(num < numBdd)
{
ListPtr<Arbre> nodes(getList(Arbre::Parent,node.parent(),Arbre::Num,num,Arbre::Num,numBdd,
Arbre::Num,bdd::Condition::Egal,bdd::Condition::SupEgal,bdd::Condition::Inf,false));
for(ListPtr<Arbre>::iterator i = nodes.begin(); i != nodes.end(); ++i)
{
(*i).setNum((*i).num() + 1);
ManagerSqlArbre::modify((*i));
}
}
else
{
ListPtr<Arbre> nodes(getList(Arbre::Parent,node.parent(),Arbre::Num,numBdd,Arbre::Num,num,
Arbre::Num,bdd::Condition::Egal,bdd::Condition::Sup,bdd::Condition::InfEgal));
for(ListPtr<Arbre>::iterator i = nodes.begin(); i != nodes.end(); ++i)
{
(*i).setNum((*i).num() - 1);
ManagerSqlArbre::modify((*i));
}
}
nodeBdd.setNum(num);
}
}
else
{
nodeBdd.setParent(node.parent());
Arbre parent(nodeBdd.parent());
get(parent);
if(parent.feuille())
{
parent.setFeuille(false);
ManagerSqlArbre::modify(parent);
nodeBdd.setNum(0);
}
else
{
int max = fonctionAgrega<int>(bdd::Agrega::Max,Arbre::Num,Arbre::Parent,node.parent());
if(node.num() < 0 || node.num() > max)
nodeBdd.setNum(max + 1);
else
{
ListPtr<Arbre> nodes(getList(Arbre::Parent,node.parent(),Arbre::Num,node.num(),
Arbre::Num,bdd::Condition::Egal,bdd::Condition::SupEgal,false));
for(ListPtr<Arbre>::iterator i = nodes.begin(); i != nodes.end(); ++i)
{
(*i).setNum((*i).num() + 1);
ManagerSqlArbre::modify((*i));
}
nodeBdd.setNum(node.num());
}
}
}
ManagerSqlArbre::modify(nodeBdd);
}
else
{
nodeBdd.setParent(0);
nodeBdd.setNum(0);
ManagerSqlArbre::modify(nodeBdd);
}
if(idParentBdd != 0 && idParentBdd != nodeBdd.parent())
{
if(exists(Arbre::Parent,idParentBdd))
{
ListPtr<Arbre> nodes(getList(Arbre::Parent,idParentBdd,Arbre::Num,numBdd,Arbre::Num,bdd::Condition::Egal,bdd::Condition::Sup));
for(ListPtr<Arbre>::iterator i = nodes.begin(); i != nodes.end(); ++i)
{
(*i).setNum((*i).num() - 1);
ManagerSqlArbre::modify((*i));
}
}
else
{
Arbre parent(idParentBdd);
get(parent);
parent.setFeuille(true);
ManagerSqlArbre::modify(parent);
}
}
}
