@@ -155,6 +155,19 @@ def criar_grafo():
155
155
156
156
157
157
# ------------------------------------------------------------FUNCOES-DOS-ALGORITMOS-----------------------------------------------
158
+
159
+ # caso o professor queira checar o recultado do algoritmo alguma outra hora, eh possivel salvar os resultados gerados
160
+ def salvar (grafo , nome_do_arquivo , layout_do_grafo , raiz = []):
161
+ x = raw_input ('O senhor gostaria de salvar o resultado que o programa acabou de mostrar? (s/n)\n ' )
162
+ if x .lower () == 's' :
163
+ if not raiz :
164
+ plot (grafo , nome_do_arquivo , layout = layout_do_grafo )
165
+ else :
166
+ plot (grafo , nome_do_arquivo , layout = layout_do_grafo , root = raiz )
167
+
168
+ print 'Arquivo salvo com sucesso!\n Nome do arquivo: ' + nome_do_arquivo + '\n '
169
+
170
+
158
171
# descobrir os vizinhos de um vertice e salvar na variavel adjacentes
159
172
def vizinhos (arestas , vertice , primeira_vez = False ):
160
173
aux = []
@@ -175,40 +188,6 @@ def vizinhos(arestas, vertice, primeira_vez = False):
175
188
if (primeira_vez == False ):
176
189
return adjacentes
177
190
178
- # funcao que checa se ha ciclo fechado
179
- def checar_ciclos (arestas , vertices ):
180
- tem_ciclo = False
181
- vizinhos = {} # vertice: arestas vizinhas deste vertice
182
- loop = False
183
- cont = 0
184
-
185
- # loop para se adicionar os vizinho de todos os vertices no dicionario "vizinhos"
186
- while cont < len (vertices ):
187
- lista = []
188
- for a in arestas :
189
- if vertices [cont ] in a :
190
- lista .append (a )
191
- vizinhos [vertices [cont ]] = lista
192
- cont = cont + 1
193
-
194
- for v in vizinhos :
195
- for a in vizinhos [v ]:
196
- cont = 0
197
- loop = True
198
- lista = []
199
- lista2 = []
200
- lista .append (a )
201
- lista2 .append (v )
202
- while loop == True :
203
- for i in range (2 ):
204
- if (lista2 [cont ] != lista [cont ][i ]):
205
- lista .append (lista [cont ][i ])
206
-
207
- cont = cont + 1
208
-
209
-
210
- return tem_ciclo
211
-
212
191
# ----------------------------------------------------------------------ALGORITMOS-----------------------------------------------
213
192
def dijkstra ():
214
193
global g
@@ -263,12 +242,6 @@ def dijkstra():
263
242
dict = vizinhos (arestas , v )
264
243
adjacentes .update (dict )
265
244
266
- # print 'ANTES DO DIJKSTRA'
267
- # print predecessor
268
- # print adjacentes
269
- # print menor_custo
270
- # print '\n'
271
-
272
245
# agora comecando de verdade o algoritmo
273
246
predecessor_aux = {}
274
247
falta_vertice = True
@@ -295,11 +268,6 @@ def dijkstra():
295
268
falta_vertice = True
296
269
if falta_vertice == False :
297
270
break
298
- # print 'DEPOIS DO DIJKSTRA'
299
- # print predecessor
300
- # print adjacentes
301
- # print menor_custo
302
- # print '\n'
303
271
304
272
# printar na tela o menor caminho e o menor custo
305
273
aux = []
@@ -347,94 +315,74 @@ def dijkstra():
347
315
lista .append (cont )
348
316
layout = t .layout ("tree" , root = lista )
349
317
plot (t , layout = layout )
350
-
351
- #g.vcount()
352
- #g.ecount()
318
+ salvar (t , 'dijkstra.png' , 'tree' , lista )
353
319
354
320
# o algoritmo usado na spanning tree foi o de Kruskal
355
321
def spanning_tree ():
356
- global g
357
322
global vertices
358
323
global arestas
359
324
global pesos
360
325
antes = {} # aresta: peso
361
- depois = {}
362
- arestas2 = []
363
- pesos2 = []
364
326
365
- print 'Voce selecionou o algoritmo de SPANNING TREE\n A partir do seu grafo, sera construida uma arvore minima:'
366
- print 'VERTICES: ' + str (vertices )
367
- print 'ARESTAS: ' + str (arestas )
368
- print 'PESOS: ' + str (pesos )
327
+ print '\n Bem vindo ao algoritmo do SPANNING TREE\n Iremos gerar uma arvore de custo minimo a partir do grafo que voce escolheu'
369
328
370
- # ordenar os pesos em ordem crescente e adicionar as 2 primeiras arestas na arvore final
329
+ # ordenar os pesos em ordem crescente
371
330
for i in range (len (arestas )):
372
331
antes [arestas [i ]] = pesos [i ]
373
- print antes
374
332
menor_pesos = pesos
375
333
menor_pesos .sort ()
376
334
menor_arestas = []
377
335
for p in menor_pesos :
378
336
for a in arestas :
379
337
if (antes [a ] == p ):
380
338
menor_arestas .append (a )
381
- for i in range (2 ):
382
- arestas2 .append (menor_arestas [i ])
383
- pesos2 .append (menor_pesos [i ])
384
-
385
- # comecar o algoritmo de kruskal
386
- cabou = False
387
- cont = 2
388
- while cabou == False :
389
- lista = []
390
- arestas2 .append (menor_arestas [cont ])
391
- n_arestas = len (arestas2 )
392
- for i in range (len (arestas2 )):
393
- for j in range (2 ):
394
- lista .append (arestas2 [i ][j ])
395
- lista2 = []
396
- for v in lista :
397
- if v not in lista2 :
398
- lista2 .append (v )
399
- n_vertices = len (lista2 )
400
- graus = [0 ]* (len (lista2 ))
401
- for i in range (len (lista2 )):
402
- for j in range (len (lista )):
403
- if lista [j ] == lista2 [i ]:
404
- graus [lista2 [i ]] = graus [lista2 [i ]] + 1
405
-
406
-
407
-
408
339
409
- '''
340
+ # inicializando o grafo DE TESTES
410
341
t = Graph ()
411
342
t .add_vertices (len (vertices ))
412
- for p in predecessor:
413
- arestas_final.append(predecessor[p])
414
- lista.append(custo[predecessor[p]])
415
343
t .vs ["name" ] = vertices
416
- t.add_edges(arestas_final)
417
- t.es["weight"] = lista
344
+
345
+ # IMPLEMENTAR FUNCAO AQUI QUE RECEBA UM NO CENTRAL
346
+
347
+ # comecar o algoritmo de kruskal
348
+ aux = menor_arestas
349
+ aux2 = menor_pesos
350
+ cont = 0
351
+ n_arestas = 0
352
+ while (n_arestas < (len (vertices )- 1 )):
353
+ lista = []
354
+ lista .append (aux [cont ])
355
+ t .add_edges (lista )
356
+ if (t .cohesion () > 1 ):
357
+ t .delete_edges (lista )
358
+ del aux [cont ]
359
+ del aux2 [cont ]
360
+ else :
361
+ cont = cont + 1
362
+ n_arestas = n_arestas + 1
363
+
364
+ # inicializando o grafo FINAL e salvando arquivo
365
+ t .es ["weight" ] = aux2
418
366
t .vs ["label" ] = t .vs ["name" ]
419
367
t .es ["label" ] = t .es ["weight" ]
420
- cont = 0
421
- for v in vertices:
422
- if(v == no_inicial):
423
- break
424
- cont = cont + 1
425
- lista = []
426
- lista.append(cont)
427
- layout = t.layout("tree", root = lista)
428
- plot(t, layout=layout)
429
- '''
368
+ print 'A seguir a sua arvore gerada a partir do spanning tree algorithm!'
369
+ plot (t , layout = "kk" )
370
+ salvar (t , "spanning_tree.png" , "kk" )
371
+
372
+ # algoritmo que constroi arvore a partir dos menores caminhos entre os vertices
373
+ def rpf ():
374
+
430
375
376
+ salvar (t , "rpf.png" , "tree" )
431
377
# ----------------------------------------------------------------------MAIN-----------------------------------------------------
432
378
def main ():
433
379
menu ()
434
380
while (n != 5 ):
435
381
criar_grafo ()
436
382
if (n == 1 ):
437
383
dijkstra ()
384
+ elif n == 3 :
385
+ rpf ()
438
386
elif n == 4 :
439
387
spanning_tree ()
440
388
menu (False )
0 commit comments