【LeetCode】嚼烂热题100【持续更新】

2、字母异位词分组

 方法一：排序+哈希表

思路：对每个字符串排序，排序后的字符串作为键插入到哈希表中，值为List<String>形式存储单词原型，键为排序后的字符串。

 Map<String, List<String>> m = new HashMap<>();

难点（重点）：

1、排序字符串

字符串本身不能直接排序，需要先利用str.toCharArray()转换成为char[]，再利用Arrays.sort(s)；完成排序，但排序完的s就是char[]形式的。

2、哈希表map已有的接口computeIfAbsent(Key,Function)

map.computeIfAbsent(Key, Function)
  • ​​若键存在​​：直接返回对应的值（在本题中返回的就是对应的列表）。
  • ​​若键不存在​​：调用 Function 生成新值（本题中就是生成一个空的列表作为新的键对应的值），将键值对存入 Map，并返回新值。

这个方法的平替：但也需要知道map.getOrDefault（）方法

 List<String> list = map.getOrDefault(key, new ArrayList<String>());list.add(str);map.put(key, list);

值得注意的是：这个Key需要对应map的键值的类型。不能用char[]作为键的类型，因为所有数组类型（如 char[]）继承自 Object，其 hashCode() 和 equals() 基于对象地址（而非内容）。

键可以选用基本类型和部分引用类型：

3、返回值要是List<List<String>>，

​​Map.values()的返回值是类型为Collection<List<String>>的所有 ​​值（List<String>）​​ 的集合。要返回List<List<String>>只需要新建一个ArrayList<>（map.values()）即可。

