【LeetCode_字符串_回溯算法】面试题 08.07. 无重复字符串的排列组合

林雨涵

已于 2022-12-15 13:54:59 修改

阅读量166

点赞数 1

分类专栏： # LeetCode 文章标签：算法 leetcode 深度优先

于 2022-12-07 15:26:41 首次发布

本文链接：https://blog.csdn.net/qq_43718048/article/details/128220926

版权

LeetCode 专栏收录该内容

41 篇文章 0 订阅

订阅专栏

考察点

回溯算法

第一次：2022年12月7日15:18:37

解题思路

此时长度 K 就是树的深度，
在这里插入图片描述
——图片来源于：全排列-交换法，清晰图示

回溯算法需要考虑到的三点：

以本题为例子：

递归函数的返回值和参数

定义两个全局变量，一个用来存放符合条件单一结果，一个用来存放符合条件结果的集合

// 用来存放符合条件结果集合
private List<String> list = new ArrayList<>();
// 树的路径
private StringBuilder path = new StringBuilder();
// 记录下一层递归的开始参数

背模板吧也没太搞懂，先背下来，万一有一天懂了呢

DFS模板：

	// 模板来源于：[LeetCode上mata川提供](https://leetcode.cn/problems/permutation-i-lcci/comments/)
    private List<String> list = new ArrayList<>();
    private StringBuilder path = new StringBuilder();
    private boolean[] used = new boolean[10];

    // 定义一个回溯函数
    private void dfs(String S) {
        // 回溯函数的出口：当找到了一个问题的解时，存储该解
        if (path.length() == S.length()) {
            list.add(path.toString());
            return;
        }
        // 回溯主体
        for (int i = 0; i < S.length(); i++) {
            if (!used[i]) {
                path.append(S.charAt(i));
                used[i] = true;
                dfs(S);
                used[i] = false;
                // 树的路径 -1 ，即返回上一层树
                path.deleteCharAt(path.length() - 1);
            }
        }
    }

优化点

自己前10min背下来的代码，默写出来又有问题；
要习惯在leetcode上没有提示，敲写代码

代码展示

class Solution {

    private StringBuilder path = new StringBuilder();
    private List<String> list = new ArrayList<>();
    private boolean[] used = new boolean[10];

    private void dfs(String str){
        if (path.length() == str.length()){
            list.add(path.toString());
            return ;
        }
        for(int i = 0; i < str.length(); i ++){
            if(!used[i]){
                path.append(str.charAt(i));
                used[i] = true;
                dfs(str);
                used[i] = false;
                path.deleteCharAt(path.length() - 1);
            }
        }
    }

    public String[] permutation(String S) {
        dfs(S);
        String[] result = new String[list.size()];
        for(int i = 0; i < list.size() ; i++){
            result[i] = list.get(i);
        }
        return result;
    }
}

拓展链接

DFS回溯算法及例题

第二次：2022年12月15日09:31:49

class Solution {
    private StringBuilder path = new StringBuilder();
    private List<String> list = new ArrayList<>();
    private boolean[] isUsed = new boolean[10];

    private void dfs(String str){
        if (path.length() == str.length()){
            list.add(path.toString());
            return ;
        }

        for(int i = 0; i < str.length(); i++){
            if(!isUsed[i]){
                path.append(str.charAt(i));
                isUsed[i] = true;
                dfs(str);
                isUsed[i] = false;
                path.deleteCharAt(path.length() -1);
            }
        }
    }

    public String[] permutation(String S) {
        dfs(S);
        String[] result = new String[list.size()];
        for(int i = 0; i < list.size() ; i++){
            result[i] = list.get(i);
        }
        return result;
    }
}