【LeetCode】剑指 Offer Ⅱ 第5章：哈希表（6道题） -- Java Version

题库链接：https://leetcode.cn/problem-list/e8X3pBZi/
在这里插入图片描述

类型题目解决方案
哈希表的设计剑指 Offer II 030. 插入、删除和随机访问都是O(1) 的容器HashMap + ArrayList ⭐
剑指 Offer II 031. LRU 缓存HashMap + 双向链表 ⭐
哈希表的应用剑指 Offer II 032. 有效的变位词哈希表：数组模拟哈希表 ⭐
剑指 Offer II 033. 变位词组排序：Arrays.sort(arr) ⭐
剑指 Offer II 034. 外星语言是否排序哈希表：数组模拟哈希表 ⭐
剑指 Offer II 035. 最小时间差排序：计算两两差值 + 鸽巢原理 ⭐

本章主要练习了基本的哈希表设计和应用：

  • 哈希表的时间效率很高，添加、删除和查找操作的时间复杂度都是 O(1)；
  • 哈希表经常被用来记录字符串中字母出现的次数、字符串中字符出现的位置等信息；
  • 如果哈希表的键的数目是固定的，并且数目不太大，那么也可以使用数组来模拟哈希表，数组的下标对应哈希表的键，而数组的值则与哈希表的值对应。（与哈希表相比，数组的代码更加简洁，应聘者在面试时只要情况允许就可以尽量使用数组模拟哈希表）

1. 剑指 Offer II 030. 插入、删除和随机访问都是O(1) 的容器 – P76

设计一个支持在平均 时间复杂度 O(1) 下，执行以下操作的数据结构：

  • insert(val)：当元素 val 不存在时返回 true ，并向集合中插入该项，否则返回 false 。
  • remove(val)：当元素 val 存在时返回 true ，并从集合中移除该项，否则返回 false 。
  • getRandom：随机返回现有集合中的一项。每个元素应该有 相同的概率 被返回。

1.1 HashMap + ArrayList – O(1)（⭐）

时间复杂度 O ( 1 ) O(1) O(1)，空间复杂度 O ( n ) O(n) O(n)

🎈 注意：该题比较麻烦的地方在于删除一个元素，本题解采用的方法是通过交换删除元素与变长列表中最后一个元素的位置，删除最后一个元素实现的，使用这种方法可以避免移动被删除元素后面的元素。

class RandomizedSet {
    Map<Integer,Integer> map;
    List<Integer> list;
    Random random;
    /** Initialize your data structure here. */
    public RandomizedSet() {
        map = new HashMap<>();
        list = new ArrayList<>();
        random = new Random();
    }
    
    /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
    public boolean insert(int val) {
        if (map.containsKey(val)) return false;  // val存在 返回false
        int index = map.size();
        map.put(val,index);
        list.add(val);
        return true;
    }
    
    /** Removes a value from the set. Returns true if the set contained the specified element. */
    public boolean remove(int val) {
        if (!map.containsKey(val)) return false;  // val不存在 返回false

        int index = map.get(val);  // val 在变长数组中的索引位置
        int last = list.get(list.size()-1);  // 变长数组中最后位置的元素
        list.set(index, last);  // 交换元素
        map.put(last, index);
        list.remove(list.size()-1);  // 删除元素
        map.remove(val);
        return true;

    }
    
    /** Get a random element from the set. */
    public int getRandom() {
        int randomIndex = random.nextInt(list.size());
        return list.get(randomIndex);
    }
}

/**
 * Your RandomizedSet object will be instantiated and called as such:
 * RandomizedSet obj = new RandomizedSet();
 * boolean param_1 = obj.insert(val);
 * boolean param_2 = obj.remove(val);
 * int param_3 = obj.getRandom();
 */

在这里插入图片描述

2. 剑指 Offer II 031. LRU 缓存 – P79

运用所掌握的数据结构，设计和实现一个 LRU (Least Recently Used，最近最少使用) 缓存机制 。
实现 LRUCache 类

  • LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存；
  • int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 ；
  • void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。

2.1 HashMap + 双向链表 – O(1)（⭐）

时间复杂度 O ( 1 ) O(1) O(1)，空间复杂度 O ( n ) O(n) O(n)

