Analytic hierarchy process algorithm.

ahp-algorithm.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TAM 100
#define QUA 100

struct Alternativas
{
    float nota[TAM];
    float classificacao[TAM][TAM];
    float adicao[TAM];
    float aux[TAM];
    float media_aluno[TAM]
}alt[QUA];
void IniciaCriterio(int *num, char nome[QUA][20])
{
    int i;

    //Informações Iniciais para fazer a media dos criterios e as operações necessarias
    printf("Informe quantos criterios serao avaliados: ");
    scanf("%d", &(*num));
    system("cls");
    fflush(stdin);

    for(i=0;i<(*num);i++)
    {
        printf("\nInsira o nome do Criterio para avaliacao (%d de %d): ", i+1, (*num));
        gets(nome[i]);
    }

    system("cls");
}

void Criterio(float *media_criterios, int num, char nome[num])
{
    int linha, coluna, vetor;
    float tabela[num][num], soma[num], auxiliar[num];

    for(linha=0;linha<num;linha++)
    {
        auxiliar[linha] = 0;
        soma[linha] = 0;
        for(coluna=0;coluna<num;coluna++)
        {
            tabela[linha][coluna] = 0;
        }
    }

    //coloca o peso inicial de cada criterio sobre um outro criterio, [coluna/linha é o oposto de linha/coluna]
    for(linha=0;linha<num;linha++)
    {
        for(coluna=0;coluna<num;coluna++)
        {
            if(linha==coluna)
            {
                tabela[linha][coluna] = 1;
            }
            if(linha<coluna)
            {
                printf("Informe o peso entre o criterio %d e o %d: ", linha+1, coluna+1);
                scanf("%f", &tabela[linha][coluna]);
                tabela[coluna][linha] = 1/(tabela[linha][coluna]);
            }
        }
    }

    //SOMA
    for(vetor=0;vetor<num;vetor++)
    {
        for(linha=0;linha<num;linha++)
        {
            for(coluna=0;coluna<num;coluna++)
            {
                if(coluna==vetor)
                {
                    soma[vetor] = soma[vetor] + tabela[linha][coluna];
                }
            }
        }
    }

    //DIVISAO
    for(linha=0;linha<num;linha++)
    {
        for(coluna=0;coluna<num;coluna++)
        {
            tabela[linha][coluna] = tabela[linha][coluna]/soma[coluna];
        }
    }

    //MEDIA FINAL
    for(linha=0;linha<num;linha++)
    {
        for(coluna=0;coluna<num;coluna++)
        {
            auxiliar[linha] = tabela[linha][coluna] + auxiliar[linha];
            media_criterios[linha] = auxiliar[linha]/num;
        }
    }

    system("cls");
}

void IniciaAluno(int *num, char aluno[TAM][50])
{
    int i;

    printf("Informe quantos alunos irao concorrer ao auxilio: ");
    scanf("%d", &(*num));
    fflush(stdin);

    for(i=0;i<(*num);i++)
    {
        printf("Informe o nome do Aluno (%d de %d): ", i+1, (*num));
        gets(aluno[i]);
    }
}

