Leetcode刷题

已于 2024-07-06 01:35:13 修改
阅读量230 收藏
点赞数 2
文章标签： leetcode 算法
于 2024-06-25 21:27:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43696328/article/details/139969981
版权

打算跟着代码随想录的顺序刷一个暑期，看看效果如何，发个帖记录一下

6.25

704 二分查找

class Solution {
    public int search(int[] nums, int target) {
        int len = nums.length;
        int left = 0; // 初始为数组0位置
        int right = len-1; // 初始为数组最后一个数
        int mid  = len / 2;
        
        while(nums[mid] != target){
            if(left == right){
                mid = -1;
                break;
            }
            if(nums[mid] > target){
                right = mid - 1;
                mid = (left + right) / 2;
                continue;
            }
            else{
                left = mid+1;
                mid = (left + right) / 2;
                continue;
            }
        }
        return mid;
    }
}

27 移除元素

class Solution {
    public int removeElement(int[] nums, int val) {
        int fast = 0; // 定义快指针
        int slow = 0; // 定义慢指针
        int len = nums.length;
        int count = 0;
        for(fast = 0; fast < len; fast++){
            if(nums[fast] != val){
                nums[slow] = nums[fast];
                slow++;
            }
            else {
                continue;
            }
        }
        return slow;
    }
}

6.26

977、有序数组的平方

class Solution {
    public int[] sortedSquares(int[] nums) {
        int i=0;
        int len = nums.length;
        int j = len-1;
        int k = len-1;
        int[] result = new int[len];
        while(i<=j){
            if(nums[i]*nums[i] > nums[j] * nums[j]){
                result[k--] = nums[i]*nums[i];
                i++;
            }
            else{
                result[k--] = nums[j] * nums[j];
                j--;
            }
        }
        return result;
    }
}

209、拿下滑动窗口

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int i=0;
        int j=0;
        int len = nums.length;
        int sum = 0;
        int result = Integer.MAX_VALUE;
        for(j=0; j<len; j++){
            sum += nums[j];
            while(sum >= target){
                sum = sum - nums[i];
                result = Math.min(result,j-i+1);
                i++;
            }
        }
        if(result == Integer.MAX_VALUE)
            return 0;
        return result; 
    }
}

6.27

59、螺旋矩阵II

class Solution {
    public int[][] generateMatrix(int n) {

        int[][] mat = new int[n][n];

        if(n == 1){
            mat[0][0] = 1;
            return mat;
        }
        int startX = 0; //右边界
        int startY = 0; //下边界
        int offside = 1;
        int a = 1;
        int i = 1;
        int j = 0; // 行
        int k = 0; // 列
        while(i <= n/2){
            for(k=startY; k<n-offside; k++){
                mat[startX][k] = a;
                a++;
            }
            for(j = startX; j<n-offside; j++){
                mat[j][k] = a;
                a++;
            }
            for(;k>startY;k--){
                mat[j][k] = a;
                a++;
            }
            for(;j>startX; j--){
                mat[j][k] = a;
                a++;
            }
            startX++;
            startY++;
            offside++;
            i++;
        }
        
        if(n%2 != 0){
            mat[n/2][n/2] = n*n;
        }
        return mat;
    }
}

203、移除链表元素

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummy = new ListNode();
        dummy.next = head;
        ListNode h1 = dummy;

        while(h1.next!=null){
            if(h1.next.val == val)
                h1.next = h1.next.next;
            else{
                h1 = h1.next;
            }
        }

        return dummy.next;
    }
}

206、反转链表

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null || head.next == null)
            return head;
        ListNode pre = null;
        ListNode current = head;
        ListNode tmp =  null;
        
        while(current !=null){
            tmp = current.next;
            current.next = pre;
            pre = current;
            current = tmp;

        }
        return pre;
    }
}

6.28

707、设计链表

class ListNode{
    int val;
    ListNode next;
    ListNode(){}
    ListNode(int val){
        this.val = val;
    }
}

