leetcode-排列组合问题

1.无重复字符串的排列组合-面试题 08.07-简单

无重复字符串的排列组合。编写一种方法，计算某字符串的所有排列组合，字符串每个字符均不相同。

输入：S = “qwe”
输出：[“qwe”, “qew”, “wqe”, “weq”, “ewq”, “eqw”]
输入：S = “ab”
输出：[“ab”, “ba”]

答案

/*
*	思路：回溯思想。
*/
class Solution {
	// 用一个used存储已经访问过的数据
    private boolean[] used;
    //存储结果
    private List<String> res;
    //字符长度
    private int len;

    public String[] permutation(String S) {
        len = S.length();
        used = new boolean[len];
        res = new ArrayList<>();

        dfs(S, new StringBuilder(), 0);

        return res.toArray(new String[0]);
    }
    
    private void dfs(String s, StringBuilder sb, int cnt) {
        // end —— 当sb长度与s长度一致时结束，存储答案
        if (cnt == len) {
            res.add(sb.toString());
            return;
        }

        // 回溯模板
        for (int i = 0; i < len; i++) {
            if (!used[i]) {
            	//访问该位时，设置为true，防止下一次递归时重复访问。
                used[i] = true;
                sb.append(s.charAt(i));
                //递归
                dfs(s, sb, cnt + 1);
                //再次将该位设置为未访问状态
                used[i] = false;
                sb.deleteCharAt(cnt);
            }
        }
    }
}

2.有重复字符串的排列组合

有重复字符串的排列组合。编写一种方法，计算某字符串的所有排列组合

输入：S = “qqe”
输出：[“eqq”,“qeq”,“qqe”]
输入：S = “ab”
输出：[“ab”, “ba”]

答案

/*
* 思路：同样是回溯思想，与上面类似，但是需要去重。
*/
class Solution {
    public String[] permutation(String S) {

        List<String> list = new ArrayList<>();
        char[] arr = S.toCharArray();
        //将数组排好序，方便去重
        Arrays.sort(arr);
        boolean[] book = new boolean[arr.length];
        dfs(list, new StringBuilder(), book, arr);

        String[] res = new String[list.size()];
        for (int i = 0; i < res.length; i++)
            res[i] = list.get(i);

        return res;
    }

    public void dfs(List<String> res, StringBuilder sb, boolean[] book, char[] arr) {

        if (sb.length() == arr.length) {
            res.add(sb.toString());
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            if (!book[i]) {
                if (i > 0 && arr[i] == arr[i - 1] && !book[i - 1]){
                    //去重
                    continue;
                }
                else {
                    sb.append(arr[i]);
                    book[i] = true;
                    dfs(res, sb, book, arr);
                    book[i] = false;
                    sb.deleteCharAt(sb.length() - 1);
                }
            }
        }
    }
}