Class c2 = Class.forName("[D");
Class c1 = Boolean.class;
Class c4 = instance.getClass();

Class<?> klass = methodClass.class;
//创建methodClass的实例
Object obj = klass.newInstance();
//获取methodClass类的add方法，传入int.class是为了确定唯一的方法，以防重载
Method method = klass.getMethod("add",int.class,int.class);
//调用method对应的方法 => add(1,4)
Object result = method.invoke(obj,1,4);
System.out.println(result);

/**
     * 可以直接使用栈来做，栈中存放的是下标。
     * 当元素是'('，直接入栈下标，当元素是')'且栈顶是'('，将栈顶出栈，并且减去栈顶下标，然后就得到当前合法序列的长度
     * */
public int longestValidParentheses(String s) {
    if(s==null||s.length()==0){
        return 0;
    }
    Stack<Integer> stack = new Stack<>();
    stack.push(-1);
    int res = 0;
    for(int i=0;i<s.length();i++){
        if(s.charAt(i)=='('){
            stack.push(i);
        }else{
            stack.pop();
            if(stack.isEmpty()){
                stack.push(i);
            }else{
                res = Math.max(res,i-stack.peek());
            }
        }
    }
    return res;
}


public int longestValidParentheses(String s) {
    int[] dp = new int[s.length()];
    int res = 0;
    int max = 0;
    //假如直接是'('，那么dp[i]直接等于0,如果是')'，那么需要看i-dp[i-1]-1个位置是否是'('，假如是的话+2，还需要再看i-dp[i-1]-1前一个位置的dp
    for(int i=1;i<s.length();i++){
        if(s.charAt(i)==')'){
            int pre = i-dp[i-1]-1;
            if(pre>=0&&s.charAt(pre)=='('){
                dp[i] = dp[i-1]+2+(pre-1>=0?dp[pre-1]:0);
                max= Math.max(max,dp[i]);
            }
        }
    }
    return max;
}

public boolean isValid(String s) {
    Stack<Character> stack = new Stack<>();
    for(int i=0;i<s.length();i++){
        if(s.charAt(i)==']'||s.charAt(i)==')'||s.charAt(i)=='}'){
            if(!stack.isEmpty()){
                char c1 = stack.pop();
                if(!isSym(c1,s.charAt(i))){
                    return false;
                }
            }else{
                return false;
            }
        }else{
            stack.push(s.charAt(i));
        }
    }
    return stack.isEmpty();
}
public boolean isSym(char c1,char c2){
    return (c1=='('&&c2==')')||(c1=='['&&c2==']')||(c1=='{'&&c2=='}');
}

public boolean isPalindrome(int x) {
    if(x<0){
        return false;
    }
    //计算x的最高位数,12321 计算出10000
    int help = 1;
    while(x/help>=10){
        help*=10;
    }
    while(x!=0) {
        //x/help计算第一个位置 x%10计算最后一个位置
        if (x / help != x % 10) {
            return false;
        }
        //x%help/10 12321->232，因为少了两位，所以help/100
        x = x%help/10;
        help/=100;
    }
    return true;
}

/**
     * 未排序正数数组中累加和为定值的最长子数组长度
     * 准备两个指针，left以及right，以sum表示left以及right之间的数值和。
     * 假如sum<k，则right后移；
     * sum==k，记录下长度，并将left左移；
     * sum>k，left直接左移
     * */

public int getMaxLength(int[] nums,int k) {
    if (nums == null || nums.length == 0 || k <= 0) {
        return 0;
    }
    int left = 0;
    int right = 0;
    int sum = 0;
    int maxLength = 0;
    while (right < nums.length) {
        //假如sum<k，说明不够长，还需要加元素，right往右移
        if (sum < k) {
            right++;
            //注意下标越界判断
            if(right==nums.length){
                break;
            }
            sum += nums[right];
            //sum==k，记录长度，太满了，缩小长度，将left右移
        } else if (sum == k) {
            maxLength = Math.max(maxLength, right - left + 1);
            sum -= nums[left];
            left++;
            //sum>k，太满了，left右移
        } else {
            sum -= nums[left];
            left++;
        }
    }
    return maxLength;
}

/**
     * 未排序整数数组中累加和为定值的最长子数组长度，可为正，负，0
     * sum用来记录从0到i的子数组之和，使用map存储所有出现的sum值以及位置
     * 在map中查找sum-k，假如存在，那么i与该位置之间就是满足的子数组，与最值比较
     * 假如sum-k不存在，那么以nums[i]结尾的情况下没有累加和为k的子数组
     * */
