《剑指Offer》笔记题解思路技巧优化 Java版本——新版leetcode_Part_3

news2024/12/25 23:39:27

《剑指Offer》笔记&题解&思路&技巧&优化_Part_3

  • 😍😍😍 相知
  • 🙌🙌🙌 相识
  • 😢😢😢 开始刷题
    • 1. LCR 138. 有效数字——表示数值的字符串
    • 2. LCR 139. 训练计划 I——调整数组顺序使奇数位于偶数前面
    • 3. LCR 140. 训练计划 II——链表中倒数第k个节点
    • 4. LCR 141. 训练计划 III——反转链表
    • 5. LCR 142. 训练计划 IV——合并两个排序的链表
    • 6. LCR 143. 子结构判断——树的子结构
    • 7. LCR 144. 翻转二叉树——二叉树的镜像
    • 8. LCR 145. 判断对称二叉树——对称的二叉树
    • 9. LCR 146. 螺旋遍历二维数组——顺时针打印矩阵
    • 10. LCR 147. 最小栈——包含min函数的栈

在这里插入图片描述

😍😍😍 相知

当你踏入计算机科学的大门，或许会感到一片新奇而陌生的领域，尤其是对于那些非科班出身的学子而言。作为一位非科班研二学生，我深知学习的道路可能会充满挑战，让我们愿意迎接这段充满可能性的旅程。

最近，我开始了学习《剑指Offer》和Java编程的探索之旅。这不仅是一次对计算机科学的深入了解，更是对自己学术生涯的一次扩展。或许，这一切刚刚开始，但我深信，通过努力与坚持，我能够逐渐驾驭这门技艺。

在这个博客中，我将深入剖析《剑指Offer》中的问题，并结合Java编程语言进行解析。

让我们一起踏上这段学习之旅，共同奋斗，共同成长。无论你是已经驾轻就熟的Java高手，还是像我一样初出茅庐的学子，我们都能在这里找到彼此的支持与激励。让我们携手前行，共同迎接知识的挑战，为自己的未来打下坚实的基石。

这是我上一篇博客的，也希望大家多多关注！

  1. 《剑指Offer》笔记&题解&思路&技巧&优化 Java版本——新版leetcode_Part_1
  2. 《剑指Offer》笔记&题解&思路&技巧&优化 Java版本——新版leetcode_Part_2

🙌🙌🙌 相识

根据题型可将其分为这样几种类型：

  1. 结构概念类（数组，链表，栈，堆，队列，树）
  2. 搜索遍历类（深度优先搜索，广度优先搜索，二分遍历）
  3. 双指针定位类（快慢指针，指针碰撞，滑动窗口）
  4. 排序类（快速排序，归并排序）
  5. 数学推理类（动态规划，数学）

😢😢😢 开始刷题

1. LCR 138. 有效数字——表示数值的字符串

题目跳转：https://leetcode.cn/problems/biao-shi-shu-zhi-de-zi-fu-chuan-lcof/description/

边界条件很多

学会函数：

  1. s = s.trim();
  2. char[] res = s.toCharArray();
class Solution {
    public boolean isNumber(String s) {
        if (s == null || s.length() == 0) return false;
        //去掉首尾空格
        s = s.trim();
        boolean numFlag = false;
        boolean dotFlag = false;
        boolean eFlag = false;
        for (int i = 0; i < s.length(); i++) {
            //判定为数字，则标记numFlag
            if (s.charAt(i) >= '0' && s.charAt(i) <= '9') {
                numFlag = true;
                //判定为.  需要没出现过.并且没出现过e
            } else if (s.charAt(i) == '.' && !dotFlag && !eFlag) {
                dotFlag = true;
                //判定为e，需要没出现过e，并且出过数字了
            } else if ((s.charAt(i) == 'e' || s.charAt(i) == 'E') && !eFlag && numFlag) {
                eFlag = true;
                numFlag = false;//为了避免123e这种请求，出现e之后就标志为false
                //判定为+-符号，只能出现在第一位或者紧接e后面
            } else if ((s.charAt(i) == '+' || s.charAt(i) == '-') 
            && (i == 0 || s.charAt(i - 1) == 'e' || s.charAt(i - 1) == 'E')) {

                //其他情况，都是非法的
            } else {
                return false;
            }
        }
        return numFlag;
    }
}

