我正在使用python解决facebook hackercup上的Find the min问题，我的代码适用于样本输入，但对于大输入（10 ^ 9），需要数小时才能完成。
那么，有可能使用python在6分钟内无法计算出该问题的解决方案吗？或者可能是我的方法太糟糕了？
问题陈述：
发送表情后，John决定玩数组。你知道黑客喜欢玩阵列吗？ John有一个从零开始的索引数组m，其中包含n个非负整数。但是，他只知道数组的第一个k值，他想弄清楚其余的。
John知道以下内容：对于每个索引i，其中k <= i < n，m[i]是最小的非负整数，不包含在前一个中*k*的{{1}}值。
例如，如果m，k = 3和n = 4的已知值为m，则可以找出[2, 3, 0]。
约翰非常忙于让世界变得更加开放和联系，因此，他没有时间去弄清楚阵列的其余部分。你的任务就是帮助他。
给定m[3] = 1的第一个k值，计算此数组的第n个值。 （即m）。
由于m[n - 1]和n的值可能非常大，我们使用伪随机数生成器来计算k的第一个k值。给定正整数m，a，b和c，r的已知值可按如下方式计算：
m输入
第一行包含整数T（T <= 20），测试次数 例。
接下来是T个测试用例，每个测试用例包含2行。
每个测试用例的第一行包含2个空格分隔的整数，
m[0] = a
m[i] = (b * m[i - 1] + c) % r, 0 < i < k
，n（k，1 <= k <= 10^5）。
每个测试用例的第二行包含4个空格分隔的整数
k < n <= 10^9，a，b，c（0＆lt; = a，b，c＆lt; = 10 ^ 9，1＆lt; = r＆lt; = 10 ^ 9）。
我尝试了两种方法，但都未能在6分钟内返回结果，这是我的两种方法：
第一
r第二
import sys
cases=sys.stdin.readlines()
def func(line1,line2):
n,k=map(int,line1.split())
a,b,c,r =map(int,line2.split())
m=[None]*n #initialize the list
m[0]=a
for i in xrange(1,k): #set the first k values using the formula
m[i]= (b * m[i - 1] + c) % r
#print m
for j in range(0,n-k): #now set the value of m[k], m[k+1],.. upto m[n-1]
temp=set(m[j:k+j]) # create a set from the K values relative to current index
i=-1 #start at 0, lowest +ve integer
while True:
i+=1
if i not in temp: #if that +ve integer is not present in temp
m[k+j]=i
break
return m[-1]
for ind,case in enumerate(xrange(1,len(cases),2)):
ans=func(cases[case],cases[case+1])
print "Case #{0}: {1}".format(ind+1,ans)
第二种方法中的最后一个for循环也可以写成：
import sys
cases=sys.stdin.readlines()
def func(line1,line2):
n,k=map(int,line1.split())
a,b,c,r =map(int,line2.split())
m=[None]*n #initialize
m[0]=a
for i in xrange(1,k): #same as above
m[i]= (b * m[i - 1] + c) % r
#instead of generating a set in each iteration , I used a
# dictionary this time.
#Now, if the count of an item is 0 then it
#means the item is not present in the previous K items
#and can be added as the min value
temp={}
for x in m[0:k]:
temp[x]=temp.get(x,0)+1
i=-1
while True:
i+=1
if i not in temp:
m[k]=i #set the value of m[k]
break
for j in range(1,n-k): #now set the values of m[k+1] to m[n-1]
i=-1
temp[m[j-1]] -= 1 #decrement it's value, as it is now out of K items
temp[m[k+j-1]]=temp.get(m[k+j-1],0)+1 # new item added to the current K-1 items
while True:
i+=1
if i not in temp or temp[i]==0: #if i not found in dict or it's val is 0
m[k+j]=i
break
return m[-1]
for ind,case in enumerate(xrange(1,len(cases),2)):
ans=func(cases[case],cases[case+1])
print "Case #{0}: {1}".format(ind+1,ans)
示例输入：
for j in range(1,n-k):
i=-1
temp[m[j-1]] -= 1
if temp[m[j-1]]==0:
temp.pop(m[j-1]) #same as above but pop the key this time
temp[m[k+j-1]]=temp.get(m[k+j-1],0)+1
while True:
i+=1
if i not in temp:
m[k+j]=i
break
输出：
5
97 39
34 37 656 97
186 75
68 16 539 186
137 49
48 17 461 137
98 59
6 30 524 98
46 18
7 11 9 46
我已经尝试了codereview，但还没有人回复。
答案 0 :(得分：14)
最多k+1步后，数组中的最后k+1个数字将为0...k（按某种顺序）。随后，序列是可预测的：m[i] = m[i-k-1]。因此，解决此问题的方法是执行k+1步骤的简单实现。然后你有一个包含2k+1元素的数组（第一个k是从随机序列生成的，另一个k+1来自迭代）。
现在，最后的k + 1个元素将无限重复。因此，您可以立即返回m[n]的结果：它是m[k + (n-k-1) % (k+1)]。
这是一些实现它的代码。
import collections
def initial_seq(k, a, b, c, r):
v = a
for _ in xrange(k):
yield v
v = (b * v + c) % r
def find_min(n, k, a, b, c, r):
m = [0] * (2 * k + 1)
for i, v in enumerate(initial_seq(k, a, b, c, r)):
m[i] = v
ks = range(k+1)
s = collections.Counter(m[:k])
for i in xrange(k, len(m)):
m[i] = next(j for j in ks if not s[j])
ks.remove(m[i])
s[m[i-k]] -= 1
return m[k + (n - k - 1) % (k + 1)]
print find_min(97, 39, 34, 37, 656, 97)
print find_min(186, 75, 68, 16, 539, 186)
print find_min(137, 49, 48, 17, 461, 137)
print find_min(1000000000, 100000, 48, 17, 461, 137)
这四个案例在我的机器上运行4秒钟，最后一个案例的可能性最大n。
答案 1 :(得分：12)
这是我的O（k）解决方案，它基于与上面相同的想法，但运行速度更快。
import os, sys
f = open(sys.argv[1], 'r')
T = int(f.readline())
def next(ary, start):
j = start
l = len(ary)
ret = start - 1
while j < l and ary[j]:
ret = j
j += 1
return ret
for t in range(T):
n, k = map(int, f.readline().strip().split(' '))
a, b, c, r = map(int, f.readline().strip().split(' '))
m = [0] * (4 * k)
s = [0] * (k+1)
m[0] = a
if m[0] <= k:
s[m[0]] = 1
for i in xrange(1, k):
m[i] = (b * m[i-1] + c) % r
if m[i] < k+1:
s[m[i]] += 1
p = next(s, 0)
m[k] = p + 1
p = next(s, p+2)
for i in xrange(k+1, n):
if m[i-k-1] > p or s[m[i-k-1]] > 1:
m[i] = p + 1
if m[i-k-1] <= k:
s[m[i-k-1]] -= 1
s[m[i]] += 1
p = next(s, p+2)
else:
m[i] = m[i-k-1]
if p == k:
break
if p != k:
print 'Case #%d: %d' % (t+1, m[n-1])
else:
print 'Case #%d: %d' % (t+1, m[i-k + (n-i+k+k) % (k+1)])
这里的关键点是，m [i]永远不会超过k，如果我们记住连续的数字，我们可以在从0到p的先前k个数字中找到，那么p将永远不会减少。
如果数m [i-k-1]大于p，那么显然我们应该将m [i]设置为p + 1，并且p将增加至少1.
如果数m [ik-1]小于或等于p，那么我们应该考虑m [ik：i]中是否存在相同的数字，否则，m [i]应该设置为等于m [ik- 1]，如果是，我们应该将m [i]设置为p + 1，就像“m [ik-1] -larger-than-p”一样。
每当p等于k，循环开始，循环大小为（k + 1），所以我们可以跳出计算并立即打印出答案。
答案 2 :(得分：0)
我通过添加地图来增强性能。
import sys, os
import collections
def min(str1, str2):
para1 = str1.split()
para2 = str2.split()
n = int(para1[0])
k = int(para1[1])
a = int(para2[0])
b = int(para2[1])
c = int(para2[2])
r = int(para2[3])
m = [0] * (2*k+1)
m[0] = a
s = collections.Counter()
s[a] += 1
rs = {}
for i in range(k+1):
rs[i] = 1
for i in xrange(1,k):
v = (b * m[i - 1] + c) % r
m[i] = v
s[v] += 1
if v < k:
if v in rs:
rs[v] -= 1
if rs[v] == 0:
del rs[v]
for j in xrange(0,k+1):
for t in rs:
if not s[t]:
m[k+j] = t
if m[j] < k:
if m[j] in rs:
rs[m[j]] += 1
else:
rs[m[j]] = 0
rs[t] -= 1
if rs[t] == 0:
del rs[t]
s[t] = 1
break
s[m[j]] -= 1
return m[k + ((n-k-1)%(k+1))]
if __name__=='__main__':
lines = []
user_input = raw_input()
num = int(user_input)
for i in xrange(num):
input1 = raw_input()
input2 = raw_input()
print "Case #%s: %s"%(i+1, min(input1, input2))