2024-01-12 20:18阅读: 84评论: 0推荐: 0

括号的合法性判断

括号相关的应用

括号相关的应用

力扣上，括号相关的题目如下：

序号	题目	难度
1	20. 有效的括号	简单
2	1541. 平衡括号字符串的最少插入次数	中等
3	921. 使括号有效的最少添加	中等

1. Leetcode 20. 有效的括号

1.1. 题目

20. 有效的括号

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
有效字符串需满足：

左括号必须用相同类型的右括号闭合。

左括号必须以正确的顺序闭合。

每个右括号都有一个对应的相同类型的左括号。

示例 1：

输入：s = "()"
输出：true

1.2. 解题思路

维护一个栈 $s t a c k$ ，顺序遍历字符串，对于遇到的每一个字符：

如果它是一个左括号，就将其入栈；
如果它是一个右括号，就弹出栈顶的元素，并判断是否与之匹配，若不匹配，则返回 $f a l s e$ 。

遍历完字符串后，如果栈里面还有剩余元素，则返回 $f a l s e$ ，否则，就返回 $t r u e$ 。

1.3. 代码实现

 class Solution {
    public boolean isValid(String s) {
        Deque<Character> stack = new ArrayDeque<>();
        Map<Character, Character> map = new HashMap<>();
 
        map.put(')', '(');
        map.put(']', '[');
        map.put('}', '{');
 
        for (int i = 0;i< s.length();i++) {
            // 遇到左括号就从栈里面弹出一个元素，并判断是否是对应的右括号
            if (map.containsKey(s.charAt(i))) {
                if (stack.isEmpty() || stack.peek() != map.get(s.charAt(i))) {
                    return false;
                }
                stack.pop();
            } else {
                // 遇到左括号就压栈
                stack.push(s.charAt(i));
            }
        }
        // 如果站里面还有剩余元素，就返回失败
        return stack.isEmpty();
    }
}

2. Leetcode 1541. 平衡括号字符串的最少插入次数

2.1. 题目

1541. 平衡括号字符串的最少插入次数

给你一个括号字符串 s ，它只包含字符 '(' 和 ')' 。一个括号字符串被称为平衡的当它满足：

任何左括号 '(' 必须对应两个连续的右括号 '))' 。

左括号 '(' 必须在对应的连续两个右括号 '))' 之前。

比方说 "())"， "())(())))" 和 "(())())))" 都是平衡的， ")()"， "()))" 和 "(()))" 都是不平衡的。
你可以在任意位置插入字符 '(' 和 ')' 使字符串平衡。
请你返回让 s 平衡的最少插入次数。

示例 1：

输入：s = "(()))"
输出：1
解释：第二个左括号有与之匹配的两个右括号，但是第一个左括号只有一个右括号。我们需要在字符串结尾额外增加一个 ')' 使字符串变成平衡字符串 "(())))" 。

2.2. 解题思路

我们维护两个变量，来记录所需插入的括号数量：

所需要插入的括号： $n e e d I n s e r t$ ，包含插入左括号和插入右括号；
维持平衡所需要的右括号数量： $n e e d R i g h t$ 。

我们遍历字符串 $S$ ，对于遇到的每一字符：

如果当前字符是一个左括号，就将 $n e e d R i g h t$ 加 $2$ ；

此时，如果对右括号的需求数变为奇数，说明它的左侧有一个不配对的右括号，那么，就需要插入一个右括号来保持平衡，这样，对右括号的需求就减 $1$ 。

因此， $n e e d I n s e r t$ 需要加 $1$ ，同时，将 $n e e d R i g h t$ 减 $1$ 。
如果当前字符是一个右括号，就将 $n e e d R i g h t$ 减 $1$ ；

此时，如果对右括号的需求减少到 $- 1$ ，说明它的左侧右括号较多，就需要插入一个左括号来保持平衡。

