// 解决方案类
class Solution {
    public int findMinArrowShots(int[][] points) {
        // 根据气球直径的开始坐标从小到大排序
        // 使用Integer内置的比较方法，以避免整数溢出问题
        Arrays.sort(points, (a, b) -> Integer.compare(a[0], b[0]));

        // 初始化箭的数量为1，因为至少需要一支箭
        int result = 1;

        // 遍历气球数组，从第二个气球开始
        for (int i = 1; i < points.length; i++) {
            // 检查当前气球的起始坐标是否大于上一个气球的结束坐标
            if (points[i][0] > points[i - 1][1]) {
                // 当前气球不重叠，需要新的箭
                result++;
            } else {
                // 当前气球与上一个气球重叠，更新当前气球的结束坐标为两者中较小的值
                points[i][1] = Math.min(points[i][1], points[i - 1][1]);
            }
        }

        // 返回最少的箭数量
        return result;
    }
}

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        // 将区间数组按每个区间的起始位置进行排序
        Arrays.sort(intervals, (a, b) -> {
            return a[0] - b[0]; // 比较两个区间的起始位置，按升序排列
        });
        int count = 1;// 计数器初始化为1，用于统计不重叠的区间数量
        // 遍历区间数组，从第二个区间开始
        for (int i = 1; i < intervals.length; i++) {
            // 如果当前区间与前一个区间不重叠
            if(intervals[i-1][1] <= intervals[i][0]){
                // 增加计数器
                count++;
            } else {
                // 如果当前区间与前一个区间重叠，更新当前区间的右边界为两者右边界的较小值
                intervals[i][1] = Math.min(intervals[i - 1][1], intervals[i][1]);
            }
        }
        
        return intervals.length - count;// 返回需要移除的重叠区间数量，即总区间数减去不重叠区间的数量
    }
}

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        // 将区间数组按每个区间的起始位置进行排序
        Arrays.sort(intervals, (a, b) -> {
            // 比较两个区间的起始位置，按升序排列
            return Integer.compare(a[0], b[0]);
        });

        // 记录需要移除的重叠区间数量
        int remove = 0;
        // 初始化前一个区间的右边界为第一个区间的右边界
        int preR = intervals[0][1];

        // 遍历区间数组，从第二个区间开始
        for (int i = 1; i < intervals.length; i++) {
            // 如果当前区间的起始位置不小于前一个区间的右边界（无重叠）
            if (preR <= intervals[i][0]) {
                // 更新前一个区间的右边界为当前区间的右边界
                preR = intervals[i][1];
            } else {
                // 如果当前区间与前一个区间重叠，增加需要移除的区间计数
                remove++;
                // 更新前一个区间的右边界为两者右边界的较小值，以减少后续重叠
                preR = Math.min(preR, intervals[i][1]);
            }
        }

        // 返回需要移除的重叠区间数量
        return remove;
    }
}

class Solution {
    // 定义一个方法 partitionLabels，接收一个字符串 s，返回一个整数列表
    public List<Integer> partitionLabels(String s) {
        // 创建一个长度为26的数组 edge，用于存储每个字符最后出现的位置
        int[] edge = new int[26];
        // 遍历字符串，记录每个字符的最右边界索引
        for(int i = 0; i < s.length(); i++) edge[s.charAt(i) - 'a'] = i;
        // 创建一个结果列表，用于存储每个分区的长度
        List<Integer> result = new ArrayList<>();
        // 初始化两个指针，left 表示分区的起始位置，right 表示当前分区的结束位置
        int left = 0, right = 0;
        // 遍历字符串
        for(int i = 0; i < s.length(); i++) {
            // 更新当前分区的最右边界
            right = Math.max(right, edge[s.charAt(i) - 'a']);
            
            // 如果当前位置 i 等于当前分区的最右边界
            if(right == i) {
                // 将当前分区的长度添加到结果列表中
                result.add(right - left + 1);
                // 更新左边界为下一个分区的起始位置
                left = right + 1;
            }
        }
        return result;
    }
}

