LeetCode Weekly Contest 130 题解

最新推荐文章于 2021-07-05 16:44:27 发布

acDream_

最新推荐文章于 2021-07-05 16:44:27 发布

阅读量283

点赞数

分类专栏： ●算法很美文章标签： leetcode weekly 130

本文链接：https://blog.csdn.net/acdream_/article/details/88958375

版权

●算法很美专栏收录该内容

116 篇文章 7 订阅

订阅专栏

1018. 可被 5 整除的二进制前缀

给定由若干 0 和 1 组成的数组 A。我们定义 N_i：从 A[0] 到 A[i] 的第 i 个子数组被解释为一个二进制数（从最高有效位到最低有效位）。

返回布尔值列表 answer，只有当 N_i 可以被 5 整除时，答案 answer[i] 为 true，否则为 false。

示例 1：
输入：[0,1,1]
输出：[true,false,false]
解释：
输入数字为 0, 01, 011；也就是十进制中的 0, 1, 3 。只有第一个数可以被 5 整除，因此 answer[0] 为真。
示例 2：
输入：[1,1,1]
输出：[false,false,false]
示例 3：
输入：[0,1,1,1,1,1]
输出：[true,false,false,false,true,false]
示例 4：
输入：[1,1,1,0,1]
输出：[false,false,false,false,false]
提示：

1 <= A.length <= 30000
A[i] 为 0 或 1

思路:

递推
下一个数nextNum为上一个数乘2+当前数,最后判断nextNum是否能被5整除就行了

AcCode:
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
class Solution {
    public List<Boolean> prefixesDivBy5(int[] A) {
        
        List<Boolean> list = new ArrayList<Boolean>();
        StringBuilder builder = new StringBuilder();
        BigInteger bigInteger = BigInteger.ZERO;
        BigInteger TWO = BigInteger.valueOf(2);
        BigInteger FIVE = BigInteger.valueOf(5);
        for (int i = 0; i < A.length; i++) {
        	bigInteger = bigInteger.multiply(TWO).add(BigInteger.valueOf(A[i]));
        	if(bigInteger.mod(FIVE).compareTo(BigInteger.ZERO)==0) {
        		list.add(true);
        	}else {
        		list.add(false);
        	}
		}
        return list;
    
    }
}
1017. 负二进制转换

给出数字 N，返回由若干 "0" 和 "1"组成的字符串，该字符串为 N 的负二进制（base -2）表示。

除非字符串就是 "0"，否则返回的字符串中不能含有前导零。

示例 1：
输入：2
输出："110"
解释：(-2) ^ 2 + (-2) ^ 1 = 2
示例 2：
输入：3
输出："111"
解释：(-2) ^ 2 + (-2) ^ 1 + (-2) ^ 0 = 3
示例 3：
输入：4
输出："100"
解释：(-2) ^ 2 = 4
提示：

0 <= N <= 10^9

思路:

暴力模拟
转化为负二进制其实和转化二进制差不多,除-2取余,但余数不能是负数,所以如果余数是负数,要将其转化成正数,对应的商也需要改变,新的商=（被除数-abs(余数))/-2,按这个思路模拟下去即可

AcCode:
import static java.lang.Math.abs;
class Solution {
    public String baseNeg2(int N) {
        if(N==0) {
			return "0";
		}
		StringBuilder builder = new StringBuilder();
        while(N!=0) {
        	int mod = N%-2;
        	if(mod>0) {
        		builder.append(mod);
        		N = N/-2;
        	}else {
        		builder.append(abs(mod));
        		N = (N-abs(mod))/-2;
        	}
        }
		return builder.reverse().toString();
    
    }
}
1019. 链表中的下一个更大节点

给出一个以头节点 head 作为第一个节点的链表。链表中的节点分别编号为：node_1, node_2, node_3, ... 。

每个节点都可能有下一个更大值（next larger value）：对于 node_i，如果其 next_larger(node_i) 是 node_j.val，那么就有 j > i 且 node_j.val > node_i.val，而 j 是可能的选项中最小的那个。如果不存在这样的 j，那么下一个更大值为 0 。

返回整数答案数组 answer，其中 answer[i] = next_larger(node_{i+1}) 。

注意：在下面的示例中，诸如 [2,1,5] 这样的输入（不是输出）是链表的序列化表示，其头节点的值为 2，第二个节点值为 1，第三个节点值为 5 。