因此， $n e e d I n s e r t$ 需要加 $1$ ，同时，将 $n e e d R i g h t$ 加 $2$ 。

2.3. 代码实现

 class Solution {
    public int minInsertions(String s) {
        int needInsert = 0;
        int needRight = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '(') {
                // 对右括号的需求加2
                needRight += 2;
                // 遇到左括号的时候，右括号的需求为奇数，说明当前字符的左侧有一个不配对的右括号
                if (needRight % 2 == 1) {
                    // 需要插入一个右括号
                    needInsert++;
                    // 对右括号的需求减1
                    needRight--;
                }
            } else {
                needRight--;
                // 右括号减到-1，说明需要插入一个左括号与之匹配
                if (needRight == -1) {
                    // 需要插入一个左括号
                    needInsert++;
                    // 对右括号的需求加2
                    needRight += 2;
                }
 
            }
        }
        return needRight + needInsert;
    }
}

3. Leetcode 921. 使括号有效的最少添加

3.1. 题目

921. 使括号有效的最少添加

只有满足下面几点之一，括号字符串才是有效的：

它是一个空字符串，或者

它可以被写成 AB （A 与 B 连接）, 其中 A 和 B 都是有效字符串，或者

它可以被写作 (A)，其中 A 是有效字符串。

给定一个括号字符串 s ，在每一次操作中，你都可以在字符串的任何位置插入一个括号

例如，如果 s = "()))" ，你可以插入一个开始括号为 "(()))" 或结束括号为 "())))" 。

返回为使结果字符串 s 有效而必须添加的最少括号数。

示例 1：

输入：s = "())"
输出：1

3.2. 解题思路

3.2.1. 方法一：栈

使用一个栈 $s t a c k$ 记录所有的左括号，当遇到一个右括号就弹出栈里的左括号，如果栈为空，就将需要插入的左括号数量加 $1$ 。

遍历完整个字符串后，如果栈里还剩余有左括号，那么，也需要对应数量的右括号。

3.2.2. 方法二：模拟

我们维护两个变量，来记录所需添加的括号数量：

用 needLeftCount 表示需要插入的左括号数量；
用 right 表示对的右括号需求。

我们以左括号为基准，遍历字符串 $S$ 从左右往右遍历字符串：

如果遇到一个左括号，就对 right 加 1，
如果遇到一个右括号，就对 right 减 1，如果 right 小于零了，表示右括号太多了，需要新插入一个左括号来平衡一下，此时，将 needLeftCount 加 1。

因此，需要插入的括号数量，就是待插入的左括号与右括号的需求之和。

3.3. 代码实现

方法一

 class Solution {
    public int minAddToMakeValid(String s) {
        Deque<Character> stack = new ArrayDeque<>();
        int count = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '(') {
                stack.push(s.charAt(i));
            } else {
                if (!stack.isEmpty()) {
                    stack.pop();
                } else {
                    count++;
                }
            }
        }
        return count + stack.size();
    }
}

方法二

 class Solution {
    public int minAddToMakeValid(String s) {
        // 需要插入左括号的数量
        int needLeftCount = 0;
        // 记录遍历过程中，需要的右括号数量
        int right = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '(') {
                // 遇到一个左括号，就需要一个右括号
                right++;
            } else {
                // 遇到一个右括号，所需要的右括号数量就减一
                right--;
                // 右括号的需求减少到零，说明右括号太多了，就插入一个左括号
                if (right == -1) {
                    // 插入一个左括号
                    needLeftCount++;
                    // 将右括号的需求重置为零
                    right = 0;
                }
            }
        }
        // 如果遍历完了之后，还有右括号，需要插入等量的左括号
        return needLeftCount + right;
    }
}

本文作者：LARRY1024

本文链接：https://www.cnblogs.com/larry1024/p/17961411

posted @ 2024-01-12 20:18 LARRY1024 阅读(84) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

历史上的今天：
2023-01-12 【动态规划】博弈问题

