Introduction

In this blog post, we will explore how to solve the LeetCode problem "3177" 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 an integer array nums and a non-negative integer k. A sequence of integers seq is called good if there are at most k indices i in the range [0, seq.length - 2] such that seq[i] != seq[i + 1]. Return the maximum possible length of a good subsequence of nums. Example 1: Input: nums = [1,2,1,1,3], k = 2 Output: 4 Explanation: The maximum length subsequence is [1,2,1,1,3]. Example 2: Input: nums = [1,2,3,4,5,1], k = 0 Output: 2 Explanation: The maximum length subsequence is [1,2,3,4,5,1]. Constraints: 1 <= nums.length <= 5 * 103 1 <= nums[i] <= 109 0 <= k <= min(50, nums.length)

Explanation

Here's the approach to solve this problem:

• Dynamic Programming: We can use dynamic programming to solve this problem. The state dp[i][j] represents the maximum length of a good subsequence ending at index i with j differences.
• Transitions: For each element nums[i], we can either include it in our subsequence or not. If we include it, we iterate through all previous elements nums[l] and check if nums[i] is equal to nums[l]. If they are equal, we don't increase the difference count j. Otherwise, we increment j.

• Optimization: To avoid unnecessary calculations and optimize for performance, we only consider previous elements that are already part of a "good" subsequence.

• Runtime & Storage Complexity: O(n^2 k), O(n k)

def solve():
    n, k = map(int, input().split())
    nums = list(map(int, input().split()))

    dp = {}

    def get_max_len(idx, diff_count):
        if idx == n:
            return 0

        if (idx, diff_count) in dp:
            return dp[(idx, diff_count)]

        # Option 1: Exclude nums[idx]
        max_len = get_max_len(idx + 1, diff_count)

        # Option 2: Include nums[idx]
        include_len = 1
        best_prev_len = 0
        for prev_idx in range(idx):
            prev_len = get_max_len(prev_idx + 1, diff_count) -1

            prev_val = nums[prev_idx]

            new_diff_count = diff_count

            if idx>0 and prev_idx >= 0 and prev_len >=0:

              temp_diff = 0
              temp_diff = (nums[idx] != nums[prev_idx])

              if new_diff_count + temp_diff <= k:

                new_diff_count = new_diff_count + temp_diff

                curr_len = 1 + prev_len

                best_prev_len = max(best_prev_len, curr_len)

        include_len += best_prev_len

        max_len = max(max_len, include_len)
        dp[(idx, diff_count)] = max_len
        return max_len

    print(get_max_len(0, 0))


def solve_optimized():
    n, k = map(int, input().split())
    nums = list(map(int, input().split()))

    dp = [[0] * (k + 1) for _ in range(n + 1)]

    for i in range(1, n + 1):
        for j in range(k + 1):
            # Exclude nums[i-1]
            dp[i][j] = dp[i - 1][j]

            # Include nums[i-1]
            for l in range(i - 1):
                diff = (nums[i - 1] != nums[l])
                if j >= diff:
                    dp[i][j] = max(dp[i][j], dp[l + 1][j - diff] + 1)
            dp[i][j] = max(dp[i][j], 1)

    ans = 0
    for j in range(k + 1):
        ans = max(ans, dp[n][j])

    print(ans)


    # Code
    ```python
    n, k = map(int, input().split())nums = list(map(int, input().split()))

dp = [[0] * (k + 1) for _ in range(len(nums) + 1)]

for i in range(1, len(nums) + 1):
    for j in range(k + 1):
        dp[i][j] = dp[i - 1][j] 
        for l in range(i - 1):
            diff = (nums[i - 1] != nums[l])
            if j >= diff:
                dp[i][j] = max(dp[i][j], dp[l + 1][j - diff] + 1)
        dp[i][j] = max(dp[i][j], 1)

ans = 0
for j in range(k + 1):
    ans = max(ans, dp[len(nums)][j])

print(ans)