LeetCode141周赛

最新推荐文章于 2021-11-22 21:18:49 发布

FakeNews

最新推荐文章于 2021-11-22 21:18:49 发布

阅读量172

点赞数

CC 4.0 BY-SA版权

分类专栏： LeetCode刷题之路文章标签： LeetCode周赛 1091. 二进制矩阵中的最短路径

本文链接：https://blog.youkuaiyun.com/lizhao8817/article/details/92718492

LeetCode刷题之路专栏收录该内容

15 篇文章

订阅专栏

本文介绍了LeetCode141周赛中的两道题。1090题是求受标签影响的子集最大和，思路是用HashMap和优先级队列；1091题是求二进制矩阵中从左上角到右下角的最短畅通路径长度，思路是使用BFS算法。

LeetCode141周赛

1090. 受标签影响的最大值

我们有一个项的集合，其中第 i 项的值为 values[i]，标签为 labels[i]。

我们从这些项中选出一个子集 S，这样一来：

|S| <= num_wanted
对于任意的标签 L，子集 S 中标签为 L 的项的数目总满足 <= use_limit。

返回子集 S 的最大可能的和。

示例 1：
输入：values = [5,4,3,2,1], labels = [1,1,2,2,3], num_wanted = 3, use_limit = 1
输出：9
解释：选出的子集是第一项，第三项和第五项。
示例 2：
输入：values = [5,4,3,2,1], labels = [1,3,3,3,2], num_wanted = 3, use_limit = 2
输出：12
解释：选出的子集是第一项，第二项和第三项。
示例 3：
输入：values = [9,8,8,7,6], labels = [0,0,0,1,1], num_wanted = 3, use_limit = 1
输出：16
解释：选出的子集是第一项和第四项。
示例 4：
输入：values = [9,8,8,7,6], labels = [0,0,0,1,1], num_wanted = 3, use_limit = 2
输出：24
解释：选出的子集是第一项，第二项和第四项。
思路：HashMap+优先级队列（排序也行）

public int largestValsFromLabels(int[] values, int[] labels, int num_wanted, int use_limit) {
    HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
    PriorityQueue<SimpleEntry<Integer, Integer>> priorityQueue = 
            new PriorityQueue<SimpleEntry<Integer,Integer>>(new Comparator<SimpleEntry<Integer, Integer>>() {
                @Override
                public int compare(SimpleEntry<Integer, Integer> o1, SimpleEntry<Integer, Integer> o2) {
                    // TODO Auto-generated method stub
                    if(o1.getValue() == o2.getValue())
                        return o1.getKey() - o2.getKey();
                    return o2.getValue() - o1.getValue();
                }
            });
    for(int i = 0;i < values.length;i++) {
        SimpleEntry<Integer, Integer> entry = new SimpleEntry<Integer, Integer>(labels[i],values[i]);
        priorityQueue.add(entry);			
    }
    int cnt = 0,res = 0;
    while(!priorityQueue.isEmpty() && cnt < num_wanted) {
        SimpleEntry<Integer, Integer> entry = priorityQueue.poll();
        Integer integer = map.getOrDefault(entry.getKey(),new Integer(0));
        if(integer < use_limit) {
            res += entry.getValue();
            cnt++;
            integer++;
            map.put(entry.getKey(), integer);
        }else {
            continue;
        }			
    }        
    return res;
}

1091. 二进制矩阵中的最短路径

https://leetcode-cn.com/problems/shortest-path-in-binary-matrix/solution/java-bfs-by-ftcl_lx/

在一个 N × N 的方形网格中，每个单元格有两种状态：空（0）或者阻塞（1）。

一条从左上角到右下角、长度为 k 的畅通路径，由满足下述条件的单元格 C_1, C_2, ..., C_k 组成：

相邻单元格 C_i 和 C_{i+1} 在八个方向之一上连通（此时，C_i 和 C_{i+1} 不同且共享边或角）
C_1 位于 (0, 0)（即，值为 grid[0][0]）
C_k 位于 (N-1, N-1)（即，值为 grid[N-1][N-1]）
如果 C_i 位于 (r, c)，则 grid[r][c] 为空（即，grid[r][c] == 0）

返回这条从左上角到右下角的最短畅通路径的长度。如果不存在这样的路径，返回 -1 。

思路：BFS

final int INF = 1000000000;
int[] dx = {-1, -1, -1, 0, 0, 1, 1, 1};
int[] dy = {-1, 0, 1, -1, 1, -1, 0, 1};	
class Pair{
	int x;
	int y;
	public Pair(int x,int y) {
		this.x = x;
		this.y = y;
	}
}
public int shortestPathBinaryMatrix(int[][] grid) {
    int n = grid.length;
	if(grid[0][0] == 1 || grid[n-1][n-1] == 1) return -1;
	int[][] dis = new int[n][n];
	for(int i = 0;i < n;i++)
		Arrays.fill(dis[i], INF);
	Queue<Pair> queue = new LinkedList<>();
	dis[0][0] = 0;
	queue.add(new Pair(0, 0));
	while(!queue.isEmpty()) {
		int x = queue.peek().x;
		int y = queue.peek().y;
		queue.poll();
		for(int i = 0;i < 8;i++) {
			int tx = x + dx[i];
			int ty = y + dy[i];
			if(tx >= 0 && tx < n && ty >= 0 && ty < n && grid[tx][ty] == 0 && dis[tx][ty] > dis[x][y] + 1) {
				dis[tx][ty] = dis[x][y] + 1;
				queue.add(new Pair(tx, ty));
			}											
		}						
	}
	if(dis[n-1][n-1] == INF) return -1;
	return dis[n-1][n-1] + 1;
}