Python实现在给定整数序列中找到和为100的所有数字组合
摘要： 使用Python在给定整数序列中找到和为100的所有数字组合。可以学习贪婪算法及递归技巧。
难度： 初级
问题
给定一个整数序列，要求将这些整数的和尽可能拼成 100。
比如 [17, 17, 4, 20, 1, 20, 17, 6, 18, 17, 12, 11, 10, 7, 19, 6, 16, 5, 6, 21, 22, 21, 10, 1, 10, 12, 5, 10, 6, 18] , 其中一个解是 [ [17, 17, 4, 20, 1, 17, 6, 18] [20, 18, 17, 12, 11, 10, 6, 6] [7, 19, 16, 5, 6, 21, 10, 1, 5, 10] ] , 没有用到的数字是 [12, 10, 21, 22]
累加性的序列问题，通常可以使用动态规划法。不过这个略有不同，因为和为 sum 与 和为 sum-1 的解基本没有联系； 此题将使用贪心算法，每次总是根据当下找到一个数字组合来拼成 100 ， 而不顾及使用的数字对后面拼100 造成的影响；因为不会穷尽所有可行解集合，所以不确保一定是最优解（未使用的数字最少）。
算法设计
STEP1: 从序列 origin 中取出一个数 NUM ;
STEP2: 在剩下的数中寻找和为 100 - NUM 的数字组合 matched = m1,m2,..., mN ；
A. 如果找到， 那么在 origin 中移除 NUM 和 matched , 将 [matched, NUM] 加入匹配解集合 finalResults, 然后跳转到 STEP3 ;
B. 如果没有找到， 将 NUM 加入未匹配序列 unMatched, 跳转到 STEP3 ;
STEP3: 检测 origin 是否还有元素； 如果还有元素， 跳转到 STEP1 ; 否则跳转到 STEP4
STEP4: 退出算法。
注意到这里需要一个函数 matchSum，实现以下功能： 给定一个数字 sum 及一个序列 seq， 如果能够在 seq 中找到和为 sum 的数字组合 matched，则返回 (True, matched) ; 否则返回 (False, []) . 这个函数可以递归实现。递归的三要素是： (解结构，终止条件， 递归方式)。如果解结构是一个无序序列，那么可以直接将解结构传入递归函数，在递归函数中逐步添加解结构的组成元素； 如果解结构是有序序列，则要注意递归添加解元素确保其顺序。
A0. 设置解结构 matched , 传入递归函数 matchSum(sum, seq, matched) , 在递归调用 matchSum 的过程中在 matched 中添加解元素；
A1. 规定终止条件。通常就是最简单的情况，为空或只有一个元素。
a1. 如果 sum > 0 , seq 为空，那么必然不存在匹配，返回 False；
a2. 如果 sum > 0, seq 仅含有一个数字， 且 seq[0] != sum, 那么仍然不存在匹配，返回 False ;
a3. 如果 sum > 0, seq 仅含有一个数字， 且 seq[0] == sum, 那么存在匹配，将 seq[0] 加入 matched, 返回 True;
A2. 设置递归方式。 seq 非空， 且含有两个及以上元素，该如何递归呢？ 可以将 sum 与 seq[0] 比较，分情况讨论：
a1. 如果 sum < seq[0] , 那么很显然 sum 只能在除去 seq[0] 之外的序列 seq[1:] 中寻找匹配了： matchSum(sum, seq, prematched) = matchSum(sum, seq[1:], prematched) ;
a2. 如果 sum == seq[0] , 那么很显然找到了一个匹配， 可以直接返回： matchSum(sum, seq, prematched) = seq[0] + prematched ; 注意到， seq[0] 并不一定是指初始序列的第一个值，而是指在递归过程中获取到的当前序列的第一个值，而 prematched 在之前的递归过程中可能已经填充部分数字了；
a3. 如果 sum > seq[0]，就分两种情况，要么匹配结果包含 seq[0], 为 seq[0] + matchSum(sum-seq[0], seq[1:], prematched) ; 要么匹配结果不包含 seq[0], 为 matchSum(sum, seq[1:], prematched) .
解结构是一个列表，每个列表元素是一个小的列表，其元素之和为 100 ; 比如 [[54,36,10], [32, 63, 5], [24, 20, 34, 6, 12, 4]] , 未匹配数字为 [16, 20, 32] ;
更优的解法
在算法结束时，很可能存在未匹配数字组合。尤其是当所有整数的和不能除尽100时。
将拼成100的数字组合中的数字替换成未匹配数字的组合，可以减少未匹配数字的数量。比如解结构里的一个元素是 [54, 36, 10] , 未匹配数字为 [16, 20, 32] , 那么可以将 36 与 16, 20 替换。
更多的解法： 将解结构的子列表中的大数字与小数字组合交换，即可得到新的解法，比如将 54 与 (20,34) ， 10 与 (6,4) , 32 与 (20,12) 交换。
这些都会用到 matchSum(sum, seq, matched) ， 可以说这个函数是核心而基本的组件。通过这个组件可以衍生出各种的方法和解法。这就像业务开发中的基础接口，通过基础接口的叠加可以衍生出多样灵活的业务。
应对大数据量： 当序列中数字比较多，且远小于要拼成的和时，就会出现递归深度很深的问题。Python 中有递归深度的限制。一种方法是提高递归深度设置；一种是将递归改写成非递归；一种是分治法，将大数字拆解为较小数字之和，在序列中先寻找较小数字的解结构，然后再拼接出最终的解结构。问题是，较小数字的选取很难确定，因为序列中可能根本不存在和为某一个较小数字的数字组合。
使用非递归方式， 可以考虑预排序。如果预排序可以使得后续处理更快速，那么算法复杂度就可能是 O(nlogn)； 可以仍然按照之前的算法流程， 编写非递归的实现接口。注意到下面的实现是非优化的。取序列元素，只要和小于指定数，就一直添加； 当和为指定数时，就可以输出解；而当和大于指定数时，要考虑回溯。下面的实现仅考虑了最简单的情形的处理， 比如，序列为 [12,13,14,14,16,18,18,20,20,20,21,...] ，要构造和为 76 ; 假设已经添加的元素为 [12,13,14,14,16] , sum = 69 ，还差 7 , 那么就用后面的序列中的数替换前面的数 [12,13,14,14,16] + 7 = [19, 20, 21, 21, 23] , 只要后面的序列存在这几个数之一，替换后就可以输出解，比如 [12,20,14,14,16] . 但后面的序列不存在这几个数，就不会输出解。要么添加逻辑严密的回溯算法，要么添加更完备的处理方法。
代码实现
import random import sys sys.setrecursionlimit(10000) UPLIMIT = 100000 NUMBERS = 500 NUMBER_RANGE = (1,UPLIMIT/4) def randNums(n): return [randGen(NUMBER_RANGE[0], NUMBER_RANGE[1]) for i in range(n)] def randGen(start, end): return random.randint(start, end) def solve(numlist): if UPLIMIT >= 10000 and NUMBERS >= 500: numlist.sort() (finalResults, unMatchedNums) = baseSolve(numlist, matchSumUnrec) else: (finalResults, unMatchedNums) = baseSolve(numlist, matchSum) improve(finalResults, unMatchedNums) return (finalResults, unMatchedNums) def baseSolve(numlist, matchSum): if not numlist or len(numlist) == 0: return ([],[]); finalResults = [] unMatchNums = [] while len(numlist) > 0: num = numlist.pop() matched = [] if matchSum(UPLIMIT-num, numlist, matched): removelist(numlist, matched) matched.append(num) finalResults.append(matched) else: unMatchNums.append(num) return (finalResults, unMatchNums) def removelist(origin, toberemoved): for e in toberemoved: if e in origin: origin.remove(e) def copylist(numlist): return [num for num in numlist] def matchSum(rest, restlist, prematched): if rest > 0 and len(restlist) == 0: return False if rest > 0 and len(restlist) == 1 and restlist[0] != rest: return False if rest > 0 and len(restlist) == 1 and restlist[0] == rest: prematched.append(restlist[0]) return True getone = restlist[0] if rest > getone: prematched.append(getone) if matchSum(rest-getone, restlist[1:], prematched): return True else: prematched.remove(getone) return matchSum(rest, restlist[1:], prematched) elif rest == getone: prematched.append(getone) return True; else: return matchSum(rest, restlist[1:], prematched) def matchSumUnrec(asum, sortedlist, matched): if asum > 0 and len(sortedlist) == 0: return False if asum > 0 and len(sortedlist) == 1 and sortedlist[0] != asum: return False if asum > 0 and len(sortedlist) == 1 and sortedlist[0] == asum: matched.append(sortedlist[0]) return True tmpsum = 0 ind = 0 size = len(sortedlist) while ind < size: num = sortedlist[ind] tmpsum += num if tmpsum < asum: matched.append(num) ind += 1 continue elif tmpsum == asum: matched.append(num) return True else: tmpsum -= num break need = asum - tmpsum tosearch = map(lambda x:x+need, matched) restlist = sortedlist[ind:] for e in tosearch: if e in restlist: matched.append(e) matched.remove(e-need) return True return False def improve(finalResults, unMatchedNums): for comb in finalResults: for num in comb: matched = [] if matchSum(num, unMatchedNums, matched) and len(matched) > 1: print 'Improved: ' , num, ' ', matched comb.remove(num) comb.extend(matched) unMatchedNums.append(num) for e in matched: unMatchedNums.remove(e) if len(unMatchedNums) == 0: return def printResult(finalResults, unMatchedNums, numlist): f_res = open('/tmp/res.txt', 'w') f_res.write('origin: ' + str(numlist) + '\n') f_res.write('averag: ' + str((float(sum(numlist))/len(numlist))) + '\n') f_res.write('solution: ') usedNums = 0 finalNumList = [] for comb in finalResults: f_res.write(str(comb) + ' ') assert sum(comb) == UPLIMIT usedNums += len(comb) finalNumList.extend(comb) finalNumList.extend(unMatchedNums) f_res.write('\nUnMatched Numbers: ' + str(unMatchedNums) + '\n') f_res.write('Used numbers: %s, UnMatched numbers: %d.\n' % (usedNums, len(unMatchedNums))) f_res.write('origin: %d , final: %d\n' % (len(numlist), len(finalNumList))) for e in finalNumList: numlist.remove(e) if len(numlist) > 0: f_res.write('Not Occurred numbers: ' + str(numlist)) f_res.close() def to100(numlist): newnumlist = copylist(numlist) (finalResults, unMatchedNums) = solve(newnumlist) newnumlist = copylist(numlist) printResult(finalResults, unMatchedNums, newnumlist) if __name__ == '__main__': to100(randNums(NUMBERS))
需要优化的地方：
将递归的 matchSum 改成非递归版本的 matchSumUnrec .
