题目描述
输入:一个字符串,包含(,),还有一些其他字符。
输出:左右括号完全匹配的字符串。并且要尽可能少的删除字符。
规则:有左括号,有对应的右括号与之匹配,成为有效。
回溯法
分析1:用回溯法/暴力搜索,对于每一位的字符都考虑去掉或者留下两种可能,总会得到结果。这样的话,去掉的字符个数不同,需要记录下来,返回的时候返回删除字符最少的那个。同时还要考虑到可能通过多种途径得到同一个字符串,需要去重。
public class RemoveInvalidParentheses301 {
//key:去掉了几个字符; value 最后形成的结果
private Map<Integer,List<String>> map = new HashMap<>();
private int minDis;
/**
* 用回溯法/暴力搜索,挨个去掉或者留下每个字符计算文字的有效性
* @param s
* @return
*/
public List<String> removeInvalidParentheses(String s) {
minDis = s.length();
dfs(s,0,new StringBuilder());
return map.get(minDis);
}
private void dfs(String s, int idx,StringBuilder val) {
if(idx<s.length()){
if(s.charAt(idx)=='('||s.charAt(idx)==')'){
//留下第idx个元素
dfs(s,idx+1,val.append(s.charAt(idx)));
val.setLength(val.length()-1);
//去掉第idx个元素
dfs(s,idx+1,val);
}else{
dfs(s,idx+1,val.append(s.charAt(idx)));
val.setLength(val.length()-1);
}
}else{
//判断val是否有效
int dis = s.length() - val.length();
if(dis>minDis){
return;
}
String text = val.toString();
if(isValidate(text)){
List<String> results = map.getOrDefault(dis,new ArrayList<>());
if(!results.contains(text)){
results.add(text);
map.put(dis,results);
minDis = Math.min(minDis,dis);
}
}
}
}
private boolean isValidate(String text) {
int leftSize = 0;
for(int i=0;i<text.length();i++){
if(text.charAt(i)=='('){
leftSize++;
}else if(text.charAt(i)==')'){
if(leftSize==0) return false;
leftSize--;
}
}
return leftSize==0;
}
}
有效剪枝,速度更快
这个版本的代码基本就是官方的实现。思路和上面一样,但是速度快了很多。原有有几个。
1 判断字符串是否有效,这里通过计数结果中左括号、右括号数量来判断。速度更快。
2 有效剪枝。在leftCount<=rightCount的时候遇到一个),那肯定是一个无效字符,无需加入到结果集。
3 有效剪枝。在已经删除元素个数removed>minimumRemoved,无需继续递归。
class Solution {
private Set<String> result;
private int minimumRemoved;
public List<String> removeInvalidParentheses(String s) {
result = new HashSet<String>();
minimumRemoved = s.length();
dfs(s,0,0,0,new StringBuilder(),0);
return new ArrayList<String>(result);
}
private void dfs(String s,int index,int leftCount,int rightCount,StringBuilder expression,int removed){
if(removed > minimumRemoved) return;
if(index == s.length()){
if(leftCount == rightCount){
if(removed < minimumRemoved){
minimumRemoved = removed;
result.clear();
result.add(expression.toString());
}else if(removed == minimumRemoved){
result.add(expression.toString());
}
}
}else{
int length = expression.length();
//不是括号的时候
if(s.charAt(index)!='(' && s.charAt(index)!=')'){
expression.append(s.charAt(index));
dfs(s,index+1,leftCount,rightCount,expression,removed);
expression.deleteCharAt(length);
}else if(s.charAt(index)==')' && leftCount<=rightCount){
dfs(s,index+1,leftCount,rightCount,expression,removed+1);
}else{
dfs(s,index+1,leftCount,rightCount,expression,removed+1);
expression.append(s.charAt(index));
if(s.charAt(index)=='('){
dfs(s,index+1,leftCount+1,rightCount,expression,removed);
}else{
dfs(s,index+1,leftCount,rightCount+1,expression,removed);
}
expression.deleteCharAt(length);
}
}
}
}
回溯法改进
分析2:也是官方解释。观察所有返回值的长度是相同的。我们需要移除的字符数是一定的。
怎么确定这个数量呢?为了得到有效的字符串,我们应该移除多少个左括号,多少个右括号呢?
1 我们从左开始每次处理一个括号;
2 如果我们遇到了左 括号,它可能回也有可能不会导致一个错误的表达。因为可能在后面会遇到一个关闭的括号。所以我们简单地记录下左括号的痕迹:left +=1;
3 如果我们遇到了右 括号,这会有两种情况。情况1:没有左括号,left=0,这个时候直接right+=1。情况2:还有一些左括号没有匹配到,这个时候left-=1。
4 继续处理,直到字符串结束。
5 最后left 和 right的值告诉我们没有匹配到的左右括号分别有多少个。
public class RemoveInvalidParentheses301_2 {
private List<String> results = new ArrayList<>();
public List<String> removeInvalidParentheses(String s) {
results = new ArrayList<>();
int len = s.length();
int left = 0,right = 0;
for(int i=0;i<len;i++){
if(s.charAt(i)=='('){
left++;
}else if(s.charAt(i)==')'){
if(left>0){
left--;
}else{
right++;
}
}
}
dfs(s,0,left,right,new StringBuilder());
return results;
}
private void dfs(String s, int idx, int left, int right, StringBuilder val) {
if(left<0 || right<0) return;
if(idx==s.length()){
String text = val.toString();
if(left==0 && right==0 && isValidate(text)){
if(!results.contains(text)){
results.add(text);
}
}
}else{
int len = val.length();
if(s.charAt(idx)=='('){
//去掉
dfs(s,idx+1,left-1,right,val);
val.append(s.charAt(idx));
dfs(s,idx+1,left,right,val);
}else if(s.charAt(idx)==')'){
dfs(s,idx+1,left,right-1,val);
val.append(s.charAt(idx));
dfs(s,idx+1,left,right,val);
}else{
val.append(s.charAt(idx));
dfs(s,idx+1,left,right,val);
}
val.setLength(len);
}
}
private boolean isValidate(String text) {
int leftSize = 0;
for(int i=0;i<text.length();i++){
if(text.charAt(i)=='('){
leftSize++;
}else if(text.charAt(i)==')'){
if(leftSize==0) return false;
leftSize--;
}
}
return leftSize==0;
}
}