def main():
nome_arquivo = input("Digite o caminho do arquivo:")
# arquivo para leitura
arquivo = open(nome_arquivo, "r")
quantidade = int(arquivo.readline())
grafo = Grafo()
# salva os objetos criados para economizar espaco e utilizá-los
# na criação das arestas
vertices_criados = {}
primeiro_vertice = Vertice(1)
vertices_criados[1] = primeiro_vertice
grafo.adiciona_vertice(primeiro_vertice)
for i in range(2, quantidade + 1):
vertices_criados[i] = Vertice(i)
grafo.adiciona_vertice(vertices_criados[i])
for leitura in arquivo:
# separa dois valores pelo espaco
valores_vertices = leitura.split()
v1 = vertices_criados[int(valores_vertices[0])]
v2 = vertices_criados[int(valores_vertices[1])]
grafo.adiciona_aresta(v1, v2)
try:
resultado = encontrar_caminho_projetos(grafo, primeiro_vertice)
print("A solução para este problema é: ", resultado)
except Exception as ex:
print(ex)
def __init__(self, path):
self.qtd_vertices = 0
self.qtd_arestas = 0
self.tipo = "" # directed or undirected
self.vertices = {} # dicionario de vertices do grafo
self.adj = {} # lista de adjacencias (um dicionario)
with open(path, 'r') as arq_entrada:
linha = arq_entrada.readline()
linha = arq_entrada.readline()
self.qtd_vertices = int(linha)
linha = arq_entrada.readline()
self.qtd_arestas = int(linha)
linha = arq_entrada.readline()
self.tipo = linha
linha = arq_entrada.readline()
linha = arq_entrada.readline()
while linha:
linha = linha.split()
v1, v2 = linha[0], linha[1]
if v1 not in self.vertices:
self.vertices[v1] = Vertice(v1)
self.adj[self.vertices[v1]] = []
if v2 not in self.vertices:
self.vertices[v2] = Vertice(v2)
self.adj[self.vertices[v2]] = []
self.adj[self.vertices[v1]].append(self.vertices[v2])
if self.tipo == 'undirected':
self.adj[self.vertices[v2]].append(self.vertices[v1])
linha = arq_entrada.readline()
def insert_vertices(self, vertice):
# inserir vertice da lista de vertices
if type(vertice) is list:
for v in vertice:
self.vertices.append(Vertice(v))
for c in self.matriz_adjacencia:
c.append(0)
self.matriz_adjacencia.append(
list(itertools.repeat(0, int(len(self.vertices)))))
else:
self.vertices.append(Vertice(vertice))
for c in self.matriz_adjacencia:
c.append(0)
self.matriz_adjacencia.append(
list(itertools.repeat(0, int(len(self.vertices)))))
def connect(self, label1, label2, direction):
v1 = self.vertices.setdefault(label1, Vertice(label1))
v2 = self.vertices.setdefault(label2, Vertice(label2))
if direction == '→':
v1.right = v2
v2.left = v1
elif direction == '←':
v1.left = v2
v2.right = v1
elif direction == '↑':
v1.top = v2
v2.bottom = v1
elif direction == '↓':
v1.bottom = v2
v2.top = v1
def agregar_vertice(self, nombre, dato=None):
"""Pre: el grafo esta creado.
Retorna true si se agrega el vertice,
en el caso que el vertice ya se encuentre, retorna false."""
if nombre in self.vertices: return False
self.vertices[nombre] = Vertice(nombre, dato)
return True
def insert_vertex(self, vertex, pos=None):
if vertex not in self.vertices:
self.vertices[vertex] = Vertice(vertex, pos)
if self.debug >= 1:
self.debug_version()
return "Inserido vértice: " + vertex
return "Vértice já existe no grafo. Não inserido."
def __init__(self, nome):
if type(nome) is set and len(nome) == 2 and all(type(x) is Vertice for x in nome):
self.vert_ini = nome.pop()
self.vert_des = nome.pop()
else:
if type(nome) is list and len(nome) == 2 and all(type(x) is Vertice for x in nome):
self.vert_ini = nome[0]
self.vert_des = nome[1]
else:
self.nome = str(nome)
self.vert_ini = Vertice(nome[0])
self.vert_des = Vertice(nome[1])
self.nome = "{0}{1}".format(self.vert_ini.nome, self.vert_des.nome)
self.lista_vertices = (self.vert_ini, self.vert_des)
self.visit = False
self.explo = False
self.desco = False
def montar(self):
n = self.n * self.n
nmrVertices = (n * n) * (n * n)
#incializa os vertices
k = 0
for i in range(n):
for j in range(n):
self.vertices[i][j] = Vertice(k, i, j, self.n)
k += 1
#faz adjacencias das linhas e das colunas
for i in range(n):
for j in range(n):
#ajacentes da linha
for k in range(n):
if k is not j:
self.vertices[i][j].adjacente(self.vertices[i][k])
#ajacentes dacoluna
for k in range(n):
if k is not i:
self.vertices[i][j].adjacente(self.vertices[k][j])
#adicionando ajacentes do mesmo bloco, jeova has power
for i in range(n):
for j in range(n):
#limite direito
lim = j + 1
while lim % self.n is not 0:
lim += 1
direito = lim
#limite esquerdo
lim = j
while lim % self.n is not 0:
lim -= 1
esquerdo = lim
#limite inferior
lim = i + 1
while lim % self.n is not 0:
lim += 1
inferior = lim
#superior
lim = i
while lim % self.n is not 0:
lim -= 1
superior = lim
for k in range(superior, inferior):
for l in range(esquerdo, direito):
if k is not i and l is not j:
if self.vertices[k][l] not in self.vertices[i][
j].edges:
self.vertices[i][j].adjacente(
self.vertices[k][l])
def CriaVertices(numeroVertices):
verticesLst = []
i = 0
while i < numeroVertices:
vertice = Vertice(i, rotuloVertices[i])
verticesLst.append(vertice)
i += 1
return verticesLst
def insert(self, v: Vertice) -> None:
if self.__size + 1 >= self.__capacity:
return
self.__size += 1
self.__vertices[self.__size] = v
self.__indexes_hash[v.v_id()] = self.__size
self.__pull_up(self.__size)
def insereVertice(self,idVertice):
"""
insere um vértice no grafo
Args:
idVertice (string): id do vértice para ser adicionado
"""
#cria um novo vértice e adiciona no vetor
self.listaVertices.append(Vertice(idVertice))
def inputParse():
with open('input.txt') as file:
lines = file.readlines()
allVertices = []
vertices, medians = lines.pop(0).split()
for eachLine in lines:
x, y, cap, demand = eachLine.split()
vertice = Vertice(float(x), float(y), float(cap), float(demand))
allVertices.append(vertice)
return [allVertices, int(vertices), int(medians)]
def __init__(self, qtd_vertices):
self.qtd_vertices = qtd_vertices
self.nome = "grafo_" + str(self.qtd_vertices)
__vertice_list__ = list(range(1, int(qtd_vertices + 1)))
self.vertices = []
for vertice in __vertice_list__:
self.vertices.append(Vertice(vertice))
self.arestas = set()
self.matriz_adjacencia = []
for k in range(0, qtd_vertices):
self.matriz_adjacencia.append(
list(itertools.repeat(0, int(qtd_vertices))))
self.lista_adjacencia = []
def main():
g1 = Grafo(False) # gera um grafo sem direção
v1 = Vertice("a", 12) # cria o vérice v1
g1.add_vertice(v1) # insere o vérice v1 no grafo g1
v2 = Vertice("b", 13) # cria o vértice v2
g1.add_vertice(v2) # insere o vértice v2 no grafo g1
v3 = Vertice("c", 6) # cria o vértice v3
g1.add_vertice(v3) # insere o cértice v3 no grafo v3
a1 = Aresta(v1, v2, "a1", 2) # cria uma aresta entre v1 e v2
a2 = Aresta(v2, v3, "a2", 2) # cria uma aresta entre v2 e v3
a3 = Aresta(v3, v1, "a3", 2) # cria uma aresta entre v3 e v1
# corrigir
g1.add_aresta(a1) # insere a aresta a1 no grafo
g1.add_aresta(a2) # insere a aresta a2 no grafo
g1.add_aresta(a3) # insere a aresta a3 no grafo
print(g1)
g1.getFTD(v1)
g1.dfs()
def __init__(self, num_vertices, arestas):
self.num_comparacoes = 0
# Cria os vertices
self.vertices = []
for i in range(num_vertices):
vertice = Vertice(i)
self.vertices.append(vertice)
# Cria um dicionario de arestas com o par de vertices sendo a chave
self.dic_arestas = {}
for aresta in arestas:
v1, v2, capacidade = aresta
key = (v1, v2)
invert_key = (v2, v1)
aresta_dicionario = self.dic_arestas.get(key)
# Se nao existe aresta entre os vertices no dicionario
if (aresta_dicionario is None):
nova_aresta = Aresta(v1, v2, capacidade)
self.dic_arestas[key] = nova_aresta
self.dic_arestas[invert_key] = nova_aresta
else:
# Se existir mais de uma aresta entre dois vertices, pode-se
# considerar que existe apenas uma aresta com a soma das
# capacidades
self.dic_arestas[key].capacidade += capacidade
self.dic_arestas[key].atualiza_residual()
# Cria um vetor com os indices das arestas (para facilitar a criação da
# lista de adjacencia)
self.indices_arestas = set()
for aresta in arestas:
key = (aresta[0], aresta[1])
invert_key = (aresta[1], aresta[0])
if (key in self.indices_arestas
or invert_key in self.indices_arestas):
continue
self.indices_arestas.add((aresta[0], aresta[1]))
self.grafo = ListaAdjacencia(num_vertices, self.indices_arestas)
def __init__(self, matrice_adiacenza, vertici_scc=None):
self.matrice_adiacenza = matrice_adiacenza
# Inizializza vertici con colore bianco 'W' e predecessore None
self.vertici = [Vertice(i) for i in range(len(self.matrice_adiacenza))]
# Variabile globale per registrare informazioni temporali
self.time = 0
# Variabili per la memorizzazione di informazioni riguardanti le scc
self.numero_di_scc = 0 # numero di componenti fortemente connesse del grafo
self.dizionario_scc = {} # dizionario che memorizza l'insieme di vertici di ogni componente fortemente connessa
# Booleano che indica se siamo al passo 3 dell'algoritmo scc
self.usaDfsModificata = vertici_scc is not None
if self.usaDfsModificata:
self.dfs_scc(vertici_scc)
else:
self.dfs()
def ler_de_arquivo(arq):
cont = open(arq, 'r').read()
dic = ast.literal_eval(cont)
grf = Grafo(0) # Cria um Grafo vazio
grf.nome = dic[
'nome'] # Extrai o nome do arquivo e inclui direto no grafo vazio
lista = []
# grf.vertices = dic['vertices']
for v in dic['vertices']:
grf.vertices.append(
Vertice(v)
) # Cria um Vertice para cada vertice extraido do arquivo e inclui em vertices
grf.qtd_vertices = int(len(grf.vertices)) # atualiza o Numero de vertices
# grf.arestas = dic['arestas']
for a in dic['arestas']: # para cada aresta do arquivo...
if type(a) is list and len(
a) == 2: # verifica se é válida (uma lista com 2 elementos)...
for v in a: # e para cada elemento dessa lista de 2...
for vertc in grf.vertices: # verifica se corresponde a um vertice obtidos...
if str(v) == vertc.nome: # através do nome...
lista.append(vertc) # e junta a uma lista parcial...
grf.arestas.add(
Aresta(lista)) # para gerar uma aresta com esses 2 vertices
lista.clear() # limpa a lista parcial para recomeçar
else:
grf.arestas.add(
Aresta(a)
) # caso não ache o vertice em vértices, registra como uma lista de vertices, não uma resta
for x in range(
0, grf.qtd_vertices
): # reeinicia a matriz de adjacencia vazia com os vértices inseridos anteriormente
grf.matriz_adjacencia.append(
list(itertools.repeat(0, grf.qtd_vertices)))
for v in grf.vertices:
grf.add_matriz_adj(
v
) # popular matriz de adjacencia vazia com os vértices inseridos anteriormente
grf.lista_adjacencia.append(
grf.vizinhos(v)) # popular lista de adjacências
return grf
def __init__(self, n):
self.quantidade_vertices = n
# Lista de adjacencia para representar o grafo
self.lista_adjacencia = []
for i in range(self.quantidade_vertices):
self.lista_adjacencia.append([])
# Matriz de adjacencia para representar o grafo
self.matriz_adjacencia = []
for i in range(self.quantidade_vertices):
linha = []
for j in range(self.quantidade_vertices):
linha.append(0)
self.matriz_adjacencia.append(linha)
# Lista de vertices para realizar algumas operacoes
self.lista_vertices = []
for i in range(self.quantidade_vertices):
self.lista_vertices.append(Vertice(i))
# Tempo de visitacao dos vertices
self.tempo = 0
def novoVertice(self, identificador, estado, sinal, acaoControle):
self._vertices.append(
Vertice(identificador, estado, sinal, acaoControle))
def updateVertices(self, to):
self.vertices.append(Vertice(pointing=(self.startNode, to)))
v_antecessor[v_adj.chave] = v_atual
distancia_ate_n[v_adj.chave] = novo_g_de_n
# f(n) = g(n) + h(n)
v_adj.f_de_n = distancia_ate_n[v_adj.chave] + v_adj.h_de_n
return None
if __name__ == '__main__':
from vertice import Vertice
from aresta import Aresta
import sys
vertices = []
# segundo parametro corresponde a distancia do No ate o destino Final(nesse caso E12)
noE1 = Vertice('E1', 30)
vertices.append(noE1)
noE2 = Vertice('E2', 23)
vertices.append(noE2)
noE3 = Vertice('E3', 21)
vertices.append(noE3)
noE4 = Vertice('E4', 21)
vertices.append(noE4)
noE5 = Vertice('E5', 27)
vertices.append(noE5)
noE6 = Vertice('E6', 30)
vertices.append(noE6)
noE7 = Vertice('E7', 28)
vertices.append(noE7)
noE8 = Vertice('E8', 7)
vertices.append(noE8)
def adicionar_vertice(self, nome: str) -> None: self.vertices.append(Vertice(nome))
def createVertice(self, pt):
vertice = Vertice(self)
vertice.setPos(pt)
return vertice
from vertice import Vertice
##############################
v_a = Vertice("a")
v_b = Vertice("b")
v_c = Vertice("c")
v_d = Vertice("d")
v_e = Vertice("e")
v_f = Vertice("f")
vertices = [v_a, v_b, v_c, v_d, v_e, v_f]
g = {
"a": [v_d],
"b": [v_c],
"c": [v_b, v_c, v_d, v_e],
"d": [v_a, v_c],
"e": [v_c],
"f": []
}
##############################
bfs_r = Vertice("r")
bfs_s = Vertice("s")
bfs_t = Vertice("t")
bfs_u = Vertice("u")
bfs_v = Vertice("v")
bfs_w = Vertice("w")
bfs_x = Vertice("x")
bfs_y = Vertice("y")
def create_vertices(self, size):#criando os vertices i = 0 while i < size: vertice = Vertice(i) self.vertices.append(vertice) #preenchendo minha lista com os vertices criados i+=1
print(
"you have given a wrong argument. the input word must be 6 character long"
)
sys.exit()
if in_word not in allWords:
print("you have entered a word which isn't in the word file;")
sys.exit()
graphDic = {}
edgeCount = 0
groupId = 0
while len(allWords) > 0: #while allWords isn't empty
word = allWords[0]
allWords.remove(word)
v_new = Vertice(word)
for v_word in graphDic:
if matchTwoWords(word, v_word):
v_new.add_edge(v_word)
graphDic[v_word].add_edge(word)
if v_new.getGroupId() == 0:
v_new.setGroupId(graphDic[v_word].getGroupId())
else:
graphDic[v_word].setGroupId(v_new.getGroupId())
edgeCount += 1
if v_new.getGroupId() == 0:
groupId += 1
v_new.setGroupId(groupId)
graphDic[word] = v_new
timeReadbuild = time.time() - startTime
def novo_vertice(self, identificador):
self.lista_vertices.append(Vertice(identificador))
def add_cart(self, position, direction):
v = self.vertices.setdefault(position, Vertice(position))
cart = Cart(v, direction)
self.carts.append(cart)
distancia_ate_n[v_adj.chave] = novo_g_de_n
# f(n) = g(n) + h(n)
v_adj.f_de_n = distancia_ate_n[v_adj.chave] + v_adj.h_de_n
return None
if __name__ == '__main__':
from vertice import Vertice
from aresta import Aresta
import sys
vertices = []
# O segundo parametro de Vertice tem a função de
# guardar a distancia do no ate o destino final
noE1 = Vertice('E1', 450)
vertices.append(noE1)
noE2 = Vertice('E2', 302)
vertices.append(noE2)
noE3 = Vertice('E3', 659)
vertices.append(noE3)
noE4 = Vertice('E4', 48)
vertices.append(noE4)
noE5 = Vertice('E5', 446)
vertices.append(noE5)
noE6 = Vertice('E6', 132)
vertices.append(noE6)
noE7 = Vertice('E7', 278)
vertices.append(noE7)
noE8 = Vertice('E8', 720)
vertices.append(noE8)