2. LCR 139. 训练计划 I——调整数组顺序使奇数位于偶数前面

题目跳转：https://leetcode.cn/problems/diao-zheng-shu-zu-shun-xu-shi-qi-shu-wei-yu-ou-shu-qian-mian-lcof/description/

class Solution {
    public int[] trainingPlan(int[] actions) {
        if(actions==null)return null;
        if(actions.length==0)return new int[0];
        int slow = 0;
        int fast = 0;
        while(fast<actions.length&&slow<actions.length){
            if(actions[slow]%2==0){
                while(fast<actions.length){
                    if(actions[fast]%2==1){
                        int temp = actions[fast];
                        for(int i = fast;i>slow;i--){
                            actions[i] = actions[i-1];
                        }
                        actions[slow] =temp;
                        
                        break;
                    }
                    else fast++;
                }
            }
            slow++;
            fast++;
            
        }
        return actions;
    }
}

在这里插入图片描述

class Solution {
    public int[] trainingPlan(int[] nums) {
        if(nums == null || nums.length == 0){
            return nums;
        }
        int left = 0;
        int right = nums.length - 1;
        while(left < right){
	        while(left < right && nums[left] % 2 != 0) left++;
	        while(left < right && nums[right] % 2 != 1) right--;
	        int temp = nums[left];
	        nums[left] = nums[right];
	        nums[right] = temp;
        }
        return nums;
    }
}

3. LCR 140. 训练计划 II——链表中倒数第k个节点

题目跳转：https://leetcode.cn/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/description/

