Swift 如何更改递归代码以连接所有磁贴，而不多次交叉磁贴？

下面是我试图让我的Swift代码执行的操作的图片：

我已经在瓷砖上标上了数字。磁贴3和8被禁用。6是起点，0是目标

注意：指定了起点，但未指定终点。端点可以是任何位置，只要路径穿过所有平铺。在我的示例中，我只是指定了0以使其更简单，但实际上并没有指定它

我只能水平或垂直行走。通往目标的道路不止一条，但我需要找到一条能一次通过所有数字的道路。我已经在图像中标记了这条路径（6,7,4,5,2,1,0）

现在我有下面的代码，它首先获取每个图块的所有直接连接，然后使用递归来查找路径。目前我的代码给我的路径是6,7,4,1,0，它不经过5和2，因此不是我想要的

我不知道如何更改我的代码以获得通过所有分幅的路径

let size = (rows: 3, columns: 3)
let off = [3,8]
let start : Int = 6
let finish : Int = 0
var connections = [Int:[Int]]()
var path = [Int]()
var visited = [Int]()

func backtrackingStuff() {
    
    for index in 0..<size.rows * size.columns {
        if !off.contains(index) {
            
            let rowStart : Int = index - index%size.columns
            let rowEnd : Int = rowStart + size.columns - 1
            
            var temp = [Int]()
            let possibleUpperConnection : Int = index - size.columns
            if possibleUpperConnection >= 0 && !off.contains(possibleUpperConnection) {
                temp.append(possibleUpperConnection)
            }
            let possibleBottomConnection : Int = index + size.columns
            if possibleBottomConnection <= (size.rows * size.columns - 1) && !off.contains(possibleBottomConnection) {
                temp.append(possibleBottomConnection)
            }
            
            let possibleLeftConnection : Int = index - 1
            if possibleLeftConnection >= rowStart && !off.contains(possibleLeftConnection) {
                temp.append(possibleLeftConnection)
            }
            
            let possibleRightConnection : Int = index + 1
            if possibleRightConnection <= rowEnd && !off.contains(possibleRightConnection) {
                temp.append(possibleRightConnection)
            }
            
            connections[index] = temp
        }
    }
    
    print("V: \(NSSet(array: Array(connections.keys)))")
    
    getPaths(currentPosition: start)
    
    print("Path: \(path)")
}

func getPaths (currentPosition : Int) -> Bool {
    
    //if NSSet(array: possiblePath).isEqual(to: NSSet(array: Array(connections.keys)) as! Set<AnyHashable>) { {
    if currentPosition == finish {
        path.insert(currentPosition, at: 0)
        return true
    }
    
    visited.append(currentPosition)
    
    if let connectionsForThisIndex = connections[currentPosition] {
        for newIndex in connectionsForThisIndex {
            if !visited.contains(newIndex) {
                if getPaths(currentPosition: newIndex) {
                    path.insert(currentPosition, at: 0)
                    return true
                }
            }
        }
    }
    
    return false
}

let size=（行：3，列：3）
送经=[3,8]
让我们开始：Int=6
让我们结束：Int=0
变量连接=[Int:[Int]]（）
变量路径=[Int]（）
访问的变量=[Int]（）
func backtrackingstaff（）{
对于0..=0&&！off.contains中的索引（可能的UpperConnection）{
临时附加（可能的UpperConnection）
}
让possibleBottomConnection:Int=index+size.columns
如果possibleBottomConnection=rowStart&！off.contains（possibleLeftConnection）{
临时附加（可能的EleftConnection）
}
let possibleRightConnection:Int=index+1
如果可能的话，右连接布尔{
//如果NSSet（array:possiblePath）.isEqual（to:NSSet（array:array（connections.keys））as！Set）{{
如果currentPosition==完成{
路径.插入（当前位置，位于：0）
返回真值
}
已访问。追加（当前位置）
如果let connectionsForThisIndex=连接[currentPosition]{
用于连接中的新索引用于此索引{
if！visted.contains（newIndex）{
if getpath（当前位置：newIndex）{
路径.插入（当前位置，位于：0）
返回真值
}
}
}
}
返回错误
}

是指定了起点/终点，还是由您来确定？@Alexander指定了起点，但没有指定终点。只要路径穿过所有分片，终点可以是任何位置。在我的示例中，我只是指定了0以简化操作，但实际上不会指定。明白了！我可以尝试一下 later@Alexander谢谢！我会等的。@Alexander嘿，很抱歉打扰你。你能试一试吗？是指定了起点/终点，还是由你来决定？@Alexander指定了起点，但没有指定终点。终点可以是任何地方，只要路径穿过所有瓷砖。在我的示例中，我只是已指定0以使其更简单，但实际上不会指定它。明白了！我可以尝试一下later@Alexander谢谢！我会等的。@Alexander嘿，很抱歉打扰你。你能试一试吗？