力扣10.2

1870. 准时到达的列车最小时速

给你一个浮点数 hour ，表示你到达办公室可用的总通勤时间。要到达办公室，你必须按给定次序乘坐 n 趟列车。另给你一个长度为 n 的整数数组 dist ，其中 dist[i] 表示第 i 趟列车的行驶距离（单位是千米）。

每趟列车均只能在整点发车，所以你可能需要在两趟列车之间等待一段时间。

• 例如，第 1 趟列车需要 1.5 小时，那你必须再等待 0.5 小时，搭乘在第 2 小时发车的第 2 趟列车。
  返回能满足你准时到达办公室所要求全部列车的 最小正整数 时速（单位：千米每小时），如果无法准时到达，则返回 -1 。

生成的测试用例保证答案不超过 107 ，且 hour 的 小数点后最多存在两位数字

数据范围

• n == dist.length
• 1 <= n <= 105
• 1 <= dist[i] <= 105
• 1 <= hour <= 109
• hours 中，小数点后最多存在两位数字

分析

二分答案

代码

class Solution {
public:
    bool check(int v, vector<int>& dist, double h) {
        double t = 0;
        for(int i = 0; i < dist.size(); i ++ ) {
            if(i != dist.size() - 1) t += ceil(dist[i] * 1.0 / v);
            else t += dist[i] * 1.0 / v;
        }
        return t <= h;
    }
    double find(int l, int r, vector<int>& dist, double h) {
        while(l < r) {
            int mid = (l + r) >> 1;
            if(check(mid, dist, h)) r = mid;
            else l = mid + 1;
        }
        if(l > 1e7) return -1;
        return l;
    }
    int minSpeedOnTime(vector<int>& dist, double hour) {
         return find(0, 1e8, dist, hour);
    }
};

2684. 矩阵中移动的最大次数

给你一个下标从 0 开始、大小为 m x n 的矩阵 grid ，矩阵由若干 正 整数组成。

你可以从矩阵第一列中的 任一 单元格出发，按以下方式遍历 grid ：

从单元格 (row, col) 可以移动到 (row - 1, col + 1)、(row, col + 1) 和 (row + 1, col + 1) 三个单元格中任一满足值 严格 大于当前单元格的单元格。
返回你在矩阵中能够 移动 的 最大 次数。

数据范围

• m == grid.length
• n == grid[i].length
• 2 <= m, n <= 1000
• 4 <= m * n <= 105
• 1 <= grid[i][j] <= 106

分析

类似数字三角形

代码

class Solution {
public:
    const static int N = 1005;
    int dp[N][N];
    int nums[N][N];
    int res = 0;
    int maxMoves(vector<vector<int>>& grid) {
        int n = grid.size();
        int m = grid[0].size();
        memset(dp, -0x3f, sizeof(dp));
        for(int i = 1; i <= n; i ++ ) {
            for(int j = 1; j <= m; j ++ ) {
                nums[j][i] = grid[i - 1][j - 1];
            }
        }

        memset(dp, -0x3f, sizeof(dp));
        for(int i = 1; i <= m; i ++ ) {
            for(int j = 1; j <= n; j ++ ) {
                if(i == 1) {
                    dp[i][j] = 0;
                    continue;
                }
                if(nums[i][j] > nums[i - 1][j]) dp[i][j] = max(dp[i][j], dp[i - 1][j] + 1);
                if(j > 1 && nums[i][j] > nums[i - 1][j - 1]) dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1);
                if(j < n && nums[i][j] > nums[i - 1][j + 1]) dp[i][j] = max(dp[i][j], dp[i - 1][j + 1] + 1);
                res = max(res, dp[i][j]);
            }
        }
        return res;
    }
};