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)