golang版使用队列秒解数独

本文找了两个不同版本的算法实现的数独解法，均转译成golang版本。最后以执行时间对比相互之间的效率。
需要填充的数字，以数字0表达。

{0,2,5,0},{0,7,8,3,4,{5,1,8},{2,9,

第一版，参考一个网上找的C++版
原文链接

package main

import (
    "fmt"
)
var sign = false

var Sudoku = [9][9]int{
    {0, 0, 2, 5, 0},{0, 7, 8, 3, 4,{5, 1, 8},{2, 9,}


func main() {
    DFS(0)
    Output(Sudoku)
}

func Output(sudoku [9][9]int) {
    for i := 0; i < 81; i++ {
        fmt.Printf("%2d ",sudoku[i/9][i%9])
        if i != 0 && (i+1)%9 == 0 {
            fmt.Println("")
        }
    }
}

func Check(n int,key int) bool {
    for i := 0; i < 9; i++ {
        r := n / 9
        if Sudoku[r][i] == key {
            return false
        }
    }

    for i := 0; i < 9; i++ {
        c := n % 9
        if Sudoku[i][c] == key {
            return false
        }
    }

    x := n / 9 / 3 * 3
    y := n % 9 / 3 * 3

    for i := x; i < x+3; i++ {
        for j := y; j < y+3; j++ {
            if Sudoku[i][j] == key {
                return false
            }
        }
    }

    return true
}

func DFS(n int) {
    if n > 80 {
        sign = true
        return
    }

    if Sudoku[n/9][n%9] != 0 {
        DFS(n + 1)
    } else {
        for v := 1; v <= 9; v++ {
            if Check(n,v) {
                Sudoku[n/9][n%9] = v
                DFS(n + 1)
                if sign {
                    return
                }
                Sudoku[n/9][n%9] = 0
            }
        }
    }
}

执行时间如下图所示：

第二版参考一个python实现的版本

这个版本代码比较长，感兴趣的朋友可以去我的github查看源码

第一版实现采用了DFS深度搜索遍历解数独，但因为是深度搜索所以算法上效率较低，做了太多无用功。
第二版使用了队列和栈回溯解数独，效率上比较高。但在开发时间的对比，使用了golang花的时间恰好相反。

C++版本约半个小时就实现了，因为golang也是c系家族的一员，同是静态语言，所以实现并需花太多时间思考。

而python版牺牲了我约一周的空余时间，中间还遇到挺多问题，很沮丧差点放弃，之所以花了那么长时间，
python有现成的map,filter方法可以直接调用。而golang官方并无现成的包去实现这些功能，需要自己去考虑实现。

在场合上面，可以看出动态类型语言与静态类型语言天生不一样，动态类型语言开发快，执行效率稍慢。静态语言类型开发较花时间，执行效率高。

源码地址：https://github.com/ivaners/data_structure/tree/master/sudoku