public int subarraySum(int[] nums, int k) {
    if(nums==null||nums.length==0){
        return 0;
    }
    int sum = 0;
    int max = 0;
    int count = 0;
    //存储sum值以及他第一次出现的位置
    Map<Integer,Integer> map = new HashMap<>();
    map.put(0,-1);
    for(int index=0;index<nums.length;index++){
        sum+=nums[index];
        if(map.containsKey(sum-k)){
            max = Math.max(max,index-map.get(sum-k));
        }
        if(!map.containsKey(sum)){
            map.put(sum,index);
        }
    }
    return max;
}

public int findMaxLength(int[] nums) {
       if(nums==null||nums.length==0){
           return 0;
       }
       //存储某个sum值以及第一次出现的位置
       Map<Integer,Integer> map = new HashMap<>();
       int sum = 0;
       int max = 0;
       map.put(0,-1);
       for(int i=0;i<nums.length;i++){
           sum+=nums[i]==0?-1:nums[i];
           if(map.containsKey(sum-0)){
               max = Math.max(max,i-map.get(sum-0));
           }
           if(!map.containsKey(sum)){
               map.put(sum,i);
           }
       }
       return max;
}

/**
     * 整数数组，依旧使用sum-k的方式
     * */
public int subarraySum2(int[] nums, int k) {
    if(nums==null||nums.length==0){
        return 0;
    }
    int sum = 0;
    int count = 0;
    //map中存储的是某个sum值出现的次数
    Map<Integer,Integer> map = new HashMap<>();
    //初始0值出现了一次
    map.put(0,1);
    for(int index=0;index<nums.length;index++){
        sum+=nums[index];
        if(map.containsKey(sum-k)){
            count+=map.get(sum-k);
        }
        //存储sum出现的次数，假如map中已经存在，直接++，未存在，直接存储1
        map.put(sum,map.getOrDefault(sum,0)+1);
    }
    return count;
}

public int maxLength(int[] arr,int k){
    //计算以i结尾的最小子数组长度
    int[] minSums = new int[arr.length];
    int[] minEnds = new int[arr.length];
    minSums[arr.length-1] = minSums[arr.length-1];
    minEnds[arr.length-1] = arr.length-1;
    for(int i=arr.length-2;i>=0;i--){
        if(minSums[i+1]<0){
            minSums[i] = minSums[i+1]+arr[i];
            minEnds[i] = minEnds[i+1];
        }else{
            minSums[i] = arr[i];
            minEnds[i] = i;
        }
    }
    //扩展窗口,end是窗口最右位置的下一个位置，i是窗口的左侧
    int sum = 0;
    int end = 0;
    int max = 0;
    for(int i=0;i<arr.length;i++){
        //将窗口向右扩，直到>k
        while(end<arr.length&&sum+minSums[end]<=k){
            sum+=minSums[end];
            end = minEnds[end]+1;
        }
        //扩充到不能再扩了，形成了一个结果
        max = Math.max(max,end-i);
        //移动左侧位置
        if(end>i){
            sum-=arr[i];
        }else{
            end = i+1;
        }
    }
    return max;
}

/**
     * 汉诺塔问题
     * 递归方法来解决。
     * from  to   help
     * 一开始from有n个元素，需要将这n个元素移动到to中。可以分为三个步骤：
     *  1.将n-1个元素从from移动到help
     *  2.将第n个元素从from直接移到to
     *  3.将n-1个元素从help移动到to
     * */
public void hanuo(int N,String from,String to,String help){
    if(N==1){
        System.out.println("move 1 "+" form "+from+" to "+to);
    }else{
        hanuo(N-1,from,help,to);
        System.out.println("move "+N+" from "+from+" to "+to);
        hanuo(N-1,help,to,from);
    }
}

//dp[i]到第i家可以偷多少钱dp[i]=max(dp[i-1],dp[i-2]+nums[i-1])
public int rob(int[] nums) {
    if(nums.length<1){
        return 0;
    }
    int[] dp = new int[nums.length+1];
    dp[0] = 0;
    dp[1] = nums[0];
    for(int i=2;i<=nums.length;i++){
        dp[i] = Math.max(dp[i-2]+nums[i-1],dp[i-1]);
    }
    return dp[nums.length];
}

public void printAllSub(char[] arr,int i,String res){
    if(i==arr.length){
        System.out.println(res);
        return ;
    }
    //存在两种情况，打印该元素以及不打印该元素
    printAllSub(arr,i+1,res);
    printAllSub(arr,i+1,res+String.valueOf(arr[i]));
}

public int minPathSum(int[][] grid) {
    if(grid.length==0||grid[0].length==0){
        return 0;
    }
    return helperMinPath(grid,0,0);
}

/**
     * 递归来解决
     *  该方法表示从(row,col)走到右下角的距离
     *  1.到达最右下角节点，直接返回结果
     *  2.res  = min(向右走，向下走)
     * */
