Arrays 优化大型阵列中的值比较-Go

我试图学习围棋，并试图解决这里解释的问题

我提出了一个可行的解决方案，但一旦问题变得复杂，计算就需要很长时间，实际上需要运行数小时而无法解决问题，因此我认为我需要以某种方式优化我的解决方案。下面是我的代码

package main

import "fmt"

func main() {
    fmt.Println(wall(18, 10))
}

func wall(width, height int) int64 {

    var total int64

    combinations := findCombinations(width)

    combiPointer := &combinations

    for i := 0; i < 4; i++ {
        for _, a := range combinations[i] {
            if i%2 == 0 {
                buildWall(a, combiPointer[i+1], 0, height, i+1, &total, combiPointer)
            } else {
                buildWall(a, combiPointer[i-1], 0, height, i-1, &total, combiPointer)
            }
        }
    }
return total
}

func buildWall(a []int, combi [][]int, level, height, index int, total *int64, pointer *[4][][]int) {
level++
var canCombine bool
for _, a1 := range combi {
    canCombine = true
    for _, value := range a {
            if canCombine == false {
                break
            }
            for _, value1 := range a1 {
                if value == value1 {
                    canCombine = false
                    break
                }
            }
        }
        if canCombine == true && level < height {

            if index%2 == 0 {
                buildWall(a1, pointer[index+1], level, height, index+1, total, pointer)
            } else {
                buildWall(a1, pointer[index-1], level, height, index-1, total, pointer)
            }
        } else if level == height {
            *total++
            break
        }
    }
}

主程序包
输入“fmt”
func main（）{
fmt.Println（墙（18、10））
}
func墙（宽度、高度int）int64{
var总计int64
组合：=查找组合（宽度）
组合机：=&组合
对于i:=0；i<4；i++{
对于u，a:=范围组合[i]{
如果i%2==0{
建筑墙（a，combiPointer[i+1]，0，高度，i+1和总计，combiPointer）
}否则{
建筑墙（a，combiPointer[i-1]，0，高度，i-1和总计，combiPointer）
}
}
}
返回总数
}
func buildWall（a[]int，combi[]int，level，height，index int，total*int64，pointer*[4][]int）{
水平仪++
坎康比恩布尔酒店
对于u，a1:=范围组合{
康康宾=真
对于u，值：=范围a{
如果canCombine==false{
打破
}
对于1，值1:=范围a1{
如果值==value1{
canCombine=false
打破
}
}
}
如果canCombine==真值和水平<高度{
如果索引%2==0{
建筑墙（a1，指针[索引+1]，标高，高度，索引+1，总计，指针）
}否则{
建筑墙（a1，指针[索引-1]，标高，高度，索引-1，总计，指针）
}
}如果标高=高度，则为else{
*总数++
打破
}
}
}

FindCompositions运行良好，返回一个包含所有可能解决方案的三维数组。[0]和[1]中的阵列可以（可能）相互重叠，而不会出现裂缝。[2]和[3]相同。我选择通过查看用于构建墙的第一个和最后一个块的位置，将所有解决方案的阵列分成4个阵列，因为我认为在较小的阵列上循环会提高性能

func findCombinations(width int) [4][][]int {
    var i int
    var tmp int
    var tmpInt1 int
    var tmpInt2 int
    open := make([][]int, 0, 100)
    var solutionsHolder [4][][]int
    open = append(open, []int{3, 2})
    tmpArray := make([]int, 0, 100)

    for {
        if len(open[i]) > 0 {
            tmpArray = append(tmpArray[:i], open[i][0])
            open[i] = append(open[i][:0], open[i][1:]...)
            counter := 0
            for _, x := range tmpArray {
                counter += x
            }
            if counter == width {
                solutionArray := make([]int, len(tmpArray)-1)
                counter2 := 0
                for n := 0; n < len(tmpArray)-1; n++ {
                    if n == 0 {
                        tmpInt1 = tmpArray[n] % 2
                    }
                    counter2 += tmpArray[n]
                    solutionArray[n] = counter2
                }
                tmpInt2 = counter2 % 2
                if tmpInt1 == 0 && tmpInt2 == 0 {
                    solutionsHolder[0] = append(solutionsHolder[0], solutionArray)
                } else if tmpInt1 == 1 && tmpInt2 == 1 {
                    solutionsHolder[1] = append(solutionsHolder[1], solutionArray)
                } else if tmpInt1 == 1 && tmpInt2 == 0 {
                    solutionsHolder[2] = append(solutionsHolder[2], solutionArray)
                } else {
                    solutionsHolder[3] = append(solutionsHolder[3], solutionArray)
                }

                for _, v := range open {
                    tmp += len(v)
                }
                if tmp == 0 {
                    return solutionsHolder
                }
                tmp = 0
            } else if counter > width {
                for _, v := range open {
                    tmp += len(v)
                }
                if tmp == 0 {
                   return solutionsHolder
                }
                tmp = 0
            } else if counter < width {
                i++
                if len(open) <= i {
                    open = append(open, []int{3, 2})
                } else {
                    open[i] = append(open[i], []int{3, 2}...)
                }
            }
        } else {
            i--
        }
    }
}

func find组合（宽度int）[4][]int{
变量i int
var tmp int
变量tmpInt1 int
变量tmpInt2 int
打开：=make（[]整型，0，100）
var solutionsHolder[4][]int
open=append（open，[]int{3，2}）
tmpArray:=make（[]整数，0，100）
为了{
如果len（open[i]）>0{
tmpArray=append（tmpArray[：i]，打开[i][0]）
打开[i]=追加（打开[i][：0]，打开[i][1:]…）
计数器：=0
对于ux:=范围tmpArray{
计数器+=x
}
如果计数器==宽度{
solutionArray:=make（[]整数，len（tmpArray）-1）
计数器2:=0
对于n:=0；n宽度{
对于u，v:=范围打开{
tmp+=len（v）
}
如果tmp==0{
返回解决方案持有者
}
tmp=0
}否则，如果计数器<宽度{
我++
如果len（打开）这个问题与Go无关，但与算法设计有关。这不是要求解决Project Euler问题的地方。如果您的解决方案需要运行数小时，您可能从错误的算法开始。它返回正确的结果，我检查了其他人已经计算过的值。它的效率不足以n在可接受的时间范围内解决（32,10）问题。是否有其他论坛可以让我询问此类问题。我不太擅长阐述我的问题，因此我不确定是否有专门讨论此类问题的论坛。很抱歉在错误的位置发布。