240423 leetcode exercises

@jarringslee

33. 搜索旋转排序数组

[nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]

取左右边界 --> 根据左右边界取中间值mid --> 将mid和给定值比较 --> 更新边界，再取mid进行比较

🔁先找旋转点 再分段二分

1. 找最小值下标（旋转点）

我们可以对 nums 做一次二分，找到“从末尾看，第一个比末尾大的元素位置”——也就是旋转前的最后一个元素位置，再加 1 就是最小值下标。

• 循环不变量
  • nums[left] ≥ nums[n-1]（left 在第一段或 等于n-1）
  • nums[right] < nums[n-1]（right 在最小值及其右侧）

2. 在对应区间做二分查找

再写一个常规的 lowerBound 函数，在开区间里寻找第一个 ≥ target 的位置，最后判断是否等于 target。

// 在开区间 (-1, n-1) 中找最小值的位置
int findMin(int* nums, int numsSize) {
    int left = -1, right = numsSize - 1;
    while (left + 1 < right) {
        int mid = left + (right - left) / 2;
        // 若 nums[mid] < nums[n-1]，说明 mid 在右半段（最小值左侧）
        if (nums[mid] < nums[numsSize - 1]) {
            right = mid;
        } else {
            left = mid;
        }
    }
    return right; // 最小值下标
}
     // 在 nums[left+1..right-1]（开区间）里找 target
int lowerBound(int* nums, int left, int right, int target) {
    while (left + 1 < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] >= target) {
            right = mid;
        } else {
            left = mid;
        }
    }
    return (nums[right] == target) ? right : -1;
}

int search(int* nums, int numsSize, int target) {
    int rot = findMin(nums, numsSize);
    // 如果 target 比末尾元素大，则落在第一段 [0..rot-1]
    if (target > nums[numsSize - 1]) {
        return lowerBound(nums, -1, rot, target);
    }
    // 否则落在第二段 [rot..n-1]
    return lowerBound(nums, rot - 1, numsSize, target);
}

时间复杂度

• findMin 做一次二分 → O(log n)
• lowerBound 最坏再做一次二分 → O(log n)
• 总体 O(log n)

空间复杂度 O(1)

🔁利用布尔变量进行一次二分

一次遍历式二分，在每次判断 mid 所在的那段是否有序，并结合 target 落在哪一段来决定向左收窄还是向右收窄。

• 每次二分都先看 nums[left] ≤ nums[mid]：若成立，说明左边是连续递增的；否则右边是连续递增的。
• 再判断 target 是否落在有序那段范围内，决定下一步收缩哪一半。

1. 初始化

​ 我们需要维护区间 [left, right]，在它之内如果有解，我们始终不把它丢掉。循环条件是 left <= right，保证当区间为空时退出。

2. 进入循环体

​ 用二分查找的思路迭代，不断更新mid值并和目标值进行检查。如果 nums[left] <= nums[mid]，说明 左半段 是升序；否则右半段 就是升序，最后根据 target 落点，收缩哪一半：

​ 若左半段有序，即 nums[left] ≤ target < nums[mid]，说明 target 在这段，就把 right = mid - 1；否则去右半段，left = mid + 1。反之，右半段有序，上述操作相反。