public int helperMinPath(int[][] grid,int row,int col){
    int val = grid[row][col];
    //走到最右下角点
    if(row==(grid.length-1)&&col == grid[0].length-1){
        return grid[row][col];
    }
    //走到最后一行或者是最后一列
    if(row==grid.length-1){
        return val+helperMinPath(grid,row,col+1);
    }
    if(col == grid[0].length-1){
        return val+helperMinPath(grid,row+1,col);
    }

    //取向下走以及往右走的最小值
    int down = helperMinPath(grid,row+1,col);
    int right = helperMinPath(grid,row,col+1);
    return Math.min(down,right)+val;
}

public int minPathSum(int[][] grid) {
    if(grid.length==0||grid[0].length==0){
        return 0;
    }
    return DPMinPath(grid);
}

public int minPathSum(int[][] grid) {
    return DPMinpath(grid);
}
public int DPMinpath(int[][] matrix){
    if(matrix.length==0||matrix[0].length==0){
        return 0;
    }
    int m = matrix.length;
    int n = matrix[0].length;
    int[][] dp = new int[m][n];
    for(int i=0;i<m;i++){
        for(int j=0;j<n;j++){
            if(i==0&&j==0){
                dp[i][j] =  matrix[i][j];
            }else if(i==0){
                dp[i][j] = dp[i][j-1]+matrix[i][j];
            }else if(j==0){
                dp[i][j] = dp[i-1][j]+matrix[i][j];
            }else{
                dp[i][j] = Math.min(dp[i-1][j]+matrix[i][j],dp[i][j-1]+matrix[i][j]);
            }
        }
    }
    return dp[m-1][n-1];
}

public int minPathSum(int[][] grid) {
        return DPMinpath(grid);
    }
    public int DPMinpath(int[][] matrix){
        if(matrix.length==0||matrix[0].length==0){
            return 0;
        }
        int m = matrix.length;
        int n = matrix[0].length;
        int[] dp = new int[n];
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(i==0&&j==0){
                    dp[0] =  matrix[i][j];
                }else if(i==0){
                    dp[j] = dp[j-1]+matrix[i][j];
                }else if(j==0){
                    dp[j] = dp[j]+matrix[i][j];
                }else{
                    dp[j] = Math.min(dp[j]+matrix[i][j],dp[j-1]+matrix[i][j]);
                }
            }
        }
        return dp[n-1];
    }
}

/**第一种是递归方法来解决。每个元素有选择以及不选择两种可能
     * 假如i==arr.length，说明已经走完了最后一个元素，判断sum是否等于aim
     * 对于每一个元素，我们有选择加他或者不加他两种可能
     * @param arr1：输入的数组
     * @param i：数组中第几个数据
     * @param sum
     * @param aim：目标和
     * @return
     */
public  boolean process1(int[] arr1,int i,int sum,int aim){
    if(i==arr1.length){
        return sum==aim;
    }
    //分为选择该元素以及不选择该元素两种可能
    return process1(arr1,i+1,sum,aim)||process1(arr1,i+1,sum+arr1[i],aim);
}

/**
     * DP版本
     * 两个可变参数：sum以及i(元素个数)
     * */

public  boolean process1(int[] arr1,int aim){
    //计算sum范围
    int sum = 0;
    for(int ele:arr1){
        sum+=ele;
    }
    boolean[][] dp = new boolean[arr1.length+1][sum+1];
    /**
         * if(i==arr1.length){
         *    return sum==aim;
         *  }
         *  计算特殊情况
         * */
    for(int i=0;i<=sum;i++){
        dp[arr1.length][i] = i==aim?true:false;
    }
    for(int i=1;i<arr1.length;i++){
        for(int j=0;j<=sum;j++){
            dp[i][j] = dp[i+1][j]||dp[i+1][j+arr1[j]];
        }
    }
    return dp[0][0];
}

/**
     * 集合组成是以i个元素结尾的字段，比如[2,1,-1,4]有四个，分别是以2，1，-1，4结尾的子段
     * f(i) = max(f(i-1),0)+nums[i]，f(i)表示以i作为结尾的子段的所有元素之和
     * */
public int maxSubArray(int[] nums) {
    if(nums.length==1){
        return nums[0];
    }
    int[] dp = new int[nums.length];
    dp[0] = nums[0];
    int max = dp[0];
    for(int i=1;i<nums.length;i++){
        dp[i] = Math.max(dp[i-1],0)+nums[i];
        max = Math.max(max,dp[i]);
    }
    return max;
}

/**
     * 特殊情况：col = 0 dp[i][0] = dp[i-1][0]+triangle.get(i).get(0);
     *           每个list中的最后一个元素
     * dp[i][j] = min(dp[i-1][j],dp[i-1][j-1])+当前值
     * */
