Você está na página 1de 4

Implementao dos problemas Satifasbilidade, Clique e

Conjunto Independentes.
[Clique usando Branch and Bound e os demais usando Redues Polinomiais.]
Jnior Rhis

Lucas Soares

Luis Henrique

Universidade Federal de Ouro


Preto

Universidade Federal de Ouro


Preto

Universidade Federal de Ouro


Preto

juniorrhis1@gmail.com

lucassoares3@gmail.com luis ccm14@hotmail.com

ABSTRACT

2.

Esse artigo apresenta o estudo e a demonstraca


o de implementaco
es de tres algoritmos de otimizaca
o: Clique, Conjunto Independente reduzido a
` Clique e SAT reduzido a
`
clique. Os resultados s
ao mostrados em pseudoc
odigos e
tambem em uma tabela de tempo de execuca
o.

Branch and Bound e um algoritmo usado para encontrar


soluco
es o
timas para v
arios problemas de otimizac
ao, especialmente em otimizaca
o combinat
oria. Consiste em uma
enumeraca
o sistem
atica de todos os candidatos a soluca
o,
atraves do qual subconjuntos n
ao promissores e consistentes
s
ao descartados, com base nos limites superior e inferior da
quantia otimizada, dependendo da finalidade do problema
(minimizaca
o ou maximaca
o).

N
ao h
a nenhuma comparaca
o entre os metodos e, portanto,
n
ao e necess
aria a apresentaca
o de comparaco
es.

Keywords
Clique, SAT, Conjunto Independente, Reduca
o Polinomial

1.

INTRODUO

Uma Classe de Complexidade e um conjunto de problemas


relacionados aos recursos computacionais baseados em complexidade. As classes de complexidade s
ao definidas em:
classe P - consiste nos problemas que podem ser resolvidos
em tempo polinomial (Problemas trat
aveis).
classe NP - consiste nos problemas que podem ser verificados em tempo polinomial (Problemas Intrat
aveis).
NP-completo s
ao problemas NP que possuem a caracterstica de que se um deles puder ser resolvido em tempo polinomial ent
ao todo problema NP-Completo ter
a uma soluca
o
em tempo polinomial.
Este trabalho consiste na implementac
ao de tres programas.
S
ao eles Satifasbilidade, Clique e Conjunto Independentes.
O Clique e resolvido usando Branch and Bound, o conjunto
idependente e o problema da satisfabilidade s
ao resolvidos
por meio de reduco
es polinomiais ao clique. O artigo e dividido nas seguintes sec
oes: Na segunda seca
o e descrito a
tecnica de programaca
o Branch and Bound. A terceira seca
o
apresenta a tecnica de reduca
o polinomial. Na quarta seca
o
e feita uma descrica
o dos tres metodos assim como um passo
a passo da implementaca
o. A Quinta seca
o ilustra os resultados obtidos com as inst
ancias testadas. A u
ltima seca
o
apresenta as conclus
oes relacionadas as implementaco
es.

BRANCH AND BOUND

