Added internal solution for Atcoder - Grouping

content/4_Gold/DP_Bitmasks.problems.json

@@ -52,8 +52,7 @@
       "isStarred": false,
       "tags": ["Bitmasks", "DP"],
       "solutionMetadata": {
-        "kind": "autogen-label-from-site",
-        "site": "AC"
+        "kind": "internal"
       }
     },
     {

solutions/gold/ac-grouping.mdx

@@ -0,0 +1,77 @@
+---
+id: ac-grouping
+source: AtCoder
+title: Grouping
+author: Kiruthees G
+---
+
+## Explanation
+
+TThe goal is to partition a set of $N$ rabbits into any number of groups to maximize the total compatibility score. Since $N$ is small (up to 16), we use Bitmask DP.
+
+### 1. Bitmask Representation
+
+An integer $i$ between $0$ and $2^N - 1$ represents a subset of rabbits. If the $j$-th bit is set ($1$), rabbit $j$ is included in the subset.
+
+### 2. DP State and Transition
+
+We define `dp[i]` as the maximum score possible for the subset of rabbits represented by mask $i$.
+
+The transition involves two steps for each mask $i$:
+
+1. **Base Score**: Initialize `dp[i]` by calculating the sum of $a_{j,k}$ for all pairs $(j, k)$ within the mask. This assumes all rabbits in the mask form a single group.
+2. **Merging Subsets**: Improve `dp[i]` by splitting the mask into two disjoint submasks $j$ and $i \char`\^ j$. The transition is:
+
+$$dp[i] = \max_{j \subseteq i} \{ dp[j] + dp[i \char`\^ j] \}$$
+
+For an efficient way to iterate over submasks, we use the pattern `for (int j = i; j; j = (j - 1) & i)`. You can read more about this technique in the [USACO Guide: Merging Subsets](https://usaco.guide/gold/dp-bitmasks?lang=cpp#merging-subsets).
+
+### Additional Resources
+
+* [USACO Guide: Bitmask DP](https://usaco.guide/gold/dp-bitmasks?lang=cpp)
+* [Unofficial Editorial (Nwatx)](https://nwatx.me/post/atcoderdp)
+
+---
+
+## Implementation
+
+**Time Complexity**: $$\mathcal{O}(3^N + N^2 \cdot 2^N)$$
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+using ll = long long;
+
+int main() {
+	ios_base::sync_with_stdio(false);
+	cin.tie(nullptr);
+
+	int n;
+	cin >> n;
+	vector a(n, vector<int>(n));
+	for (int i = 0; i < n; i++) {
+		for (int j = 0; j < n; j++) { cin >> a[i][j]; }
+	}
+
+	vector<ll> dp(1 << n);
+	// Iterate through every possible subset of rabbits
+	for (int i = 1; i < (1 << n); i++) {
+		// Calculate internal score if this subset forms ONE single group
+		for (int j = 0; j < n; j++) {
+			if (!(i >> j & 1)) continue;
+			for (int k = j + 1; k < n; k++) {
+				if (!(i >> k & 1)) continue;
+				dp[i] += a[j][k];
+			}
+		}
+
+		// Try splitting the mask into smaller groups to find a better score
+		for (int j = (i - 1) & i; j > 0; j = (j - 1) & i) {
+			dp[i] = max(dp[i], dp[j] + dp[i ^ j]);
+		}
+	}
+
+	cout << dp.back() << '\n';
+}
+```