Python 获取一组最大数量的不同数组

我有一个长度为n的数组，这个数组的每个元素（比如Wi）都是一个长度为10的数组。有一个功能，匹配检查（Wi，Wj），定义为：

def match_check(Wi, Wj):
  n = len(Wi)
  num_matches =0
  for i in range(n):
    if (round(Wi[i],4)== round(Wj[i]),4):
        num_matches +=1
  if (num_matches >= 3):
    return True 
  else :
    False

我想从数组A中获取最大元素数的集合，这样集合中就没有两个元素匹配了。我认为这是一个DP问题，并编写了以下解决方案

def maximum_arrays(start,end ,curr_items=[], match_dict={}, lookup_dict={}):
 key = str(start) + "|" + str(end) 
 
 if (lookup_dict.get(key)):
    return lookup_dict[key]
 if (start == end ):
    for items in curr_items:
        match_key = str(start)+ ":" + str(items)
        if(match_dict[match_key]):
            lookup_dict[key] = len(curr_items)
            return lookup_dict[key]
    lookup_dict[key] = 1 + len(curr_items)
    return lookup_dict[key]

 match_flag = False
 for items in curr_items:
    match_key = str(start)+":" + str(items)
    if (match_dict.get(match_key)):
        match_flag = True
        break
 if (match_flag):
    lookup_dict[key] = maximum_arrays(start+1,end, curr_items,match_dict, lookup_dict)
 else:
    curr_items_new   = curr_items + [start]
    lookup_dict[key] = max(1 + maximum_arrays(start+1,end, curr_items_new,match_dict, lookup_dict),
                      maximum_arrays(start+1,end, curr_items,match_dict, lookup_dict))

     
 return lookup_dict[key]

---

其中match_dict包含数组A中所有可能的索引对的match_检查结果。但我怀疑动态规划是否有帮助，解决方案是O（2^n），因为我们必须评估所有可能的情况（保留和删除集合中的每个元素）。

一个简单的算法，需要

O（n^2）

首先为这些数组构建一个邻接矩阵，只需对每对数组应用匹配检查即可。如果函数match_check返回False，将添加一条边。 然后，问题归结为在图中找到最大团并返回其大小，这可以在

O（n^2）

中完成

下面是一个简单的演示：

import networkx as nx
import numpy as np

def match_check(Wi, Wj):
  n = len(Wi)
  num_matches =0
  for i in range(n):
    if round(Wi[i],4) == round(Wj[i],4):
        num_matches +=1
  if (num_matches >= 3):
    return True 
  else :
    return False
    

check_arr = [list(10*np.random.rand(5)) for k in range(10)]
n = len(check_arr)
graph_adjacency_mat = np.zeros((n,n))
for i in range(n):
    for j in range(n):
        if i==j:
            continue
        graph_adjacency_mat[i][j] = not match_check(check_arr[i],check_arr[j])
        graph_adjacency_mat[j][i] = graph_adjacency_mat[i][j]

G=nx.from_numpy_matrix(graph_adjacency_mat)
print(max([len(clique) for clique in nx.find_cliques(G)]))
    

---

注意，这里我使用了NetworkX中的find_cliques函数，它不是

O（n^2）

（而是

O（3^（n/3））

），因为NetworkX的函数max_clique似乎被丢弃了。通过从每个顶点开始在图上应用BFS/DFS并保存到目前为止找到的最大团，可以轻松实现最大团。

一个简单的算法需要

O（n^2）

首先为这些数组构建一个邻接矩阵，只需对每对数组应用匹配检查。如果函数match_check返回False，将添加一条边。 然后，问题归结为在图中找到最大团并返回其大小，这可以在

O（n^2）

中完成

下面是一个简单的演示：

import networkx as nx
import numpy as np

def match_check(Wi, Wj):
  n = len(Wi)
  num_matches =0
  for i in range(n):
    if round(Wi[i],4) == round(Wj[i],4):
        num_matches +=1
  if (num_matches >= 3):
    return True 
  else :
    return False
    

check_arr = [list(10*np.random.rand(5)) for k in range(10)]
n = len(check_arr)
graph_adjacency_mat = np.zeros((n,n))
for i in range(n):
    for j in range(n):
        if i==j:
            continue
        graph_adjacency_mat[i][j] = not match_check(check_arr[i],check_arr[j])
        graph_adjacency_mat[j][i] = graph_adjacency_mat[i][j]

G=nx.from_numpy_matrix(graph_adjacency_mat)
print(max([len(clique) for clique in nx.find_cliques(G)]))
    

注意，这里我使用了NetworkX中的find_cliques函数，它不是

O（n^2）

（而是

O（3^（n/3））

），因为NetworkX的函数max_clique似乎被丢弃了。通过从每个顶点开始在图上应用BFS/DFS并保存到目前为止找到的最大团，可以轻松实现max_团