算法题-相加为目标数之和（两数之和、三数之和、从数组中取n个数相加为m（不可重复取）、从数组中取任意个数相加为m（可重复取））

function threeSum(num) {
	num.sort((a, b) => a - b)
	let len = num.length
	let res = []
	if (len < 3) {
		return res
	}
	for (let i = 0; i < len - 2; i++) {
		while (num[i] == num[i - 1]) {
			i++
		}
		let left = i + 1, right = len - 1
		while (left < right) {
			let sum = num[i] + num[left] + num[right]
			if (sum === 0) {
				res.push([num[i], num[left], num[right]])
				right--
				left++
				while (num[left] == num[left - 1]) {
					left++
				}
				while (num[right] == num[right + 1]) {
					right--
				}
			} else if (sum < 0) {
				left++
			} else {
				right--
			}
		}
	}
	return res
}

从数组中取n个数相加为m（不可重复取）

请用算法实现，从给定的不重复的数组中，取出n个数，使其相加和为m，如：

let arr = [1, 4, 7, 11, 9, 8, 10, 6]
let n = 3
let m = 27
Result:
[[7,11,9],[11,10,6],[9,8,10]]

解析

注意该题答案不能直接用于上题三数之和，因为给的数组是不重复的，当nums([-2,0,0,2,2],3,0)会返回[[-2,0,2],[-2,0,2]]。得到重复的答案。

核心思想

把n个数和拆为n-1个数和与剩余的一个数。

backtrace(start)表示从start-length-1的nums数组中选n为数和为m。

stack数组中为已经选取了的数。

剩余的这个数可能是每一位，故for循环将数组的每一位放入stack中调用backtrace函数，由于每次将一位放入了数组，故需要取出（这里注意的是递归中每次也会调用push和pop，所以for循环时，最外层每次的stack数组会为空）。

最后寻找出口：当放入stack中的数为n-1时，表示只用寻找一个数了。

答案

function numsSum(nums, n, m) {
	if (!nums.length || nums.length < n) return [];
	nums.sort((a, b) => a - b)
	const result = [];
	const stack = []
	const backtrace = (start) => {
		if (stack.length === n - 1) {
			const temp = stack.reduce((acc, cur) => acc + cur);
			if(nums.slice(start).includes(m-temp)){
				result.push([...stack,m-temp])
			}
			return
		}
		for (let i = start; i < nums.length; i++) {
			stack.push(nums[i])
			backtrace(i + 1)
			stack.pop()
		}
	}
	backtrace(0)
	return result
}

从数组中取任意个数相加为m（可重复取）

从数组中选取任意个数的数可以重复相加为target，输出所有的组合，不要求组合中的顺序，

例如[1,2,3]，target=4,输出[[1,1,1,1],[1,1,2],[1,3],[2,2]]。

解析

注意是可重复选取，故可能存在重复的解，故最后需要去重。

核心思想

递归：

把n个数和拆为n-1个数和与剩余的一个数。

首先确定入参和出参，入参f(arr,target)，出参result数组。

确定上下层级的关系，f(arr,target)=选中的1位和剩下的n-1位返回的result的拼接数组即f(arr,target-arr[i])，i从0~length-1。

找出口，当target-arr[i]===0时，存入result中，大于0时不进行操作。

动态规划：

赋初始值：小于数组中最小值的，res解集为空，

找到res[i]下层之间的关系：res[i]=对数组的每一位进行循环(j)，如果res[i-arr[j]]的数组有解就将该解和arr[j]合并，还需要判断右直接等于arr[j]的也加入。

答案

方法一（递归）

function join(a, arr) {
	return arr.map(v => {
		v.push(a)
		return v
	})
}
function find(arr, target) {
	arr = arr.sort((a, b) => a - b).filter(v => v <= target)
	if (!arr.length) {
		return;
	}
	let result = []
	for (let i = 0; i < arr.length; i++) {
		if (target - arr[i] > 0) {
			result.push(...join(arr[i], find(arr, target - arr[i])))
		}
		if (target - arr[i] === 0) {
			result.push([arr[i]])
		}
	}
	return result
}
let result = find([1, 2, 3, 4], 6)
console.log([...new Set(result.map((v) => v.sort((a, b) => a - b).join('')))].map((v) => v.split('').map(v => Number(v))))

方法二（动态规划）

function find(arr, target) {
    function join(a, arr) {
        return JSON.parse(JSON.stringify(arr)).map(v => {
            v.push(a)
            return v
        })
    }
    let result = []
    arr = arr.sort((a, b) => a - b).filter(v => v <= target)
    for (let i = 0; i <= target; i++) {
        if (i < arr[0]) {
            result[i] = []
        } else {
            result[i] = []
            for (let j = 0; j < arr.length; j++) {
                if (i>arr[j] && result[i - arr[j]].length) {
                    result[i].push(...join(arr[j], result[i - arr[j]]))
                }
                if(i===arr[j]){
                    result[i].push([i])
                }

            }
        }
    }
    return [...new Set(result.pop().map((v)=>v.sort((a,b)=>a-b).join('')))].map((v)=>v.split('').map(v=>Number(v)))
}
console.log(find([2,3,4],6))