class MyLinkedList {
    int size; //节点个数
    ListNode head; //虚拟头结点

    public MyLinkedList() {
        size = 0;
        head = new ListNode();
    }
    
    public int get(int index) {
        if(index<0 || index >= size){
            return -1;
        }

        ListNode cur = head;
        for(int i = 0; i<=index; i++){
            cur = cur.next;
        }
        return cur.val;
    }
    
    public void addAtHead(int val) {
        ListNode tmp = new ListNode(val);
        tmp.next = head.next;
        head.next = tmp;
        size++;
    }
    
    public void addAtTail(int val) {
        if(size==0){
            ListNode tmp = new ListNode(val);
            head.next = tmp;
            tmp.next = null;
            size++;
        }
        else{
        ListNode cur = head;
        while(cur.next!=null)
            cur = cur.next;
        ListNode tmp = new ListNode(val);
        cur.next = tmp;
        tmp.next = null;
        size++;}
    }
    
    public void addAtIndex(int index, int val) {
        if(index > size)
            return;
        if(index<=0){
            addAtHead(val);
            return;
        }
        ListNode cur = head;
        ListNode tmp = new ListNode(val);
        for(int i=0; i<index; i++){
            cur = cur.next;
        }
        tmp.next = cur.next;
        cur.next = tmp;
        size++;
    }
    
    public void deleteAtIndex(int index) {
        if(index<0 || index >=size)
            return;
        if(index == 0)
        {
            head = head.next;
            size--;
            return;
        }
        ListNode cur = head;
        for(int i=0; i<index; i++){
            cur = cur.next;
        }
        if(cur.next!=null)
            cur.next = cur.next.next;
        else cur.next = null;
        size--;
    }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */

这道题要注意index到底代表什么，debug了一小时我也是醉了

24、两两交换链表中的节点

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {

        if(head==null || head.next==null)
            return head;

        ListNode b,c;
        ListNode dummy = new ListNode();
        ListNode a = dummy;
        dummy.next = head;
        ListNode h1 = head;

        b = head;
        c = head.next;
        ListNode tmp;
        while(b!=null && c!=null){
            b.next = c.next;
            c.next = a.next;
            a.next = c;
            
            a = b;
            b = b.next;
            if(b!=null)
                c = b.next;
        }

        return dummy.next;
    }
}

6.29

160、相交链表

