Introduction

In this blog post, we will explore how to solve the LeetCode problem "2926" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like Chatmagic, we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

Problem Statement

You are given a 0-indexed integer array nums. A subsequence of nums having length k and consisting of indices i0 < i1 < ... < ik-1 is balanced if the following holds: nums[ij] - nums[ij-1] >= ij - ij-1, for every j in the range [1, k - 1]. A subsequence of nums having length 1 is considered balanced. Return an integer denoting the maximum possible sum of elements in a balanced subsequence of nums. A subsequence of an array is a new non-empty array that is formed from the original array by deleting some (possibly none) of the elements without disturbing the relative positions of the remaining elements. Example 1: Input: nums = [3,3,5,6] Output: 14 Explanation: In this example, the subsequence [3,5,6] consisting of indices 0, 2, and 3 can be selected. nums[2] - nums[0] >= 2 - 0. nums[3] - nums[2] >= 3 - 2. Hence, it is a balanced subsequence, and its sum is the maximum among the balanced subsequences of nums. The subsequence consisting of indices 1, 2, and 3 is also valid. It can be shown that it is not possible to get a balanced subsequence with a sum greater than 14. Example 2: Input: nums = [5,-1,-3,8] Output: 13 Explanation: In this example, the subsequence [5,8] consisting of indices 0 and 3 can be selected. nums[3] - nums[0] >= 3 - 0. Hence, it is a balanced subsequence, and its sum is the maximum among the balanced subsequences of nums. It can be shown that it is not possible to get a balanced subsequence with a sum greater than 13. Example 3: Input: nums = [-2,-1] Output: -1 Explanation: In this example, the subsequence [-1] can be selected. It is a balanced subsequence, and its sum is the maximum among the balanced subsequences of nums. Constraints: 1 <= nums.length <= 105 -109 <= nums[i] <= 109

Explanation

Here's the breakdown of the solution:

• Transform the problem: Rewrite the condition nums[j] - nums[i] >= j - i as nums[j] - j >= nums[i] - i. This allows us to focus on the values nums[i] - i.
• Dynamic Programming with Binary Indexed Tree (Fenwick Tree): Use dynamic programming to store the maximum sum of a balanced subsequence ending at each index. Optimize this DP by using a Fenwick Tree (BIT) to efficiently query the maximum DP value for elements less than or equal to nums[i] - i.

• Coordinate Compression: Since nums[i] - i can be very large, compress the distinct values of nums[i] - i to a smaller range to make the Fenwick Tree efficient.

• Runtime Complexity: O(N log N), where N is the length of nums.

• Storage Complexity: O(N)

Code

    class FenwickTree:
    def __init__(self, n):
        self.n = n
        self.tree = [float('-inf')] * (n + 1)  # Initialize with -inf

    def update(self, i, val):
        i += 1  # 1-based indexing
        while i <= self.n:
            self.tree[i] = max(self.tree[i], val)
            i += i & (-i)

    def query(self, i):
        i += 1  # 1-based indexing
        res = float('-inf')
        while i > 0:
            res = max(res, self.tree[i])
            i -= i & (-i)
        return res

def max_balanced_subsequence_sum(nums):
    n = len(nums)
    modified_nums = [nums[i] - i for i in range(n)]
    sorted_modified_nums = sorted(list(set(modified_nums)))
    index_map = {val: i for i, val in enumerate(sorted_modified_nums)}

    fenwick_tree = FenwickTree(len(sorted_modified_nums))
    dp = [0] * n

    for i in range(n):
        val = nums[i] - i
        idx = index_map[val]

        prev_max = fenwick_tree.query(idx)

        dp[i] = max(val + i, nums[i] + (prev_max if prev_max != float('-inf') else 0))  # Fix: dp[i] should be nums[i] + prev_max
        fenwick_tree.update(idx, dp[i] - (nums[i] - (nums[i]-i)))
        fenwick_tree.update(idx, dp[i]) # Original Submission has this line


    return max(dp) if dp else 0