ler_dot() finalizada. Iniciando o Dijkstra

Author: danielbergholz

g2.dot

@@ -0,0 +1,6 @@
+graph g {
+    v0 -- v1 [label=0.3];
+    v1 -- v2 [label=1.5];
+    v2 -- v3 [label=3.8];
+    v3 -- v4 [label=1.7];
+}

g3.dot

@@ -0,0 +1,6 @@
+graph g {
+    a -- v1 [label=0.3];
+    v1 -- a [label=1.5];
+    v2 -- v3 [label=3.8];
+    v3 -- v4 [label=1.7];
+}

trabalho3.py

@@ -9,8 +9,12 @@
 # variavel global para ir armazenando decisoes do usuario 
 n = 0
 
-# criar grafo
+# variaveis globais do grafo
+
 g = Graph() 
+vertices = []
+arestas = []
+pesos = []
 
 '''
 g.add_vertices(4)
@@ -28,34 +32,49 @@
 plot(g, layout = layout)
 '''
 
+# ----------------------------------------------------------------------MENU-----------------------------------------------
 def menu(primeira_vez=True):
+    global n  
     if (primeira_vez == True):
         os.system('clear')
         print 'Seja bem vindo ao meu programa que simula grafos\n'
     print 'A seguir os algoritmos disponiveis:\n'
     print '1) Dijkstra\n2) Bellman-Ford\n3) RPF\n4) Spanning Tree\n5) SAIR'
-    global n  
     n = input('Por favor, selecione um algoritmo que vc gostaria de executar:\n')
     while (n < 1 or n > 5):
         n = input('Escolha um numero valido (entre 1 e 5):\n')
 
 def ler_dot():
     lista = []
-    vertices = []
     vertices_aux = []
     n_vertices = 0
+    global vertices 
+    global arestas
+    global pesos
+    global g
+    g = Graph()
+    vertices = []
+    arestas = []
+    pesos = []
 
     # abrir arquivo do usuario e ler cada linha 
     x = raw_input('Por favor digite o nome do arquivo: (eh preciso ter .dot no final e o PATH adequado)\n')
     file = open(x, 'r')
     linhas = file.readlines()
-    pattern = '\w+\s*'
+    pattern = '\w+\.*\w*'
 
     # lista = variavel que guarda par de vertices que possuem aresta
     # comeca a ler da linha 1 ao inves da 0, pois a linha zero contem o nome do grafo
     for i in range(1, len(linhas)): 
         lista.append(re.findall(pattern, linhas[i]))
 
+    # apos o regex, temos de deletar o 'label' e salvar o peso da aresta
+    for i in range(len(lista)):
+        if (len(lista[i]) == 4):
+            lista[i].remove('label')
+            pesos.append(float(lista[i][2]))
+            del lista[i][2]
+
     # lista = lista de listas. vertices = lista
     for sublista in lista:
         for item in sublista:
@@ -69,6 +88,13 @@ def ler_dot():
         except ValueError:
             break 
 
+    # agora iremos adicionar as arestas no grafo
+    tupla = ()
+    global arestas
+    for i in range(0, len(vertices), 2):
+        tupla = (vertices[i], vertices[i+1])
+        arestas.append(tupla)
+
     # loop para eliminar duplicatas na lista "vertices"
     for i in vertices:
         if i not in vertices_aux:
@@ -79,29 +105,20 @@ def ler_dot():
     n_vertices = len(vertices)
     g.add_vertices(n_vertices)
     g.vs["name"] = vertices
-
-    # agora iremos adicionar as arestas no grafo
-    tupla = ()
-    arestas = []
-    for i in range(len(lista)):
-        if (len(sublista) == 2):
-            for sublista in lista[i]:
-                tupla = (sublista[0], sublista[1])
-                arestas.append(tupla) 
     g.add_edges(arestas)
-    g.es["weight"] = [0]*len(vertices)
-
-
+    g.es["weight"] = pesos
     file.close()
-    
 
 def criar_grafo():
     print 'Agora iremos criar seu grafo de testes\n'
     y = raw_input('Voce gostaria de carregar um grafo a partir de um arquivo .DOT? (s/n)\n')
     if (y == 's'):
         ler_dot()
-        # fazer algo aqui depois
     else:
+        global g
+        g = Graph()
+        vertices = []
+        arestas = []
         while True:
             try:
                 x = input('Quantos vertices tem seu grafo?\n')
@@ -138,17 +155,61 @@ def criar_grafo():
     plot(g, layout=layout)
 
 # ----------------------------------------------------------------------ALGORITMOS-----------------------------------------------
-#def dijkstra(grafo, no_inicial):
+def dijkstra():
+    global g
+    global vertices
+    global arestas
+    global pesos
+    v_visitados = []
+    predecessor = {}
+    custo = {}
+    menor_custo = {}
+
+    # mensagem de boas vindas / relembrar quais vertices existem no grafo
+    print '\nVoce selecionou o algoritmo de DIJKSTRA\nA seguir o nome dos vertices do seu grafo:\nV = {',
+    for i in range(len(vertices)):
+        if (i < len(vertices)-1):
+            print vertices[i] + ', ',
+        else:
+            print vertices[i] + ' }'
+
+    # loop para selecionar vertice raiz
+    while True:
+        no_inicial = raw_input('Qual sera o seu no inicial(Raiz)?\n')
+        if (no_inicial not in vertices):
+            print 'Por favor, digite um vertice que realmente exista no grafo\nA seguir os vertices do seu grafo:\nV = {',
+            for i in range(len(vertices)):
+                if (i < len(vertices)-1):
+                    print vertices[i] + ', ',
+                else:
+                    print vertices[i] + ' }'
+        else:
+            break
+
+    # inicializando o dijkstra
+    v_visitados.append(no_inicial)
+    predecessor[no_inicial] = '0'
+    menor_custo[no_inicial] = 0
+    for i in range(len(arestas)):
+        custo[arestas[i]] = pesos[i]
+
+    # descobrir os vizinhos do vertice raiz
 
 
 
+#g.vcount()
+#g.ecount()
+
+
 
 # ----------------------------------------------------------------------MAIN-----------------------------------------------------
 def main():
     global n
     menu()
     while (n != 5):
         criar_grafo()
+        if (n == 1):
+            dijkstra()
         menu(False)
 
 if __name__ == "__main__":
@@ -161,4 +222,3 @@ def main():
 
 
 
-