穷举算法解谜初探

之前无意中看到推箱子游戏，想了一下这个游戏的求解算法，感觉非常复杂，苦思无果。最近在看《java并发编程实践》时得到启发，可以利用穷举算法来解决这一问题，而且很多类似的问题都可以用穷举算法解决。

这里定义三个类：

PuzzleState：定义解谜过程中的一个状态或者说一个步骤。
SolvePuzzle：解谜线程管理类
Solving：解谜线程类

一个接口：

PuzzleModeling：问题建模，在这里定义问题规则。

PuzleState

/**
 * 解谜过程中的一个状态或者一个步骤，与问题建模有关。在推箱子游戏中，是工人的一步移动；<br>
 * 每个状态都维护一个父状态和一个关闭状态列表。父状态用于解决方法的回溯，从目标状态返回起点状态；
 * 关闭列表保存了到达当前状态前已经处理过的状态。<br>
 * 关闭列表在每个状态中作为内部变量维护，保证即使父状态和子状态由不同线程处理，其结果都是一致的。<br>
 * @author nfhy
 * 2015年9月29日
 * <br> 
   myBlog: http://nfhy.wang
 */
public abstract class PuzzleState {
  
  /**每个状态的唯一ID.*/
  protected String uniqueId;
  
  /**指向父状态，计算解决方法价值，回溯解决方法时使用.*/
  protected PuzzleState parent;
  
  /**关闭状态列表，保存状态id，这一列表中的状态不需要再次处理.*/
  private ArrayList<String> closeList;
  
  /**生成状态唯一ID，与问题建模有关.*/
  public abstract void generateUniqueId();
  
  public String getUniqueId() {
    return this.uniqueId;
  }
  
  public void setParent(PuzzleState parent) {
    this.parent = parent;
  }
  
  /**当前状态的后续状态，一般情况下，如果后续状态出现在closeList中，这一状态可以跳过不处理.*/
  public abstract <K extends PuzzleState> List<K> next();
  
  /**从当前状态回溯到起始状态，返回一个状态队列.*/
  public abstract List<PuzzleState> traceBackToStart();
  
  /**计算从当前状态回溯到起始状态的步数，当谜题有多个解时，可以通过这一方法找到最优解.*/
  public abstract int traceBackCost();

  /**在console中打印状态简图的方法.*/
  public void draw(){}
  
}

SolvePuzzle

/**
 * 解谜线程管理类。维护一个线程池 es；
 * 维护一个开启状态阻塞队列 openList，队列中的状态都是待处理的，所有线程都可以在这里取得任务；<br>
 * 保存一个或多个目标状态 targetStates；维护一个解决方法阻塞队列 findStates，
 * 每找到与目标状态相同的状态，就保存在队列中；<br>
 * 保存一个开始状态 start，所有后续状态的顶层父状态都是开始状态；
 * 保存一个闭锁 latch，当所有线程执行完毕或异常退出时，latch-1<br>
 * @author nfhy
 * 2015年9月29日
 * <br> 
   myBlog: http://nfhy.wang
 */
public class SolvePuzzle {
  
  /**
   * 等待线程执行的最长等待时间.
   */
  private static final int maxWaitLength = 10;
  /**
   * 解密线程的线程池.
   */
  final ExecutorService es = 
      Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
  
  /**开启状态阻塞队列，保存待处理的状态，线程以阻塞方式从队列中取值，阻塞时间超过规定时间，表明没有新的状态产生，线程结束.*/
  final LinkedBlockingQueue<PuzzleState> openList = new LinkedBlockingQueue<PuzzleState>();
  
  /**解决方法阻塞队列，保存找到的解决方法，也就是和目标状态相同的状态.*/
  final LinkedBlockingQueue<PuzzleState> findStates = new LinkedBlockingQueue<PuzzleState>();
  
  /**一个或多个目标状态，有的谜题可能有多个解.*/
  PuzzleState[] targetStates;
  
  /**谜题初始状态.*/
  PuzzleState start;
  
  /**线程执行闭锁，只有所有线程执行完毕后，才开是梳理解决方法.*/
  final CountDownLatch latch = new CountDownLatch(Runtime.getRuntime().availableProcessors());
  
  /**构造方法，提供目标状态和初始状态.
   * @param targetStates 目标状态
   * @param start 初始状态
   */
  public SolvePuzzle(PuzzleState[] targetStates, PuzzleState start) {
    this.targetStates = targetStates;
    this.start = start;
  }
  
  /**解谜开始方法.*/
  public void start() {
    try {
      openList.put(start);
    } catch (InterruptedException e) {
      System.out.println("start interrupted, abort");
      return;
    }
    for (int i = 0; i < Runtime.getRuntime().availableProcessors(); ++i) {
      es.submit(new Solving(targetStates));
    }
    try {
      latch.await();
    } catch (InterruptedException e) {
      System.out.println("latch waiting interrupted");
    }
    shutdown();
    handleResult();
  }
  
