solution(cpp,java): Problems 1425 and 238

238. Product of Array Except Self
- C++

1425. Constrained Subsequence Sum
- C++
- Java

Author: godkingjay

Hard/1425. Constrained Subsequence Sum/sol.cpp

@@ -0,0 +1,30 @@
+#include <iostream>
+#include <vector>
+#include <deque>
+#include <algorithm>
+using namespace std;
+
+class Solution
+{
+public:
+    int constrainedSubsetSum(vector<int> &nums, int k)
+    {
+        vector<int> dp(nums);
+        deque<int> q;
+        q.push_back(0);
+        for (int i = 1; i < nums.size(); i++)
+        {
+            while (!q.empty() && q.back() < i - k)
+            {
+                q.pop_back();
+            }
+            dp[i] = max(dp[i], dp[q.back()] + nums[i]);
+            while (!q.empty() && dp[q.front()] <= dp[i])
+            {
+                q.pop_front();
+            }
+            q.push_front(i);
+        }
+        return *max_element(dp.begin(), dp.end());
+    }
+};

Hard/1425. Constrained Subsequence Sum/sol.java

@@ -0,0 +1,29 @@
+import java.util.Arrays;
+
+public class sol {
+    public static void main(String[] args) {
+        // call the fn here
+    }
+    class Solution {
+        public int constrainedSubsetSum(int[] nums, int k) {
+            int[] dp = Arrays.copyOf(nums, nums.length);
+            Deque<Integer> q = new ArrayDeque<>();
+            q.offerLast(0);
+            for (int i = 1; i < nums.length; i++) {
+                while (!q.isEmpty() && q.peekLast() < i - k) {
+                    q.pollLast();
+                }
+                dp[i] = Math.max(dp[i], dp[q.peekLast()] + nums[i]);
+                while (!q.isEmpty() && dp[q.peekFirst()] <= dp[i]) {
+                    q.pollFirst();
+                }
+                q.offerFirst(i);
+            }
+            int max = Integer.MIN_VALUE;
+            for (int num : dp) {
+                max = Math.max(max, num);
+            }
+            return max;
+        }
+    }
+}

Hard/1425. Constrained Subsequence Sum/sol.md

@@ -0,0 +1,22 @@
+## Approach: Dynamic Programming with Deque
+
+### Intuition
+
+To find the maximum sum of a non-empty subsequence, we can use dynamic programming (DP). We define `dp[i]` as the maximum sum of a non-empty subsequence of `nums[:i+1]`. The result we seek is the maximum value in the `dp` array. Initially, we can compute `dp[i]` using the recurrence `dp[i] = nums[i] + max(dp[i-k], dp[i-k+1], ..., dp[i-1])`. However, this approach would be too slow and result in a Time Limit Exceeded (TLE) error. To optimize it, we use a deque data structure to keep track of the maximum value within a sliding window.
+
+### Algorithm
+
+1. Initialize a deque `q` to store indices.
+2. Create a `dp` array with the same length as `nums` and initialize it with the values of `nums`.
+3. Iterate through the `nums` array from left to right (index `i` from 1 to `nums.size()`):
+   - While the deque `q` is not empty and the index at the back of `q` is out of the window of size `k`, pop the back element from `q`.
+   - While the deque is not empty and the `dp` value at the front index of `q` is smaller than `dp[i]`, pop the front element from `q`.
+   - Append the current `dp[i]` value to the deque `q`.
+   - Update `dp[i]` by taking the maximum between its current value and `dp[q[0]] + nums[i]`. This step captures the idea of maximizing the subsequence sum while adhering to the constraint.
+4. After the loop, the result is the maximum value in the `dp` array, which can be found using the `max_element` function.
+5. Return the result as the answer.
+
+### Complexity
+
+- Time complexity: O(N) where N is the length of the `nums` array.
+- Space complexity: O(K), where K is the constraint that limits the size of the deque.

Medium/238. Product of Array Except Self/sol.cpp

@@ -0,0 +1,51 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+class Solution
+{
+public:
+    vector<int> productExceptSelf(vector<int> &nums)
+    {
+        vector<int> answer;
+        int m = 1;
+        int m1 = 1;
+        int count = 0;
+        for (int i = 0; i < nums.size(); i++)
+        {
+            answer.push_back(nums[i]);
+            if (nums[i] != 0)
+            {
+                m = m * nums[i];
+                m1 = m1 * nums[i];
+            }
+            else
+            {
+                m = m * nums[i];
+                count++;
+            }
+        }
+        for (int i = 0; i < nums.size(); i++)
+        {
+            if (count > 1)
+            {
+                answer[i] = 0;
+            }
+            else if (nums[i] == 0)
+            {
+                answer[i] = m1;
+            }
+            else
+                answer[i] = m / nums[i];
+        }
+        return answer;
+    }
+};
+
+int main()
+{
+
+    // call the fn here
+    return 0;
+}

Medium/238. Product of Array Except Self/sol.md

@@ -0,0 +1,26 @@
+## Solution
+
+The provided solution is implemented in C++ and uses two passes through the `nums` array to calculate the `answer` vector without using division.
+
+1. **Initialization**:
+   - Initialize an empty vector `answer`.
+   - Initialize two variables `m` and `m1` to 1, which will be used to track the product of non-zero elements and all elements, respectively.
+   - Initialize a variable `count` to keep track of the number of zeros in the array.
+
+2. **First Pass**:
+   - Iterate through the `nums` array.
+   - For each element `nums[i]`, add it to the `answer` vector.
+   - Update `m` and `m1` by multiplying them with the current element `nums[i]`.
+   - If the current element is 0, increment the `count` variable.
+
+3. **Second Pass**:
+   - Iterate through the `nums` array again.
+   - For each element at index `i`, calculate the value for `answer[i]` based on the following conditions:
+     - If `count` is greater than 1 (meaning there are more than one zero in the array), set `answer[i]` to 0 because the product of all elements would be 0.
+     - If `nums[i]` is 0, set `answer[i]` to `m1`. This is because the product of all elements except the zero element is equal to `m1`.
+     - Otherwise, set `answer[i]` to the result of dividing `m` by `nums[i`, which effectively gives the product of all elements except the current one.
+
+4. **Return**:
+   - Return the `answer` vector, which contains the desired result.
+
+The provided solution correctly handles different cases and satisfies the O(n) time complexity constraint, but it uses O(n) extra space to store the `answer` vector. Achieving O(1) extra space complexity would require a different approach, such as using prefix and suffix products with careful computation.