生命不息，奋斗不止

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

题目描述：

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

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

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

【输入格式】

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

【输出格式】

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

【样例输入】 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 \le 10\)； 对于20%的测试点，\(n \le 12\)； 对于50%的测试点，\(n \le 16\)； 对于70%的测试点，\(n \le 19\)； 对于100%的测试点，\(4 \le k \le n \le 21，1 \le u, v \le n\)。数据有梯度。

资源约定：

峰值内存消耗 < 256M

CPU消耗 < 1000ms

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

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

注意: main函数需要返回0

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

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

问题分析：

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

发表于 更新于 本文字数： 617 阅读时长 ≈ 1 分钟

问题描述：

对于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;
}

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

问题描述：

小明家的一面装饰墙原来是3*10的小方格。现在手头有一批刚好能盖住2个小方格的长方形瓷砖。

瓷砖只有两种颜色：黄色和橙色。小明想知道，对于这么简陋的原料，可以贴出多少种不同的花样来。

小明有个小小的强迫症：忍受不了任何2*2的小格子是同一种颜色。

（瓷砖不能切割，不能重叠，也不能只铺一部分。另外，只考虑图案，请忽略瓷砖的拼接）

显然，对于2*3的小格子来说，口算都可以知道：一共10中贴法，如图所示：

但对于3*10的格子呢？肯定是个不小的数目，请你利用计算机的威力算出该数字。

注意：你需要提交的是一个整数，不要填写任何多余的内容（比如：说明性文字）

问题分析：

​题目说的很长，但中心思想一句话就可以概括：用2种 2*1 瓷砖，覆盖 10*3 的墙面，保证没有 2*2 颜色相同，请问有多少种情况？

​考场上初步想来，直接暴力搜索所有解，最后对所有解进行判定合，足够秒出结果。而且代码简单，不会花费过多时间，为后面大分题准备。

​现在想来，其实不必对所有解进行判合法，在中途选择瓷砖时，就可以进行判定，这样可以降低时间复杂度。

问题答案：

​114434

代码：

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
#include <iostream>

int a[5][12];   //  -1代表未摆放，1代表黄色，2代表橙色 
int res = 0;

bool judge(int x, int y) {
    if (a[x][y] == a[x - 1][y - 1] && a[x][y] == a[x - 1][y] && a[x][y] == a[x][y - 1])
        return false;
    if (a[x][y] == a[x - 1][y] && a[x][y] == a[x - 1][y + 1] && a[x][y] == a[x][y + 1])
        return false;
    if (a[x][y] == a[x][y - 1] && a[x][y] == a[x + 1][y - 1] && a[x][y] == a[x + 1][y])
        return false;
    return true;

}

void dfs(int x, int y) {
    if (x == 3 && y == 10) {
        res++;
        return;
    }
    if (y > 10) {
        dfs(x + 1, 0);
        return;
    }
    if (a[x][y] == -1) {
        if (a[x][y + 1] == -1)  // 竖着铺 
        {
            a[x][y] = 1;
            a[x][y + 1] = 1;

            if (judge(x, y))    // 边铺边判合法 
                dfs(x, y + 1);
            a[x][y] = -1;
            a[x][y + 1] = -1;

            a[x][y] = 2;
            a[x][y + 1] = 2;
            if (judge(x, y))
                dfs(x, y + 1);
            a[x][y] = -1;
            a[x][y + 1] = -1;
        }
        if (a[x + 1][y] == -1)  // 横着铺 
        {
            a[x][y] = 1;
            a[x + 1][y] = 1;
            if (judge(x, y))
                dfs(x, y + 1);
            a[x][y] = -1;
            a[x + 1][y] = -1;

            a[x][y] = 2;
            a[x + 1][y] = 2;
            if (judge(x, y))
                dfs(x, y + 1);
            a[x][y] = -1;
            a[x + 1][y] = -1;
        }
    } else {
        dfs(x, y + 1);
    }
}


int main() {
    int i, j;
    for (i = 1; i <= 3; i++)
        for (j = 1; j <= 10; j++)
            a[i][j] = -1;
    dfs(1, 1);
    std::cout << res;
    return 0;
}
0%