Can you suggest a LeetCode Medium problem similar to permutations using dynamic programming?

A LeetCode Medium problem that is conceptually similar to finding permutations using dynamic programming is the "Partition Equal Subset Sum" problem (LeetCode Problem 416). This problem requires using a subset of numbers to achieve a certain target sum, which shares similarities with dynamic programming strategies needed for permutations where you build up solutions incrementally.

Problem Statement:

You are given a list of positive integers nums. Determine if you can partition the list into two subsets such that the sum of the elements in both subsets is equal.

Solution Approach:

To decide if the list can be partitioned into two subsets with equal sum, the total sum of the elements in nums needs to be even (since only then can it be divided into two equal parts). Let's denote this target sum as S = sum(nums) / 2. The task is then to find if there exists a subset of nums that sums to S.

Here’s a detailed explanation of the dynamic programming approach:

1. State Definition: Define a boolean DP array dp where dp[i] will indicate if a subset with sum i can be formed using elements from nums.

2. Initial State: dp[0] = True because a subset sum of 0 can always be achieved with an empty subset.

3. State Transition: Iterate through each number in nums and update the DP array backward (from S down to the number). This is done to prevent overwriting results of the previous iteration, thereby maintaining valid answers.

   For each number num in the list, update the DP table as follows:

   for num in nums:
       for i in range(S, num - 1, -1):
           dp[i] = dp[i] or dp[i - num]
   

   This process uses the property that if a subset sum i - num can be achieved (dp[i - num] is True), then a subset sum i can also be achieved by including num.

4. Final Check: After processing all elements, check dp[S]. If it is True, it indicates a subset with the sum S can be formed, thus implying the original set can be partitioned into two subsets of equal sum.

Example:

Suppose nums = [1, 5, 11, 5].

1. Total sum = 22, which is even, so the target S = 11.
2. Initialize dp = [True, False, ..., False] of length 12 (0 to 11).
3. For num = 1, update: dp[1] becomes True.
4. For num = 5, update: dp[6] and dp[5] become True.
5. For num = 11, update: dp[11] becomes True, which means a subset sum of 11 is possible.

Finally, because dp[11] is True, the input list can indeed be partitioned into subsets of equal sum.

This dynamic programming approach efficiently determines the possibility of partitioning within O(n*S) time complexity where n is the number of elements in nums and S is half the total sum, making it a typical dynamic programming problem akin to permutation considerations.