C Problema Com Codigo em C receber arquivo e implementar pseudocodigo

[marechalmelo]

Bom tenho o seguinte arquivo:

#Exemplo de projeto simples de montagem de cadeira
#
# Total de atividades, incluindo INI e FIM
T 14
# Listagem das atividades
n 0 0.0 INI
n 1 3.0 SelecaoMadeira
n 2 4.0 EntalhamentoDosArcos
n 3 6.0 EntalhamentoAcentos
n 4 7.0 EntalhamentoEncostos
n 5 3.0 EntalhamentoBracos
n 6 1.0 EscolhaTecidos
n 7 2.0 CosturaAlmofadas
n 8 2.0 MontagemAcentoEncostos
n 9 2.0 FixacaoBracos
n 10 3.0 FixacaoArcos
n 11 5.0 Verniz
n 12 0.5 InstalacaoAlmofadas
n 13 0.0 FIM
# Listagem das precedencias
a 0 1
a 1 2
a 1 3
a 1 4
a 1 5
a 6 7
a 3 8
a 4 8
a 5 9
a 8 9
a 2 10
a 8 10
a 9 11
a 10 11
a 7 12
a 11 12
a 12 13
# Fim de arquivo
f

 

 

T = Numero de Atividades

A - Predecessores

N = Atividades

 

Preciso implementar o seguinte pseucodogio e passa-lo para  C

 {Aqui começa o cálculo do agendamento} 2: T ← R ⊲ Mantém R original
3: s0 ← 0 ⊲ a0 começa e termina em t = 0 4: t0 ← 0 5: T ← T − {(a0,aj)|a0 precede aj na rede } ⊲ Libera os sucessores de a0
6: while (T 6= ∅) do 7: M ← {ak |ak é uma atividade minimal em T} ⊲ Descobre quem já pode ser agendada
8: repeat 9: Escolher alguma atividade aj ∈ M ⊲ Não importa a ordem
10: P(aj) ← {ai |(ai,aj) ∈ R} ⊲ Descobre predecessores de aj
11: sj ← max ai∈P(aj)
{ti} ⊲ Descobre qual predecessor termina mais tarde e agenda aj
12: tj ← sj + dj ⊲ Calcula quando aj termina
13: T ← T − {(aj,ak)|aj precede ak na rede } ⊲ Libera os sucessores de aj 14: M ← M − {aj} ⊲ Marca que aj já foi agendado 15: until (M = ∅) 16: end while
17: {Início do cálculo de um dos caminhos críticos} 18: C ← {an} ⊲ an sempre está no caminho crítico 19: ak ← an ⊲ Atividade corrente ak é o an, inicialmente
20: P(ak) ← {ai |(ai,ak) ∈ R} ⊲ Descobre quem precede a última atividade
21: while (P(ak) 6= ∅) do 22: Selecione ai tal que ai ∈ P(ak) e ti = sk ⊲ Descobre quem está no caminho crítico com ak
23: C ← C ∪ {ai} ⊲ Inclui ai no caminho crítico
24: ak ← ai ⊲ Faz com que ai seja a atividade corrente
25: P(ak) ← {ai |(ai,ak) ∈ R} ⊲ Descobre quem precede nova atividade corrente 26: end while
27: return (sk,tk,C) ⊲ Retorna agendamentos e quem está no caminho crítico

 

 

 