示例 1：
输入：[2,1,5]
输出：[5,5,0]
示例 2：
输入：[2,7,4,3,5]
输出：[7,0,5,5,0]
示例 3：
输入：[1,7,5,1,9,2,5,1]
输出：[7,9,9,9,0,5,0,0]
提示：

对于链表中的每个节点，1 <= node.val <= 10^9
给定列表的长度在 [0, 10000] 范围内

思路:

~~因为我看到数据范围在 $10^4$ ,我想直接暴力 $O(n^2)$ 应该能过,没想到最后没有过~~
之后我看了一下别人的思路,使用单调栈即可

AcCode:
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    class Node{
		int value;
		int index;
		
		public Node(){
			
		}
		public Node(int value,int index) {
			this.value = value;
			this.index = index;
		}
	}
	
	public int[] nextLargerNodes(ListNode head) {
		List<Integer> list = new ArrayList<Integer>();
		while(head!=null) {
			list.add(head.val);
			head = head.next;
		}
		int[] res = new int[list.size()];
		Stack<Node> stack = new Stack<Node>();//建立一个单调栈
		for (int i = 0; i < list.size(); i++) {
			int target = list.get(i);
			if(stack.isEmpty()) {
				stack.push(new Node(target, i));
			}else {
				while(!stack.isEmpty()) {
					int topElem = stack.peek().value;
					if(target<=topElem) {
						break;
					}else {
						Node temp = stack.pop();
						res[temp.index] = target;
					}
				}
				stack.push(new Node(target, i));
			}
		}
		
		return res;
    }
}
1020. 飞地的数量

给出一个二维数组 A，每个单元格为 0（代表海）或 1（代表陆地）。

移动是指在陆地上从一个地方走到另一个地方（朝四个方向之一）或离开网格的边界。

返回网格中无法在任意次数的移动中离开网格边界的陆地单元格的数量。

示例 1：
输入：[[0,0,0,0],[1,0,1,0],[0,1,1,0],[0,0,0,0]]
输出：3
解释： 
有三个 1 被 0 包围。一个 1 没有被包围，因为它在边界上。
示例 2：
输入：[[0,1,1,0],[0,0,1,0],[0,0,1,0],[0,0,0,0]]
输出：0
解释：
所有 1 都在边界上或可以到达边界。
提示：

1 <= A.length <= 500
1 <= A[i].length <= 500
0 <= A[i][j] <= 1
所有行的大小都相同

思路:

连通图的变体
遍历该网格的所有边界,使用dfs让连通的陆地都变成0,之后只要搜索该图中还是多少剩余的陆地就是答案了

AcCode:
class Solution {
    public int numEnclaves(int[][] A) {
		//搜第一行
		for (int j = 0; j < A[0].length; j++) {
			if(A[0][j]==1)dfs(A,0,j);
		}
		//搜最后一行
		for (int j = 0; j < A[A.length-1].length; j++) {
			if(A[A.length-1][j]==1)dfs(A,A.length-1,j);
		}
		//搜第一列
		for (int i = 0; i < A.length; i++) {
			if(A[i][0]==1)dfs(A, i, 0);
		}
		//搜最后一列
		for (int i = 0; i < A.length; i++) {
			if(A[i][A[i].length-1]==1)dfs(A, i, A[i].length-1);
		}
		int count = 0;
		for (int i = 0; i < A.length; i++) {
			if(i==0 || i==A.length-1)continue;
			for (int j = 0; j < A[i].length; j++) {
				if(j==0 || j==A[i].length-1)continue;
				if(A[i][j]==1) {
					count++;
				}
			}
		}
        return count;
    
    }
    private void dfs(int[][] A, int x, int y) {
		A[x][y] = 0;
		//向上搜
		if(x-1>=0 && A[x-1][y]==1)dfs(A, x-1, y);
		//向下搜
		if(x+1<A.length && A[x+1][y]==1)dfs(A,x+1, y);
		//向左搜
		if(y-1>=0 && A[x][y-1]==1)dfs(A, x, y-1);
		if(y+1<A[0].length && A[x][y+1]==1)dfs(A, x, y+1);
		
	}
}   

acDream_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LeetCode Weekly Contest 130 题解

1018.可被 5 整除的二进制前缀给定由若干0和1组成的数组A。我们定义N_i：从A[0]到A[i]的第i个子数组被解释为一个二进制数（从最高有效位到最低有效位）。返回布尔值列表answer，只有当N_i可以被5整除时，答案answer[i]为true，否则为false。示例 1：输入：[0,1,1]输出：[true,false,...
复制链接

扫一扫