leetcode-第 34 场双周赛

5493. 删除最短的子数组使剩余数组有序

给你一个整数数组 arr ，请你删除一个子数组（可以为空），使得 arr 中剩下的元素是 非递减 的。
一个子数组指的是原数组中连续的一个子序列。
请你返回满足题目要求的最短子数组的长度。

输入：arr = [1,2,3,10,4,2,3,5]
输出：3
解释：我们需要删除的最短子数组是 [10,4,2] ，长度为 3 。剩余元素形成非递减数组 [1,2,3,3,5] 。
另一个正确的解为删除子数组 [3,10,4] 。

class Solution {
    public int findLengthOfShortestSubarray(int[] arr) {
        int len = arr.length;
        int r, l, i, j;
		//左递增边界
        for(l = 0; l < len - 1; l++){
            if(arr[l] > arr[l + 1]) break;
        }
        if(l + 1 == len) return 0;
        //右递增边界
        for(r = len - 1; r > 0; r--){
            if(arr[r] < arr[r - 1]) break;
        }
        int ans = Math.max(l + 1, len - r);
        for(i = 0, j = r; i <= l; i++){
        	//两部分递增的合并
            for(; j < len && arr[j] < arr[i]; j++)
            if(j == len) break;
            ans = Math.max(ans, i + 1 + len - j);
        }
        return len - ans;
    }
}

5494. 统计所有可行路径

记忆化搜索

给你一个 互不相同 的整数数组，其中 locations[i] 表示第 i 个城市的位置。同时给你 start，finish 和 fuel 分别表示出发城市、目的地城市和你初始拥有的汽油总量
每一步中，如果你在城市 i ，你可以选择任意一个城市 j ，满足 j != i 且 0 <= j < locations.length ，并移动到城市 j 。从城市 i 移动到 j 消耗的汽油量为 |locations[i] - locations[j]|，|x| 表示 x 的绝对值。
请注意， fuel 任何时刻都不能为负，且你可以经过任意城市超过一次（包括 start 和 finish ）。
请你返回从 start 到 finish 所有可能路径的数目。
由于答案可能很大， 请将它对 10^9 + 7 取余后返回。

输入：locations = [4,3,1], start = 1, finish = 0, fuel = 6
输出：5
解释：以下为所有可能的路径：
1 -> 0，使用汽油量为 fuel = 1
1 -> 2 -> 0，使用汽油量为 fuel = 5
1 -> 2 -> 1 -> 0，使用汽油量为 fuel = 5
1 -> 0 -> 1 -> 0，使用汽油量为 fuel = 3
1 -> 0 -> 1 -> 0 -> 1 -> 0，使用汽油量为 fuel = 5

class Solution {
    int n;
    int[][] map;
    int finish;
    int[][] visit;
    int mod = (int) 1e9 + 7;
    public int countRoutes(int[] locations, int start, int finish, int fuel) {
    
        n = locations.length;
        this.finish = finish;
        visit = new int[n][fuel + 1];
        for(int i = 0; i < n; i++){
            Arrays.fill(visit[i], -1);
        }
        map = new int[n][n];
        for(int i = 0; i < n; i++){
            for(int j = i; j < n; j++){
                map[i][j] = Math.abs(locations[i] - locations[j]);
                map[j][i] = map[i][j];
            }
        }
        return dfs(start, fuel);     
    }
    public int dfs(int cur, int fuel){
        if(visit[cur][fuel] == -1){
            long way = cur == finish? 1 : 0;
            for(int i = 0; i < n; i++){
                if(i != cur && map[cur][i] <= fuel){  
                    way += dfs(i, fuel - map[cur][i]);

                }
            }
            way = way % mod;   
            visit[cur][fuel] = (int) way;
        }
        return visit[cur][fuel];    
    }
}