🎈 提示：此处双向链表使用头插法或者尾插法均可，尾插法代码可参考：

  • LCR 031. LRU 缓存 - 力扣（LeetCode）
class LRUCache {
   // 1. 头插法，从头节点插入，从尾节点删除
    class DuLNode {  // 双向链表
        DuLNode prev;
        DuLNode next;
        int key;
        int value;
        public DuLNode(){};
        public DuLNode(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }

    DuLNode head;  // 头节点
    DuLNode tail;  // 尾节点
    int size;  // 容量
    Map<Integer,DuLNode> map;

    public LRUCache(int capacity) {
        size = capacity;
        map = new HashMap<>();
        head = new DuLNode();
        tail = new DuLNode();
        head.next = tail;  // head 和 tail 是两个哨兵节点
        tail.prev = head;
    }

    public void deleteNode(DuLNode node) {  // 删除链表中的某节点
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    public void addToHead(DuLNode node) {  // 链表头插法
        node.next = head.next;
        head.next.prev = node;
        head.next = node;
        node.prev = head;
    }

    public void moveToHead(DuLNode node) {  // 将某节点移动到头
        deleteNode(node);
        addToHead(node);
    }
    
    public int get(int key) {
        if (!map.containsKey(key)) return -1;
        DuLNode node = map.get(key);
        moveToHead(node);
        return node.value;
    }
    
    public void put(int key, int value) {
        if (map.containsKey(key)) {
            DuLNode node = map.get(key);
            node.value = value;
            moveToHead(node);
        } else {
            DuLNode node = new DuLNode(key, value);
            if (map.size() == size) {
                DuLNode delete = tail.prev;
                deleteNode(delete);
                map.remove(delete.key);
            }
            map.put(key, node);
            addToHead(node);
        }
    }
}

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

在这里插入图片描述

PS：补充知识1 - 【双向链表】

🎈 可参考：
[1] 数据结构笔记（六）-- 双向链表 - 淡定的炮仗的博客【图解鲜明】
[2] 线性表的链式表示-双向链表 - yunfan188的博客【代码示例】

在这里插入图片描述

// 线性表的双向链表存储结构
class DuLNode {  // 双向链表
    DuLNode prev;
    DuLNode next;
    int key;
    int value;
    public DuLNode(){};
    public DuLNode(int key, int value) {
        this.key = key;
        this.value = value;
    }
}

3. 剑指 Offer II 032. 有效的变位词 – P83

给定两个字符串 s 和 t ，编写一个函数来判断它们是不是一组变位词（字母异位词）。
……
注意： s 和 t 中每个字符出现的次数都相同且字符顺序不完全相同，才能称 s 和 t 互为变位词。

3.1 哈希表：数组模拟哈希表 – O(n)（⭐）

时间复杂度 O ( n ) O(n) O(n)，空间复杂度 O ( 26 ) O(26) O(26)

class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length() || s.equals(t)) return false;  // 长度不一致/两者一样

        int[] map = new int[26];

        for (char c : s.toCharArray()) {  // 遍历 s，存入map
            map[c-'a']++;
        }

        for (char c : t.toCharArray()) {  // 遍历 t，存入map，并判断是否有字符次数不同的情况
            map[c-'a']--;
            if (map[c-'a'] < 0) return false;
        }
        return true;
    }
}

在这里插入图片描述

进阶: 如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？将 int[26] 数组替换成无固定大小的 HashMap 即可，但与 HashMap 相比，使用数组会更快一些，因此只要情况允许就应该尽量使用数组模拟哈希表。

class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length() || s.equals(t)) return false;  // 长度不一致/两者一样

        Map<Character, Integer> map = new HashMap<>();

        for (char c : s.toCharArray()) {  // 遍历 s，存入map
            map.put(c, map.getOrDefault(c,0)+1);
        }

        for (char c : t.toCharArray()) {  // 遍历 t，存入map，并判断是否有字符次数不同的情况
            map.put(c, map.getOrDefault(c,0)-1);;
            if (map.get(c) < 0) return false;
        }
        return true;
    }
}

在这里插入图片描述

3.2 排序：Arrays.sort(arr) – O(nlogn)

