1、将数组切分为两个和相等的子数组

【题意】：给定一个数组nums（仅包含正整数），将这个数组切分为两个子数组，使得这两个子数组的和相等。若能完成上述切分，返回True，否则返回False；

【总思路】：

0-1背包，和“将数组切分为两个和相等的子数组”想法一样；
先初始化一个数组 dp，数组长度为输入数组的累加和， dp[i] = 0表示不存在几个数相加和为 i，存在则为 1 ；
若每个元素只能用一次，那么尝试放每一个元素时都要避免其他元素的干扰，所以从最大的值开始，所以先排序；
具体：对数组 nums = [1,5,11,5] 中的每一个 n ，有dp[n] = 1；
比如：n = 5，i=11，dp[11] = 1有两种情况，一种是数组中存在一个值为11，或者对于 n = 5,如果有 dp[i-n] = 1,即 dp[6] = 1,
那么dp[11]还可以由dp[5]+dp[6]得到（因为5+6=11）；当然了，dp[6]可以由dp[5]+dp[1]得到；

思路1：用dp[i]来存储和为i的组合个数

先进行数学分析，设子集为A、B，则有sum(A)+sum(B)=sum(nums),sum(A)=sum(B)，则有sum(A)=sum(nums)/2。故可以将题目转化为从nums中寻找是否有和为sum(nums)/2的子集，有则返回True，否则返回False。

寻找和为sum(nums)/2的子集，可以使用动态规划的思路。用dp[i]来存储和为i的组合个数，对nums里边的数字用n进行遍历，对于所有i>=n的i，有dp[i]=dp[i]+dp[i-n]。

转自：

class Solution(object):
    def canPartition(self, nums):
        """
        :type nums: List[int]
        :rtype: bool
        """
        if nums==[]:
            return True
        if sum(nums)%2==1:
            return False
        target = sum(nums)//2
        print (target)
        dp = [0]*(target+1)
        dp[0] = 1
        for n in nums:
            i = target
            while(i>=n):
                dp[i] = dp[i]+dp[i-n]
                i = i-1
        print(dp)
        if dp[target]>=2:
            return True
        else:
            return False
w = Solution()

nums = [1,5,11,5]
w.canPartition(nums)

 输出：

11
[1, 1, 0, 0, 0, 2, 2, 0, 0, 0, 1, 2]

思路2：：dp存的是是否存在和为 i 的子数组

 

/*
    * 思路：一个背包的题目，背包容量为数组中元素和的一半＋１，
    * 这样只要看是否有元素可以正好填满背包即可．
    * 但是每个元素只能用一次，所以在尝试放一个元素的时候还要避免他对尝试放其他位置时对自己的影响．
    * 所以在尝试放一个元素到背包的时候需要从容量最大的位置开始，如果（当前位置－当前元素大小）位置可以通过放置之前的元素达到，
    * 则当前位置也可以通过放置当前元素正好达到这个位置．状态转移方程为：dp[i] = dp[i] || dp[i - nums[k]];
    * */
    public static boolean canPartition(int[] nums) {
        int sum = computeArraySum(nums);
        if (sum % 2 != 0) {
            return false;
        }
        int W = sum / 2;
        boolean[] dp = new boolean[W + 1];
        dp[0] = true;
        Arrays.sort(nums);
        for (int num : nums) {                 // 0-1 背包一个物品只能用一次
            for (int i = W; i >= num; i--) {   // 从后往前，先计算 dp[i] 再计算 dp[i-num]
                dp[i] = dp[i] || dp[i - num];
            }
        }
        return dp[W];
    }

    private static int computeArraySum(int[] nums) {
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        return sum;
    }

2、延伸：满减优惠

'''

输入：
5 20
18 19 17 6 7

输出：
23

解析：【都只点一份】
第一行：5:表示菜品数，20：表示满20元可以参与满减优惠；
第二行：5个菜品的价格
'''

import sys
ns = sys.stdin.readline().strip().split()
n = int(ns[0])
s = int(ns[1])
data = sys.stdin.readline().strip().split()
data = [int(d) for d in data]

data.sort()
allsum = sum(data)
dp = [0 for _ in range(allsum+1)]

if allsum < s:
   print(-1)
else:
   dp[0] = 1
   for i in range(n):
      for j in range(allsum,data[i]-1,-1):
         dp[j]  = dp[j] | dp[j-data[i]]
   for i in range(s,allsum+1):
      if dp[i]:
         print(i)
         break