class Solution {
    public int[][] merge(int[][] intervals) {
        // 如果区间数组为空，直接返回空数组
        if(intervals.length == 0) return new int[0][2];

        // 将区间数组按每个区间的起始位置进行排序
        Arrays.sort(intervals, new Comparator<int[]>() {
            public int compare(int[] intervals1, int[] intervals2) {
                // 按照区间的起始值升序排列
                return intervals1[0] - intervals2[0];
            }
        });

        // 用来保存合并后的区间
        List<int[]> result = new ArrayList<>();

        // 遍历所有区间
        for(int i = 0; i < intervals.length; i++) {
            // 当前区间的左边界 L 和右边界 R
            int L = intervals[i][0], R = intervals[i][1];

            // 如果 result 为空，或者 result 中最后一个区间的右边界小于当前区间的左边界
            // 说明当前区间与前一个区间没有重叠，直接添加当前区间
            if(result.size() == 0 || result.get(result.size() - 1)[1] < L) {
                result.add(new int[]{L, R});
            } else {
                // 否则，说明当前区间和前一个区间有重叠
                // 将最后一个区间的右边界更新为两个区间中较大的右边界，合并区间
                result.get(result.size() - 1)[1] = Math.max(result.get(result.size() - 1)[1], R);
            }
        }

        // 将结果列表转换为二维数组形式并返回
        return result.toArray(new int[result.size()][]);
    }
}

class Solution {
    public String removeDuplicates(String s) {
        // 使用 LinkedList 来存储不重复的字符，作为栈使用
        LinkedList<Character> list = new LinkedList<>();

        // 遍历字符串中的每一个字符
        for (int i = 0; i < s.length(); i++) {
            Character c = s.charAt(i);

            // 如果列表不为空且当前字符与列表最后一个字符相同，则移除最后一个字符（即相邻的重复字符）
            if (!list.isEmpty() && list.peekLast() == c) {
                list.pollLast();
            } else {
                // 否则将当前字符加入列表的末尾
                list.offer(c);
            }
        }

        // 使用 StringBuilder 将最终结果拼接成字符串
        StringBuilder sb = new StringBuilder();
        while (!list.isEmpty()) {
            // 依次从列表中取出字符，拼接成结果字符串
            sb.append(list.poll());
        }

        // 返回拼接好的字符串
        return sb.toString();
    }
}

class Solution {
    public String removeDuplicates(String s) {
        StringBuilder sb  = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            Character c = s.charAt(i);
            if(sb.length() > 0 && sb.charAt(sb.length()-1) == c){
                sb.deleteCharAt(sb.length()-1);
            }else{
                sb.append(c);
            }   
        }

        return sb.toString();
    }
}

class Solution {
    public String removeDuplicates(String s) {
        // 双指针
        char[] chs = s.toCharArray();
        int left = 0;  // 左指针用于表示结果部分的末尾
        for (int right = 0; right < s.length(); right++) {
            // 如果当前字符和结果末尾字符相同，左指针回退
            if (left > 0 && chs[right] == chs[left - 1]) {
                left--;
            } else {
                chs[left] = chs[right];  // 更新结果部分
                left++;
            }
        }
        return new String(chs, 0, left);  // 只返回有效部分的字符串
    }
}