public int minimumTotal(List<List<Integer>> triangle) {
    if(triangle==null||triangle.size()==0){
        return 0;
    }
    int[][] dp = new int[triangle.size()][triangle.size()];
    dp[0][0] = triangle.get(0).get(0);
    for(int i=1;i<triangle.size();i++){
        dp[i][0] = dp[i-1][0]+triangle.get(i).get(0);
    }
    for(int i=1;i<triangle.size();i++){
        List<Integer> data = triangle.get(i);
        dp[i][data.size()-1] = dp[i-1][data.size()-2]+data.get(data.size()-1);
    }
    for(int i=1;i<triangle.size();i++){
        List<Integer> data = triangle.get(i);
        for(int j=1;j<data.size()-1;j++){
            dp[i][j] = Math.min(dp[i-1][j-1],dp[i-1][j])+data.get(j);
        }
    }
    int min = Integer.MAX_VALUE;
    for(int i=0;i<triangle.get(triangle.size()-1).size();i++){
        min = Math.min(min,dp[triangle.size()-1][i]);
    }
    return min;
}

/**
     * 假设[5,10,25,1]，targrt = 15
     * 使用0张5元的，剩下的15元在[10,25,1]中凑得。使用1张5元的，剩下的10元在[10,25,1]中凑得。使用两张5元的，剩下的5元在[10,25,1]中凑得。使用3张5元的，剩下0元，不用凑了。
     * 对[10,25,1]继续递归这个过程，直到遍历完这个数组。
     * */
public int coinChange(int[] coins, int target) {
    return helper(coins,0,target);
}

public int helper(int[] coins,int index,int amount){
    int res = 0;
    //遍历完数组，假如还剩下0元，那么这是一种选择方法
    if(index==coins.length){
        return amount==0?1:0;
    }
    for(int i=0;coins[index]*i<=amount;i++){
        res+=helper(coins,index+1,amount-coins[index]*i);
    }
    return res;
}

/**
     * 使用动态规划来完成，两个变量，index，amount，我们需要求的值是index=0，amount=target
     * 特殊情况：index==coins.length,amount==0?1:0
     * 普通情况：dp[i][j] = dp[index+1][amount-coins[index]]+dp[index+1][amount-coins[index]*2]....
     * */

public int coinChange2(int[] coins, int target) {
    //定义动态规划数组，index以及amount两个变量
    int[][] dp = new int[coins.length+1][target+1];
    dp[coins.length][0] = 1;
    for(int i=1;i<=target;i++) {
        dp[coins.length][i] = 0;
    }
    for(int i=coins.length-1;i>=0;i--){
        for(int j=0;j<=target;j++){
            //                for(int k=0;j-coins[i]*k>=0;k++) {
            //                    dp[i][j] += dp[i + 1][j - coins[i]*k];
            //                }
            dp[i][j] = dp[i+1][j]+(j-coins[i]>=0?dp[i][j-coins[i]]:0);
        }
    }
    return dp[0][target];
}

/**
     * 暴力递归
     * f(i,j):绝顶聪明的人在arr[i...j]上先拿纸牌，可以获得什么分数
     * s(i,j):绝顶聪明的人在arr[i...j]上后拿纸牌，可以获得什么分数
     * 返回玩家1先拿纸牌的分数以及玩家2后拿纸牌的分数
     * */
public boolean PredictTheWinner(int[] nums) {
    return first(nums,0,nums.length-1)>second(nums,0,nums.length-1);
}

/**
     * 先拿纸牌获取的分数
     * start==end:return nums[start]
     * strat!=end:可以取nums[start]或者是nums[end]，
     *      取nums[start]，那么，在[start+1,end]中后取
     *      取nums[end]，那么，在[start,end-1]中后取
     *      因为他绝顶聪明，所以会选取两个最大值取
     * */
public int first(int[] nums,int start ,int end){
    if(start==end){
        return nums[start];
    }
    return Math.max(nums[start]+second(nums,start+1,end),nums[end]+second(nums,start,end-1));
}

/**
     * 后拿纸牌获取的分数
     * start==end:直接返回0
     * strat!=end:对手可以取nums[start]或者是nums[end]，
     *      对手取nums[start]，那么，玩家就可以在[start+1,end]中先取
     *      对手取nums[end]，那么，玩家就可以在[start,end-1]中先取
     *      因为对手也是绝顶聪明，所以会留取最差的情况给玩家，返回最小值
     * */
public int second(int[] nums,int start ,int end){
    if(start==end){
        return 0;
    }
    return Math.min(first(nums,start+1,end),first(nums,start,end-1));
}


/**
     * 递归改动态规划
     * 需要准备两个动态规划数组，f以及s
     * 两个变量：start，end
     * */

