您当前的位置：首页 > 计算机 > 编程开发 > 数据结构与算法

程序员的算法趣题Q69: 蓝白歌会

时间：01-01来源：作者：点击数：67

1. 问题描述

问题：当有4*6=24个人，以12人为一组分为两组时，求所需移动次数最多的起始状态有多少种？

2. 解题分析

2.1 基本思路

由于终止状态是确定的（4个），所以适合于逆向搜索（本系列前面出现过不少逆向思维解决的问题例）。

位置交换动作是可逆的，从4个确定性的终止状态开始，通过合理的位置交换操作（确保距离最小化）寻找距离4个确定性的终止状态最远的初始状态。这个显然是图搜索中最大距离问题，适合于用广度优先搜索算法。

另外，由于本题要求不仅找出最大距离，还要求找出满足这一条件的初始状态的个数，所以相当于要找出再广度优先搜索中出现在最远一层的所有状态的个数。

2.2 算法流程

基于广度优先搜索的算法流程如下所示：

2.3 实现要点

当前人员状态用二维数组（本题解用numpy数组）表示，为了方便判断，与棋盘问题类似采用了外加围栏的方式。

如以上算法流程图中所述，由于最后需要最终层的所有状态个数，因此visited以字典的方式记录状态以及其对应的距离。

由于numpy数组不能用作dict的key，所以，表示状态的numpy二维数组先变换为一维数组，然后转变为tuple，用作visited的key，而距离（层数, curStep）。存入队列时，则是将前述visited的key与距离（层数, curStep）组成一个嵌套式的tuple再存入。注意队列q与visited的这两种存储方式的区别。

在每个格子上查询是否可以交换时，只考虑它与右边一格以及下边一格交换的可能性。这样按行扫描下去，不会遗漏也不会产生不必要的重复。这个技巧也是在前面的题目中已经出现过。

3. 代码及测试

# -*- coding: utf-8 -*-
"""
Created on Mon Oct 18 07:39:04 2021

@author: chenxy
"""

import sys
import time
import datetime
import math
# import random
from   typing import List
from   collections import deque
import itertools as it
import numpy as np

N = 4
M = 6

seat = np.ones((N,M))
initState1 = seat.copy()
initState1[:,:M//2] = -1
initState2 = seat.copy()
initState2[:,M//2:] = -1
initState3 = seat.copy()
initState3[:N//2,:] = -1
initState4 = seat.copy()
initState4[N//2:,:] = -1

q = deque()
visited = dict()

q.append((tuple(np.reshape(initState1, (N*M,))),0))
q.append((tuple(np.reshape(initState2, (N*M,))),0))
q.append((tuple(np.reshape(initState3, (N*M,))),0))
q.append((tuple(np.reshape(initState4, (N*M,))),0))

visited[tuple(np.reshape(initState1, (N*M,)))] = 0
visited[tuple(np.reshape(initState2, (N*M,)))] = 0
visited[tuple(np.reshape(initState3, (N*M,)))] = 0
visited[tuple(np.reshape(initState4, (N*M,)))] = 0

ansLst = []
tStart = time.perf_counter()
while len(q) > 0:    
    curState, curStep = q.popleft()
    # print(curState,curStep)
    curExt = np.zeros((N+2,M+2))
    curExt[1:N+1,1:M+1] = np.reshape(curState, (N,M))
    for k in range(1,N+1):
        for l in range(1,M+1):
            if curExt[k,l] * curExt[k,l+1] == -1:
                curExt[k,l] *= -1
                curExt[k,l+1] *= -1
                nxtState = curExt[1:N+1,1:M+1]
                if tuple(np.reshape(nxtState, (N*M,))) not in visited:
                    q.append((tuple(np.reshape(nxtState, (N*M,))),curStep+1))
                    visited[tuple(np.reshape(nxtState, (N*M,)))] = curStep+1                    
                curExt[k,l] *= -1
                curExt[k,l+1] *= -1            
            if curExt[k,l] * curExt[k+1,l] == -1:
                curExt[k,l] *= -1
                curExt[k+1,l] *= -1
                nxtState = curExt[1:N+1,1:M+1]
                if tuple(np.reshape(nxtState, (N*M,))) not in visited:
                    q.append((tuple(np.reshape(nxtState, (N*M,))),curStep+1))
                    visited[tuple(np.reshape(nxtState, (N*M,)))] = curStep+1                    
                curExt[k,l] *= -1
                curExt[k+1,l] *= -1


ansSteps = curStep    
numStates = 0
for key in visited:
    if visited[key] == ansSteps:
        ansLst.append(key)
        numStates += 1
tCost  = time.perf_counter() - tStart

print('N={0}, M={1}, ansSteps={2}, numStates={3}, {4:6.3f}(sec)'.format(N,M,ansSteps,numStates,tCost))