class Solution {
    public int evalRPN(String[] tokens) {
        // 使用栈来存储计算过程中的操作数
        Stack<Integer> stack = new Stack<>();
        
        // 遍历所有的输入 tokens
        for (int i = 0; i < tokens.length; i++) {
            // 如果当前 token 是加号
            if (tokens[i].equals("+")) {
                // 弹出栈顶的两个操作数，进行相加，然后将结果压入栈中
                // 这里 pop() 两次是因为加法是二元操作，需要两个操作数
                stack.push(stack.pop() + stack.pop());
            }
            // 如果当前 token 是减号
            else if (tokens[i].equals("-")) {
                // 弹出栈顶的两个操作数，先弹出的数为减数，后弹出的数为被减数
                // 计算后将结果压入栈中
                stack.push(-stack.pop() + stack.pop());
            }
            // 如果当前 token 是乘号
            else if (tokens[i].equals("*")) {
                // 弹出栈顶的两个操作数，进行相乘，然后将结果压入栈中
                stack.push(stack.pop() * stack.pop());
            }
            // 如果当前 token 是除号
            else if (tokens[i].equals("/")) {
                // 弹出栈顶的两个操作数，注意除法的顺序：
                // 第一个弹出的数为除数 (num2)，第二个弹出的数为被除数 (num1)
                int num2 = stack.pop();
                int num1 = stack.pop();
                // 进行除法计算后，将结果压入栈中
                stack.push(num1 / num2);
            }
            // 如果当前 token 是数字
            else {
                // 将数字字符串转换为整数，并压入栈中
                stack.push(Integer.parseInt(tokens[i]));
            }
        }
        
        // 最终栈中只剩下一个元素，即计算结果，弹出栈顶并返回
        return stack.pop();
    }
}

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        // 定义一个双端队列，用来存储滑动窗口中可能的最大值的下标
        LinkedList<Integer> deque = new LinkedList<>();
        int n = nums.length;
        // 结果数组，用来存储每个滑动窗口的最大值
        int[] res = new int[n - k + 1];
        // 结果数组的下标，用于记录结果的位置
        int idx = 0;
        
        // 遍历数组
        for (int i = 0; i < n; i++) {
            // 1. 保证队列头节点在当前滑动窗口的范围内
            // 如果队列头部元素的下标小于滑动窗口的起始下标（i - k + 1），
            // 说明该下标已经滑出窗口范围，需要将其移除队列
            while (!deque.isEmpty() && deque.peek() < i - k + 1) {
                deque.poll();
            }
            
            // 2. 保证队列中元素按从大到小排列
            // 如果当前元素 nums[i] 大于队列末尾元素对应的值，说明队列末尾元素不可能成为窗口的最大值，
            // 需要将其从队列中移除，直到找到一个比当前元素大的元素或队列为空
            while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
                deque.pollLast();
            }

            // 将当前元素下标加入队列，保持队列的单调性（从大到小）
            deque.offer(i);

            // 当窗口大小达到 k（即 i >= k - 1 时），可以确定此时的窗口内最大值
            // 最大值就是队列头部的元素所对应的数组值，将其加入结果数组
            if (i >= k - 1) {
                res[idx++] = nums[deque.peek()];
            }
        }
        return res;
    }
}

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums.length == 0 || k == 0) return new int[0];
        Deque<Integer> deque = new LinkedList<>();
        int[] res = new int[nums.length - k + 1];
        // 未形成窗口
        for(int i = 0; i < k; i++) {
            while(!deque.isEmpty() && deque.peekLast() < nums[i])
                deque.removeLast();
            deque.addLast(nums[i]);
        }
        res[0] = deque.peekFirst();
        // 形成窗口后
        for(int i = k; i < nums.length; i++) {
            if(deque.peekFirst() == nums[i - k])
                deque.removeFirst();
            while(!deque.isEmpty() && deque.peekLast() < nums[i])
                deque.removeLast();
            deque.addLast(nums[i]);
            res[i - k + 1] = deque.peekFirst();
        }
        return res;
    }
}

class Solution {
    public boolean isValid(String s) {
        // 初始化栈，用于存储需要匹配的右括号
        Stack<Character> stack = new Stack<>();

        // 创建哈希映射，将左括号与相应的右括号配对
        Map<Character, Character> map = new HashMap<>();
        map.put('(', ')');
        map.put('{', '}');
        map.put('[', ']');

        // 遍历字符串的每一个字符
        for (int i = 0; i < s.length(); i++) {
            Character c = s.charAt(i);

            // 如果字符是左括号（即 map 的键），则将对应的右括号压入栈中
            if (map.containsKey(c)) {
                stack.push(map.get(c));
            } 
            // 如果是右括号，检查栈顶元素是否与当前右括号匹配
            else {
                // 如果栈非空，且栈顶的括号与当前字符匹配，则弹出栈顶元素
                if (!stack.isEmpty() && stack.peek() == c) {
                    stack.pop();
                } else {// 如果不匹配或栈为空，返回 false，表示括号不合法
                    return false;
                }
            }
        }
        return stack.isEmpty();// 最后检查栈是否为空，如果为空则表示所有括号匹配，否则返回 false
    }
}

