编程题刷题

最新推荐文章于 2023-05-05 17:52:45 发布

喵小苡♡

最新推荐文章于 2023-05-05 17:52:45 发布

阅读量420

点赞数

分类专栏：数据结构与算法

本文链接：https://blog.youkuaiyun.com/Roy_Paris/article/details/105510186

版权

数据结构与算法专栏收录该内容

3 篇文章

订阅专栏

力扣（力扣打卡和剑指offer）、牛客网（左程云题集）

42 接雨水

题目：
给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。
示例: 输入: [0,1,0,2,1,0,1,3,2,1,2,1] ，输出: 6
解决方法：

方法时间复杂度空间复杂度说明
1. 暴力 O(N²) O(1)
2. 动态规划 O(N) O(N) 在法1的基础上进行记忆化
3. 双指针 O(N) O(1) 在法2的基础上进行空间优化
4. 单调栈 O(N) O(N)

方法	时间复杂度	空间复杂度	说明
1. 暴力	O(N²)	O(1)
2. 动态规划	O(N)	O(N)	在法1的基础上进行记忆化
3. 双指针	O(N)	O(1)	在法2的基础上进行空间优化
4. 单调栈	O(N)	O(N)

1、暴力法

遍历每个柱子：每个柱子的积水受限于其左右两侧最高柱子高度，res += min(lmax,rmax)-height[i];
而lmax是遍历该柱子左侧所有柱子，比较得到的；rmax右侧同理。
这就有了大量的重复计算。

2、动态规划
在上述的暴力法中，对于每个柱子，我们都需要从两头重新遍历一遍求出左右两侧的最大高度，这里是有很多重复计算的，很明显最大高度是可以记忆化的，具体在这里可以用数组边递推边存储，也就是常说的动态规划，DP。具体做法：

dp[i][0] 表示下标i的柱子左边的最大值，dp[i][1] 表示下标i的柱子右边的最大值；初始化左右两端：dp[0][0] = height[0]; dp[n - 1][1] = height[n - 1];
首先从左到右遍历[1→n-1]，填第一列，每个柱子对应的左侧最大值 dp[i][0] = max(height[i], dp[i -1][0]);
然后从右往左遍历[0←n-2]，填第二列，每个柱子对应的右侧最大值 dp[i][1] = max(height[i], dp[i + 1][1]);
最后遍历所有柱子[1,n-2]，（左右两端肯定不积水）同暴力法原理一样，res += min(dp[i][0], dp[i][1]) - height[i];

3、双指针
我们发现，动态规划在计算当前的柱子的左右最大高度时，事实上只用到了dp数组里和待计算的最大高度，相邻的数据；且用过之后就没用了，所以可以精简为两个数来保存下一步需要用的旧数据。

对于left和right对应的柱子，只能确定单侧的最大值，所以lmax比rmax更小的时候，left对应的水位一定是受到lmax限制的，因而可以确定left的积水，无法确定right的积水，那么此时就计算left的。
而当rmax更小的时候，right的水位也同理可得，而left的积水不确定，因此此时就计算right这个柱子的积水。

                                  right_max
 left_max                             __
   __                                |  |
  |  |__   __??????????????????????  |  |
__|     |__|                       __|  |__
        left                      right

class Solution {
public:
    int trap(vector<int>& height) {
        int hsize = (int)height.size();
        if (hsize < 3) { return 0; }
        int res = 0, lmax = height[0], rmax = height[hsize-1], left = 1, right = hsize-2; // 最左和最右一定不会积水
        while (left <= right){
            if (lmax < rmax){ // 左侧最大高度小于右侧，左侧可确定
                lmax = max(lmax, height[left]); // 若left的左侧的最大柱子高度低于left自身柱高，则lmax更新为left柱子高度，从而让res+=0。若left左侧的最大高度超过了自己的柱子高度，则可以积水
                res += lmax - height[left++]; // 计算后，left右移
            }else{ // 若右侧最大柱高更矮，则可以确定right柱子的积水
                rmax = max(rmax, height[right]); // 右侧高度高于本身柱子高度，才能积水
                res += rmax - height[right--];
            }
        }
        return res;
    }
};

