UNIVERSIDADE FEDERAL DA BAHIA

Escola Politécnica da Ufba - EPUFBA

COLORAÇÃO DE GRAFOS

Engenharia e Planejamento de Redes e Sistemas

Prof.: Karcius Assis

Aluno: Igor Moura Queiroz

Salvador, 29 de setembro de 2010

Índice

Introdução.............................................................................................................................3
Metodologia...........................................................................................................................3

Simulação..............................................................................................................................4

Conclusão..............................................................................................................................7

Anexos....................................................................................................................................8
Introdução
O seguinte projeto tem como objetivo desenvolver um algoritmo para coloração de grafos. O
programa foi desenvolvido em ambiente linux utilizando o software Scilab. Scilab é um freeware
com linguagem bastante semelhante ao Matlab cuja interface é simples e amigável. O algoritmo é
de autoria própria e é baseado em busca por profundidade.

Metodologia
De uma maneira simplificada, o programa é particionado em três etapas: entrada de dados,
processamento de dados e saída de dados. Logo abaixo será descrita cada uma dessas etapas. O
algoritmo completo está descrito no item “Anexos”.

1) Entrada de dados

Através da função fscanfMat('madj') o programa lê a matriz de adjacência que está escrita no

arquivo madj e escreve na matriz M. Demonstração:

M = fscanfMat('madj');

Com a função input é requisitado ao usuário a inserção da ordem da matriz de adjacência.

Isso será preciso para, posteriormente, aplicar laços for na etapa de processamento. A ordem da
matriz é armazenada na variável n. Demonstração:

n = input('Insira a ordem da matriz:')

2) Processamento de dados

Esta etapa se caracteriza como ponto-chave do algoritmo, pois é nela que a criatividade do
programador se exterioriza. Utilizou-se o método de busca por profundidade, bastante popular entre
profissionais e hobbistas da área. Através de laços for foram feitas varreduras na matriz de
adjacências, de forma a colorir cada vértice do grafo em questão condicionando-os - através das
funções if e elseif – a não terem a mesma cor de qualquer vértice adjacente. Depois da primeira
varredura o programa faz um reprocessamento para prevenir possíveis erros do processo inicial e
então calcula o número cromático. Para melhor entendimento, vide Anexo.

3) Saída de dados

Depois de calculado e o número cromático o programa gera um arquivo de saída entitulado

output que contém as cores associadas a cada vértice do grafo em forma de matriz de ordem n:1.
Isso é feito através da função fprintfMat(file,a), onde file significa o arquivo que se quer escrever e
a é a matriz que representa as cores dos vértices. Através da função Matplot(C), é plotado um
gráfico xy com as cores do número cromático calculado. Demonstração:

...fprintfMat(TMPDIR+'/output',cor);
editor(TMPDIR+'/output');
Matplot(C)...
Simulação
Foram feitas algumas simulações com matrizes de adjacências de ordem seis variando as
conexões dos vértices, com o objetivo de obter um resultado ótimo. Para executar o arquivo do
editor no console do Scilab utiliza-se a funcão exec('file'), onde file é o nome do arquivo de edição.
Seguem abaixo os resultados:

1ª Simulação

madj
011001
101011
110110
001010
011101
110010

Digita-se no console: exec('redes')

Resultados:

crom =

3.

output =

1.000000
2.000000
3.000000
2.000000
1.000000
3.000000

janela gráfica =

figura 1: Mínimo de cores na

1ª simulação
 2ª Simulação

madj
011111
101011
110110
101010
111101
110010

Digita-se no console: exec('redes')

Resultados:

crom =

4.

output =

1.000000
2.000000
3.000000
2.000000
4.000000
3.000000

janela gráfica =

figura 2: Mínimo de cores na 2ª simulação

 3ª Simulação

madj
011111
101011
110111
101010
111101
111010

Digita-se no console: exec('redes')

Resultados:

crom =

5.

output =

1.000000
2.000000
3.000000
2.000000
4.000000
5.000000

janela gráfica =

figura 3: Mínimo de cores na 3ª simulação

Conclusão
O projeto foi altamente produtivo, proporcionando um excelente aprendizado em
programação no ambiente linux. A partir das simulações e resultados, percebe-se que o algoritmo
cumpriu com o seu objetivo, que era o de colorir os vértices de um grafo qualquer com um mínimo
de cores possíveis. Sugere-se para trabalhos futuros desenvolver otimizações no método de
coloração utilizado, de forma a tornar o algoritmo mais eficiente e seu processamento mais ágil,
afim de obter uma resposta satisfatória em grandes sistemas. Outra aplicação futura seria em redes
neurais. O código utilizado neste projeto ainda está em fase de aperfeiçoamento.
Anexos

arquivo: redes

//Desenvolvido por Igor Moura Queiroz

M = fscanfMat('madj'); //lê a matriz de adjacência no arquivo madj

n = input('Insira a ordem da matriz:') //usuário insere a ordem

//definição do vetor
for x=1:n
cor(x)=1;
end

//processamento
for i=2:n
for j=1:i
if (M(i,j)==0)
cor(i)=cor(j);
elseif (M(i,j)==1) & (cor(i)==cor(j));
cor(i)=cor(j)+1;
for k=1:i;
if (M(i,k)==1) & (cor(i)==cor(k));
cor(i)=cor(k)+1;
end
end
end
end
end

//reprocessamento-correção de erros
for i=2:n
for j=1:i
if (M(i,j)==1) & (cor(i)==cor(j));
cor(i)=cor(j)+1;
end
end
end

//número cromático
crom=1;
for x=1:n
if cor(x)>crom
crom=cor(x);
end
end

//plotagem de cores
for x=1:crom
C(x)=x;
end
//arquivo de saída
fprintfMat(TMPDIR+'/output',cor);
editor(TMPDIR+'/output');
crom

//gráfico de cores
Matplot(C)

arquivo: madj – 1ª simulação

011001
101011
110111
001010
011101
111010

arquivo: madj – 2ª simulação

011111
101011
110110
101010
111101
110010

arquivo: madj – 3ª simulação

011111
101011
110111
101010
111101
111010