[Swift]LeetCode1138. 字母板上的路径 | Alphabet Board Path

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/11258427.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

On an alphabet board, we start at position (0, 0), corresponding to character board[0][0].

Here, board = ["abcde", "fghij", "klmno", "pqrst", "uvwxy", "z"].

We may make the following moves:

• 'U' moves our position up one row, if the square exists;
• 'D' moves our position down one row, if the square exists;
• 'L' moves our position left one column, if the square exists;
• 'R' moves our position right one column, if the square exists;
• '!' adds the character board[r][c] at our current position (r, c) to the answer.

Return a sequence of moves that makes our answer equal to target in the minimum number of moves.  You may return any path that does so. 

Example 1:

Input: target = "leet"
Output: "DDR!UURRR!!DDD!"

Example 2:

Input: target = "code"
Output: "RR!DDRR!UUL!R!" 

Constraints:

• 1 <= target.length <= 100
• target consists only of English lowercase letters.

---

我们从一块字母板上的位置 (0, 0) 出发，该坐标对应的字符为 board[0][0]。

在本题里，字母板为board = ["abcde", "fghij", "klmno", "pqrst", "uvwxy", "z"].

我们可以按下面的指令规则行动：

• 如果方格存在，'U' 意味着将我们的位置上移一行；
• 如果方格存在，'D' 意味着将我们的位置下移一行；
• 如果方格存在，'L' 意味着将我们的位置左移一列；
• 如果方格存在，'R' 意味着将我们的位置右移一列；
• '!' 会把在我们当前位置 (r, c) 的字符 board[r][c] 添加到答案中。

返回指令序列，用最小的行动次数让答案和目标 target 相同。你可以返回任何达成目标的路径。 

示例 1：

输入：target = "leet"
输出："DDR!UURRR!!DDD!"

示例 2：

输入：target = "code"
输出："RR!DDRR!UUL!R!" 

提示：

• 1 <= target.length <= 100
• target 仅含有小写英文字母。

---

Runtime: 4 ms

Memory Usage: 20.3 MB

class Solution {
    func alphabetBoardPath(_ target: String) -> String {
        var x:Int = 0
        var y:Int = 0
        var res:String = String()
        let arrTarget:[Int] = Array(target).map{$0.ascii}
        for ch in arrTarget
        {
            var x1:Int = (ch - 97) % 5
            var y1:Int = (ch - 97) / 5
            let str:String = String(repeating:"U",count:max(0, y - y1)) + String(repeating:"R",count:max(0, x1 - x)) + String(repeating:"L",count:max(0, x - x1)) + String(repeating:"D",count:max(0, y1 - y)) + "!"       
            res += str
            x = x1
            y = y1
        }
        return res
    }
}

//Character扩展 
extension Character  
{  
  //Character转ASCII整数值(定义小写为整数值)
   var ascii: Int {
       get {
           return Int(self.unicodeScalars.first?.value ?? 0)
       }       
    }
}

---

4ms 

class Solution {
    func alphabetBoardPath(_ target: String) -> String {
        let board: [Character: (row: Int, col: Int)] = ["a": (0, 0), "b": (0, 1), "c": (0, 2), "d": (0, 3), "e": (0, 4),
                                                    "f": (1, 0), "g": (1, 1), "h": (1, 2), "i": (1, 3), "j": (1, 4),
                                                    "k": (2, 0), "l": (2, 1), "m": (2, 2), "n": (2, 3), "o": (2, 4),
                                                    "p": (3, 0), "q": (3, 1), "r": (3, 2), "s": (3, 3), "t": (3, 4),
                                                    "u": (4, 0), "v": (4, 1), "w": (4, 2), "x": (4, 3), "y": (4, 4),
                                                    "z": (5, 0)
                                                    ]
    
        var prevChar: Character = "a"
        var moves: String = ""
    
        for eachChar in [Character](target) {

            while eachChar != prevChar {
                switch prevChar {
                    case "z":
                        moves += "U"
                        prevChar = "u"
                        continue

                    default:
                        let leftOrRight = board[eachChar]!.col - board[prevChar]!.col
                        let upOrDown = board[eachChar]!.row - board[prevChar]!.row

                        switch leftOrRight.signum() { // Move Left or Right
                            case -1:
                                moves += repeatElement("L", count: -leftOrRight)
                            case 1:
                                moves += repeatElement("R", count:  leftOrRight)
                            default:
                                moves.append("")
                        }

                        switch upOrDown.signum() { // Then Move Up or Down
                            case -1:
                                moves += repeatElement("U", count: -upOrDown)
                            case 1:
                                moves += repeatElement("D", count:  upOrDown)
                            default:
                                moves.append("")
                    }
                }
                prevChar = eachChar
            }
            moves += "!"
        }
        return moves    
    }
}