Conforme mencionado neste documento, o diagrama de redes PERT/CPM pode ser entendido como um diagrama de Hasse da ordenação parcial gerada sobre o conjunto A de atividades que diz que o par ordenado (i,j) ∈4 quando a atividade i precede a atividade j no respectivo projeto. Dessa forma, desenhando o diagrama da esquerda para a direita, teremos que as atividades sem predecessores à esquerda são elementos minimais do diagrama de Hasse, enquanto que as atividades à direita sem sucessores serão os elementos maximais do diagrama. Com base nesta observação é possível esboçar, em pseudocódigo, um procedimento computacional capaz de calcular o caminho crítico de um projeto. Um esboço do procedimento é dado em pseudocódigo do Algoritmo 1. Em termos de notação, A representa o conjunto com todas as atividades do projeto, que inicia-se na atividade a0 e encerra em an; R representa a rede de atividades original do projeto, codificada sob a forma de uma matriz de incidência (isto é, se a atividade i precede a atividade j, então na linha R[i,j] = 1) e deve também ser entendida matematicamente como o conjunto R = {(i,j)|i precede j}; T é o conjunto dos arcos que representam a rede de atividades, mas que é modificada ao longo do algoritmo para eliminar atividades já processadas; M guarda o conjunto dos elementos minimais de T e é reconstruído sempre que T sofre alterações; P(ak) refere-se ao conjunto das atividades que precedem ak na rede; e C é o conjunto que contém todas as atividades que estão presentes em um dos caminhos críticos da rede (se houver apenas um, conterá o caminho crítico). O algoritmo é descrito em notação de conjuntos. Observe que no pseudocódigo dado, assume-se que a atividade 0 é a atividade fantasma INI, e que a atividade n é a atividade fantasma FIM. Desta forma, toda atividade real tem como predecessora a atividade a0, e a última atividade do cronograma será an. O makespan do cronograma pode ser obtido consultado o valor de
 

 

O algoritmo funciona como segue, dividido em duas partes, mais especificamente que lidam com o agendamento de início e término de cada atividade da rede (linhas 1 à 16) e cálculo de que atividades estão no caminho crítico (linhas 17 à 27). Comentaremos primeiramente o agendamento das atividades. Ela inicia na linha 2, onde copia-se a matriz de incidência R para uma matriz temporária T, que será modificada ao longo do algoritmo para expressar o pedaço da rede que contém as atividades que ainda não foram agendadas no tempo. Nas linhas 3 e 4 define-se o agendamento da atividade INI, que é zero por não ter duração real e marcar simplesmente o início do projeto. Na linha 5 elimina-se da matriz T todos os arcos que partem de a0 e chega nas primeiras atividades reais do projeto. Fazemos isso para que estas atividades sejam as próximas minimais a serem consideradas, ou seja, quais atividades já estão aptas a serem agendadas. São atividades aptas para o agendamento todas aquelas em que os seus predecessores já foram agendados e, portanto, conhece-se o
10
tempo de encerramento dos mesmos. Isso é calculado na linha 7 do algoritmo. Para realizar a operação da linha 5 pode-se simplesmente varrer a linha 0 da matriz T, eliminando-se entradas iguais à 1 (em outras palavras, retirando da matriz T todos os registros de arcos que partem de a0 e chegam em alguma atividade). Ao realizar essa operação é fácil perceber que as atividades que serão consideradas minimais são aquelas que não tem predecessor registrado em T, ou seja, aquelas em que não chegam nenhum arco nelas (o que pode ser facilmente verificado checando-se quais delas não possuem nenhum valor 1 na coluna correspondente em T), sendo esta a lógica de construção do conjunto M, conforme linha 7. Para cada elemento minimal iremos realizar as operações contidas entre as linhas 9 e 15. Em 9, escolhe-se alguma atividade contida no conjunto M (não importa a ordem, pois todas estão aptas e todas serão processadas antes do algoritmo avançar). Descobre-se, na linha 10, quem são os predecessores da atividade aj escolhida. Isso é feito verificando-se na matriz da rede original (isto é, na matriz R, não em T) quais são as entradas da coluna j que possuem valor 1. Para cada uma destas atividades ai espera-se que já tenham sido escalonadas; logo os valores de ti são conhecidos. A atividade aj selecionada irá iniciar no mesmo instante de tempo que a sua predecessora mais tardia ai encerrar, o que está denotado na linha 11 do algoritmo. Tendo a duração da atividade aj é possível determinar, com base em seu início, quando irá terminar no tempo (linha 12). Temos, portanto, a atividade aj agendada, de forma que para prosseguir devemos eliminar os arcos que partem de aj para as demais atividades para que estas estejam aptas a serem agendadas (caso que ocorre se todas as suas predecessoras também estiverem agendadas). Isso é feito na linha 13, novamente eliminando todas as entradas da matriz T em cuja linha j possuem colunas com valor 1. Eliminamos também na linha 14 o registro de que aj é minimal, para que não seja novamente calculada, visto que já foi agendada e não precisa mais ser tratada pelo algoritmo. Se todas as atividades minimais já foram processadas, então o algoritmo já agendou todas as atividades e pode seguir para a linha 17, onde inicia-se o cálculo para descobrir que atividades compõem o caminho crítico; caso contrário o processo segue, repetindo as linhas 6 à 15, até agendar todas as atividades no tempo. A segunda parte do algoritmo dá-se início efetivo na linha 18, em que o conjunto C é criado contendo, inicialmente, apenas a última atividade do projeto (atividade an, ou FIM). Como ela sempre encerra o cronograma então ela faz parte do caminho mínimo, naturalmente. Para determinar que outras atividades também compõem o caminho crítico, temos que varrer a rede ao contrário, das atividades maximais em direção às minimais. O algoritmo apresentado irá guardar em C as atividades de algum caminho crítico existente; entretanto ele não consegue lidar com a situação onde mais de um caminho existe. É uma simplificação razoável visto que o objetivo do trabalho é também demonstrar que uma estrutura puramente matemática como relações e ordenações parciais podem ser úteis como modelos para tratar situações e problemas reais não tendo este trabalho, portanto, a ousadia de cobrir todos os casos tais como ocorre em programas comerciais. Na linha 19 iremos assumir que a atividade atual ak será, inicialmente, an. Na linha 20 descobre-se quem precede ak, e na linha 22 descobre-se qual foi a predecessora ai de ak que foi responsável por agendar ak em sk. Se ak está no caminho crítico e ai precede ak de forma que quando ai termina ak começa, então ela também está no caminho crítico, portanto devemos guardá-la no conjunto C, como descrito na linha 23. A partir daqui o
11
processo recomeça, partindo agora de ai (que torna-se a nova atividade ak corrente, linha 24) recalculando as predecessoras da nova atividade corrente (linha 25), até que esse caminhamento atinja a atividade a0, que não tem predecessores. Essa será a condição de saída do laço controlado na linha 21. Se ainda não atingimos a atividade a0, então executa-se mais uma iteração com as operações descritas entre as linhas 22 e 25; caso contrário já descobrimos todas as atividades de um dos caminhos críticos e podemos, enfim, retornar o agendamento das tarefas e o próprio caminho crítico computado (linha 27).
 

 

 

