检查两个列表是否在Python中至少有两个常用项目的最快方法?

时间:2017-08-04 15:47:57

标签: python

 a={}

 t= list(map(int,input().split()))
 n=t[0]
 k=t[1]

 for i in range(n):
    a.update({i:[]})

 ids=[] 

 for i in range(n):
     k=input().split()
     ids.append(set(k[1:]))


 def ifrel(i, j):
    if i==j:
      return False
    return len(ids[i] & ids[j]) >= 2

 for i in range(n):
    for j in range(n):
       if ifrel(i,j):
          a[i].append(j)
 stack=[]
 res=[]
 def iterdfs(g,s):
     stack.append(s)
     while stack!=[]:
       k=stack.pop()
       if k not in res:
          res.append(k)
       for i in g[k]:
          if i not in res: 
         stack.append(i)
     return res

  print(len(iterdfs(a,0)))

这是使用Set的最终解决方案,但我仍然得到TLE!

ids []是一个包含列表的列表,例如:ids = [[' 1',' 2',' 3']]。使用Dictionary会提高速度吗?

我有一些编辑麻烦,因为这是Stack Overflow中的第一个问题。

我想解决的问题是: https://www.codechef.com/IOIPRAC/problems/INOI1302/

4 个答案:

答案 0 :(得分:3)

如果您想要最快的解决方案,那就不会简洁了。这是最坏情况O(A + B)的尝试,但是一旦找到两个匹配就会退出,最好是Ω(B),其中B是两个列表中较短的一个。

def check_common_items(A, B, n=2):

    # set B to be the shorter list, len is O(1)
    if len(B) < len(A):
        A, B = B, A

    B_set = set(B) # O(len(B))

    count = 0
    for a in A: # worst case O(len(A))
        if a in B_set: # O(1)
            count += 1
            if count == n:
                return True
    return False

但是,大多数使用集合的实现都是渐近有效的。例如,以下函数可能不会太慢​​。

def check_common_items(A, B, n=2):
    return len(set(A) & set(B)) >= n

答案 1 :(得分:2)

使用一套。

In [1]: lst1 = [1, 2, 3, 4]
In [2]: lst2 = [3, 4, 5, 6]
In [3]: set(lst1).intersection(set(lst2))
Out[3]: {3, 4}
In [4]: len(set(lst1).intersection(set(lst2)))
Out[4]: 2

答案 2 :(得分:1)

def check(list1,list2):
   if len([elem for elem in set(list1) if elem in list2])>=2:return True
   return False

使用此功能。它列出了常用项目并检查列表的长度。

答案 3 :(得分:1)

您需要提出一个更有效的算法,而不是检查两个列表的整体,一旦您确定了两个重复项,就可以终止:

a = ['some', 'list']
b = ['some', 'other', 'list']
duplicate_count = 0
my_bool = False
for item in a:
    if item in b:
        duplicate_count += 1
    if duplicate_count >= 2:
        my_bool = True
        break

在最坏的情况下算法仍然是O(n 2 ),但它有可能提前终止