🎁 剪格子

题目：
时间限制：
1s

内存限制：
128MB

题目描述：
如下图所示，3 x 3 的格子中填写了一些整数。

+--*--+--+
|10*  1|52|
+--****--+
|20|30*  1|
*******--+
|  1|  2|  3|
+--+--+--+

我们沿着图中的星号线剪开，得到两个部分，每个部分的数字和都是 60。

本题的要求就是请你编程判定：对给定的 $\times n$ 的格子中的整数，是否可以分割为两个部分，使得这两个区域的数字和相等。

如果存在多种解答，请输出包含左上角格子的那个区域包含的格子的最小数目。
如果无法分割，则输出 0。

输入描述：
程序先读入两个整数 m n 用空格分割 (m,n< 10)。
表示表格的宽度和高度。
接下来是 n 行，每行 m 个正整数，用空格分开。每个整数不大于 10000。

输出描述：
输出一个整数，表示在所有解中，包含左上角的分割区可能包含的最小的格子数目。

样例输入：

样例输出：
3

解题思路

利用深度优先搜索。
对于题目给出的格子数据，我们可以在周围一圈加上一圈 0，这样就可以避免考虑边界情况。

具体思路可以见下面代码及其注释。

参考代码

# 深度优先搜索
def dfs(n, m, cell, visited, cell_sum, x, y, dx, dy, ant, res):
    global count
    # count 表示所有方法的最小格子数
    # ant 表示当前方法的格子数
    if (res == cell_sum//2) and count > ant:
        count = ant
    for i in range(4):
        # 同一区域的数字相邻，即只能向四个方向走
        x0 = x + dx[i]
        y0 = y + dy[i]
        if x0 >= 1 and x0 <= m and y0 >= 1 and y0 <= n and not visited[x0][y0]:
            visited[x][y] = True
            # 递归
            dfs(n, m, cell, visited, cell_sum, x0, y0, dx, dy, ant+1, res+cell[x0][y0])
            # 回溯
            visited[x0][y0] = False


if __name__ == '__main__':
    m, n = map(int, input().split())
    # 将原格子边界一圈都设置为0，方便后续处理
    cell = [[0 for j in range(m+2)] for i in range(n+2)]
    for i in range(1, n+1):
        tmp = [0] + list(map(int, input().split())) + [0]
        cell[i] = tmp
    # count 表示所有方法的最小格子数，初始化为 m*n 的最大值 100
    count = 100

    # visited 用来记录该位置是否被访问过
    visited = [[False for j in range(m+2)] for i in range(n+2)]
    visited[1][1] = True

    # dx, dy 对应四个方向的坐标变化
    dx = [0, 1, 0, -1]
    dy = [1, 0, -1, 0]

    # cell_sum 为格子所有数字之和
    cell_sum = 0
    for i in range(1, n+1):
        for j in range(1, m+1):
            cell_sum += cell[i][j]

    if cell_sum%2 == 1:
        # cell_sum 为奇数
        print(0)
    else:
        # res 表示目前访问过节点数字的总和
        res = cell[1][1]
        dfs(n, m, cell, visited, cell_sum, 1, 1, dx, dy, 1, res)
        if count == 100:
            print(0)
        else:
            print(count)

🚀 卡勒沃夫之弱水路三千

题目：
时间限制：
1s

内存限制：
128MB

题目描述：
锦瑟年华谁与度莫问情归处只影向斜阳剑吼西风欲把春留驻
天涯芳草无归路回首花无数解语自销魂弱袂萦春尘缘不相误
…
在卡勒沃夫充满文学杀伤力的声音中，身处紫荆2号楼202B的四位远近高低各不同的室友纷纷回忆起了各自波澜起伏的过去，并对长在百草园，邻有百花谷的现状表达了各自的见解。
某Q：" …我小学就开窍了…她的父母说我很好，但是…今天又和北林的联系了…"
某X：" …差点就成了，结果到学校了…这个方法放假了我去对我的同桌用！…"
某W：" …" （千言万语不言中，有大量的故事等待考古）
某Z：" …为了来清华…咱们审美观不一样，不会抢…"
…
卡勒沃夫在这个不朽的夜话中搜集出了某人零散的历任女友资料，为了强迫某人将他出的题目的标程交出，现在卡勒沃夫需要一个能将这些零散信息整合起来的程序。

输入描述：
第一行为一个不超过 5 的整数 T，表示数据的组数。之后每组数据的一行为一个不超过 100 的整数 n。之后 n 行每行有两个用单个空格隔开的字符串（每个字符串只有英文大小写字母，长度不超过 10），为两位 mm 的名字。每行第一个 mm 先于第二个 mm 成为某人的女友。
在这里我们假装诅咒某人不会同时被两个或两个以上 mm 泡，某个 mm 抛弃了某人后不会再吃回头草，同时卡勒沃夫深邃的洞察力使得他收集到了充足的信息以确定某人女友的先后顺序。
在小数据组中出现的人物不超过 13 个.

输出描述：
输出 T 行，每行对应一组数据，并按照 mm 们从先到后成为某人女友的顺序输出她们的名字，各个名字间用一个空格隔开。

样例输入：

2 
2 
RY  Unknown 
YSZ  RY 
3 
tomorrow  yestoday 
tomorrow  today 
today  yestoday

样例输出：

YSZ RY Unknown
tomorrow today yestoday

解题思路

本题思路是拓扑排序。

具体思路见参考代码代码和注释。

参考代码

from collections import defaultdict
"""
defaultdict 是 collections 模块中的一个类。
它继承自 Python 内置的 dict 类
但是与 dict 类不同的是，defaultdict 会自动为访问的不存在的键赋一个默认值。
这样在使用 defaultdict 时就不需要像在使用 dict 时那样先判断一个键是否存在，再进行对应的操作。
"""
class Graph:
    def __init__(self):
        # 每个键对应的值为一个列表，用来存储该键值作为起点对应的终点
        self.graph = defaultdict(list)

    def addEdge(self, u, v):
        # 添加一条以 u 为起点，v 为终点的边
        self.graph[u].append(v)

    # 拓扑排序函数
    def topoLogicalSortUtil(self, key, visited, stack):
        # 标记该结点为已访问
        visited[key] = True
        for i in self.graph[key]:
            if visited[i] == False:
                self.topoLogicalSortUtil(i, visited, stack)
        # 用一个栈来保存排序结点
        stack.append(key)

    def topoLogicalSort(self, dic):
        visited = dic.copy()
        stack = []
        for key in dic.keys():
            # 判断该结点是否被访问过
            if visited[key] == False:
                # 如果没有被访问过
                self.topoLogicalSortUtil(key, visited, stack)

        # 栈是先进后出，因此需要倒序输出
        for i in stack[::-1]:
            print(i, end=' ')
        print()


t = int(input())
while t:
    # dic 用来保存结点状态：是否被访问过
    # start, end 分别存储起点和终点
    dic, start, end = {}, [], []
    n = int(input())
    for i in range(n):
        a, b = input().split()
        start.append(a)
        end.append(b)

    # grils 利用集合去重，可以得到所有结点（即所有前女友名字）
    grils = set(start + end)

    # 创建 Graph 类
    gf_graph = Graph()

    # 添加边
    for i in zip(start, end):
        gf_graph.addEdge(i[0], i[1])

    # 初始化结点状态
    for i in grils:
        dic.update({i: False})

    # 拓扑排序
    gf_graph.topoLogicalSort(dic)
    t -= 1

🍞 盾神与砝码称重

题目：
时间限制：
1s

内存限制：
128MB

题目描述：
有一天，他在宿舍里无意中发现了一个天平！这个天平很奇怪，有n个完好的砝码，但是没有游码。盾神为他的发现兴奋不已！于是他准备去称一称自己的东西。他准备好了 m 种物品去称。神奇的是，盾神一早就知道这 m 种物品的重量，他现在是想看看这个天平能不能称出这些物品出来。但是盾神稍微想了1秒钟以后就觉得这个问题太无聊了，于是就丢给了你。

输入描述：
第一行为两个数，n 和 m。
第二行为 n 个数，表示这 n 个砝码的重量。
第三行为 m个数，表示这 m 个物品的重量。

数据规模和约定
1 <= n <= 24, 1 <= m <= 10.
输出描述：
输出 m 行，对于第 i 行，如果第 i 个物品能被称出，输出 YES 否则输出 NO。

样例输入：

4 2
1 2 4 8
15 16

样例输出：

YES
NO

解题思路

深度优先搜索。

注意每个砝码有三种状态：

砝码和物品放在不同侧；
不使用该砝码
砝码和物品放在同一侧

对于每一个称重物品，逐个考虑砝码的三种状态，进行搜索。

具体见参考代码和注释。

参考代码

# 深度优先搜索
def dfs(num, res):
    global weight, tag, w01
    # 退出条件：达到物品的重量 -- 成功
    if res == weight:
        tag = True
        return
    # 退出条件：没有砝码可用 -- 失败
    elif num < 0:
        return
    else:
        ## 搜索下一个砝码
        # 将这个砝码放在物品的不同侧
        dfs(num - 1, res + int(w01[num]))
        # 不使用第 i 个砝码
        dfs(num - 1, res)
        # 将这个砝码和物品放在同一侧
        dfs(num - 1, res - int(w01[num]))

if __name__ == '__main__':
    # 输入
    n, m = map(int, input().split())
    # w01, w02 分别为砝码和物品重量
    w01 = list(map(int, input().split()))
    w02 = list(map(int, input().split()))

    # 对于每一个物品
    for i in w02:
        weight = i
        tag = False
        dfs(n-1, 0)

        # 输出结果
        if tag:
            print('YES')
        else:
            print('NO')