public boolean wordBreak(String s, List<String> wordDict) {
    // 将单词字典转换为哈希集合，提高查找效率
    Set<String> wordDictSet = new HashSet<>(wordDict);
    
    // 创建 dp 数组，dp[i] 表示 s 的前 i 个字符是否可以被拆分
    boolean[] dp = new boolean[s.length() + 1];
    
    // 初始化：空字符串可以被拆分
    dp[0] = true;
    
    // 遍历字符串的每个位置
    for (int i = 1; i <= s.length(); i++) {
        // 检查所有可能的分割点
        for (int j = 0; j < i; j++) {
            // 如果前 j 个字符可以被拆分，且子串 s[j:i] 在字典中
            if (dp[j] && wordDictSet.contains(s.substring(j, i))) {
                // 设置 dp[i] 为 true，并跳出内层循环
                dp[i] = true;
                break;
            }
        }
    }
    
    // 返回整个字符串是否可以被拆分
    return dp[s.length()];
}

public boolean wordBreak(String s, List<String> wordDict) {
    Set<String> wordDictSet = new HashSet<>(wordDict);
    
    // 计算字典中单词的最大长度
    int maxWordLength = 0;
    for (String word : wordDict) {
        maxWordLength = Math.max(maxWordLength, word.length());
    }
    
    boolean[] dp = new boolean[s.length() + 1];
    dp[0] = true;
    
    for (int i = 1; i <= s.length(); i++) {
        // 优化 1：只检查可能的分割点
        // 计算起始检查位置，避免检查长度超过最大单词长度的子串
        int start = Math.max(0, i - maxWordLength);
        // 优化 2：从后向前检查，优先匹配较短的单词
        // 从 i-1 开始向前检查，一旦找到匹配的单词就可以提前退出循环
        for (int j = i - 1; j >= start; j--) {
            if (dp[j] && wordDictSet.contains(s.substring(j, i))) {
                dp[i] = true;
                break;
            }
        }
    }
    
    return dp[s.length()];
}

/**
 * 单向链表节点定义
 */
class ListNode {
    int val;
    ListNode next;

    ListNode() {

    }

    ListNode(int val) {
        this.val = val;
    }

    ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}

class Solution {
    /**
     * 重新组织链表
     * @param head 链表头节点
     */
    public void reorderList(ListNode head) {
        // 处理空链表或只有一个节点的情况
        if (head == null || head.next == null) {
            return;
        }
        
        // 步骤1: 使用快慢指针找到链表中点
        ListNode slow = head;
        ListNode fast = head.next;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        
        // 步骤2: 分割链表为两部分
        ListNode second = slow.next;
        // 断开链表
        slow.next = null;
        
        // 步骤3: 反转后半部分链表
        second = reverseList(second);
        
        // 步骤4: 合并两个链表
        ListNode first = head;
        while (first != null && second != null) {
            ListNode firstNext = first.next;
            ListNode secondNext = second.next;
            
            // 将后半部分的节点插入到前半部分的节点之间
            first.next = second;
            second.next = firstNext;
            
            // 移动指针到下一位置
            first = firstNext;
            second = secondNext;
        }
    }
    
    /**
     * 反转链表
     * @param head 要反转的链表头节点
     * @return 反转后的链表头节点
     */
    private ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode nextTemp = curr.next;
            curr.next = prev;
            prev = curr;
            curr = nextTemp;
        }
        return prev;
    }
}

public int coinChange(int[] coins, int amount) {
    if (amount <= 0) {
        return 0;
    }
    return coinChange(coins, amount, new int[amount]);
}

private int coinChange(int[] coins, int rem, int[] count) {
    if (rem < 0) {
        return -1;
    }
    if (rem == 0) {
        return 0;
    }
    // 检查是否已经计算过：count[rem - 1] 对应金额 rem 的解
    if (count[rem - 1] != 0) {
        return count[rem - 1];
    }
    int min = Integer.MAX_VALUE;
    for (int coin : coins) {
        // 递归计算子问题
        int res = coinChange(coins, rem - coin, count);
        // 如果子问题有解且更优，更新最小值
        if (res >= 0 && res < min) {
            min = 1 + res;
        }
    }
    // 存储当前金额的解
    count[rem - 1] = (min == Integer.MAX_VALUE) ? -1 : min;
    return count[rem - 1];
}