时间复杂度 O ( n l o g n ) O(nlogn) O(nlogn)，空间复杂度 O ( l o g n ) O(logn) O(logn)

class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length() || s.equals(t)) {
            return false;
        }
        char[] str1 = s.toCharArray();
        char[] str2 = t.toCharArray();
        Arrays.sort(str1);
        Arrays.sort(str2);
        return Arrays.equals(str1, str2);
    }
}

在这里插入图片描述

4. 剑指 Offer II 033. 变位词组 – P85

给定一个字符串数组 strs ，将 变位词 组合在一起。 可以按任意顺序返回结果列表。

4.1 映射：字符 - 质数 – O(mn)

时间复杂度 O ( m n ) O(mn) O(mn)，空间复杂度 O ( n ) O(n) O(n)

🎈 说明：该解法是将 26 个小写字母均映射为了一个质数，这样的话，如果是变位词，那么一定具有相同的值。但该解法存在一个潜在的问题：即由于把字符映射到数字用到了乘法，因此当单词非常长时，乘法就有可能溢出。

class Solution {
    // 1. 字符映射
    public List<List<String>> groupAnagrams(String[] strs) {
        int[] hash = new int[]{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101};

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

        for (String str : strs) {
            char[] ch = str.toCharArray();
            long key = 1;
            for (char c : ch) {
                key *= hash[c-'a']; 
            }
            map.putIfAbsent(key, new ArrayList<String>());  // key不存在，才加入
            map.get(key).add(str);
        }

        return new ArrayList<>(map.values());
    }
}

在这里插入图片描述

PS：补充知识1 - 【求质数】

🎈 可参考：
[1] Java求质数常见的3种方式 - 十三度灰的博客

以埃氏筛法（埃拉托斯特尼筛法）为例：【模板题】AcWing 868. 筛质数

💡 原理：先把从2开始的所有数写下来，然后从2开始，将每个质数的倍数都标记成合数，即非质数，直到筛完所有小于等于给定数n的数。这样，留下的就是小于等于n的质数。

import java.util.*;

class Main {
    // 1. 埃氏筛法
    private final static int N = 1000010;
    public static void main (String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        List<Integer> primes = new ArrayList<>();
        boolean[] isPrime = new boolean[N];
        
        for (int i = 2; i <= n; i++) {
            if (!isPrime[i]) {  // 是质数
                primes.add(i);
                if (primes.size() == 26) break;
                for (int j = i+i; j <= n; j += i) {
                    isPrime[j] = true;
                }
            } 
        }
        System.out.println(primes);
        sc.close();
    }
}

4.2 排序：Arrays.sort(arr) – O(nmlogm)（⭐）

时间复杂度 O ( n m l o g m ) O(nmlogm) O(nmlogm)，空间复杂度 O ( n m ) O(nm) O(nm)

🎈 说明：对变位词进行排序，同一类变位词排序后会得到相同的字符串。

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        Map<String, List<String>> map = new HashMap<String, List<String>>();
        for (String str : strs) {
            char[] array = str.toCharArray();
            Arrays.sort(array);
            String key = new String(array);
            List<String> list = map.getOrDefault(key, new ArrayList<String>());
            list.add(str);
            map.put(key, list);
        }
        return new ArrayList<List<String>>(map.values());
    }
}

在这里插入图片描述

4.3 计数：StringBuilder – O(nm)

时间复杂度 O ( n m ) O(nm) O(nm)，空间复杂度 O ( n m ) O(nm) O(nm)

🎈 说明：记录变位词每个字符出现的次数，并将其形成字符串（eg：a2b3c1），同样同一类变位词形成的字符串一定相同。

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        Map<String, List<String>> map = new HashMap<String, List<String>>();
        for (String str : strs) {
            int[] counts = new int[26];
            int length = str.length();
            for (int i = 0; i < length; i++) {
                counts[str.charAt(i) - 'a']++;
            }
            // 将每个出现次数大于 0 的字母和出现次数按顺序拼接成字符串，作为哈希表的键
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < 26; i++) {
                if (counts[i] != 0) {
                    sb.append((char) ('a' + i));
                    sb.append(counts[i]);
                }
            }
            String key = sb.toString();
            List<String> list = map.getOrDefault(key, new ArrayList<String>());
            list.add(str);
            map.put(key, list);
        }
        return new ArrayList<List<String>>(map.values());
    }
}

