1、原题目描述：

Given a list of words, list of  single letters (might be repeating) and score of every character.

Return the maximum score of any valid set of words formed by using the given letters (words[i] cannot be used two or more times).

It is not necessary to use all characters in letters and each letter can only be used once. Score of letters 'a', 'b', 'c', ... ,'z' is given by score[0], score[1], ... , score[25] respectively.

 

Example 1:

Input: words = ["dog","cat","dad","good"], letters = ["a","a","c","d","d","d","g","o","o"], score = [1,0,9,5,0,0,3,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0]
Output: 23
Explanation:
Score  a=1, c=9, d=5, g=3, o=2
Given letters, we can form the words "dad" (5+1+5) and "good" (3+2+2+5) with a score of 23.
Words "dad" and "dog" only get a score of 21.

Example 2:

Input: words = ["xxxz","ax","bx","cx"], letters = ["z","a","b","c","x","x","x"], score = [4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,10]
Output: 27
Explanation:
Score  a=4, b=4, c=4, x=5, z=10
Given letters, we can form the words "ax" (4+5), "bx" (4+5) and "cx" (4+5) with a score of 27.
Word "xxxz" only get a score of 25.

Example 3:

Input: words = ["leetcode"], letters = ["l","e","t","c","o","d"], score = [0,0,1,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0]
Output: 0
Explanation:
Letter "e" can only be used once.

 

Constraints:

• 1 <= words.length <= 14
• 1 <= words[i].length <= 15
• 1 <= letters.length <= 100
• letters[i].length == 1
• score.length == 26
• 0 <= score[i] <= 10
• words[i], letters[i] contains only lower case English letters.

2、简要翻译：

输入：字符串列表 words ，字符列表letters（给出允许出现的字符和个数的限制），分数列表 score (长度为26，代表每个字符的得分)

输出：用letters 中的字符拼接words 中的字符串，给出最大得分。

 

3、代码思路：

用回溯法遍历各种可能性，时间复杂度 O（2^n），可以使用一些剪枝的技巧。

 

4、JAVA代码实现：

private static int result;
    private static Map<String, Integer> scoreMap = null;
    private static int[] lettersNumber;

    public int maxScoreWords(String[] words, char[] letters, int[] score) {
        result = 0;
        scoreMap = new HashMap<>();
        lettersNumber = new int[26];
        char[] chars;
        int wordScore;
        for (String word : words) {
            chars = word.toCharArray();
            wordScore = 0;
            for (char aChar : chars) {
                wordScore += score[aChar - 'a'];
            }
            scoreMap.put(word, wordScore);
        }
        for (char letter : letters) {
            lettersNumber[letter - 'a']++;
        }
        Arrays.sort(words, (a, b) -> scoreMap.get(b) - scoreMap.get(a));
        dfsHelper(0, 0, words);
        return result;
    }

    private void dfsHelper(int score, int index, String[] words) {
        if (index >= words.length) {
            result = Math.max(result, score);
            return;
        }
        String word = words[index];
        if ((score + scoreMap.get(word) * (words.length - index)) <= result) {
            return;
        }
        char[] chars = word.toCharArray();
        int len = 0;
        for (char aChar : chars) {
            if (lettersNumber[aChar - 'a'] > 0) {
                lettersNumber[aChar - 'a']--;
                len++;
            } else {
                break;
            }
        }
        if (len == chars.length) {
            score += scoreMap.get(word);
            dfsHelper(score, index + 1, words);
            score -= scoreMap.get(word);
        }
        for (int i = 0; i < len; i++) {
            lettersNumber[chars[i] - 'a']++;
        }
        dfsHelper(score, index + 1, words);
    }