public int coinChange(int[] coins, int amount) {
    // 创建 dp 数组，dp[i] 表示金额 i 所需的最少硬币数
    int[] dp = new int[amount + 1];
    // 初始化 dp 数组，除 0 外都设为最大值
    Arrays.fill(dp, Integer.MAX_VALUE);
    dp[0] = 0;
    // 遍历每种硬币
    for (int coin : coins) {
        // 对于当前硬币，从 coin 开始到 amount 更新 dp 数组
        for (int j = coin; j <= amount; j++) {
            // 如果 j-coin 有解，则更新 dp[j]
            if (dp[j - coin] != Integer.MAX_VALUE) {
                dp[j] = Math.min(dp[j], dp[j - coin] + 1);
            }
        }
    }
    // 如果 dp[amount] 无解，返回-1
    return dp[amount] == Integer.MAX_VALUE ? -1 : dp[amount];
}

public int numSquares(int n) {
    // 创建动态规划数组，f[i] 表示组成 i 所需的最少完全平方数数量
    int[] f = new int[n + 1];
    // 从 1 到 n 计算每个数字的最少平方数数量
    for (int i = 1; i <= n; i++) {
        int min = Integer.MAX_VALUE; // 初始化最小值
        // 遍历所有可能的完全平方数 j*j，其中 j*j <= i
        for (int j = 1; j * j <= i; j++) {
            // 更新最小值，f[i - j*j] 表示减去一个平方数后的最优解
            min = Math.min(min, f[i - j * j]);
        }
        // 当前 i 的最优解为 min + 1（加上当前平方数）
        f[i] = min + 1;
    }
    return f[n]; // 返回结果
}

public int numSquares(int n) {
    // 如果 n 是完全平方数，直接返回 1
    if (isPerfectSquare(n)) {
        return 1;
    }
    // 如果 n 满足 4^k*(8m+7) 的形式，返回 4
    if (checkAnswer4(n)) {
        return 4;
    }
    // 检查是否可以由两个完全平方数组成
    for (int i = 1; i * i <= n; i++) {
        int j = n - i * i;
        // 如果 j 是完全平方数，返回 2
        if (isPerfectSquare(j)) {
            return 2;
        }
    }
    // 否则返回 3
    return 3;
}

// 判断是否为完全平方数
public boolean isPerfectSquare(int x) {
    int y = (int) Math.sqrt(x);
    return y * y == x;
}

// 判断是否能表示为 4^k*(8m+7)
public boolean checkAnswer4(int x) {
    while (x % 4 == 0) {
        x /= 4;
    }
    return x % 8 == 7;
}

public List<List<Integer>> generate(int numRows) {
    List<List<Integer>> res = new ArrayList<>();
    for (int i = 0; i < numRows; i++) {
        Integer[] row = new Integer[i + 1];
        row[0] = 1; // 每行第一个元素为1
        row[i] = 1; // 每行最后一个元素为1
        for (int j = 1; j < i; j++) {
            // 当前元素等于上一行的前一个元素和当前元素之和
            row[j] = res.get(i - 1).get(j - 1) + res.get(i - 1).get(j);
        }
        res.add(Arrays.asList(row));
    }
    return res;
}

public void combinationSum(int[] nums, int m, int n) {
    if (nums == null || nums.length < m) {
        System.out.println(Arrays.toString(new int[0]));
        return;
    }

    // 对数组进行排序
    Arrays.sort(nums);

    int len = nums.length;
    // 计算前缀和数组，其中 prefixSum[i] 表示前 i 个数字的和
    // [0, -1, 0, 2, 5, 9, 14, 20]
    int[] prefixSum = new int[len + 1];
    for (int i = 0; i < len; i++) {
        prefixSum[i + 1] = prefixSum[i] + nums[i];
    }
    // 计算后缀和数组，其中 suffixSum[k] 表示最后 k 个数字的和
    // [0, 6, 11, 15, 18, 20, 21, 20]
    int[] suffixSum = new int[m + 1];
    for (int k = 1; k <= m; k++) {
        suffixSum[k] = prefixSum[len] - prefixSum[len - k];
    }

    List<List<Integer>> results = new ArrayList<>();
    List<Integer> current = new ArrayList<>();
    backtrack(nums, m, n, 0, current, 0, results, prefixSum, suffixSum);
    // 打印结果
    System.out.println(results);
}

