括号生成（DFS） + 括号匹配 +最长括号子串 + 24点

括号生成

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

LeetCode22

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

    public void dfs(int left,int right,String cur,List<String> list){
        if(left == 0 && right == 0){
            list.add(cur);
            return;
        }

        if(left > 0){ // 如果左括号还剩余的话，可以拼接左括号
            dfs(left - 1, right,cur + "(", list);
        }
        if(right > left){ // 如果右括号剩余多于左括号剩余的话，可以拼接右括号
            dfs(left, right - 1,cur + ")", list);
        }
    }
}

括号匹配

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效

import java.util.Scanner;
import java.util.Stack;

public class Solution{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String s = sc.nextLine();
			System.out.println(isValid(s));
        }
		sc.close();
    }
	
    public static boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        char[] c = s.toCharArray();
        int len = s.length();
        
        for(int i=0;i<len;i++){
            if(c[i] == '('){
                stack.push(')');
            }else if(c[i] == '['){
                stack.push(']');
            }else if(c[i] == '{'){
                stack.push('}');
            }else if(stack.isEmpty() || c[i] != stack.pop()){
                return false;
            }
        }
        return stack.isEmpty();
    }

}

最长的括号子串

给出一个仅包含字符’(‘和’)'的字符串，计算最长的格式正确的括号子串的长度。
对于字符串"(()“来说，最长的格式正确的子串是”()"，长度为2.

再举一个例子：对于字符串")()())",来说，最长的格式正确的子串是"()()"，长度为4.

import java.util.*;

public class Solution {
    public int longestValidParentheses (String s) {
        // write code here
        if(s == null && s.length() <= 1){
            return 0;
        }
        int[] dp = new int[s.length()];
        int max = 0;
        for(int i=1;i<s.length();i++){
            if(s.charAt(i) == ')'){
                if(s.charAt(i-1) == '('){
                    if(i >= 2){
                        dp[i] = dp[i-2] + 2;
                    }else{
                        dp[i] = 2;
                    }
                }else{
                    if(i - dp[i-1] - 1 >= 0 && s.charAt(i-dp[i-1]-1)=='('){
                        dp[i] = dp[i-1] + 2;
                        if(i - dp[i-1] - 2 >= 0){
                            dp[i] = dp[i] + dp[i-dp[i-1]-2];
                        }
                    }
                }
            }
            max = Math.max(max,dp[i]);
        }
        return max;
    }
}

24点

不考虑括号，数字位置可调

import java.util.*;

public class Main1 {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		while(sc.hasNext()){
			int res=0;
			int[] num=new int[4];
			int[] temp=new int[4];
			for(int i=0;i<4;i++){
				num[i]=sc.nextInt();
			}
			System.out.println(check(num,temp,res));
		}
		sc.close();
	}

	private static boolean check(int[] num,int[] temp,int res) {
		for(int i=0;i<num.length;i++){
			if(temp[i]==0){
				temp[i]=1;
				if(check(num,temp,res+num[i])
					    || check(num,temp,res-num[i])
						|| check(num,temp,res*num[i])
						|| check(num,temp,res/num[i])) {
					return true;
				}
				temp[i]=0;
			}
		}

		if(res==24){
			return true;
		}else{
			return false;
		}
	}
}