// 121. 买卖股票的最佳时机 (只允许一次交易)
var maxProfit = function(prices) {
    let profit = 0;
    
    // 方法：我们假设第 0 天买入，然后找之后价格更高的卖出
    // 实际操作：维护一个 minPrice 成本线
    let minPrice = prices[0];
    
    for (let i = 1; i < prices.length; i++) { // 从第 1 天开始看
        if (prices[i] > minPrice) {
            // 如果今天比成本线高，尝试卖出，看是不是能赚更多
            profit = Math.max(profit, prices[i] - minPrice);
        } else {
            // 如果今天比成本线还低，那不如今天买入（更新成本线）
            minPrice = prices[i];
        }
    }
    return profit;
};

// 122. 买卖股票的最佳时机 II (允许无限次交易)
var maxProfitII = function(prices) {
    let profit = 0;
    
    // 方法：我们只看从昨天到今天这一段，能不能赚钱
    // 实际操作：比较今天和昨天的价格
    
    for (let i = 1; i < prices.length; i++) { // 从第 1 天开始看
        if (prices[i] > prices[i - 1]) {
            // 如果今天比昨天高，就赚这个差价（收集上坡）
            profit += prices[i] - prices[i - 1];
        }
        // 如果比昨天低，就不动（不把亏损算进去），也无需更新 minPrice，因为我们可以每天都操作
    }
    return profit;
};

// 54. 螺旋矩阵 (四边界收缩法)
var spiralOrder = function(matrix) {
    if (!matrix.length) return [];
    
    // 1. 定义四个边界
    let top = 0, bottom = matrix.length - 1;
    let left = 0, right = matrix[0].length - 1;
    const res = [];
    
    // 2. 循环直到边界交错
    while (true) {
        // 向右移动 (top行)
        for (let i = left; i <= right; i++) res.push(matrix[top][i]);
        if (++top > bottom) break; // 上边界下移，检查是否越界

        // 向下移动 (right列)
        for (let i = top; i <= bottom; i++) res.push(matrix[i][right]);
        if (--right < left) break; // 右边界左移

        // 向左移动 (bottom行)
        for (let i = right; i >= left; i--) res.push(matrix[bottom][i]);
        if (--bottom < top) break; // 下边界上移

        // 向上移动 (left列)
        for (let i = bottom; i >= top; i--) res.push(matrix[i][left]);
        if (++left > right) break; // 左边界右移
    }
    
    return res;
};

// 48. 旋转图像 (数学变换法)
// 顺时针转90度 = 先水平上下翻转 + 再对角线翻转 (写法很多，这种最好记)
// 或者：先对角线转置 + 再左右翻转
var rotate = function(matrix) {
    const n = matrix.length;
    
    // 1. 先水平上下翻转 (Top <-> Bottom)
    // 1 2 3      7 8 9
    // 4 5 6  =>  4 5 6
    // 7 8 9      1 2 3
    let top = 0, bottom = n - 1;
    while (top < bottom) {
        [matrix[top], matrix[bottom]] = [matrix[bottom], matrix[top]];
        top++;
        bottom--;
    }
    
    // 2. 再对角线翻转 (Swap matrix[i][j] with matrix[j][i])
    // 7 8 9      7 4 1
    // 4 5 6  =>  8 5 2
    // 1 2 3      9 6 3
    for (let i = 0; i < n; i++) {
        for (let j = i + 1; j < n; j++) { // 注意 j 从 i+1 开始，只遍历上三角
            [matrix[i][j], matrix[j][i]] = [matrix[j][i], matrix[i][j]];
        }
    }
};

// 31. 下一个排列 (三步走)
var nextPermutation = function(nums) {
    let i = nums.length - 2;
    // 1. 从后向前找第一个【升序对】 (i, i+1)，即 nums[i] < nums[i+1]
    //    此时 [i+1, end] 肯定是降序的
    while (i >= 0 && nums[i] >= nums[i + 1]) {
        i--;
    }
    
    if (i >= 0) {
        // 2. 从后向前找第一个比 nums[i] 大的数 nums[j]
        let j = nums.length - 1;
        while (j >= 0 && nums[j] <= nums[i]) {
            j--;
        }
        // 交换它们，让大一点点的数排到前面
        [nums[i], nums[j]] = [nums[j], nums[i]];
    }
    
    // 3. 将 [i+1, end] 这部分降序的数组反转成升序，使其变小
    let left = i + 1;
    let right = nums.length - 1;
    while (left < right) {
        [nums[left], nums[right]] = [nums[right], nums[left]];
        left++;
        right--;
    }
};

