这是我参与2022首次更文挑战的第21天，活动详情查看：2022首次更文挑战

字母大小写全排列

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

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

示例 1：

输入：s = "a1b2" 输出：["a1b2", "a1B2", "A1b2", "A1B2"] 示例 2:

输入: s = "3z4" 输出: ["3z4","3Z4"]  

提示:

1 <= s.length <= 12 s 由小写英文字母、大写英文字母和数字组成

题解

算法一：DFS回溯（Java）

从左往右依次遍历字符，过程中保持 ans 为已遍历过字符的字母大小全排列。

例如，当 S = "abc" 时，考虑字母 "a", "b", "c"，初始令 ans = [""]，依次更新 ans = ["a", "A"]， ans = ["ab", "Ab", "aB", "AB"]， ans = ["abc", "Abc", "aBc", "ABc", "abC", "AbC", "aBC", "ABC"]。

如果下一个字符 c 是字母，将当前已遍历过的字符串全排列复制两份，在第一份的每个字符串末尾添加 lowercase(c)，在第二份的每个字符串末尾添加 uppercase(c)。

如果下一个字符 c 是数字，将 c 直接添加到每个字符串的末尾。

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

        List<String> res = new ArrayList<>();
        char[] chars = S.toCharArray();
        letterCasePermutationHelper(chars, res, 0);

        return res;
    }

    private void letterCasePermutationHelper(char[] chars, List<String> res, int start) {
        res.add(String.valueOf(chars));

        for (int i = start; i < chars.length; i++) {
            if (Character.isLetter(chars[i])) {
                chars[i] = chars[i] ^= 1 << 5;
            } else {
                continue;
            }
            letterCasePermutationHelper(chars, res, i + 1);
            // 优化——大小写相差32 = 2^5 —— 进行异或运算
            if (Character.isLetter(chars[i])) {
                chars[i] = chars[i] ^= 1 << 5;
            }
        }
    }
}

时间复杂度：O（2^N * N）

空间复杂度：O（2^N * N）

算法一：DFS回溯（Go）

func letterCasePermutation(s string) []string {
    var ans []string
    backtrace([]byte(s), 0,  &ans)
    return ans
}

func backtrace(str []byte, start int, ans *[]string) {
    *ans = append(*ans, string(str))
    for i:=start; i<len(str); i++ {
        if str[i] >= 'a' && str[i] <= 'z' {
            str[i] -= 32
            backtrace(str, i+1, ans)
            str[i] += 32
        }
        if str[i] >= 'A' && str[i] <= 'Z' {
            str[i] += 32
            backtrace(str, i+1, ans)
            str[i] -= 32
        }
    }
}

时间复杂度：O（2^N * N）

空间复杂度：O（2^N * N）