生命不息，奋斗不止

题目描述：

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

小明发现网站的自动对局系统在匹配对手时，只会将积分差恰好是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;
}

题目描述：

跳蚤国正在大力发展旅游业，每个城市都被打造成了旅游景点。

许多跳蚤想去其他城市旅游，但是由于跳得比较慢，它们的愿望难以实现。这时，小C听说有一种叫做火车的交通工具，在铁路上跑得很快，便抓住了商机，创立了一家铁路公司，向跳蚤国王请示在每两个城市之间都修建铁路。

然而，由于小C不会扳道岔，火车到一个城市以后只能保证不原路返回，而会随机等概率地驶向与这个城市有铁路连接的另外一个城市。跳蚤国王向广大居民征求意见，结果跳蚤们不太满意，因为这样修建铁路以后有可能只游览了3个城市（含出发的城市）以后就回来了，它们希望能多游览几个城市。于是跳蚤国王要求小C提供一个方案，使得每只跳蚤坐上火车后能多游览几个城市才回来。 小C提供了一种方案给跳蚤国王。跳蚤国王想知道这个方案中每个城市的居民旅游的期望时间（设火车经过每段铁路的时间都为1），请你来帮跳蚤国王。

【输入格式】

输入的第一行包含两个正整数n、m，其中n表示城市的数量，m表示方案中的铁路条数。 接下来m行，每行包含两个正整数u、v，表示方案中城市u和城市v之间有一条铁路。 保证方案中无重边无自环，每两个城市之间都能经过铁路直接或间接到达，且火车由任意一条铁路到任意一个城市以后一定有路可走。

【输出格式】

输出n行，第i行包含一个实数t_i，表示方案中城市i的居民旅游的期望时间。你应当输出足够多的小数位数，以保证输出的值和真实值之间的绝对或相对误差不超过e⁻⁹。

【样例输入】 4 5 1 2 2 3 3 4 4 1 1 3

【样例输出】 3.333333333333 5.000000000000 3.333333333333 5.000000000000

【样例输入】

10 15 1 2 1 9 1 5 2 3 2 7 3 4 3 10 4 5 4 8 5 6 6 7 6 10 7 8 8 9 9 10

【样例输出】 10.000000000000 10.000000000000 10.000000000000 10.000000000000 10.000000000000 10.000000000000 10.000000000000 10.000000000000 10.000000000000 10.000000000000

【数据规模与约定】 对于10%的测试点，n ≤ 10； 对于20%的测试点，n ≤ 12； 对于50%的测试点，n ≤ 16； 对于70%的测试点，n ≤ 19； 对于100%的测试点，4 ≤ k ≤ n ≤ 21，1 ≤ u, v ≤ n。数据有梯度。

资源约定：

峰值内存消耗 < 256M

CPU消耗 < 1000ms

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

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

注意: main函数需要返回0

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

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

问题分析：

​这道问题真的很难，当时间也很紧，就剩余20分钟左右，考试直接放弃了。现在并没有明确思路，待网上有题解后，有机会再补充。

2017第八届蓝桥杯决赛题目解析(1)：36进制

2017第八届蓝桥杯决赛题目解析(2)：瓷砖样式

2017第八届蓝桥杯决赛题目解析(3)：希尔伯特曲线

2017第八届蓝桥杯决赛题目解析(4)：发现环

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

2017第八届蓝桥杯决赛题目解析(6)：观光旅游

问题描述：

对于16进制，我们使用字母A-F来表示10及以上的数字。如法炮制，一直用到字母Z，就可以表示36进制。36进制中，A表示10，Z表示35，AA表示370。你能算出MANY表示的数字用10进制表示是多少吗？请提交一个整数，不要填写任何多余的内容（比如：说明文字）

问题分析：

​作为蓝桥杯一贯的风格，省赛时候就有各种水题，国赛也不例外，这种题目甚至不需要编程解决，用excel，windows自带的计算器等工具，一般都能解决。

​但为了表述问题解决策略，还是贴出代码以供参考。

问题答案：

​1040254

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include <iostream>

int conversion(char t) { // 对36进制的单数字转换为10进制 
    if ('0' <= t and t <= '9')
        return t - '0';
    else
        return t - 'A' + 10; 
} 
int main() {
    std::cout << conversion('M') * 36 * 36 * 36 + \
        conversion('A') * 36 * 36 + \
        conversion('N') * 36 + \
        conversion('Y');
    return 0;
}