[Swift]LeetCode416. 分割等和子集 | Partition Equal Subset Sum

原文地址：https://www.cnblogs.com/strengthen/p/10331729.html 

Given a non-empty array containing only positive integers, find if the array can be partitioned into two subsets such that the sum of elements in both subsets is equal.

Note:

1. Each of the array element will not exceed 100.
2. The array size will not exceed 200. 

Example 1:

Input: [1, 5, 11, 5]

Output: true

Explanation: The array can be partitioned as [1, 5, 5] and [11]. 

Example 2:

Input: [1, 2, 3, 5]

Output: false

Explanation: The array cannot be partitioned into equal sum subsets.

---

给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

注意:

1. 每个数组中的元素不会超过 100
2. 数组的大小不会超过 200

示例 1:

输入: [1, 5, 11, 5]

输出: true

解释: 数组可以分割成 [1, 5, 5] 和 [11]. 

示例 2:

输入: [1, 2, 3, 5]

输出: false

解释: 数组不能分割成两个元素和相等的子集.

---

32ms

class Solution {
    var mark = [String : Bool]()
    func canPartition(_ nums: [Int]) -> Bool {
        let count = nums.count
        var sum = 0
        for i in 0..<count {
            sum += nums[i]
        }
        
        if sum & 1 == 1 {
            return false
        }
        return reachTarget(nums, count, 0, sum / 2)
    }
    
    func reachTarget(_ nums: [Int], _ count: Int, _ index: Int, _ target: Int) -> Bool {
        let key = "(index),(target)"
        if let _ = mark[key] {
            return false
        }
        if target == 0 {
            return true
        } else if target < 0 {
            return false
        }
        if index == count {
            return false
        }
        
        if reachTarget(nums, count, index + 1, target - nums[index]) {
            return true
        }
        if reachTarget(nums, count, index + 1, target) {
            return true
        }
        
        mark[key] = false
        return false
    }
}

---

40ms

class Solution {
  func canPartition(_ nums: [Int]) -> Bool {
    var sum = 0
    for num in nums {
      sum += num
    }

    if sum % 2 == 1 {
      return false
    }
    let numsCount = nums.count
    let target = sum / 2
    let invalidArray = Array(repeating: false, count: target + 1)
    var invalidMatrix = Array(repeating: invalidArray, count: numsCount + 1)
    return helper(nums: nums, currentIndex: 0, target: target, invalidMatrix: &invalidMatrix)
  }

  func helper(nums: [Int], currentIndex: Int, target: Int, invalidMatrix: inout [[Bool]]) -> Bool {
    if invalidMatrix[currentIndex][target] {
      return false
    }

    let arrayCount = nums.count
    for i in currentIndex ..< arrayCount {
      let newTarget = target - nums[i]
      if newTarget == 0 {
        return true
      }
      if newTarget < 0 {
        break
      }

      if (i + 1) < arrayCount
        && helper(nums: nums, currentIndex: i + 1, target: newTarget, invalidMatrix: &invalidMatrix) {
        return true
      }
    }
    invalidMatrix[currentIndex][target] = true
    return false
  }
}

---

3456ms

class Solution {
    func canPartition(_ nums: [Int]) -> Bool {
        var sum:Int = nums.reduce(0, +)
        var target:Int = sum >> 1
        if (sum & 1) == 1 {return false}
        var dp:[Bool] = [Bool](repeating:false,count:target + 1)
        dp[0] = true
        for num in nums
        {
            if num > target {continue}
            for i in (num...target).reversed()
            {
                dp[i] = dp[i] || dp[i - num]
            }
        }
        return dp[target]
    }
}

---

3504ms

class Solution {
    func canPartition(_ nums: [Int]) -> Bool {
        var nums = nums
        if nums.count == 0 {
            return true
        }
        var sum = 0 
        nums = nums.sorted()
        for num in nums {
            sum += num
        }
        if sum % 2 != 0 {
            return false
        }
        sum = sum / 2
        if nums.last! > sum {
            return false
        }
        var dp = [Bool](repeating: false, count: sum + 1)
        dp[0] = true
        for i in 1...nums.count {
            for j in (nums[i - 1]...sum).reversed() {
                dp[j] = dp[j] || dp[j - nums[i - 1]]
            }
        }
        return dp[sum]
    }
}