int search(int* nums, int numsSize, int target) {
    int left = 0, right = numsSize - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        
        // 判断左半段 [left..mid] 是否有序
        if (nums[left] <= nums[mid]) {
            // target 在这有序段内则缩右边界，否则去右段
            if (nums[left] <= target && target < nums[mid]) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        // 否则右半段 [mid..right] 必有序
        else {
            if (nums[mid] < target && target <= nums[right]) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
    }
    return -1;
}

时间复杂度 O(log n)，每次都能砍掉一半区间
空间复杂度 O(1)

LCR 009. 乘积小于 K 的子数组

int fornum(int* num, int a, int b, int k){
    int n = 1;
    while (a <= b){
        n *= num[a++];
        if(n >= k) return -1;
    }
    return 1;
}//写一个判断目标区间内所有元素之积是否小于目标值的小函数

int numSubarrayProductLessThanK(int* nums, int numsSize, int k){
        if (k == 0) return 0;
        
        int cjx = 0;
        for (int i = 0; i <= numsSize - 1; i++){
            if (nums[i] < k) cjx++;
        }
        for (int i = 0; i < numsSize - 1; i++ ){
            int j = numsSize - 1;
            while(j >= i){
                if (fornum(nums, i, j, k) == 1){
                    cjx += (j - i);
                    break;
                }
                j--;
            }
        }
        return cjx;
} 

🔁前缀对数 + 二分查找

这个利用对数值二分法竟然是官方第一题解。现在对程序员数学要求都这么高吗。

• 直接比较 子数组乘积 容易爆栈/溢出，也无法快速定位；

• 利用对数性质，将乘积转为加法,预先计算 对数前缀和;

• 对于每个右端点 r（对应代码中的 j+1），希望找到最小的 l

  这正好是一个 后缀区间里第一个大于某个值的下标 问题，可用二分解决。

int numSubarrayProductLessThanK(int* nums, int numsSize, int k){
    if (k <= 1) 
        return 0;                              // k<=1 时，任何正数乘积都 ≥1，不可能 < k

    // 1) 构造对数前缀和
    double *logPrefix = malloc(sizeof(double) * (numsSize + 1));
    logPrefix[0] = 0;
    for (int i = 0; i < numsSize; i++) {
        logPrefix[i + 1] = logPrefix[i] + log(nums[i]);
    }
    double target = log(k);

    int count = 0;
    // 2) 对每个右端点 j，二分在 logPrefix[0..j] 中找第一个 > (logPrefix[j+1] - log k)
    for (int j = 0; j < numsSize; j++) {
        double need = logPrefix[j + 1] - target + 1e-12; 
        int l = 0, r = j + 1, idx = j + 1;
        while (l <= r) {
            int mid = (l + r) / 2;
            if (logPrefix[mid] > need) {
                idx = mid;
                r = mid - 1;
            } else {
                l = mid + 1;
            }
        }
        // [idx..j] 开始的每个子数组都满足乘积<k
        count += (j + 1 - idx);
    }
    free(logPrefix);
    return count;
}

复杂度分析

• 时间：
  • 构造前缀和 O(n)；
  • 对每个 j 做一次二分 O(log n)，共 O(n log n)。
• 空间：O(n)（存放 logPrefix）。

数学好的话看了一遍答案大概就能理清这个取对数的思路了，但是相信大家在实战中也很难打出来，那么这时候有人就要问了，主播主播取对数的高数方法还是太吃操作了，有没有简单又强势的不吃数学基础低复杂度方法？

有的兄弟有的。

🔁双指针（滑动窗口）

• 用一个可变区间 [i..j]，维护区间内的乘积 prod；

• 当 prod < k 时，所有以 j 为右端点且左端点位于 i…j 的子数组都符合条件，数量为 j - i + 1；

• 如果 prod ≥ k，则不断 右移左指针 i，并在 prod 上除去 nums[i]，直至 prod < k 或 i > j。

  其实就是暴力解法的变种，增加了一些限制条件，可以省去很多不必要的步骤，提高效率。

int numSubarrayProductLessThanK(int* nums, int numsSize, int k){
    if (k <= 1) return 0;  // 同样，k<=1 时无解

    int count = 0;
    long prod = 1;
    int i = 0;
    for (int j = 0; j < numsSize; j++) {
        prod *= nums[j];
        // 当乘积不满足时，收缩左指针
        while (i <= j && prod >= k) {
            prod /= nums[i];
            i++;
        }
        // 现在 [i..j] 内任意左端点都能满足 prod<k
        count += (j - i + 1);
    }
    return count;
}

复杂度分析

• 时间：
  • 每个 j 只进一次窗、每个 i 最多出一次窗，整体 O(n)。
• 空间：O(1)。

要么把所有数字都取对数，变成前缀和然后对每个右端点二分，复杂度大概是 n·log n；要么更直接就是滑动窗口，维护一个乘积，只要它大于等于 k 就把左指针右移、除掉旧元素，保证窗口内乘积始终小于 k，这样每个数字只进出窗口一次，O(n) 秒解。