// 70. 爬楼梯
var climbStairs = function(n) {
    if (n <= 1) return 1;
    const dp = new Array(n + 1).fill(0); // 状态：dp[i] 到第i阶的方法数
    dp[0] = 1; dp[1] = 1;               // 初始化
    for (let i = 2; i <= n; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];   // 方程：前两阶方法数之和
    }
    return dp[n];                        // 答案
};

// 53. 最大子数组和
var maxSubArray = function(nums) {
    const n = nums.length;
    const dp = new Array(n).fill(0);     // 状态：以i结尾的最大子数组和
    dp[0] = nums[0];                     // 初始化
    for (let i = 1; i < n; i++) {
        // 方程：要么接在前面后面，要么自立门户
        dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);
    }
    return Math.max(...dp);              // 答案：所有结尾情况中的最大值
};

// 300. 最长上升子序列
var lengthOfLIS = function(nums) {
    const n = nums.length;
    if (n === 0) return 0;
    const dp = new Array(n).fill(1);     // 状态：以i结尾的LIS长度，初始化为1
    for (let i = 1; i < n; i++) {
        for (let j = 0; j < i; j++) {
            // 方程：如果 nums[i] 比前面的大，尝试接在后面
            if (nums[j] < nums[i]) dp[i] = Math.max(dp[i], dp[j] + 1);
        }
    }
    return Math.max(...dp);              // 答案
};

// 139. 单词拆分
var wordBreak = function(s, wordDict) {
    const n = s.length;
    const wordSet = new Set(wordDict);
    const dp = new Array(n + 1).fill(false); // 状态：前i个字符能否拆分
    dp[0] = true;                            // 初始化：空字符串为true
    for (let i = 1; i <= n; i++) {
        for (let j = 0; j < i; j++) {
            // 方程：如果前j个能拆分，且剩余部分在字典中
            if (dp[j] && wordSet.has(s.substring(j, i))) {
                dp[i] = true;
                break;
            }
        }
    }
    return dp[n];                            // 答案
};

// 322. 零钱兑换
var coinChange = function(coins, amount) {
    const dp = new Array(amount + 1).fill(Infinity); // 状态：凑成金额i的最少硬币数
    dp[0] = 0;                                       // 初始化
    for (let i = 1; i <= amount; i++) {
        for (const coin of coins) {
            if (i >= coin) {
                // 方程：取当前硬币，则需凑齐 i-coin 的金额
                dp[i] = Math.min(dp[i], dp[i - coin] + 1);
            }
        }
    }
    return dp[amount] === Infinity ? -1 : dp[amount]; // 答案
};

// 1143. 最长公共子序列
var longestCommonSubsequence = function(text1, text2) {
    const m = text1.length, n = text2.length;
    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0)); // 状态：t1前i和t2前j的LCS
    for (let i = 1; i <= m; i++) {
        for (let j = 1; j <= n; j++) {
            if (text1[i - 1] === text2[j - 1]) {
                dp[i][j] = dp[i - 1][j - 1] + 1; // 方程：字符相等，长度+1
            } else {
                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]); // 方程：不等，取左或上的最大值
            }
        }
    }
    return dp[m][n]; // 答案
};

// 72. 编辑距离
var minDistance = function(word1, word2) {
    const m = word1.length, n = word2.length;
    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0)); // 状态：w1前i转为w2前j的最小步数
    for (let i = 0; i <= m; i++) dp[i][0] = i; // 初始化：w1变为空需删除i次
    for (let j = 0; j <= n; j++) dp[0][j] = j; // 初始化：空变w2需插入j次
    for (let i = 1; i <= m; i++) {
        for (let j = 1; j <= n; j++) {
            if (word1[i - 1] === word2[j - 1]) {
                dp[i][j] = dp[i - 1][j - 1]; // 方程：相等，无需操作
            } else {
                // 方程：不等，取 替换、删除、插入 三者最小值 + 1
                dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + 1;
            }
        }
    }
    return dp[m][n]; // 答案
};