  /**遍历解决方法，找到最优解.*/
  private void handleResult() {
    PuzzleState result;
    PuzzleState minCostState = null;
    while ((result = findStates.poll()) != null) {
      System.out.println("---- " + result.traceBackCost());
      if (null == minCostState || minCostState.traceBackCost() > result.traceBackCost()) {
        minCostState = result;
      }
    }
    minCostState.draw();
    List<PuzzleState> traces = minCostState.traceBackToStart();
    Collections.reverse(traces);
    for (PuzzleState state : traces) {
      state.draw();
    }  
  }
  
  /**等待线程池关闭，如果100秒仍没有关闭，手动关闭.*/
  public void shutdown() {
    if (!es.isTerminated()) {
      try {
        es.awaitTermination(maxWaitLength, TimeUnit.SECONDS);
      } catch (InterruptedException e) {
        System.out.println("wait for termination interrupted");
      } finally {
        es.shutdown();
      }
    }
  }

Solving

/**
   * @Title SolvePuzzle.java
   * @author nfhy
   * @date 2015年9月29日
   * @Description 解谜线程类，定义了解谜的过程：<br>
   *     1.从开启队列中取得待处理状态，如果超过等待时间仍没有取到新的状态，跳转步骤5<br>
   *     2.获取该状态的后续状态<br>
   *     3.如果不存在后续状态，返回步骤1；
   *     4.如果存在后续状态，遍历这些状态，如果这些状态与目标状态相同，记录在解决方法队列中，
   *     如果这些状态不在开启列表中，将它们放入开启列表，返回步骤1。<br>
   *     5.结束线程
   * <br> 
     myBlog: http://nfhy.wang
   */
  class Solving implements Callable<Boolean> {
    
    PuzzleState nowState;
    
    PuzzleState[] targetStates;
    
    public Solving(PuzzleState[] targetStates) {
      this.targetStates = targetStates;
    }
    
    private boolean checkTarget(PuzzleState state) {
      for (PuzzleState target : targetStates) {
        if (null != target && target.getUniqueId().equals(state.getUniqueId())) {
          return true;
        }
      }
      return false;
    }
    
    private boolean getState() throws Exception {
      while ((nowState = openList.poll(maxWaitLength, TimeUnit.SECONDS)) != null) {
        List<PuzzleState> nextStates = nowState.next();
        for (PuzzleState state : nextStates) {
          if (checkTarget(state)) {
            findStates.add(state);
          }
          if (!openList.contains(state)) {
            openList.put(state);
          }
        }
      }
      return true;
    }

    @Override
    public Boolean call() {
      try {
        getState();
      } catch (Exception e) {
        e.printStackTrace();
      } finally {
        latch.countDown();
      }
      return true;
    }
    
  }

为了解决推箱子问题，继承SingleState，实现PuzzleModeling，代码不在这贴了，有兴趣的可以去我的github下载

测试场景非常简单，5*4的地图，四周围墙，两个箱子，两个仓库。W表示工人，#表示墙壁，*表示仓库，B带表箱子。

初始状态：
 # # # # # #
 # * * B S #
 # W B # * #
 # * * * S #
 # # # # # #
目标状态：

 # # # # # #
 # * * * B #
 # * * # * #
 # W * * B #
 # # # # # #
 
 最优结果回溯（从初始状态到最终状态，最快需要11步）：
 注意，这可能不是唯一的最优解，但肯定是最优解之一。
 # # # # # #
 # * * * B #
 # * * # * #
 # W * * B #
 # # # # # #

 # # # # # #
 # * * B S #
 # W B # * #
 # * * * S #
 # # # # # #

 # # # # # #
 # W * B S #
 # * B # * #
 # * * * S #
 # # # # # #

 # # # # # #
 # * W B S #
 # * B # * #
 # * * * S #
 # # # # # #

 # # # # # #
 # * * W B #
 # * B # * #
 # * * * S #
 # # # # # #

 # # # # # #
 # * W * B #
 # * B # * #
 # * * * S #
 # # # # # #

 # # # # # #
 # * * * B #
 # * W # * #
 # * B * S #
 # # # # # #

 # # # # # #
 # * * * B #
 # W * # * #
 # * B * S #
 # # # # # #

 # # # # # #
 # * * * B #
 # * * # * #
 # W B * S #
 # # # # # #

 # # # # # #
 # * * * B #
 # * * # * #
 # * W B S #
 # # # # # #

 # # # # # #
 # * * * B #
 # * * # * #
 # * * W B #
 # # # # # #

 # # # # # #
 # * * * B #
 # * * # * #
 # * W * B #
 # # # # # #

 # # # # # #
 # * * * B #
 # * * # * #
 # W * * B #
 # # # # # #

版权声明：本文为博主原创文章，未经博主允许不得转载.