Introduction

In this blog post, we will explore how to solve the LeetCode problem "1799" 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 nums, an array of positive integers of size 2 n. You must perform n operations on this array. In the ith operation (1-indexed), you will: Choose two elements, x and y. Receive a score of i gcd(x, y). Remove x and y from nums. Return the maximum score you can receive after performing n operations. The function gcd(x, y) is the greatest common divisor of x and y. Example 1: Input: nums = [1,2] Output: 1 Explanation: The optimal choice of operations is: (1 gcd(1, 2)) = 1 Example 2: Input: nums = [3,4,6,8] Output: 11 Explanation: The optimal choice of operations is: (1 gcd(3, 6)) + (2 gcd(4, 8)) = 3 + 8 = 11 Example 3: Input: nums = [1,2,3,4,5,6] Output: 14 Explanation: The optimal choice of operations is: (1 gcd(1, 5)) + (2 gcd(2, 4)) + (3 gcd(3, 6)) = 1 + 4 + 9 = 14 Constraints: 1 <= n <= 7 nums.length == 2 * n 1 <= nums[i] <= 106

Explanation

Here's the breakdown of the solution:

• Dynamic Programming with Bitmasking: Represent the state of nums using a bitmask, where each bit indicates whether a number has been removed. Use dynamic programming to explore all possible pairings and store the maximum score achievable for each state.
• GCD Optimization: Precompute the GCD of all possible pairs of numbers in nums to avoid redundant calculations within the dynamic programming loop.

• Memoization: Store the results of subproblems (maximum score for a given state) to avoid recomputation, significantly improving efficiency.

• Runtime Complexity: O(n² * 2²ⁿ), Storage Complexity: O(2²ⁿ + n²)

Code

    import math

def max_score(nums):
    n = len(nums) // 2
    memo = {}
    gcd_matrix = {}

    def gcd(a, b):
        if (a, b) in gcd_matrix:
            return gcd_matrix[(a, b)]
        if b == 0:
            gcd_matrix[(a, b)] = a
            gcd_matrix[(b, a)] = a
            return a
        gcd_matrix[(a, b)] = gcd(b, a % b)
        gcd_matrix[(b, a)] = gcd_matrix[(a, b)]
        return gcd_matrix[(a, b)]

    def solve(mask, op):
        if op > n:
            return 0
        if (mask, op) in memo:
            return memo[(mask, op)]

        max_score_val = 0
        for i in range(2 * n):
            if (mask >> i) & 1 == 0:
                for j in range(i + 1, 2 * n):
                    if (mask >> j) & 1 == 0:
                        new_mask = mask | (1 << i) | (1 << j)
                        current_score = op * gcd(nums[i], nums[j]) + solve(new_mask, op + 1)
                        max_score_val = max(max_score_val, current_score)
        memo[(mask, op)] = max_score_val
        return max_score_val

    return solve(0, 1)