// 64. 最小路径和
var minPathSum = function(grid) {
    const m = grid.length, n = grid[0].length;
    const dp = Array.from({ length: m }, () => new Array(n).fill(0)); // 状态：到(i,j)的最小路径和
    dp[0][0] = grid[0][0];                                            // 初始化起点
    for (let i = 1; i < m; i++) dp[i][0] = dp[i - 1][0] + grid[i][0]; // 初始化第一列
    for (let j = 1; j < n; j++) dp[0][j] = dp[0][j - 1] + grid[0][j]; // 初始化第一行
    for (let i = 1; i < m; i++) {
        for (let j = 1; j < n; j++) {
            // 方程：只能从左边或上边过来
            dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
        }
    }
    return dp[m - 1][n - 1]; // 答案
};

// 221. 最大正方形
var maximalSquare = function(matrix) {
    if (!matrix.length) return 0;
    const m = matrix.length, n = matrix[0].length;
    const dp = Array.from({ length: m }, () => new Array(n).fill(0)); // 状态：以(i,j)为右下角的最大正方形边长
    let maxSide = 0;
    for (let i = 0; i < m; i++) {
        for (let j = 0; j < n; j++) {
            if (matrix[i][j] === '1') {
                if (i === 0 || j === 0) dp[i][j] = 1; // 边界初始化
                else {
                    // 方程：受限于左、上、左上三个方向的最小值
                    dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + 1;
                }
                maxSide = Math.max(maxSide, dp[i][j]);
            }
        }
    }
    return maxSide * maxSide; // 答案：面积 = 边长平方
};

// 5. 最长回文子串
var longestPalindrome = function(s) {
    const n = s.length;
    if (n < 2) return s;
    const dp = Array.from({ length: n }, () => new Array(n).fill(false)); // 状态：s[i..j]是否为回文
    for (let i = 0; i < n; i++) dp[i][i] = true;                          // 初始化：单个字符必回文
    let start = 0, maxLen = 1;
    for (let len = 2; len <= n; len++) {       // 枚举长度
        for (let i = 0; i <= n - len; i++) {   // 枚举左端点
            let j = i + len - 1;               // 计算右端点
            if (s[i] === s[j]) {
                // 方程：首尾相等且内部是回文（或内部为空/单字符）
                if (len <= 3) dp[i][j] = true;
                else dp[i][j] = dp[i + 1][j - 1];
            }
            if (dp[i][j] && len > maxLen) {
                maxLen = len;
                start = i;
            }
        }
    }
    return s.substring(start, start + maxLen); // 答案
};

// 46. 全排列
var permute = function(nums) {
    const res = [];
    const used = new Array(nums.length).fill(false);
    const backtrack = (path) => {
        if (path.length === nums.length) {
            res.push([...path]); // 满足结束条件
            return;
        }
        for (let i = 0; i < nums.length; i++) {
            if (used[i]) continue; // 剪枝：已使用的元素跳过
            used[i] = true;
            path.push(nums[i]);    // 做选择
            backtrack(path);       // 递归
            path.pop();            // 撤销选择
            used[i] = false;
        }
    };
    backtrack([]);
    return res;
};

// 78. 子集
var subsets = function(nums) {
    const res = [];
    const backtrack = (path, start) => {
        res.push([...path]); // 每个节点都是一个子集
        for (let i = start; i < nums.length; i++) {
            path.push(nums[i]);    // 做选择
            backtrack(path, i + 1); // 递归：传入 i+1 保证不重复选
            path.pop();            // 撤销选择
        }
    };
    backtrack([], 0);
    return res;
};

// 39. 组合总和
var combinationSum = function(candidates, target) {
    const res = [];
    const backtrack = (path, start, sum) => {
        if (sum === target) {
            res.push([...path]); // 满足结束条件
            return;
        }
        if (sum > target) return; // 剪枝
        for (let i = start; i < candidates.length; i++) {
            path.push(candidates[i]);
            // 递归：传入 i 而不是 i+1，表示元素可以重复选取
            backtrack(path, i, sum + candidates[i]);
            path.pop();
        }
    };
    backtrack([], 0, 0);
    return res;
};

