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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximize-score-after-n-operations
 

解法一：

状压dp。第一次写状压dp的题，完全没有思路，看了大佬的题解，才知道咋写。状压dp中用二进制来枚举状态。dp[state]表示状态为state时的最大分数和。state是二进制的状态，根据题意，其中1的数量x需为偶数，表示第x/2次操作。我们需枚举state的子集，并要求其子集中1的数量为x-2，表示第（x-1）/2次操作,经过state^i后，1的数量必为2。

状态转移方程为dp[state]=max(dp[state], dp[i]+x/2 * dp[state^i]).

class Solution {

	int gcd(int a, int b)
	{
		if (a == 0)
			return b;
		return gcd(b%a, a);
	}

	int count(int x)
	{
		int cnt = 0;
		while (x)
		{
			x = (x - 1)&x;
			++cnt;
		}
		return cnt;
	}

public:
	int maxScore(vector<int>& nums) {
		int n2 = nums.size();
		int top = 1 << n2;
		vector<int> dp(top);
		for (int i = 0; i < n2; ++i)//初始化dp
		{
			for (int j = i + 1; j < n2; ++j)
			{
				dp[1 << i | 1 << j] =gcd(nums[i], nums[j]);
			}
		}
		for (int mask = 1; mask < top; ++mask)
		{
			int cnt = __builtin_popcount(mask); //内建函数求二进制中1的数量，速度比count函数快
			if (cnt & 1) 
				continue;
			for (int i = mask; i > 0; i = (i - 1)&mask)
			{
				if (2 == cnt - __builtin_popcount(i))
				{
					dp[mask] = max(dp[mask], dp[i] + (cnt >> 1)*dp[i^mask]);
				}
			}
		}
		return dp[top - 1];
	}
};

后续复习：

这一次看到题目比第一次看到要好一点，至少还有点头绪，可以用比较拙劣的方法写出。

用dp(i, mask)表示第i次操作完，状态为mask时的最大分数和为多少。

dp[i][mask]=max(dp[i][mask], dp[i-1][sub]+ i/2*gcd(num[j], num[k]))

class Solution {

	int gcd(int a, int b)
	{
		if (a==0)
			return b;
		return gcd(b%a, a);
	}

public:
	int maxScore(vector<int>& nums) {
		int n = nums.size();
		int top = 1 << n;
		vector<int> g(top);
		for (int i = 0; i < n; ++i) //预处理出每个元素之间的公约数
		{
			for (int j = i + 1; j < n; ++j)
			{
				g[1 << i | 1 << j] = gcd(nums[i], nums[j]);
                //cout<<g[1 << i | 1 << j]<<endl;
			}
		}

		vector<vector<int>> dp(n/2+1, vector<int>(top));
		//dp[0][0] = 0;
		for (int i = 1; i <= n/2; ++i)
		{
			for (int mask = 1; mask < top; ++mask)
			{
				int cnt = __builtin_popcount(mask);
				if (cnt!=2*i)     //实际上每次循环的数都是不一样的
					continue;
				for (int sub = mask; sub >= 0; sub = (sub - 1)&mask)
				{
					if (2 == cnt - __builtin_popcount(sub))
					{
						dp[i][mask] = max(dp[i][mask], dp[i - 1][sub] + i*g[mask^sub]);
					}
					if (sub == 0)
						break;
				}
				
			}
		}
		return dp[n/2][top - 1];
	}
};

然后可以发现dp[i]只与dp[i-1]有关，并且sub状态不会在第i次改变，所以可以优化为解法一。本题是模板题，状态压缩dp+子空间遍历：用二进制数表示数组状态，并且还需遍历数组的子空间。