class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            // 如何碰到的是键，就入栈
            Character c = s.charAt(i);
            if (c == '(') {
                stack.push(')');
            } else if (c == '{') {
                stack.push('}');
            } else if (c == '[') {
                stack.push(']');
            } else {
                if (!stack.isEmpty() && stack.peek() == c) {
                    stack.pop();
                } else {
                    return false;
                }
            }
        }
        return stack.isEmpty();
    }
}

class Solution {
    // 定义保存最终结果的列表，每个解法是一个List<String>，代表棋盘上的布局
    List<List<String>> result = new ArrayList<>();
    // 定义保存当前棋盘路径的列表，存放字符串形式的每一行布局
    List<String> path = new ArrayList<>();

    // 主函数，负责初始化棋盘并调用回溯算法
    public List<List<String>> solveNQueens(int n) {
        // 定义棋盘，char数组，用 '.' 表示空位
        char[][] chessboard = new char[n][n];
        // 初始化棋盘，每个位置都填充为 '.'
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                chessboard[i][j] = '.';
            }
        }
        backtracking(chessboard, n, 0);// 开始回溯算法，从第0行开始放置皇后
        return result;// 返回所有可能的解法
    }

    // 回溯函数，递归尝试每一行的不同列位置放置皇后
    public void backtracking(char[][] chessboard, int n, int depth) {
        // 如果当前路径长度等于n，说明已经找到一个解法，加入结果集中
        if (path.size() == n) {
            result.add(new ArrayList<>(path));  // 将当前路径加入到结果中
            return;  // 回溯终止条件
        }

        // 尝试在当前行（depth）每一列放置皇后
        for (int col = 0; col < n; col++) {
            // 如果当前位置放置皇后合法
            if (isValid(chessboard, n, depth, col)) {
                // 构建当前行的字符串表示，并在指定列放置 'Q'
                StringBuilder sb = new StringBuilder();
                for (int j = 0; j < n; j++) sb.append(".");  // 初始化为全是空位 '.'
                sb.replace(col, col + 1, "Q");  // 在col列位置放置皇后 'Q'
                path.add(sb.toString());// 将当前行加入路径
                chessboard[depth][col] = 'Q';// 在棋盘上放置皇后
                backtracking(chessboard, n, depth + 1);// 递归放置下一行的皇后
                chessboard[depth][col] = '.';// 回溯，移除当前行的皇后
                
                // 回溯，移除当前行的字符串布局
                path.remove(path.size() - 1);  // 使用 path.removeLast() 会出错，因为 List 不支持这个方法
            }
        }
    }

    // 判断在棋盘的(row, col)位置放置皇后是否合法
    public boolean isValid(char[][] chessboard, int n, int row, int col) {
        // 判断当前列是否有其他皇后
        for (int i = 0; i < row; i++) {
            if (chessboard[i][col] == 'Q') return false;  // 当前列已经有皇后，放置非法
        }

        // 判断135度对角线（左上到右下）是否有其他皇后
        for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
            if (chessboard[i][j] == 'Q') return false;  // 135度对角线上已经有皇后
        }

        // 判断45度对角线（右上到左下）是否有其他皇后
        for (int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
            if (chessboard[i][j] == 'Q') return false;  // 45度对角线上已经有皇后
        }
        
        // 没有冲突，放置合法
        return true;
    }
}

class Solution {
    // 存储最终结果的列表，每个解法是一个 List<String>，表示棋盘的布局
    List<List<String>> result = new ArrayList<>();
    
