void Drainer::GenerateMicros()
{
m_Micros.reserve(static_cast<size_t>(m_Mgr.m_Solver.m_TotalStates));
auto &sets = m_Mgr.m_Solver.m_BlockSets;
std::vector<BlockSet> indexes;
indexes.reserve(sets.size());
for (auto &set : sets)
{
indexes.emplace_back();
auto &lst = indexes.back();
for (auto blk : set)
lst.push_back(m_BlocksLookup[blk]);
}
std::vector<std::map<int, std::vector<std::map<int, BlockStatus>>>> dicc(sets.size());
for(auto solution : m_Mgr.m_Solver.m_Solutions)
{
std::vector<std::vector<std::map<int, BlockStatus>>*> ddic;
for (auto i = 0; i < sets.size(); i++)
{
auto m = solution.Dist[i];
auto &lst = dicc[i][m];
if (lst.empty())
{
std::vector<std::vector<BlockStatus>> dists;
Combinations(sets[i].size(), m, dists);
for(auto l : dists)
{
lst.emplace_back();
auto &d = lst.back();
for (auto j = 0; j < sets[i].size(); ++j)
d.insert(std::make_pair(indexes[i][j], l[j]));
}
}
ddic.push_back(&lst);
}
std::vector<int> stack;
stack.reserve(sets.size());
stack.push_back(0);
while (true)
if (stack.size() == sets.size())
if (stack.back() < ddic[stack.size() - 1]->size())
{
m_Micros.emplace_back();
auto &lst = m_Micros.back();
lst.resize(m_Blocks.size(), BlockStatus::Blank);
for (auto i = 0; i < stack.size(); ++i)
for (auto kvp : ddic[i]->at(stack[i]))
lst[kvp.first] = kvp.second;
#ifdef _DEBUG
for (auto row = 0; row < m_Mgr.m_Solver.m_Matrix.GetHeight(); ++row)
{
auto v = 0;
auto nr = m_Mgr.m_Solver.m_Matrix.GetRowHead(row).Right;
ASSERT(nr != nullptr);
while (nr->Col != m_Mgr.m_Solver.m_BlockSets.size())
{
for (auto blk : m_Mgr.m_Solver.m_BlockSets[nr->Col])
if (lst[m_BlocksLookup[blk]] == BlockStatus::Mine)
++v;
nr = nr->Right;
ASSERT(nr != nullptr);
}
ASSERT(nr->Value == v);
}
#endif
++stack.back();
}
else
{
stack.pop_back();
if (stack.empty())
break;
++stack.back();
}
else if (stack.back() < ddic[stack.size() - 1]->size())
stack.push_back(0);
else
{
stack.pop_back();
if (stack.empty())
break;
++stack.back();
}
}
}
campusSeguro::campusSeguro(campus c, Dicc<Agente,Posicion> d)
{
campus camp = c;
DiccPalabra<Posicion> estyHip;// creo un DiccTrie vacio.
campusSeguro::DatosPos tup;
tup.id = 4;
tup.tag = "libre";
tup.placa = 0;
Nat cantidadFilas=c.Filas();
Nat cantidadColumnas=c.Columnas();
diccMatriz<campusSeguro::DatosPos> datosMatriz(cantidadFilas,cantidadColumnas,tup);
diccHash<Agente,campusSeguro::Datos> dicc(d.CantClaves()); // creo dicchash de tamaño d.Claves().Cardinal()
diccHash<Agente,campusSeguro::Datos>::Iterador itHashVacio = dicc.CrearIt();
tup.datosAgente = itHashVacio;
ConjsEqu<Agente> equSan; // creo un EqusEqu vacio y lo guardo en la variable equSan.
campusSeguro::DatosSanciones KSan;
Nat i = 0;
Nat j = 0;
while( i < c.Filas() )
{
while( j< c.Columnas())
{
//Posicion pos(i,j); // creo una posicion (i,j).
Posicion p;
p.x = i;
p.y = j;
campusSeguro::DatosPos data; // ESTA VARIABLE NO SE SI VA DENTRO DEL SCOPE DEL WHILE, xq SE BORRA.
if( _campus.Posocupada(p))
{
data.id = 0;
data.tag = "ocupada";
data.placa = 0;
data.datosAgente = itHashVacio;
datosMatriz.Definir(p, data);
}
j++;
}// endwhile
i++;
}// endwhile
Dicc<Agente,Posicion>::Iterador it;
it = d.CrearIt();
while( it.HaySiguiente() )
{
campusSeguro::DatosPos data; // ESTA VARIABLE NO SE SI VA DENTRO DEL SCOPE DEL WHILE, xq SE BORRA.
campusSeguro::Datos dataH;
Posicion pos;
Agente plak;
ConjsEqu<Agente>::Iterador itEqu;
plak = it.SiguienteClave();
pos = it.SiguienteSignificado();
itEqu = equSan.relacionar(0, plak);
dataH.pos = pos;
dataH.Sanciones = 0;
dataH.hippiesAtrapados = 0;
dataH.claseConMismasSanciones = itEqu;
data.id = 3;
data.tag = "agente";
data.placa = plak;
data.datosAgente = dicc.Definir(plak, dataH); // definir retorna un iterador de Dicc.
datosMatriz.Definir(pos, data);
it.Avanzar();
}
Arreglo<TuplaAgYSan> nuevoArreglo(1); // creo array de 1 posicion
KSan.arreglo = nuevoArreglo; // meto el arreglo en el campo arreglo de KSan.
KSan.buffer = false;
KSan.itMenosSanciones = equSan.CrearIt();
// el masvigilante al comienzo de la instancia campusSeguro es cualquier vigilante:
campusSeguro::DatosAgentesyAtrapados elMas;
Dicc<Agente,Posicion>::Iterador itAgts = d.CrearIt();
elMas.agente = itAgts.SiguienteClave();// el primer agente que encuentre.
elMas.cantAtrapados = 0;
// incio la instancia:
_campus = camp;
_estudiantes = estyHip;
_hippies = estyHip;
Conj<Agente> conjuntoDeAgentes; // conjunto vacio que almacenará agentes
Dicc<Agente,Posicion>::Iterador itDiccAgentes = d.CrearIt();
while(itDiccAgentes.HaySiguiente()) // voy llenando el conjunto con los agentes del diccionario.
{
conjuntoDeAgentes.AgregarRapido(itDiccAgentes.SiguienteClave());
itDiccAgentes.Avanzar();
}
_agentes = conjuntoDeAgentes;
datosAgentes = dicc;
grilla = datosMatriz;
_masVigilante = elMas;
equivalenciaSanciones = equSan;
KSanciones = KSan;
Dicc<Agente,Posicion>::Iterador it2;
it2 = d.CrearIt();
} // fin funcion constructora (rastrillaje).
