2023ICPC济南站VP补题记录(第48届)

Chuanhua Yu 发布于

最后更新于

[TOC]

2023ICPC济南站训练补题

注:暂时更新vp时ac的4道题，其余题目之后持续更新

本人是主要Python竞赛，补题代码实现一般用python，在codeforces中，由于没未其他语言开另外时限，python提交无法ac的情况下补题给出C++实现，按难度排序。

Problem - D - Largest Digit

题目翻译

假设 是正整数 的十进制表示中的最大位数。例如， 和 。

给定四个整数, , 和 其中 并且 , 计算 的最大值（ ）.

题目分析

这是一道签到题，比较简单直接上代码吧~

python code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import sys
input = sys.stdin.readline

def solve():
    la,ra,lb,rb = map(int, input().split())
    l = la+lb
    r = ra + rb
    ans = 0
    if r - l > 10:
        ans = 9
    else:
        for i in range(l,r+1):
            x = i
            while x:
                ans = max(x%10,ans)
                x //= 10
    print(ans)
for _ in range(int(input())):
    solve()

Problem - I - Largest Digit

题目翻译

在学习了 2021 国际大学生程序设计竞赛亚洲区域赛南京站的《Paimon Sorting》一题中奇怪的排序算法 后，小青鱼想到了如下的一个问题。 给定序列 表示一个 n 的排列，您需要将该排列按升序排序，为此可以执行以下操作至多 次：选择两个下标 l 和 r 满足 以及 ，将 按升序进行排序。 请回忆：一个 n 的排列是一个长度为 n 的序列，每个从 1 到 n（含两端）的整数在其中都恰好出现一 次。

题目分析

这题等待队友写题解喽~

Python code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import sys
input = sys.stdin.readline
for _ in range(int(input())):
    n = int(input())
    a = list(map(int, input().split()))
    ls = []
    for i in range(n):
        start = i
        end = i
        for j in range(i+1, n):
            if a[start] > a[j]:
                end = j
        if start != end:
            ls.append((start + 1, end + 1))
            a[start:end+1] = sorted(a[start:end+1])
    print(len(ls))
    for l, r in ls:
        print(l, r)

Problem - A - Many Many Heads

题目翻译

多头杯(Multi-Heads Cup)，简称 MHC，是为拥有**多头的参赛者举办的世界性编程比赛。大赛总裁判长小青鱼正在考虑为每位参赛者设计一个识别号码。

“就这样吧，”小青鱼想，”我们用一些括号序列吧！”他给每个参赛者分配了一个独一无二的平衡括号序列，括号有两种—圆括号(也叫小括号)和方括号。为了确保大家理解平衡括号序列的概念，小青鱼准备了一份平衡括号序列的正式定义：

  • (空字符串)是一个平衡括号序列。
  • 如果 是平衡括号序列，那么 和 都是平衡括号序列。
  • 如果 和 是平衡括号序列，那么 也是平衡括号序列。

例如，”()”、”[()]“和”[()]() “是平衡括号序列，但”)(“、”[(]) “和”[) “不是。

对于多头参与者来说，记忆括号序列并不是一件难事。然而，挑战在于他们的独特能力：由于他们的头数太多，他们无法辨别每个括号的方向！因此，与原来的平衡括号序列相比，他们在记忆序列时可能会改变一些括号的方向。例如，括号序列”[()]() “可能会被记忆成”])) “或”]()])”。幸运的是，括号的类型保证保持不变。

A

比赛当天，当小青鱼收到每位参赛者的括号序列时，一个问题出现了：能否唯一地推导出原始括号序列？换句话说，小青鱼需要确定所提供的括号序列是否正好映射到一个平衡的括号序列。

请帮助 “小青鱼 “完成这项任务，这样我们的多头朋友就能参加比赛了！

题目分析

这道题很容易让我们想到栈的经典问题括号匹配，但其实感觉和这题没啥关系，主要还是考思维，我们其实很容易想到有三个连续的相同种类括号那么答案必然是,比如必然可以条成 而 这种同理。

那么我们现在考虑两个连续的相同种类阔号：假设只有一个或，其他全是交替，是满足条件的，如果有两个呢，不妨设为小括号，中括号同理，形如： 这中类型。我们会发现只有 满足条件。

综上所述，一个括号序列合法，当且仅当其不存在长度 的连续段，且存在不超过 2 个长度 的连续段。

Python code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import sys
input = sys.stdin.readline

def solve():
    s = input().strip()
    cnt = 0
    s1 = {'(',')'}
    for i in range(len(s)-1):
        if (s[i] in s1 and s[i+1] in s1) or (s[i] not in s1 and s[i+1] not in s1):
            cnt += 1
            if cnt >= 3:
                print("No")
                return
    print("Yes")

for _ in range(int(input())):
    solve()

Problem - G - Gifts from Knowledge

题目翻译

在学习了理查德-彭(Richard Peng)和桑托什-文帕拉(Santosh Vempala)的论文《比矩阵乘法更快地解决稀疏线性系统》(Solving Sparse Linear Systems Faster than Matrix Multiplication)后，小青鱼对任何稀疏的东西都很着迷。例如，稀疏矩阵。这里，稀疏矩阵指的是零元素的数量远远多于非零元素数量的矩阵。现在，小青鱼想出了一个关于二进制稀疏矩阵的问题，他想让你试着解决这个问题。

