int dfs_novo() {
register int vFlag[MAX];
register int vertice[MAX]; //representa o ciclo
register int custo = ZERO;
register int i, nivel = 1; //---> nivel zero ja tem a raiz
/*Inicializacao*/
for (i = 0; i < N; ++i) { //
vFlag[i] = 0;
vertice[i] = -1;
}
/*
para dizer que 0-1 sao fixos
*/
vertice[0] = 0; //raiz
vFlag[0] = 1;
while (nivel >= 1) { // modificar aqui se quiser comecar a busca de determinado nivel
if(vertice[nivel] !=-1 ) {
vFlag[vertice[nivel]] = 0;
custo-= mat(vertice[anterior(nivel)],vertice[nivel]);
}
for(vertice[nivel]++;vertice[nivel] < N && vFlag[vertice[nivel]]; vertice[nivel]++); //
if (vertice[nivel] < N) {
custo+= mat(vertice[anterior(nivel)],vertice[nivel]);
vFlag[vertice[nivel]] = 1;
nivel++;
if (nivel == N){ //se o vértice do nível for == N, entao formou o ciclo e vc soma peso + vertice anterior -> inicio
++qtd;
if(custo + mat(vertice[anterior(nivel)],0)<upper_bound)
upper_bound=custo + mat(vertice[anterior(nivel)],0);
nivel--;
}else{
}
} else {
vertice[nivel] = -1;
nivel--;
}
}
return upper_bound;
}
PtrNodoPiso adicionarAntes(ListaPiso &listaP, PilUb pilUb, PtrNodoPiso ptrNodoP){
PtrNodoPiso ptrNuevoNodo = finP();
if (! listaVacia(listaP)) {
if (ptrNodoP != primero(listaP))
ptrNuevoNodo = adicionarDespues(listaP,pilUb,anterior(listaP,ptrNodoP));
else
ptrNuevoNodo = adicionarPrincipio(listaP,pilUb);
}
return ptrNuevoNodo;
}
void eliminarNodo(ListaPiso &listaP, PtrNodoPiso ptrNodoP){
PtrNodoPiso ptrPrevio;
/* verifica que la lista no esté vacia y que nodo no sea fin*/
if ((! listaVacia(listaP)) && (ptrNodoP != finP())) {
if (ptrNodoP == primero(listaP))
listaP.primeroPiso = siguiente(listaP,primero(listaP));
else {
ptrPrevio = anterior( listaP , ptrNodoP );
ptrPrevio->sgteP = ptrNodoP->sgteP;
}
// Si el dato es un TDA, acá habría que llamar al destructor.
destruir(ptrNodoP->pilUb);
delete ptrNodoP;
}
}
//*******************
void eliminarNodo(ListaArtDeposito &listaArtDep,PtrNodoListaDeposito ptrNodoListaDep){
PtrNodoListaDeposito ptrPrevio;
/* verifica que la lista no esté vacia y que nodo no sea fin*/
if ((! listaVacia(listaArtDep)) && (ptrNodoListaDep != finAD())) {
if (ptrNodoListaDep == primero(listaArtDep))
listaArtDep.primerArtDeposito = siguiente(listaArtDep,primero(listaArtDep));
else {
ptrPrevio = anterior( listaArtDep , ptrNodoListaDep );
ptrPrevio->sgteAD= ptrNodoListaDep->sgteAD;
}
// Si el dato es un TDA, acá habría que llamar al destructor.
delete ptrNodoListaDep;
}
}
void roda()
{
int p = 0;
pont = vetor;
for(int i = 0; i < TAM; i++)
vetor[i] = 0;
while(1){
if(p == tamprog)
return;
switch(prog[p]){
case '<':
if(pont == vetor)
pont = vetor + TAM;
pont--;
break;
case '>':
pont++;
if(pont == vetor + TAM)
pont = vetor;
break;
case '+':
(*pont)++;
break;
case '-':
(*pont)--;
break;
case '.':
printf("%c", *pont);
break;
case '[':
if(*pont == 0)
p = proximo(p);
break;
case ']':
if(*pont != 0)
p = anterior(p);
break;
}
p++;
}
}
int main (void)
{
lista *l1 = NULL, *b = NULL, *a = NULL;
inserir(&l1, 1);
imprimir(l1);
inserir(&l1, 2);
imprimir(l1);
inserir(&l1, 3);
imprimir(l1);
b = buscar(l1, 2);
if(b!=NULL)
printf("b -> c: %d.\n", b -> c);
a = anterior(l1, b);
if (a != NULL)
printf("a -> c: %d.\n", a -> c);
b = buscar(l1, 2);
remover(&l1, b);
imprimir(l1);
return 0;
}
PtrNodoPiso ultimo(ListaPiso &listaP){
return anterior(listaP,finP());
}
void Recuerdo::updateParticulas(double tiempoSeg, double tiempoMil){
// a que recuerdo llamo con tiempo en segundo.
bool* pixelBool = new bool[(int)this->pixels->size()];
std::fill_n( pixelBool, (int)this->pixels->size(), 0 );
vector<Particula*>::iterator it = this->particulas->begin();
vector<Pixel*>::iterator itpixels;
Pixel *pixel;
Particula* particula;
Punto *ptoAnt = NULL;
Punto *ptoSig = NULL;
Punto *ptoAct = NULL;
long a;// = ofGetElapsedTimeMillis() % 1000;
bool recTienePar=false;
while (it!=this->particulas->end())
{
particula = *it;
// a = fmod(tiempoMil,particula->frecuencia);
a = fmod(tiempoMil - (particula->tiempoini),particula->frecuencia );//+ particula->tiempoini*1000;
itpixels = pixels->begin();
//if (particula->tiempoini <= tiempoSeg && particula->tiempofin >= tiempoSeg){
if (particula->tiempoini <= tiempoMil && particula->tiempofin >= tiempoMil){
ptoAnt = anterior(particula, a);
ptoSig = siguiente(particula,a);
if (ptoAnt != NULL && ptoSig != NULL){
ptoAct = ptoActual(ptoAnt,ptoSig,a);
//Gonzalo
//ptoAct->draw(ptoAct);
//ofPushMatrix();
//particula->draw(ptoAct);
//ofPopMatrix();
cout << particula->id;
while (itpixels != pixels->end()){
pixel = *itpixels;
ofVec3f pos = pixel->getPosition();
int dis = sqrt((pos.x - ptoAct->x)*(pos.x - ptoAct->x) + (pos.z - ptoAct->z)* (pos.z - ptoAct->z));
if (dis <= ptoAct->intensidad){
//Aca va el decaimiento del color
ofVec3f colores(ptoAct->r, ptoAct->g,ptoAct->b);
ofVec3f retColores = decaimiento (colores,dis,ptoAct->intensidad);
pixel->blendRGBA(retColores.x, retColores.y, retColores.z,0,0.4f);
//pixel->blendRGBA(ptoAct->r,ptoAct->g,ptoAct->b,0,0.4f);
pixelBool[(int)pixel->getId()] = true;
}
itpixels++;
}
}
}
it++;
}// Busco
itpixels = pixels->begin();
if (recTienePar) {
while (itpixels != pixels->end()){
Pixel* px = *itpixels;
if (!pixelBool[(int)px->getId()]){
px->blendRGBA(0, 0, 0, 255, 0.4f);
}
itpixels++;
}
}
delete[] pixelBool;
this->draw();
};
int main() {
lista lst = crear_lista();
nat cont_comandos = 0;
bool salir = false;
while (!salir) {
mostrar_prompt(cont_comandos);
enum_cmd_t enum_com = identificador_comando();
// procesar el comando
switch (enum_com) {
case cmd_fin:
salir = true;
imprimir_con_nl(msg_fin);
break;
case cmd_comentario:
escribir_nueva_linea();
break;
case cmd_ins_lista: {
info_t info = leer_info(MAX_LARGO_PALABRA);
while (es_valida_info(info)) {
insertar_despues(info, final_lista(lst), lst);
info = leer_info(MAX_LARGO_PALABRA);
}
liberar_info(info);
texto_t txt = cadena_a_texto("primero");
info = crear_info(0, txt);
insertar_antes(info, inicio_lista(lst), lst);
imprimir_lista(lst);
break;
}
case cmd_recorrido_lista: {
if (!es_vacia_lista(lst)) {
localizador loc = inicio_lista(lst);
while (es_localizador_lista(loc)) {
texto_t txt = info_a_texto(info_lista(loc, lst));
escribir_texto(txt);
liberar_texto(txt);
loc = siguiente(loc, lst);
}
loc = final_lista(lst);
while (es_localizador_lista(loc)) {
texto_t txt = info_a_texto(info_lista(loc, lst));
escribir_texto(txt);
liberar_texto(txt);
loc = anterior(loc, lst);
}
escribir_nueva_linea();
}
break;
}
case cmd_segmentos_lista: {
int clave1 = leer_int();
int clave2 = leer_int();
localizador desde = siguiente_clave(clave1, inicio_lista(lst), lst);
localizador hasta = anterior_clave(clave2, final_lista(lst), lst);
if (es_localizador_lista(desde) && es_localizador_lista(hasta) &&
precede_en_lista(desde, hasta, lst)) {
lista sgm = separar_segmento(desde, hasta, lst);
lista copia = segmento_lista(inicio_lista(sgm), final_lista(sgm), sgm);
imprimir_lista(sgm);
liberar_lista(sgm);
insertar_segmento_despues(copia, final_lista(lst), lst);
liberar_lista(copia);
imprimir_lista(lst);
}
break;
}
case cmd_modificar_lista: {
int clave1 = leer_int();
int clave2 = leer_int();
localizador loc1 = siguiente_clave(clave1, inicio_lista(lst), lst);
localizador loc2 = anterior_clave(clave2, final_lista(lst), lst);
if (es_localizador_lista(loc1) && es_localizador_lista(loc2)) {
intercambiar(loc1, loc2, lst);
imprimir_lista(lst);
retroceder(loc2, lst);
imprimir_lista(lst);
}
break;
}
case cmd_ordenar_lista: {
nat len_lst = longitud(lst);
imprimir_int(len_lst);
localizador loc = inicio_lista(lst);
for (nat i = 0; i < len_lst / 2 - 1; i++)
loc = siguiente(loc, lst);
lista primera = segmento_lista(inicio_lista(lst), loc, lst);
lista segunda =
segmento_lista(siguiente(loc, lst), final_lista(lst), lst);
lista concat = concatenar(primera, segunda);
imprimir_lista(concat);
liberar_lista(concat);
if (son_numeros_iguales(primera, segunda)) {
imprimir_lista(primera);
}
if (!esta_ordenada(primera))
ordenar(primera);
if (!esta_ordenada(segunda))
ordenar(segunda);
lista mzc = mezcla(primera, segunda);
imprimir_lista(mzc);
unificar(mzc);
imprimir_lista(mzc);
liberar_lista(mzc);
liberar_lista(primera);
liberar_lista(segunda);
break;
}
case cmd_filtrado_lista: {
int clave = leer_int();
texto_t palabra = leer_palabra(MAX_LARGO_PALABRA);
comp_t criterio = texto_a_comp(palabra);
liberar_texto(palabra);
if (pertenece(clave, lst)) {
imprimir_int(cantidad(clave, lst));
}
lista flt = filtrado(clave, criterio, lst);
imprimir_lista(flt);
liberar_lista(flt);
break;
}
case cmd_reversa_lista: {
int dato1 = leer_int();
int dato2 = leer_int();
if (esta_ordenada(lst) && pertenece(dato1, lst) &&
pertenece(dato2, lst) && dato1 < dato2) {
lista sub = sublista(dato1, dato2, lst);
imprimir_lista(sub);
lista rev = reversa(sub);
imprimir_lista(rev);
cambiar_todos(dato1, dato2, rev);
imprimir_lista(rev);
liberar_lista(sub);
liberar_lista(rev);
}
break;
}
case cmd_liberar_lista: {
liberar_lista(lst);
lst = crear_lista();
break;
}
default:
imprimir_con_nl(msg_cmd_no_reconocido);
break;
} // switch
texto_t resto_linea = leer_resto_linea(MAX_RESTO_LINEA);
liberar_texto(resto_linea);
} // while
liberar_lista(lst);
return 0;
}
//********************
PtrNodoListaDeposito ultimo(ListaArtDeposito &listaArtDep){
return anterior(listaArtDep,finAD());
}
void segundo(int N, int *mat_d, short *preFixos_d,
int nPreFixos, int nivelPrefixo, int upper_bound, int *sols_d,int *melhorSol_d) {
register int idx = blockIdx.x * blockDim.x + threadIdx.x;
register int flag[16];
register int vertice[16]; //representa o ciclo
register int N_l = N;
register int i, nivel; //para dizer que 0-1 ja foi visitado e a busca comeca de 1, bote 2
register int custo;
register int qtd_solucoes_thread = 0;
register int UB_local = upper_bound;
register int nivelGlobal = nivelPrefixo;
if (idx < nPreFixos) { //(@)botar algo com vflag aqui, pois do jeito que esta algumas threads tentarao descer.
for (i = 0; i < N_l; ++i) {
vertice[i] = _VAZIO_;
flag[i] = _NAO_VISITADO_;
}
vertice[0] = 0;
flag[0] = _VISITADO_;
custo= ZERO;
for (i = 1; i < nivelGlobal; ++i) {
vertice[i] = preFixos_d[idx * nivelGlobal + i];
flag[vertice[i]] = _VISITADO_;
custo += mat_d(vertice[i-1],vertice[i]);
}
nivel=nivelPrefixo;
while (nivel >= nivelGlobal ) { // modificar aqui se quiser comecar a busca de determinado nivel
if (vertice[nivel] != _VAZIO_) {
flag[vertice[nivel]] = _NAO_VISITADO_;
custo -= mat_d(vertice[anterior(nivel)],vertice[nivel]);
}
do {
vertice[nivel]++;
} while (vertice[nivel] < N_l && flag[vertice[nivel]]); //
if (vertice[nivel] < N_l) { //vertice[x] vertice no nivel x
custo += mat_d(vertice[anterior(nivel)],vertice[nivel]);
flag[vertice[nivel]] = _VISITADO_;
nivel++;
if (nivel == N_l) { //se o vértice do nível for == N, entao formou o ciclo e vc soma peso + vertice anterior -> inicio
++qtd_solucoes_thread;
if (custo + mat_d(vertice[anterior(nivel)],0) < UB_local) {
UB_local = custo + mat_d(vertice[anterior(nivel)],0);
}
nivel--;
}
//else {
//if (custo > custoMin_d[0])
//nivel--; //poda, LB maior que UB
//}
}
else {
vertice[nivel] = _VAZIO_;
nivel--;
}//else
}//while
sols_d[idx] = qtd_solucoes_thread;
melhorSol_d[idx] = UB_local;
}//dfs
}//kernel