    // 主函数，初始化棋盘并调用回溯算法
    public List<List<String>> solveNQueens(int n) {
        // 定义棋盘，初始化为 '.' 表示空位
        char[][] chessboard = new char[n][n];
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < n; j++) {
                chessboard[i][j] = '.';
            }
        }
        
        // 调用回溯函数，开始从第0行放置皇后
        backtracking(chessboard, n, 0);
        
        // 返回所有可能的解法
        return result;
    }

    // 回溯函数，递归尝试每一行的不同列放置皇后
    public void backtracking(char[][] chessboard, int n, int depth) {
        // 如果已经放置了n个皇后，说明找到一个解，保存结果
        if(depth == n) {
            result.add(arrayToList(chessboard));  // 将棋盘的当前布局转为列表并加入结果
            return;  // 回溯终止条件
        }

        // 尝试在当前行（depth）的每一列放置皇后
        for(int col = 0; col < n; col++) {
            // 如果在 (depth, col) 放置皇后合法
            if(isValid(chessboard, n, depth, col)) {
                // 在棋盘上放置皇后
                chessboard[depth][col] = 'Q';
                
                // 递归放置下一行的皇后
                backtracking(chessboard, n, depth + 1);
                
                // 回溯，撤销当前行的皇后
                chessboard[depth][col] = '.';
            }
        }
    }

    // 将棋盘转换为字符串列表，便于保存结果
    public List<String> arrayToList(char[][] chessboard) {
        List<String> list = new ArrayList<>();
        for(char[] chs : chessboard) {
            // 将每一行的字符数组转换为字符串并加入列表
            list.add(String.copyValueOf(chs));
        }
        return list;
    }

    // 判断在棋盘 (row, col) 位置放置皇后是否合法
    public boolean isValid(char[][] chessboard, int n, int row, int col) {
        // 判断当前列是否有其他皇后
        for (int i = 0; i < row; i++) {
            if (chessboard[i][col] == 'Q') return false;  // 同列有冲突
        }

        // 判断135度对角线（左上到右下）是否有皇后
        for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
            if (chessboard[i][j] == 'Q') return false;  // 135度对角线上有冲突
        }

        // 判断45度对角线（右上到左下）是否有皇后
        for (int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
            if (chessboard[i][j] == 'Q') return false;  // 45度对角线上有冲突
        }
        
        // 没有冲突，放置合法
        return true;
    }
}

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        //暴力解法：直接合并,然后排序
        for(int i=0;i<n;i++){
            nums1[m+i] = nums2[i];
        }

        //方式1：使用内置函数
        //Arrays.sort(nums1);
        //方式2：冒泡排序
        for(int i=0;i<nums1.length;i++){
            for(int j=i+1;j<nums1.length;j++){
                if(nums1[i] > nums1[j]){
                    int temp = nums1[j];
                    nums1[j] = nums1[i];
                    nums1[i] = temp;
                }
            }
        }
    }
}

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        // 双指针，i 指向 nums1 的第一个元素，j 指向 nums2 的第一个元素
        int i = 0, j = 0;
        // 创建一个临时数组 result，用于存储合并后的有序数组
        int[] result = new int[m + n];
        int cur;  // 当前需要填入 result 的元素

        // 当 i 或 j 不越界时，进行循环
        while (i < m || j < n) {
            // 如果 nums1 的所有有效元素已经处理完毕，将 nums2 的剩余元素直接放入 result
            if (i == m) {
                cur = nums2[j++];
            } 
            // 如果 nums2 的所有元素已经处理完毕，将 nums1 的剩余元素放入 result
            else if (j == n) {
                cur = nums1[i++];
            } 
            // 如果 nums1 当前元素小于 nums2 当前元素，将 nums1 的当前元素放入 result
            else if (nums1[i] < nums2[j]) {
                cur = nums1[i++];
            } 
            // 否则将 nums2 当前元素放入 result
            else {
                cur = nums2[j++];
            }
            // 将当前值填入 result 的相应位置
            result[i + j - 1] = cur;
        }

        // 将 result 数组中的元素复制回 nums1 中
        for (int l = 0; l < nums1.length; l++) {
            nums1[l] = result[l];
        }
    }
}

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        // 双指针，i 指向 nums1 有效部分的最后一个元素，j 指向 nums2 的最后一个元素
        int i = m - 1, j = n - 1;
        int tail = m + n - 1;// tail 指向 nums1 的最后一个位置，作为填充的位置
        int cur;  // 当前需要填入 nums1 的元素

        // 当 i 或 j 不越界时，进行循环
        while (i >= 0 || j >= 0) {
            if (i == -1) {// 如果 nums1 已经全部填完了，则将 nums2 中剩下的元素直接填入 nums1
                cur = nums2[j--];
            }else if (j == -1) {// 如果 nums2 已经全部填完了，则将 nums1 中剩下的元素留在原地
                cur = nums1[i--];
            }else if (nums1[i] > nums2[j]) {// 比较 nums1 和 nums2 的当前元素，将较大值填入 nums1 的尾部
                cur = nums1[i--];
            }else {
                cur = nums2[j--];
            }
            // 将当前值填入 nums1 的尾部
            nums1[tail--] = cur;
        }
    }
}

