Leetcode 1799. N 次操作后的最大分数和

给你 nums ，它是一个大小为 2 * n 的正整数数组。你必须对这个数组执行 n 次操作。

在第 i 次操作时（操作编号从 1 开始），你需要：

    选择两个元素 x 和 y 。
    获得分数 i * gcd(x, y) 。
    将 x 和 y 从 nums 中删除。

请你返回 n 次操作后你能获得的分数和最大为多少。

函数 gcd(x, y) 是 x 和 y 的最大公约数。

 

示例 1：

输入：nums = [1,2]
输出：1
解释：最优操作是：
(1 * gcd(1, 2)) = 1

示例 2：

输入：nums = [3,4,6,8]
输出：11
解释：最优操作是：
(1 * gcd(3, 6)) + (2 * gcd(4, 8)) = 3 + 8 = 11

示例 3：

输入：nums = [1,2,3,4,5,6]
输出：14
解释：最优操作是：
(1 * gcd(1, 5)) + (2 * gcd(2, 4)) + (3 * gcd(3, 6)) = 1 + 4 + 9 = 14

 

提示：

    1 <= n <= 7
    nums.length == 2 * n
    1 <= nums[i] <= 106

解法一：状态压缩 + 记忆化搜索 + 预处理

一共有2n个数可以两两配对，n最大为7，因此可以考虑使用二进制位来枚举某个数是否被选取，初始状态位$mask=\mathrm{11...11}$,当某位被选择时，变为0。

从初始状态$(1<<n)-1$开始进行搜索，每次选择两个数进行配对，每次选取两个数的位置为$i，j$,我们使用异或运算便可以将对应位置变为0，即$mask$^ $(1<<i)$ ^ $(1<<j)$，直至选取所有数后即$mask=0$，便得到答案，保存最大值。单纯地搜索会导致时间超时，因此创建dp数组进行记忆化搜索。

dp[mask]: 代表从当前状态mask出发能够获得的分数。对于当前的状态maks来说，以前如何选取并不影响以后能够获得的最大分数。

对于每次的gcd计算，我们也可以预先创建一个二维数组进行保存。

• 时间复杂度：$O(2^n\ast n^2)$,其中n为nums数组的长度
• 空间复杂度：$O(n^2)$

class Solution {
    int n;
    int[] dp;
    int[][] gcd;
    public int maxScore(int[] nums) {
        n = nums.length;
        dp = new int[1 << n];
        gcd = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) gcd[i][j]= GCD(nums[i], nums[j]);
        }
        return dfs(1, (1 << n) - 1, 0, nums);
    }
    int dfs(int x, int mask, int sum, int[] nums) { 
        if (x == n / 2 + 1) return sum;
        if (dp[mask] > 0) return sum + dp[mask]; // sum为已经选取的数获得的分数 + 未选取的数能够获得的最大分数
        int ans = 0;
        for (int i = 0; i < n; i++) {
            if (((1 << i) & mask) == 0) continue;
            for (int j = i + 1; j < n; j++) {
                if (((1 << j) & mask) == 0) continue;
                int next = mask ^ (1 << i) ^ (1 << j); 
                ans = Math.max(ans, dfs(x + 1,  next, sum + x * gcd[i][j], nums));
            }
        }
        dp[mask] = ans - sum; //ans为能够获得的总分数 减去sum后才是maks状态获得的最大分数
        return ans;
    }
    int GCD(int a, int b) {return b == 0? a : GCD(b, a % b);}
}

class Solution {
public:
    int n;
    vector<int> dp;
    vector<vector<int>> gcd;
    int maxScore(vector<int>& nums) {
        n = nums.size();
        dp.resize(1 << n, 0);
        gcd.resize(n, vector<int>(n, 0)); 
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) gcd[i][j]= GCD(nums[i], nums[j]);
        }
        return dfs(1, (1 << n) - 1, 0, nums);
    }
    int dfs(int x, int mask, int sum, vector<int>& nums) { 
        if (x == n / 2 + 1) return sum;
        if (dp[mask] > 0) return sum + dp[mask]; // // sum为已经选取的数获得的分数 + 未选取的数能够获得的最大分数
        int ans = 0;
        for (int i = 0; i < n; i++) {
            if (((1 << i) & mask) == 0) continue;
            for (int j = i + 1; j < n; j++) {
                if (((1 << j) & mask) == 0) continue;
                int next = mask ^ (1 << i) ^ (1 << j); 
                ans = max(ans, dfs(x + 1,  next, sum + x * gcd[i][j], nums));
            }
        }
        dp[mask] = ans - sum; //ans为能够获得的总分数 减去sum后才是maks状态获得的最大分数
        return ans;
    }
    int GCD(int a, int b) {return b == 0? a : GCD(b, a % b);}
};

如果有问题,欢迎评论区交流, 如果有帮助到你，请给题解点个赞和收藏哈~~~