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

news2024/10/6 2:22:50

题库链接：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';
    }
}

在这里插入图片描述

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

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

相关文章

pytorch中 nn.Conv2d的简单用法

pytorch中 nn.Conv2d的简单用法

torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride1, padding0, dilation1, groups1, biasTrue,padding_modezeros)参数介绍&#xff1a; in_channels&#xff1a;卷积层输入通道数 out_channels&#xff1a;卷积层输出通道数 kernel_size&#xff1a;卷积层的…
阅读更多...
AZ900备考

AZ900备考

文章目录 云服务的概念云服务模型云服务类型消费的模型云服务的好处可靠性和可预测性的优势云中的管理 Azure 体系结构和服务核心结构组件物理基础结构组件 Azure计算和网络服务Azure 存储服务身份认证AD身份认证 Azure 管理和治理成本管理治理合规性的功能和工具管理和部署Azu…
阅读更多...
Java设计模式：四、行为型模式-05：备忘录模式

Java设计模式：四、行为型模式-05：备忘录模式

文章目录 一、定义&#xff1a;备忘录模式二、模拟场景&#xff1a;备忘录模式三、改善代码&#xff1a;备忘录模式3.1 工程结构3.2 备忘录模式模型结构图3.3 备忘录模式定义3.3.1 配置信息类3.3.2 备忘录类3.3.3 记录者类3.3.4 管理员类 3.4 单元测试 四、总结&#xff1a;备忘…
阅读更多...
如何构建自己的技术博客

如何构建自己的技术博客

本文相关知识点&#xff1a; markdownVuepress/vitepressGitHub pages 托管服务 为什么建议搭建个人博客网站 拥有自己的技术博客&#xff0c;不仅可以提升自己的技术能力&#xff0c;还可以提升自己的影响力&#xff0c;未来也可能带来一些“睡后”收益。 对于我们职场新人…
阅读更多...
QTday2（登录界面+跳转——小黄人篇）

QTday2（登录界面+跳转——小黄人篇）

1.完成登录框的按钮操作&#xff0c;并在登录成功后进行界面跳转 form.h&#xff1a; #ifndef FORM_H #define FORM_H#include <QWidget> #include <QPushButton> #include <QDebug> #include <QLineEdit> //行编辑器 #include <QLab…
阅读更多...
W5500-EVB-PICO主动PING主机IP检测连通性（十）

W5500-EVB-PICO主动PING主机IP检测连通性（十）

前言 上一章我们用W5500_EVB_PICO 开发板做UDP组播数据回环测试&#xff0c;那么本章我们进行W5500_EVB_PICO Ping的测试。 什么是PING&#xff1f; Ping &#xff08;Packet Internet Groper&#xff09;是一种因特网包探索器&#xff0c;用于测试网络连接量的程序 。Ping是…
阅读更多...
python读取图像小工具

python读取图像小工具

一、和图像交互获得图像的坐标和像素值 import cv2 import numpy as np import signal import threading import timeif __name__ __main__:img cv2.imread(XXX,0)#读取图片font_face,font_scale,thicknesscv2.FONT_HERSHEY_SIMPLEX,0.5,1#鼠标交互def mouseHandler(event,x…
阅读更多...
Android基础之Activity生命周期

Android基础之Activity生命周期

