CF1110D Jongmah

tags

dp 动态规划

中文题面

Jongmah

题面翻译

你在玩一个叫做 Jongmah 的游戏，你手上有 $n$ 个麻将，每个麻将上有一个在 $1$ 到 $m$ 范围内的整数 $a_i$。

为了赢得游戏，你需要将这些麻将排列成一些三元组，每个三元组中的元素是相同的或者连续的。如 $7,7,7$ 和 $12,13,14$ 都是合法的。你只能使用手中的麻将，并且每个麻将只能使用一次。

请求出你最多可以形成多少个三元组。

数据范围：$1\le n,m\le 10^6$，$1\le a_i\le m$

样例 #1

样例输入 #1

10 6
2 3 3 3 4 4 4 5 5 6

样例输出 #1

3

样例 #2

样例输入 #2

12 6
1 5 3 3 3 4 3 5 3 2 3 3

样例输出 #2

3

样例 #3

样例输入 #3

13 5
1 1 5 1 2 3 3 2 4 2 3 4 5

样例输出 #3

4

提示

In the first example, we have tiles $ 2, 3, 3, 3, 4, 4, 4, 5, 5, 6 $ . We can form three triples in the following way: $ 2, 3, 4 $ ; $ 3, 4, 5 $ ; $ 4, 5, 6 $ . Since there are only $ 10 $ tiles, there is no way we could form $ 4 $ triples, so the answer is $ 3 $ .

In the second example, we have tiles $ 1 $ , $ 2 $ , $ 3 $ ( $ 7 $ times), $ 4 $ , $ 5 $ ( $ 2 $ times). We can form $ 3 $ triples as follows: $ 1, 2, 3 $ ; $ 3, 3, 3 $ ; $ 3, 4, 5 $ . One can show that forming $ 4 $ triples is not possible.

思路

对于三元组 {x−2,x−1,x}，它最多取 2 次，否则就可以变成多个 {x,x,x}
设 $d{p}_{i,j,k}$ 表示考虑到第 $i$ 位，假设第 $i$ 位已经用掉了 $j$ 个，第 $i-1$ 位已经用掉了 $k$ 个，能得到的三元组个数。

得到转移方程：

d p i , j , k = m a x l = 0 2 { d p i − 1 , k + l , l + ⌊ ( c n t i − l − j ) ÷ 3 ⌋ + l } dp_{i,j,k}=max_{l=0}^2\{dp_{i−1,k+l},l+⌊(cnt_i−l−j) \div 3⌋+l\} dpi,j,k​=maxl=02​{dpi−1,k+l​,l+⌊(cnti​−l−j)÷3⌋+l}

代码

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define N (int)1e6 + 5
#define pdd pair<double, double>
#define pii pair<int, int>

int a, b, c, d, x, y, n, m, t, k, q, l, r, p, z, h;
int num[N];
int dp[N][3][3];
string s;
map<int, int> mp;
signed main() {
	ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
	// 注意根据数据量调整N的大小
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        cin >> x;
        num[x]++;
    }
    for (int i = 1; i <= m; i++) {
         for (int j = 0; j <= 2; j++) {
             for (int k = 0; k <= 2; k++) {
                 for (int t = 0; t <= 2; t++) {
                     if (j + k + t > num[i]) continue;
                     dp[i][j][k] = max(
                             j + dp[i - 1][k][t] + (num[i] - j - k - t) / 3,
                             dp[i][j][k]
                             );
                 }
             }
         }
    }
    cout << dp[m][0][0];
	return 0;
}