예제 #1
0
/******************************************************************************************
* 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;
}
예제 #2
0
/*
  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;
}
예제 #3
0
파일: TAD_GRAFO.c 프로젝트: gioknx/AEDS-3
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];
	}
}
예제 #4
0
/******************************************************************************************
* 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; 
}
예제 #5
0
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;
}
예제 #6
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;
}
예제 #7
0
/******************************************************************************************
* 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);
}