---

8ms

class Solution {
    func position(of c: Character) -> (Int, Int) {
        let av = Int(c.asciiValue! - 97)
        return (av / 5, av % 5)
    }
    
    func path(from a: Character, to b: Character) -> String {
        guard a != b else {
            return ""
        }
        
        let posA = position(of: a)
        let posB = position(of: b)
        
        if a == "z" {
            return String(repeating:"U", count:posA.0 - posB.0) + String(repeating:"R", count:posB.1 - posA.1)
        }
        if b == "z" {
            return String(repeating:"L", count: posA.1 - posB.1) + String(repeating:"D", count:posB.0 - posA.0)
        }
        
        return String(repeating:posA.0 > posB.0 ? "U" : "D", count: abs(posA.0 - posB.0)) + String(repeating:posA.1 > posB.1 ? "L" : "R", count: abs(posA.1 - posB.1))
    }
    
    func alphabetBoardPath(_ target: String) -> String {
        var result = ""
        var cc : Character = "a"
        for c in target { 
           result += path(from: cc, to: c) + "!"
           cc = c 
        }
        return result
    }
}

---

20ms

class Solution {
    let board: [[Character]] = [Array("abcde"), Array("fghij"), Array("klmno"), Array("pqrst"), Array("uvwxy"), Array("z")]
    let boardHash: [Character:Position] = 
    ["a": Position(0,0), "b": Position(0,1), "c": Position(0,2), "d": Position(0,3), "e": Position(0,4), 
     "f": Position(1,0), "g": Position(1,1), "h": Position(1,2), "i": Position(1,3), "j": Position(1,4), 
     "k": Position(2,0), "l": Position(2,1), "m": Position(2,2), "n": Position(2,3), "o": Position(2,4), 
     "p": Position(3,0), "q": Position(3,1), "r": Position(3,2), "s": Position(3,3), "t": Position(3,4), 
     "u": Position(4,0), "v": Position(4,1), "w": Position(4,2), "x": Position(4,3), "y": Position(4,4), 
     "z": Position(5,0)]
    
    func alphabetBoardPath(_ target: String) -> String {
        var hash = [Key:[Character]]()
        return String(_alphabetBoardPath(Array(target), 0, Position(0,0), &hash))
    }
    
    func _alphabetBoardPath(_ target: [Character],
                            _ i: Int,
                            _ position: Position,
                            _ hash: inout [Key:[Character]]) -> [Character] {
        if i >= target.count { return [] }
        
        let targetPosition = boardHash[target[i]]!
        // let index = Key(i, position, visited)
        // if let savedSolution = hash[index] { return savedSolution }
        
        var solution: [Character] = []
        if targetPosition == position {
            solution = ["!"] + _alphabetBoardPath(target, i+1, position, &hash)
        } else {
            let downP = Position(position.i+1, position.j)
            let upP = Position(position.i-1, position.j)
            let rightP = Position(position.i, position.j+1)
            let leftP = Position(position.i, position.j-1)
            
            if targetPosition.i == position.i {
                if position.j < targetPosition.j {
                    solution = ["R"] + _alphabetBoardPath(target, i, rightP, &hash)
                } else {
                    solution = ["L"] + _alphabetBoardPath(target, i, leftP, &hash)
                }
            } 
            else {
                if position.i < targetPosition.i {
                    if downP.isValid(for: board) {
                        solution = ["D"] + _alphabetBoardPath(target, i, downP, &hash)        
                    } else {
                        solution = ["L"] + _alphabetBoardPath(target, i, leftP, &hash)
                    }
                    
                } else {
                    solution = ["U"] + _alphabetBoardPath(target, i, upP, &hash)
                }
            }
        }
        
        // hash[index] = solution
        return solution
    }
}

struct Key: Hashable {
    let i: Int
    let position: Position
    let visited: Set<Position>
    
    init(_ i: Int, _ position: Position, _ visited: Set<Position>) {
        self.i = i
        self.position = position
        self.visited = visited
    }
}

struct Position: Hashable {
    let i: Int
    let j: Int
    
    init(_ i: Int, _ j: Int) {
        self.i = i
        self.j = j
    }
    
    func isValid(for board: [[Character]]) -> Bool {
        return i >= 0 && i < board.count && j >= 0 && j < board[i].count
    }
}