JAVA数独解题（二）：摒除法与优化框架

摒除法

摒除法：是通过数字所在行或列或宫中，如果能够确定该数字在其所在行、列、宫中，只有一个单元格能够填写，那就确实这个数字就属于这个单元格。（描述不好，请移步数独解题方法大全 或 数独游戏进阶之占位法详解

所以逻辑就是遍历所有空单元格，再便利该单元格内所有候选值，如果其中一个候选值满足如上条件，则确定这个候选值就是最终值。

package com.suduku.calc;

import com.suduku.calc.enums.CalcEnum;
import com.suduku.entity.Box;
import com.suduku.util.SudoUtil;

/**
 * 摒除法（数字在所在行或列或宫中，只有一个空格能够填写，则确定是唯一数字） <br/>
 * 测试数据：DataConstant.XING_01_50
 */
public class OnlyBoxCalc extends AbstractCalc {

    @Override
    Box solve() {
        // 遍历单元格列表
        long count = -1;
        for(Box box : getBoxList()) {
            // 如果是空白格
            if(box.isBlank()) {
                // 遍历该单元格的候选值列表
                for(Integer n : box.getCList()) {
                    // 判断所在宫内是否唯一
                    count = SudoUtil.getNumCount(getGList(box), box.getI(), n);
                    if(count == 0) {
                        // 说明在该宫中，数字n只有当前单元格存在
                        getSudo().getListener().sendMsg("通过所在宫");
                        box.setVAndClear(n);
                        return box;
                    }
                    // 判断所在行内是否唯一
                    count = SudoUtil.getNumCount(getXList(box), box.getI(), n);
                    if(count == 0) {
                        // 说明在该行中，数字n只有当前单元格存在
                        getSudo().getListener().sendMsg("通过所在行");
                        box.setVAndClear(n);
                        return box;
                    }
                    // 判断所在列内是否唯一
                    count = SudoUtil.getNumCount(getYList(box), box.getI(), n);
                    if(count == 0) {
                        // 说明在该宫中，数字n只有当前单元格存在
                        getSudo().getListener().sendMsg("通过所在列");
                        box.setVAndClear(n);
                        return box;
                    }
                }
            }
        }
        return null;
    }
    
}

SudoUtil

新增方法

    /**
     * 功能描述: 统计在area区域内，数字v不在当前单元格内出现的个数 <br/>
     * 
     * @param areaList 区域列表
     * @param i 下标
     * @param v 数字
     * @return "long"
     */
    public static long getNumCount(List<Box> areaList, int i, Integer v) {
        return areaList.stream().filter(b -> b.isBlank() && b.getI() != i && b.getCList().contains(v)).count();
    }

优化框架

AbstractCalc

由于在编写 摒除法 的过程中，发现有很多重复获取区域列表的内容，所以就提取到基类中获取。

package com.suduku.calc;

import com.suduku.entity.Box;
import com.suduku.entity.Sudo;
import com.suduku.calc.enums.CalcEnum;
import lombok.Data;

import java.util.List;

/**
 * 基础解题方法 <br/>
 *
 * @author chena
 */
@Data
public abstract class AbstractCalc {

    private Sudo sudo;

    /**
     * 功能描述: 实例化 <br/>
     * 
     * @param clazz AbstractCalc子类
     * @return "com.suduku.calc.AbstractCalc"
     */
    public static AbstractCalc getInstance(Class<? extends AbstractCalc> clazz) {
        try {
            return clazz.newInstance();
        } catch (Exception e) {
            throw new RuntimeException("实例化异常：" + e.getMessage());
        }
    }

    /**
     * 功能描述: 计算 <br/>
     *
     * @return "com.suduku.calc.enums.CalcResultEnum"
     */
    public boolean calculate() {
        this.sudo.getListener().useCalc(this);
        // 解题
        Box box = solve();
        if(box != null) {
            // 刷新
            this.sudo.refreshOtherBox(box);
            // 发送改变监听
            this.sudo.getListener().change(this.sudo.getBoxList(), box);
            if(box.isBlank()) {
                // 如果没有得到结果，则重复执行
                calculate();
            }
            return true;
        }
        return false;
    }

    /**
     * 功能描述: 解题方法 <br/>
     *
     * @return "com.suduku.entity.Box"
     */
    abstract Box solve();

    /**
     * 功能描述: 算法枚举 <br/>
     *
     * @return "com.suduku.calc.enums.CalcEnum"
     */
    public CalcEnum getCalcEnum() {
        return CalcEnum.indexOf(this.getClass());
    }

   /**
    * 功能描述: 方便使用，减少算法实现中的获取变量太长的写法 <br/>
    *
    * @return "java.util.List<com.suduku.entity.Box>"
    */
   protected List<Box> getBoxList() {
       return this.sudo.getBoxList();
   }