class Solution {
    // 存储最终结果的列表，用于保存所有满足条件的子序列
    List<List<Integer>> result = new ArrayList<>();
    // 存储当前子序列的路径，用于构建每一个子序列
    List<Integer> path = new ArrayList<>();

    // 主方法 findSubsequences，输入一个整数数组 nums，返回所有递增的子序列
    public List<List<Integer>> findSubsequences(int[] nums) {
        // 从索引 0 开始回溯生成子序列
        backtracking(nums, 0);
        // 返回生成的所有递增子序列
        return result;
    }

    // 回溯算法，用于生成所有符合条件的子序列
    public void backtracking(int[] nums, int start) {
        // 当当前路径长度大于1时，将其加入结果列表中（子序列长度至少为2）
        if (path.size() > 1) result.add(new ArrayList<>(path));

        // 使用 Set 集合去重，避免在同一层次中使用相同的元素
        Set<Integer> set = new HashSet<>();

        // 遍历数组，从起始索引开始
        for (int i = start; i < nums.length; i++) {
            // 剪枝：跳过不符合递增条件或在同一层中已处理过的数字
            // 1. 如果当前数字小于路径中的最后一个数字，则跳过（不满足递增条件）
            // 2. 如果当前数字在本轮递归中已经使用过，则跳过
            if ((!path.isEmpty() && nums[i] < path.get(path.size() - 1)) || set.contains(nums[i])) continue;

            // 将当前数字加入 Set 集合，表示本层已经处理过该数字
            set.add(nums[i]);
            // 将当前数字加入子序列路径
            path.add(nums[i]);
            // 递归处理后续的数字，构建新的子序列
            backtracking(nums, i + 1);
            // 回溯：移除路径中的最后一个元素，进行下一个可能的选择
            path.remove(path.size() - 1);
        }
    }
}

class Solution {
    // 存储最终结果的列表，用于保存所有满足条件的子序列
    List<List<Integer>> result = new ArrayList<>();
    // 存储当前子序列的路径，用于构建每一个子序列
    List<Integer> path = new ArrayList<>();

    // 主方法 findSubsequences，输入一个整数数组 nums，返回所有递增的子序列
    public List<List<Integer>> findSubsequences(int[] nums) {
        // 从索引 0 开始回溯生成子序列
        backtracking(nums, 0);
        // 返回生成的所有递增子序列
        return result;
    }

    // 回溯算法，用于生成所有符合条件的子序列
    public void backtracking(int[] nums, int start) {
        // 当当前路径长度大于1时，将其加入结果列表中（子序列长度至少为2）
        if (path.size() > 1) result.add(new ArrayList<>(path));

        // 创建哈希数组，范围为 [-100, 100]，用于去重
        boolean[] hash = new boolean[201];

        // 遍历数组，从起始索引开始
        for (int i = start; i < nums.length; i++) {
            // 剪枝：跳过不符合递增条件或在同一层中已处理过的数字
            // 1. 如果当前数字小于路径中的最后一个数字，则跳过（不满足递增条件）
            // 2. 如果当前数字在本轮递归中已经使用过（即哈希数组中标记为 true），则跳过
            if ((!path.isEmpty() && nums[i] < path.get(path.size() - 1)) || hash[nums[i] + 100]) continue;

            // 将当前数字标记为已使用
            hash[nums[i] + 100] = true;
            // 将当前数字加入子序列路径
            path.add(nums[i]);
            // 递归处理后续的数字，构建新的子序列
            backtracking(nums, i + 1);
            // 回溯：移除路径中的最后一个元素，进行下一个可能的选择
            path.remove(path.size() - 1);
        }
    }
}