突然发现原来我已经那么久没有更新leeetcode了。
确实有段时间没有好好的刷leetcode了。先更一下前段时间做的题目吧。
7.18
牛客上的面试高频题
最大数
难度入门
题目描述
给定一个包含大写英文字母和数字的句子,找出这个句子所包含的最大的十六进制整数,返回这个整数的值。数据保证该整数在int表示范围内。
连续字符串的最大值。
import java.util.*;
public class Solution {
/**
*
* @param s string字符串
* @return int整型
*/
public int solve (String s) {
// write code here
int ans = 0;
char[] arr = s.toCharArray();
int temp = 0;
for(int i = 0;i < arr.length;i++){
if(arr[i] >= '0' && arr[i] <= '9'){
temp *= 16;
temp += (arr[i] - '0');
}else if(arr[i] >= 'A' && arr[i] <= 'F'){
temp *= 16;
temp += (arr[i] - 'A' + 10);
}else{
ans = Math.max(ans, temp);
temp = 0;
}
}
return ans;
}
}
牛牛的和平年代
题目描述
题目背景:
数轴世界建立之初,还没有任何的生机。直到有一天,在数轴的整点上,慢慢诞生了一个一个新兴的文明。如果两个文明相邻,也就是在他们之间不存在其他的整点,他们就会慢慢受到彼此的影响,逐渐融为一个整体。而当所有的文明大一统,全部融为一个整体的时候,这个数轴世界才会重归和平。为了能够让自己的文明发展壮大,牛牛决定根据每个文明诞生的年代表,计算出什么时候才是和平的黄金时代。
简明题意:
我们定义一个整数可重集合是好的,当且仅当对于集合中任意两个元素 a, b (a \leq ba≤b) ,所有满足 a\leq c\leq ba≤c≤b 的元素 c 都在集合中出现过。
现在,给你一个数组 mSet,你需要做的是,对于这个数组的每一个前缀,判断这个前缀是不是一个好的集合。所以,你将计算出的是一个数组,为布尔类型。
用一个TreeSet来帮助排序,之后去遍历其中的是否满足要求即可。
import java.util.*;
public class Solution {
/**
* 检查数组的每个前缀是不是一个好的集合
* @param mSet int整型一维数组
* @return bool布尔型一维数组
*/
public boolean[] continuousSet (int[] mSet) {
// write code here
boolean[] ans = new boolean[mSet.length];
if(mSet.length == 0){
return ans;
}
TreeSet<Integer> set = new TreeSet<>();
for(int i = 0;i < mSet.length;i++){
set.add(mSet[i]);
if(core(set)){
ans[i] = true;
}
}
return ans;
}
public boolean core(TreeSet<Integer> set){
List<Integer> list = new ArrayList<>(set);
for(int m = 1;m < list.size();m++){
if(list.get(m) - list.get(m - 1) != 1){
return false;
}
}
return true;
}
}
204. 计数质数
难度简单
暴力解法,效率很低。
class Solution {
public int countPrimes(int n) {
if(n <= 1){
return 0;
}
int ans = 0;
for(int i = 2;i < n;i++){
if(i % 2 == 0 && i != 2){
continue;
}
if(judge(i)){
set.add(i);
ans++;
}
}
return ans;
}
public boolean judge(int num){
for(int i = 2;i * i <= num;i++){
if(num % i == 0){
return false;
}
}
return true;
}
}
看了题解发现有其它更快速的方法。
class Solution {
public int countPrimes(int n) {
int result = 0;
boolean[] b = new boolean[n]; // 初始化默认值都为 false,为质数标记
if(2 < n) result++; // 如果大于 2 则一定拥有 2 这个质数
for(int i = 3; i < n; i += 2){ // 从 3 开始遍历,且只遍历奇数
if(!b[i]){ // 是质数
for(int j = 3; i * j < n; j += 2){
b[i * j] = true; // 将当前质数的奇数倍都设置成非质数标记 true
}
result++; // 质数个数 +1
}
}
return result;
}
}
97. 交错字符串
难度困难
自己尝试写了动态规划,但是里面的状态转移总是写不对。参照了题解才想通。
s1的每个字符都尝试与s2的字符串组合在一起,再配合上辅助数组来帮助确定这个组合是否有效。
class Solution {
public boolean isInterleave(String s1, String s2, String s3) {
int len1 = s1.length();
int len2 = s2.length();
int len3 = s3.length();
if(len1 + len2 != len3){
return false;
}
boolean[][] f = new boolean[len1 + 1][len2 + 1];
f[0][0] = true;
for(int i = 0;i <= len1;i++){
for(int j = 0;j <= len2;j++){
int p = i + j - 1;
if (i > 0) {
f[i][j] = f[i][j] || (f[i - 1][j] && s1.charAt(i - 1) == s3.charAt(p));
}
if (j > 0) {
f[i][j] = f[i][j] || (f[i][j - 1] && s2.charAt(j - 1) == s3.charAt(p));
}
}
}
return f[len1][len2];
}
}
7.21
95. 不同的二叉搜索树 II
难度中等
之前做过1,用动态规划的方式来做。但是如果要把所有结果都展示出来却不知道要怎么下手。看了题解才会做的。
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public List<TreeNode> generateTrees(int n) {
if(n == 0){
return new LinkedList<TreeNode>();
}
return generateTrees(1,n);
}
public List<TreeNode> generateTrees(int begin, int end){
List<TreeNode> ans = new LinkedList<>();
if(begin > end){
ans.add(null);
return ans;
}
for(int i = begin;i <= end;i++){
List<TreeNode> leftList = generateTrees(begin, i - 1);
List<TreeNode> rightList = generateTrees(i + 1, end);
for(TreeNode left : leftList){
for(TreeNode right : rightList){
TreeNode node = new TreeNode(i);
node.left = left;
node.right = right;
ans.add(node);
}
}
}
return ans;
}
}
7.22
剑指 Offer 11. 旋转数组的最小数字
难度简单
二分查找
class Solution {
public int minArray(int[] numbers) {
int low = 0;
int high = numbers.length - 1;
while (low < high) {
int pivot = low + (high - low) / 2;
if (numbers[pivot] < numbers[high]) {//后面的序列有序
high = pivot;
} else if (numbers[pivot] > numbers[high]) {
low = pivot + 1;
} else {
high -= 1;
}
}
return numbers[low];
}
}
7.23
239. 滑动窗口最大值
难度困难
利用LinkedList双向链表的性质可以做窗口的问题。自己写了一个方法,不过超时了。
emmm,可能是维护从大到小的链表时花费了太多时间。
class Solution {
public void updateList(LinkedList<Integer> list, int num){
while(!list.isEmpty() && num > list.getLast()){
list.removeLast();
}
list.add(num);
}
public int[] maxSlidingWindow(int[] nums, int k) {
LinkedList<Integer> list = new LinkedList<>();//list从左到右,从大到小
LinkedList<Integer> window = new LinkedList<>();
LinkedList<Integer> ans = new LinkedList<>();
for(int i = 0;i < nums.length;i++){
//首先填充窗口
if(i < k){
updateList(list, nums[i]);
window.add(nums[i]);
if(i == k - 1){
ans.add(list.getFirst());
}
continue;
}
int temp = window.removeFirst();
window.add(nums[i]);
updateList(list, nums[i]);
if(temp == list.getFirst()){
list.removeFirst();
}
ans.add(list.getFirst());
}
int[] res = new int[ans.size()];
for(int i = 0;i < res.length;i++){
res[i] = ans.get(i);
}
return res;
}
}
根据题解更改了之前的做法。窗口队列里面放的不是元素,而是索引。利用索引我们可以知道窗口的开始是否已经过时,以及能够知道窗口是否已经填充完成。
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
LinkedList<Integer> list = new LinkedList<>();//list从左到右,从大到小,窗口队列
int[] result = new int[nums.length - k + 1];
for(int i = 0;i < nums.length;i++){
while(!list.isEmpty() && nums[i] >= nums[list.peekLast()]){
list.pollLast();
}
list.addLast(i);
if(list.peek() <= i - k){
list.poll();
}
if(i + 1 >= k){
result[i + 1 - k] = nums[list.peek()];
}
}
return result;
}
}