void removeNodo(ramo** albero, int val)
{
ramo* temp = *albero;
if(temp==NULL)
return;
if(temp->val==val)
{
temp=NULL;
printf("rimuovo: %d\n", val);
*albero=temp;
}
else
{
if(val>temp->val)
{
if(temp->right!=NULL)
addNodo(&temp->right, val);
}
else if(val<temp->val)
{
if(temp->left!=NULL)
addNodo(&temp->left, val);
}
}
}
int removePerm(permesso_t * pp, nodo_t ** r)
{
int discr;
int ret;
if (r == NULL) {
return -1;
}
discr = strcmp(pp->targa, (*r)->targa);
if (discr == 0) {
ret = removeIntervallo(&((*r)->lint), &(pp->in));
/**se ho eliminato tutti i permessi (intervalli) devo eliminare anche il nodo relativo*/
if (ret == 0 && (*r)->lint == NULL) {
nodo_t *elim = *r;
/**assegno il figlio destro (del nodo eliminato)
al posto del nodo da eliminare*/
(*r) = elim->right;
/**aggiungo il figlio sinistro all'albero ottenuto*/
addNodo(r, elim->left);
free(elim);
}
return ret;
} else {
if (discr < 0) {
return removePerm(pp, &((*r)->left));
} else {
return removePerm(pp, &((*r)->right));
}
}
}
void addAlbero(ramo** albero, ramo* add)
{
if(add==NULL)
return;
addNodo(albero, add->val);
if(add->left!=NULL)
addAlbero(albero, add->left);
if(add->right!=NULL)
addAlbero(albero, add->right);
}
//aggiunge un nodo, non aggiunge nodi uguali
void addNodo(ramo** albero, int val)
{
ramo* temp = *albero;
if(temp==NULL)
{
temp=(ramo*) malloc(sizeof(ramo));
printf("inserisco: %d\n", val);
temp->val=val;
temp->left=NULL;
temp->right=NULL;
*albero=temp;
}
else
{
if(val>temp->val)
addNodo(&temp->right, val);
else if(val<temp->val)
addNodo(&temp->left, val);
}
}
/**
Inserisce nell'albero r il sottoalbero binario add
\param r puntatore all'albero su cui effettura l'inserimento
\param add sottoalbero da inserire
\retval 0 se l'inserimento è andato a buon fine
\retval 1 altrimenti
*/
int addNodo(nodo_t ** r, nodo_t * add)
{
if (add == NULL) {
errno = EINVAL;
return 1;
}
if ((*r) == NULL) {
*r = add;
return 0;
} else {
int discr = strcmp((*r)->targa, add->targa);
/**il nuovo nodo non deve avere targa uguale a un nodo gia presente*/
if (discr == 0) {
errno = EINVAL;
return 1;
}
if (discr < 0) {
return addNodo(&((*r)->right), add);
} else
return addNodo(&((*r)->left), add);
}
}
MCtree treePolicy(MCtree tree, DATABASE * simulacao, int * flag2){
int counter[4] = {0};
float UCT_value = 0.0;
float max = -1.0;
int index = 0;
int count1 = 0, count2 = 0;
int nc = (simulacao ->nc) - 1;
int wi = 0, ni = 0, t = 0;
MAO jogadas[4][40];
MAO jogada_max = 0;
memset(jogadas,0,8 * 4 * 40);
jogadas_possiveis(simulacao,counter,0,jogadas);
if(nc >= 0){
count1 = 0;
while(count1 < counter[nc]){
for(count2 = 0; count2 < 40; count2++){
if(tree->nextN[nc][count2] == NULL){
tree->nextN[nc][count2] = addNodo(jogadas[nc][count1], tree);
simulacao->mao[0] = (simulacao->mao[0]) ^ (jogadas[nc][count1]);
if(jogadas[nc][count1] == 0)
simulacao->passar++;
else{
simulacao->passar = 0;
simulacao->jogada = jogadas[nc][count1];
}
if(simulacao->passar == 3){
simulacao->nc = 0;
simulacao->jogada = 0;
}
simulacao->usadas[0] = simulacao->usadas[0] | (jogadas[nc][count1]);
flag2[0] = 1;
return tree->nextN[nc][count2];
}
else if((jogadas[nc][count1]) == ((tree->nextN[nc][count2])->estado)){
wi = (tree->nextN[nc][count2])->r;
ni = (tree->nextN[nc][count2])->t;
t = tree->t;
UCT_value = (float)(((wi) / (float)(ni)) + (1.3 * (sqrt(log(t) / (ni)))));
count1++;
if(UCT_value > max){
max = UCT_value;
index = (nc * 40) + count2;
jogada_max = jogadas[nc][count1];
}
count2 = 40;
}
}
}
}
else{
for(nc = 0; nc < 4; nc++){
count1 = 0;
while(count1 < counter[nc]){
for(count2 = 0; count2 < 40; count2++){
if(jogadas[nc][count1] != 0){
if(tree->nextN[nc][count2] == NULL){
simulacao->nc = nc + 1;
simulacao->passar = 0;
simulacao->jogada = jogadas[nc][count1];
simulacao->mao[0] = (simulacao->mao[0]) ^ (jogadas[nc][count1]);
tree->nextN[nc][count2] = addNodo(jogadas[nc][count1], tree);
simulacao->usadas[0] = simulacao->usadas[0] | jogadas[nc][count1];
flag2[0] = 1;
return tree->nextN[nc][count2];
}
else if((jogadas[nc][count1])== ((tree->nextN[nc][count2])->estado)){
wi = (tree->nextN[nc][count2])->r;
ni = (tree->nextN[nc][count2])->t;
t = tree->t;
UCT_value = (float)(((wi) / (float)(ni)) + (1.3 * (sqrt(log(t) / (ni)))));
count1++;
if(UCT_value > max){
max = UCT_value;
index = (nc * 40) + count2;
jogada_max = jogadas[nc][count1];
simulacao->nc = nc + 1;
}
count2 = 40;
}
}
else
count1++;
}
}
}
}
if(jogada_max == 0)
simulacao->passar++;
else{
simulacao->jogada = jogada_max;
simulacao->passar = 0;
simulacao->usadas[0] = simulacao->usadas[0] | jogada_max;
}
if(simulacao->passar == 3){
simulacao->nc = 0;
simulacao->jogada = 0;
}
tree = tree->nextN[index/40][index%40];
simulacao->mao[0] = jogada_max ^ (simulacao->mao[0]);
return tree;
}
int main()
{
printf("-----Programma albero-----\n");
ramo * myAlbero = NULL;
addNodo(&myAlbero, 17);
printf("Ver val: %d \n",myAlbero->val);
//removeNodo(&myAlbero, 17);
printf("next 2 \n");
addNodo(&myAlbero, 2);
printf("next 5 \n");
addNodo(&myAlbero, 5);
printf("next 23\n");
addNodo(&myAlbero, 23);
printf("next 12 \n");
addNodo(&myAlbero, 12);
printf("next\n");
addNodo(&myAlbero, 37);
addNodo(&myAlbero, 75);
int res =profonditNodo(myAlbero, 75, 0);
printf("Profondità: %d\n", res);
int res2 = existNodo(myAlbero, 12);
printf("12 esiste?: %d --\n", res2);
ramo * myAlbero2 = NULL;
addNodo(&myAlbero2, 3);
addNodo(&myAlbero2, 14);
addNodo(&myAlbero2, 1);
addAlbero(&myAlbero, myAlbero2);
StampaAlbero(myAlbero);
fStampaAlbero(myAlbero);
printf("\n\n\n\n\n\ Ora si fa sul serio:\nCreo due alberi uguali e controllo con il metodo l'ugualianza a una data profondità:");
ramo * a1 = NULL;
addNodo(&a1, 15);
addNodo(&a1, 7);
addNodo(&a1, 5);
addNodo(&a1, 11);
addNodo(&a1, 3);
addNodo(&a1, 6);
addNodo(&a1, 8);
addNodo(&a1, 13);
addNodo(&a1, 19);
addNodo(&a1, 17);
addNodo(&a1, 16);
addNodo(&a1, 18);
addNodo(&a1, 23);
addNodo(&a1, 21);
addNodo(&a1, 25);
ramo * a2 = NULL;
addNodo(&a2, 15);
addNodo(&a2, 7);
addNodo(&a2, 5);
addNodo(&a2, 11);
addNodo(&a2, 3);
addNodo(&a2, 6);
addNodo(&a2, 8);
addNodo(&a2, 13);
addNodo(&a2, 19);
addNodo(&a2, 17);
addNodo(&a2, 16);
addNodo(&a2, 18);
addNodo(&a2, 23);
addNodo(&a2, 21);
addNodo(&a2, 25);
printf("\n\n\n\nsono uguali: %d", ProfonditaUguale(a1, a2, 2));
return 0;
}
int main()
{
printf("inizio\n");
Albero* myalbero=NULL;
addNodo(&myalbero, 15);
addNodo(&myalbero, 10);
addNodo(&myalbero, 8);
addNodo(&myalbero, 5);
addNodo(&myalbero, 9);
addNodo(&myalbero, 25);
addNodo(&myalbero, 19);
addNodo(&myalbero, 29);
printf("fine inserimento\n");
lista* l1 = AllocaLista(myalbero, 1);
printf("fine allocalista\n");
printLista(l1);
Albero* myalbero2=NULL;
addNodo(&myalbero2, 15);
addNodo(&myalbero2, 10);
addNodo(&myalbero2, 8);
addNodo(&myalbero2, 5);
addNodo(&myalbero2, 9);
addNodo(&myalbero2, 25);
addNodo(&myalbero2, 19);
addNodo(&myalbero2, 29);
addNodo(&myalbero2, 28);
addNodo(&myalbero2, 31);
// printf("verificalivelli: %d",verificaLivello(myalbero, myalbero2, 3));
printf("\n\nfine Programma\n");
ModificaFile(myalbero,"livelli.txt");
return 0;
}
