3.3 RESULTADOS
3.3.3 Análise de Qualidade
menor erro residual encontrado entre os modelos utilizados. A análise da função corrobora com o que foi levantado no tópico de "Análise Experimental", exibido anteriormente: quanto maior o número de arestas, menor a demanda de tempo computacional.
As colunas de preenchimento cinza, apresentadas em algumas tabelas, indicam que não há empreendedor com alta intensidade na respectiva característica. A Tabela 4 se refere a um grupo ótimo, em que os empreendedores se compensam em todas as características.
Tabela 4. Grupo Ótimo.
Nome C1 C2 C3 C4 C5 C6 C7 C8 C9 C10
Abigail Tabares B B M M A B M A B B
Diana Gómez M A B A B A M A B A
Edmundo Carballo A A A B A A M B A B
Flávia Carrasqueira B M M B B M B A A B
Gertrudes Passos A A B B M B B A B M
Israel Pari B A B M B B M A A M
Mateus Cotrim M M B M A M M A M B
Melinda Picanço B M A M A A M A A A
Nazaré Gomes B B B A M A A A A M
Poliana Castel-Bran M B A B B B M A M B
A Tabela 5 representa um grupo onde não há alta intensidade para todas as competências, no entanto a combinação das mesmas não gera uma vulnerabilidade. Desta forma, o grupo é aceito como possibilidade de sugestão.
Tabela 5. Grupo Aceitável.
Nome C1 C2 C3 C4 C5 C6 C7 C8 C9 C10
Balduíno Rebouças M M M A A B B B M M
Gávio Pena B B M A B M M A M M
Hermígio Peroba B M A A A M B A M M
Iberê Peña M M M A M B B B M M
Ludovico Domínguez B A B A M B B B A B
Luísa Mendonça A M M A B B A B A M
Lúcio Peña A A B A M B A M M B
Nazaré Gomes B B B A M A A A A M
Noel Paraguaçu B B M A A M M B M M
Tália Dornelles M A M A M M A A A M
A Tabela 6 apresenta um grupo em que a falta de um empreendedor que compense uma característica defasada torna o grupo vulnerável, de acordo com as combinações identificadas por Rosa (2010), sendo considerado um grupo inaceitável e de baixa qualidade.
Tabela 6. Grupo Inaceitável.
Nome C1 C2 C3 C4 C5 C6 C7 C8 C9 C10
Diana Gómez M A B A B A M A B A
Flávia Carrasqueira B M M B B M B A A B
Hermígio Peroba B M A A A M B A M M
Israel Pari B A B M B B M A A M
Jadir Ignacio B A A B M M B B M B
Justino Cortez M A B M B M B A A M
Poliana Castel-Branco M B A B B B M A M B
Rosália Calheiros M B A B A B B A B A
Soeiro Brandán M A M M M A B A M B
Tália Dornelles M A M A M M A A A M
4 CONCLUSÕES
A ferramenta TUTOR, proposta por Pessoa (2010), tem por objetivo monitorar e proporcionar a incorporação de características do comportamento empreendedor nos usuários que a utilizem. Neste contexto, surgiu a proposta de ampliar a ferramenta, desenvolvendo uma funcionalidade capaz de sugerir grupos de empreendedores com base nas características que estes possuem. Desta forma, possibilitando a criação de equipes complementares e equilibradas, onde os pontos fracos de um empreendedor são amenizados por outro integrante do grupo.
Para cumprir com este objetivo foi realizado um estudo relacionado à Complexidade de Algoritmos, uma vez que a análise das conexões entre os empreendedores compreende problemas NP-Completos, como Conjunto Independente e Clique. Este estudo possibilitou a compreensão da dificuldade para encontrar soluções ótimas para problemas computacionalmente difíceis e alternativas para solucioná-los em tempo polinomial. A partir das referências, também foi possível compreender e documentar os problemas computacionais envolvidos neste projeto.
Ainda durante o processo de pesquisa, foram levantados trabalhos similares, os quais abordam alternativas heurísticas para obter soluções em tempo polinomial para Conjunto Independente ou Clique. Os trabalhos foram documentados e contribuíram para o processo de desenvolvimento do projeto.
Após os estudos realizados, foi dado início à implementação dos algoritmos heurísticos para os problemas envolvidos. Durante o processo foram identificadas situações que inviabilizaram o progresso de duas heurísticas. A heurística proposta por Andrade, Resende e Werneck (2012) não apresentou detalhes suficientes de implementação, impedindo que sua codificação fosse realizada. Já para a heurística apresentada por Benlic e Hao (2013), foram encontradas dificuldades durante codificação, garantindo resultados para poucas instâncias. Isto dificultou a realização dos testes, impedindo que a mesma fosse utilizada para a sugestão dos grupos.
Durante a codificação da heurística proposta por Grosso, Locatelli e Pullan (2007), foram encontrados problemas relacionados às estruturas de dados. Após três abordagens diferentes, obteve-se como melhor estrutura uma implementação de duas listas distintas. A primeira contém os vértices pertencentes à lista, enquanto a segunda informa a posição em que
o vértice se encontra na primeira lista. Esta alternativa apresentou resultados bastante satisfatórios, permitindo verificar em tempo 𝑂(1) se um elemento está na lista. Desta forma, o algoritmo se aproximou dos resultados relatados por Grosso, Locatelli e Pullan (2007)
Após a implementação do algoritmo foram realizados os testes para validar a heurística em relação à complexidade de tempo e qualidade da solução. A análise dos resultados mostrou que a implementação realizada neste projeto consegue atingir as soluções em tempo polinomial, apesar de apresentar tempo um pouco superior ao relatado por Grosso, Locatelli e Pullan (2007).
O algoritmo foi capaz de encontrar a solução ótima, pelo menos uma vez, para todos os problemas analisados. Ainda foi possível identificar que o algoritmo demanda maior tempo computacional ao trabalhar com grafos esparsos, onde existem poucas ligações entre os vértices do grafo.
Os resultados de qualidade mostraram eficiência, garantindo, em sua maioria, grupos em que todas as características são compensadas por pelo menos um empreendedor. No entanto, os testes foram realizados com dados fictícios, buscando simular um grupo real de pessoas. A aplicação dos testes em turmas reais foi inviabilizada, pois a ferramenta TUTOR não foi disponibilizada em nenhuma disciplina durante o desenvolvimento deste trabalho. Desta forma, os resultados não possuem volume suficiente para considerar a solução como definitiva, havendo possibilidades de melhoria na complexidade de tempo, bem como na qualidade da solução.
Para trabalhos futuros, é possível citar: (i) dar continuidade aos estudos de heurísticas de busca local, visando à solução do Conjunto Independente ou Clique; (ii) trabalhar na melhoria da solução quanto à busca de grupos de empreendedores, uma vez que a ferramenta TUTOR ainda não possui volume suficiente de dados de usuários, o que permitiria uma melhor avaliação do produto deste trabalho; e (iii) proporcionar a integração entre a ferramenta TUTOR e o algoritmo desenvolvido, permitindo que todo o processo envolvido nas etapas seja feito de forma transparente, simplificando o processo de obtenção de grupos.
REFERÊNCIAS
ANDRADE, D. V.; RESENDE, M. G. C.; WERNECK, R. F. Fast local search for the maximum independent set problem. Journal of Heuristics. Springer US, 2012. ISSN: 1381- 1231.
ARORA, S.; BARAK, B. Computational complexity: a modern approach. Nova York:
Cambridge University Press, 2009.
BALAS, E.; YU, C, S. Finding a maximum clique in an arbitrary graph. SIAM Journal of Computing, 1986, doi:10.1137/0215075.
BATSYN, M. et al. Improvements to MCS algorithm for the maximum clique problem.
Journal of Combinatorial Optimization. [S.l.]: Springer, 2013. ISSN: 1382-6905.
BENLIC, U.; HAO; J. Breakout local search for maximum clique problems. Computers and Operations Research. Elsevier UK, 2013. ISSN: 0305-0548.
BOMZE, I. M. et al. The Maximum Clique Problem. In: DU, D. Z.; PARDALOS, P. M.
Hankbook of combinatorial optimization. [S.l.]:Kluwer Academic Publishers, 1999.
BOSCARIOL, L. A.; GAMEIRO, L. B.; ARRUDA, R. L. S. Coloração de grafos, 2007.
Disponível em: <http://www2.dc.uel.br/~rlarruda/trab/coloracao-grafos.pdf>. Acesso em: 22 abr. 2013.
BUTENKO, S. Maximum independent set and related problems, with applications. 2003.
167 f. Dissertação (Doutorado) – Gainesville, 2003.
BUTENKO, S.; WILHELM, W. E. Clique-detection models in computational biochemistry and genomics. In: European journal of operational research, College Station, p. 1-17, 2006.
CARRAGHAN, R.; PARDALOS, P. M. An exact algorithm for the maximum clique problem. Operations Research Letters, 1990, doi:10.1016/0167-6377(90)90057-C.
CARNEIRO, P.P. Metodologia fuzzy aplicada para predição do comportamento empreendedor. Rio de Janeiro: IBMEC 2008.
CORMEN, T. H. et al. Algoritmos: teoria e prática. 2. ed. Rio de Janeiro: Elsevier, 2002.
DOLABELA, F. Oficina do empreendedor. São Paulo: Cultura Editores Associados, 1999.
DORNELAS, J. C. A. Empreendedorismo: transformando ideias em negócios. Rio de Janeiro: Elsevier, 2008.
GAREY, M. R.; JOHNSON, D. S. Computers and intractability: a guide to the theory of NP-Completeness. [S.l.]: Bell Telephone Laboratories Inc., 1979. ISBN 0-7167-1044-7.
GROSSO, A.; LOCATELLI, M.; PULLAN, W. Simple ingredients leading to very efficient heuristics for the maximum clique problem. Journal of Heuristics. Springer US, 2007.
ISSN: 1381-1231.
JACK, S. L.; ANDERSON, A. R. Entrepreneurship education within the enterprise culture. International journal of entrepreneurial behaviour & research. Vol. 5, 1 abr. 1999.
JOHNSON, D. S. Approximation algorithms for combinatorial problems. In: STOC '73 Proceedings of the fifth annual ACM symposium on theory of computing, New York, p.
38-49, 1973.
MCCLELLAND, D. C. The achievement society. Princeton. New Jersey: D. Van NostrandCo., 1961.
MCCLELLAND, D. C. A sociedade competitiva: realização & progresso social. Rio de Janeiro: Expressão e Cultura, 1972.
ÖSTERGARD, P. R. J. A fast algorithm for the maximum clique problem. Discrete Applied Mathematics, 2002, doi:10.1016/S0166-218X(01)00290-6.
PESSOA, M. C. Ferramenta de monitoramento do comportamento empreendedor. 2010.
81 f. Trabalho de Conclusão de Curso de Graduação em Ciência da Computação – Centro de Ciências Tecnológicas da Terra e do Mar, UNIVALI, Itajaí, 2011.
RAY, D. M. Understanding the entrepreneur: entrepreneurial attributes, experience and skills. Entrepreneurship & Regional Development, Oxfordshire, n.5, v.4, 1993.
RESE, A. L. R.; SANTIAGO, R. Ensino de teoria da complexidade. In: XXXII Congresso da Sociedade Brasileira de Computação, 2012, Curitiba. Anais..., 2012.
ROBSON, J. M. Algorithms for maximum independent sets, Journal of Algorithms, 1986, doi:10.1016/0196-6774(86)90032-5.
ROSA, S. B.; LAPOLLI, E. M. Santa Catarina: um estado que é uma vitrine de talentos. In:
LAPOLLI, E. M.; FRANZONI, A. M. B.; SOUZA, V. A. B. (Orgs). Vitrine de talentos:
notáveis empreendedores em Santa Catarina. Florianópolis: Pandion, 2010.
ROSA, S. B.; MORALES, S. A. Perfil empreendedor: uma representação gráfica.
Metodologia de medida quantitativa de competências empreendedoras. Revue internationale de psychosociologie, Paris, 2010.
SIPSER, M. Introdução à teoria da computação. 2.ed. São Paulo: Thomson, 2007.
TARJAN, R. E.; TROJANOWSKI, A. E. Finding a maximum independent set. SIAM Journal of Computing, 1977, doi:10.1137/0206038.
TOMITA, E.; KAMEDA, T. An efficient branch-and-bound algorithm for finding a
maximum clique with computational experiments. Journal of Global Optimization, 2007, doi:10.1007/s10898-006-9039-7.
TOMITA, E.; SEKI, T. An efficient branch-and-bound algorithm for finding a maximum clique. Discrete Mathematics and Theoretical Computer Science, 2003, doi:10.1007/3- 540-45066-1_22.
TOMITA, E.; SUTANI, Y.; HIGASHI, T.; TAKAHASHI, S.; WAKATSUKI, M. A simple and faster branch-and-bound algorithm for finding a maximum clique. WALCOM:
Algorithms and Computation, 2010, doi: 10.1007/978-3-642-11440-3_18.
TOSCANI, L. V.; VELOSO, P. A. S. Complexidade de algoritmos. 2.ed. Porto Alegre:
Bookman, 2008.
XU, X.; MA, J.; LEI, J. An Improved Ant Colony Optimization for the Maximum Clique Problem. In: Third International Conference, 2007, Haikou. Proceedings, 2007.
ZIVIANI, N. Projeto de algoritmos: com implementações em Java e C++. São Paulo:
Thomson, 2007.
GLOSSÁRIO
|𝑋| sendo 𝑋 um conjunto, |𝑋| denota a quantidade de
elementos contidos em 𝑋.
(𝑖, 𝑗)-swap consiste em remover 𝑖 vértices e adicionar 𝑗 vértices à uma solução 𝑆 (ANDRADE; RESENDE; WERNECK, 2012).
Algoritmo Determinístico apresenta comportamento previsível, onde o resultado de cada operação é definido de maneira única.
Algoritmo Não Determinístico algoritmo capaz de escolher uma dentre várias opções possíveis a cada passo, ou seja, contêm operações em que o resultado não é unicamente definido (ZIVIANI, 2007).
BHOSLIB Benchmarks with Hidden Optimum Solutions Library (Biblioteca de benchmarks com soluções ótimas ocultas) consiste em uma biblioteca de grafos gerados de forma randômica, onde existem soluções ótimas ocultas.
Branch and Bound ou Branch & Bound, consiste em uma técnica para solução de problemas de otimização. São aplicados limites superiores e inferiores, com o objetivo de reduzir o número de soluções geradas, onde o problema é subdividido em subproblemas (Branch) e são eliminados os conjuntos que não conduzem a uma solução ótima (Bound).
Caixeiro Viajante dado um conjunto de cidades, o problema consiste em determinar o caminho de menor distância, de forma que passe por todas as cidades apenas uma vez, retornando à cidade inicial (ZIVIANI, 2007).
CODE consiste em grafos difíceis decorrentes da teoria de codificação. Cada subfamília se refere a um código de correção de erros diferentes, onde os vértices representam as palavras de código e as arestas indicando conflitos entre eles.
DIMACS Center for Discrete Mathematics and Theoretical
Computer Science (Centro de Matemática Discreta e Ciência da Computação Teórica) apresenta instâncias de grafos frequentemente utilizadas para comparação e avaliação de algoritmos para o Clique.
k-clique é uma variação do Clique, a qual consiste em encontrar clques de k, onde 10-clique representa um clique contendo 10 vértices.
k-improvement consiste em um (𝑘 − 1, 𝑘)-swap (ANDRADE;
RESENDE; WERNECK, 2012).
Máquina de Turing a máquina de Turing é um dispositivo teórico, o qual representa um modelo abstrato de um computador, restringindo-se aos aspectos lógicos de funcionamento (memória, estados e transições). Numa máquina de Turing pode-se modelar qualquer computador digital (SIPSER, 2007).
MESH motivada por uma aplicação em Computação Gráfica, onde para processar uma triangulação eficiente em
hardware de gráficos, o algoritmo deve encontrar um pequeno subconjunto de triângulos, que abrange todas as arestas da malha (mesh). Desta forma, esta família contém representações em grafo buscando solucionar o problema.
ROAD consiste em grafos planares, os quais representam a rede rodoviária dos Estados Unidos. Os cruzamentos são representados por vértices e as estradas que os ligam são representadas pelas arestas.
SAT instâncias de transformadas originalmente da competição
SAT 04.
Subgrafo Completo é um conjunto de vértices 𝑉 de um Grafo 𝐺 = (𝑉, 𝐸), onde todo vértice 𝑣 ∈ 𝑉 é adjacente a todos os outros, ou seja, ∀ (𝑢, 𝑣) ∈ 𝑉, 𝑢 ≠ 𝑣, ∃ (𝑢, 𝑣) ∈ 𝐸.
Tightness para um vértice 𝑣 não pertencente a solução 𝑆, tightness é número de vértices vizinhos de 𝑣 que pertencem a 𝑆. Desta forma um vértice 0-tight não possui vizinhos pertencentes à solução 𝑆, sendo assim um vértice livre (ANDRADE;
RESENDE; WERNECK, 2012).
APÊNDICE A. CÓDIGO FONTE
Arquivo glp.cpp
#include <iostream>
#include <fstream>
#include <sstream>
#include <time.h>
#include <chrono>
using namespace std;
unsigned int INFINITO = numeric_limits<unsigned int>::max();
#include "vetor.h"
//Estruturas utilizadas durante a execução
Vetor solucao, solucao_temporaria, melhor_solucao, vertices_removidos, candidatos_0, candidatos_1, vizinhanca, add_moves, swap_moves,
lastchance_moves, excecoes, temporario, temporario_dois, auxiliar;
//Função para gerar valores aleatórios
unsigned int gerar_valor_aleatorio(unsigned int limit) // 1 {
limit = (limit == 0) ? 1 : limit;
unsigned long r30 = RAND_MAX * rand() + rand();
unsigned long s30 = RAND_MAX * rand() + rand();
unsigned long t4 = rand() & 0xf;
unsigned int v1 = ((r30 << 34) + (s30 << 4) + t4) % limit;
return v1;
}
//inicialização das estruturas do algoritmo
void inicializar_vetores(unsigned int numero_elementos) //n {
inicializa_vetor(solucao, numero_elementos);
inicializa_vetor(melhor_solucao, numero_elementos);
inicializa_vetor(solucao_temporaria, numero_elementos);
inicializa_vetor(vertices_removidos, numero_elementos);
inicializa_vetor(candidatos_0, numero_elementos);
inicializa_vetor(candidatos_1, numero_elementos);
inicializa_vetor(vizinhanca, numero_elementos);
inicializa_vetor(add_moves, numero_elementos);
inicializa_vetor(swap_moves, numero_elementos);
inicializa_vetor(lastchance_moves, numero_elementos);
inicializa_vetor(excecoes, numero_elementos);
inicializa_vetor(temporario, numero_elementos);
inicializa_vetor(temporario_dois, numero_elementos);
}
void limpar_vetores() {
limpar_vetor(solucao);
limpar_vetor(melhor_solucao);
limpar_vetor(solucao_temporaria);
limpar_vetor(vertices_removidos);
limpar_vetor(candidatos_0);
limpar_vetor(candidatos_1);
limpar_vetor(vizinhanca);
limpar_vetor(add_moves);
limpar_vetor(swap_moves);
limpar_vetor(lastchance_moves);
limpar_vetor(excecoes);
limpar_vetor(temporario);
limpar_vetor(temporario_dois);
}
#include "grafo.h"
#include "glp.h"
int main(int argc, char *argv[]) {
srand(time(NULL));
Grafo grafo;
bool *vertices;
bool utilizado;
Vetor resultado;
ofstream arquivo;
long tempo_execucao;
chrono::system_clock::time_point inicio;
string nome_grafo = argv[argc - 1];
unsigned int va, numero_selecoes, numero_execucoes = 100, maximo_selecoes = 10000;
string cores[] = { "aliceblue", "antiquewhite", "aqua",
"aquamarine", "azure", "beige", "bisque", "black", "blanchedalmond",
"blue", "blueviolet", "brown", "burlywood", "cadetblue", "chartreuse",
"chocolate", "coral", "cornflowerblue", "cornsilk", "crimson", "cyan",
"darkblue", "darkcyan", "darkgoldenrod", "darkgray", "darkgreen",
"darkgrey", "darkkhaki", "darkmagenta", "darkolivegreen", "darkorange",
"darkorchid", "darkred", "darksalmon", "darkseagreen", "darkslateblue",
"darkslategray", "darkslategrey", "darkturquoise", "darkviolet",
"deeppink", "deepskyblue", "dimgray", "dimgrey", "dodgerblue", "firebrick",
"floralwhite", "forestgreen", "fuchsia", "gainsboro", "ghostwhite", "gold",
"goldenrod", "gray", "grey", "green", "greenyellow", "honeydew", "hotpink",
"indianred", "indigo", "ivory", "khaki", "lavender", "lavenderblush",
"lawngreen", "lemonchiffon", "lightblue", "lightcoral", "lightcyan",
"lightgoldenrodyellow", "lightgray", "lightgreen", "lightgrey",
"lightpink", "lightsalmon", "lightseagreen", "lightskyblue",
"lightslategray", "lightslategrey", "lightsteelblue", "lightyellow",
"lime", "limegreen", "linen", "magenta", "maroon", "mediumaquamarine",
"mediumblue", "mediumorchid", "mediumpurple", "mediumseagreen",
"mediumslateblue", "mediumspringgreen", "mediumturquoise",
"mediumvioletred", "midnightblue", "mintcream", "mistyrose", "moccasin",
"navajowhite", "navy", "oldlace", "olive", "olivedrab", "orange",
"orangered", "orchid", "palegoldenrod", "palegreen", "paleturquoise",
"palevioletred", "papayawhip", "peachpuff", "peru", "pink", "plum",
"powderblue", "purple", "red", "rosybrown", "royalblue", "saddlebrown",
"salmon", "sandybrown", "seagreen", "seashell", "sienna", "silver",
"skyblue", "slateblue", "slategray", "slategrey", "snow", "springgreen",
"steelblue", "tan", "teal", "thistle", "tomato", "turquoise", "violet",
"wheat", "white", "whitesmoke", "yellow", "yellowgreen" };
//printf("Iniciando grafo\n");
//inicialização do objeto grafo com as informações do arquivo inicializa_dimacs(grafo, nome_grafo);
vertices = new bool[grafo.numero_vertices];
for (unsigned int i = 0; i < grafo.numero_vertices; i++) {
vertices[i] = false;
}
//inicialização das estruturas utilizadas inicializar_vetores(grafo.numero_vertices);
arquivo.open("resultados/" + grafo.nome_grafo + ".dot", ios::out);
arquivo << "digraph G {\n";
//laço para executar o algoritmo n vezes, garantindo um resultado para cada elemento
for (unsigned int i = 0; i < numero_execucoes; i++) {
//reseta valores das estruturas utilizadas limpar_vetores();
//reseta contagem de seleções necessárias numero_selecoes = 0;
//elemento a ser analisado va = i;
printf("g ");
inicio = chrono::system_clock::now();
//chamada do algoritmo principal, responsável por calcular o clique
resultado = processar_glp(grafo, numero_selecoes, maximo_selecoes, va);
//cálculo do tempo de execução tempo_execucao =
chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now() - inicio).count();
for (int j = 0; j < resultado.numero_elementos; j++) {
for (int k = j + 1; k < resultado.numero_elementos;
k++)
{
arquivo << resultado.elementos[j] << " -> "
<< resultado.elementos[k] << "[dir=none color=\"" << cores[i % 147] <<
"\"];\n";
}
if (j == resultado.numero_elementos - 1) {
printf("%u\n", resultado.elementos[j]);
} else {
printf("%u,", resultado.elementos[j]);
}
} }
arquivo << "}";
arquivo.close();
return 0;
}
Arquivo vetor.h
#ifndef VETOR_H_INCLUDED
#define VETOR_H_INCLUDED
//Definição da estrutura principal Vetor
struct Vetor { unsigned int *posicoes; unsigned int *elementos; unsigned int numero_elementos; unsigned int linf; unsigned int lsup;};
//função de inicialização das informações da estrutura
void inicializa_vetor(Vetor &vetor, unsigned int numero_elementos) {
vetor.linf = -1;
vetor.lsup = -1;
vetor.numero_elementos = 0;
vetor.posicoes = new unsigned int[numero_elementos];
vetor.elementos = new unsigned int[numero_elementos];
for(unsigned int i = 0; i < numero_elementos; i++) {
vetor.posicoes[i] = INFINITO;
} }
//adição de elementos na estrutura
void adicionar_elemento(Vetor &vetor, unsigned int elemento) // 1 {
if(vetor.posicoes[elemento] == INFINITO) {
vetor.posicoes[elemento] = vetor.numero_elementos;
vetor.elementos[vetor.numero_elementos] = elemento;
vetor.numero_elementos++;
} }
//remoção de elementos da estrutura
void remover_elemento(Vetor &vetor, unsigned int elemento) // 1 {
if(vetor.posicoes[elemento] != INFINITO) {
vetor.elementos[vetor.posicoes[elemento]] = vetor.elementos[vetor.numero_elementos - 1];
vetor.posicoes[vetor.elementos[vetor.numero_elementos - 1]]
= vetor.posicoes[elemento];
vetor.posicoes[elemento] = INFINITO;
vetor.numero_elementos--;
} }
//função para resetar os valores da estrutura void limpar_vetor(Vetor &vetor) // n
{
for(unsigned int i = 0; i < vetor.numero_elementos; i++) {
vetor.posicoes[vetor.elementos[i]] = INFINITO;
}
vetor.numero_elementos = 0;
}
//Função para copiar informações de uma estrutura para outra void vetor_copia(Vetor &vetorUm, Vetor &vetorDois) // 2n {
limpar_vetor(vetorDois);
for(unsigned int i = 0; i < vetorUm.numero_elementos; i++) {
adicionar_elemento(vetorDois, vetorUm.elementos[i]);
} }
#endif //VETOR_H_INCLUDED
Arquivo grafo.h
#ifndef GRAFO_H_INCLUDED
#define GRAFO_H_INCLUDED using namespace std;
//Definição de estrutura básica de vértice struct Vertice { unsigned int arestaInicial; };
//Definição da estrutura principal do grafo
struct Grafo { Vetor *vizinhos; Vertice *vertices; unsigned int *arestas;
string nome_grafo; unsigned int clique_size; unsigned int numero_arestas;
unsigned int numero_vertices; };
//função para impressão das estruturas vetoriais void imprime_vetor(Vetor vetor)
{
for(unsigned int i = 0; i < vetor.numero_elementos; i++) {
printf("%u\t", vetor.elementos[i]);
}
printf("\n");
}
//inicialização do grafo
void inicializa_grafo(Grafo &grafo, unsigned int numero_vertices, unsigned int numero_arestas, unsigned int clique_size, string nome_grafo)
{
grafo.nome_grafo = nome_grafo;
grafo.clique_size = clique_size;
grafo.numero_arestas = numero_arestas;
grafo.numero_vertices = numero_vertices;
grafo.vizinhos = new Vetor[numero_vertices];
grafo.vertices = new Vertice[numero_vertices + 1];
grafo.arestas = new unsigned int [2 * numero_arestas];
for (unsigned int i = 0; i < numero_vertices; i++) {
grafo.vertices[i].arestaInicial = 0;
} }
//função pra criação dos grafos a partir dos arquivos com padrão DIMACS void inicializa_dimacs(Grafo &grafo, string arquivo)
{
ifstream entrada;
string nome_grafo = "", linha = "", lixo = "";
unsigned int numero_vertices, numero_arestas, clique_size = NULL;
entrada.open(arquivo);
//identificação do nome do arquivo while (linha.find("c FILE:") == -1) {
getline(entrada, linha);
}
stringstream stream_nome_grafo(linha);
stream_nome_grafo >> lixo >> lixo >> nome_grafo;
nome_grafo = nome_grafo.substr(0, nome_grafo.length() - 4);
//identificação do clique conhecido while(linha.find("Clique Size:") == -1) {
getline(entrada, linha);
}
stringstream stream_clique_size(linha);
stream_clique_size >> lixo >> lixo >> lixo >> lixo >> lixo >>
clique_size;
grafo.clique_size = clique_size;
//identificação de informações de número de vértices e arestas while (linha.find("p edge") == -1)
{
getline(entrada, linha);
}
stringstream stream_grafo(linha);
stream_grafo >> lixo >> lixo >> numero_vertices >> numero_arestas;
//chamada de inicialização do grafo
inicializa_grafo(grafo, numero_vertices, numero_arestas, clique_size, nome_grafo);
unsigned **vs = new unsigned * [numero_arestas];
unsigned int i = 0;
unsigned int j = 0;
//preenchimento das arestas do agrafo while (i < numero_arestas)
{
linha = "";
unsigned int verticeUm, verticeDois;
getline(entrada, linha);
if (linha.find("e ") != -1) {
stringstream stringStream(linha);
stringStream >> lixo >> verticeUm >> verticeDois;
vs[j] = new unsigned int[2];
vs[j][0] = verticeUm - 1;
vs[j][1] = verticeDois - 1;
grafo.vertices[verticeUm - 1].arestaInicial++;
grafo.vertices[verticeDois - 1].arestaInicial++;
j++;
i++;
} }
unsigned int lastQtd = grafo.vertices[0].arestaInicial;
grafo.vertices[0].arestaInicial = 0;
for (unsigned int i = 1; i < numero_vertices; i++) {
unsigned int temp = lastQtd;
lastQtd = grafo.vertices[i].arestaInicial;
grafo.vertices[i].arestaInicial = temp + grafo.vertices[i - 1].arestaInicial;
}
grafo.vertices[numero_vertices].arestaInicial = 2 * numero_arestas;
unsigned int * conts = new unsigned int[numero_vertices];
for (unsigned int i = 0; i < numero_vertices; i++) {
conts[i] = 0;
}
for (unsigned int i = 0; i < j; i++) {
unsigned int verticeUm = vs[i][0];
unsigned int verticeDois = vs[i][1];
grafo.arestas[grafo.vertices[verticeUm].arestaInicial + conts[verticeUm]] = verticeDois;