class Solution:
    def isSolvable(self, words: List[str], result: str) -> bool:
        """
        Process digits from right to left (like real addition)
        """
        # Setup
        all_words = words + [result]
        leading_chars = set(word[0] for word in all_words if len(word) > 1)
        max_len = max(len(word) for word in all_words)
        
        # Quick validation: result can't be shorter than longest addend
        if len(result) < max_len:
            return False
        
        def dfs(col, word_idx, carry, char_to_digit, used_digits):
            """
            col: current column index (0 = rightmost/ones place)
            word_idx: which word we're processing in this column
            carry: carry from previous column
            char_to_digit: mapping of characters to digits
            used_digits: set of already-used digits
            """
            
            # Base case: processed all columns
            if col == max_len:
                return carry == 0  # valid only if no leftover carry
            
            # Processed all words in this column: verify the sum
            if word_idx == len(all_words):
                # Calculate sum of this column's digits from all addends
                column_sum = carry
                for word in words:
                    if col < len(word):
                        column_sum += char_to_digit[word[~col]]
                
                # Check if column sum matches result digit
                result_digit = char_to_digit[result[~col]]
                if column_sum % 10 != result_digit:
                    return False  # Prune: column doesn't match
                
                # Move to next column with new carry
                return dfs(col + 1, 0, column_sum // 10, char_to_digit, used_digits)
            
            # Skip if current word is too short for this column
            if word_idx < len(words) and col >= len(words[word_idx]):
                return dfs(col, word_idx + 1, carry, char_to_digit, used_digits)
            
            # Get current character
            char = all_words[word_idx][~col]
            
            # If already assigned, continue to next word
            if char in char_to_digit:
                return dfs(col, word_idx + 1, carry, char_to_digit, used_digits)
            
            # Try assigning each valid digit (backtracking)
            start_digit = 1 if char in leading_chars else 0
            
            for digit in range(start_digit, 10):
                if digit in used_digits:
                    continue
                
                # Assign digit
                char_to_digit[char] = digit
                used_digits.add(digit)
                
                # Recurse
                if dfs(col, word_idx + 1, carry, char_to_digit, used_digits):
                    return True
                
                # Backtrack
                del char_to_digit[char]
                used_digits.remove(digit)
            
            return False
        
        return dfs(0, 0, 0, {}, set())
10. Regular Expression Matching

Approach