public boolean PredictTheWinner(int[] nums) {
    if(nums.length<=1){
        return true;
    }
    int[][] f = new int[nums.length][nums.length];
    int[][] s = new int[nums.length][nums.length];
    for(int i=0;i<nums.length;i++){
        f[i][i] = nums[i];
    }
    for(int i=nums.length-2;i>=0;i--){
        for(int j=i+1;j<nums.length;j++){
            if(i!=j){
                f[i][j] = Math.max(nums[i]+s[i+1][j],nums[j]+s[i][j-1]);
                s[i][j] = Math.min(f[i+1][j],f[i][j-1]);
            }
        }
    }
    return f[0][nums.length-1]>=s[0][nums.length-1];
}

/**
     * 机器人到达指定位置方法数
     * N:N个位置
     * M:机器人开始的位置
     * K:需要走的步数
     * P:最终来到的位置
     * */
public int walkWay(int N,int M,int K,int P){
    if(N<2||M<1||K<1||P<1||M>N||P>N){
        return 0;
    }
    return walk(N,M,K,P);
}

/**
     * @param cur:当前所处的位置
     * @param rest：剩余的步数
     *
     */
public int walk(int N,int cur,int rest,int P){
    //步数走完了，看是否停在了P
    if(rest==0){
        return cur==P?1:0;
    }
    //假如走到了1位置，那么只能向右走
    if(cur==1){
        return walk(N,2,rest-1,P);
    }
    //假如走到了N位置，那么只能向左走
    if(cur==N){
        return walk(N,N-1,rest-1,P);
    }
    //其他位置，可以向左走向右走
    return walk(N,cur+1,rest-1,P)+walk(N,cur-1,rest-1,P);
}
/**
     * 递归转动态规划
     * 可变参数：cur，rest
     * 返回：dp[M][K]
     * */
public int walkWay2(int N,int M,int K,int P){
    if(N<2||M<1||K<1||P<1||M>N||P>N){
        return 0;
    }
    //K:rest N:cur
    int[][] dp = new int[K+1][N+1];
    dp[0][P] = 1;
    //因为rest==0时是初始的特殊情况，所以，所有值都应该根据rest==0时求得，所以应该rest值先进性遍历，即<=k
    for(int i =1;i<=K;i++){
        for(int j=1;j<=N;j++){
            if(j==1){
                dp[i][j] = dp[i-1][2];
            }else if(j==N){
                dp[i][j] = dp[i-1][N-1];
            }else{
                dp[i][j] = dp[i-1][j-1]+dp[i-1][j+1];
            }
        }
    }
    return dp[K][M];
}

public int min_money(int[] arr){
    //定义一个小顶堆，每次取出两个最小的元素作为哈夫曼树的构建
    PriorityQueue<Integer> data = new PriorityQueue<>();
    for(int i=0;i<arr.length;i++){
        data.add(arr[i]);
    }
    //构建哈夫曼树，每次取出两个最小元素作为合并的两个节点，并将合并的值重新放入堆中
    int cur = 0;
    int res = 0;
    while(data.size()>1){
        cur = data.poll()+data.poll();
        data.add(cur);
        res+= cur;
    }
    return res;
}

public class Node{
    private int cost;
    private int profit;
    public Node(int cost,int profit){
        this.cost = cost;
        this.profit = profit;
    }
}
public class MinHeapComparator implements Comparator<Node> {
    @Override
    public int compare(Node o1, Node o2) {
        return o1.cost-o2.cost;
    }
}
public class MaxHeapComparator implements Comparator<Node>{
    @Override
    public int compare(Node o1, Node o2) {
        return o2.profit-o1.profit;
    }
}
public int findMaximizedCapital(int k, int W, int[] Profits, int[] Capital) {
    //小顶堆，按照花费排序
    PriorityQueue<Node> minCostHeap = new PriorityQueue<>(new MinHeapComparator());
    //大顶堆，按照收益排序
    PriorityQueue<Node> maxProfitHeap = new PriorityQueue<>(new MaxHeapComparator());
    for(int i=0;i<Profits.length;i++){
        Node node = new Node(Capital[i],Profits[i]);
        minCostHeap.add(node);
    }

    /***将minCostHeap中所有<=W的元素全部移到MaxProfit中，这样，MaxProfit中存储的就是所有小于总资产的可挑选的项目，
         * 并且按照收益排序，因此，直接获取MaxProfit堆顶元素即可，直到k次项目选择完毕，或者是大顶堆没有元素(没有项目<=手中的资产)*/
    for(int i =0;i<k;i++){
        while(!minCostHeap.isEmpty()&&minCostHeap.peek().cost<=W){
            maxProfitHeap.add(minCostHeap.poll());
        }
        if(maxProfitHeap.size()<1){
            return W;
        }
        W+=maxProfitHeap.poll().profit;
    }
    return W;
}

public class Program{
    private int start;
    private int end;
    public Program(int start,int end){
        this.start = start;
        this.end = end;
    }

}
public class ProgramComparator implements Comparator<Program>{
    @Override
    public int compare(Program o1, Program o2) {
        return o1.end-o2.end;
    }
}
/**
     * 以结束时间最早作为贪心策略
     * 因此，每次需要取出大于等于上一次结束时间的且结束时间最小的项目
     * */