// 93. 复原 IP 地址
var restoreIpAddresses = function(s) {
    const res = [];
    const backtrack = (path, start) => {
        if (path.length === 4) {
            if (start === s.length) res.push(path.join('.'));
            return;
        }
        for (let len = 1; len <= 3; len++) {
            if (start + len > s.length) break;
            const segment = s.substring(start, start + len);
            // 剪枝：不能有前导零，且值不能大于 255
            if (len > 1 && segment[0] === '0') break;
            if (len === 3 && parseInt(segment) > 255) break;
            
            path.push(segment);
            backtrack(path, start + len);
            path.pop();
        }
    };
    backtrack([], 0);
    return res;
};

// 22. 括号生成
var generateParenthesis = function(n) {
    const res = [];
    const backtrack = (path, left, right) => {
        if (path.length === 2 * n) {
            res.push(path);
            return;
        }
        // 剪枝：左括号随时加（只要不满n），右括号必须少于左括号时加
        if (left < n) backtrack(path + '(', left + 1, right);
        if (right < left) backtrack(path + ')', left, right + 1);
    };
    backtrack('', 0, 0);
    return res;
};

// 79. 单词搜索
var exist = function(board, word) {
    const m = board.length, n = board[0].length;
    const backtrack = (i, j, k) => {
        if (k === word.length) return true; // 找到单词
        if (i < 0 || i >= m || j < 0 || j >= n || board[i][j] !== word[k]) return false;
        
        const temp = board[i][j];
        board[i][j] = '#'; // 标记已访问，防止回头
        const found = backtrack(i + 1, j, k + 1) || 
                      backtrack(i - 1, j, k + 1) || 
                      backtrack(i, j + 1, k + 1) || 
                      backtrack(i, j - 1, k + 1);
        board[i][j] = temp; // 回溯：恢复网格状态
        return found;
    };
    for (let i = 0; i < m; i++) {
        for (let j = 0; j < n; j++) {
            if (backtrack(i, j, 0)) return true;
        }
    }
    return false;
};

// 200. 岛屿数量 (套用 DFS 模板)
var numIslands = function(grid) {
    if (!grid || grid.length === 0) return 0;
    const m = grid.length, n = grid[0].length;
    let count = 0;
    
    const dfs = (i, j) => {
        // 边界检查 & 检查是否为陆地
        if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] === '0') return;
        
        grid[i][j] = '0'; // 沉没当前陆地
        
        // 四方向遍历
        dfs(i + 1, j);
        dfs(i - 1, j);
        dfs(i, j + 1);
        dfs(i, j - 1);
    };
    
    for (let i = 0; i < m; i++) {
        for (let j = 0; j < n; j++) {
            if (grid[i][j] === '1') {
                count++;      // 发现新岛屿
                dfs(i, j);    // 启动 DFS 将该岛屿彻底沉没
            }
        }
    }
    return count;
};

// 695. 岛屿的最大面积 (套用 DFS 模板 - 带返回值)
var maxAreaOfIsland = function(grid) {
    const m = grid.length, n = grid[0].length;
    let maxArea = 0;
    
    const dfs = (i, j) => {
        // 边界检查 & 检查是否为陆地
        if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] !== 1) return 0;
        
        grid[i][j] = 0; // 标记已访问 (修改为0)
        
        // 当前面积(1) + 四周的面积
        return 1 + dfs(i + 1, j) + dfs(i - 1, j) + dfs(i, j + 1) + dfs(i, j - 1);
    };
    
    for (let i = 0; i < m; i++) {
        for (let j = 0; j < n; j++) {
            if (grid[i][j] === 1) {
                // 更新最大面积
                maxArea = Math.max(maxArea, dfs(i, j));
            }
        }
    }
    return maxArea;
};

// 240. 搜索二维矩阵 II (类二分查找 / 聪明双指针)
// 虽然放在搜索章节，但这题用双指针更优：从右上角出发
var searchMatrix = function(matrix, target) {
    if (!matrix.length) return false;
    const m = matrix.length, n = matrix[0].length;
    
    // 从右上角开始 (row = 0, col = n - 1)
    let row = 0, col = n - 1;
    
    while (row < m && col >= 0) {
        const curr = matrix[row][col];
        if (curr === target) {
            return true;
        } else if (curr > target) {
            col--; // 当前值太大，往左移变小
        } else {
            row++; // 当前值太小，往下移变大
        }
    }
    return false;
};