class Solution {public List<List<String>> groupAnagrams(String[] strs) {Map<String, List<String>> m = new HashMap<>();for (String str : strs) {char[] s = str.toCharArray();Arrays.sort(s);// s 相同的字符串分到同一组m.computeIfAbsent(new String(s), k -> new ArrayList<>()).add(str);}return new ArrayList<>(m.values());}
}

3、 最长连续序列

给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。

请你设计并实现时间复杂度为 O(n) 的算法解决此问题。

输入：nums = [100,4,200,1,3,2]
输出：4
解释：最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。
class Solution {public int longestConsecutive(int[] nums) {Arrays.sort(nums);int ans = 1;int n = nums.length;if(n==0){return 0;}int tmp = nums[0];int count = 1;for(int i = 1;i<n;i++){if(nums[i]==tmp+1){count++;ans = Math.max(ans,count);tmp = nums[i];continue;}else if(nums[i]==tmp){continue;}else{count = 1 ;tmp = nums[i];ans = Math.max(ans,count);}}return ans;}
}

4、移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

思路：

双指针问题——>left指针指向待填充的位置，依次加1；right指针从小到大依次指向非零的。

相当于右指针每遇到一个非零的数，就把他按照left指针依次存到数组里

class Solution {public void moveZeroes(int[] nums) {int n = nums.length;if(n == 1 || n == 0){return;}int l = 0;int r = 0;while(r<n){if(nums[r] !=0 ){int tmp = nums[l];nums[l] = nums[r];nums[r] = tmp;r++;l++;}else{r++;}}}
}

5、盛最多水的容器

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

说明：你不能倾斜容器

示例 1：

输入：[1,8,6,2,5,4,8,3,7]
输出：49 
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

思路：

先框到最大，往里缩的时候，肯定是去变化那个最小的边，因为是由于那个边小面积才小的。

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

6、三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

思路：

如果是有序数组，遍历第一个数，则三个数之和相当于在第一个数的右边找两个数和为-nums[i]。

值得注意的是，要避免重复，例如第一个数在遍历的时候就要判断是不是重复了；

后续如果满足了，通过ans.add(List.of(三个数));即可，然后跳过重复的字段。

class Solution {public List<List<Integer>> threeSum(int[] nums) {Arrays.sort(nums);List<List<Integer>> ans = new ArrayList<>();int n = nums.length;for (int i = 0; i < n - 2; i++) {int x = nums[i];if (i > 0 && x == nums[i - 1]) continue; // 跳过重复数字if (x + nums[i + 1] + nums[i + 2] > 0) break; // 优化一if (x + nums[n - 2] + nums[n - 1] < 0) continue; // 优化二int j = i + 1;int k = n - 1;while (j < k) {int s = x + nums[j] + nums[k];if (s > 0) {k--;} else if (s < 0) {j++;} else { // 三数之和为 0ans.add(List.of(x, nums[j], nums[k]));//for (j++; j < k && nums[j] == nums[j - 1]; j++); // 跳过重复数字while(++j < k && nums[j] == nums[j - 1]);//for (k--; k > j && nums[k] == nums[k + 1]; k--); // 跳过重复数字while(--k>j && nums[k] == nums[k+1]);}}}return ans;}
}

7、接雨水

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

示例 1：

输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出：6
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。

思路：

接雨水经典问题：把每一个点当成一个桶，这个点能存多少水取决于他的左右两侧最高值的最小值，否则水会从两边流出去。如果左右两边的最值中相对小的数>这个桶本身的高度，则属于正常接雨水，差值就是接到的雨水。

class Solution {public int trap(int[] height) {int n = height.length;int[] pre = new int[n];int[] lst = new int[n];pre[0] = height[0];lst[n-1] = height[n-1];for(int i = 1;i<n;i++){pre[i] = Math.max(pre[i-1],height[i]);}for(int i = n-2 ; i>=0 ;i--){lst[i] = Math.max(height[i],lst[i+1]);}int ans = 0;for(int i = 1;i < n-1 ; i++){int tmp = Math.min(pre[i],lst[i]);if(tmp > height[i]){ans+=(tmp-height[i]);}}return ans;}
}

8、无重复字符的最长子串

给定一个字符串 s ，请你找出其中不含有重复字符的 最长 子串 的长度。

示例 1:

输入: s = "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

（1）官方得到滑动窗口（更快）

利用哈希表记录每一个字母在滑动窗口中第一次出现的位置。

关键点的是怎么更新哈希表，通过左右指针，判断右指针指向的字符是不是已经存在在哈希表中且在左指针的右边，如果是，就相当于被滑动窗口框住了，也就是说框住的字符串由于右指针的加入，出现了重复的字符，所以要更新左指针和右指针指向的字符在滑动窗口中第一次出现的位置，把左指针指向右指针的字符原本第一次出现的位置+1的位置。

class Solution {public int lengthOfLongestSubstring(String s) {Map<Character, Integer> map = new HashMap<>();  // 记录字符的最近一次出现位置int ans = 0;                                     // 最长子串长度int left = 0;                                    // 滑动窗口左边界for (int right = 0; right < s.length(); right++) {char c = s.charAt(right);// 关键逻辑：如果字符 c 已经存在，且其位置 >= left，说明它在当前窗口内重复了if (map.containsKey(c) && map.get(c) >= left) {left = map.get(c) + 1;  // 将左边界移动到重复字符的下一个位置}map.put(c, right);  // 更新字符 c 的最新位置ans = Math.max(ans, right - left + 1);  // 计算当前窗口长度，更新最大值}return ans;}
}

（2）我的思路

利用哈希表记录每个字符出现的次数

需要一个公共参数index，判断每次新加的字符是不是已经出现过，如果已经出现过，利用while循环执行把index++指向的字符出现的次数减1，直到新加的字符出现的次数不再大于1。

class Solution {public int lengthOfLongestSubstring(String S) {Map<Character,Integer> map = new HashMap<>();char[] s = S.toCharArray();int n = s.length;int ans = 0;int index = 0;for(int i = 0; i<n ; i++){if(map.containsKey(s[i])){map.put(s[i],map.get(s[i])+1);}else{map.put(s[i],1);}if(map.get(s[i])==1){ans = Math.max(ans,i-index+1);}while(map.get(s[i])>1){map.put(s[index],map.get(s[index])-1);index++;}}return ans;}
}

9、找到字符串中所有字母异位词

给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。

示例 1:

输入: s = "cbaebabacd", p = "abc"
输出: [0,6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。

(1) 

 标准的定长滑动窗口

关键：（1）利用 字符-‘a’ 把字符转换为数字，设 int[ ] cnt = new int[26]

           （2）Arrays的一个接口方法：Arrays.equal（数组1，数组2）

           （3）滑动窗口三个步骤：入——>更新——>出

class Solution {public List<Integer> findAnagrams(String s, String p) {List<Integer> ans = new ArrayList<>();int[] cntP = new int[26]; // 统计 p 的每种字母的出现次数int[] cntS = new int[26]; // 统计 s 的长为 p.length() 的子串 s' 的每种字母的出现次数for (char c : p.toCharArray()) {cntP[c - 'a']++; // 统计 p 的字母}for (int right = 0; right < s.length(); right++) {cntS[s.charAt(right) - 'a']++; // 右端点字母进入窗口int left = right - p.length() + 1;if (left < 0) { // 窗口长度不足 p.length()continue;}if (Arrays.equals(cntS, cntP)) { // s' 和 p 的每种字母的出现次数都相同ans.add(left); // s' 左端点下标加入答案}cntS[s.charAt(left) - 'a']--; // 左端点字母离开窗口}return ans;}
}

(2)不定长窗口

class Solution {public List<Integer> findAnagrams(String s, String p) {List<Integer> ans = new ArrayList<>();int[] cnt = new int[26]; // 统计 p 的每种字母的出现次数for (char c : p.toCharArray()) {cnt[c - 'a']++;}int left = 0;for (int right = 0; right < s.length(); right++) {int c = s.charAt(right) - 'a';cnt[c]--; // 右端点字母进入窗口while (cnt[c] < 0) { // 字母 c 太多了cnt[s.charAt(left) - 'a']++; // 左端点字母离开窗口left++;}if (right - left + 1 == p.length()) { // s' 和 p 的每种字母的出现次数都相同ans.add(left); // s' 左端点下标加入答案}}return ans;}
}

10、 和为 K 的子数组

（1）枚举

两个for循环枚举每一个数打头的可能性。

public class Solution {public int subarraySum(int[] nums, int k) {int count = 0;for (int start = 0; start < nums.length; ++start) {int sum = 0;for (int end = start; end >= 0; --end) {sum += nums[end];if (sum == k) {count++;}}}return count;}
}

（2）前缀和优化

枚举的思想是，确定1个开头的数字nums[i]，然后依次求他后面所有数的和；

前缀和的思想：

定义 pre[i] 为 [0..i] 里所有数的和，则 pre[i] 可以由 pre[i−1] 递推而来，即：

pre[i]=pre[i−1]+nums[i]。那么j到i的和就为pre[i]-pre[j-1]，判断是否为k即可。

也就相当于找k+pre[j-1]是否存在

利用哈希表，把前缀和作为键，值为出现的次数。由于是按照从小到大顺序走的，所以出现的次数只会是i之前的和，所以也就相当于遍历了一遍0~i。 

public class Solution {public int subarraySum(int[] nums, int k) {int count = 0, pre = 0;HashMap < Integer, Integer > mp = new HashMap < > ();mp.put(0, 1);for (int i = 0; i < nums.length; i++) {pre += nums[i];if (mp.containsKey(pre - k)) {count += mp.get(pre - k);}mp.put(pre, mp.getOrDefault(pre, 0) + 1);}return count;}
}

要注意的是：这个key是子串和，值为个数。当pre = k时， 不管map里面有没有和为0的，肯定是满足的，所以提前存一个（0,1），​​处理前缀和直接等于 k 的情况​。

11、 滑动窗口最大值

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回 滑动窗口中的最大值 。

示例 1：

输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置                最大值
---------------               -----
[1  3  -1] -3  5  3  6  7       31 [3  -1  -3] 5  3  6  7       31  3 [-1  -3  5] 3  6  7       51  3  -1 [-3  5  3] 6  7       51  3  -1  -3 [5  3  6] 7       61  3  -1  -3  5 [3  6  7]      7

方法一：单调队列 

思路：

利用单调队列求：

如果即将进入到框内的数更小，当大的走了这个小的有可能成为最大，但如果即将进来的数比末尾数大，那么这个末尾数就再也不会当做最大值，因为末尾值比即将进来的数小而且走的还早。也就相当于只在队列中保存从大到小的数（单调队列），出现小到大就扔掉小的；

当队列中人数超了，扔掉队首的数，下一个最大的只会是新队首。

主要用到的ArrayDeque<>的方法：

（1）getLast()     getFirst();

（2）removeLast()

class Solution {public int[] maxSlidingWindow(int[] nums, int k) {int n = nums.length;int[] ans = new int[n - k + 1];Deque<Integer> q = new ArrayDeque<>(); // 双端队列for (int i = 0; i < n; i++) {// 1. 入while (!q.isEmpty() && nums[q.getLast()] <= nums[i]) {q.removeLast(); // 维护 q 的单调性}q.addLast(i); // 入队// 2. 出if (i - q.getFirst() >= k) { // 队首已经离开窗口了q.removeFirst();}// 3. 记录答案if (i >= k - 1) {// 由于队首到队尾单调递减，所以窗口最大值就是队首ans[i - k + 1] = nums[q.getFirst()];}}return ans;}
}

 （简单看了下，还没理解）方法二 优先级队列

我们不断地移除堆顶的元素，直到其确实出现在滑动窗口中。此时，堆顶元素就是滑动窗口中的最大值。为了方便判断堆顶元素与滑动窗口的位置关系，我们可以在优先队列中存储二元组 (num,index)，表示元素 num 在数组中的下标为 index。

算法步骤​​

  1. ​​初始化优先队列​​
    使用自定义比较器，队列中的元素是包含数值和索引的数组。比较规则：

    • ​​数值降序​​：数值大的元素优先。
    • ​​索引降序​​：数值相同时，索引大的元素优先。
    PriorityQueue<int[]> pq = new PriorityQueue<>(new Comparator<int[]>() {public int compare(int[] pair1, int[] pair2) {return pair1[0] != pair2[0] ? pair2[0] - pair1[0] : pair2[1] - pair1[1];}
});

  2. ​​填充初始窗口​​
    将前 k 个元素加入队列：

    for (int i = 0; i < k; ++i) {pq.offer(new int[]{nums[i], i});
}

  3. ​​处理第一个窗口的最大值​​
    直接取队首元素的值：

    ans[0] = pq.peek()[0];

  4. ​​滑动窗口并更新结果​​
    从第 k 个元素开始遍历：

    • ​​添加新元素到队列​​。
    • ​​移除过期元素​​：循环检查队首元素的索引是否在当前窗口的左侧边界之前（即 <= i - k），若过期则弹出。
    • ​​记录当前窗口的最大值​​。
    for (int i = k; i < n; ++i) {pq.offer(new int[]{nums[i], i});while (pq.peek()[1] <= i - k) {pq.poll();}ans[i - k + 1] = pq.peek()[0];
}
class Solution {public int[] maxSlidingWindow(int[] nums, int k) {int n = nums.length;PriorityQueue<int[]> pq = new PriorityQueue<int[]>(new Comparator<int[]>() {public int compare(int[] pair1, int[] pair2) {return pair1[0] != pair2[0] ? pair2[0] - pair1[0] : pair2[1] - pair1[1];}});for (int i = 0; i < k; ++i) {pq.offer(new int[]{nums[i], i});}int[] ans = new int[n - k + 1];ans[0] = pq.peek()[0];for (int i = k; i < n; ++i) {pq.offer(new int[]{nums[i], i});while (pq.peek()[1] <= i - k) {pq.poll();}ans[i - k + 1] = pq.peek()[0];}return ans;}
}

12、最小覆盖子串

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。

注意：

  • 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
  • 如果 s 中存在这样的子串，我们保证它是唯一的答案。

示例 1：

输入：s = "ADOBECODEBANC", t = "ABC"
输出："BANC"
解释：最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。

思路：

遍历右指针，先加进来新的，加进来以后，只要cntS能够覆盖cntT，那么就一直更新返回值，并且更新左指针（左指针加一），直到不再覆盖了。

所以引入了一个方法：能否覆盖？

方法中，可以利用  for（int i = 'A' ; i <= 'Z' ; i++）来遍历（再遍历一遍‘a’到‘z’），只要cntT[i] > cntS[i]，就代表S不覆盖T，就返回false

class Solution {public String minWindow(String s, String T) {int[] cntS = new int[128];int[] cntT = new int[128];int n = s.length();int ansl = -1;int ansr = n;for(char t:T.toCharArray()){cntT[t] ++;}int l = 0;for(int r = 0 ;r<n;r++){cntS[s.charAt(r)]++;while(isCoverd(cntS,cntT)){if(r-l<ansr-ansl){ansl = l ;ansr = r ;}cntS[s.charAt(l)]--;l++;}}return ansl < 0 ? "" : s.substring(ansl,ansr+1);       }public boolean isCoverd(int[] cntS,int[] cntT){for(int i = 'A';i<='Z'; i++ ){if(cntS[i]<cntT[i]){return false;                         }}for(int i = 'a';i<='z'; i++ ){if(cntS[i]<cntT[i]){return false;                         }}return true;}
}

13、最大子数组和

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组是数组中的一个连续部分。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

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

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

相关文章

2025年最新版 Git和Github的绑定方法，以及通过Git提交文件至Github的具体流程(详细版)

2025年最新版 Git和Github的绑定方法，以及通过Git提交文件至Github的具体流程(详细版)

文章目录 Git和Github的绑定方法与如何上传至代码仓库一. 注册 GitHub 账号二.如何创建自己的代码仓库&#xff1a;1.登入Github账号&#xff0c;完成登入后会进入如下界面&#xff1a;2.点击下图中红色框选的按钮中的下拉列表3.选择New repostitory4.进入创建界面后&#xff0…
阅读更多...
FPGA开发板这样做？（一）-像 Arduino 一样玩 FPGA

FPGA开发板这样做？（一）-像 Arduino 一样玩 FPGA

这也是一个系列文章&#xff0c;来源之前和粉丝们在评论区讨论的国外对于FPGA的开发或者入门所做的努力。 基本一篇文章会介绍一个FPGA开发板&#xff0c;重点在于为开发板准备的开发方式&#xff08;和国内大不相同&#xff09;。 今天的主角-PulseRain M10&#xff1a;像 Ard…
阅读更多...
【C++游戏引擎开发】第21篇：基于物理渲染（PBR）——统计学解构材质与光影

【C++游戏引擎开发】第21篇：基于物理渲染（PBR）——统计学解构材质与光影

引言 宏观现象：人眼观察到的材质表面特性（如金属的高光锐利、石膏的漫反射柔和），本质上是微观结构对光线的统计平均结果。 微观真相：任何看似平整的表面在放大后都呈现崎岖的微观几何。每个微表面（Microfacet）均为完美镜面，但大量微表面以不同朝向分布时，宏观上会表…
阅读更多...
深入理解linux操作系统---第11讲 bshell编程

深入理解linux操作系统---第11讲 bshell编程

11.1 正则表达式 11.1.1 字符集 正则表达式的字符集包含三类核心要素&#xff1a; 普通字符&#xff1a;直接匹配单个字符&#xff0c;如a匹配字母a范围字符集&#xff1a;[a-z]匹配所有小写字母&#xff0c;[0-9A-F]匹配十六进制数字预定义字符集&#xff1a;\d等价于[0-9]…
阅读更多...
C++中的引用：深入理解与实用示例

C++中的引用：深入理解与实用示例

文章目录 C中的引用&#xff1a;深入理解与实用示例一、引用的基本概念二、引用作为别名的应用三、引用作为函数参数四、指针与引用的区别五、常量引用六、引用与返回值七、总结 C中的引用&#xff1a;深入理解与实用示例 在C编程中&#xff0c;“引用”是一个强大而重要的概念…
阅读更多...
C#委托介绍

C#委托介绍

委托可以将方法作为参数传递&#xff0c;同时委托也可以自己作为参数传递 委托可分为自定义委托delegate 无返回值的Action 与有返回值的Func委托 也有匿名委托与Lamada 委托支持多播是事件的基础 用处如在分线程调用主线程的UI invoke public delegate string Say(stri…
阅读更多...
Node.js 模块导入的基本流程

Node.js 模块导入的基本流程

Node.js 模块导入的基本流程&#xff0c;主要是 CommonJS 模块加载机制&#xff08;即使用 require()&#xff09;的内部执行步骤。下面我用清晰的结构给你梳理一下这个过程&#xff1a; ✅ Node.js 模块导入的基本流程&#xff08;使用 require()&#xff09; const someModu…
阅读更多...
n8n 中文系列教程_02. 自动化平台深度解析：核心优势与场景适配指南

n8n 中文系列教程_02. 自动化平台深度解析：核心优势与场景适配指南

在低代码与AI技术深度融合的今天&#xff0c;n8n作为开源自动化平台正成为开发者提效的新利器。本文深度剖析其四大核心技术优势——极简部署、服务集成、AI工作流与混合开发模式&#xff0c;并基于真实场景测试数据&#xff0c;厘清其在C端高并发、多媒体处理等场景的边界。 一…
阅读更多...
【C++ Qt】信号和槽（内配思维导图 图文并茂 通俗易懂）

【C++ Qt】信号和槽（内配思维导图 图文并茂 通俗易懂）

每日激励&#xff1a;“不设限和自我肯定的心态&#xff1a;I can do all things。 — Stephen Curry” 绪论​&#xff1a; 本章是Qt中的第三章&#xff0c;也是我们理解Qt中必备的点 信号槽&#xff0c;它本质由信号和槽两个来实现&#xff0c;其中将细致的讲述如何自定义信号…
阅读更多...
【项目】基于MCP+Tabelstore架构实现知识库答疑系统

【项目】基于MCP+Tabelstore架构实现知识库答疑系统

基于MCPTabelstore架构实现知识库答疑系统 整体流程设计&#xff08;一&#xff09;Agent 架构&#xff08;二&#xff09;知识库存储&#xff08;1&#xff09;向量数据库Tablestore&#xff08;2&#xff09;MCP Server &#xff08;三&#xff09;知识库构建&#xff08;1&a…
阅读更多...
免费将静态网站部署到服务器方法（仅支持HTML，CSS，JS）

免费将静态网站部署到服务器方法（仅支持HTML，CSS，JS）

原视频链接&#xff1a;把HTML免费部署到网站上&#xff0c;实现别人也能访问的教程来啦QAQ_哔哩哔哩_bilibili 注意&#xff1a;仅支持HTML、CSS、JS。不支持Vue等框架。 1.打开网站www.wordpress.org 点击红框按钮 点击红框按钮下载wordpress模板文件并解压。 将自己编写的…
阅读更多...
游戏引擎学习第235天:在 Windows 上初始化 OpenGL

游戏引擎学习第235天:在 Windows 上初始化 OpenGL

奇怪有问题 之前没注意到 这个问题是Count 0 GlobalConstants_Renderer_UsedDebugCamer 打开的话会有Bug Count是零的话就不让排序了 game.h: 查阅 TODO 列表 大家好&#xff0c;欢迎来到 game Hero&#xff0c;这是一档我们在直播中一起编写完整游戏的节目。不幸的是&a…
阅读更多...
使用eCharts绘制中国地图

使用eCharts绘制中国地图

eCharts官网&#xff1a;https://echarts.apache.org/zh/index.html 1. 首先新建一个html页面&#xff0c;并引入echarts <html lang"en"><head><meta charset"UTF-8" /><meta name"viewport" content"widthdevice-…
阅读更多...
Linux与Anaconda环境部署与管理（运维交接）

Linux与Anaconda环境部署与管理（运维交接）

文章目录 一、前言二、Linux基础命令三、进程管理与监控四、后台任务与服务管理五、Anaconda环境管理六、JAR包的运行与管理七、网络与端口映射八、安全与权限管理九、故障排查与日志分析十、附录 一、前言 本文将详细介绍Linux系统下的常用命令以及Anaconda环境管理&#xff…
阅读更多...
php：实现压缩文件上传、解压、文件更名、删除上传临时文件、存入数据库等操作

php：实现压缩文件上传、解压、文件更名、删除上传临时文件、存入数据库等操作

一、效果图 1.上传文件 2.压缩包文件 3.itemno1文件 二层结构 或 三层结构 4.上传到系统路径\ItemNo 5.更名后的itemno1文件(命名：当天日期+六位随机数) 二、普通实现 1、内容介绍 含有两种结构 二层结构：zip->料号文件夹->料号文件三层结构：zip->总文件夹-&g…
阅读更多...
基于大语言模型的减肥健身计划系统设计与实现

基于大语言模型的减肥健身计划系统设计与实现

基于大语言模型的减肥健身计划系统设计与实现 【包含内容】 【一】项目提供完整源代码及详细注释 【二】系统设计思路与实现说明 【三】功能演示与部署指南 【技术栈】 ①&#xff1a;系统环境&#xff1a;Python 3.x Django 4.2 ②&#xff1a;开发环境&#xff1a;Web服务…
阅读更多...
c#开发大冲锋游戏登录器

c#开发大冲锋游戏登录器

1 前言 本文主要分享登录器的简要开发过程&#xff0c;只适合小白选手&#xff0c;高手请自动避让。 此项目是复刻大冲锋计划中的子集。 &#xff08;注&#xff1a;大冲锋是迅雷代理的一款次时代多职业第一人称FPS射击游戏&#xff0c;目前已经关服嗝屁。&#xff09; 2 …
阅读更多...
Linux[基础指令][2]

Linux[基础指令][2]

Linux[基础指令][2] cp(复制) 格式:cp [-rf] 源文件 {普通文件,目录} 拷贝 cp -r 递归拷贝目录 蓝色为目录,白色为具体文件 拷贝后面加一个不存在的文件会新建文件再拷贝 cp -ir -i是覆盖的时候询问 如果目标文件存在就会覆盖原有文件 mv(重命名/剪切) 格式:mv 源文件…
阅读更多...
React18+ 项目搭建-从初始化、技术选型到开发部署的全流程规划

React18+ 项目搭建-从初始化、技术选型到开发部署的全流程规划

搭建一个 React 项目需要从项目初始化、技术选型到开发部署的全流程规划。以下是详细步骤和推荐的技术栈&#xff1a; 一、项目初始化 1. 选择脚手架工具 推荐工具&#xff1a; Vite&#xff08;现代轻量级工具&#xff0c;支持 React 模板&#xff0c;速度快&#xff09;&am…
阅读更多...
人工智能学习框架完全指南（2025年更新版）

人工智能学习框架完全指南（2025年更新版）

一、核心框架分类与适用场景 人工智能框架根据功能可分为深度学习框架、机器学习框架、强化学习框架和传统工具库，以下是主流工具及选型建议： 1. 深度学习框架 （1）PyTorch 核心优势：动态计算图、灵活性强，适合科研与快速原型开发，支持多模态任务（如NLP、CV） 。技术生…
阅读更多...
最新文章

Copyright @ 2022~2023