力扣每日一题2021-11-09祖玛游戏

---

488.祖玛游戏

题目描述

祖玛游戏

---

思路：BFS、DFS

根据题意，桌面上最多有16个球，手中最多5个球；可以按照任意顺序在5个回合内使用手中的球；在每个回合中，我们可以选择将手中的球插入到桌面上任意两球之间或者这一排球的任意一端。

BFS

根据上述内容，可以通过如下方法实现BFS：
使用队列维护需要处理的状态队列，使用哈希集合存储已经访问过的状态。每次取出队列队头的状态，考虑其中所有可以插入球的方案，如果新方案还没有被访问过，则将新方案添加到队列的队尾。

剪枝条件：

• 手中的颜色相同的球每次选择时，考虑其中一个即可。这是因为球颜色一样，在一次放入球的操作中，选择相同颜色球中的任意一个对结果没有影响。在具体实现中，可以对手中的球的颜色进行排序，如果当前遍历的球的颜色和上一个遍历的球的颜色相同，则跳过当前遍历的球。当然也可以Python也可以使用Counter方法统计球的颜色个数。
• 只在连续相同的颜色的球的开头位置或者结尾位置插入新的颜色相同的球。假设桌上有一个白球，那么在左侧和右侧加入一个新的白球没有区别；假定桌上有两个连续的白球，则在其左侧、右侧或中间插入一个新的白球也没有区别。因此，如果新插入的球和桌面上某组连续颜色相同的球（也可以是1个球）的颜色相同，则只需要考虑在其左侧或右侧中的一种情况插入新球即可。
• 只考虑放置新球后可能得到的更优解的位置。考虑插入新球的颜色与插入位置周围球的颜色的情况，再根据第二个剪枝条件剪枝后，还可能出现如下三种情况：插入新球与插入位置右侧的球的颜色相同；插入新球与插入位置两侧的球颜色均不相同，且插入位置两侧的球的颜色不同；插入新球与插入位置两侧的球颜色均不相同，且插入位置两侧的球的颜色相同。

因为题目规定了如果在消除后，出现了新的连续的三个或三个以上颜色相同的球，则继续消除这些球，直到不再满足消除条件，实际操作时，可以利用栈的特性，每次遇到可消除的球，就将其从栈中弹出。可以在遍历桌上的球时，使用列表维护遍历过的每种球的颜色和连续数量，从而通过一次遍历消除连续三个或三个以上颜色相同的球。

Python实现

# BFS
class Solution:
    def findMinStep(self, board: str, hand: str) -> int:
        def clean(s):
            # 消除桌面上需要消除的球
            n = 1
            while n:
                s, n = re.subn(r"(.)\1{2,}", "", s)
            return s
        
        hand = "".join(sorted(hand))
        
        # 初始化用队列维护的状态队列，其中的三个元素分别为桌面球状态、手中球状态和回合数
        queue = deque([(board, hand, 0)])
        
        # 初始化用哈希集合维护的已访问过的状态
        visited = {(board, hand)}
        
        while queue:
            cur_board, cur_hand, step = queue.popleft()
            for i, j in product(range(len(cur_board)+1), range(len(cur_hand))):
                # 当前球的颜色与上一个球的颜色相同
                if j > 0 and cur_hand[j] == cur_hand[j-1]:
                    continue
                # 只在连续相同颜色的球的开头位置插入新球
                if i > 0 and cur_board[i-1] == cur_hand[j]:
                    continue
                # 当前球颜色与后面的球的颜色相同或当前后颜色相同且与当前颜色不同时放置球
                choose = False
                if 0 < i < len(cur_board) and cur_board[i - 1] == cur_board[i] and cur_board[i - 1] != cur_hand[j]:
                    choose = True
                if i < len(cur_board) and cur_board[i] == cur_hand[j]:
                    choose = True
                if choose:
                    new_board = clean(cur_board[:i]+cur_hand[j]+cur_board[i:])
                    new_hand = cur_hand[:j] + cur_hand[j+1:]
                    if not new_board:
                        return step + 1
                    if (new_board, new_hand) not in visited:
                        queue.append((new_board, new_hand, step+1))
                        visited.add((new_board, new_hand))
        return -1

DFS

核心思想与BFS类似，还是搜索所有可能的插入方案，找到最少的插入方案。每次尝试选择一个手中的球将其插入到桌面上的任意两个球之间，然后对桌面上的球进行检测并对连续相同颜色的球进行消除，然后依次再进行插入和消除，直到桌面上的球全部消除或手中的球全部插入后桌面上的球也无法消除为止。假设当前桌面有n个球，手中持有m个球，则此时共有$A_{n+m}^m$种插入方法。如果直接搜索会超时，因此需要剪枝，剪枝的思路与BFS类似。

Python实现

# DFS
COLORS = ["R", "Y", "B", "G", "W"]
class Solution:
    def findMinStep(self, board: str, hand: str) -> int:
        @lru_cache(None)
        def clean(s):
            # 消除桌面上需要消除的球
            n = 1
            while n:
                s, n = re.subn(r"(.)\1{2,}", "", s)
            return s

        cnts = Counter(hand)
        start = [cnts[c] for c in COLORS]
        hand = tuple(start)

        # 初始化用双端队列维护的状态队列：其中的三个元素分别为当前桌面的球、当期手中的球、当前回合数
        queue = deque([(board, hand, 0)])

        # 记忆化
        visited = {(board, hand)}

        while queue:
            cur_board, cur_hand, step = queue.popleft()
            for i in range(len(cur_board) + 1):
                for j in range(len(cur_hand)):
                    if not cur_hand[j]:
                        continue
                    c = COLORS[j]
                    # 第 1 个剪枝条件: 只在连续相同颜色的球的开头位置插入新球(在它前面插入过了，不需要再插入，意义相同)
                    if i > 0 and cur_board[i - 1] == c:
                        continue

                    # 第 2 个剪枝条件: 只在以下两种情况放置新球
                    #  - 第 1 种情况 : 当前后颜色相同且与当前颜色不同时候放置球
                    #  - 第 2 种情况 : 当前球颜色与后面的球的颜色相同
                    choose = False
                    if 0 < i < len(cur_board) and cur_board[i - 1] == cur_board[i] and cur_board[i - 1] != c:
                        choose = True
                    if i < len(cur_board) and cur_board[i] == c:
                        choose = True

                    if choose:
                        cp = list(cur_hand)
                        cp[j] -= 1
                        b2, h2 = clean(cur_board[:i] + c + cur_board[i:]), tuple(cp)
                        if not b2:
                            return step + 1
                        if (b2, h2) not in visited:
                            queue.append((b2, h2, step + 1))
                            visited.add((b2, h2))
                            visited.add((b2[::-1], h2))

        return -1