每周算法（week2）【leetcode11~30】

 前言

        本该两周完成的30道算法题没想到5天就完成了，接下来继续刷算法，保持手感，对不熟悉的基础算法二分、搜索还得继续练。

leetcode 编号完成时间复习时间
11. 盛水最多的容器2024-07-02
12. 整数转罗马数字2024-07-02
13. 罗马数字转整数2024-07-02
14. 最长公共前缀2024-07-02
15. 三数之和2024-07-02
16、最接近的三数之和

2024-07-03

17、电话号码的字母组合2024-07-03
18、四数之和2024-07-03
19、删除链表倒数第N个节点2024-07-03
20、有效的括号2024-07-04
21、合并两个有序的链表2024-07-04
23、合并K个升序链表2024-07-05
24、两两交换链表中的节点2024-07-05
25、K个一组翻转链表2024-07-05
26、删除有序数组中的重复项2024-07-05
27、移除元素
28、找出字符串中第一个匹配项的下标2024-07-05
30、串联所有单词的子串2024-07-05

11、盛水最多的容器（双指针）

11.1、暴力枚举

思路💡：枚举每种左右高度的组合，直到取到最大值
时间复杂度🕖：O（n2）

class Solution {public int maxArea(int[] height) {int max = 0;for(int i=0;i<height.length-1;i++){for(int j=i+1;j<height.length;j++){int high = Math.min(height[i],height[j]);int width = j-i;max = Math.max(max,high*width);}}return max;}
}

 11.2、双指针

思路💡：左右指针

  • 虽然指针每移动一次，容器的宽度 -1，但是如果移动得到的"回报"——边界的高度变得更高，那就是值得的

时间复杂度🕖： O（N）

class Solution {public int maxArea(int[] height) {int max = 0;int left = 0,right = height.length - 1;while(left < right){int area = Math.min(height[left],height[right])*(right-left);if(height[left] <= height[right]){left++;}else{right--;}max = Math.max(max,area);}return max;}
}

12、整数转罗马数字（数学 + 模拟）

12.1、模拟

思路💡：从千位到个位，对每一位进行逻辑模拟
时间复杂度🕖：O（1）

class Solution {static Map<Integer,Character> map = new HashMap<>();static{map.put(1,'I');map.put(5,'V');map.put(10,'X');map.put(50,'L');map.put(100,'C');map.put(500,'D');map.put(1000,'M');}public String intToRoman(int num) {StringBuilder sb = new StringBuilder();if(String.valueOf(num).length()>3){int q = num/1000;while(q!=0){sb.append(map.get(1000));q--;}num %= 1000;}if(String.valueOf(num).length()>2){int b = num/100;while(b!=0) {if(b >=5 && b < 9) {sb.append(map.get(500));b-=5;}else if(b==4) {sb.append("CD");break;}else if(b==9) {sb.append("CM");break;}else {while(b!=0){sb.append(map.get(100));b--;}	}	}  num %= 100;}if(String.valueOf(num).length()>1){int s = num/10;while(s!=0) {if(s<9 &&  s>=5){sb.append(map.get(50));s-=5;}else if(s==4){sb.append("XL");break;}else if(s==9){sb.append("XC");break;}else{while(s != 0){sb.append(map.get(10));s--;}}}num %= 10;}while(String.valueOf(num).length()>0 && num>0){if(num <9 && num >= 5){sb.append(map.get(5));num-=5;}else if(num == 4){sb.append("IV");break;}else if(num == 9){sb.append("IX");break;}else{while(num!=0){sb.append("I");num--;}}}return sb.toString();}
}

13、罗马数字转整数（模拟）

13.1、模拟

思路💡：从高位到低位，在判断当前位对应数值的同时向低一位判断一下，因为罗马数字只有相邻位置可以进行减法表示（比如 49 可以表示为 IX）
时间复杂度🕖：O（1）