给定一个有 行和 列的二进制矩阵(只包含 s 和 s 的矩阵)，你可以选择是否反转每一行。求在每列最多有一个 的情况下，有多少种方法可以选择一组行来反转(允许不选择任何行)。如果在其中一种方法中选择了一行，而在另一种方法中没有选择，那么这两种方法就被认为是不同的。

我们所说的颠倒行是指这样：让 -th行上的元素从第一列到最后一列都是 。如果把 (th)行颠倒过来，它就变成了 。

题目分析

如果第 列和第 总共的 1 的数量超过了两个， 显然无解。否则假设这两个 1 位于第 行和第 行，有两种 情况： 两个 1 处于同一列，则 和 的选择情况是相反的。 两个 1 处于不同列，则 和 的选择情况是相同的。 给定相同相反关系，求方案数是一个经典问题，可以通过建图来维护，当然我们也可以通过扩展域并查集来求。

Python code

扩展域并查集求解：

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
import sys
input = sys.stdin.readline
mod = 1000000007

def solve():
    def find(x):
        if fa[x] == x: return x
        fa[x] = find(fa[x])
        return fa[x]
    n,m = map(int, input().split())
    fa = [i for i in range(n+n)]
    ls = [list(input().strip()) for _ in range(n)]
    for i in range(m//2+1):
        l1, l2 = [], []
        if i == m-i-1:
            for j in range(n):
                if ls[j][i] == '1': l1.append(j)
            if len(l1) > 1:
                print(0)
                return
        else:
            for j in range(n):
                if ls[j][i] == '1': l1.append(j)
                if ls[j][m - i - 1] == '1': l2.append(j)
            if len(l1)+len(l2) > 2:
                print(0)
                return
        if l1 and l2:
           pa,pb = find(l1[0]),find(l2[0])
           fa[pa] = pb
           pa,pb = find(l1[0]+n),find(l2[0]+n)
           fa[pa] = pb
        elif len(l1) == 2:
            pa,pb = find(l1[0]),find(l1[1]+n)
            fa[pa] = pb
            pa,pb = find(l1[1]),find(l1[0]+n)
            fa[pa] = pb
        elif len(l2) == 2:
            pa,pb = find(l2[0]),find(l2[1]+n)
            fa[pa] = pb
            pa,pb = find(l2[1]),find(l2[0]+n)
            fa[pa] = pb
    for i in range(n):
        if find(i) == find(i+n):
            print(0)
            return
    print(pow(2,len(set(fa))//2,mod))

for _ in range(int(input())):
    solve()

建图按要求连边找连通块求解：

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
import sys
from collections import deque
input = sys.stdin.readline
mod = 1000000007

def solve():
    def bfs(x):
        q = deque()
        q.append(x)
        while q:
            x = q.popleft()
            if color[x]: continue
            color[x] = cnt
            for y in g[x]:
                if not color[y]: q.append(y)

    n, m = map(int, input().split())
    ls = [input().strip() for _ in range(n)]
    g = [[] for i in range(n + n)]
    for i in range(m//2+1):
        j = m - i - 1
        l1, l2 = [], []
        for k in range(n):
            if ls[k][i] == '1': l1.append(k)
            if ls[k][j] == '1': l2.append(k)
        if len(l1) + len(l2) <= 1: continue
        if i == j:
            if len(l1) >= 2:
                print(0)
                return
        else:
            if len(l1)+len(l2) > 2:
                print(0)
                return
        for a in l1:
            for b in l2:
                g[a].append(b)
                g[b].append(a)
                g[a + n].append(b + n)
                g[b + n].append(a + n)
        for a in range(len(l1)):
            for b in range(len(l1)):
                if a == b: continue
                g[l1[a]].append(l1[b] + n)
                g[l1[b] + n].append(l1[a])
                g[l1[b]].append(l1[a] + n)
                g[l1[a] + n].append(l1[b])

        for a in range(len(l2)):
            for b in range(len(l2)):
                if a == b: continue
                g[l2[a]].append(l2[b] + n)
                g[l2[b] + n].append(l2[a])
                g[l2[b]].append(l2[a] + n)
                g[l2[a] + n].append(l2[b])
    cnt = 0
    color = [0] * (n + n)
    for i in range(n + n):
        if not color[i]:
            cnt += 1
            bfs(i)
    for i in range(n):
        if color[i] == color[i + n]:
            print(0)
            return
    print(pow(2, cnt // 2, mod))


for _ in range(int(input())):
    solve()
smile是对你的礼貌

smile是对你的礼貌

在思维的迷宫里，有的人凭天生的灵感直奔终点； 有的人以持久的勤勉，铸造出适合自己的罗盘！

33
2
13
NOTICE

这是我的个人博客，主要发布一些算法竞赛相关题解和人工智能相关的技术与知识，页面最下面可以访问我的Github和知乎，可以通过下面链接访问我的CSDN https://blog.csdn.net/smile__everydays?spm=1000.2115.3001.5343

CATEGORYS
TAGS
DP Machine Learning XCPC div2 python模板 介绍 图匹配 图论 技术部寒假算法培训 最小生成树 牛客竞赛 蓝书 题目汇总