Projeto e Análise de Algoritmos

TP1: Comunidades em Grafos

Valor: 7 pontos + 1 extra

Uma tarefa frequente na análise de redes sociais é a busca por comunidades. Uma
comunidade pode ser vista como um subconjunto de vértices da rede que, quando
comparado com vértices não pertencentes ao subconjunto, apresentam ligações mais
densas. Uma representação de comunidades é mostrada na Figura abaixo. Na Figura as
comunidades são demonstradas por vértices de cores e formato diferentes. Note como
existe uma maior quantidade de arestas entre vértices de uma mesma comunidade.

Inspirado no trabalho de Girvan-Newman1, neste TP você irá implementar dois

algoritmos para detecção de comunidades. Os algoritmos serão baseados no conceito de
centralidade. A centralidade (betweenness em inglês) de uma aresta2 é simplesmente a
quantidade de caminhos mínimos que passa por aquela aresta. Os dois algoritmos
devem apresentar a mesma resposta final, alterando apenas a forma como é computado
o caminho mínimo entre os vértices. De forma sucinta, o algoritmo é o seguinte:

1) Calculate the betweenness of all existing edges in the network.

2) Remove the edge with the highest betweenness.
3) Recalculate the betweenness of all edges affected by the edge removed.
4) Repeat steps 2 and 3 until the desired number of communities is obtained.

1
http://en.wikipedia.org/wiki/Girvan%E2%80%93Newman_algorithm
2
É comum computar o betweenness do vértice. Neste caso, estamos falando de betweeness da aresta!
Na Figura abaixo mostramos um grafo e a centralidade de cada aresta. Observe que, nas
arestas onde c = 2, existem caminhos dos vértices origem, A ou B, até C e um outro até
D. Note que, contabilizamos os caminhos da forma A->B e B->A como sendo apenas 1,
dado que o grafo não é direcionado. Em grafos direcionados, os valores de centralidades
se alteram. Se o objetivo fosse encontrar duas comunidades, iríamos simplesmente
remover a aresta vermelha, pois ela possui maior centralidade.

No TP, queremos que você resolva o problema da busca de comunidades usando o

algoritmo descrito acima. Você irá implementar quatro versões do algoritmo: na
primeira, os caminhos mínimos serão computados usando o algoritmo de BFS N vezes,
onde N é o número de vértices no grafo. Na segunda o algoritmo “Repeated Squaring”
deve ser utilizado. Na terceira, o algoritmo de Floyd-Warshall e na quarta o algoritmo
de Johnson. Assuma que os grafos de entrada são não direcionados com arestas de peso
= 1. Existem estruturas de dados diferentes que afetam o desempenho do algoritmo de
Johnson (e.g. array linear e heaps binários ou de Fibonacci). Você deve implementar
pelo menos duas estruturas e comparar o desempenho dos algoritmos. Note que, no
passo 3 do algoritmo, nem todas as arestas devem ser atualizadas.

Pontos extras
Será dado 1 ponto extra para os trabalhos que apresentarem a comparação dos
algoritmos acima com implementações mais eficientes do Betweenness, como por
exemplo, a descrita a seguir. Implementações que consideram paralelismo também
podem ser consideradas, se devidamente testadas.
http://www.inf.uni-konstanz.de/algo/publications/b-fabc-01.pdf

Entrada
O arquivo de entrada é composto de n linhas, onde cada linha representa uma aresta. O
mesmo tem o seguinte formato:
node_id_1 node_id_2
...
O programa deve também receber como entrada o número de comunidades k que serão
gerados. Siga o formato abaixo:
comando <arquivo_arestas> <k>

Você deve testar o TP em pelo menos três grafos disponíveis em no link abaixo:

http://www-personal.umich.edu/~mejn/netdata/

Você pode gerar grafos aleatórios densos e esparsos para complementar seus testes,
porém sua estratégia de geração de grafos deve ser devidamente descrita. Apesar dos
grafos de teste não possuírem arestas negativas, você deve apresentar exemplos
simplificados (toy examples) que consideram arestas negativas e até mesmo ciclos
negativos, para o teste do algoritmo de Johnson.

Saída
Para cada n_o imprima qual comunidade o mesmo faz parte. Apenas isso. Exemplo:
node_id_1 1
node_id_2 1
node_id_3 1
node_id_3 2
...
Siga o formato do exemplo acima, ordenando os vértices pelo identificador

Entrega
O aluno deve entregar um README.pdf e o código. Entregue também um Makefile
que compila o código. O README deve conter as seguintes informações:
- Como você implementou os algoritmos apresentados? Quais as estruturas de dados
utilizadas.
- Qual o custo assimptótico (em Big-O) do tempo de execução e espaço
em memória utilizado de cada algoritmo e implementação?
- Em quais casos é esperado que o algoritmo de Johnson seja mais adequado
do que o Floyd-Warshall e vice-versa?
_ Em qual máquina o tp foi testado?
_ Como sua implementação se comporta em termos de tempo de execução e
memória alocada? Apresente uma variação experimental da solução, com
entradas de tamanho diferente tentando discutir também o melhor e o pior caso.

Apenas Java, C e C++ serão aceitos (arquivos .java, .c, .cpp e .h).
Neste TP não existe restrição de nomes e quantidade de arquivos.