[LeetCode] 784. Letter Case Permutation

Given a string s, you can transform every letter individually to be lowercase or uppercase to create another string.

Return a list of all possible strings we could create. Return the output in any order.

Example 1:

Input: s = "a1b2"
Output: ["a1b2","a1B2","A1b2","A1B2"]

Example 2:

Input: s = "3z4"
Output: ["3z4","3Z4"]

Constraints:

• 1 <= s.length <= 12
• s consists of lowercase English letters, uppercase English letters, and digits.

字母大小写全排列。

给定一个字符串 s ，通过将字符串 s 中的每个字母转变大小写，我们可以获得一个新的字符串。

返回 所有可能得到的字符串集合 。以 任意顺序 返回输出。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/letter-case-permutation
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题意是给一个字符串，请你返回他的大小写全排列，意思是每当遇到其中的字母的时候，需要大写字母有一份，小写字母也有一份。

我这里提供三种做法，一种就是简单的遍历，一种 DFS，一种 BFS。

首先是遍历。开始遍历 input 字符串，并且创建一个 list of StringBuilder，当遇到数字的时候就直接将数字加入每一个 StringBuilder；当遇到字母的时候，需要遍历之前创建过的每一个 StringBuilder，并将当前遍历到的字母，大写 copy 一份，小写也 copy 一份。

时间O(2^n * n) - n是字符串的长度

空间O(2^n * n)

Java实现

class Solution {
    public List<String> letterCasePermutation(String S) {
        List<StringBuilder> ans = new ArrayList<>();
        ans.add(new StringBuilder());
        for (char c : S.toCharArray()) {
            int n = ans.size();
            if (Character.isLetter(c)) {
                for (int i = 0; i < n; i++) {
                    ans.add(new StringBuilder(ans.get(i)));
                    ans.get(i).append(Character.toLowerCase(c));
                    ans.get(n + i).append(Character.toUpperCase(c));
                }
            } else {
                for (int i = 0; i < n; i++) {
                    ans.get(i).append(c);
                }
            }
        }
        List<String> res = new ArrayList<>();
        for (StringBuilder sb : ans) {
            res.add(sb.toString());
        }
        return res;
    }
}

 

DFS/backtracking。会在 backtracking 经典的模板的基础上稍作变化。遇到数字就直接递归到下一层，遇到字母的时候需要用大小写分别递归到下一层。

时间O(2^n * n) - n是字符串的长度

空间O(2^n * n)

Java实现

class Solution {
    public List<String> letterCasePermutation(String s) {
        List<String> res = new ArrayList<>();
        helper(res, 0, s.toCharArray());
        return res;
    }

    private void helper(List<String> res, int index, char[] letters) {
        if (index == letters.length) {
            res.add(new String(letters));
            return;
        }
        if (Character.isLetter(letters[index])) {
            letters[index] = Character.toUpperCase(letters[index]);
            helper(res, index + 1, letters);
            letters[index] = Character.toLowerCase(letters[index]);
            helper(res, index + 1, letters);
        } else {
            helper(res, index + 1, letters);
        }
    }
}

 

BFS

时间O(2^n * n) - n是字符串的长度

空间O(n) - queue

Java实现

class Solution {
    public List<String> letterCasePermutation(String S) {
        // corner case
        if (S == null || S.length() == 0) {
            return new LinkedList<>();
        }

        // normal case
        Queue<String> queue = new LinkedList<>();
        queue.offer(S);
        for (int i = 0; i < S.length(); i++) {
            if (Character.isDigit(S.charAt(i))) {
                continue;
            }
            int size = queue.size();
            for (int j = 0; j < size; j++) {
                String cur = queue.poll();
                char[] chs = cur.toCharArray();

                chs[i] = Character.toUpperCase(chs[i]);
                queue.offer(String.valueOf(chs));

                chs[i] = Character.toLowerCase(chs[i]);
                queue.offer(String.valueOf(chs));
            }
        }
        // return new LinkedList<>(queue);
        List<String> res = new ArrayList<>();
        while (!queue.isEmpty()) {
            res.add(queue.poll());
        }
        return res;
    }
}

 

LeetCode 题目总结