private void backtrack(int[] nums, int m, int n, int start, List<Integer> current, int currentSum,
                       List<List<Integer>> results, int[] prefixSum, int[] suffixSum) {
    // 还需要选择的数字个数
    int r = m - current.size();
    if (r == 0) {
        if (currentSum == n) {
            results.add(new ArrayList<>(current));
        }
        return;
    }
    // 检查剩余数字是否足够
    if (start + r > nums.length) {
        return;
    }
    // 计算从 start 开始 r 个数字的最小和
    int minSumFromStart = prefixSum[start + r] - prefixSum[start];
    // 如果当前和加上剩余元素的最小可能和已超过目标值，直接返回。
    if (currentSum + minSumFromStart > n) {
        return;
    }
    // 如果当前和加上剩余元素的最大可能和仍小于目标值，直接返回。
    if (currentSum + suffixSum[r] < n) {
        return;
    }
    for (int i = start; i < nums.length; i++) {
        // 跳过重复元素，避免重复组合
        if (i > start && nums[i] == nums[i - 1]) {
            continue;
        }

        // 因为数组已排序，如果当前数字加上当前和已经大于n，后面的数字更大，直接跳出循环
        if (currentSum + nums[i] > n) {
            break;
        }

        current.add(nums[i]);
        backtrack(nums, m, n, i + 1, current, currentSum + nums[i], results, prefixSum, suffixSum);
        // 回溯
        current.remove(current.size() - 1);
    }
}

public int jump(int[] nums) {
    // 处理边界情况：数组为空或长度为0
    if (nums == null || nums.length == 0) {
        return 0;
    }
    
    int max = 0;    // 记录当前能够到达的最远位置
    int end = 0;    // 记录当前跳跃能够到达的边界
    int step = 0;   // 记录跳跃次数
    
    // 遍历数组，注意不需要遍历最后一个元素
    for (int i = 0; i < nums.length - 1; i++) {
        // 更新当前能够到达的最远位置
        if (i + nums[i] > max) {
            max = i + nums[i];
        }
        
        // 当遍历到当前边界时，必须进行一次跳跃
        if (i == end) {
            step++;     // 增加跳跃次数
            end = max;  // 更新边界为当前能够到达的最远位置
        }
    }
    
    return step;
}

public boolean canJump(int[] nums) {
    int len = nums.length; // 数组长度
    int max = 0; // 当前能到达的最远位置
    for (int i = 0; i < len; i++) {
        // 如果当前索引i在可达范围内，才更新最远位置
        if (i <= max) {
            // 更新最远可达位置：取当前最远位置和i + nums[i]的较大值
            max = Math.max(max, i + nums[i]);
            // 如果最远可达位置已经超过或等于最后一个位置，则返回true
            if (max >= len - 1) {
                return true;
            }
        }
    }
    return false; // 遍历结束仍未到达最后位置，返回false
}

public int maxProfit(int[] prices) {
    // 如果数组为空或长度为零，直接返回0
    if (prices == null || prices.length == 0) {
        return 0;
    }
    // 初始化最小价格为最大整数，最大利润为0
    int minPrice = Integer.MAX_VALUE;
    int maxProfit = 0;
    // 遍历价格数组
    for (int i = 0; i < prices.length; i++) {
        if (prices[i] < minPrice) {
            // 如果当前价格小于最小价格，更新最小价格
            minPrice = prices[i];
        } else if (prices[i] - minPrice > maxProfit) {
            // 如果当前价格减去最小价格大于最大利润，更新最大利润
            maxProfit = prices[i] - minPrice;
        }
    }
    return maxProfit;
}

public int[] topKFrequent(int[] nums, int k) {
    // 处理边界情况
    if (nums == null || nums.length == 0) {
        return new int[0];
    }

    // 步骤1：统计每个数字的出现次数
    Map<Integer, Integer> numToCountMap = new HashMap<>();
    for (int num : nums) {
        // 使用 merge 方法统计次数，等价于 getOrDefault 和 put
        // numToCountMap.put(num, numToCountMap.getOrDefault(num, 0) + 1);
        numToCountMap.merge(num, 1, Integer::sum);
    }

    // 步骤2：将频率映射到数字列表
    Map<Integer, List<Integer>> countToNumMap = new HashMap<>();
    for (Map.Entry<Integer, Integer> entry : numToCountMap.entrySet()) {
        int num = entry.getKey();
        int count = entry.getValue();
        // 如果该频率还没有列表，创建一个新列表
        if (!countToNumMap.containsKey(count)) {
            countToNumMap.put(count, new ArrayList<>());
        }
        // 将数字添加到对应频率的列表中
        countToNumMap.get(count).add(num);
    }

    // 步骤3：从最高频率开始收集数字
    List<Integer> res = new ArrayList<>();
    // 频率最大可能为数组长度，从高到低遍历
    for (int i = nums.length; i >= 0; i--) {
        if (countToNumMap.containsKey(i)) {
            List<Integer> numList = countToNumMap.get(i);
            for (Integer num : numList) {
                res.add(num);
                // 如果已收集到 k 个数字，转换为数组返回
                if (res.size() == k) {
                    return res.stream().mapToInt(Integer::intValue).toArray();
                }
            }
        }
    }

    return new int[0];
}

