python-字符串算法问题（二）

回溯算法-排列

---

一、排列

给定一个 没有重复数字的序列[1,2,3,4]，返回下面形式所有可能的全排列
[[1,2,3,4],…,]
方法1：使用python中的库方法，得到序列所有可能的排列（返回的是元组）然后转换成列表增加在一个新的列表中。

from itertools import permutations
def permute(arr):
	ret = []
	mm = permutations(arr)
	for m in mm:
		ret.append(list(m))
	return ret

方法2：使用回溯法，待排列序列[1,2,3,4]可以看成是1+permute([2,3,4] ，同理还可以把1依

次换成2,3,4，对于子序列[2,3,4]同样分解。求解的时候是将它们分解了，但是需要注意函数

返回的需要是一个组合在一起的序列，因此需要一个列表把每次分解的元素加入。根据代码

更好的理解

def permute(arr):
	n = len(arr)
	ret = []
	def add(arr,temp):
		# 分解为空的时候，此时temp里面会记录依次被分解掉的元素。
		if not arr:
			ret.append(temp)
			return 
		# 用第二个参数temp记录分解掉的元素，当分解到空集时候，用temp可以用来回溯效果。
		for i in range(n):
			add(arr[:i]+add[i+1:],temp+[arr[i]])
	add(arr,[])
	return ret

注意：对于一个字符串排列的情况，可以给上述的add(arr,’’)函数传入一个空字符串

二、子集

给你一个整数数组 nums =[1,2,3]，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集不能包含重复的子集。你可以按 任意顺序返回解集：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]。

分析：这个问题是每次分解出来的都需要立刻加入到解集中，对于任一元素，都可以与其他元素组成一个子集。这个需要记录每个元素的下标，不是一个组合问题，需要一个一个的进行分解

def subSet(arr):
	n = len(arr)
	ret = []
	def add(index,temp)
		# 每次进来就要加入
		ret.append(temp)
		for i in range(n):
			# 需要的是记录下标位置，依次加入的temp列表中。
			add(i+1, temp + [arr[i]]
	add(0,[])
	return ret

三、排序与双指针

1、三数之和

给你一个包含 n 个整数的数组arr，判断arr 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。
①三层循环，可以找到和为零的组合，但是有可能会产生重复。
②针对排序数组，看成b+c=-a问题，依次遍历赋值给a，然后通过两个首尾指针调整大小。

def three_sum(arr):
	if not arr:
		return []
	ret = []
	arr.sort()
	n = len(arr)
	for i in range(n):
		# 去重 ，保证和上一次枚举的不一样
		if i > 0 and arr[i] == arr[i-1] :
			continue
		target = -arr[i]
		# 固定第二个数，但是对于第二个每个后面的数，第三个数不是从最后开始的，就从上一次那个位置开始即可,但是对于不同的i值，第三个数都要从后面开始
		k = n - 1
		for j in range(i,n):
			if j > 1+i and arr[j] == arr[j-1]:
				continue
			while k > j and arr[j] + arr[k] > target:
				k -= 1
			# 找到一个就跳出
			if k == j: # 当前的j和后面的j都不可能了
				break
			elif arr[j] + arr[k] == target:
				ret.append([arr[i],arr[j],arr[k]])
	return ret	

2、最接近的三数之和

给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。
同样的道理通过排序和双指针，遍历第一个值，移动后面两个指针并每次记录最接近的那个和值。

def three_sum_closest(nums,target):
	n = len(nums)
	best_sum = float(1e4)
	nums.sort()
	for i in range(n):
		# 因为第一个是相当于固定一个一个遍历，所以相同的就没必要再进行下面的循环了
		if i > 0 and nums[i] == num[i-1]:
			continue
		# 同样，后面的两个数每次都要‘从头’开始
		j,k = i+1, n-1
		while j < k:
			s = nums[i] + nums[j] + nums[k]
			if s == target:
				return s
			# 不和目标相等就要记录下来
			if abs(s - target) <= abs(best_sum - target):
				best_sum = s
			if s > target :
				k -= 1
				# 这个时候需要去重,k已经减过一次，当前和上次比较
				while k > j and nums[k] == nums[k+1]:
					k -= 1
			else:
				j += 1 
				while j < k and nums[j] == nums[j-1]:
					j += 1
	 return best_sum