4、单调栈 👉图解

若待入栈元素>栈顶元素，则可以积水：
- 把栈顶元素pop出去，若新的栈顶元素和刚刚pop出去的等高，则也可以一并pop出去（确保栈不为空）。
- 积水宽度是新的栈顶元素的位置和当前元素位置之间隔的柱子数目。
  积水的高度是新的栈顶元素和当前元素的高度中的更小值，减去之前的栈顶元素也就是底座的高度。
- 在完成这一次计算后，将当前元素入栈，开始下一轮。

class Solution {
public:
    int trap(vector<int>& height) {
        int hsize = (int)height.size();
        stack<int> pos;
        int res = 0;
        if (hsize < 3){ return 0;}
        for (int i = 0; i < hsize; i++){
            while (!pos.empty() && height[pos.top()] < height[i]){
                int lastID = pos.top(); // 底座
                pos.pop(); // 栈顶出来
                while (!pos.empty() && height[pos.top()] == height[lastID]){
                    pos.pop();
                }
                if (!pos.empty()){
                    // 积水左侧壁：栈顶元素对应位置 = pos.top()，右侧壁：当前元素对应位置 = i
                    // 积水宽度：i - pos.top() -1
                    // 积水深度：左右侧壁更矮的一边的高度 减去 底座高度
                    res += (i-pos.top()-1) * (min(height[pos.top()],height[i]) - height[lastID]);
                } 
            } 
            pos.push(i); // 在完成一轮计算后，把当前柱子压入栈中（成为未来可能的左侧壁），开始下一轮寻找
        } 
        return res;
    } // end fx
};

搜索旋转排序数组问题

假设按照升序排序的数组在预先未知的某个点上进行了旋转。( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

33 搜索旋转排序数组（无重复元素）

题目：
搜索给定的目标值，判断是否存在于数组中。若存在则返回它的索引，否则返回 -1 。
你可以假设数组中不存在重复元素。你的算法时间复杂度必须是 O(log n) 级别。
解决方法：如 012 | 4567 → nums：4567 012。logn的复杂度：考虑二分查找。
- mid将nums分割成两段，其中一段必然是有序的（有序=升序排列，无序=左大右小）。
  - 如：245 6 701 (2<6)左侧有序，456 7 012 (4<7)都有序（算作左侧有序），670 1 245 (6>1, 2<5)右侧有序。
    ∴ 比较nums[0]和nums[mid]的大小。
- 确定了有序的一边，就可以比较target和该区间两端点大小，看target是否属于该区间（即：左端点值<=target<=右端点值）。
  - 若属于该区间，则将两指针圈出的范围缩小至该区间；
  - 否则target就不属于此区间，则将指针圈出的范围缩小到mid划分出的另一边。
- 在中途找到了target数字的位置，则直接返回，否则不断缩小左右指针圈出的空间，直到右指针跑到左指针左边去，区间不存在，则说明该数不存在于nums里，返回-1。
思想：情况复杂时，只要找到一个明确的可以确定的情况处理即可；而其他情况为else，做下一轮处理。
代码：

class Solution {
public:
    int search(vector<int>& nums, int target) {
        if (nums.empty()) return -1;
        int n = (int)nums.size();
        if (n == 1) return nums[0] == target ? 0 : -1;
        int l = 0, r = n - 1;
        while (l <= r) { // 左右指针不断缩小范围，二分查找
            int mid = (l + r) / 2;
            if (nums[mid] == target) return mid;
            if (nums[0] <= nums[mid]) { // mid往左是有序的，就可以判断target是否是在左侧区间里
                if (nums[0] <= target && target < nums[mid]) {
                    r = mid - 1;
                } else {
                    l = mid + 1;
                }
            } else { // mid往右是有序的
                if (nums[mid] < target && target <= nums[n - 1]) {
                    l = mid + 1;
                } else {
                    r = mid - 1;
                }
            }
        }
        return -1;
    }
};