/**
 * Definition for singly-linked list.
 * public class ListNode {
 * int val;
 * ListNode next;
 * ListNode(int x) {
 * val = x;
 * next = null;
 * }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA==null || headB==null)
            return null;
        if(headA==headB){
                return headA;
        }
        ListNode h1 = headA;
        ListNode h2 = headB;
        int countA = 1;
        while(h1.next!=null){
            h1 = h1.next;
            countA++;    
        }
        int countB = 1;
        while(h2!=h1 && h2!=null){
            h2 = h2.next;
            countB++;
        }
        if(h2 == null)
            return null;
        
        ListNode h3 = headA;
        ListNode h4 = headB;
        if(countA > countB){
            int count = countA - countB;
            while(count>0){
                h3 = h3.next;
                count--;
            }
            while(h3!=h4){
                h3 = h3.next;
                h4 = h4.next;
            }
            return h3;
        }

        if(countA < countB){
            int count = countB - countA;
            while(count>0){
                h4 = h4.next;
                count--;
            }
            while(h3!=h4){
                h3 = h3.next;
                h4 = h4.next;
            }
            return h3;
        }

        if(countA == countB){
            while(h3!=h4){
                h3 = h3.next;
                h4 = h4.next;
            }
            return h3;
        }
        return null;
    }
}

19、删除链表的倒数第N个节点

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode();
        dummy.next = head;

        ListNode slow = dummy;
        ListNode fast = dummy;

        for(int i=1; i<=n+1; i++)
            fast = fast.next;
        while(fast!=null){
            fast = fast.next;
            slow = slow.next;
        }
        slow.next = slow.next.next;
        return dummy.next;
    }
}
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode h = head;
        int count=0;
        while(h!=null){
            h = h.next;
            count++;
        }

        if(count == n){
            head = head.next;
            return head;
        }
        
        ListNode h1 = head;
        for(int i=0; i<count-n-1; i++){
            h1 = h1.next;
        }
        
        h1.next = h1.next.next;

        return head;

    }
}

142、环形链表II

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head==null || head.next==null)
            return null;
        ListNode fast= head;
        ListNode slow = head;
        ListNode h1 = head;
        while(fast!=null && fast.next!=null){
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow){
                while(h1!=fast){
                    h1 = h1.next;
                    fast = fast.next;
                }
                return fast;
            }
        }
        return null;    
    }
}

6.30

242、有效的字母异位词

class Solution {
    Map<Character, Integer> map = new HashMap<>();
    public boolean isAnagram(String s, String t) {
        int len = s.length();
        for (int i = 0; i < len; i++) {
            char c = s.charAt(i);
            if (map.containsKey(c)) {
                map.put(c, map.get(c) + 1);
            } else {
                map.put(c, 1);
            }
        }

        int len2 = t.length();
        for (int i = 0; i < len2; i++) {
            char c = t.charAt(i);
            if (map.containsKey(c)) {
                map.put(c, map.get(c) - 1);
            } else {
                return false;
            }
        }
        for(Map.Entry<Character, Integer> entry : map.entrySet()){
            if(entry.getValue()!=0)
                return false;
        }
        return true;
    }
}

7.1

349、两个数组的交集

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        Set<Integer> set = new HashSet<>();
        Set<Integer> set2 = new HashSet<>();

        int len = nums1.length;
        for(int i=0; i<len; i++){
            set.add(nums1[i]);
        }
        int len2 = nums2.length;

        for(int i=0; i<len2; i++){
            if(set.contains(nums2[i])){
                set2.add(nums2[i]);
            }
        }
        Integer[] arr1 = set2.toArray(new Integer[0]);
        int[] arr = new int[arr1.length];
        for(int i=0; i<arr1.length; i++){
            arr[i] = arr1[i];
        }
        return arr;
    }
}

基础还是不扎实，set转成数组发现自己竟然不会。晕倒。

202、快乐数

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> set = new HashSet<>();
        int sum = 0;
        while(sum!=1){
            n = sum(n);
            sum = n;
            if(set.contains(sum)){
                return false;
            }
            else
                set.add(sum);
        }
        return true;
    }

    public int sum(int n){
        int sum = 0;
        int a = 0;
        while(n!=0){
            a = n%10;
            sum += a*a;
            n = n/10;
        }
        return sum;
    }
}

7.2

1、两数之和

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer,Integer> map = new HashMap<>();
        int[] arr = new int[2];
        for(int i=0; i<nums.length; i++){
            int tmp = target - nums[i];
            if(!map.containsKey(tmp)){
                map.put(nums[i], i);
            }
            else{
                int a = map.get(tmp);
                arr[0] = a;
                arr[1] = i;
                return arr;
            } 
        }
        return null;
    }
}

454、四数相加II

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int count = 0;
        Map<Integer, Integer> map1 = new HashMap<>();
        for (int i = 0; i < nums1.length; i++) {
            for (int j = 0; j < nums2.length; j++) {
                int sum = nums1[i] + nums2[j];
                if (map1.containsKey(sum)) {
                    map1.put(sum, map1.get(sum) + 1);
                } else
                    map1.put(sum, 1);
            }
        }

        for (int i = 0; i < nums3.length; i++) {
            for (int j = 0; j < nums4.length; j++) {
                int sum = nums3[i] + nums4[j];
                int sum1 = 0 - sum;
                if(map1.containsKey(sum1)){
                    count += map1.get(sum1);
                }
            }
        }
        return count;
    }
}

7.3

383、赎金信

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        Map<Character, Integer> map = new HashMap<>();
        for(int i=0; i<magazine.length(); i++){
            char c = magazine.charAt(i);
            if(map.containsKey(c)){
                map.put(c, map.get(c)+1);
            }
            else{
                map.put(c, 1);
            }
        }
        for(int i=0; i<ransomNote.length(); i++){
            char c =ransomNote.charAt(i);
            if(!map.containsKey(c))
                return false;
            else if(map.get(c)==0){
                return false;
            }
            else{
                map.put(c, map.get(c)-1);
            }
        }
        return true;
    }
}

15、三数之和

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {

        Arrays.sort(nums);
        List<List<Integer>> list = new ArrayList<>();

        int left = 0; // 左指针
        
        for(left=0; left<nums.length-2; left++){

            if(nums[left]>0){
                break;
            } //左指针指向的数大于0直接返回
            if(left>0 && nums[left] == nums[left-1]){
                continue;
            } //去除左指针重复的数

            int right = nums.length - 1; // 右指针
            int i = left+1; // 移动指针

            while(i < right){
                int sum = nums[left] + nums[i] + nums[right];
                if(sum < 0){
                    i++;
                    continue;
                }
                if(sum>0){
                    right--;
                    continue;
                }
                if(sum == 0){
                    List<Integer> tmpList = new ArrayList<>();
                    tmpList.add(nums[left]);
                    tmpList.add(nums[i]);
                    tmpList.add(nums[right]);
                    list.add(tmpList);
                    while(i<right && nums[i]==nums[i+1]){
                        i++;
                    }
                    while(i<right && nums[right] == nums[right-1]){
                        right--;
                    }
                    i++;
                    right--;
                }
            }
        }
        return list;
    }
}

7.4

541、反转字符串II

class Solution {
    public String reverseStr(String s, int k) {
        char[] ch = s.toCharArray();
        for (int i = 0; i < ch.length; i += 2 * k) {
            if(i+k<=ch.length){
                reverse(ch, i, i+k-1);
                continue;
            }
            reverse(ch, i, ch.length-1);
        
        }
        return new String(ch);
    }

    public void reverse(char[] ch, int start, int end) {
        while(start < end){
            char tmp = ch[start];
            ch[start] = ch[end];
            ch[end] = tmp;
            start++;
            end--;
        }
    }
}

7.5

18、四数之和

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);

        int left1 = 0;
        int left2 = 1;
        for (; left1 < nums.length - 1; left1++) {
            if (nums[left1] > 0 && nums[left1] > target) {
                return result;
            }
            if (left1 > 0 && nums[left1 - 1] == nums[left1]) {
                continue;
            }
            for (left2 = left1 + 1; left2 < nums.length; left2++) {
                if (left2 > left1 + 1 && nums[left2 - 1] == nums[left2]) {
                    continue;
                }
                int i = left2 + 1;
                int right = nums.length - 1;
                while (i < right) {
                    int sum = nums[left1] + nums[left2] + nums[i] + nums[right];
                    if (sum < target) {
                        i++;
                        continue;
                    }
                    if (sum > target) {
                        right--;
                        continue;
                    }
                    if (sum == target) {
                        List<Integer> list = new ArrayList<>();
                        list.add(nums[left1]);
                        list.add(nums[left2]);
                        list.add(nums[i]);
                        list.add(nums[right]);
                        result.add(list);
                        while (i < right && nums[i + 1] == nums[i])
                            i++;
                        while (i < right && nums[right - 1] == nums[right])
                            right--;
                        i++;
                        right--;
                    }
                }
            }
        }
        return result;
    }
}

Epoch_C
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LeetCode刷题指南
weixin_70907010的博客
05-18 2241
CSDN话题挑战赛第1期 活动详情地址：https://marketing.csdn.net/p/bb5081d88a77db8d6ef45bb7b6ef3d7f 参赛话题：Leetcode刷题指南 话题描述：代码能力是一个程序员的基本能力，而除了做项目之外，大家接触到的最常规的提升代码能力的方法基本就是刷题了，因此，加油刷题，冲刺大厂！ 创作模板：Leetcode刷题指南 虽然题目是刷题指南，但实际上这是一篇面向新手的，主要讲如何比较系统地学习数据结构和算法的文章。就我个人来说，刷题（leetcod.
leetcode刷题方法
m0_46672151的博客
08-24 2045
leetcode刷题方法一、范围内的200题二、刷题步骤三、算法思路 此文章借鉴 陈同学在搬砖 微信公众号的一篇文章：https://mp.weixin.qq.com/s/xr2abGNv8wDZJ-qyN4KewQ. 一、范围内的200题 二、刷题步骤 传统刷题步骤： 1、想出解题大概思路 2、将思路转换成伪代码 3、将伪代码转换成具体代码 4、debug 这种刷题步骤相对来说比较耗时，所以针对目前我的情况来写出相应优化反方法。 首先对这200道题目只看不写，记住思路。 可以熟练记住每一道题的解法思
关于leetcode刷题详细介绍
热门推荐
智者之家
10-01 8万+
  虽然刷题一直饱受诟病，不过不可否认刷题确实能锻炼我们的编程能力，相信每个认真刷题的人都会有体会。现在提供在线编程评测的平台有很多，比较有名的有 hihocoder，LintCode，以及这里我们关注的 LeetCode。 LeetCode收录了许多互联网公司的算法题目，被称为刷题神器，我虽然早有耳闻，不过却一直没有上面玩过。   据了解，LeetCode 是一个非常棒的 OJ（Online J...
leetcode刷题规划
weixin_42986599的博客
12-15 603
leetcode刷题规划、总结、技巧、经验
leetcode 刷题指南 & 刷题顺序
qijingpei的博客
07-01 5342
leetcode 刷题指南
leetcode刷题方法&路径
weixin_44163570的博客
05-28 662
一开始刷题的时候不能够随便找个题就来做，应该一段时间专门突击某个专题，如“链表”、“二叉树”等。在刷题的过程中应该自己首先想一想，不要一没有思路就去网上找（这样刷题没有效果），自己思考半天试了一试还是做不出来就去百度。做过的题应该做笔记，反复看就跟高中做题一样，有错题本，反复看才有效果。
LeetCode刷题
平平淡淡，戒急用忍，一生学闭嘴。
08-30 248
目前上述内容已打包成完整电子书，具体获取方式如下： 关注 GitCube 公众号； 在 GitCube 后台回复关键词「小抄」获取下载地址： 除此之外，这里再跟大家推荐一本前不久火爆 GitHub 的 LeetCode 中文刷题手册：LeetCode Cookbook。 GitHub：https://github.com/halfrost/LeetCode-Go ...
LeetCode刷题攻略
Redemption___的博客
06-13 6541
应届生面试算法就考个数组 链表 二叉树 矩阵 数组变着法子考你排序 查询 指针 位运算 链表变着法子考你指针 最多再考个哈希 二叉树变着法子考用递归和栈前中后遍历 最多加上回溯 矩阵的话就是知道起点的路径查询和不知道起点的路径查询 掌握了这些 面大厂就比较轻松了 其实和学历技术关系也不大 大部分人先死到想都不敢想上了。 据了解，LeetCode 是一个非常棒的 OJ（Online Judge）平台，收集了许多公司的面试题目。相对其他 OJ 平台而言，有着下面的几个优点： 题目全部来自业内大公司的真.
LeetCode刷题python详解
w0714的博客
07-14 1万+
LeetCode刷题 最近想要练一练代码能力，得知LeetCode这个网站挺不错的，所以便开始刷题。 LeetCode中国网址 在这里主要就是练习一下python，其它编程语言可能基本不会涉及到。 从最简单的开始题——两数相加开始。 先附带一下题目： 首先是最简单也是最容易想到的解法： class Solution(object): def twoSum(self, nums, target): """ :type nums: List[int] :
LeetCode刷题开源手册
Linux,Java,SpringBoot,Python,Lua略知一点
12-13 1878
需要该PDF文档的朋友扫码关注下方二维码【入门小站】，回复 「1002」 四个字自取 当前面试各个互联网大厂除了扎实的编程技术外,还需要掌握常见的一些算法。搞不定就被无情的秒杀了。最近我花时间搜索了网络上流传的LeetCode刷题手册,找到一个覆盖面比较广的PDF文档,供大家学习参考。开源地址https://github.com/halfrost/LeetCode-Go(大佬写的开源书籍,Star 22.1k) 看完这本书内讲解的常见数据结构和算法，在 Leetcode 上遇到中等难度的题基本不.
（C++）LeetCode刷题题解答案
02-20
（C++）LeetCode刷题题解答案
LeetCode刷题笔记.rar
07-05
《LeetCode刷题笔记》是针对LeetCode这个在线编程挑战平台的个人学习心得与总结，主要涵盖数据结构和算法两大核心领域。LeetCode是一个全球知名的编程训练网站，它提供了丰富的编程题目，帮助开发者提升编程技能，...
LeetCode 刷题笔记 with Java.zip
11-23
《LeetCode刷题笔记withJava》是一份专为Java开发者准备的算法实战指南，涵盖了LeetCode网站上前一百道编程挑战题目。这份资料旨在帮助程序员提升算法能力，掌握数据结构和问题解决技巧，对于准备面试或者想要提升...
LeetCode刷题笔记
05-29
LeetCode全栈攻略：高效...无论你是初涉编程的新手，还是已经在技术领域有一定造诣的开发者，我都相信LeetCode刷题笔记能为你的成长之路增添一份力量！ 现在就加入我们的学习之旅吧，一起征服LeetCode的每一道题目！
LeetCode刷题手册
01-16
《LeetCode刷题手册》可能是一本指导如何有效刷题和提升算法编程能力的书籍。以下是可能包含在这本书中的主题： LeetCode介绍： 对LeetCode平台的简要介绍，包括网站功能、题目分类和评估系统。 算法基础： 提供...
力扣Hot100-994腐烂的橘子
qq_52241267的博客
08-10 361
由于在找到腐烂水果后直接将它周围的水果置为腐烂水果，但是可能当前轮次腐烂的水果，又在当前轮次中影响周围水果，导致错误，所以可以标记：在不同轮次中被传染腐烂的水果标记为不同的数字，由于一开始time=0时，腐烂水果标记为2，所以在time=0到1这段时间被传染的水果标记为2+time+1,这样就可以使得本轮time=0时不会让标记为3的水果传染它周围的水果。左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个方向上。因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0。
【LeetCode每日一题】——623.在二叉树中增加一行
IronmanJay的博客
08-14 813
给定一个二叉树的根 root 和两个整数 val 和 depth ，在给定的深度 depth 处添加一个值为 val 的节点行。 注意，根节点 root 位于深度 1 。 加法规则如下: 给定整数 depth，对于深度为 depth - 1 的每个非空树节点 cur ，创建两个值为 val 的树节点作为 cur 的左子树根和右子树根。 cur 原来的左子树应该是新的左子树根的左子树。 cur 原来的右子树应该是新的右子树根的右子树。 如果 depth == 1 意味着 depth - 1 根本没有深度
leetcode 103.二叉树的锯齿形层序遍历
m0_54244065的博客
08-09 896
2.做题思路:由题我们可以判断，树中每到偶数层时，就会逆置，所以我们可以采用层序遍历和逆置函数的方法来解此题。
【Hot100】LeetCode—76. 最小覆盖子串
最新发布
weixin_44382896的博客
08-14 300
【代码】【Hot100】LeetCode—76. 最小覆盖子串。
LeetCode刷题攻略：二分法与双指针模板
"LeetCode刷题模板.pdf" 这篇文档主要涵盖了LeetCode刷题中常见的两种算法模板——二分法和双指针法，并提供了相应的代码模板、关键属性和具体题目的应用示例。以下是对这两种方法的详细解释： 1. 二分法 - 什么...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值