def solve_mis(G): """ 最大独立集合問題を既存の近似解法で解く (Reference: Approximating Maximum Independent Sets by Excluding Subgraphs) 補グラフの最大クリークを近似的に求めることで元グラフの最大独立集合を近似値として求めている 入力 G: 無向グラフ 出力 なし # ><><><><><><><><><><><><><><><><><><><><>< # ><><><><><><><><><><><><><><><><><><><><>< """ start = time.time() indep_nodes = maximum_independent_set(G) elapsed_time = time.time() - start print('elapsed_time :', elapsed_time) print(f'independent set number: {len(indep_nodes)}') print(f'independent set: {indep_nodes}')
def graph_three_sat(three_sat, find_unsat): graph = nx.Graph() for sat in three_sat: graph.add_edges_from(sat.edge_list) graph.add_edges_from(three_sat.edge_list) pos = nx.shell_layout(graph, scale=0.4) k = maximum_independent_set(graph) color_map = [] for node in graph: if node in k: color_map.append("cyan") else: color_map.append("gray") satisfiable = len(k) >= three_sat.size if find_unsat and satisfiable: return nx.draw_networkx(graph, font_size=8, node_color=color_map, pos=pos) plt.title( f"{three_sat}\nk={len(k)} size={three_sat.size}\nSatisfiable: {satisfiable}", size=8, ) plt.show()
def compute_independence_number(self, d, resp_lst): for t in range(self.T): indicator_vec = [1]*self.calA_size fg = self.compute_in_probs(indicator_vec, d, resp_lst, t) ind_set = approximation.maximum_independent_set(self.G) a_G = len(ind_set) return a_G
def getGraphBounds(graph, p, k, filename): #creates the file to store the results filename = "results\\" + filename + ".csv" file = open(filename, 'w') #runs the greedy algorithm and outputs the results greedyAlgResult = greedyAlg(graph.copy()) print("Greedy Alg result:") print(greedyAlgResult) print(len(greedyAlgResult)) print() file.write(str(len(greedyAlgResult)) + "\n") #run the vertex cover approximation algorithm 50 times and outputs the best result vertexCoverIndepResult = vertexCoverApprox(graph.copy()) for i in range(50): temp = vertexCoverApprox(graph.copy()) if (len(temp) < len(vertexCoverIndepResult)): vertexCoverIndepResult = temp print("vertex cover result:") print(len(graph.nodes()) - len(vertexCoverIndepResult)) print() file.write(str(len(graph.nodes()) - len(vertexCoverIndepResult)) + "\n") #runs the algorithm for approximating clique and outputs its results cliqueApproxResult = cliqueMaxApprox(nx.complement(graph), 0.01) print("Clique approximation result:") print(cliqueApproxResult) print(len(cliqueApproxResult)) print() file.write(str(len(cliqueApproxResult)) + "\n") #if the graph isn't too large we run the algorithm for networkx and outputs its results if (len(graph.nodes()) < 2200): networkxIndep = approximation.maximum_independent_set(graph) print("networkx result:") print(networkxIndep) print(len(networkxIndep)) print() file.write(str(len(networkxIndep)) + "\n") else: print("Too big for networkx") #if the graph isn't too large for the stochastic algorithm then we run it and output its results if (len(graph.nodes()) < 400): b = 2 stochasticResult = search(graph, b, p, k) print("Stochastic result:") print(stochasticResult) print(len(stochasticResult)) print() file.write(str(len(stochasticResult))) file.write("\n") file.write(str(stochasticResult)) else: print("Graph too big for stochastic")
def find_max_independent_set(graph, params): """Find the maximum independent set of an input graph given some optimized QAOA parameters. The code you write for this challenge should be completely contained within this function between the # QHACK # comment markers. You should create a device, set up the QAOA ansatz circuit and measure the probabilities of that circuit using the given optimized parameters. Your next step will be to analyze the probabilities and determine the maximum independent set of the graph. Return the maximum independent set as an ordered list of nodes. Args: graph (nx.Graph): A NetworkX graph params (np.ndarray): Optimized QAOA parameters of shape (2, 10) Returns: list[int]: the maximum independent set, specified as a list of nodes in ascending order """ max_ind_set = [] # QHACK # ''' cost_h, mixer_h = qml.qaoa.min_vertex_cover(graph, constrained=False) def qaoa_layer(gamma, alpha): qml.qaoa.cost_layer(gamma, cost_h) qml.qaoa.mixer_layer(alpha, mixer_h) biggest = 0 for i in graph.edges(): if i[0] > biggest: biggest = i[0] if i[1] > biggest: biggest = i[1] wires = range(biggest+1) depth = 10 def circuit(params): for w in wires: qml.Hadamard(wires=w) qml.layer(qaoa_layer, depth, params[0], params[1]) dev = qml.device("default.qubit", wires=wires) @qml.qnode(dev) def probability_circuit(gamma, alpha): circuit([gamma, alpha]) return qml.probs(wires=wires) probs = probability_circuit(params[0], params[1])''' from networkx.algorithms import approximation max_ind_set = nx.maximal_independent_set(graph, approximation.maximum_independent_set(graph)) max_ind_set.sort() # QHACK # return max_ind_set
def main(): # build up a graph filename = '../../florentine_families_graph.gpickle' G = nx.read_gpickle(filename) # Indepedent set maximal_iset = nx.maximal_independent_set(G) out_file = 'florentine_families_graph_maximal_iset.png' PlotGraph.plot_graph(G, filename=out_file, colored_nodes=maximal_iset) maximum_iset = nxaa.maximum_independent_set(G) out_file = 'florentine_families_graph_maximum_iset.png' PlotGraph.plot_graph(G, filename=out_file, colored_nodes=maximum_iset)
def main(): # build up a graph filename = '../../florentine_families_graph.gpickle' G = nx.read_gpickle(filename) # Indepedent set maximal_iset = nx.maximal_independent_set(G) out_file = 'florentine_families_graph_maximal_iset.png' PlotGraph.plot_graph(G, filename=out_file, colored_nodes=maximal_iset) maximum_iset = nxaa.maximum_independent_set(G) out_file = 'florentine_families_graph_maximum_iset.png' PlotGraph.plot_graph(G, filename=out_file, colored_nodes=maximum_iset)
def get_is(G, gs_set, k): cnt = 0 for x in gs_set: for y in gs_set: if G.has_edge(x, y) == True: cnt += 1 G.remove_edge(x, y) if cnt > k: raise Exception('The the number of K is too small!') for x in gs_set: neighbors = list(G.neighbors(x)) for y in neighbors: if G.has_node(y): G.remove_node(y) return approximation.maximum_independent_set(G), k - cnt
def solveIt(inputData): # Modify this code to run your optimization algorithm # parse the input lines = inputData.split('\n') firstLine = lines[0].split() nodeCount = int(firstLine[0]) edgeCount = int(firstLine[1]) edges = [] for i in range(1, edgeCount + 1): line = lines[i] parts = line.split() edges.append((int(parts[0]), int(parts[1]))) # build a trivial solution # every node has its own color #items = len(values) #define n constraints fir each possible color: g=nx.Graph() g.add_edges_from(edges) solution=[-1]*len(g.nodes()) i=0 while(len(g.nodes())>0): maxDegVert=g.degree().keys()[g.degree().values().index(max(g.degree().values()))] # print(maxDegVert) indSet=maximum_independent_set(g) # indSet=maximum(g,[maxDegVert]) for node in indSet: g.remove_node(node) solution[node]=i i=i+1 # print(solution) # prepare the solution in the specified output format outputData = str(i) + ' ' + str(0) + '\n' outputData += ' '.join(map(lambda x:str(int(x)), solution)) return outputData
def test_independent_set(): # smoke test G = nx.Graph() assert_equal(len(a.maximum_independent_set(G)),0)
def test_independent_set(): # smoke test G = nx.Graph() assert_equal(len(a.maximum_independent_set(G)),0)
def find_maximal_independent_set(filename, sub_filename): with open(filename) as file: lines = file.readlines() graph = nx.DiGraph() for line in lines: if 'v' in line: rg.add_nodes_from(graph, [(line.split()[1], { "type": line.split()[2] })]) elif 'e' in line: rg.add_edges_from(graph, [(line.split()[1], line.split()[2])]) with open(sub_filename) as file: lines = file.readlines() graph_ind = -1 graphs = [] invalid_graphs = [] for line in lines: if ':' in line: graph_ind += 1 graphs.append(nx.DiGraph()) elif 'v' in line: rg.add_nodes_from(graphs[graph_ind], [(line.split()[1], { "type": line.split()[2] })]) if line.split()[2] == '0': invalid_graphs.append(graph_ind) elif 'e' in line: rg.add_edges_from(graphs[graph_ind], [(line.split()[1], line.split()[2])]) ret = {} for idx, pat_graph in enumerate(graphs): if idx in invalid_graphs: continue pattern = pat_graph test = isomorphism.GraphMatcher(graph, pattern, node_match=node_match) instances_gen = test.subgraph_isomorphisms_iter() instances = [] for inst in instances_gen: instances.append(inst) newNodes = [] newEdges = [] for i, inst in enumerate(instances): # print(inst) newNodes.append(i) for k in inst: for z, temp_inst in enumerate(instances): for s in temp_inst: # breakpoint() if k == s and not z == i: if not ((z, i) in newEdges or ((i, z) in newEdges)): newEdges.append((z, i)) # print(newNodes) # print(newEdges) newGraph = nx.Graph() rg.add_nodes_from(newGraph, newNodes) rg.add_edges_from(newGraph, newEdges) res = nxaa.maximum_independent_set(newGraph) # print(res) print("Subgraph: ", idx) print("Size of Subgraph:" + str(len(pattern.nodes()))) print("Num subgraphs occurences:" + str(len(newGraph.nodes()))) print("Num overlapping subgraphs:" + str(len(newGraph.nodes()) - len(res))) print("Size max ind set:" + str(len(res))) print() # pos = nx.nx_agraph.graphviz_layout(graph, prog='dot') # nx.draw_networkx(graph, pos, with_labels=True) # plt.show() # color_map = [] # for node in newGraph: # if node in res: # color_map.append('blue') # else: # color_map.append('green') # pos = nx.nx_agraph.graphviz_layout(newGraph, prog='dot') # nx.draw_networkx(newGraph, pos, node_color=color_map, with_labels=True) # plt.show() ret[idx] = (len(newGraph.nodes()), len(newGraph.nodes()) - len(res), len(res)) return ret
def create_graph(edgelist): G = nx.DiGraph() G.add_weighted_edges_from(edgelist) # Graph layout pos = nx.spring_layout(G) # Remove nodes with out-degree = 1------------------------------------------ outdeg = nx.degree(G) while 1 in outdeg.values(): to_remove = [n for n in outdeg if outdeg[n] == 1] G.remove_nodes_from(to_remove) # Remove edges also checking the two values of the tuple edgelist = [x for x in edgelist if x[0] not in to_remove] edgelist = [x for x in edgelist if x[1] not in to_remove] outdeg = nx.degree(G) # --------------------------------------------------------------------------- # Node size ================================================================ d = nx.degree(G) nx.draw_networkx_nodes(G, pos, nodelist=d.keys(), node_size=[v * 100 for v in d.values()]) # =========================================================================== nx.draw_networkx_nodes(G, pos, cmap=plt.get_cmap("jet"), node_size=1) edge_labels = dict([((u, v), d["weight"]) for u, v, d in G.edges(data=True)]) nx.draw_networkx_edges(G, pos, width=0.5, alpha=0.2) nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels) labels = {} for node in G.nodes(): labels[node] = node nx.draw_networkx_labels(G, pos, labels, font_size=8) if not len(G) == 1: from networkx.algorithms import approximation as apxm print apxm.min_edge_dominating_set(G) print apxm.max_clique(G) print apxm.maximum_independent_set(G) print apxm.min_maximal_matching(G) print nx.degree_centrality(G) plt.savefig("directed.png") # save as png # clean old graph plt.clf()
def test_independent_set(): # smoke test G = nx.Graph() assert len(a.maximum_independent_set(G)) == 0