最大团问题

1. 回溯算法

   def find_maximum_clique(graph):
       n = len(graph)
       vertices = list(range(n))
       max_clique = []
       print(n)
       print(vertices)
   
       def is_clique(current_clique):
           # 约束函数: 判断给定的顶点集合是否构成一个团(完全子图)
           for i in range(len(current_clique)):
               for j in range(i + 1, len(current_clique)):
                   if not graph[current_clique[i]][current_clique[j]]:
                       return False
   
           return True
   
       #def bound(current_clique, vertices):
           # 限界函数
           return len(current_clique) + len(vertices)
   
       def backtrack(vertices, current_clique):
           nonlocal max_clique
   
           if not vertices:
               if len(current_clique) > len(max_clique):
                   #max_clique.clear()
                   #max_clique.extend(current_clique)
                   max_clique=current_clique[:]   #复制
               return
   
           #vertex = vertices.pop(0)
           #current_clique.append(vertex)
   
           #neighbors = []
           #for v in vertices:
               if graph[vertex][v]:
                   neighbors.append(v)
   
           # 选择当前顶点并加入团
           #if is_clique(current_clique):
               #backtrack(neighbors, current_clique)
   
           # 恢复回溯前状态
           #current_clique.pop()
   
           # 不选择当前顶点
           #if bound(current_clique, vertices) > len(max_clique):
               #backtrack(vertices, current_clique)
           for vertex in vertices:
               current_clique.append(vertex)
               neighbors=[v for v in vertices if graph[vertex][v]]
               if is_clique(current_clique):
                   backtrack(neighbors,current_clique)
               current_clique.pop()  #恢复回溯前的状态
      
       backtrack(vertices, [])
   
       return max_clique
   
   #无向图邻接矩阵
   graph= [
       [0, 1, 0, 1, 1],
       [1, 0, 1, 0, 1],
       [0, 1, 0, 0, 1],
       [1, 0, 0, 0, 1],
       [1, 1, 1, 1, 0]]
   maximum_clique = find_maximum_clique(graph)
   for i in range(len(maximum_clique)):
       maximum_clique[i]=maximum_clique[i]+1    
   print(f'最大团: {maximum_clique}')

2. 灰狼优化算法

   import numpy as np
   import random
   #无向图邻接矩阵
   graph=np.array([[0,1,1,0,0],
                  [1,0,1,1,1],
                  [1,1,0,1,1],
                  [0,1,1,0,1],
                  [0,1,1,1,0]])
   def max_clique_GWO(graph):
       def fitness(solution):
           #获取解中值为1的索引
           subset = np.where(solution == 1)[0] 
           is_clique = all(graph[i][j] == 1 for i in subset for j in subset if i != j)  
           return len(subset) if is_clique else 0
       def grey_wolf_optimizer(graph, solution_size, wolf_size, max_iter):
       #生成随机数组，用于初始化狼群  
           wolves = np.random.randint(0, 2, (wolf_size, solution_size))  
           alpha_score, beta_score, delta_score = -np.inf, -np.inf, -np.inf 
           alpha=None
           beta=None
           delta=None
           for l in range(max_iter): 
               for i,wolf in enumerate(wolves):  
                   score = fitness(wolf)  
                   if score > alpha_score:  
                       alpha_score = score
                       alpha=wolf.copy()
                   elif score > beta_score:  
                       beta_score = score
                       beta=wolf.copy() 
                   elif score > delta_score:  
                           delta_score, delta = score, wolf.copy()
                           delta=wolf.copy()
                       
               #更新每只灰狼的位置
               a = 2 - l * ((2) / max_iter);  # a从2线性减少到0
               for i in range(wolf_size):
                  for j in range(solution_size):  
                       r1, r2 = random.random(), random.random()  
                       A1, C1 = 2 * a * r1 - a, 2 * r2  
                       D_alpha = abs(C1 * alpha[j] - wolves[i, j])  
                       X1 = alpha[j] - A1 * D_alpha  
     
                       r1, r2 = random.random(), random.random()  
                       A2, C2 = 2 * a * r1 - a, 2 * r2  
                       D_beta = abs(C2 * beta[j] - wolves[i, j])  
                       X2 = beta[j] - A2 * D_beta  
     
                       r1, r2 = random.random(), random.random()  
                       A3, C3 = 2 * a * r1 - a, 2 * r2  
                       D_delta = abs(C3 * delta[j] - wolves[i, j])  
                       X3 = delta[j] - A3 * D_delta  
                       wolves[i, j] = round((X1 + X2 + X3) / 3)  # 四舍五入确保是0或1
           return alpha        
       #初始化参数
       solution_size = len(graph)
       max_iter=20
       wolf_size=10
       best_clique = grey_wolf_optimizer(graph, solution_size, wolf_size, max_iter)  
       return best_clique
   # 执行最大团问题求解  
   max_clique_result = max_clique_GWO(graph)
   #输出结果
   result=np.where(max_clique_result==1)[0]
   for i in range(len(result)):
       result[i]=result[i]+1
   print("最大团为：", result)