/**
 * 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 trainingPlan(ListNode head, int cnt) {
        if(head==null) return null;
        if(head.next == null) return head;
        ListNode result = head;
        int num = 0;
        while(result!=null){
            num++;
            result = result.next;
        }
        num = num - cnt;
        while(num!=0){
            head = head.next;
            num--;
        }
        return head;
    }
}

来个牛逼的！

/**
 * 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 trainingPlan(ListNode head, int cnt) {
        if(head==null) return null;
        if(head.next == null) return head;
        ListNode slow = head;
        ListNode fast = head;
        for(int i = 0;i<cnt;i++){
            if(fast==null)return null;
            fast = fast.next;
        }
        while(fast!=null){
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }
}

4. LCR 141. 训练计划 III——反转链表

题目跳转：https://leetcode.cn/problems/fan-zhuan-lian-biao-lcof/description/

/**
 * 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 trainningPlan(ListNode head) {
        ListNode result = new ListNode(0);
        while(head!=null){
            ListNode temp = head;
            head = head.next;
            temp.next= result.next;
            result.next = temp;
        }
        return result.next;
    }
}

递归
在这里插入图片描述

class Solution {
    public ListNode trainningPlan(ListNode head) {
        if(head==null||head.next==null)return head;
        ListNode temp = trainningPlan(head.next);
        head.next.next = head;
        head.next= null;
        return temp;
    }
}

5. LCR 142. 训练计划 IV——合并两个排序的链表

题目跳转：https://leetcode.cn/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof/description/

/**
 * 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 trainningPlan(ListNode l1, ListNode l2) {
        if(l1==null)return l2;
        if(l2==null)return l1;
        ListNode result = new ListNode();
        ListNode temp = result;
        while(l1!=null||l2!=null){
            if(l1!=null&&l2!=null){
                if(l1.val<l2.val){
                    ListNode res = new ListNode(l1.val);
                    temp.next= res;
                    temp =temp.next;
                    l1 = l1.next;
                }
                else
                {
                    ListNode res = new ListNode(l2.val);
                    temp.next= res;
                    temp =temp.next;
                    l2 = l2.next;
                }
            }
            if(l1==null){
                temp.next =l2;
                break; 
            }
            if(l2==null){
                temp.next =l1;
                break; 
            }
        }
        return result.next;
    }
}

递归思路：
我们可以如下递归地定义两个链表里的 merge 操作（忽略边界情况，比如空链表等）：

{ l i s t 1 [ 0 ] + m e r g e ( l i s t 1 [ 1 : ] , l i s t 2 ) l i s t 1 [ 0 ] < l i s t 2 [ 0 ] l i s t 2 [ 0 ] + m e r g e ( l i s t 1 , l i s t 2 [ 1 : ] ) o t h e r w i s e \left\{ \begin{array}{ll} list1[0] + merge(list1[1:], list2) & list1[0] < list2[0] \\ list2[0] + merge(list1, list2[1:]) & otherwise \end{array} \right. {list1[0]+merge(list1[1:],list2)list2[0]+merge(list1,list2[1:])​list1[0]<list2[0]otherwise​

也就是说，两个链表头部值较小的一个节点与剩下元素的 merge 操作结果合并。

算法

我们直接将以上递归过程建模，同时需要考虑边界情况。

如果 l1 或者 l2 一开始就是空链表 ，那么没有任何操作需要合并，所以我们只需要返回非空链表。否则，我们要判断 l1 和 l2 哪一个链表的头节点的值更小，然后递归地决定下一个添加到结果里的节点。如果两个链表有一个为空，递归结束。

class Solution {
    public ListNode trainningPlan(ListNode l1, ListNode l2) {
        if (l1 == null) {
            return l2;
        } else if (l2 == null) {
            return l1;
        } else if (l1.val < l2.val) {
            l1.next = trainningPlan(l1.next, l2);
            return l1;
        } else {
            l2.next = trainningPlan(l1, l2.next);
            return l2;
        }
    }
}

6. LCR 143. 子结构判断——树的子结构

题目跳转：https://leetcode.cn/problems/shu-de-zi-jie-gou-lcof/description/

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSubStructure(TreeNode A, TreeNode B) {
        if(A==null||B==null)return false;
        if(isSub(A,B))return true;
        if(isSubStructure(A.left, B) || isSubStructure(A.right, B)){
            return true;
        }
        return false;
    }
    public boolean isSub(TreeNode TA,TreeNode TB){
        if(TB==null)return true;
        if(TA==null)return false;
        if(TA.val!=TB.val)return false;
        return isSub(TA.left,TB.left)&&isSub(TA.right,TB.right);
    }
}

7. LCR 144. 翻转二叉树——二叉树的镜像

题目跳转：https://leetcode.cn/problems/er-cha-shu-de-jing-xiang-lcof/description/

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        if(root==null)return root;
        if(root.right==null&&root.left==null)return root;
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
        root.right = mirrorTree(root.right);
        root.left = mirrorTree(root.left);
        return root;
    }

}

8. LCR 145. 判断对称二叉树——对称的二叉树

题目跳转：https://leetcode.cn/problems/dui-cheng-de-er-cha-shu-lcof/description/

/**
 * 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 boolean checkSymmetricTree(TreeNode root) {
        if(root==null)return true;
        if(root.left==null&&root.right==null)return true;
        if(root.right==null||root.left==null)return false;
        return check(root.left,root.right);
    }
    public boolean check(TreeNode A,TreeNode B){
        if(A==null&&B==null)return true;
        if(A==null||B==null)return false;
        if(A.val!=B.val)return false;
        return check(A.left,B.right)&&check(A.right,B.left);
    }
}

9. LCR 146. 螺旋遍历二维数组——顺时针打印矩阵

题目跳转：https://leetcode.cn/problems/shun-shi-zhen-da-yin-ju-zhen-lcof/description/

在这里插入图片描述
算法流程：

  • 空值处理： 当 array 为空时，直接返回空列表 [] 即可。
  • 初始化： 矩阵 左、右、上、下 四个边界 l , r , t , b ，用于打印的结果列表 res 。
  • 循环打印： “从左向右、从上向下、从右向左、从下向上” 四个方向循环打印；
    • 根据边界打印，即将元素按顺序添加至列表 res 尾部；
    • 边界向内收缩 1 （代表已被打印）；
    • 判断边界是否相遇（是否打印完毕），若打印完毕则跳出。
  • 返回值： 返回 res 即可。
打印方向1. 根据边界打印2. 边界向内收缩3. 是否打印完毕
从左向右左边界l ，右边界 r上边界 t 加 111是否 t > b
从上向下上边界 t ，下边界b右边界 r 减 111是否 l > r
从右向左右边界 r ，左边界l下边界 b 减 111是否 t > b
从下向上下边界 b ，上边界t左边界 l 加 111是否 l > r
class Solution {
    public int[] spiralArray(int[][] array) {
        if(array.length == 0) return new int[0];
        int l = 0, r = array[0].length - 1, t = 0, b = array.length - 1, x = 0;
        int[] res = new int[(r + 1) * (b + 1)];
        while(true) {
            for(int i = l; i <= r; i++) res[x++] = array[t][i]; // left to right
            if(++t > b) break;
            for(int i = t; i <= b; i++) res[x++] = array[i][r]; // top to bottom
            if(l > --r) break;
            for(int i = r; i >= l; i--) res[x++] = array[b][i]; // right to left
            if(t > --b) break;
            for(int i = b; i >= t; i--) res[x++] = array[i][l]; // bottom to top
            if(++l > r) break;
        }
        return res;
    }
}

按层模拟:
在这里插入图片描述

class Solution {
    public int[] spiralArray(int[][] array) {
        if (array == null || array.length == 0 || array[0].length == 0) {
            return new int[0];
        }
        int rows = array.length, columns = array[0].length;
        int[] order = new int[rows * columns];
        int index = 0;
        int left = 0, right = columns - 1, top = 0, bottom = rows - 1;
        while (left <= right && top <= bottom) {
            for (int column = left; column <= right; column++) {
                order[index++] = array[top][column];
            }
            for (int row = top + 1; row <= bottom; row++) {
                order[index++] = array[row][right];
            }
            if (left < right && top < bottom) {
                for (int column = right - 1; column > left; column--) {
                    order[index++] = array[bottom][column];
                }
                for (int row = bottom; row > top; row--) {
                    order[index++] = array[row][left];
                }
            }
            left++;
            right--;
            top++;
            bottom--;
        }
        return order;
    }
}

复杂度分析

  • 时间复杂度：O(mn)，其中 m 和 n 分别是输入二维数组的行数和列数。二维数组中的每个元素都要被访问一次。

  • 空间复杂度：O(1)。除了输出数组以外，空间复杂度是常数。

10. LCR 147. 最小栈——包含min函数的栈

题目跳转：https://leetcode.cn/problems/bao-han-minhan-shu-de-zhan-lcof/description/

class MinStack {

    /** initialize your data structure here. */
    int minstack = Integer.MAX_VALUE;;
    Stack<Integer> stack;
    public MinStack() {
        stack = new Stack<Integer>();
    }
    
    public void push(int x) {
        stack.push(minstack);
        minstack = x<minstack?x:minstack;
        stack.push(x);
    }
    
    public void pop() {
        stack.pop();
        minstack = stack.pop();

    }
    
    public int top() {
        return stack.peek();
    }
    
    public int getMin() {
        return minstack;
    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(x);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1452812.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【数据结构】17 二叉树的建立

【数据结构】17 二叉树的建立

二叉树的建立 由于树是非线性结构&#xff0c;创建一颗二叉树必须首先确定树中结点的输入顺序&#xff0c;常用方法是先序创建和层序创建。 层序创建所用的节点输入序列是按数的从上至下从左到右的顺序形成的各层的空结点输入数值0。在构造二叉树过程中需要一个队列暂时存储各…
阅读更多...
AI数据中心网络架构需求：400/800G光模块

AI数据中心网络架构需求：400/800G光模块

随着AI技术和相关应用的不断发展&#xff0c;大模型、大数据和AI计算能力在AI发展中的重要性日益凸显。大模型和数据集构成AI研究的软件基础&#xff0c;而AI算力是关键的基础设施。在本文中&#xff0c;我们将探讨AI发展对数据中心网络架构的影响。 Fat-Tree数据中心网络架构…
阅读更多...
《白话C++》第10章 STL和boost，Page67~70 std::auto_ptr

《白话C++》第10章 STL和boost，Page67~70 std::auto_ptr

std::auto_ptr可以不经意间转移裸指针控制权 std::auto_ptr持有裸指针的控制权&#xff0c;却可以随随便便看似不经意地转移给另一个auto_ptr: #include <iostream> #include <memory>using namespace std;struct S {int a;void SetA(int a){this->a a;}~S()…
阅读更多...
跟着pink老师前端入门教程（JavaScript）-day02

跟着pink老师前端入门教程（JavaScript）-day02

三、变量 &#xff08;一&#xff09;变量概述 1、什么是变量 白话&#xff1a;变量就是一个装东西的盒子 通俗&#xff1a;变量是用于存放数据的容器&#xff0c;通过变量名获取数据&#xff0c;甚至数据可以修改 2、变量在内存中的存储 本质&#xff1a;变量是程序在内存…
阅读更多...
记录：零基础小白初学云计算 第一天

记录：零基础小白初学云计算 第一天

一、认识【rootlocalhost ~】# root:当前登录用户的用户名 localhost&#xff1a;主机名 ~&#xff1a;当前用户的家目录 #&#xff1a;超级用户的命令提示符 基础命令 ifup ens33&#xff1a;启动网卡 ip a&#xff1a;查看IP地址 远程连接端口默认 &#xff1a;22 二…
阅读更多...
WordPress主题YIA移动端文章页的面包屑不显示怎么办？

WordPress主题YIA移动端文章页的面包屑不显示怎么办？

平时我们一般都会在文章页导航菜单下方显示面包屑&#xff0c;类似于“当前位置&#xff1a;boke112百科 WordPress 正文”。平时用浏览器调试站点的时候&#xff0c;在Edge浏览器的“切换设备仿真”中&#xff0c;不管是选择什么设备都会显示面包屑。具体如下图所示&#xf…
阅读更多...
C#，整数转为短字符串（Short string）的加解密算法与源代码

C#，整数转为短字符串（Short string）的加解密算法与源代码

1 整数转为短字符串的应用 网站生成的动态 URL 往往以内容序列号id为标识与参数&#xff0c;比如&#xff1a; http://www.jerry.com/tom.aspx?id1 使用 Web Rewrite&#xff0c;可以实现网页静态化&#xff0c;称为&#xff1a; http://www.jerry.com/content/1.html 对…
阅读更多...
论文阅读-PIM-tree：一种面向内存处理的抗偏移索引

论文阅读-PIM-tree：一种面向内存处理的抗偏移索引

论文名称&#xff1a;PIM-tree: A Skew-resistant Index for Processing-in-Memory 摘要 当今的内存索引性能受到内存延迟/带宽瓶颈的限制。Processing-in-memory (PIM) 是一种新兴的方法&#xff0c;可能通过实现低延迟内存访问&#xff0c;其聚合内存带宽随 PIM 节点数量扩…
阅读更多...
【Linux系统化学习】文件重定向

【Linux系统化学习】文件重定向

目录 文件内核对象 文件描述符的分配规则 重定向 重定向的概念 dup2系统调用 输出重定向 追加重定向 输入重定向 stderr解析 重定向到同一个文件中 分离常规输出和错输出 文件内核对象 上篇文章中我们介绍到了操作系统中的文件&#xff0c;操作系统为了方…
阅读更多...
react使用Map方法遍历列表不显示的问题

react使用Map方法遍历列表不显示的问题

问题&#xff1a; 在最开始搭建选项卡的时候&#xff0c;我的js代码是这样的 import React, { Component } from react import ./css/02-maizuo.css export default class App extends Component {state {list: [{id: 1,text: 电影},{id: 2,text: 影院}, {id: 3,text: 我的}…
阅读更多...
MySQL DQL 基本查询

MySQL DQL 基本查询

一.概念 数据查询不应只是简单返回数据库中存储的数据&#xff0c;还应该根据需要对数据进行筛选以及确定数据以什么样的格式显示。 二.语法格式 select 列名 from 表 where 条件 1.查询所有的商品 select * from product; 2.查询商品名和商品价格 select pname,price from…
阅读更多...
Quantitative Analysis: PIM Chip Demands for LLAMA-7B inference

Quantitative Analysis: PIM Chip Demands for LLAMA-7B inference

1 Architecture 如果将LLAMA-7B模型参数量化为4bit&#xff0c;则存储模型参数需要3.3GB。那么&#xff0c;至少PIM chip 的存储至少要4GB。 AiM单个bank为32MB&#xff0c;单个die 512MB&#xff0c;至少需要8个die的芯片。8个die集成在一个芯片上。 提供816bank级别的访存带…
阅读更多...
Docker 第十四章 ： Docker 三剑客之 Machine

Docker 第十四章 ： Docker 三剑客之 Machine

第十四章 ： Docker 三剑客之 Machine 本章知识点： Docker Machine 是 Docker 三剑客之一，它是一个工具，允许用户在本地或远程机器上创建 Docker 主机。它简化了 Docker 环境的设置，特别是在不同的操作系统和云平台上。通过 Docker Machine，用户可以轻松地在虚拟机或物理…
阅读更多...
《白话C++》第9章 泛型，Page842~844 9.4.2 AutoPtr

《白话C++》第9章 泛型，Page842~844 9.4.2 AutoPtr

源起&#xff1a; C编程中&#xff0c;最容易出的问题之一&#xff0c;就是内存泄露&#xff0c;而new一个对象&#xff0c;却忘了delete它&#xff0c;则是造成内存泄露的主要原因之一 例子一&#xff1a; void foo() {XXXObject* xo new XXXObject;if(!xo->DoSomethin…
阅读更多...
支付交易——跨境交易

支付交易——跨境交易

摘要 老王兢兢业业经营生意多年&#xff0c;一步步从小杂货店做到现在&#xff0c;成立大型贸易公司。在做大做强的过程中&#xff0c;老王觉得国内市场已经饱和&#xff0c;竞争处处是红海。老王留意海外很多年了&#xff0c;决定走出去&#xff0c;转向海外:将国外的商品引进…
阅读更多...
蓝桥杯官网填空题（寻找整数）

蓝桥杯官网填空题（寻找整数）

问题描述 本题为填空题&#xff0c;只需要算出结果后&#xff0c;在代码中使用输出语句将所填结果输出即可。 有一个不超过 10^17 的正整数 n&#xff0c;知道这个数除以 2 至 49 后的余数如下表所示&#xff0c;求这个正整数最小是多少。 运行限制 最大运行时间&#xff1a;…
阅读更多...
C/C++重点解析——内存管理

C/C++重点解析——内存管理

1. C/C内存分布 我们先来看一段代码和其相关问题&#xff1a; int globalVar 1; static int staticGlobalVar 1; void Test() {static int staticVar 1;int localVar 1;int num1[10] { 1, 2, 3, 4 };char char2[] "abcd";const char* pChar3 "abcd"…
阅读更多...
4 月 9 日至 4 月 10 日，Hack.Summit() 2024 首聚香江

4 月 9 日至 4 月 10 日，Hack.Summit() 2024 首聚香江

Hack.Summit() 是一系列 Web3 开发者大会。2024 年的活动将于 2024 年 4 月 9 日至 4 月 10 日在香港数码港举行。自十年前首次举办以来&#xff0c;此次会议标志着 Hack.Summit() 首次在亚洲举办&#xff0c;香港被选为首次亚洲主办城市&#xff0c;这对 Hack VC 和该地区都具…
阅读更多...
【大厂AI课学习笔记】【2.1 人工智能项目开发规划与目标】（4）数据准备的流程

【大厂AI课学习笔记】【2.1 人工智能项目开发规划与目标】（4）数据准备的流程

今天学习的是数据准备的流程。 我们已经知道&#xff0c;数据准备占了AI项目超过一半甚至79%的时间。 那么数据准备&#xff0c;都做些什么&#xff0c;有哪些流程。 1.数据采集 观测数据人工收集调查问卷线上数据库 2.数据清洗 有缺失的数据有重复的数据有内容错误的数据…
阅读更多...
Filezilla:文件无法传输的问题

Filezilla:文件无法传输的问题

问题 解决方法 我发现我站点管理器原本设置的是FTP, 改成了SFTP就可以正常传输 FTP和SFTP 安全通道&#xff1a;FTP不提供安全通道&#xff0c;SFTP提供安全通道。 传输协议&#xff1a;FTP使用TCP/IP协议&#xff0c;SFTP是SSH协议的一部分。 最后由于SFTP使用了加密解密技…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023