   /**
    * 功能描述: 方便使用，获取当前单元格所在行的单元格集合 <br/>
    *
    * @param box 单元格
    * @return "java.util.List<com.suduku.entity.Box>"
    */
   protected List<Box> getXList(Box box) {
       return this.sudo.getXMap().get(box.getX());
   }

   /**
    * 功能描述: 方便使用，获取当前单元格所在列的单元格集合 <br/>
    *
    * @param box 单元格
    * @return "java.util.List<com.suduku.entity.Box>"
    */
   protected List<Box> getYList(Box box) {
       return this.sudo.getYMap().get(box.getY());
   }

   /**
    * 功能描述: 方便使用，获取当前单元格所在宫的单元格集合 <br/>
    *
    * @param box 单元格
    * @return "java.util.List<com.suduku.entity.Box>"
    */
   protected List<Box> getGList(Box box) {
       return this.sudo.getGMap().get(box.getG());
   }

}

CalcEnum

编写过程中，发现双向绑定太过于麻烦，所以添加了indexOf方法

package com.suduku.calc.enums;

import com.suduku.calc.AbstractCalc;
import com.suduku.calc.OnlyBoxCalc;
import com.suduku.calc.OnlyNumCalc;
import com.suduku.calc.TemplateCalc;
import lombok.AllArgsConstructor;
import lombok.Getter;

/**
 * 功能描述: 算法枚举 <br/>
 *
 */
@Getter
@AllArgsConstructor
public enum CalcEnum {

    /***/
    ONLY_NUM(OnlyNumCalc.class, "唯余法", "唯一余数法（当前单元格中，候选数字只有一个）"),
    ONLY_BOX(OnlyBoxCalc.class, "摒除法", "摒除法（数字在所在行或列或宫中，只有一个空格能够填写，则确定是唯一数字）"),
    ;

    /**
     * 功能描述: 通过类，获取枚举 <br/>
     *
     * @param clazz 类
     * @return "com.suduku.calc.enums.CalcEnum"
     */
    public static CalcEnum indexOf(Class<? extends AbstractCalc> clazz) {
        for(CalcEnum ce : CalcEnum.values()) {
            if(clazz.equals(ce.getClazz())) {
                return ce;
            }
        }
        return null;
    }

    private Class<? extends AbstractCalc> clazz;
    private String name;
    private String msg;

}

SudoListener 和 SudoPrintImpl

并且在打印监听是，发现输出格式不是很友好，优化了监听内容

package com.suduku.listener;

import com.suduku.calc.AbstractCalc;
import com.suduku.entity.Box;

import java.util.List;

/**
 * 监听接口 <br/>
 *
 * @author chena
 */
public interface SudoListener {

    /**
     * 功能描述: 发送提示信息 <br/>
     * 
     * @param msg 消息内容
     */
    void sendMsg(String msg, Object ...args);

    /**
     * 功能描述: 改变内容 <br/>
     *
     * @param list 数独列表
     * @param b 单元格
     */
    void change(List<Box> list, Box b);

    /**
     * 功能描述: 使用算法 <br/>
     *
     * @param ac 算法
     */
    void useCalc(AbstractCalc ac);

}

package com.suduku.listener.impl;

import com.suduku.calc.AbstractCalc;
import com.suduku.entity.Box;
import com.suduku.listener.SudoListener;
import com.suduku.util.SudoUtil;

import java.util.List;
import java.util.stream.Collectors;

/**
 * 数独输出实现监听 <br/>
 *
 * @author chena
 */
public class SudoPrintImpl implements SudoListener {

    @Override
    public void sendMsg(String msg, Object ...args) {
        System.out.printf(msg, args);
    }

    @Override
    public void change(List<Box> list, Box b) {
        sendMsg("确认位置【行：%d，列：%d】\t值为：【%d】\t候选值为：【%s】\n",
                b.getX() + 1, b.getY() + 1, b.getV(),
                b.getCList().stream().map(String::valueOf).collect(Collectors.joining(",")));
        SudoUtil.print(list, b);
    }

    @Override
    public void useCalc(AbstractCalc ac) {
        sendMsg("尝试【\t%s\t】\n", ac.getCalcEnum().getName());
    }
    
}

DataConstant

新增数独数据 XING_01_50，将原先数独名修改为：RANDOM_01_01

 /** 一星50关 */
    public static final String XING_01_50 = "006800005080200007050347200000000013003009000800000500000060080000403000700100020";

代码详情

代码地址

总结

通过一边编写逻辑，一边优化框架的过程中，不断的进行抽象和封装。使框架和代码具有更好的扩展和易于使用。