/******************************************************************************************
* rotL()
*
* Arguments: h: ponteiro para um no da arvore
*
* Returns: link
* Description: roda a arvore para a esquerda
*****************************************************************************************/
link rotL(link h){
int peso_left, peso_right;
link x = h->r;
h->r = x->l;
x->l = h;
peso_left = peso(h->l); peso_right = peso(h->r);
h->peso = peso_left > peso_right ? peso_left + 1 :
peso_right + 1;
peso_left = peso(h->l); peso_right = peso(x->r);
x->peso = peso_left > peso_right ? peso_left + 1 :
peso_right + 1;
return x;
}
/*
Objetivo do backtracking.
Devolve: 1, se foi executada corretamente;
0, se algum erro ocorreu (deve abortar o bactracking).
*/
int objetivo(unsigned int restricao)
{
if (restricao < 2 || restricao > VERTICES->tamanho)
return 1;
double custo = 1;
unsigned int i;
for (i = 0; i < restricao-1; i++)
custo = (double) (custo * peso(VERTICES->C[i], VERTICES->C[i + 1]));
unsigned int
src = VERTICES->C[0],
dst = VERTICES->C[restricao - 1];
if (custo < custo_global_get(src, dst)) {
caminho *c = caminho_novo(src);
unsigned int j;
for (j = 1; j < restricao; j++)
c = caminho_adiciona(c, VERTICES->C[j]);
free(tbl.tabela[src][dst]);
tbl.tabela[src][dst] = c;
}
return 1;
}
void relax(Heap *heap, Grafo *grafo, int u, int v){
int alt = grafo->lista[u]->d + peso(grafo,u,v);
if(grafo->lista[v]->d > alt){
heap_decrease_key(heap, v, alt);
grafo->lista[v]->d = alt;
//grafo->lista[v]->pi = grafo->lista[u];
}
}
/******************************************************************************************
* AVLbalance()
*
* Arguments: h: ponteiro para um no da arvore
*
* Returns: link retorna um no da arvore
* Description: balanceia a arvore AVL
*****************************************************************************************/
link AVLbalance(link h){
int balanceFactor;
if (h==NULL)
return h;
balanceFactor = Balance(h);
if(balanceFactor > 1){
if (Balance(h->l) >= 0)
h=rotR(h);
else
h=rotLR(h);
}
else if(balanceFactor < -1){
if (Balance(h->r) <= 0)
h = rotL(h);
else
h = rotRL(h);
} else{
int peso_left = peso(h->l);
int peso_right = peso(h->r);
h->peso = peso_left > peso_right ? peso_left + 1 : peso_right + 1;
}
return h;
}
int main() {
int i, j, n;
float media;
printf("Insira a quantidade de bois\n");
scanf("%d", &n);
float **bois = (float**)malloc(n * sizeof(float *)); //Aloca um Vetor de Ponteiros
for (i = 0; i < n; i++){ //Percorre as linhas do Vetor de Ponteiros
bois[i] = (float*) malloc(3 * sizeof(float)); //Aloca um Vetor de Inteiros para cada posição do Vetor de Ponteiros.
for (j = 0; j < 3; j++){ //Percorre o Vetor de Inteiros atual.
bois[i][j] = 0; //Inicializa com 0.
}
}
// for(i=0;i<n;i++){
// for(j=0;j<3;j++){
// printf("%.2f ", bois[i][j]);
// }
// printf("\n");
// }
printf("Insira os dados para %d boi(s)\n", n);
for(i=0,j=0;i<n;i++){
printf("Insira os dados do boi %d: Codigo, Peso e Valor\n", i+1 );
scanf("%f %f %f", &bois[i][j], &bois[i][j+1], &bois[i][j+2]);
}
// printf(" Codigo\t Peso \tValor\n");
// for(i=0;i<n;i++){
// printf("Boi #%d ", i+1);
// for(j=0;j<3;j++){
// printf("\t%.2f ", bois[i][j]);
// }
// printf("\n");
// }
media = mediaValor(bois, &n);
printf("Media dos valores do total de bois (%d) = R$ %.2f\n", n, media);
peso(bois, &n);
return 0;
}
caminho *caminho_adiciona(caminho *c, unsigned int fim)
{
if (!c || !c->C)
return NULL;
if (c->tamanho == c->capacidade) {
printf("aumentando um caminho...\n");
/* dobra a capacidade conservando o padding */
c->capacidade = 2 * (c->capacidade + 4) - 4;
c->C = realloc(c->C, c->capacidade * sizeof(unsigned int));
if (!c->C)
return NULL;
}
c->C[c->tamanho] = fim;
c->custo = (double) c->custo * peso(c->C[c->tamanho - 1], fim);
c->tamanho++;
return c;
}
/******************************************************************************************
* Balance()
*
* Arguments: h: ponteiro para um no da arvore
*
* Returns: int retorna o novo peso
* Description: retorna o novo peso para balanceamento
*****************************************************************************************/
int Balance(link h) {
if(h == NULL)
return 0;
return peso(h->l) - peso(h->r);
}