public int bestArrange(Program[] programs, int start) {
    Arrays.sort(programs,new ProgramComparator());
    int result = 0;
    for(int i=0;i<programs.length;i++){
        if(start<=programs[i].start){
            result++;
            start = programs[i].end;
        }
    }
    return result;
}

/**
 * 需要建立两个Map，mapA={value,插入顺序}  MapB={插入顺序,value}
 * */
public class RandomPool<K> {
    HashMap<K,Integer> mapA = new HashMap<>();
    HashMap<Integer,K> mapB = new HashMap<>();
    private int index = 0;
    //插入元素，需要插入两个map
    public void insert(K key){
        if(!mapA.containsKey(key)) {
            mapA.put(key, index);
            mapB.put(index, key);
            index++;
        }
    }

    //删除元素的时候，假如mapB key在0-25之间，这样，删除某一个元素的话，key就不是均匀分布的，因此，需要从最后一个位置补元素
    public void delete(K key){
        if(mapA.containsKey(key)) {
            int del_index = mapA.get(key);
            int lastIndex = --index;
            //将最后一个元素移到删除位置
            K lastEle = mapB.get(lastIndex);
            mapA.put(lastEle,del_index);
            mapB.put(del_index,lastEle);
            mapB.remove(lastIndex);
            mapA.remove(key);
        }
    }

    //随机等概率获取元素，mapB key在0-index之间，所以Math.random()*index即可返回随机的元素下标
    public K getRandom(){
        if(index==0){
            return null;
        }
        return mapB.get((int)(Math.random()*index));
    }

}

public int numIslands(char[][] grid) {
    if(grid.length==0||grid[0].length==0){
        return 0;
    }
    int res = 0;
    int row = grid.length;
    int col = grid[0].length;
    for(int i=0;i<row;i++){
        for(int j=0;j<col;j++){
            if(grid[i][j]=='1'){
                res++;
                infect(grid,i,j,row,col);
            }
        }
    }
    return res;
}

public void infect(char[][]grid,int i,int j,int M,int N){
    if(i<0||j<0||i>=M||i>=N||grid[i][j]!='1'){
        return ;
    }
    grid[i][j]='2';
    infect(grid,i-1,j,M,N);
    infect(grid,i+1,j,M,N);
    infect(grid,i,j-1,M,N);
    infect(grid,i,j+1,M,N);
}

private List<Integer> result;
//一圈一圈进行打印，当左上角元素在右下角元素的上方或者右方时结束
public List<Integer> spiralOrder(int[][] matrix) {
    result = new ArrayList<>();
    if(matrix.length==0||matrix[0].length==0){
        return result;
    }
    int left_row = 0;
    int left_col = 0;
    int right_row = matrix.length-1;
    int right_col = matrix[0].length-1;
    while(left_row<=right_row&&left_col<=right_col){
        helper(matrix,left_row++,left_col++,right_row--,right_col--);
    }
    return result;
}

/**打印一圈元素局灶性，这实际上是一个矩形，需要传递该矩形的左上角以及左下角坐标
     * 当两个坐标同行，直接打印
     * 当两个坐标同列，直接打印
     * 两个坐标不同行也不同列：
     *
     */
public void helper(int[][] matrix,int left_row,int left_col,int right_row,int right_col){
    if(left_row==right_row){
        for(int i= left_col;i<=right_col;i++){
            result.add(matrix[left_row][i]);
        }
    }else if(left_col==right_col){
        for(int i= left_row;i<=right_row;i++){
            result.add(matrix[i][left_col]);
        }
    }else{
        int curCol = left_col;
        while(curCol!=right_col){
            result.add(matrix[left_row][curCol]);
            curCol++;
        }
        int curRow = left_row;
        while(curRow!=right_row){
            result.add(matrix[curRow][right_col]);
            curRow++;
        }

        while(curCol!=left_col){
            result.add(matrix[right_row][curCol]);
            curCol--;
        }
        while(curRow!=left_row){
            result.add(matrix[curRow][left_col]);
            curRow--;
        }
    }
}

/**
     * 当a点走完最后一个点，可以结束循环
     * 执行完一次对角线打印，坐标变换方式：
     * b：先下，走到底了，再右
     * a：先右，走到最右，再下
     * */
 private int arr_index= 0;