Eu ja realizei ISSO ate o momento:

// Estudo de Caso matematica Discreta

#include <string.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// Declaracao da struct  de dados auxiliar

typedef struct criar_Dados {
    int id; // Armazena o ID de todas as atividades
    int duracao; // Armazena a duracao das atividades
    char nome[100]; // Guarda o nome de todas as atividades realizadas
} criar_Dados; // Define o tipo da struct

void CadastrarDados(criar_Dados *cadastrar, criar_Dados *dados, int *contador); // Essa struct realiza o cadastramento de todos os dados na struct principal

int main() {
    int aj;
    int verificacao;
    char *t; // Variavel utilizada para receber os valores das linhas
    int ini; // Declara a variavel de inicio do calculo de Perc
    int j; // Variavel Utilizada como Contadora
    int h; // Variavel auxiliar de t
    int *P; // variavel que capta os caminhos criticos 
    int z, q; // Variaveis contadoras
    int *M; // Vetor auxiliar para guardar conjunto de atividades
    int **R; // Declara a Matriz R de duas dimensoes
    int **T; // Declara a Matriz T que e auxiliar a R
    int contar_m; // Variavel para Contar M
    int contador; // Cria um contador
    criar_Dados *cadastrar; // Declara struct de cadastro
    cadastrar = malloc(sizeof (criar_Dados)); // Realiza a locacao de memoria do cadastrar
    criar_Dados dados; // Declara struct de receber dados
    contar_m = 0;
    FILE* arquivo = fopen("arquivo.txt", "r");
    if (arquivo == NULL) {
        printf("Erro ao abrir o arquivo.txt."); /* imprimir na tela para visualizar                     */
        return 1; /* retorna                                              */
    }
    int i;
    char linha[50];
    //Inicio da leitura de dados
    while (fgets(linha, 150, arquivo) != NULL) { /* lê uma linha no arquivo até encontrar o EOF          */
        if (linha[0] == 'T') {

            t = strtok(linha, " "); // Remove o A
            t = strtok(NULL, " "); // Remove o espaco depois do A 
            h = atoi(t); // Atribui o Valor ao H 
            R = malloc(h * sizeof (int *)); // Aloca a matriz R do tamanho de T
            T = malloc(h * sizeof (int *)); // Aloca a matriz R do tamanho de T auxiliar
            M = malloc(sizeof (int *)); // Aloca a matriz R do tamanho de T auxiliar
            for (i = 0; i < h; i++) {
                R[i] = malloc(h * sizeof (int *)); // Realoca a Coluna da Matriz
                T[i] = malloc(h * sizeof (int *)); // Realoca a Coluna da Matriz
                for (j = 0; j < h; j++) {
                    R[i][j] = 0; // Zera todos Componentes da Matriz
                    T[i][j] = 0; // Zera todos Componentes da Matriz auxilias
                }
            }
        }
        if (linha[0] == 'n') { // Localiza o caracter inicial a
            t = strtok(linha, " "); // Pula o caracter A
            t = strtok(NULL, " "); // Pula o espaço
            dados.id = atoi(t); // Atribui a Struct dados
            t = strtok(NULL, " "); // Pula espaco
            dados.duracao = atoi(t); // atribui a duracao
            t = strtok(NULL, " "); // Pula espaco
            strcpy(dados.nome, t); // Atribui o nome
            cadastrar = realloc(cadastrar, (contador + 1) * sizeof (criar_Dados)); // Realiza uma relocacao no tamanho da struct
            CadastrarDados(cadastrar, &dados, &contador); // Realiza o cadastramento na struct principal


        }

        if (linha[0] == 'a') { // Localiza o caracter inicial a
            t = strtok(linha, " "); // Pula o caracter A
            t = strtok(NULL, " "); // Pula o espaço
            z = atoi(t); // Atribui a p 
            t = strtok(NULL, " "); // Pula espaco
            q = atoi(t); // Atribui a Q
            R[z][q] = 1; // Preenche as dependencias com 1
            T[z][q] = 1; // Preenche as dependencias da matriz Auxiliar com 1
        }
        if (linha[0] == 'f') { // Localiza o caracter inicial f
            fclose(arquivo); // Realiza o fechamento do arquivo
        }
    } // Fim da leitura de dados

    //Inicio do Calculo de agendamento e caminhos criticos
    ini = 0;

    for (i = 0; i < h; i++) { // Realiza o Varrimento da Matriz a0 , aj eliminando o que tiver de 1

        if (T[0][i] == 1) { // Zera a Matriz na Posicao 0 em que eles encontram 1
            T[0][i] = 0; // Zerando onde foi encontrado o 1
        } // Fecha o IF
    } // Fecha o For

    // Inicio do laco
    do {


        for (i = 0; i < h; i++) { // Varre o primeiro para pegar a coluna
            verificacao = 0; // Define a variavel de verificacao como 0
            for (j = 0; j < h; j++) { // Segundo for para atribuir a linha
                if (T[j][i] == 1) { // Verifica se nao tem nenhum 1 na coluna 
                    verificacao = 1; // Se tiver um define verificacao como 1
                } // 
            }//

            if (verificacao != 1) { // Se a verificacao for diferente de 1 atribui a M
                M[contar_m] = i; // Define M como i
                contar_m++; // Aumenta 1 no M
                M = (int *) realloc(M, sizeof (int)*contar_m);

            }
        }

        while(M[0]!=0){
        aj = M[contar_m - 1];
        for (i = 0; i < (contar_m - 1); i++) {
            M[i] = M[i + 1];
        }
        contar_m--;
        M = (int *) realloc(M, sizeof (int)*contar_m);
        printf("%d",M[contar_m]);
        }
        break;



    } while (T != 0); // Inicia o laco ate o T nao se tornar 0





    // Fim do calculo de agendamento e caminhos criticos 

    return 0; // Fecha o main
}

// Funcoes

void CadastrarDados(criar_Dados *cadastrar, criar_Dados *dados, int *contador) {
    (*(cadastrar + (*contador))).id = dados->id; // Envia os arquivos dos dados ID para a struct principal
    (*(cadastrar + (*contador))).duracao = dados->duracao; // Envia os arquivos dos dados duracao para a struct principal
    strcpy((*(cadastrar + (*contador))).nome, dados->nome); // Envia os arquivos dos dados nome para a struct principal
    (*contador)++; // Acresce 1 no valor do contador
}

Alguem poderia me ajudar travei agora