公告

昵称：LARRY1024 园龄：11年9个月粉丝：16 关注：3

昵称： LARRY1024
园龄： 11年9个月
粉丝： 16
关注： 3

+加关注

Talk is cheap, sho|

2025年3月

日

一

二

三

四

五

六

LARRY1024

括号的合法性判断

括号相关的应用

1. Leetcode 20. 有效的括号

1.1. 题目

1.2. 解题思路

1.3. 代码实现

2. Leetcode 1541. 平衡括号字符串的最少插入次数

2.1. 题目

2.2. 解题思路

2.3. 代码实现

3. Leetcode 921. 使括号有效的最少添加

3.1. 题目

3.2. 解题思路

3.2.1. 方法一：栈

3.2.2. 方法二：模拟

3.3. 代码实现

公告

搜索

常用链接

最新随笔

我的标签

积分与排名

合集 (8)

随笔分类 (155)

随笔档案 (139)

阅读排行榜

评论排行榜

推荐排行榜

最新评论

	class Solution {
	public boolean isValid(String s) {
	Deque<Character> stack = new ArrayDeque<>();
	Map<Character, Character> map = new HashMap<>();

	map.put(')', '(');
	map.put(']', '[');
	map.put('}', '{');

	for (int i = 0;i< s.length();i++) {
	// 遇到左括号就从栈里面弹出一个元素，并判断是否是对应的右括号
	if (map.containsKey(s.charAt(i))) {
	if (stack.isEmpty() \|\| stack.peek() != map.get(s.charAt(i))) {
	return false;
	}
	stack.pop();
	} else {
	// 遇到左括号就压栈
	stack.push(s.charAt(i));
	}
	}
	// 如果站里面还有剩余元素，就返回失败
	return stack.isEmpty();
	}
	}

	class Solution {
	public int minInsertions(String s) {
	int needInsert = 0;
	int needRight = 0;
	for (int i = 0; i < s.length(); i++) {
	if (s.charAt(i) == '(') {
	// 对右括号的需求加2
	needRight += 2;
	// 遇到左括号的时候，右括号的需求为奇数，说明当前字符的左侧有一个不配对的右括号
	if (needRight % 2 == 1) {
	// 需要插入一个右括号
	needInsert++;
	// 对右括号的需求减1
	needRight--;
	}
	} else {
	needRight--;
	// 右括号减到-1，说明需要插入一个左括号与之匹配
	if (needRight == -1) {
	// 需要插入一个左括号
	needInsert++;
	// 对右括号的需求加2
	needRight += 2;
	}

	}
	}
	return needRight + needInsert;
	}
	}

	class Solution {
	public int minAddToMakeValid(String s) {
	Deque<Character> stack = new ArrayDeque<>();
	int count = 0;
	for (int i = 0; i < s.length(); i++) {
	if (s.charAt(i) == '(') {
	stack.push(s.charAt(i));
	} else {
	if (!stack.isEmpty()) {
	stack.pop();
	} else {
	count++;
	}
	}
	}
	return count + stack.size();
	}
	}

	class Solution {
	public int minAddToMakeValid(String s) {
	// 需要插入左括号的数量
	int needLeftCount = 0;
	// 记录遍历过程中，需要的右括号数量
	int right = 0;
	for (int i = 0; i < s.length(); i++) {
	if (s.charAt(i) == '(') {
	// 遇到一个左括号，就需要一个右括号
	right++;
	} else {
	// 遇到一个右括号，所需要的右括号数量就减一
	right--;
	// 右括号的需求减少到零，说明右括号太多了，就插入一个左括号
	if (right == -1) {
	// 插入一个左括号
	needLeftCount++;
	// 将右括号的需求重置为零
	right = 0;
	}
	}
	}
	// 如果遍历完了之后，还有右括号，需要插入等量的左括号
	return needLeftCount + right;
	}
	}