22. 括号生成

最新推荐文章于 2024-02-18 08:30:00 发布

jia2018

最新推荐文章于 2024-02-18 08:30:00 发布

阅读量52

点赞数

分类专栏： leetcode 文章标签： dfs leetcode

本文链接：https://blog.csdn.net/jia2018/article/details/114075158

版权

leetcode 专栏收录该内容

55 篇文章 1 订阅

订阅专栏

22. 括号生成

22. 括号生成
- 方法一：深度优先遍历
- 方法二：广度优先遍历

22. 括号生成

方法一：深度优先遍历

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> list = new ArrayList<String>();
        generate(list, 0, 0, n, "");
        return list;
    }

    private void generate(List<String> list, int left, int right, int n, String s) {
        //terminator
        if (left == n && right == n) {
            list.add(s);
            return;
        }
        
        //process current logic: left, right

        //drill down
        if (left < n) {
            generate(list, left + 1, right, n, s + "(");
        }
        if (right < left) {
            generate(list, left, right + 1, n, s + ")");
        }

        //reverse states;
    }
}

class Solution {
    //做加法
    public List<String> generateParenthesis(int n) {
        List<String> res = new ArrayList<>();
        //特判
        if (n == 0) {
            return res;
        }
        dfs("", 0, 0, n, res);
        return res;
    }

    private void dfs(String curStr, int left, int right, int n, List<String> res) {
        //terminator
        if (left == n && right == n) {
            res.add(curStr);
            return;
        }
        
        //process current logic: left, right

        //剪枝
        // if (left < right) {
        //     return;
        // }

        //drill down
        if (left < n) {
            dfs(curStr + "(", left + 1, right, n, res);
        }
        if (right < left) {
            dfs(curStr + ")", left, right + 1, n, res);
        }

        //reverse states;
        //由于字符串的特殊性，产生一次拼接都生成新的对象，因此无需回溯
    }
}

class Solution {
    //做减法
    public List<String> generateParenthesis(int n) {
        List<String> res = new ArrayList<>();
        //特判
        if (n == 0) {
            return res;
        }
        dfs("", n, n, res);
        return res;
    }

    private void dfs(String curStr, int left, int right, List<String> res) {
        //terminator
        if (left == 0 && right == 0) {
            res.add(curStr);
            return;
        }
        
        //process current logic: left, right

        //剪枝
        // if (left > right) {
        //     return;
        // }

        //drill down
        if (left > 0) {
            dfs(curStr + "(", left - 1, right, res);
        }
        if (right > left) {
            dfs(curStr + ")", left, right - 1, res);
        }

        //reverse states;
        //由于字符串的特殊性，产生一次拼接都生成新的对象，因此无需回溯
    }
}