public int[] findDiagonalOrder(int[][] matrix) {

    if(matrix.length==0||matrix[0].length==0){
        return new int[0];
    }
    int[] result = new int[matrix.length*matrix[0].length];
    arr_index = 0;
    boolean form = false;
    int row_lenth = matrix.length-1;
    int col_length = matrix[0].length-1;
    int a_row =0,b_row = 0,a_col=0,b_col=0;
    //a到达最后一个节点
    while(a_row<=row_lenth){
        helper(matrix,a_row,a_col,b_row,b_col,form,result);
        if(a_col<col_length){
            a_col++;
        }else{
            a_row++;
        }
        if(b_row<row_lenth){
            b_row++;
        }else{
            b_col++;
        }
        form=!form;
    }
    return result;

}
/**
     * 打印一个对角，a为右上角元素，b为左下角元素
     * 因为有左到右以及右到左两种方式交替，所以需要一个form参数
     * 右到左：a_row>=b_row 赋值 移动到做下第一个点:a_row--  a_col--
     * */
public void helper(int[][] matrix,int a_row,int a_col,int b_row,int b_col,boolean form,int[] result){
    if(form){
        while(a_row<=b_row&&a_col>=b_col){
            result[arr_index++] = matrix[a_row++][a_col--];
        }
    }else{
        while(a_row<=b_row&&a_col>=b_col){
            result[arr_index++] = matrix[b_row--][b_col++];
        }
    }
}

//使用index来代表栈顶位置，index=0，栈为空，index = size，栈满
public class ArrStack {
    private int[] arr;
    private int index;
    public ArrStack(int size){
        arr = new int[size];
    }
    public void push(int x){
        if(index==arr.length){
            throw new ArrayIndexOutOfBoundsException("full");
        }
        arr[index++] = x;
    }

    public int  pop(){
        if(index==0){
            throw new ArrayIndexOutOfBoundsException("empty");
        }
        return arr[--index];
    }
    public int  peek(){
        if(index==0){
            throw new ArrayIndexOutOfBoundsException("empty");
        }
        return arr[index-1];
    }
    public boolean isEmpty(){
        return index==0;
    }
}

public class MyCircularQueue {
    /**
     * 记录队头的front，记录队尾的wear，size表示队列大小
     * front指向第一个元素 rear指向最后一个元素后一个位置
     * 入队：arr[rear]=value，rear后移，size++，注意，因为要完成一个循环队列rear+1需要取模运算
     * 出队：font后移取模运算，size--
     * */
    private int front = 0;
    private int rear = 0;
    private int size = 0;
    private int[] arr;
    /** Initialize your data structure here. Set the size of the queue to be k. */
    public MyCircularQueue(int k) {
        arr = new int[size];
    }

    /** Insert an element into the circular queue. Return true if the operation is successful. */
    public boolean enQueue(int value) {
        if(size==arr.length){
            return false;
        }
        arr[rear] = value;
        rear = (rear +1)%arr.length;
        size++;
        return true;
    }

    /** Delete an element from the circular queue. Return true if the operation is successful. */
    public boolean deQueue() {
        if(size==0){
            return false;
        }
        front = (front++)%arr.length;
        size--;
        return true;
    }

    /** Get the front item from the queue. */
    public int Front() {
        if(size==0){
            throw new RuntimeException("empty");
        }
        return arr[front];
    }

    /** Get the last item from the queue. */
    public int Rear() {
        if(size==0){
            throw new RuntimeException("empty");
        }
        return arr[(rear-1)%arr.length];
    }

    /** Checks whether the circular queue is empty or not. */
    public boolean isEmpty() {
        return size==0;
    }

    /** Checks whether the circular queue is full or not. */
    public boolean isFull() {
        return size==arr.length;
    }
}

Stack<Integer> data = new Stack<>();
Stack<Integer> min = new Stack<>();
public MinStack() {

}

/**入栈的时候除了data栈之外，还包括min栈，存储的每一个元素其相应的最小值
     *
     */

public void push(int x) {
    data.push(x);
    if(min.isEmpty()){
        min.push(x);
    }else{
        int minVal = min.peek();
        if(x<minVal){
            min.push(x);
        }else{
            min.push(minVal);
        }
    }

}

public void pop() {
    if(!data.isEmpty()) {
        data.pop();
        min.pop();
    }else{
        throw new ArrayIndexOutOfBoundsException("empty");
    }
}

public int top() {
    int res = 0;
    if(!data.isEmpty()) {
        res = data.peek();
    }else{
        throw new ArrayIndexOutOfBoundsException("empty");
    }
    return res;
}

public int getMin() {
    int res = 0;
    if(!min.isEmpty()) {
        res = min.peek();
    }else{
        throw new ArrayIndexOutOfBoundsException("empty");
    }
    return res;
}

private Queue<Integer> data = new LinkedList<>();
private Queue<Integer> helper = new LinkedList<>();
private int top;
public MyStack() {

}

/** 放入到data队列中 */
public void push(int x) {
    data.add(x);
}

/** pop元素的时候，将前n-1个元素放入helper中，只留下最后一个元素，这样，就可以达到栈的目的
     * */