在这里插入图片描述

5. 剑指 Offer II 034. 外星语言是否排序 – P87

给定一组用外星语书写的单词 words，以及其字母表的顺序 order，只有当给定的单词在这种外星语中按字典序排列时，返回 true；否则，返回 false。

5.1 哈希表：数组模拟哈希表 – O(nm)（⭐）

时间复杂度 O ( n m ) O(nm) O(nm)，空间复杂度 O ( 26 ) O(26) O(26)

class Solution {
    // 1. 数组模拟哈希表
    public boolean isAlienSorted(String[] words, String order) {
        int[] map = new int[26];

        for (int i = 0; i < order.length(); i++) {
            map[order.charAt(i)-'a'] = i;  // 构建哈希表，key为英文字符，value为字典顺序
        }

        for (int i = 0; i < words.length-1; i++) {
            if (!isOrder(words[i], words[i+1], map)) {
                return false;
            }
        }
        return true;
    }

    public boolean isOrder(String w1, String w2, int[] map) {
        int i = 0;
        for (; i < w1.length() && i < w2.length(); i++) {
            char c1 = w1.charAt(i);
            char c2 = w2.charAt(i);
            if (map[c1-'a'] < map[c2-'a']) return true;  // 正确排序
            if (map[c1-'a'] > map[c2-'a']) return false;  // 错误排序
        }
        return i == w1.length();
    }
}

在这里插入图片描述

6. 剑指 Offer II 035. 最小时间差 – P88

给定一个 24 小时制（小时:分钟 “HH:MM”）的时间列表，找出列表中任意两个时间的最小时间差并以分钟数表示。

6.1 排序：计算两两差值 + 鸽巢原理 – O(nlogn)（⭐）

时间复杂度 O ( n l o g n ) O(nlogn) O(nlogn)，空间复杂度 O ( n ) O(n) O(n)

class Solution {
    public int findMinDifference(List<String> timePoints) {
        int n = timePoints.size();
        if (n > 1440) {  // 鸽巢原理
            return 0;
        }
        int res = Integer.MAX_VALUE;
        Collections.sort(timePoints);
        int fp = getMinite(timePoints.get(0));  // 记录第一个元素
        int prev = fp;  // 通过 prev 记录前一元素
        for (int i = 1; i < timePoints.size(); i++) {  // 开始两两比较，记录最小值
            int cur = getMinite(timePoints.get(i));
            res = Math.min(res, cur - prev);
            prev = cur;
        }
        res = Math.min(res, fp + 1440 - prev);  // 处理首尾 00:00
        return res;
    }

    public int getMinite(String t) {  // 获取时间转换的分钟值
        return ((t.charAt(0) - '0') * 10 + t.charAt(1) - '0') * 60 + (t.charAt(3) - '0') * 10 + t.charAt(4) - '0';
    }
}

在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

气候变化下的DNDC模拟

气候变化下的DNDC模拟

DNDC&#xff08;Denitrification-Decomposition&#xff0c;反硝化-分解模型&#xff09;是目前国际上最为成功的模拟生物地球化学循环的模型之一&#xff0c;自开发以来&#xff0c;经过不断完善和改进&#xff0c;从模拟简单的农田生态系统发展成为可以模拟几乎所有陆地生态…
阅读更多...
计算机毕业设计之基于Python+MySQL的健身房管理系统（文档+源码+部署教程）

计算机毕业设计之基于Python+MySQL的健身房管理系统（文档+源码+部署教程）

系统主要采用python技术和MySQL数据库技术以及Django框架进行开发。系统主要包括个人中心、用户管理、教练管理、健身课程管理、健身器材管理、健身记录管理、身体数据管理、在线留言、系统管理、订单管理等功能&#xff0c;从而实现智能化的健身房管理方式&#xff0c;提高健身…
阅读更多...
Jenkins 持续集成：Linux 系统 两台机器互相免密登录

Jenkins 持续集成：Linux 系统 两台机器互相免密登录