Activity是Android四大组件之一、称为之首也恰如其分。 Activity直接翻译为中文叫活动。在Android系统中Activity就是我看到的一个完整的界面。 界面中看到的TextView(文字&#xff09;、Button(按钮)、ImageView&#xff08;图片&#xff09;都是需要Activity来承载的。 总…
阅读更多...
linux免密登录最简单--图文详解

linux免密登录最简单--图文详解

最简单的免密登录 1.A电脑生成秘钥 ssh-keygen -t rsa 2.A电脑将秘钥传给B电脑 ssh-copy-id root192.168.1.129 #将秘钥直接传给B电脑 需要输入B电脑的密码&#xff0c;可以看到成功。 3.测试 同理&#xff1a;如果B->A也需要免密登录&#xff0c;统一的操作。 大功告…
阅读更多...
集成指挥平台定时任务故障流量分析

集成指挥平台定时任务故障流量分析

01故障现象 集成指挥平台中有定时任务定时传输数据到总队&#xff0c;总队定时下发数据到市交警支队。市交警支队发现定时任务一直出现执行失败的错误。市交警支队和总队联系&#xff0c;说需要市交警支队排查一下自身网络&#xff0c;前两天在应用服务器上面抓了定时任务的数…
阅读更多...
大数据、AI和云原生：引领未来软件开发的技术演进

大数据、AI和云原生：引领未来软件开发的技术演进

文章目录 **1. 数据驱动的创新&#xff1a;****2. 智能化应用的兴起&#xff1a;****3. 云原生的敏捷和可扩展性&#xff1a;****4. 实时性和即时性&#xff1a;****5. 数据隐私和安全&#xff1a;****6. 跨平台和跨设备&#xff1a;****7. 自动化和智能编程&#xff1a;****8.…
阅读更多...
Stable Diffusion 多视图实践

Stable Diffusion 多视图实践

此教程是基于秋叶的webui启动器 1.Stable Diffsuion 使用多视图需要准备一个多角度open pose 图 我给大家提供一个可使用的。 2.需要添加图片到到controlnet当中，不要选择预处理器，选择模型为openpose的模型，然后需要点选同步图片尺寸。 3.然后填写关键字可以参照一下这个…
阅读更多...
IBM Spectrum LSF Explorer 为要求苛刻的分布式和任务关键型高性能技术计算环境提供强大的工作负载管理

IBM Spectrum LSF Explorer 为要求苛刻的分布式和任务关键型高性能技术计算环境提供强大的工作负载管理

IBM Spectrum LSF Explorer 适用于 IBM Spectrum LSF 集群的强大、轻量级报告解决方案 亮点 ● 允许不同的业务和技术用户使用单一解决方案快速创建和查看报表和仪表板 ● 利用可扩展的库提供预构建的报告 ● 自定义并生成性能、工作负载和资源使用情况的报…
阅读更多...
设计模式-适配器

设计模式-适配器

文章目录 一、简介二、适配器模式基础1. 适配器模式定义与分类2. 适配器模式的作用与优势3.UML图 三、适配器模式实现方式1. 类适配器模式2. 对象适配器模式3.类适配器模式和对象适配器模式对比 四、适配器模式应用场景1. 继承与接口的适配2. 跨平台适配 五、适配器模式与其他设…
阅读更多...
无涯教程-Python机器学习 - Extra Trees函数

无涯教程-Python机器学习 - Extra Trees函数

它是袋装决策树集成方法的另一种扩展。在这种方法中,从训练数据集的样本中构建随机树。 在以下Python食谱中,我们将通过在Pima Indians糖尿病数据集上使用sklearn的ExtraTreesClassifier类来构建额外的树集成模型。 首先,导入所需的软件包,如下所示: from pandas import rea…
阅读更多...
Nginx详解 三：高级配置

Nginx详解 三：高级配置

文章目录 1. 网页的状态页2. Nginx第三方模块2.1 echo模块 3. 变量3.1 内置变量3.1.1 示例 3.2 自定义变量3.2.1 自定义访问日志3.2.2 自定义json 格式日志 3.4 Nginx压缩功能 4. HTTPS4.1 Nginx的HTTPS工作原理4.2 启用功能模块的配置过程 5、自定义图标 1. 网页的状态页 基于…
阅读更多...
江苏移动基于OceanBase稳步创新推进核心数据库分布式升级

江苏移动基于OceanBase稳步创新推进核心数据库分布式升级

*本文首发自《中国电信业》 数字经济时代&#xff0c;数据库作为企业核心数据存储、处理、挖潜等方面的关键载体&#xff0c;重要性日益凸显。对于运营商而言&#xff0c;数据库具有行业用户数量多、访问数量多、业务复杂度高、数据安全性高、响应要求性高以及需要 7*24 小时服…
阅读更多...
【组合计数 or 树DP】2021 icpc 上海 G

【组合计数 or 树DP】2021 icpc 上海 G

Problem - G - Codeforces 题意&#xff1a; Code&#xff1a; #include <bits/stdc.h>#define int long longusing namespace std;const int mxn1e610; const int mxv1e610; const int mod998244353;vector<int> G[mxn];int N,u,v; int ans1; int sz[mxn];void…
阅读更多...
手把手教你写出第一个C语言程序

手把手教你写出第一个C语言程序

Hello, World! 1. 前言2. 准备知识2.1 环境2.2 文件的分类2.3 注释2.3.1 注释的作用2.3.2 注释的两种风格2.3.2.1 C语言的注释风格2.3.2.2 C的注释风格 2.3.3 VS中注释和取消注释的快捷键 3. 开始演示3.1 创建项目3.2 创建源文件3.3 写代码3.4 编译链接运行 4. 代码解释4.1 写主…
阅读更多...
Apipost：API文档、调试、Mock与测试的一体化协作平台

Apipost：API文档、调试、Mock与测试的一体化协作平台

随着数字化转型的加速&#xff0c;API&#xff08;应用程序接口&#xff09;已经成为企业间沟通和数据交换的关键。而在API开发和管理过程中&#xff0c;API文档、调试、Mock和测试的协作显得尤为重要。Apipost正是这样一款一体化协作平台&#xff0c;旨在解决这些问题&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023