LeetCode每日一题(1307. Verbal Arithmetic Puzzle)

Given an equation, represented by words on the left side and the result on the right side.

You need to check if the equation is solvable under the following rules:

Each character is decoded as one digit (0 - 9).
No two characters can map to the same digit.
Each words[i] and result are decoded as one number without leading zeros.
Sum of numbers on the left side (words) will equal to the number on the right side (result).
Return true if the equation is solvable, otherwise return false.

Example 1:

Input: words = [“SEND”,“MORE”], result = “MONEY”
Output: true

Explanation: Map ‘S’-> 9, ‘E’->5, ‘N’->6, ‘D’->7, ‘M’->1, ‘O’->0, ‘R’->8, ‘Y’->‘2’
Such that: “SEND” + “MORE” = “MONEY” , 9567 + 1085 = 10652

Example 2:

Input: words = [“SIX”,“SEVEN”,“SEVEN”], result = “TWENTY”
Output: true

Explanation: Map ‘S’-> 6, ‘I’->5, ‘X’->0, ‘E’->8, ‘V’->7, ‘N’->2, ‘T’->1, ‘W’->‘3’, ‘Y’->4
Such that: “SIX” + “SEVEN” + “SEVEN” = “TWENTY” , 650 + 68782 + 68782 = 138214

Example 3:

Input: words = [“LEET”,“CODE”], result = “POINT”
Output: false

Explanation: There is no possible mapping to satisfy the equation, so we return false.
Note that two different characters cannot map to the same digit.

Constraints:

• 2 <= words.length <= 5
• 1 <= words[i].length, result.length <= 7
• words[i], result contain only uppercase English letters.
• The number of different characters used in the expression is at most 10.

---

从低位到高位做加法， 最终 result 对应的位要等于 sum % 10, 如果不能符合， 直接返回 false

---

impl Solution {
    fn rc(words: &Vec<Vec<char>>, result: &Vec<char>, i: usize, j: usize, steps: i32, curr: i32, vals: &mut Vec<i32>, occupied: &mut Vec<bool>) -> bool {
        // 当处理完最后一个单词时，对result中对应的位进行处理
        if i == words.len() {
            let c = result[j];
            // 如果当前位是result的最后一位， 也就是整个匹配工作的末尾， 我们检查result的最后一位是否与当前的进位值+当前值匹配
            if j == result.len() - 1 {
                if steps + curr == 0 || steps + curr > 9 {
                    return false;
                }
                // 如果result最后一位还没有定数字，并且目标数字还没有被占用。或者已经定了数字，且数字与我们的目标数字相符， 则等式可以成立
                if (vals[c as usize - 65] == 10 && !occupied[(steps + curr) as usize]) || steps + curr == vals[c as usize - 65] {
                    return true;
                }
                return false;
            }
            // 不是result的最后一位，且result当前位还没有定数字， result的当前位仅需要能匹配(steps + curr) % 10
            if vals[c as usize - 65] == 10 {
                let v = (steps + curr) % 10;
                if occupied[v as usize] {
                    return false;
                }
                vals[c as usize - 65] = v;
                occupied[v as usize] = true;
                let next = Solution::rc(words, result, 0, j + 1, (steps + curr) / 10, 0, vals, occupied);
                if next {
                    return true;
                }
                vals[c as usize - 65] = 10;
                occupied[v as usize] = false;
                return false;
            }
            // 如果result当前位已经定了数字
            if vals[c as usize - 65] != (steps + curr) % 10 {
                return false;
            }
            let next = Solution::rc(words, result, 0, j + 1, (steps + curr) / 10, 0, vals, occupied);
            if next {
                return true;
            }
            return false;
        }
        // 匹配word中的字符
        if let Some(&c) = words[i].get(j) {
            // 如果当前位已经定了数字
            if vals[c as usize - 65] != 10 {
                // 排除多位数字，首位数字为0的情况
                if words[i].len() > 1 && j == words[i].len() - 1 && vals[c as usize - 65] == 0 {
                    return false;
                }
                let next = Solution::rc(words, result, i + 1, j, steps, curr + vals[c as usize - 65], vals, occupied);
                if next {
                    return true;
                }
                return false;
            }
            // 遍历所有可用数字， 排除多位数字首位为0的情况
            for d in if j == 0 || j < words[i].len() - 1 { 0..10 } else { 1..10 } {
                if !occupied[d as usize] {
                    vals[c as usize - 65] = d;
                    occupied[d as usize] = true;
                    let next = Solution::rc(words, result, i + 1, j, steps, curr + d, vals, occupied);
                    if next {
                        return true;
                    }
                    vals[c as usize - 65] = 10;
                    occupied[d as usize] = false;
                    continue;
                }
            }
            return false;
        }
        return Solution::rc(words, result, i + 1, j, steps, curr, vals, occupied);
    }

    pub fn is_solvable(words: Vec<String>, result: String) -> bool {
        let mut words: Vec<Vec<char>> = words
            .into_iter()
            .map(|w| {
                let mut l = w.chars().collect::<Vec<char>>();
                l.reverse();
                l
            })
            .collect();
        let mut result: Vec<char> = result.chars().collect();
        result.reverse();
        if words.iter().any(|w| w.len() > result.len()) {
            return false;
        }
        Solution::rc(&mut words, &mut result, 0, 0, 0, 0, &mut vec![10; 26], &mut vec![false; 10])
    }
}