2024年C C++最全【算法】剑指 Offer II 085，2024年最新面试必备

2401_84973664

于 2024-05-13 01:45:22 发布

阅读量244

点赞数 3

分类专栏：程序员文章标签： c语言 c++ 学习

本文链接：https://blog.csdn.net/2401_84973664/article/details/138775468

版权

程序员专栏收录该内容

45 篇文章 0 订阅

订阅专栏

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

+ [rust](#rust_208)

原题传送门：https://leetcode-cn.com/problems/IDBivT/
原题传送门：https://leetcode-cn.com/problems/generate-parentheses/
原题传送门：https://leetcode.cn/problems/bracket-lcci/

剑指 Offer II 085. 生成匹配的括号｜22. 括号生成｜面试题 08.09. 括号：

正整数 n 代表生成括号的对数，请设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

样例 1：

输入：
	n = 3
	
输出：
	["((()))","(()())","(())()","()(())","()()()"]

样例 2：

输入：
	n = 1
	
输出：
	["()"]

提示：

1 <= n <= 8

分析

首先想到的是全排列排列方式，然后再从中挑选满足括号规则的序列。每个字符只可能是 ‘(’ 或者 ‘)’ 两种选择，所以全排列的数量是 22n 个。真正有效的括号序列远远少于这个量。
是否可以直接去穷举生成有效的括号序列呢？
首先要判断什么样的序列是有效的括号序列？
很显然，首先左右括号字符的数量应该相等。
右括号一定是匹配前面某个左括号。
所以只包含左右括号字符，并且从左往右看，右括号数始终小于等于左括号数，最终左右括号数相等的序列就是合理合法合规的括号序列了。

题解

java

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> ans = new ArrayList<>();

        this.dfs(n, ans, new char[n \* 2], 0, 0);

        return ans;
    }

    private void dfs(int n, List<String> ans, char[] cs, int left, int right) {
        if (left == n && right == n) {
            ans.add(new String(cs));
            return;
        }

        if (left < n) {
            cs[left + right] = '(';
            dfs(n, ans, cs, left + 1, right);
        }
        if (right < left) {
            cs[left + right] = ')';
            dfs(n, ans, cs, left, right + 1);
        }
    }
}

c

#define MAX\_SIZE 1430

void dfs(int n, int \*returnSize, char \*\*ans, char \*cs, int left, int right) {
    if (left == n && right == n) {
        ans[(\*returnSize)] = calloc((n \* 2 + 1), sizeof(char));
        strcpy(ans[(\*returnSize)], cs);
        ++(\*returnSize);
        return;
    }

    if (left < n) {
        cs[left + right] = '(';
        dfs(n, returnSize, ans, cs, left + 1, right);
    }
    if (right < left) {
        cs[left + right] = ')';
        dfs(n, returnSize, ans, cs, left, right + 1);
    }
}

/\*\*
 \* Note: The returned array must be malloced, assume caller calls free().
 \*/
char \*\*generateParenthesis(int n, int \*returnSize) {
    \*returnSize = 0;
    char \*\*ans = malloc(MAX_SIZE \* sizeof(char \*));
    char \*cs = calloc((n \* 2 + 1), sizeof(char));
    dfs(n, returnSize, ans, cs, 0, 0);
    return ans;
}

c++

class Solution {
private:
    void dfs(int n, vector<string> &ans, string &buf, int left, int right) {
        if (left == n && right == n) {
            ans.push\_back(buf);
            return;
        }

        if (left < n) {
            buf.push\_back('(');
            dfs(n, ans, buf, left + 1, right);
            buf.pop\_back();
        }
        if (right < left) {
            buf.push\_back(')');
            dfs(n, ans, buf, left, right + 1);
            buf.pop\_back();
        }
    }

public:
    vector<string> generateParenthesis(int n) {
        vector<string> ans;
        string buf;
        dfs(n, ans, buf, 0, 0);
        return ans;
    }
};

python

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        ans = []

        def dfs(s, left, right):
            if left == n and right == n:
                ans.append(''.join(s))
                return
            if left < n:
                s.append('(')
                dfs(s, left + 1, right)
                s.pop()
            if right < left:
                s.append(')')
                dfs(s, left, right + 1)
                s.pop()

        dfs([], 0, 0)
        return ans