public int pop() {
    while(data.size()>1){
        helper.add(data.remove());
    }
    int res = data.remove();
    swap();
    return res;
}
public void swap(){
    Queue<Integer> tmp = this.data;
    this.data = this.helper;
    this.helper = tmp;
}
/** Get the top element. */
public int top() {
    while(data.size()>1){
        helper.add(data.poll());
    }
    int res = data.poll();
    helper.add(res);
    swap();
    return res;
}

/** Returns whether the stack is empty. */
public boolean empty() {
    return data.size()==0;
}

Stack<Integer> sta_pop = new Stack<>();
/** Initialize your data structure here. */
public MyQueue() {

}

/** Push element x to the back of queue. */
public void push(int x) {
    pushtoPop();
    sta_push.push(x);
}

/** Removes the element from in front of queue and returns that element. */
public int pop() {
    pushtoPop();
    return sta_pop.pop();
}

/** Get the front element. */
public int peek() {
    pushtoPop();
    return sta_pop.peek();
}
//将元素从push推到pop
//1.一次性推完push中元素 2.pop中为空
public void pushtoPop(){
    if(sta_pop.isEmpty()) {
        while (!sta_push.isEmpty()) {
            sta_pop.push(sta_push.pop());
        }
    }
}

/** Returns whether the queue is empty. */
public boolean empty() {
    return sta_pop.isEmpty()&&sta_push.isEmpty();
}

public int minDepth(TreeNode root) {
    return helper(root);
}

/**
     * 左右节点均不为空使，返回min(left,right)+1
     * 左右节点只有一个为空（left==null）时，需要返回right+1，而不是返回min(lef,right)+1
     * */
public int helper(TreeNode root){
    if(root==null){
        return 0;
    }
    int left = helper(root.left);
    int right = helper(root.right);
    if(root.left==null||root.right==null){
        return left+right+1;
    }
    return Math.min(left,right)+1;
}

/*
左子树的所有点应该在(minVal,root),右子树在(root,maxVal)
*/
public boolean isValidBST(TreeNode root) {
    return helper(root,Long.MIN_VALUE,Long.MAX_VALUE);
}

public boolean helper(TreeNode root,long minVal,long maxVal){
    if(root==null){
        return true;
    }
    if(root.val<=minVal||root.val>=maxVal){
        return false;
    }
    return helper(root.left,minVal,root.val)&&helper(root.right,root.val,maxVal);
}

public boolean isValidBST(TreeNode root) {
    boolean isRoot = true;
    if(root==null){
        return true;
    }
    Stack<TreeNode> stack = new Stack<>();
    int last = Integer.MIN_VALUE;
    while(!stack.isEmpty()||root!=null){
        while(root!=null){
            stack.push(root);
            root = root.left;
        }
        if(!stack.isEmpty()){
            TreeNode node = stack.pop();
            if(isRoot){
                last = node.val;
                isRoot = false;
            }else if(node.val>last){
                last = node.val;
            }else{
                return false;
            }
            //dayin
            root = node.right;
        }
    }
    return true;
}

public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<>();
    Stack<TreeNode> stack = new Stack<>();
    while(!stack.isEmpty()||root!=null){
        while(root!=null){
            stack.push(root);
            result.add(root.val);
            root = root.left;
        }
        if(!stack.isEmpty()) {
            TreeNode node = stack.pop();
            root = node.right;
        }
    }
    return result;
}

/**
     * 将root的最左的元素全部压入栈，当root==null，表示压到底了，最左侧已经没有元素了，此时，可以将栈顶元素取出
     * 并开始对右子树做同样操作
     * */
public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<>();
    Stack<TreeNode> stack = new Stack<>();
    while(!stack.isEmpty()||root!=null){
        while (root!=null){
            stack.push(root);
            root = root.left;
        }
        if(!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            root = node.right;
        }
    }
    return result;
}

/**
     * 前序根右左，反转为左右根即可
     * */
public List<Integer> postorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<>();
    Stack<TreeNode> stack = new Stack<>();
    while(!stack.isEmpty()||root!=null){
        while(root!=null){
            result.add(0,root.val);
            stack.push(root);
            root = root.right;
        }
        if(!stack.isEmpty()){
            TreeNode node = stack.pop();
            root = node.left;
        }
    }
    return result;
}

/**
     * 两个根节点值相等
     * 左边的左子树和右边的右子树相等
     * 左边的右子树和右边的左子树相等
     * */
public boolean isSymmetric(TreeNode root) {
    //一般二叉树的题目首先判断是否null
    if(root==null){
        return true;
    }
    return helper(root,root);
}

public boolean helper(TreeNode p,TreeNode q){
    // 两个节点同时为空，返回true 只有一个节点为空，返回false
    if(p==null||q==null){
        return p==null&&q==null;
    }
    return p.val==q.val&&helper(p.left,q.right)&&helper(p.right,q.left);
}