def run(do_print):
tk=0
tp=0
for i in range(100):
G,C,Gp,N,n=load_data_2('testing_graph_'+str(i)+'.txt')
start=time.time()
if do_print:
print_kruskal(C,n,str(i))
else:
kruskal(C,n)
tk=tk+time.time()-start
n=G.shape[0]
start=time.time()
if do_print:
print_prim(Gp,N,n,str(i))
else:
prim(Gp,N,n)
tp=tp+time.time()-start
tp=tp/100.0
tk=tk/100.0
print tp
print tk
f=open('runtime.txt','w')
f.write('Prim: '+str(tp)+' seconds\nKruskal: '+str(tk)+' seconds')
f.close()
return
def mst(matrix, s):
for i in range(len(matrix)):
matrix[i][i] = sys.maxint
graph = Graph()
for i in range(len(matrix)):
for j in range(len(matrix)):
graph.addEdge(i, j, matrix[i][j])
prim(graph, graph.getVertex(s))
sum = 0
for each in graph:
sum += each.getDistance()
return sum
def main():
for filename in get_test_files():
print("%s:" % filename, end=" ")
with open(filename, "r") as fhandler:
lines = fhandler.readlines()
nb_edges = int(lines[0])
edges = [
(lambda s:
(int(s[0]), int(s[1]), int(s[2])))(lines[i + 1].strip().split())
for i in range(nb_edges)
]
try:
t1 = time.perf_counter()
_, prim_c = prim(edges)
t2 = time.perf_counter()
_, kruskal_c = kruskal(edges)
t3 = time.perf_counter()
except Exception:
print("runtime error")
else:
if prim_c != kruskal_c:
print("KO (Prim: %d, Kruskal: %d)" % (prim_c, kruskal_c))
else:
print("OK (both %d)\t- %d edges\t"
"- Prim: %.3f ms, \tKruskal: %.3f ms" %
(prim_c, nb_edges, 1000 * (t2 - t1), 1000 * (t3 - t2)))
def up_limit_dict(adj_list):
""" 使用Prim 算法计算TSP下限，并给出(i,j)查询表 """
N = len(adj_list)
dist_dict = [ [ MAX_LENGTH for i in xrange(N) ] for j in xrange(N) ]
(mst_weight, mst) = prim(adj_list)
for i in xrange(N):
for e in adj_list[i]:
(weight, u, v) = e
dist_dict[u][v] = weight
dist_dict[v][u] = weight
return (2*mst_weight, dist_dict)
def test_prim_str_vertices(self):
graph = Graph()
graph.add_edge(Edge(Vertex("A"), Vertex("D"), 2))
graph.add_edge(Edge(Vertex("A"), Vertex("G"), 3))
graph.add_edge(Edge(Vertex("A"), Vertex("B"), 1))
graph.add_edge(Edge(Vertex("B"), Vertex("E"), 6))
graph.add_edge(Edge(Vertex("B"), Vertex("F"), 7))
graph.add_edge(Edge(Vertex("F"), Vertex("D"), 10))
graph.add_edge(Edge(Vertex("F"), Vertex("C"), 12))
graph.add_edge(Edge(Vertex("E"), Vertex("G"), 9))
self.assertEqual(prim(graph), 31)
def benchmark():
n = 10**4
m = 10 * n
G = Graph.random_graph(n, m, weighted=True)
begin = time.time()
A = kruskal(G)
end = time.time()
print('* Kruskal {:.5} s'.format(end - begin))
print('-- total weight:', sum(G[u][v] for u, v in A))
print()
begin = time.time()
B = prim(G)
end = time.time()
print('* Prim {:.5} s'.format(end - begin))
print('-- total weight:', sum(G[u][v] for u, v in B))
def test_prim_int_vertices(self):
graph = Graph()
graph.add_edge(Edge(Vertex(0), Vertex(1), 1))
graph.add_edge(Edge(Vertex(0), Vertex(4), 1))
graph.add_edge(Edge(Vertex(1), Vertex(0), 1))
graph.add_edge(Edge(Vertex(1), Vertex(3), 1))
graph.add_edge(Edge(Vertex(1), Vertex(4), 1))
graph.add_edge(Edge(Vertex(1), Vertex(2), 1))
graph.add_edge(Edge(Vertex(2), Vertex(3), 1))
graph.add_edge(Edge(Vertex(2), Vertex(1), 1))
graph.add_edge(Edge(Vertex(3), Vertex(1), 1))
graph.add_edge(Edge(Vertex(3), Vertex(2), 1))
graph.add_edge(Edge(Vertex(3), Vertex(4), 1))
self.assertEqual(prim(graph), 4)
def run_equivalence_test(n, trace=False):
"""
Compare all algorithms for the same input graph
:param n: size of the test graph
:param trace: print debug info is test failed
:return True if test succeeds
"""
t = timeit.default_timer()
adj_list, vertex_list, edge_list = generate_graph(n)
if trace:
print 'Generate graph: {}'.format(timeit.default_timer() - t)
t = timeit.default_timer()
min_span_tree_boruvka = set(boruvka(adj_list))
normalize_edge_list(min_span_tree_boruvka)
if trace:
print 'Boruvka: {}'.format(timeit.default_timer() - t)
t = timeit.default_timer()
min_span_tree_kruskal = set(kruskal(vertex_list, edge_list))
if trace:
print 'Kruskal: {}'.format(timeit.default_timer() - t)
t = timeit.default_timer()
min_span_tree_prim = build_mst_edge_list(prim(adj_list), adj_list)
if trace:
print 'Prim: {}'.format(timeit.default_timer() - t)
success = min_span_tree_boruvka == min_span_tree_kruskal == min_span_tree_prim
if not success and trace and n < 100:
print 'TEST FAILED:'
print 'Adjacency list: {}'.format(adj_list)
print 'Edge and vertex list: {}'.format(edge_list)
print 'Minimum spanning tree with Boruvka: {}'.format(min_span_tree_boruvka)
print 'Minimum spanning tree with Kruskal: {}'.format(min_span_tree_kruskal)
print 'Minimum spanning tree with Prim: {}'.format(min_span_tree_prim)
print '----------------------------------'
return success
def main():
n = int(stdin.readline())
g = graphy.Graph(n)
text = read.readInput(n)
limit = int(stdin.readline())
g = read.diff(text, limit, g)
vertices = read.inputHeap(n, limit)
bh = binheap.binheap(n)
bh.binheap_make(n, vertices)
min = prim.prim(g, bh)
for i in min:
stdout.write(str(i[0]) + ' ' + str(i[1]) + '\n')
def eulerPrim(n, s, G, input):
tracemalloc.start()
cost = 0
k = 0
v = s
MST = [[] for _ in range(n)]
T = prim(n, input, s)
for i in range(len(T)):
MST[i].append([T[i][1], 0])
MST[T[i][1]].append([i, 0])
to_visit = len(T) * 2
vertices = []
while to_visit > 0:
vertices.append(v)
u = -1
vi = 3
for edg in MST[v]:
if edg[1] < 2 and edg[1] < vi:
u = edg[0]
vi = edg[1]
idx = MST[v].index([u, vi])
MST[v][idx][1] += 1
idx = MST[u].index([v, vi])
MST[u][idx][1] += 1
v = u
to_visit -= 1
visited = [False for _ in range(n)]
route = []
prev = vertices[0]
for el in vertices[1:]:
if visited[el]:
vertices.remove(el)
else:
visited[el] = True
cost += G[prev][el]
route.append(el)
prev = el
memory = tracemalloc.get_traced_memory()[1]
tracemalloc.stop()
return cost, memory, route, len(route)
def testMST(self):
size = 50
for _ in range(100):
adjList = defaultdict(list)
edges = []
cnt = 0
weights = range(size * (size - 1) / 2)
random.shuffle(weights)
for i in range(size):
for j in range(i + 1, size):
adjList[i].append((j, weights[cnt]))
adjList[j].append((i, weights[cnt]))
edges.append((i, j, weights[cnt]))
cnt += 1
parent = prim(adjList)
edges = kruskal(size, edges)
self.assertEqual(len(edges) + 1, len(parent))
for u, v in edges:
self.assertTrue(parent[u] == v or parent[v] == u)
def test_simple_graph_prim(self):
S = {0, 1, 2, 3}
A = {
(0, 1): 2,
(1, 0): 2,
(0, 2): 1,
(2, 0): 1,
(1, 2): 2,
(2, 1): 2,
(2, 3): 3,
(3, 2): 3
}
distances, predecessors = prim.prim(S, A, 0)
self.assertEqual(distances, {0: 0, 1: 2, 2: 1, 3: 3})
self.assertTrue(predecessors == {
0: None, 1: 0, 2: 0, 3: 2}
or
predecessors == {0: None, 1: 2, 2: 0, 3: 2})
def stoer_wagner(graph):
assert isinstance(graph, UndirectedGraph)
graph = graph.copy()
min_cut = graph_helper.ARC_COST_LIMIT # max possible
for _ in xrange(len(graph) - 1):
_, spanning_tree_edges = prim(graph)
heaviest_edge = spanning_tree_edges[-1] # it's supposed to be so
# cut weight is sum of edges adjacent to last joined vertex
v_last_joined = heaviest_edge[1]
cut_weight = sum(
graph.get_mark(v, v_last_joined)
for v in graph.get_adjacent(v_last_joined))
min_cut = min(min_cut, cut_weight)
# flip the heaviest edge and merge incident vertices
graph = graph_helper.merge_vertices(graph, *heaviest_edge)
return min_cut
def test_large_graph(self):
nodes = range(1, 10)
edges = [
(1, 2, 4),
(2, 1, 4),
(1, 8, 8),
(8, 1, 8),
(2, 8, 11),
(8, 2, 11),
(2, 3, 8),
(3, 2, 8),
(3, 9, 2),
(9, 3, 2),
(3, 6, 4),
(6, 3, 4),
(3, 4, 7),
(4, 3, 7),
(4, 5, 9),
(5, 4, 9),
(4, 6, 14),
(6, 4, 14),
(5, 6, 10),
(6, 5, 10),
(6, 7, 2),
(7, 6, 2),
(7, 8, 1),
(8, 7, 1),
(7, 9, 6),
(9, 7, 6),
(8, 9, 7),
(9, 8, 7)
]
graph = (nodes, edges)
mst = prim(graph, 1)
cost = sum(weigth for _, __, weigth in mst)
self.assertEquals(cost, 37)
def train(self, ratio=0.9):
# input argument: cmi, split_ratio (default: 0.9(交叉验证比例))
# output:
# the parents node of each attribute node;
# the bayes structure of TAN tree (Tree-Augmented Naive Bayes)
self.parents = par.prim(self.cmi, len(self.cmi)) # we get the parents of each node;
def show_prim(self):
text = prim(self.df)
self.p_weight.setText(str(text))
def prim():
visualPrim.prim(listofEdges, listofVertexes, window)
import load_graph
import os
import matplotlib.pyplot as plt
dataset = [('ha30_dist.txt','ha30_name.txt'), ('sgb128_dist.txt','sgb128_name.txt'), ('wg59_dist.txt','wg59_name.txt')]
# Itera entre cada dataset
for data in dataset:
G = load_graph.load_graph(os.path.abspath('..')+'\\ufscar-2014-graph-theory-task5a\\Datasets\\'+data[0],
os.path.abspath('..')+'\\ufscar-2014-graph-theory-task5a\\Datasets\\'+data[1])
# Aplica o algoritmo de Prim para 10 árvores diferentes
msts = []
for i in range(10):
T = prim(G)
# Transforma o Grafo em um Digrafo e o coloca em um vetor de 10 posicoes
mst_digraph = T.to_directed()
msts.append((mst_digraph))
# Aplica a busca de caminhos eulerianos
# Verificacao que a arvore eh euleriana
# if nx.is_eulerian(mst_digraph) == True:
# print "A arvore eh euleriana!"
# Classe circuito que sera utilizada, ela tera dois atributos: peso e circuito.
class circuito: pass
# Criacao da lista de objetos da classe circuito, e a sua devida inicializacao
circuitos_eulerianos = []
c = e.tuple_rep()
plt.plot([x[0] for x in c], [x[1] for x in c], "b--")
# m => set of edges in mst
def plot_mst(m):
for e in m:
c = e.tuple_rep()
plt.plot([x[0] for x in c], [x[1] for x in c], "b-")
if __name__ == "__main__":
# base data
graph, points = setup()
# find the mst
mst_prim = prim(graph, points, len(points))
mst_kruskal = kruskal(graph)
# metadata for Kruskal
p1 = plt.subplot(221)
p1.set_title("Kruskal")
plt.ylim([-1, 5])
plt.xlim([-1, 5])
# basic
plot_base(graph, points)
# the goods
plot_mst(mst_kruskal)
# metadata for Prim
import weighted_graph
import dijkstra
import prim
node_numbers = {'N1':0, 'N2':1, 'N3':2, 'N4':3}
G = weighted_graph.Graph(len(node_numbers))
for node in node_numbers:
G.set_vertex(node_numbers[node],node)
G.add_edge(node_numbers['N1'],node_numbers['N2'],2)
G.add_edge(node_numbers['N1'],node_numbers['N4'],2)
G.add_edge(node_numbers['N2'],node_numbers['N3'],2)
G.add_edge(node_numbers['N3'],node_numbers['N4'],-4)
G.print_graph()
dijkstra.dijkstra(G,node_numbers['N1'])
print('****')
MST = prim.prim(G,node_numbers['N1'])
MST.print_graph()
def test_two(self):
self.assertEqual(prim(10), [2, 3, 5, 7])
def test_three(self):
self.assertEqual(prim(100), [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97])
def test_one(self):
self.assertEqual(prim(2), [2])
}
G = weighted_graph.Graph(len(node_numbers))
for node in node_numbers:
G.set_vertex(node_numbers[node], node)
G.add_edge(node_numbers['N1'], node_numbers['N2'], 3)
G.add_edge(node_numbers['N1'], node_numbers['N4'], 2)
G.add_edge(node_numbers['N1'], node_numbers['N3'], 3)
G.add_edge(node_numbers['N2'], node_numbers['N4'], 9)
G.add_edge(node_numbers['N2'], node_numbers['N5'], 4)
G.add_edge(node_numbers['N2'], node_numbers['N7'], 2)
G.add_edge(node_numbers['N3'], node_numbers['N4'], 4)
G.add_edge(node_numbers['N3'], node_numbers['N5'], 1)
G.add_edge(node_numbers['N3'], node_numbers['N7'], 6)
G.add_edge(node_numbers['N3'], node_numbers['N8'], 6)
G.add_edge(node_numbers['N4'], node_numbers['N6'], 1)
G.add_edge(node_numbers['N5'], node_numbers['N7'], 7)
G.print_graph()
print('Breadth First Traversal:')
G.breadth_first_traverse()
MST = prim.prim(G, node_numbers['N1'])
MST.print_graph()