public int[] topKFrequent(int[] nums, int k) {
    // 处理边界情况
    if (nums == null || nums.length == 0) {
        return new int[0];
    }

    // 步骤1：统计每个数字的出现次数
    Map<Integer, Integer> numToCountMap = new HashMap<>();
    for (int num : nums) {
        // 使用 merge 方法统计次数，等价于 getOrDefault 和 put
        // numToCountMap.put(num, numToCountMap.getOrDefault(num, 0) + 1);
        // 1->3, 2->2, 3->1
        numToCountMap.merge(num, 1, Integer::sum);
    }

    // 步骤2：创建桶数组，索引代表频率
    int maxCnt = Collections.max(numToCountMap.values()); // 获取最大频率
    List<Integer>[] buckets = new ArrayList[maxCnt + 1];  // 桶数组，从 0 到 maxCnt
    Arrays.setAll(buckets, i -> new ArrayList<>());       // 初始化每个桶为空列表
    for (Map.Entry<Integer, Integer> entry : numToCountMap.entrySet()) {
        // 将数字添加到对应频率的桶中
        // 1->[3], 2->[2], 3->[1]
        buckets[entry.getValue()].add(entry.getKey());
    }

    // 步骤3：从最高频率桶开始收集数字
    int[] res = new int[k];
    for (int i = buckets.length - 1; i >= 0; i--) {
        for (Integer num : buckets[i]) {
            res[--k] = num;
            if (k == 0) {
                return res;
            }
        }
    }

    return new int[0];
}

import java.util.Arrays;

public int findKthLargest(int[] nums, int k) {
    if (nums == null || nums.length == 0) {
        return 0;
    }
    Arrays.sort(nums);            // 升序排序
    return nums[nums.length - k]; // 返回倒数第k个元素
}

import java.util.*;

public int findKthLargest(int[] nums, int k) {
    List<Integer> numList = new ArrayList<>();
    for (int num : nums) {
        numList.add(num);
    }
    return quickSelect(numList, k);
}

