自己看到题目，首先想到的是简单题目:有效的括号。如果基于给出的数字，生成全部的随机组合，那么再使用有效的括号即可。

暴力法

1. 先随机排列
2. 去重
3. 有效的括号匹配

递归

还有待学习：重要的是找到匹配条件和结束条件

package com.practice.字符串.中等难度;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合
 * <p>
 * 示例 1：
 * 输入：n = 3
 * 输出：["((()))","(()())","(())()","()(())","()()()"]
 * <p>
 * 示例 2：
 * 输入：n = 1
 * 输出：["()"]
 */
public class 括号生成 {
    public static void main(String[] args) {
        /**
         * 自己的思路：参考有效的括号（暴力法）
         * 1.先随机排列
         * 2.去重
         * 3.有效的括号匹配
         */
//        result(generateParenthesis(3));

        /**
         * LeetCode 递归回溯
         */
        generateParenthesisLeetCode(3);

    }


    public static void generateParenthesisLeetCode(int n){
        List<String> result = new ArrayList<>();
        backTracking(n,result,0,0,"");
        System.out.println(result);
    }
    public static void backTracking(int n,List<String> result,int left ,int right,String str){
         if(right>left){
             return ;
         }
         if(left==n && right==n){
             result.add(str);
             return;
         }
         if(left<n){
             backTracking(n,result,left+1,right,str+"(");
         }
         if(right<left){
             backTracking(n,result,left,right+1,str+")");
         }
    }

    //获得不重复的随机排列组合
    public static List<String> generateParenthesis(int n) {
        /**
         * 将（） 放入数组中，准备随机组合排列
         */
        String[] chs = new String[2 * n];
        for (int i = 0; i < n; i++) {
            chs[i] = "(";
        }
        for (int i = n; i < 2 * n; i++) {
            chs[i] = ")";
        }
        List<String> list = Arrays.asList(chs);
        //-----------------------------------------
        List<String> list1 = null;

        /**
         * 随机组合排列
         */
        Stream<String> stream = list.stream();
        for (int g = 1; g < 2 * n; g++) {  // N 个字的组合，需要 N-1 个 flatMap
            stream = stream.flatMap(str -> list.stream().map(str::concat)).distinct();
        }
        list1 = stream.collect(Collectors.toList());
        return list1;
    }

    public static void result(List<String> set) {
        List<String> result = new ArrayList<>();

        Iterator its = set.iterator();
        while (its.hasNext()) {
            String in = (String) its.next();
            if (isValidLeetCode(in)) {
                result.add(in);
            }
        }
        System.out.println(result);
    }

    /**
     * 有效的括号判断逻辑
     */
    public static boolean isValidLeetCode(String in) {
        Map map = new HashMap() {{
            put('(', ')');
//            put('{', '}');
//            put('[', ']');
        }};
        LinkedList<Character> stack = new LinkedList<Character>() {{
            add('?');
        }};
        for (Character c : in.toCharArray()) {
            if (map.containsKey(c)) {
                stack.add(c);
            } else if (!Objects.equals(map.get(stack.removeLast()), c)) {
                return false;
            }
        }
        return stack.size() == 1;
    }




}