class Solution {static Map<Character,Integer> map = new HashMap<>();static{map.put('I',1);map.put('V',5);map.put('X',10);map.put('L',50);map.put('C',100);map.put('D',500);map.put('M',1000);}public int romanToInt(String s) {int res = 0;int index = 0;while(index+1<s.length()){if(map.get(s.charAt(index)) >= map.get(s.charAt(index+1))){res += map.get(s.charAt(index));index++;}else{res += (map.get(s.charAt(index+1)) - map.get(s.charAt(index)));index+=2;}}if(index < s.length()){res += map.get(s.charAt(index));}return res;}
}

14、最长公共前缀（二分搜索）

14.1、枚举

思路💡：木桶原理，最长公共前缀取决于"最混蛋"的那个字符串（任意一个字符串的第 1 个前缀字符和别的字符串不一样，就算别的 9999 个字符串都完全一样也没用，它们的公共前缀就是 0）。所以我们可以拿任意一个字符串当做模板和别的所有字符串进行对比。

时间复杂度🕖：O(mn)，其中 m 是字符串数组中的字符串的平均长度，n 是字符串的数量。

class Solution {public String longestCommonPrefix(String[] strs) {char[] prefix = strs[0].toCharArray();StringBuilder sb = new StringBuilder();for(char c : prefix){sb.append(c);for(String str : strs){if(!str.startsWith(sb.toString())){return sb.substring(0,sb.length()-1).toString();}}}return sb.toString();}
}

14.2、二分搜索

思路💡：前缀的长度范围超不出数组中最短的字符串长度，所以使用二分不断寻找可能的 mid 值，也就是最长的前缀长度

时间复杂度🕖：二分查找的迭代执行次数是 O(logm)，每次迭代最多需要比较 mn 个字符，因此总时间复杂度是 O(mnlogm)。其中 m 是字符串数组中的字符串的最小长度，n 是字符串的数量。

知识点🙉：这里的二分搜索是左闭右闭的，所以 while 条件是 left < right，而不是 left <= right；

class Solution {public String longestCommonPrefix(String[] strs) {int minLength = Integer.MAX_VALUE;for(String str : strs)minLength = Math.min(minLength,str.length());int left = 0,right = minLength;while(left < right){// (right - left + 1) 中 +1 的原因是我们mid的意义是长度,而不是索引int mid = (right - left + 1) / 2 + left;if(isSamePrefix(strs,mid))left = mid;elseright = mid - 1;}return strs[0].substring(0,left);}public boolean isSamePrefix(String[] strs,int length){String suffix = strs[0].substring(0,length);for(int i=1;i<strs.length;i++)if(!strs[i].startsWith(suffix))return false;return true;}
}

15、三数之和（双指针）

15.1、暴力枚举

思路💡：三层遍历

时间复杂度🕖：O（n3）

知识点🙉：这里唯一收获的东西就是：使用 list.contains() 判断元素相同的集合对象进行去重

class Solution {List<List<Integer>> res = new ArrayList<>();public List<List<Integer>> threeSum(int[] nums) {for(int i=0;i < nums.length-2;i++){for(int j=i+1;j < nums.length-1;j++){for(int k=j+1;k < nums.length;k++){if(nums[i]+nums[j]+nums[k]==0){put(nums[i],nums[j],nums[k]);}}}}return res;}public void put(int v1,int v2,int v3){List<Integer> list = new ArrayList<>();list.addAll(Arrays.asList(v1,v2,v3));Collections.sort(list);if(!res.contains(list)) res.add(list);}
}

15.2、双指针

思路💡：