private int quickSelect(List<Integer> nums, int k) {
    // 随机选择基准值
    Random rand = new Random();
    int pivot = nums.get(rand.nextInt(nums.size()));
    
    // 划分大于、小于基准值的元素
    List<Integer> big = new ArrayList<>();
    List<Integer> small = new ArrayList<>();
    for (int num : nums) {
        if (num > pivot) {
            big.add(num);
        } else if (num < pivot) {
            small.add(num();
        }
    }
    
    if (k <= big.size()) {
        // 在 big 中递归查找
        return quickSelect(big, k);
    } else if (nums.size() - small.size() < k) {
        // 调整 k 值后在 small 中查找
        return quickSelect(small, k - (nums.size() - small.size()));
    }
    // pivot 是第 k 大元素
    return pivot;
}

import java.util.Random;

public int findKthLargest(int[] nums, int k) {
    int n = nums.length;
    int target = n - k; // 升序排序后第 target 个元素是第 k 大
    return quickSelect(nums, 0, n - 1, target);
}

private int quickSelect(int[] nums, int left, int right, int target) {
    // 递归终止
    if (left == right) {
        return nums[left];
    }
    
    // 随机选择基准值并交换到末尾
    Random rand = new Random();
    int pivotIdx = left + rand.nextInt(right - left + 1);
    swap(nums, pivotIdx, right);
    int pivot = nums[right];
    
    // 分区操作
    int i = left; // i 左侧元素均 < pivot
    for (int j = left; j < right; j++) {
        if (nums[j] < pivot) {
            swap(nums, i, j);
            i++;
        }
    }
    swap(nums, i, right); // 将基准值放到正确位置
    
    if (i == target) {
        return nums[i]; // 找到目标
    } else if (i < target) {
        return quickSelect(nums, i + 1, right, target); // 递归右子数组
    } else {
        return quickSelect(nums, left, i - 1, target); // 递归左子数组
    }
}

private void swap(int[] nums, int i, int j) {
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}

// 全局指针
private int i = 0;

public String decodeString(String s) {
    i = 0; // 重置指针（避免多次调用干扰）
    return decode(s.toCharArray());
}

private String decode(char[] s) {
    StringBuilder res = new StringBuilder();
    int k = 0; // 当前重复次数
    
    while (i < s.length) {
        char c = s[i];
        i++;
        if (Character.isLetter(c)) {
            res.append(c); // 字母直接拼接
        } else if (Character.isDigit(c)) {
            k = k * 10 + (c - '0'); // 计算重复次数（处理多位数）
        } else if (c == '[') {
            String sub = decode(s); // 递归解析子字符串
            for (int j = 0; j < k; j++) {
                res.append(sub); // 重复拼接子字符串
            }
            k = 0; // 重置重复次数
        } else if (c == ']') {
            break; // 结束当前递归层
        }
    }
    return res.toString();
}

import java.util.LinkedList;

class MinStack {
    // 注意不要使用 Stack 类，因为它继承自 Vector，是同步的，会导致一些性能问题
    private LinkedList<Integer> stack;    // 主栈
    private LinkedList<Integer> minStack; // 最小栈

    public MinStack() {
        stack = new LinkedList<>();
        minStack = new LinkedList<>();
    }
    
    public void push(int val) {
        stack.push(val);
        // 如果最小栈为空，或者新元素小于等于最小栈栈顶元素，则推入最小栈
        if (minStack.isEmpty() || val <= minStack.peek()) {
            minStack.push(val);
        }
    }
    
    public void pop() {
        int popVal = stack.pop();
        // 如果弹出的元素等于最小栈栈顶元素，则同时弹出最小栈栈顶元素
        if (popVal == minStack.peek()) {
            minStack.pop();
        }
    }
    
    public int top() {
        return stack.peek();
    }
    
    public int getMin() {
        return minStack.peek();
    }
}

public int[] searchRange(int[] nums, int target) {
    // 处理空数组的情况
    if (nums == null || nums.length == 0) {
        return new int[]{-1, -1};
    }
    int left = 0;
    int right = nums.length - 1;
    while (left <= right) {
        // 计算中间位置，防止整数溢出
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) {
            // 找到目标值，继续向两边搜索边界
            int start = mid, end = mid;
            // 向左搜索起始位置
            while (start > left && nums[start - 1] == target) {
                start--;
            }
            // 向右搜索结束位置
            while (end < right && nums[end + 1] == target) {
                end++;
            }
            return new int[] {start, end};
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return new int[] {-1, -1};
}

class Solution {
    public int[] searchRange(int[] nums, int target) {
        // 处理空数组的情况
        if (nums == null || nums.length == 0) {
            return new int[]{-1, -1};
        }
        
        int leftBound = findLeftBound(nums, target);
        int rightBound = findRightBound(nums, target);
        return new int[]{leftBound, rightBound};
    }
    
    // 查找左边界：第一个等于 target 的位置
    private int findLeftBound(int[] nums, int target) {
        int left = 0, right = nums.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] >= target) {
                right = mid - 1; // 向左搜索
            } else {
                left = mid + 1;
            }
        }
        // 检查 left 是否在数组范围内且等于 target
        if (left < nums.length && nums[left] == target) {
            return left;
        }
        return -1;
    }
    
    // 查找右边界：最后一个等于 target 的位置
    private int findRightBound(int[] nums, int target) {
        int left = 0, right = nums.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] <= target) {
                left = mid + 1; // 向右搜索
            } else {
                right = mid - 1;
            }
        }
        // 检查 right 是否在数组范围内且等于 target
        if (right >= 0 && nums[right] == target) {
            return right;
        }
        return -1;
    }
}

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
    Stack<Integer> stack1 = new Stack<>();
    Stack<Integer> stack2 = new Stack<>();
    
    // 将链表节点值压入栈中
    while (l1 != null) {
        stack1.push(l1.val);
        l1 = l1.next;
    }
    while (l2 != null) {
        stack2.push(l2.val);
        l2 = l2.next;
    }
    
    int carry = 0; // 进位值
    ListNode resultHead = null; // 结果链表头节点
    
    // 当栈非空或仍有进位时继续计算
    while (!stack1.isEmpty() || !stack2.isEmpty() || carry != 0) {
        // 获取栈顶元素（栈空则取0）
        int num1 = stack1.isEmpty() ? 0 : stack1.pop();
        int num2 = stack2.isEmpty() ? 0 : stack2.pop();
        
        // 计算当前位的和
        int sum = num1 + num2 + carry;
        carry = sum / 10; // 更新进位
        int digit = sum % 10; // 当前位的值
        
        // 使用头插法构建结果链表
        ListNode newNode = new ListNode(digit);
        newNode.next = resultHead;
        resultHead = newNode;
    }
    
    return resultHead;
}

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
    // 反转两个链表
    l1 = reverseList(l1);
    l2 = reverseList(l2);
    // 相加得到结果链表（低位在前）
    ListNode l3 = addTwo(l1, l2);
    // 反转结果链表得到高位在前
    return reverseList(l3);
}