Uma soluc
ao consistente e aquela que n
ao viola as restric
oes
do problema podendo ser aceit
avel na soluca
o final. Um
elemento dos possveis subconjuntos da soluca
o e promissor
caso possua um peso que possa levar a
` uma soluca
o melhor
que a atual.
O pseudoc
odigo generico do algoritmo Branch and Bound e
apresentado na subseca
o 2.0.2.

2.0.1

Descrio do algoritmo

A primeira etapa do algoritmo consiste em se encontrar uma


soluca
o inicial, geralmente construda por algoritmos gulosos. Esta soluca
o ser
a usada como base nas comparac
oes
futuras do algoritmo.
A seguir atribui-se valores as vari
aveis verificando se a soluc
ao
obtida ate o momento e promissora e consistente, em caso
positivo e atribudo um valor para pr
oxima vari
avel do problema. Em caso negativo, o subconjunto e descartado e e
atribudo um novo valor para a vari
avel.
A segunda etapa e repetida ate que seja encontrada uma
soluca
o o
tima, ou ate que todas as possveis soluc
oes sejam
analisadas.

2.0.2

Pseudocdigo

Algorithm 1 Algoritmo Branch and Bound


1: function branchAndBoundRecursivo(s, i, p)
2:
if ehCompleta(p, s, i) then
3:
melhor s
4:
else
5:
j primeiroValor(p, i)
6:
while j ultimoV alor(p, i) do
7:
s[i] j
8:
if eConsistente(p, s)&&eP romissora(p, s)
then
9:
branchAndBound(s, i+1, p)
10:
end if
11:
12:
s[i] = livre
13:
j++
14:
end while
15:
end if
16:
if i = tamanho(p) then return melhor
17:
end if
18: end function
19:
20: function branchAndBound(p)
21:
s geraSolucaoInicial(p)
22: return branchAndBoundRecursivo(s, 0, p)
23: end function

3.

REDUO POLINOMIAL

Reduca
o Polinomial consiste em uma tecnica de transformaca
o da inst
ancia de um problema A em uma inst
ancia
do problema B. Com isso e encontrada uma soluca
o para
A. A reduca
o deve ser feita em tempo polinomial, para n
ao
inviabilizar a soluca
o do problema.
A figura 1 exemplifica como e realizada a transformaca
o da
inst
ancia de um problema A para a inst
ancia problema B.

Figure 1: Exemplo redu


c
ao polinomial

4.

DESCRIO DOS MTODOS

4.1

Clique Mxima

Dado um grafo G=(V, A), uma clique e um subconjunto do


grafo que induz um subgrafo completo, ou seja, um subconjunto de vertices no qual todos s
ao adjacentes entre si. Uma
clique m
axima e o subgrafo completo de maior cardinalidade
possvel em um grafo.
O Problema da Clique M
axima e um problema fundamental
com diversas aplicaco
es. V
arios algoritmos para sua soluca
o
s
ao encontrados na literatura.

4.1.1

Gera uma Soluc


ao Inicial a partir do algoritmo guloso
que e apresentado na seca
o 4.1.2.
Cria um vetor de tamanho n, em que n representa
todos os vertices do grafo e inicializa com um valor
inv
alido.
Gera a a
rvore e analisada todas as possveis soluc
oes
que s
ao consistentes e promissoras, a partir dos metodos ehConsistente e ehPromissora
O metodo ehConsistente verifica se todos os vertices
presentes na soluca
o parcial est
ao conectados a todos
os outros.
O metodo ehPromissora verifica se todos os vertices
presentes na soluca
o parcial possuem um n
umero de
vizinhos maior ou igual ao tamanho da clique m
axima
- 1. O metodo verifica ainda se com a inserca
o de todos os vertices restantes e possvel atingir uma soluca
o
melhor que a atual.
O pseudoc
odigo desse algoritmo pode ser visualizado na
seca
o 4.1.3.

4.1.2

Pseudocdigo - Guloso

Algorithm 2 Algoritmo Clique - Guloso


1: function cliqueGuloso(G)
2:
v maiorGrau(G)
3:
solucao v
4:
5:
for all u adjacent to v do
6:
solucao = u
7:
8:
for all w adjacent to v do
9:
if u = w then
10:
continue
11:
end if
12:
13:
if u not adjacent to w then
14:
remove(solucao, u)
15:
end if
16:
end for
17:
end for
18: end function

4.1.3

Pseudocdigo - Branch And Bound

Algorithm 3 Algoritmo Clique - Branch And Bound


1: function cliqueBranchAndBound(p, G)
2:
s cliqueGuloso(G)
3:
solucao branchAndBoundRecursivo(s, 0, p) return solucao
4: end function

4.2

Conjunto Independente

Dado um grafo G=(V, A), um conjunto independente (ou


conjunto de estabilidade) e um subconjunto de vertices no
qual n
ao existam dois vertices adjacentes.

Descrio do algoritmo

O algoritmo implementado para a resoluca


o da clique m
axima usando Branch and Bound e composto nas seguintes
etapas:

A reduca
o polinomial pode ser feita em O(n2 ) utilizando
uma matriz de adjacencias. Na qual, basta inverter os valores presentes nessa matriz.

Dentre as v
arias aplicaco
es deste algoritmo, encontra-se a
resoluca
o do problema das n-rainhas.

4.2.1

Descrio do algoritmo

Dado um grafo G, calcular o grafo complemento G


desse grafo, ou seja, para todas as arestas n
ao presentes
no grafo G, adicion
a-las ao grafo complemento G. E
para todas as arestas presentes em G, n
ao adicion
a-las
em G.
Executar o metodo cliqueBranchAndBound para o grafo
complemento.
A soluca
o gerada ser
a o conjunto idependente m
aximo.

O pseudoc
odigo desse algoritmo pode ser visualizado na
seca
o 4.2.2.

4.2.2

Pseudocdigo

Algorithm 4 Algoritmo Conjunto Independente reduzido


ao Clique
1: function conjuntoIndependente(p, G)
2:
Q complemento(G)
3:
s cliqueBranchAndBound(p, Q) return s
4: end function

Algorithm 5 Algoritmo Satisfabilidade reduzido ao Clique


1: function satisfabilidade(p, F)
2:
size F.size F.size
3:
matriz sat M[size][size]
4:
for all c in F do
5:
for all v in c do
6:
for all ca in F do
7:
if ca 6= c then
8:
for all va in ca do
9:
if va = 2 && va 6= 2 && v 6= 2 kk
variavel(va) 6= variavel(v) then
10:
matriz sat[pos(v)][pos(va)]
1
11:
else
12:
matriz sat[pos(v)][pos(va)]
0
13:
end if
14:
end for
15:
end if
16:
end for
17:
end for
18:
end for
19:
resultado cliqueBranchAndBound(p, matriz sat)
return resultado
20: end function

5.

RESULTADOS

A reduca
o do problema pode se feita em tempo O(n4 ), utilizando a matriz de adjacencias, em que para cada elemento
da f
ormula e realizada uma comparac
ao com todos os demais
elementos.

A entrada dos programas para os problemas envolvendo


grafo e feita por meio de um arquivo contendo na primeira
linha a quantidade de vertices e nas pr
oximas uma matriz
indicando se h
a uma aresta (1) ou n
ao (0) entre dois vertices.
Para o problema da satisfabilidade a entrada e semelhante
a do grafo, mas, neste caso, a primeira linha deve informar
a quantidade de vari
aveis e cada uma das demais deve ser
referente a uma cl
ausula, onde o primeiro valor da linha e
referente a primeira vari
avel, o segundo a segunda vari
avel
e assim por diante.

Existem diversas variac


oes para este problema, na forma kSAT, entre elas 2-SAT, 3-SAT, em que k representa o n
umero
m
aximo de vari
aveis presentes em cada cl
ausula.

Utilizamos uma inst


ancia para a execuca
o de testes em cima
do metodo Clique Branch and Bound e do metodo Conjunto
Independente reduzido ao clique.

4.3

Satisfabilidade

O problema da satisfabilidade consiste em, dada uma f


ormula booleana na forma normal conjuntiva, encontre uma
atribuica
o satisfat
oria ou ent
ao declare que nenhuma existe.

4.3.1

Descrio do algoritmo

Dado uma f
ormula booleana B, e construdo um grafo
G, em que os vertices de G s
ao todas as ocorrencias
de literais em B. Existe uma aresta entre dois vertices
de G somente se duas ocorrencias est
ao em cl
ausulas
diferentes e os dois literais n
ao s
ao complementares.
Executar o metodo cliqueBranchAndBound para o grafo
obtido.
A soluca
o reprensenta quais valores as vari
aveis em B
podem assumir, ou se B

O pseudoc
odigo desse algoritmo pode ser visualizado na
seca
o 4.3.2.

4.3.2

Pseudocdigo

Como o problema de Satisfabilidade gera uma matriz quadrada


de maior tamanho (n
umero de elementos da matriz na segunda fase do algoritmo), a inst
ancia utilizada para testar
esse algoritmo foi menor e diferente dos demais.
Cada teste foi executado 10 vezes e na tabela a seguir mostrar
a
a media do tempo de execuca
o para cada algoritmo. As inst
ancias utilizadas ser
ao disponibilizadas no apendice.

Table 1: M
edia dos tempos de execu
c
ao
Nome da Inst
ancia Clique Conjunto Independente
Inst
ancia 1
5
7
Inst
ancia 2
30
345
Inst
ancia 3
8
7
Inst
ancia 4
Inst
ancia 5
Inst
ancia 6
-

SAT
1880
1946
3

N
ao ser
a feita nenhuma an
alise em relac
ao ao tempo de execuca
o dos testes ao fato de que e impossvel comparar esses
metodos. Esses resultados s
ao apenas para demonstraca
o.

6.

CONCLUSES

Problemas NP-Completos est


ao presentes em diversas a
reas
atualmente. Resolver estes problemas e de suma import
ancia para a sociedade moderna. Conclumos que o Branch and
Bound apresenta sempre a soluca
o o
tima para as inst
ancias
testadas com um tempo consider
avel. A inviabilidade deste
tipo de algoritmo ocorre para inst
ancias grandes, devido a
sua alta complexidade.

APPENDIX
A. INSTNCIA 1
9
0
0
1
0
0
0
0
0
0

0
0
1
0
0
0
0
0
0

1
1
0
1
1
0
0
0
0

B.
24
00
00
11
00
00
00
00
10
00
00
00
00
00
01
00
00
00
00
00
00
00
01
00
00

0
0
1
0
0
1
0
1
0

0
0
0
0
1
0
0
0
0

0
0
0
1
0
0
0
1
1

0
0
0
0
1
0
1
0
1

0
0
0
0
0
0
1
1
0

1
1
0
0
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

0
0
1
0
0
0
0
0
0
1
0
1
0
0
0
0
0
0
0
1
0
0
0
1

0
0
1
1
0
0
1
0
1
0
0
1
0
0
0
0
1
0
0
1
0
0
0
1

0
0
0
0
1
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
1
0
0

0
0
0
1
0
0
1
0
1
0
0
0
0
1
1
0
0
0
0
0
0
1
1
0

0
0
0
0
1
0
1
1
0
1
0
0
1
0
0
1
0
0
0
0
1
0
0
0

0
0
0
1
0
0
1
0
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0

0
0
0
0
1
1
0
0
1
0
1
1
0
0
0
0
0
1
1
1
0
0
0
1

0
0
0
0
0
0
1
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

1
0
0
0
0
0
1
0
0
0
0
1
0
1
0
1
0
0
0
1
0
1
0
1

0
1
0
0
0
0
0
0
1
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0

0
0
1
0
0
0
0
0
1
1
0
1
0
1
0
0
0
1
0
1
0
1
0
1

INSTNCIA 3
1
1
0
0
1

0
0
1
0
0

0
0
1
1
0

0
0
0
0
1

0
0
0
1
0

0
0
0
0
1

0
0
0
1
0

0
0
0
0
0
0
0

1
1
0
0
0
0
0

D.
4
0
1
1
1
0
1
1
1
1

1
2
1
0
0
2
2
1
0

0
0
0
0
1

0
0
0
0
0

1
0
0
0
0

0
1
0
0
0

0
0
1
0
0

0
0
0
0
0
0
0
0
0
0
0
1
1
0
0
0
0
1
0
1
1
0
0
1

0
0
0
1
0
0
0
0
0
1
0
1
0
1
0
0
1
0
0
1
0
1
0
1

0
1
0
1
0
0
1
0
0
0
1
0
0
1
0
0
0
0
1
0
0
1
0
0

0
1
0
0
0
0
0
0
0
1
0
1
0
1
1
1
0
0
0
1
0
1
1
1

0
0
0
0
1
0
0
0
0
0
0
1
0
0
0
0
0
0
0
1
0
0
0
1

0
0
0
0
0
1
0
0
0
0
0
0
0
1
0
1
0
1
0
0
0
1
0
0

0
0
0
1
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
1
0
0

0
0
1
0
0
0
0
1
0
0
0
0
0
0
0
1
0
1
0
0
0
0
0
0

1
1
0
0
0
0
0
0
1
0
0
0
0
0
0
1
1
0
0
0
0
0
0
0

0
0
0
0
0
1
0
0
0
0
0
1
0
0
0
1
0
1
0
1
0
0
0
1

0
1
0
1
0
1
0
0
0
0
0
0
0
0
1
0
0
1
0
0
0
0
1
0

0
0
1
0
0
0
0
1
0
1
0
0
0
0
0
1
0
1
0
0
0
0
0
0

0
1
1
0
0
0
0
1
0
0
1
0
0
0
0
1
0
0
1
0
0
0
0
0

3
0
1
1
1
0
1
1
1
1
1
2
1

1
2
1
0
0
2
2
1
0
1
2
1

F.
2
0
1
0
2
1
0

1
0
1
1
1
2

0
0
0
0
1
0
1

0
1
0
1
0
0
1

0
0
0
0
0
0
0

0
1
0
1
0
0
0

0
1
1
0
1
0
0

0
1
0
1
1
0
0

1
0
0
1
0
1
1

0
1
0
1
0
0
0

0
1
0
0
0
0
1

0
0
0
1
0
0
0

INSTNCIA 4
2
0
0
2
1
2
0
1
0

E.

INSTNCIA 2

C.
12
00
00
11
00
00

0
0
1
0
0
0
1
0
0

0
0
1
0
0
0
0

0
0
2
1
1
0
1
1
1

INSTNCIA 5
2
0
0
2
1
2
0
1
0
2
1
1

INSTNCIA 6

0
0
0
1
1
0
1