1307. Verbal Arithmetic Puzzle

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

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

• Each character is decoded as one digit (0 - 9).
• Every pair of different characters they must map to different digits.
• Each words[i] and result are decoded as one number without leading zeros.
• Sum of numbers on left side (words) will equal to the number on 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 = ["THIS","IS","TOO"], result = "FUNNY"
Output: true

Example 4:

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

 

Constraints:

• 2 <= words.length <= 5
• 1 <= words[i].length, result.length <= 7
• words[i], result contains only upper case English letters.
• Number of different characters used on the expression is at most 10.

思路：直接DFS复杂度太高，最好按照自己玩这个游戏的方式来，这样能剪枝不少。

比如 words = ["SEND","MORE"], result = "MONEY"，对于个位的D+E=Y，这就限制了DEY的取值，在第一步的时候就可以剪枝

class Solution(object):
    def isSolvable(self, words, result):
        """
        :type words: List[str]
        :type result: str
        :rtype: bool
        """
        from itertools import permutations
        # do as what you will do!
        n = max([len(s) for s in words] + [len(result)])
        if n!=len(result): return False
        ss = [s[::-1] for s in words]
        rr = result[::-1]
        starts = set([word[0] for word in words] + [result[0]])
        map = {}

        def get_unused_pairs(nn):
            used = set(map.values())
            unused = [i for i in range(10) if i not in used]
            return permutations(unused, nn)


        def dfs(idx, jinwei):
            if idx==n: return not any(map[c]==0 for c in starts)

            chars = [ss[i][idx] for i in range(len(ss)) if idx<len(ss[i])] + [rr[idx]]
            to_map_chars = [c for c in chars if c not in map]
            to_map_chars_unique = list(set(to_map_chars))
            pairs = list(get_unused_pairs(len(to_map_chars_unique)))
            for map_nums in pairs:
                for to_map_char,map_num in zip(to_map_chars_unique,map_nums):
                    map[to_map_char] = map_num
                left = sum([map[c] for c in chars[:-1]])+jinwei
                right = map[chars[-1]]
                if left%10 == right:
                    if dfs(idx+1, left//10):
                        return True
                for to_map_char in to_map_chars_unique:
                    del map[to_map_char]

            return False

        return dfs(0, 0)

s=Solution()
print(s.isSolvable(words = ["SEND","MORE"], result = "MONEY"))
print(s.isSolvable(words = ["SIX","SEVEN","SEVEN"], result = "TWENTY"))
print(s.isSolvable(words = ["THIS","IS","TOO"], result = "FUNNY"))
print(s.isSolvable(words = ["LEET","CODE"], result = "POINT"))
print(s.isSolvable(["AB","CD","EF"], "GHIJ"))