牛客小白月赛105 (Python题解)

比赛链接：点击传送

A-lz的吃饭问题

代码：

a, b = map(int,input().split())

c, d = map(int,input().split())

print("gzy") if a*b >= c*d else print("lz")

B-lz的数字问题

代码:

def func(a1, b1):

    a_int, a_frac = (a1 + '.0').split('.')[:2]

    b_int, b_frac = (b1 + '.0').split('.')[:2]

    if a_int != b_int: return "NO"

    a_frac = (a_frac + "000000")[:6]

    b_frac = (b_frac + "000000")[:6]

    return "YES" if a_frac == b_frac else "NO"

a, b = input().split()

print(func(a, b))

C-lz的蛋挞问题

1.问题重述:

1.1.背景:

一个两行 n 列的盒子中有两种物品：蛋挞（.）和奶贝（x），蛋挞之间如果在上下左右四个方向相邻，就可以连通，连通块是指一组可以相互连通的蛋挞。

1.2.要求:

可以吃掉一个蛋挞，并在原位置放置奶贝，找出吃掉后能改变蛋挞连通块数量的蛋挞个数。

2.求解思路：

2.1.核心思路:

遍历每个蛋挞位置
判断吃掉该蛋挞是否会改变连通块数量
设计4种判断条件

2.2.四种判断条件详解：

左侧连通性改变
```
j > 0 and m[i][j] == m[1-i][j] == m[i][j-1] != m[1-i][j-1]
```
检查左侧相邻蛋挞是否形成特定连通模式，同行和对行的蛋挞值相同，与左下/左上蛋挞值不同
右侧连通性改变
```
j + 1 < n and m[i][j] == m[1-i][j] == m[i][j+1] != m[1-i][j+1]
```
检查右侧相邻蛋挞是否形成特定连通模式，同行和对行的蛋挞值相同，与右下/右上蛋挞值不同

三连通情况

j > 0 and j + 1 < n and m[i][j-1:j+2] == '.' * 3 and m[1-i][j] == 'x'

当前行有连续三个蛋挞，对应行为奶贝

孤立点情况

(j == 0 or m[i][j-1] == 'x') and (j + 1 == n or m[i][j+1] == 'x') and m[1-i][j] == 'x'

当前蛋挞左右被奶贝包围，对应行为奶贝

3.代码:

n = int(input())

m = [input() for _ in range(2)]

ans = 0

for i in range(2):

    for j in range(n):

        if m[i][j] == 'x':

            continue

        conditions = [

	j > 0 and m[i][j] == m[1-i][j] == m[i][j-1] != m[1-i][j-1],

	j + 1 < n and m[i][j] == m[1-i][j] == m[i][j+1] != m[1-i][j+1],

	j > 0 and j + 1 < n and m[i][j-1:j+2] == '.' * 3 and m[1-i][j] == 'x',

	(j == 0 or m[i][j-1] == 'x') and (j + 1 == n or m[i][j+1] == 'x') and m[1-i][j] == 'x'

        ]#四种判断条件

        ans += any(conditions)

print(ans)

D-lz的染色问题

1.问题重述:

1.1.背景:

花园包含 n 朵花,每朵花有自己的颜色,在接下来的 m 天里，每天观察两朵花,如果观察的两朵花颜色不同，lz会生气。

1.2.要求:

需要选择最少数量的花进行重新染色，让 lz 在 m 天观察中不会生气

2.求解思路：

2.1.核心思路:

使用并查集将需要颜色相同的花分组
对每个连通分量，找出出现最多的颜色
计算需要染色的花的数量

2.2.详细解题步骤:

初始化并查集

将需要颜色相同的花合并到同一个集合
分组统计

找出每个连通分量的根节点，将同一连通分量的花分到同一组
计算最小染色数

对每个连通分量，统计出现最多的颜色数量，用连通分量的总花数减去最多颜色的数量，得到需要染色的最少花数

3.代码:

class UnionFind:

    def __init__(self, n):

        self.far = list(range(n + 1))

        self.rank = [0] * (n + 1)

    def find(self, x):

        if self.far[x] == x:

            return x

        self.far[x] = self.find(self.far[x])

        return self.far[x]

    def unite(self, x, y):

        x = self.find(x)

        y = self.find(y)

        if x == y:

            return

        if self.rank[x] > self.rank[y]:

            self.far[y] = x

        else:

            self.far[x] = y

            if self.rank[x] == self.rank[y]:

                self.rank[y] += 1

def main():

    n, m = map(int, input().split())

    uf = UnionFind(n)

    c = [0] + list(map(int, input().split()))# 读取颜色

    a = []

    for _ in range(m):# 处理边的连接

        x, y = map(int, input().split())

        uf.unite(x, y)

        a.extend([x, y])

    cnt = 0

    mp = {}

    G = {}

    for x in a:

        root = uf.find(x)

        if root not in mp:

            cnt += 1

            mp[root] = cnt

        if mp[root] not in G:

            G[mp[root]] = set()

        G[mp[root]].add(x)

    ans = 0

    for i in range(1, cnt + 1):

        s = {}

        ma = 0

        for x in G[i]:

            s[c[x]] = s.get(c[x], 0) + 1

            ma = max(ma, s[c[x]])

        ans += len(G[i]) - ma

    print(ans)

main()

E- lz的括号问题

1.问题重述:

1.1.背景:

给定一个由 n 对括号组成的字符串，字符串仅由字符 ( 和 ) 组成。每对括号需要按照出现的顺序进行编号。

1.2.要求:

计算每对括号在删除之前最多可以删除多少对括号。如果字符串中的括号无法完全匹配，则输出 -1。

2.求解思路：

使用一个计数器 len_ 来跟踪当前的括号深度。每遇到一个 (，计数器加一；每遇到一个 )，计数器减一。如果 len_ 变为负值，说明有多余的 )，此时输出 -1 并结束程序。若 len_ 不为零，说明括号没有完全匹配，输出 -1。

用一个列表 l 来存储每个 ( 的编号。每当遇到一个 ( 时，将当前的深度记录到列表中。使用 n - len_ 来表示当前括号可以在删除之前删除的对数。

3.代码:

n = int(input())

s = input().strip()

l = []

len_ = 0

for i in s:

    len_ += 1 if i == "(" else -1

    if len_ < 0:

        print(-1)

        exit()

    if i == "(":

        l.append(n - len_)

print(" ".join(map(str, l)))

祝ACCCCCCC...