  • 首先对数组排序，不然无法判断指针应该如何移动
  • 这道题在使用双指针时有一个特别需要注意的就是：当左指针或右指针对应当前值和下一个值相同时，得到的结果会有重复，所以在每次循环前后都会对重复值进行处理

时间复杂度🕖：O（n2）

class Solution {public List<List<Integer>> threeSum(int[] nums) {int n = nums.length;List<List<Integer>> ans = new ArrayList<List<Integer>>();Arrays.sort(nums);//确定第一个数for(int i = 0;i < n ;i ++){// 当起始的值等于前一个元素，那么得到的结果将会和前一次相同if(i != 0 && nums[i] == nums[i - 1]) continue;int l = i + 1,r = n - 1;while(l < r){int sum = nums[i] + nums[l] + nums[r];if(sum > 0) {r --;continue;}if(sum < 0){l ++;continue;}//sum == 0时ans.add(Arrays.asList(nums[i],nums[l],nums[r]));//去除重复处理do {l ++;} while(l < r && nums[l] == nums[l - 1]);do {r --;} while(l < r && nums[r] == nums[r + 1]);}}return ans;}
}

16、最接近的三数之和（双指针）

16.1、双指针

思路💡：首先对数组进行排序，然后枚举三数之和中的第一个数字，剩下的两个数字用左右指针寻找，不断逼近和目标值最近的两个数

时间复杂度🕖：O（n2）

class Solution {public int threeSumClosest(int[] nums, int target) {Arrays.sort(nums);int ans = Integer.MAX_VALUE;for(int i=0;i<nums.length;i++){int l = i+1,r = nums.length-1;while(l < r){int sum = nums[i] + nums[l] + nums[r];ans = Math.abs(sum-target)<Math.abs(ans-target)?sum:ans;if(sum > target)    r--;else if (sum < target)  l++;else if (sum == target) return target;}}return ans;}
}

17、电话号码的字母组合（深搜）

17.1、深度优先搜索

思路💡：组合问题，直接深搜

时间复杂度🕖：O(3^m ×4^n )，其中 m 是输入中对应 3 个字母的数字个数（包括数字 2、3、4、5、6、8），n 是输入中对应 4 个字母的数字个数（包括数字 7、9）

class Solution {Map<Integer, Character[]> map = new HashMap<Integer, Character[]>();{int index = 'a';for (int i = 2; i < 7; i++) {Character[] arr = new Character[3];for (int j = 0; j < arr.length; j++) arr[j] = (char)index++;map.put(i, arr);}map.put(7, new Character[]{'p','q','r','s'});map.put(8, new Character[]{'t','u','v'});map.put(9, new Character[]{'w','x','y','z'});}List<String> res = new ArrayList<>();List<String> letterCombinations(String digits) {if(digits.length()==0) return res;backtrack(digits,0,"");return res;}public void backtrack(String digits,int index,String str){if(index == digits.length()){res.add(str);return;}for(char s : map.get(Integer.parseInt(""+digits.charAt(index)))){backtrack(digits,index + 1,str + s);}}
}

18、四数之和（双指针）

18.1、双指针

思路💡：同样对数组先排序，前两个数使用枚举，后两个数用双指针优化

时间复杂度🕖：O（n3）

class Solution {public List<List<Integer>> fourSum(int[] nums, int target) {List<List<Integer>> list = new ArrayList<>();if(nums.length == 0) return new ArrayList<>();int n = nums.length;Arrays.sort(nums);// 定下nums[i]for(int i = 0;i < n;i++){// 去重if(i != 0 && nums[i] == nums[i - 1]) continue;// 定下nums[j]for(int j = i + 1;j < n - 2;j++){// 去重if(j != i+1 && nums[j] == nums[j-1]) continue;int k = j + 1,m = n-1;// 双指针while(k < m){int sum = nums[i] + nums[j] + nums[k] + nums[m];if(sum > target){m--;continue;}if(sum < target){k++;continue;}else if(sum == target){list.add(Arrays.asList(nums[i],nums[j],nums[k],nums[m]));}// 去重do{k++;}while(k < m && nums[k] == nums[k - 1]);do{m--;}while(k < m && nums[m] == nums[m + 1]);}}}return list;}
}

19、删除链表最后一个节点

思路💡：删除倒数第 N 个节点就是删除正数第 L - N +1 个节点

时间复杂度🕖：O（L），L 是链表的长度

class Solution {public ListNode removeNthFromEnd(ListNode head, int n) {// 如果链表只有一个元素还要删除就直接返回空if(head.next == null && n==1) return null;// 计算链表的长度ListNode t1 = head;int len = 1;while(t1.next != null){len++;t1 = t1.next;}int target = len - n + 1; // 倒数第n个就是正数第(len-n+1)个元素int cur = 1; // 当前节点位置if(cur == target) return head.next; // 如果当前位置就是要删除的元素就直接返回下一个节点t1 = head; // 重新初始化while(cur != target-1){ // 找到要删除的目标节点的前一个节点t1 = t1.next;cur++;}// 如果目标节点的下一个节点为空就置当前节点的下一个节点为空 否则连接下下一个节点if(t1.next.next != null) t1.next = t1.next.next; else t1.next = null;return head;}
}

20、有效的括号

20.1、栈

思路💡：右括号总是出现在第偶数次的，否则说明括号不合法

时间复杂度🕖：O（N）

class Solution {public boolean isValid(String s) {if(s.length() %2 != 0) return false;Map<Character,Character> map = new HashMap<>();map.put(')','(');map.put('}','{');map.put(']','[');Deque<Character> stack = new ArrayDeque<>(); for(int i=0;i<s.length();i++){if(i!=0 && stack.peek()!=null && stack.peek() == map.get(s.charAt(i))){stack.pop();continue;}stack.push(s.charAt(i));}return stack.size() == 0;}
}

21、合并两个有序链表 

思路💡：借助一个中间指针，穿针引线

时间复杂度🕖：O（L），L 是链表的长度

class Solution {public ListNode mergeTwoLists(ListNode list1, ListNode list2) {if(list1==null) return list2;if(list2==null) return list1;ListNode dummy = new ListNode();ListNode cur = dummy;while(list1 != null && list2!=null){if(list1.val <= list2.val){cur.next = list1;list1 = list1.next;}else{cur.next = list2;list2 = list2.next;}cur = cur.next;}cur.next = list1==null?list2:list1;return dummy.next;}
}

23、合并K个有序链表

思路💡：把链表问题转为数组问题

时间复杂度🕖：O（n2）

class Solution {public ListNode mergeKLists(ListNode[] lists) {if(lists ==null || lists.length==0) return null;List<Integer> list = new ArrayList<>();for(ListNode node : lists){while(node != null){list.add(node.val);node = node.next;}}Collections.sort(list);ListNode res = new ListNode();if(list.size()==0) return null;ListNode t = new ListNode(list.get(0));res.next = t;for(int n: list){t.next = new ListNode(n);t = t.next;}return res.next.next;}
}

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

思路💡：把链表问题转为数组问题

时间复杂度🕖：O（n2）

class Solution {public ListNode swapPairs(ListNode head) {if(head==null || head.next==null) return head;// 1.把链表转为数组// 1.1求出链表的深度ListNode t = head;int len = 0;while(t != null){len++;t = t.next;}// 1.2 创建数组并赋值int[] arr = new int[len];int index = 0;t = head;while(t != null){arr[index++] = t.val;t = t.next;}// 2.交换数组(链表)中的节点for(int i=0;i+1<len;i+=2){swap(arr,i,i+1);}// 3. 把数组转为链表返回ListNode res =  new ListNode();ListNode a =  new ListNode(arr[0]);res.next = a;for(int i=1;i<len;i++){a.next = new ListNode(arr[i]);a = a.next;}return res.next;}void swap(int[] arr,int i, int j){arr[i] ^= arr[j];arr[j] ^= arr[i];arr[i] ^= arr[j];}
}

25、K个一组翻转链表

思路💡：把链表问题转为数组问题，使用双指针翻转元素

时间复杂度🕖：O（N）

class Solution {public ListNode reverseKGroup(ListNode head, int k) {// 1. 将链表转为数组ListNode t = head;int len = 0;while(t != null){len++;t = t.next;} int[] nums = new int[len];t = head; // 重新初始化int index = 0;while(t!=null){nums[index++] = t.val;t = t.next;}// 比如3个一组，但是数组长度是5，我们只需要翻转前3个，因为剩下的凑不够一组int range = len/k*k;for(int i=0;i<range;i+=k){int l = i,r = i+k-1;while(l < r){ // 双指针翻转元素nums[l] ^= nums[r];nums[r] ^= nums[l];nums[l] ^= nums[r];l++;r--;}}ListNode res = new ListNode();ListNode a = new ListNode(nums[0]);res.next = a;// 把数组组合成链表for(int i=1;i<nums.length;i++){a.next = new ListNode(nums[i]);a = a.next;}return res.next;}}

26、删除有序数组中的重复项

思路💡：快慢指针

时间复杂度🕖：O（N）

class Solution {public int removeDuplicates(int[] nums) {if(nums.length == 1) return 1;int l = 0,r = 0;while(r < nums.length){// 直到找到和左指针指向不同的值while(r<nums.length && nums[r]==nums[l])    r++;// 防止越界if(r >= nums.length) break;// 判断是否重复,把不重复的数据前移if(r - l > 1)   nums[l+1] = nums[r];l++;r++;}return l+1; // 返回去重后原数组的长度}
}

27、移除元素（快慢指针）

思路💡：使用两个指针，慢指针负责从索引 0 重新给数组赋值，快指针负责找非目标值

时间复杂度🕖：O（N）

class Solution {public int removeElement(int[] nums, int val) {int l = 0;for (int r = 0; r < nums.length; r++)if (nums[r] != val)nums[l++] = nums[r];return l;}
}

28、找出字符串中第一个匹配项的下标（字符串）

思路💡：substring 遍历

时间复杂度🕖：O（n * m），其中 n 是 haystack 的长度，m 是neddle 的长度

class Solution {public int strStr(String haystack, String needle) {for(int i=0;i<=haystack.length()-needle.length();i++){if(haystack.substring(i,i+needle.length()).equals(needle)){return i;}}return -1;}
}

30、串联所有单词的子串

思路💡：使用回溯法得到数组元素的全排列，然后遍历字符串的子串查看是否能够匹配

时间复杂度🕖：

class Solution {boolean[] visits;HashSet<Integer> set = new HashSet<>(); // 因为数组中可能包含重复，所以全排列中可能有重复值List<Integer> ans;List<List<String>> tracks = new ArrayList<List<String>>();public List<Integer> findSubstring(String s, String[] words) {visits = new boolean[words.length];LinkedList<String> track = new LinkedList<>();backtrack(track,words);for (List<String> list : tracks) {StringBuilder sb = new StringBuilder();for(String word : list) {sb.append(word);}check(s,sb.toString());}ans = new ArrayList<Integer>(set);return ans;}public void check(String s,String ch) {for(int i=0;i<s.length();i++) {if(i+ch.length()<=s.length() && ch.charAt(0) == s.charAt(i) && s.substring(i,i+ch.length()).equals(ch)) {set.add(i);}}}public void backtrack(LinkedList<String> track,String[] words) {if(track.size()==words.length) {LinkedList<String> res = new LinkedList<>(track);tracks.add(res);return;}for (int i = 0; i < words.length; i++) {// if(track.contains(words[i])) continue; // 这里不能这么用，因为包含重复元素if(visits[i]) continue;track.add(words[i]);visits[i] = true;backtrack(track, words);track.removeLast();visits[i] = false;}}
}

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

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

相关文章

计算机大方向的选择

计算机大方向的选择

选专业要了解自己的兴趣所在。 即想要学习什么样的专业&#xff0c;如果有明确的专业意向&#xff0c;就可以有针对性地选择那些专业实力较强的院校。 2.如果没有明确的专业意向&#xff0c;可以优先考虑一下院校。 确定一下自己想要选择综合性院校还是理工类院校或是像财经或者…
阅读更多...
从 Keycloak 导出和导入 Realm 和用户

从 Keycloak 导出和导入 Realm 和用户

1. 首先对keycloak 命令有所了解 需要将 Keycloak 中的 Realm 导出或导入时&#xff0c;您可以使用 JSON 文件进行操作。以下是一些有关导出和导入 Realm 的方法&#xff1a; 导出 Realm 到目录&#xff1a; 使用 export 命令将 Realm 导出到目录。在执行此命令时&#xff0c;…
阅读更多...
技术分享：直播平台如何开发并接入美颜SDK

技术分享：直播平台如何开发并接入美颜SDK

本篇文章&#xff0c;笔者将分享直播平台如何开发并接入美颜SDK的技术细节与步骤。 一、选择合适的美颜SDK 首先&#xff0c;选择一款适合的美颜SDK非常重要。市面上有很多优秀的美颜SDK供应商&#xff0c;选择时应考虑以下因素&#xff1a; 功能丰富性&#xff1a;支持美白…
阅读更多...
短视频文案提取神器怎么提取抖音视频文案！

短视频文案提取神器怎么提取抖音视频文案！

很多编导以及视频内容创作者为了提高自己的工作效率还会使用视频转文字提取神器&#xff0c;我们都清楚短视频领域每个平台人群熟悉都有所不同&#xff0c;在分发内容的时候也会调整内容已符合平台属性。 短视频文案提取神器怎么提取抖音视频文案 短视频常见的平台有抖音、西瓜…
阅读更多...
linux ifconfig未找到命令

linux ifconfig未找到命令

linux ifconfig未找到命令 1、使用yum安装net-tools yum install net-toolsyum报未找到命令请查看文章vim未找到命令&#xff0c;且yum install vim安装vim失败 2、安装后使用ifconfig命令 ifconfig
阅读更多...
windows实现Grafana+Loki+loki4j轻量级日志系统，告别沉重的ELK

windows实现Grafana+Loki+loki4j轻量级日志系统，告别沉重的ELK

文章目录 Loki下载Loki下载安装Loki添加Loki数据源springboot日志推送 Loki下载 下载地址&#xff1a;https://github.com/grafana/loki/releases/ 找到loki-windows-amd64.exe.zip点击开始下载&#xff0c;我这里下载的2.9.9版本 Loki下载 下载地址&#xff1a;https://gr…
阅读更多...
springboot苏桦旅游管理系统-计算机毕业设计源码02123

springboot苏桦旅游管理系统-计算机毕业设计源码02123

摘要 旅游业在全球范围内不断发展&#xff0c;为了提供高效的旅游管理和服务&#xff0c;开发一个旅游管理系统具有重要意义。本文旨在设计和实现该旅游管理系统&#xff0c;以满足用户和管理员的需求。该系统采用Spring Boot作为后端框架&#xff0c;利用其简化的开发流程和强…
阅读更多...
暑假即将上映的电影——浔川电影报

暑假即将上映的电影——浔川电影报

作为全年最长的电影档期&#xff0c;暑期档目前已经启动。根据统计&#xff0c;定档暑期档的电影已超过100部&#xff0c;而观众的观影热情正在逐步升温。据灯塔专业版数据显示&#xff0c;截至7月4日14时50分&#xff0c;2024年暑期档期&#xff08;6月1日-8月31日&#xff09…
阅读更多...
通过百度文心智能体创建STM32编程助手-实操

通过百度文心智能体创建STM32编程助手-实操

一、前言 文心智能体平台AgentBuilder 是百度推出的基于文心大模型的智能体&#xff08;Agent&#xff09;平台&#xff0c;支持广大开发者根据自身行业领域、应用场景&#xff0c;选取不同类型的开发方式&#xff0c;打造大模型时代的产品能力。开发者可以通过 prompt 编排的…
阅读更多...
【并发编程JUC】AQS详解

【并发编程JUC】AQS详解

定义理解 AQS&#xff0c;全称为AbstractQueuedSynchronizer&#xff0c;是Java并发包&#xff08;java.util.concurrent&#xff09;中的一个框架级别的工具类&#xff0c;用于构建锁和同步器。它是许多同步类的基础&#xff0c;如ReentrantLock、Semaphore、CountDownLatch等…
阅读更多...
相关技术 太阳能热水器循环水泵制作技术

相关技术 太阳能热水器循环水泵制作技术

网盘 https://pan.baidu.com/s/1oAKwUEGkKnEgxE-F4znKow?pwdidxd 双温区蓄能供热型太阳能热水系统及其工作方法.pdf 双罐叠压节能恒温型太阳能热水机组.pdf 基于傅科电流的循环式风能热水器.pdf 基于太阳能利用的建筑冷热电联产系统及工作方法.pdf 基于太阳能和热泵的双蓄式热…
阅读更多...
C++ function bind 学习笔记

C++ function bind 学习笔记

文档声明&#xff1a; 以下资料均属于本人在学习过程中产出的学习笔记&#xff0c;如果错误或者遗漏之处&#xff0c;请多多指正。并且该文档在后期会随着学习的深入不断补充完善。感谢各位的参考查看。 笔记资料仅供学习交流使用&#xff0c;转载请标明出处&#xff0c;谢谢配…
阅读更多...
使用Selenium进行Web应用自动化测试

使用Selenium进行Web应用自动化测试

自动化测试是现代软件开发中不可或缺的一部分&#xff0c;它可以帮助我们快速、准确地验证软件的功能。Selenium是一个广泛使用的自动化测试工具&#xff0c;特别适用于Web应用程序。本文将详细介绍如何使用Selenium进行Web应用自动化测试&#xff0c;并提供丰富的Java代码示例…
阅读更多...
C++:特殊类的设计(无线程）

C++:特殊类的设计(无线程）

目录 一、设计一个不能拷贝类 二、设计一个只能在堆上创建对象的类 方法一&#xff1a;析构函数私有化 方法二&#xff1a;构造函数私有化 三、设计一个只能在栈上创建对象的类 四、设计一个类不能被继承 五、设计一个只能创建一个对象的类&#xff08;单例模式&#xf…
阅读更多...
海思SS928（SD3403）内存地址空间分配和使用

海思SS928（SD3403）内存地址空间分配和使用

说明 所有 DDR 内存中&#xff0c;一部分由操作系统管理&#xff0c;称为 OS 内存&#xff1b;另一部分由 MMZ 模块管理&#xff0c;供媒体业务单独使用&#xff0c;称为 MMZ 内存。具体描述参考《SS928V100 SDK 安装以及升级使用说明.pdf》的“第5部分 地址空间分配与使用”。…
阅读更多...
数学建模MATLAB绘图大全

数学建模MATLAB绘图大全

最近快要开始一年一度的数学建模竞赛啦&#xff0c;接下来争取每天更一篇数学建模算法&#xff01;&#xff08;当然这是理想状态下&#xff09;&#xff0c;今天就先更一些MATLAB常用的绘图吧&#xff0c;论文赏心悦目的关键就在于丰富多彩的图&#xff0c;好看的图一定会成为…
阅读更多...
景区智慧公厕，剩余厕位显示，公厕环境监测。

景区智慧公厕，剩余厕位显示，公厕环境监测。

在当今科技飞速发展的时代&#xff0c;景区的服务设施也在不断升级和创新。其中&#xff0c;景区智慧公厕的出现无疑为游客带来了极大的便利。特别是剩余厕位显示和公厕环境监测这两大功能&#xff0c;更是显著提升了景区公厕的管理水平和游客的使用体验。 剩余厕位显示功能是景…
阅读更多...
磁钢生产领域上下料解决方案

磁钢生产领域上下料解决方案

随着智能制造技术的不断革新&#xff0c;磁钢生产领域正逐步引入自动化生产线。然而&#xff0c;传统的人工上下料方式存在诸多问题&#xff0c;难以满足现代生产需求。富唯智能提出了一款复合机器人磁钢上下料解决方案&#xff0c;通过先进的自动化技术&#xff0c;提高生产效…
阅读更多...
一款纯 js 实现的大模型应用服务 FastGPT 解读

一款纯 js 实现的大模型应用服务 FastGPT 解读

背景介绍 最近被不同的人安利了 FastGPT 项目&#xff0c;实际上手体验了一下&#xff0c;使用流程类似之前调研过的 Dify, 包含的功能主要是&#xff1a;任务流的编排&#xff0c;知识库管理&#xff0c;另外还有一些外部工具的调用能力。使用页面如下所示&#xff1a; 实际…
阅读更多...
前端实现坐标系转换

前端实现坐标系转换

一、地理坐标系和投影坐标系 地理坐标系和投影坐标系是地理信息系统&#xff08;GIS&#xff09;中常见的两种坐标系统&#xff0c;它们用于描述和定位地球表面上的点和区域&#xff0c;但在实现方式和应用场景上有所不同。 1. 地理坐标系&#xff08;Geographic Coordinate …
阅读更多...
最新文章

Copyright @ 2022~2023