leetcode_187_contest

5400. 旅行终点站

思路：
直接使用dict记录出度即可

from collections import defaultdict
class Solution:
    def destCity(self, paths: List[List[str]]) -> str:
        res_map = defaultdict(int)
        tmp = set()
        for path in paths:
            tmp.add(path[0])
            tmp.add(path[1])
            res_map [path[0]] += 1
        for x in tmp:
            if res_map[x] ==0:
                return x
        return None

是否所有 1 都至少相隔 k 个元素

思路：
比较简单，直接模拟寻找即可

class Solution:
    def kLengthApart(self, nums: List[int], k: int) -> bool:
        pre = -1
        for i,num in enumerate(nums):
            if num == 1:
                if pre==-1 or i-pre-1>=k:
                    pre = i
                else:
                    return False
        return True

5402. 绝对差不超过限制的最长连续子数组

思路：
使用两个单调队列来存储窗口内的最大值和最小值，使用left标志来表示队列的左侧端点。
窗口内的最大值使用降序队列存储，队列头为最大值；最小值使用升序队列存储，队列头为最小值；
遍历数组时，维数窗口内的两个队列，如果最大值减最小值大于limit，将窗口左端点向右移动，直到两个队列的最值满足小于limit。

class Solution {
public:
	int longestSubarray(vector<int> & nums, int limit) {
		deque<int> maxq;
		deque<int> minq;
		int n = nums.size();
		int ans = 1;
		int left = 0;
		for (int i = 0; i < n; ++i) {
			int tmp = nums[i];
			while (!maxq.empty() && nums[maxq.back()] < tmp) {
				maxq.pop_back();
			}
			while (!minq.empty() && nums[minq.back()] > tmp) {
				minq.pop_back();
			}
			maxq.push_back(i);
			minq.push_back(i);
			while ((nums[maxq.front()] - nums[minq.front()]) > limit) {
				++left;
                if (maxq.front()<left){
                    maxq.pop_front();
                }
                if (minq.front()<left){
                    minq.pop_front();
                }
			}
            ans = max(ans, i - left + 1);
		}
		return ans;
	}
};

5403. 有序矩阵中的第 k 个最小数组和

思路：
直接暴力求解就行。。每一行累加，然后取top k，继续加上下一行。

class Solution:
    def kthSmallest(self, mat: List[List[int]], k: int) -> int:
        res = mat[0][:k]
        for x in mat[1:]:
            tmp = []
            for t in x:
                tmp += [y+t for y in res]
            res = sorted(tmp)[:k]
        return res[-1]