void Aluno(int num_alunos, int num_criterios, char nome_aluno[num_alunos][50], char nome_crit[num_criterios][20], struct Alternativas *alun)
{
    int linha, coluna, vetor;

    //COLUNA = Criterio && LINHA = Aluno

    //NOTA
    for(linha=0;linha<num_alunos;linha++)
    {
        for(coluna=0;coluna<num_criterios;coluna++)
        {
            printf("Informe a nota do aluno %s sobre o criterio %s : ", nome_aluno[linha], nome_crit[coluna]);
            scanf("%f", &(alun[coluna]).nota[linha]);
        }
    }

    //CLASS
    for(vetor=0;vetor<num_criterios;vetor++)
    {
        for(linha=0;linha<num_alunos;linha++)
        {
            for(coluna=0;coluna<num_alunos;coluna++)
            {
                if(alt[vetor].classificacao[linha][coluna] == 0)
                {
                    if(linha==coluna)
                    {
                        alt[vetor].classificacao[linha][coluna]=1;
                    }
                    if(linha<coluna)
                    {
                        if((alt[vetor].nota[linha])-(alt[vetor].nota[coluna])==0)
                        {
                            alt[vetor].classificacao[linha][coluna]=1;
                            alt[vetor].classificacao[coluna][linha]=1;

                        }
                        if((alt[vetor].nota[linha])-(alt[vetor].nota[coluna])<0)
                        {
                            alt[vetor].classificacao[linha][coluna]=1/-((alt[vetor].nota[linha])-(alt[vetor].nota[coluna])-1);
                            alt[vetor].classificacao[coluna][linha]=-((alt[vetor].nota[linha])-(alt[vetor].nota[coluna])-1);
                        }
                        if((alt[vetor].nota[linha])-(alt[vetor].nota[coluna])>0)
                        {
                            alt[vetor].classificacao[linha][coluna]=((alt[vetor].nota[linha])-(alt[vetor].nota[coluna])+1);
                            alt[vetor].classificacao[coluna][linha]=1/((alt[vetor].nota[linha])-(alt[vetor].nota[coluna])+1);
                        }
                    }
                }
            }
        }
    }

    //SOMA

    for(vetor=0;vetor<num_criterios;vetor++)
    {
        for(linha=0;linha<num_alunos;linha++)
        {
            for(coluna=0;coluna<num_alunos;coluna++)
            {
                alt[vetor].adicao[coluna] = alt[vetor].adicao[coluna] + alt[vetor].classificacao[linha][coluna];
            }
        }
    }

    //DIVISAO
    for(vetor=0;vetor<num_criterios;vetor++)
    {
        for(linha=0;linha<num_alunos;linha++)
        {
            for(coluna=0;coluna<num_alunos;coluna++)
            {
                alt[vetor].classificacao[linha][coluna] = alt[vetor].classificacao[linha][coluna]/alt[vetor].adicao[coluna];
            }
        }
    }

    //MEDIA
    for(vetor=0;vetor<num_criterios;vetor++)
    {
        for(linha=0;linha<num_alunos;linha++)
        {
            for(coluna=0;coluna<num_alunos;coluna++)
            {
                alt[vetor].aux[linha] = alt[vetor].classificacao[linha][coluna] + alt[vetor].aux[linha];
                alt[vetor].media_aluno[linha] = alt[vetor].aux[linha]/num_alunos;
            }
        }
    }
}

int main ()
{
    float media_criterios[QUA], media_final[TAM], aux;
    int linha, coluna, vetor, numero_criterios, numero_alunos;
    char auxiliarchar[50], nome_criterios[QUA][20], nome_aluno[TAM][50];

    IniciaCriterio(&numero_criterios, &nome_criterios);
    Criterio(&media_criterios, numero_criterios, nome_criterios);
    IniciaAluno(&numero_alunos, &nome_aluno);
    Aluno(numero_alunos, numero_criterios, &nome_aluno, &nome_criterios, &alt);

    for(vetor=0;vetor<numero_criterios;vetor++)
    {
        for(linha=0;linha<numero_alunos;linha++)
        {
            for(coluna=0;coluna<numero_criterios;coluna++)
            {
                if(linha==vetor)
                {
                    media_final[linha] = media_final[linha] + ((media_criterios[coluna])*(alt[vetor].media_aluno[linha]));
                }
            }
        }
    }

    for(linha=0;linha<numero_alunos;linha++)
    {
        for(coluna=linha+1;coluna<numero_alunos;coluna++)
        {
            if(media_final[coluna]>media_final[linha])
            {
                aux = media_final[coluna];
                media_final[coluna] = media_final[linha];
                media_final[linha] = aux;

                strcpy(auxiliarchar, nome_aluno[coluna]);
                strcpy(nome_aluno[coluna], nome_aluno[linha]);
                strcpy(nome_aluno[linha], auxiliarchar);
            }
        }
    }

    printf("\nOrdem de Classificacao");
    printf("\n\n\n\n\n");

    for(linha=0;linha<numero_alunos;linha++)
    {
        printf("\n%s", nome_aluno[linha]);
    }
    system("pause");
}