Added Rust solutions in 13_1-D_Dynamic_Programming

Author: mdmzfzl

13_1-D_Dynamic_Programming/11_Longest_Increasing_Subsequence/0300-longest-increasing-subsequence.rs

@@ -0,0 +1,40 @@
+/*
+Problem: LeetCode 300 - Longest Increasing Subsequence
+
+Key Idea:
+The key idea is to use dynamic programming to find the length of the longest increasing subsequence in the given array.
+
+Approach:
+1. Initialize a vector `dp` of the same length as the input vector `nums`, all initially set to 1.
+   - `dp[i]` will represent the length of the longest increasing subsequence ending at index `i`.
+   - Initialize it to 1 because a single element is always a valid subsequence.
+2. Iterate through the input vector `nums` from the second element to the end.
+3. For each element `nums[i]`, iterate through the elements from the start to index `i - 1`:
+   - For each element `nums[j]`, if `nums[i]` is greater than `nums[j]`, update `dp[i]` to the maximum of `dp[i]` and `dp[j] + 1`.
+   - This means that if we can extend an increasing subsequence ending at index `j` with `nums[i]`, we update the length of the increasing subsequence ending at index `i`.
+4. After the iteration, the maximum value in the `dp` vector will be the length of the longest increasing subsequence.
+5. Return this maximum value as the result.
+
+Time Complexity:
+O(n^2), where `n` is the length of the input vector `nums`. We have nested loops for each element.
+
+Space Complexity:
+O(n), as we use a vector of size `n` to store the dynamic programming values.
+*/
+
+impl Solution {
+    pub fn length_of_lis(nums: Vec<i32>) -> i32 {
+        let n = nums.len();
+        let mut dp = vec![1; n];
+        
+        for i in 1..n {
+            for j in 0..i {
+                if nums[i] > nums[j] {
+                    dp[i] = dp[i].max(dp[j] + 1);
+                }
+            }
+        }
+        
+        dp.iter().cloned().max().unwrap_or(0)
+    }
+}

13_1-D_Dynamic_Programming/12_Partition_Equal_Subset_Sum/0416-partition-equal-subset-sum.rs

@@ -0,0 +1,45 @@
+/*
+Problem: LeetCode 416 - Partition Equal Subset Sum
+
+Key Idea:
+The key idea is to use dynamic programming to determine if it's possible to partition the input array into two subsets with equal sums.
+
+Approach:
+1. Calculate the sum of all elements in the input array `nums` and store it in a variable `total_sum`.
+2. If the total sum is odd, it's impossible to partition the array into two subsets with equal sums. Return `false` in this case.
+3. Otherwise, initialize a boolean vector `dp` of size `total_sum / 2 + 1`, where `dp[i]` represents whether it's possible to form a subset with a sum of `i`.
+   - Initialize `dp[0]` to `true` because an empty subset has a sum of 0.
+4. Iterate through the elements of the input array `nums`:
+   - For each element `num`, iterate through the `dp` vector in reverse order from `total_sum / 2` down to `num`.
+   - Update `dp[i]` to `true` if either `dp[i]` is already `true` or `dp[i - num]` is `true`. This means we can form a subset with a sum of `i` by either not including the current `num` or including it.
+5. After the iteration, if `dp[total_sum / 2]` is `true`, it's possible to partition the array into two subsets with equal sums; otherwise, it's not possible.
+6. Return `dp[total_sum / 2]` as the result.
+
+Time Complexity:
+O(n * sum), where `n` is the number of elements in the input array `nums`, and `sum` is the sum of all elements in the array. We fill in the `dp` table with a nested loop.
+
+Space Complexity:
+O(sum / 2), as we use a boolean vector of size `total_sum / 2 + 1` to store the dynamic programming values.
+*/
+
+impl Solution {
+    pub fn can_partition(nums: Vec<i32>) -> bool {
+        let total_sum: i32 = nums.iter().sum();
+        
+        if total_sum % 2 != 0 {
+            return false;
+        }
+        
+        let target_sum = (total_sum / 2) as usize;
+        let mut dp = vec![false; target_sum + 1];
+        dp[0] = true;
+        
+        for &num in nums.iter() {
+            for i in (num as usize..=target_sum).rev() {
+                dp[i] = dp[i] || dp[i - num as usize];
+            }
+        }
+        
+        dp[target_sum]
+    }
+}