背景知识 我们把public key放在远程系统合适的位置&#xff0c;然后从本地开始进行ssh连接。 此时&#xff0c;远程的sshd会产生一个随机数并用我们产生的public key进行加密后发给本地&#xff0c;本地会用private key进行解密并把这个随机数发回给远程系统。 最后&#xf…
阅读更多...
excel怎么设置任意选一个单元格纵横竖横都有颜色

excel怎么设置任意选一个单元格纵横竖横都有颜色

有时excel表格内容过多的时候&#xff0c;我们通过excel设置任意选一个单元格纵横&#xff0c;竖横背景颜色&#xff0c;这样会更加具有辨识度。设置方式截图如下 设置成功后&#xff0c;预览的效果图
阅读更多...
计网第四章（网络层）（五）

计网第四章（网络层）（五）

目录 静态路由配置 默认路由&#xff1a; 特定主机路由&#xff1a; 示例&#xff1a; 广播域和冲突域&#xff1a; 静态路由配置 在第四节&#xff08;计网第四章&#xff08;网络层&#xff09;&#xff08;四&#xff09;_永无魇足的博客-CSDN博客&#xff09;有提到过…
阅读更多...
【C++】C++11新特性 lambda表达式

【C++】C++11新特性 lambda表达式

C11新特性 lambda表达式1、引入2、lambda表达式语法3、 捕获列表说明4、 lambda表达式的原理5、 lambda对象的大小 lambda表达式 1、引入 在C98中&#xff0c;如果想要对一个数据集合中的元素进行排序&#xff0c;可以使用std::sort方法&#xff0c;如果待排序元素为自定义类…
阅读更多...
BookStack开源免费知识库docker-compose部署

BookStack开源免费知识库docker-compose部署

BookStack&#xff08;书栈&#xff09;是一个功能强大且易于使用的开源知识管理平台&#xff0c;适用于个人、团队或企业的文档协作和知识共享。 一、BookStack特点 简单易用&#xff1a;BookStack提供了一个直观的用户界面&#xff0c;使用户能够轻松创建、编辑和组织文档多…
阅读更多...
8. 损失函数与反向传播

8. 损失函数与反向传播

8.1 损失函数 ① Loss损失函数一方面计算实际输出和目标之间的差距。 ② Loss损失函数另一方面为我们更新输出提供一定的依据。 8.2 L1loss损失函数 ① L1loss数学公式如下图所示&#xff0c;例子如下下图所示。 import torch from torch.nn import L1Loss inputs torch.tens…
阅读更多...
visual studio编写DLL，python调用

visual studio编写DLL，python调用

选择第一个c DLL&#xff0c; 然后项目源文件下右击新建项&#xff0c;这里名字随便取&#xff0c;在代码中输入一下内容&#xff1a; #include <iostream>#define EXPORT extern "C" __declspec(dllexport)EXPORT int sub(int a, int b) {return a - b; } 在…
阅读更多...
【GO】LGTM_Grafana_Tempo(1)_架构

【GO】LGTM_Grafana_Tempo(1)_架构

最近在尝试用 LGTM 来实现 Go 微服务的可观测性&#xff0c;就顺便整理一下文档。 Tempo 会分为 4 篇文章&#xff1a; Tempo 的架构官网测试实操跑通gin 框架发送 trace 数据到 tempogo-zero 微服务框架使用发送数据到 tempo 第一篇是关于&#xff0c;tempo 的架构&#xff…
阅读更多...
R语言对综合社会调查GSS数据进行自举法bootstrap统计推断、假设检验、探索性数据分析可视化|数据分享...

R语言对综合社会调查GSS数据进行自举法bootstrap统计推断、假设检验、探索性数据分析可视化|数据分享...

全文链接&#xff1a;https://tecdat.cn/?p33514 综合社会调查&#xff08;GSS&#xff09;是由国家舆论研究中心开展的一项观察性研究。自 1972 年以来&#xff0c;GSS 一直通过收集当代社会的数据来监测社会学和态度趋势。其目的是解释态度、行为和属性的趋势和常量。从 197…
阅读更多...
Docsify + Gitalk详细配置过程讲解

Docsify + Gitalk详细配置过程讲解

