2017第八届蓝桥杯决赛题目解析(5)：对局匹配

发表于 更新于 本文字数： 2.6k 阅读时长 ≈ 2 分钟

题目描述：

小明喜欢在一个围棋网站上找别人在线对弈。这个网站上所有注册用户都有一个积分，代表他的围棋水平。

小明发现网站的自动对局系统在匹配对手时，只会将积分差恰好是K的两名用户匹配在一起。如果两人分差小于或大于K，系统都不会将他们匹配。

现在小明知道这个网站总共有N名用户，以及他们的积分分别是A1, A2, … AN。

小明想了解最多可能有多少名用户同时在线寻找对手，但是系统却一场对局都匹配不起来(任意两名用户积分差不等于K)？

输入：

第一行包含两个个整数N和K。

第二行包含N个整数A1, A2, … AN。

对于30%的数据，1 ≤ N ≤ 10​

对于100%的数据，1 ≤ N ≤ 100000, 0 ≤ Ai ≤ 100000, 0 ≤ K ≤ 100000

输出：

一个整数，代表答案。

样例输入： 5 1 2 3 1 2 4 2 5 5 3

样例输出： 6

再比如，

样例输入：

10 1

2 1 1 1 1 4 4 3 4 4

样例输出： 8

资源约定：

峰值内存消耗 < 256M

CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

注意: main函数需要返回0

注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。

注意: 所有依赖的函数必须明确地在源文件中 #include ， 不能通过工程设置而省略常用头文件。提交时，注意选择所期望的编译器类型。

问题分析：

​这题就相较于前几题就有难度提升，不在依靠于单一基础算法就能较好的解决问题。

​比赛时，我一开始就认为搜索能解决问题，纸上推演的半个小时才发现有问题，始终是一个NP问题。后来经过分析：这样的策略可能达到解决问题的目的：

  1. 因为当K>0时，若选值为m的点，则应该选上值为m的所有点，依照桶排序的思想，进行优化

  2. 当K=0时，最大选择数=不同值的点的类别数

  3. 依照K值，形成关系链（可以为多条关系链）

  4. 单一关系链中，选择类数和并且不关联的最大一个或几个点，该算法应为动态规划

如图所示：

输入：

1
2
22 2  
2 1 1 1 1 4 4 3 4 4 6 7 7 8 8 8 8 9 11 11 12 13

  • 第一条链最大个数和：4
  • 第二条链最大个数和：8
  • 第三条链最大个数和：2
  • 第四条链最大个数和：2
  • 第五条链最大个数和：1

最大个数和：4 + 8 + 2 + 2 + 1 = 17

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#include <iostream>
#include <vector>
#include <algorithm>
#include <array>

const int N = 100000;
int n, k;
std::array<int, N> num{0};
std::vector<int> link[N];
int node[N];
int num_node = 0;
int num_link = 0;   // 关系链数
std::array<short, N> vis{0};    // 1代表已访问，0代表未访问，-1代表点不存在
std::array<int, N> F{0}; // dp F[i]=max(F[i-1],F[F-2]+num[i])
long long tot = 0;

void init() {
    std::cin >> n >> k;
    for (int i = 1; i <= n; i++) {
        int t;
        std::cin >> t;
        num[t]++;
        vis[i] = -1;
    }

}

void work() {
    for (int i = 0; i <= N; i++)
        if (num[i] != 0) {
            node[num_node++] = i;
            vis[i] = 0;
        }
    for (int i = 0; i < num_node; i++) {
        if (vis[node[i]] == 0) {
            vis[node[i]] = 1;
            link[num_link].push_back(node[i]);
            int next = node[i] + k;
            while (vis[next] == 0) {
                link[num_link].push_back(next);
                vis[next] = 1;
                next = next + k;
            }
            num_link++;
        }
    }
}

void dp() {
    for (int i = 0; i < num_link; i++) {
        F.fill(0);
        for (int j = 0; j < link[i].size(); j++) {
            if (j >= 2)
                F[j] = std::max(F[j - 1], F[j - 2] + num[link[i][j]]);
            else if (j == 0)
                F[j] = num[link[i][j]];
            else if (j == 1)
                F[j] = std::max(F[j - 1], num[link[i][j]]);
        }
        // std::cout << F[link[i].size() - 1] << std::endl;
        tot += F[link[i].size() - 1];
    }
}

int main() {
    init();
    work();
    dp();
    std::cout << tot;
    /*
    for (int i = 0; i < num_node; i++)
        std::cout << node[i] << "->" << num[node[i]] << " ";
    std::cout << std::endl;

    for (int i = 0; i < num_link; i++) {
        for (int j : link[i]) {
            std::cout << j << " ";
        }
        std::cout << std::endl;
    }
    */
    return 0;
}