void AG(int n,
        int *s,
        int *p,
        int *w,
        int b,
        int penalidade,
        int *peso_objetos,
        int *fo,
        int nind,
        int max_geracoes,
        double prob_crossover,
        double prob_mutacao)
{
    int **pop; // populacao
    int *fo_pop; // funcao objetivo corrente de um dado individuo da populacao
    int *inv_pop;  // quantidade de inviabilidade de cada individuo
    int *peso_objetos_pop; // peso dos objetos de cada individuo
    int **pop_sobrev; // populacao sobrevivente
    int *fo_pop_sobrev; // funcao objetivo corrente de um dado individuo da populacao sobrevivente
    int *inv_pop_sobrev;  // quantidade de inviabilidade de cada individuo da populacao sobrevivente
    int *peso_objetos_pop_sobrev; // peso dos objetos de cada individuo da populacao sobrevivente
    int *s_star;   // vetor que contem a melhor solucao gerada
    int fo_star;   // valor da melhor solucao gerada

    s_star = cria_vetor(n);
    fo_star = *fo = -INT_MAX;
    nind = nind * 2;
    pop = cria_matriz(nind, n);
    inv_pop = cria_vetor(nind);
    peso_objetos_pop = cria_vetor(nind);
    fo_pop = cria_vetor(nind);
    inicializa_vetor(inv_pop,nind);
    inicializa_vetor(peso_objetos_pop,nind);
    inicializa_vetor(fo_pop,nind);
    for (int j=0;j<nind;j++) inicializa_vetor(pop[j],n);
    inicializa_vetor(s_star,n);

    pop_sobrev = cria_matriz(nind/2, n);
    inv_pop_sobrev = cria_vetor(nind/2);
    peso_objetos_pop_sobrev = cria_vetor(nind/2);
    fo_pop_sobrev = cria_vetor(nind/2);
    inicializa_vetor(inv_pop_sobrev,nind/2);
    inicializa_vetor(peso_objetos_pop_sobrev,nind/2);
    inicializa_vetor(fo_pop_sobrev,nind/2);
    for (int j=0;j<nind/2;j++) inicializa_vetor(pop_sobrev[j],n);

    /* Geracao da populacao inicial */
    for (int j=0; j< nind/2; j++){
        constroi_solucao_aleatoria(pop[j], n);
        //imprime_solucao(pop[j],n);
        peso_objetos_pop[j] = calcula_peso_objetos(pop[j], n, w);
        inv_pop[j] = calcula_inviabilidade(peso_objetos_pop[j], b);
        fo_pop[j] = calcula_fo(pop[j], n, p, inv_pop[j], penalidade);
        printf("Individuo %d : fo = %2d  peso = %2d  inviabilidade = %d \n",
               j, fo_pop[j], peso_objetos_pop[j], inv_pop[j]);
        if (inv_pop[j]){
           repara_inviabilidade(n,pop[j],p,w,b,penalidade,&peso_objetos_pop[j],&fo_pop[j],&inv_pop[j]);
           printf("Individuo %d reparado : fo = %2d  peso = %2d  inviabilidade = %d \n",
                   j, fo_pop[j], peso_objetos_pop[j], inv_pop[j]);
           //imprime_solucao(pop[j],n);
        }
        if (fo_pop[j] > fo_star){
           fo_star = fo_pop[j];
           atualiza_melhor_solucao(pop[j], s_star, n);
        }
    }
    printf("fo do Melhor individuo da populacao inicial = %2d\n",fo_star);

    int ngeracoes = 0;
    while (ngeracoes < max_geracoes){
      ngeracoes++;
      /* Aplicar crossover */
      int quant_filhos = 0;
      while (quant_filhos < nind/2){
          /* Selecao aleatoria de pais */
          int jpai1 = random(nind/2);
          int jpai2 = random(nind/2);
          if (randomico(0,1) < prob_crossover){
             int ponto_de_corte = random(n);
             crossover(pop[jpai1], pop[jpai2], pop[quant_filhos+nind/2], pop[quant_filhos+nind/2+1], n, ponto_de_corte);
             quant_filhos+=2;
          }
      }
      /* Aplicar mutacao */
      for (int j=0; j < nind; j++)
        if (randomico(0,1) < prob_mutacao)
           mutacao(pop[j], n);
      /* Avaliar a populacao inteira (pais e filhos) */
      for (int j=0; j<nind; j++){
        peso_objetos_pop[j] = calcula_peso_objetos(pop[j], n, w);
        inv_pop[j] = calcula_inviabilidade(peso_objetos_pop[j], b);
        fo_pop[j] = calcula_fo(pop[j], n, p, inv_pop[j], penalidade);
        printf("Individuo %d : fo = %2d  peso = %2d  inviabilidade = %d \n",
               j, fo_pop[j], peso_objetos_pop[j], inv_pop[j]);
        if (inv_pop[j]){
           repara_inviabilidade(n,pop[j],p,w,b,penalidade,&peso_objetos_pop[j],&fo_pop[j],&inv_pop[j]);
           printf("Individuo %d reparado : fo = %2d  peso = %2d  inviabilidade = %d \n",
                   j, fo_pop[j], peso_objetos_pop[j], inv_pop[j]);
        }
        if (fo_pop[j] > fo_star){
           fo_star = fo_pop[j];
           atualiza_melhor_solucao(pop[j], s_star, n);
        }
      }
      /* Definir a populacao sobrevivente */
      /* fo de todos os individuos da populacao, isto e', pais e filhos */
      for (int j=0; j<nind; j++)
        printf("fo_pop[%2d] = %2d\n",j,fo_pop[j]);
      for (int j=0; j<nind/2; j++){
        /* escolha dos individuos sobreviventes por selecao aleatoria */
        int individuo_escolhido = random(nind);
        for (int i=0; i<n; i++) pop_sobrev[j][i] = pop[individuo_escolhido][i];
        fo_pop_sobrev[j] = fo_pop[individuo_escolhido];
        peso_objetos_pop_sobrev[j] = peso_objetos_pop[individuo_escolhido];
        inv_pop_sobrev[j] = inv_pop[individuo_escolhido];
      }
      /* Zerar a populacao e seus dados */
      inicializa_vetor(inv_pop,nind);
      inicializa_vetor(peso_objetos_pop,nind);
      inicializa_vetor(fo_pop,nind);
      for (int j=0;j<nind;j++) inicializa_vetor(pop[j],n);
      /* Primeira metade da populacao <-- populacao sobrevivente */
      for (int j=0; j<nind/2; j++){
        for (int i=0; i<n; i++) pop[j][i] = pop_sobrev[j][i];
        fo_pop[j] = fo_pop_sobrev[j];
        peso_objetos_pop[j] = peso_objetos_pop_sobrev[j];
        inv_pop[j] = inv_pop_sobrev[j];
      }
      /* fo dos individuos sobreviventes */
      for (int j=0; j<nind/2; j++)
        printf("fo_pop[%2d] = %2d\n",j,fo_pop[j]);
      /* Zerar a matriz e os vetores que armazenam os dados da populacao sobrevivente */
      inicializa_vetor(inv_pop_sobrev,nind/2);
      inicializa_vetor(peso_objetos_pop_sobrev,nind/2);
      inicializa_vetor(fo_pop_sobrev,nind/2);
      for (int j=0;j<nind/2;j++) inicializa_vetor(pop_sobrev[j],n);
    }
    imprime_solucao(s_star,n);
    atualiza_melhor_solucao(s_star, s, n);
    *fo = fo_star;
    *peso_objetos = calcula_peso_objetos(s_star, n, w);;

    printf("-------------------------------------------------\n");
    printf("Melhor solucao encontrada pelo Algoritmo Genetico:\n");
    printf("Funcao objetivo: %d\n", *fo);
    printf("Peso da mochila: %d    Inviabilidade = %d \n", *peso_objetos, MAX(0,*peso_objetos - b));
    printf("-------------------------------------------------\n");

    libera_matriz(pop, nind);
    libera_vetor(inv_pop);
    libera_vetor(peso_objetos_pop);
    libera_vetor(fo_pop);
    libera_matriz(pop_sobrev, nind/2);
    libera_vetor(inv_pop_sobrev);
    libera_vetor(peso_objetos_pop_sobrev);
    libera_vetor(fo_pop_sobrev);
    libera_vetor(s_star);
}