// 反转链表（LeetCode 206）
private ListNode reverseList(ListNode head) {
    ListNode cur = head, pre = null;
    while (cur != null) {
        ListNode tmp = cur.next; // 保存下一个节点
        cur.next = pre;          // 当前节点指向前一个节点
        pre = cur;               // 前节点后移
        cur = tmp;               // 当前节点后移
    }
    return pre; // 返回反转后的头节点
}

// 两数相加（LeetCode 2）
private ListNode addTwo(ListNode l1, ListNode l2) {
    ListNode dummy = new ListNode(0); // 虚拟头节点
    ListNode cur = dummy;
    int carry = 0; // 进位值
    
    while (l1 != null || l2 != null) {
        int x = (l1 != null) ? l1.val : 0;
        int y = (l2 != null) ? l2.val : 0;
        int sum = x + y + carry;
        
        carry = sum / 10; // 计算进位
        cur.next = new ListNode(sum % 10); // 创建新节点
        cur = cur.next; // 移动当前指针
        
        // 移动链表指针
        if (l1 != null) l1 = l1.next;
        if (l2 != null) l2 = l2.next;
    }
    
    // 处理最后的进位
    if (carry > 0) {
        cur.next = new ListNode(carry);
    }
    return dummy.next;
}

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode cur = head;
        ListNode pre = null;
        while (cur != null) {
            ListNode tmp = cur.next; // 暂存后继节点
            cur.next = pre;          // 反转当前节点的指针
            pre = cur;               // pre 移动至当前节点
            cur = tmp;               // cur 访问下一节点
        }
        return pre; // 返回新头节点
    }
}

class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) {
            return head; // 终止条件：返回尾节点作为新头节点
        }
        ListNode newHead = reverseList(head.next); // 递归至下一层
        head.next.next = head; // 反转指向：下一节点指向当前节点
        head.next = null;      // 断开当前节点原指向
        return newHead;        // 始终返回新头节点
    }
}

public static List<List<Integer>> permute(int[] nums) {
    List<List<Integer>> ans = new ArrayList<>();
    List<Integer> t = new ArrayList<>();
    boolean[] vis = new boolean[nums.length];
    dfs(nums, ans, t, vis);
    return ans;
}

public static void dfs(int[] nums, List<List<Integer>> ans, List<Integer> t, boolean[] vis) {
    // 当路径长度等于数组长度时，将当前路径加入结果集
    if (t.size() == nums.length) {
        // 注意创建新列表
        ans.add(new ArrayList<>(t));
        return;
    }

    // 遍历所有元素
    for (int i = 0; i < nums.length; i++) {
        // 如果元素未被使用
        if (!vis[i]) {
            // 做出选择
            t.add(nums[i]);
            vis[i] = true;

            // 递归进入下一层
            dfs(nums, ans, t, vis);

            // 撤销选择（回溯）
            t.removeLast();
            vis[i] = false;
        }
    }
}

public void flatten(TreeNode root) {
    if (root == null) return;
    
    // 递归展开左右子树
    flatten(root.left);
    flatten(root.right);
    
    TreeNode left = root.left;   // 保存左子树
    TreeNode right = root.right; // 保存右子树
    
    root.left = null;            // 切断左指针
    root.right = left;           // 左子树变为右子树
    
    // 遍历至新链表末端
    TreeNode cur = root;
    while (cur.right != null) {
        cur = cur.right;
    }
    cur.right = right;          // 连接原右子树
}