[LeetCode] 784. Letter Case Permutation

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

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

Example 1:

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

Example 2:

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

Example 3:

Input: s = "12345"
Output: ["12345"]

Example 4:

Input: s = "0"
Output: ["0"]

Constraints:

• s will be a string with length between 1 and 12.
• s will consist only of letters or digits.

字母大小写全排列。

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

我这里提供三种做法，一种就是简单的遍历，一种 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 经典的模板的基础上稍作变化。遇到数字就直接递归到下一层，遇到字母的时候需要用大小写分别递归到下一层。

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

空间O(2^n * n)

Java实现

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

        // normal case
        helper(res, 0, s.toCharArray());
        return res;
    }

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

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 题目总结