&#x1f496; 作者简介&#xff1a;大家好&#xff0c;我是Zeeland&#xff0c;开源建设者与全栈领域优质创作者。&#x1f4dd; CSDN主页&#xff1a;Zeeland&#x1f525;&#x1f4e3; 我的博客&#xff1a;Zeeland&#x1f4da; Github主页: Undertone0809 (Zeeland)&…
阅读更多...
前端：html实现页面切换、顶部标签栏（可删、可切换，点击左侧超链接出现标签栏）

前端：html实现页面切换、顶部标签栏（可删、可切换，点击左侧超链接出现标签栏）

一、在一个页面&#xff08;不跨页面&#xff09; 效果&#xff1a; 代码 <!DOCTYPE html> <html><head><style>/* 设置标签页外层容器样式 */.tab-container {width: 100%;background-color: #f1f1f1;overflow: hidden;}/* 设置标签页选项卡的样式 …
阅读更多...
Linux socket网络编程实战（tcp）实现双方聊天

Linux socket网络编程实战（tcp）实现双方聊天

在上节已经系统介绍了大致的流程和相关的API&#xff0c;这节就开始写代码&#xff01; 回顾上节的流程&#xff1a; 创建一个NET文件夹 来存放网络编程相关的代码&#xff1a; tcp服务端代码初步实现--上 这部分先实现服务器的连接部分的代码并进行验证 server1.c&#xff…
阅读更多...
如何在小红书进行学习直播

如何在小红书进行学习直播

诸神缄默不语-个人CSDN博文目录 因为我是从B站开始的&#xff0c;所以一些直播常识型的东西请见我之前写的如何在B站进行学习直播这一篇。 本篇主要介绍一些小红书之与B站不同之处。 小红书在手机端是可以直接点击“”选择直播的。 文章目录 1. 电脑直播-小红书直播软件2. 电…
阅读更多...
二叉树题目：二叉树的右视图

二叉树题目：二叉树的右视图

文章目录 题目标题和出处难度题目描述要求示例数据范围 解法一思路和算法代码复杂度分析 解法二思路和算法代码复杂度分析 题目 标题和出处 标题&#xff1a;二叉树的右视图 出处&#xff1a;199. 二叉树的右视图 难度 4 级 题目描述 要求 给定二叉树的根结点 root \t…
阅读更多...
DHCP中继实验

DHCP中继实验

文章目录 一、实验背景与目的二、实验拓扑三、实验需求四、实验解法1. 配置IP地址2.配置R1为DHCP服务器&#xff0c;能够跨网段为192.168.2.0/24网段自动分配IP地址3. 在PC3上Ping 192.168.1.1&#xff0c;确认可以Ping通 摘要&#xff1a; 本实验旨在通过配置DHCP中继实现跨网…
阅读更多...
C++项目：网络版本在线五子棋对战

C++项目：网络版本在线五子棋对战

目录 1.项目介绍 2.开发环境 3.核心技术 4. 环境搭建 5.websocketpp 5.1原理解析 5.2报文格式 5.3websocketpp常用接口介绍 5.4websocket服务器 6.JsonCpp使用 6.1Json数据格式 6.2JsonCpp介绍 7.MySQL API 7.1MySQL API介绍 7.2MySQL API使用 7.3实现增删改查…
阅读更多...
降噪音频转录 Krisp: v1.40.7 Crack

降噪音频转录 Krisp: v1.40.7 Crack

主打人工智能降噪服务的初创公司「Krisp」近期宣布推出音频转录功能&#xff0c;能对电话和视频会议进行实时设备转录。该软件还整合的ChatGPT&#xff0c;以便快速总结内容&#xff0c;开放测试版于今天上线。 随着线上会议越来越频繁&#xff0c;会议转录已成为团队工作的重…
阅读更多...
微服务系统面经之二: 以秒杀系统为例

微服务系统面经之二: 以秒杀系统为例

16 微服务与集群部署 16.1 一个微服务一般会采用集群部署吗&#xff1f; 对于一个微服务是否采用集群部署&#xff0c;这完全取决于具体的业务需求和系统规模。如果一个微服务的访问压力较大&#xff0c;或者需要提供高可用性&#xff0c;那么采用集群部署是一种常见的策略。…
阅读更多...
最新文章

Copyright @ 2022~2023