好吧，我有这张图：
我必须制作一个基于 Branch and Bound 并使用回溯的代码，它必须显示匹配图形节点的最佳方式。所以在这个例子中，最优解必须是>> [(1,4),(2,3)]。但是我的算法显示了这个可能的解决方案，这不是最佳的>> [(1,2),(3,4)]。我认为问题可能出在“撤消”行，但我不确定......如果有人可以帮助我解决这个问题，我将非常感激！
这是我的代码：
import networkx as nx
import sys
import matplotlib.pyplot as plt
import copy
import operator
from itertools import izip
def grouped(iterable, n):
"s -> (s0,s1,s2,...sn-1), (sn,sn+1,sn+2,...s2n-1), (s2n,s2n+1,s2n+2,...s3n-1), ..."
return izip(*[iter(iterable)]*n)
''' Method to create a Graf from a file '''
def leerGrafo():
#name = raw_input("Enter the name of the Graph please: ")
name = "grafo2.dat"
G = nx.read_edgelist(name,nodetype=int,data=(('weight',float),))
return G
''' Method to create the adjacency matrix '''
def matrixAdj(G):
''' Tener en cuenta: diagonal = 0, y no conex. = Inf '''
nodes = G.number_of_nodes()
edges = G.edges()
listaAdj = [[float("Inf") for j in range(nodes)] for i in range(nodes)]
for i in range(len(edges)):
valor1,valor2 = edges[i][0],edges[i][1]
listaAdj[valor1-1][valor2-1] = G.edge[valor1][valor2]['weight']
listaAdj[valor2-1][valor1-1] = G.edge[valor1][valor2]['weight']
return listaAdj
''' returns the weight from the adjacency matrix '''
def weight_of(s,G,son):
return matrix[s-1][int(son)-1]
''' Backtracking Method '''
def backtracking(s,G,l,cMax,cMin,finalSol):
# We insert the current valid node, from our current way
l.append(s)
# We iterate over the sons of our current node
for son in G.neighbors(s):
# If the current son is not one of the predecessors of the current node 's'...
if not son in l:
# We calculate the bound of the current son, adding the weight of his father (s) + the weight of the current son
# Note: At the start (the first node), we add the lower bound + the weight of that node.
c = weight_of(son,G,s) + cMin
# If this bound is lesser or iqual than the upper bound...
if c <= cMax:
# If this current node is a leaf, means that we've found a possible way...
if len(l)+1 == G.number_of_nodes():
# We insert this current node (son)
l.append(son)
# We update the upper bound with the bound of this current node
cMax = c
# We store a copy of our possible way
finalSol = copy.copy(l)
# We reset our list that conteins our possible way
l = []
return finalSol
# Si no...seguimos recorriendo las ramas hasta encontrar un camino entero
else:
backtracking(son,G,l,cMax,c,finalSol)
# Undo
del l[-1]
return
''' Main Function '''
def main():
# We make the graf
G1 = leerGrafo()
global matrix
# We create the adjacency matrix
matrix = matrixAdj(G1)
# We make a ordered list that contains just the weight of all nodes
pesos = [a[2]['weight'] for a in sorted(G1.edges(data=True), key=lambda aux: aux[2])]
# We calculate the default upper bound
cotaMax = sum(pesos)
# We calculate the lower bound
cotaMin = pesos[0]
l = []
global finalSol
finalSol = 0
# We call the backtracking method
bestSol = backtracking(G1.nodes()[0],G1,l,cotaMax,cotaMin,finalSol)
# We print the solution
print "Best Solution: "
for x, y in grouped(bestSol, 2):
print "(%d,%d)" % (x, y)