HDU - 5651 xiaoxin juju needs help（Java JS Python C C++）

题目来源

Problem - 5651 (hdu.edu.cn)

题目描述

众所周知，小新是一位才华横溢的程序员。当他还是小学六年级的学生时，他就知道回文字符串了。

今年夏天，他在腾讯实习。一天，他的领导来找小新帮忙。他的领导给了他一个字符串，他想让小新为他生成回文字符串。

一旦小新生成一个不同的回文串，他的领导就会给他一个西瓜糖。

问：小新的领导需要买多少糖果?

输入描述

这个问题有多个测试用例。

第一行，包含单个整数 T，它表示测试用例的数量。

  • T ≤ 20

对于每个测试用例，有一行，包含字符串S。

  • 1 ≤ length(S) ≤ 1000

输出描述

对于每个测试用例，打印一个整数，这是小新的领导需要购买的西瓜糖的数量，模取1,000,000,007。

用例

输入3
aa
aabb
a
输出1
2
1

题目解析

本题的解题思路其实很简单。

给定一个字符串s，我们可以任意重排s内字符的顺序，如果新串是回文串，则结果数量+1。

比如：s = "aabb"，重排后有："baab"，"abba" 两种回文串。

那么，我们该如何求解一个字符串重排后可得的回文串数量呢？

思路很简单：

首先，我们需要统计字符串s中各个字符的出现次数

然后，检查“出现次数为奇数次”的字符的数量，如果这个数量超过1，那么字符串s就无法重排出回文串，因为回文串是左右对称的，即可以在中间位置一分为二，比如：

  • 没有“出现次数为奇数次”的字符

  • 有一个“出现次数为奇数次”的字符


  • 但是如果有一个以上的“出现次数为奇数次”的字符时，某一边就会多出无法对称的字符

因此，如果统计到的“出现次数为奇数次”的字符数量＞1，则对应字符串s无法重排出回文串。

反之，如果统计到的“出现次数为奇数次”的字符数量 ≤ 1，则对应字符串s可以重排出回文串。但是如果计算可以重排的回文串数量呢？

比如s = "aabb"，那么有如下两种情况：

由于回文串是左右对称的，因此，当我们求出回文串的左半部分时，其右半部分也自然确定了。

比如，回文串左半部分是"ab"，那么回文串右半部分必然是"ba"。

因此，我们可以将之前统计的字符串s的各个字符数量除以2，得到回文串左半部分的各字符数量，然后求回文串左半部分的（不重复的）全排列数量，即为回文串的数量。

比如 s = "aabb"，其中统计结果 a字符有2个，b字符有2个，

那么用于组成回文串左半部分的字符数量为：a字符1个，b字符1个。

而1个a字符，一个b字符，可以组成的全排列有"ab"和"ba"两种。即对应的回文串有2种。

另外，还有一个需要注意的是，如果s = "abbba"，其中统计结果：a字符有2个，b字符有3个

那么用于组成回文串左半部分的字符数量为：a字符1个，b字符1.5个？

其实，此时“出现奇数次”的b字符，可以抠出来一个b固定为回文串的中间字符，这个作为中间字符的b既不属于左半部分，也不属于右半部分。

因此，我们可以理解为：回文串左半部分字符数量为：a字符1个，b字符1个（即：3整除2的结果）

那么本题的问题又可以变为：求一组元素的不重复的全排列数量。

假设有n个数，则这n个数的全排列数量即为：n!

比如 [1,2,3] 的全排列有 3！个，分别为：

  • 123
  • 132
  • 213
  • 231
  • 312
  • 321

那么这n个数如果存在重复元素，比如 [1,2,2] 的全排列有：

  • 122
  • 122
  • 212
  • 221
  • 212
  • 221

其中画删除线的都是重复的全排列，那么此时该如何求解不重复的全排列数量呢？

假设有 n 个字符，分为 k 种，

第1种有n1个相同字符，第2种有n2个相同字符，...，第k种有nk个相同字符，

存在关系：n1+n2+...+nk == n

那么，此时不重复全排列数量为：

n! / n1! / n2! / ... / nk! 

比如 [1,2,2] 的有两种字符：字符1有1个，字符2有2个，那么其不重复的全排列数量为：

3! / 1! / 2!

以上就是本题的基础解题思路，总结一下就是：

  • 首先，统计字符串s中各个字符的出现次数
  • 然后，检查“出现次数为奇数次”的字符的数量，如果这个数量超过1，则字符串s无法重排出回文串，即结果为0，否则继续下一步
  • 之后，将各个字符数量整除2，得到回文串左半部分各字符数量
  • 最后，基于回文串左半部分各字符数量求不重复的全排列数量，即为字符串s可以重排出的回文串数量

题目输出描述中说：需要对输出结果值取模1,000,000,007。因此本题的结果实际为：

（n! / n1! / n2! / ... / nk! ）% 1000000007

但是，这里面有一个问题，那就是，字符串s长度最大1000，也就是说回文串左半部分字符总数最大可以n=500，因此按照上面策略，我们必然要求解 500!，这是一个极其庞大的数，计算过程中肯定会long溢出。

当然，如果你的编程语言支持大数的四则运算的话，可以不用担心这个问题，比如Java的BigInteger类型，JS的BigInt类型。

但是其他语言，比如C/C++语言不支持大数的四则运算，Python不支持大数除法（可以支持大数的加法、减法，乘法）。

因此我们依旧需要考虑如果避免整型溢出。

这题为什么要我们将结果值对1000000007，即1e9 + 7取模呢？

因为这涉及到一个知识点：除法取模

算法竞赛6.1-模运算_哔哩哔哩_bilibili

而除法取模又涉及到了：乘法逆元

【C++/算法】乘法逆元详解_哔哩哔哩_bilibili

而乘法逆元的求解又涉及到了：费马小定理

数论：费马小定理_哔哩哔哩_bilibili

由费马小定理公式，类比为，乘法逆元公式，我们又需要基于：快速幂算法来求解逆元

【C++/算法】快速幂算法详解_哔哩哔哩_bilibili

Java算法源码

解法一：基于BigInteger类型
import java.math.BigInteger;
import java.util.Scanner;public class Main {static BigInteger[] fact = new BigInteger[501];public static void main(String[] args) {Scanner sc = new Scanner(System.in);// 初始化1~500的阶乘initFact();// 输入获取int t = Integer.parseInt(sc.nextLine());for (int i = 0; i < t; i++) {String s = sc.nextLine();// 核心代码调用System.out.println(solution(s));}}public static void initFact() {fact[0] = new BigInteger("1");for (int i = 1; i <= 500; i++) {fact[i] = new BigInteger(i + "").multiply(fact[i - 1]);}}public static String solution(String s) {// 求s串每个字符c的数量int[] count = new int[26];for (int i = 0; i < s.length(); i++) {char c = s.charAt(i);count[c - 'a']++;}// "出现次数为奇数次的"字符的数量int odd = 0;for (int i = 0; i < 26; i++) {if (count[i] % 2 != 0) {odd++;}count[i] /= 2; // 只保留一半字符数量, 后续只需要用到回文串的左半部分，即一半的字符}// 如果"出现次数为奇数次的"字符的数量不止1个，则s串无法重组出回文串if (odd > 1) {return "0";}// 不重复的全排列数BigInteger ans = fact[s.length() / 2];for (int i = 0; i < 26; i++) {ans = ans.divide(fact[count[i]]);}return ans.mod(new BigInteger("1000000007")).toString();}
}
解法二：除法取模，乘法逆元，费马小定理，快速幂
import java.util.Scanner;public class Main {static final long mod = 1000000007;static long[] fact = new long[501];public static void main(String[] args) {Scanner sc = new Scanner(System.in);// 初始化1~500的阶乘initFact();// 输入获取int t = Integer.parseInt(sc.nextLine());for (int i = 0; i < t; i++) {String s = sc.nextLine();// 核心代码调用System.out.println(solution(s));}}public static void initFact() {fact[0] = 1;for (int i = 1; i <= 500; i++) {fact[i] = i * fact[i - 1] % mod;}}public static long solution(String s) {// 求s串每个字符c的数量int[] count = new int[26];for (int i = 0; i < s.length(); i++) {char c = s.charAt(i);count[c - 'a']++;}// "出现次数为奇数次的"字符的数量int odd = 0;for (int i = 0; i < 26; i++) {if (count[i] % 2 != 0) {odd++;}count[i] /= 2; // 只保留一半字符数量, 后续只需要用到回文串的左半部分，即一半的字符即可}// 如果"出现次数为奇数次的"字符的数量不止1个，则s串无法重组出回文串if (odd > 1) {return 0;}// 不重复的全排列数long ans = fact[s.length() / 2];for (int i = 0; i < 26; i++) {// 假设 x == fact[count[i] / 2]// ans / x % mod// 等价于// ans * x的乘法逆元 % mod// 而x的乘法逆元为 fast_pow(x, mod-2, mod)ans = ans * fast_pow(fact[count[i]], mod - 2, mod) % mod;}return ans;}// 快速幂算法：用于求解 (a^b) % mod 的结果public static long fast_pow(long a, long b, long mod) {long ans = 1; // 记录结果a %= mod;// 快速幂算法是为了高效计算a^b, 举例// 3^5//  = 3 * 3^4//  = 3 * 9^2//  = 3 * 81^1//  = 3 * 81 * 81^0// 这个过程中如果发现b为奇数，则析出一个底a作为乘数, 实现 b-=1// 这个过程中如果发现b为偶数，则底a进行平方运算，实现 b/=2// 这个算法求解a^b的时间复杂度为O(log2(b)), 相较于O(b)算法十分高效while (b != 0) {if (b % 2 == 1) { // 位运算优化： if(b&1 == 1)// 3^5 析出来一个3后, 变为 3 * 3^4, 将b值从奇数变为偶数// 下面将析出的来3合入结果ans中, 则剩余3^4ans = (ans * a) % mod;// b -= 1; // 可以不用此步, 因为后面b会整除2}// 3^4 变为 9^2a = (a * a) % mod; // 底数3 变为 9b /= 2; // 幂4 变为 2  // 位运算优化： b>>=1}return ans;}
}

JS算法源码

解法一：基于BigInt类型
const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;let fact;void (async function () {// 初始化1~500的阶乘initFact();// 输入获取const t = parseInt(await readline());for (let i = 0; i < t; i++) {const s = await readline();// 核心代码调用console.log(solution(s));}
})();function initFact() {fact = new Array(501);fact[0] = BigInt(1);for (let i = 1; i <= 500; i++) {fact[i] = BigInt(i) * fact[i - 1];}
}function solution(s) {// 求s串每个字符c的数量const count = new Array(26).fill(0);for (let i = 0; i < s.length; i++) {count[s.charCodeAt(i) - 97]++;}// "出现次数为奇数次的"字符的数量let odd = 0;for (let i = 0; i < 26; i++) {if (count[i] % 2 != 0) {odd++;}count[i] = parseInt(count[i] / 2); // 只保留一半字符数量, 后续只需要用到回文串的左半部分，即一半的字符}// 如果"出现次数为奇数次的"字符的数量不止1个，则s串无法重组出回文串if (odd > 1) {return "0";}// 不重复的全排列数let ans = fact[parseInt(s.length / 2)];for (let i = 0; i < 26; i++) {ans = ans / fact[count[i]];}return (ans % BigInt("1000000007")).toString();
}
解法二：除法取模，乘法逆元，费马小定理，快速幂

JS使用快速幂的意义不大，因为JS普通数值最大只能表示(2^53)-1，如果超出这个数值，那么计算结果就会不准确。

而求解快速幂的过程中，是非常有可能产生一个大于(2^53)-1的值的，JS貌似没有像Java一样做long * long % long 这种计算过程的精度保护。

因此，JS实现快速幂的过程中，我们还是需要使用BigInt，那么又有什么意义使用快速幂呢？

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;const mod = BigInt(1000000007);
const fact = new Array(501);void (async function () {// 初始化1~500的阶乘initFact();// 输入获取const t = parseInt(await readline());for (let i = 0; i < t; i++) {const s = await readline();// 核心代码调用console.log(solution(s));}
})();function initFact() {fact[0] = 1n;for (let i = 1; i <= 500; i++) {fact[i] = (BigInt(i) * fact[i - 1]) % mod;}
}function solution(s) {// 求s串每个字符c的数量const count = new Array(26).fill(0);for (let i = 0; i < s.length; i++) {count[s.charCodeAt(i) - 97]++;}// "出现次数为奇数次的"字符的数量let odd = 0;for (let i = 0; i < 26; i++) {if (count[i] % 2 != 0) {odd++;}count[i] >>= 1; // 只保留一半字符数量, 后续只需要用到回文串的左半部分，即一半的字符}// 如果"出现次数为奇数次的"字符的数量不止1个，则s串无法重组出回文串if (odd > 1) {return 0;}// 不重复的全排列数let ans = fact[s.length >> 1];for (let i = 0; i < 26; i++) {// 假设 x == fact[count[i] / 2]// ans / x % mod// 等价于// ans * x的乘法逆元 % mod// 而x的乘法逆元为 fast_pow(x, mod-2, mod)ans = (ans * fast_pow(fact[count[i]], mod - 2n, mod)) % mod;}return ans.toString();
}// 快速幂算法：用于求解 (a^b) % mod 的结果
function fast_pow(a, b, mod) {let ans = 1n; // 记录结果a %= mod;// 快速幂算法是为了高效计算a^b, 举例// 3^5//  = 3 * 3^4//  = 3 * 9^2//  = 3 * 81^1//  = 3 * 81 * 81^0// 这个过程中如果发现b为奇数，则析出一个底a作为乘数, 实现 b-=1// 这个过程中如果发现b为偶数，则底a进行平方运算，实现 b/=2// 这个算法求解a^b的时间复杂度为O(log2(b)), 相较于O(b)算法十分高效while (b != 0n) {if (b % 2n == 1n) {// 3^5 析出来一个3后, 变为 3 * 3^4, 将b值从奇数变为偶数// 下面将析出的来3合入结果ans中, 则剩余3^4ans = (ans * a) % mod;b -= 1n;}// 3^4 变为 9^2a = (a * a) % mod; // 底数3 变为 9b /= 2n; // 幂4 变为 2}return ans;
}

Python算法源码

解法一：除法取模，乘法逆元，费马小定理，快速幂
# 全局变量
fact = [0] * 501
mod = 1000000007def initFact():fact[0] = 1for i in range(1, 501):fact[i] = i * fact[i - 1] % mod# 快速幂算法：用于求解 (a^b) % mod 的结果
def fast_pow(a, b):ans = 1  # 记录结果a %= mod# 快速幂算法是为了高效计算a^b, 举例# 3 ^ 5# = 3 * 3 ^ 4# = 3 * 9 ^ 2# = 3 * 81 ^ 1# = 3 * 81 * 81 ^ 0# 这个过程中如果发现b为奇数，则析出一个底a作为乘数, 实现 b -= 1# 这个过程中如果发现b为偶数，则底a进行平方运算，实现 b /= 2# 这个算法求解a ^ b的时间复杂度为O(log2(b)), 相较于O(b)算法十分高效while b != 0:if b % 2 == 1:  # 位运算优化： if(b&1 == 1)# 3^5 析出来一个3后, 变为 3 * 3^4, 将b值从奇数变为偶数# 下面将析出的来3合入结果ans中, 则剩余3^4ans = ans * a % mod# b -= 1; # 可以不用此步, 因为后面b会整除2# 3^4 变为 9^2a = a * a % mod  # 底数3 变为 9b //= 2  # 幂4 变为 2  # 位运算优化： b>>=1return ansdef solution(s):# 求s串每个字符c的数量count = [0] * 26for i in range(len(s)):count[ord(s[i]) - 97] += 1# "出现次数为奇数次的"字符的数量odd = 0for i in range(26):if count[i] % 2 != 0:odd += 1count[i] //= 2  # 只保留一半字符数量, 后续只需要用到回文串的左半部分，即一半的字符即可# 如果"出现次数为奇数次的"字符的数量不止1个，则s串无法重组出回文串if odd > 1:return 0# 不重复的全排列数ans = fact[len(s) // 2]for i in range(26):# 假设 x == fact[count[i] / 2]# ans / x % mod# 等价于# ans * x的乘法逆元 % mod# 而x的乘法逆元为 fast_pow(x, mod-2, mod)ans = ans * fast_pow(fact[count[i]], mod - 2) % modreturn ansif __name__ == '__main__':# 初始化1~500的阶乘initFact()# 输入获取t = int(input())for _ in range(t):# 核心代码调用print(solution(input()))
解法二：使用内置函数pow代替快速幂
# 全局变量
fact = [0] * 501
mod = 1000000007def initFact():fact[0] = 1for i in range(1, 501):fact[i] = i * fact[i - 1] % moddef solution(s):# 求s串每个字符c的数量count = [0] * 26for i in range(len(s)):count[ord(s[i]) - 97] += 1# "出现次数为奇数次的"字符的数量odd = 0for i in range(26):if count[i] % 2 != 0:odd += 1count[i] //= 2  # 只保留一半字符数量, 后续只需要用到回文串的左半部分，即一半的字符即可# 如果"出现次数为奇数次的"字符的数量不止1个，则s串无法重组出回文串if odd > 1:return 0# 不重复的全排列数ans = fact[len(s) // 2]for i in range(26):# 假设 x == fact[count[i] / 2]# ans / x % mod# 等价于# ans * x的乘法逆元 % mod# 而x的乘法逆元为 fast_pow(x, mod-2, mod)ans = ans * pow(fact[count[i]], mod - 2, mod) % modreturn ansif __name__ == '__main__':# 初始化1~500的阶乘initFact()# 输入获取t = int(input())for _ in range(t):# 核心代码调用print(solution(input()))

C算法源码

除法取模，乘法逆元，费马小定理，快速幂

#include <stdio.h>
#include <string.h>#define MAX_LEN 1001
#define MOD 1000000007long long fact[501] = {0};void initFact() {fact[0] = 1;for (int i = 1; i <= 500; i++) {fact[i] = i * fact[i - 1] % MOD;}
}// 快速幂算法：用于求解 (a^b) % mod 的结果
long long fast_pow(long long a, long long b) {long long ans = 1; // 记录结果a %= MOD;// 快速幂算法是为了高效计算a^b, 举例// 3^5//  = 3 * 3^4//  = 3 * 9^2//  = 3 * 81^1//  = 3 * 81 * 81^0// 这个过程中如果发现b为奇数，则析出一个底a作为乘数, 实现 b-=1// 这个过程中如果发现b为偶数，则底a进行平方运算，实现 b/=2// 这个算法求解a^b的时间复杂度为O(log2(b)), 相较于O(b)算法十分高效while (b != 0) {if (b % 2 == 1) { // 位运算优化： if(b&1 == 1)// 3^5 析出来一个3后, 变为 3 * 3^4, 将b值从奇数变为偶数// 下面将析出的来3合入结果ans中, 则剩余3^4ans = ans * a % MOD;// b -= 1; // 可以不用此步, 因为后面b会整除2}// 3^4 变为 9^2a = a * a % MOD; // 底数3 变为 9b /= 2; // 幂4 变为 2  // 位运算优化： b>>=1}return ans;
}long long solution(char *s) {// 求s串每个字符c的数量int count[26] = {0};for (int i = 0; i < strlen(s); i++) {char c = s[i];count[c - 'a']++;}// "出现次数为奇数次的"字符的数量int odd = 0;for (int i = 0; i < 26; i++) {if (count[i] % 2 != 0) {odd++;}count[i] /= 2; // 只保留一半字符数量, 后续只需要用到回文串的左半部分，即一半的字符即可}// 如果"出现次数为奇数次的"字符的数量不止1个，则s串无法重组出回文串if (odd > 1) {return 0;}// 不重复的全排列数long long ans = fact[strlen(s) / 2];for (int i = 0; i < 26; i++) {// 假设 x == fact[count[i] / 2]// ans / x % mod// 等价于// ans * x的乘法逆元 % mod// 而x的乘法逆元为 fast_pow(x, mod-2, mod)ans = ans * fast_pow(fact[count[i]], MOD - 2) % MOD;}return ans;
}int main() {// 初始化1~500的阶乘initFact();// 输入获取int t;scanf("%d", &t);while (t--) {char s[MAX_LEN];scanf("%s", s);// 核心代码调用printf("%lld\n", solution(s));}return 0;
}

C++算法源码

除法取模，乘法逆元，费马小定理，快速幂

#include <bits/stdc++.h>
using namespace std;#define MOD 1000000007
long long fact[501] = {0};void initFact() {fact[0] = 1;for (int i = 1; i <= 500; i++) {fact[i] = i * fact[i - 1] % MOD;}
}// 快速幂算法：用于求解 (a^b) % mod 的结果
long long fast_pow(long long a, long long b) {long long ans = 1; // 记录结果a %= MOD;// 快速幂算法是为了高效计算a^b, 举例// 3^5//  = 3 * 3^4//  = 3 * 9^2//  = 3 * 81^1//  = 3 * 81 * 81^0// 这个过程中如果发现b为奇数，则析出一个底a作为乘数, 实现 b-=1// 这个过程中如果发现b为偶数，则底a进行平方运算，实现 b/=2// 这个算法求解a^b的时间复杂度为O(log2(b)), 相较于O(b)算法十分高效while (b != 0) {if (b % 2 == 1) { // 位运算优化： if(b&1 == 1)// 3^5 析出来一个3后, 变为 3 * 3^4, 将b值从奇数变为偶数// 下面将析出的来3合入结果ans中, 则剩余3^4ans = ans * a % MOD;// b -= 1; // 可以不用此步, 因为后面b会整除2}// 3^4 变为 9^2a = a * a % MOD; // 底数3 变为 9b /= 2; // 幂4 变为 2  // 位运算优化： b>>=1}return ans;
}long long solution(string &s) {// 求s串每个字符c的数量int count[26] = {0};for (int i = 0; i < s.length(); i++) {char c = s[i];count[c - 'a']++;}// "出现次数为奇数次的"字符的数量int odd = 0;for (int i = 0; i < 26; i++) {if (count[i] % 2 != 0) {odd++;}count[i] /= 2; // 只保留一半字符数量, 后续只需要用到回文串的左半部分，即一半的字符即可}// 如果"出现次数为奇数次的"字符的数量不止1个，则s串无法重组出回文串if (odd > 1) {return 0;}// 不重复的全排列数long long ans = fact[s.length() / 2];for (int i = 0; i < 26; i++) {// 假设 x == fact[count[i] / 2]// ans / x % mod// 等价于// ans * x的乘法逆元 % mod// 而x的乘法逆元为 fast_pow(x, mod-2, mod)ans = ans * fast_pow(fact[count[i]], MOD - 2) % MOD;}return ans;
}int main() {// 初始化1~500的阶乘initFact();// 输入获取int t;cin >> t;while (t--) {string s;cin >> s;// 核心代码调用cout << solution(s) << endl;}return 0;
}

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

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

相关文章

MySQL之优化服务器设置(五)

MySQL之优化服务器设置(五)

优化服务器设置 高级InnoDB设置 innodb_old_blocks_time InnoDB有两段缓冲池LRU(最近最少使用)链表&#xff0c;设计目的是防止换出长期很多次的页面。像mysqldump产生的这种一次性的(大)查询&#xff0c;通常会读取页面到缓冲池的LRU列表&#xff0c;从中读取需要的行&…
阅读更多...
Android 支持库迁移到AndroidX

Android 支持库迁移到AndroidX

对应官方文档&#xff1a; developer.android.com/jetpack/and… 简单点说就是&#xff0c;对App开发者而言&#xff0c;AndroidX更加友好&#xff0c;因为我们引入时&#xff0c;只需要关注AndroidX中具体的需要引入的构件版本即可。且大部分具体的构件&#xff0c;具有一致的…
阅读更多...
Ansys Mechanical｜学习方法

Ansys Mechanical｜学习方法

Ansys Mechanical是Ansys的旗舰产品之一&#xff0c;涉及的学科体系全面丰富&#xff0c;包括的力学分支主要有理论力学&#xff0c;振动理论&#xff0c;连续介质力学&#xff0c;固态力学&#xff0c;物理力学&#xff0c;爆炸力学及应用力学等。 在自媒体及数字经济飞速发展…
阅读更多...
单例集合:Collection

单例集合:Collection

一.Collection Collection是单列集合的祖宗接口,它的功能是全部单列集合都可以继承使用的。 一.add添加 1.细节1 如果我们要往List系列集合中添加数据,那么方法永远返回true,因为List系列的是允许元素重复的。 2.细节2 如果要往Set系列集合中添加数据,如果当前要添加元素不…
阅读更多...
【Linux】进程间通信1——管道概念，匿名管道

【Linux】进程间通信1——管道概念，匿名管道

1.进程间通信介绍 进程是计算机系统分配资源的最小单位&#xff08;严格说来是线程&#xff09;。每个进程都有自己的一部分独立的系统资源&#xff0c;彼此是隔离的。为了能使不同的进程互相访问资源并进行协调工作&#xff0c;才有了进程间通信。 进程间通信&#xff0c;顾名…
阅读更多...
如何利用 TypeScript 的判别联合类型提升错误处理与代码安全性

如何利用 TypeScript 的判别联合类型提升错误处理与代码安全性

欢迎回到 TypeScript 高级技巧系列文章。我们之前已经讨论了Extract、Exclude和Indexed Access Types&#xff0c;接下来我们将深入探讨我最喜欢的TypeScript特性之一&#xff1a;判别联合类型&#xff08;Discriminated Unions&#xff09;。为什么我如此钟爱它呢&#xff1f;…
阅读更多...
【ROS里程计】中部分代码解释

【ROS里程计】中部分代码解释

bool OdomNodePub::Odom_Reset(ubt_odom::odomreset::Request& req, ubt_odom::odomreset::Response& res) {if(req.cmd "reset"){OdomResetFlag true;}else{OdomResetFlag false;}res.state "success";return true; } 该函数是一个ROS节点中…
阅读更多...
【Mybatis-Plus】根据自定义注解实现自动加解密

【Mybatis-Plus】根据自定义注解实现自动加解密

背景 我们把数据存到数据库的时候&#xff0c;有些敏感字段是需要加密的&#xff0c;从数据库查出来再进行解密。如果存在多张表或者多个地方需要对部分字段进行加解密操作&#xff0c;每个地方都手写一次加解密的动作&#xff0c;显然不是最好的选择。如果我们使用的是Mybati…
阅读更多...
边缘微型AI的宿主？—— RISC-V芯片

边缘微型AI的宿主？—— RISC-V芯片

一、RISC-V技术 RISC-V&#xff08;发音为 "risk-five"&#xff09;是一种基于精简指令集计算&#xff08;RISC&#xff09;原则的开放源代码指令集架构&#xff08;ISA&#xff09;。它由加州大学伯克利分校在2010年首次发布&#xff0c;并迅速获得了全球学术界和工…
阅读更多...
嵌入式门槛高不高，工资怎么样？

嵌入式门槛高不高，工资怎么样？

一般来说&#xff0c;嵌入式岗位的准入门槛其实并不是特别高。通常情况下&#xff0c;只要能够熟练掌握 C 语言编程以及单片机相关知识&#xff0c;就能够去制作一些较为简单的电子产品&#xff0c;由此可见其门槛相对而言是比较低的&#xff0c;相应的薪水可能也不会特别高。 …
阅读更多...
数据库-数据定义和操纵-初始MySQL数据库

数据库-数据定义和操纵-初始MySQL数据库

连接数据库&#xff1a; mysql -u用户名 -p密码 创建数据库&#xff1a; create database 数据库名; 命令查看MySQL中已存在的数据库 show database; 数据库中创建表的规则&#xff1a; CREATE TABLE 表名 (字段名,数据类型,字段名,数据类型,..... ) eg: 首先创建数据库&am…
阅读更多...
计算机专业：黄金时代是否依旧？

计算机专业：黄金时代是否依旧？

计算机专业&#xff1a;黄金时代是否依旧&#xff1f; 随着2024年高考落幕&#xff0c;数百万高三学生将面临人生中的重要抉择&#xff1a;选择大学专业。在这个关键节点&#xff0c;计算机相关专业是否仍是“万金油”的选择&#xff1f;在过去的几十年里&#xff0c;计算机科…
阅读更多...
fetch_lfw_people（）报错urllib.error.HTTPError: HTTP Error 403: Forbidden的解决方案

fetch_lfw_people（）报错urllib.error.HTTPError: HTTP Error 403: Forbidden的解决方案

零、实验报告地址 计算机视觉实验二：基于支持向量机和随机森林的分类（Part one: 编程实现基于支持向量机的人脸识别分类 ）-CSDN博客 一、代码报错 fetch_lfw_people（）报错urllib.error.HTTPError: HTTP Error 403: Forbidden 二、报错原因 通常是由于访问权限不足导致的…
阅读更多...
Mysql中索引详解

Mysql中索引详解

1、什么是索引 在日常学习中&#xff0c;最常见使用索引的例子就是词典&#xff0c;通过对字母进行排序&#xff0c;并设置对应的页数&#xff0c;从而循序定位某个单词&#xff0c;除了词典&#xff0c;如火车站的车次表、图书的目录等都是使用了索引。它们的原理都是一样的&…
阅读更多...
C++11参数包...Args

C++11参数包...Args

以list中的包装器做介绍 包装器是由一个类模板接收后存储在统一的...Args中 标准格式 说明&#xff1a;...Args就是参数包的类型 实例&#xff1a; //参数包 void Show() {cout <<"结束" << endl; }template<class T,class ...Args> void Show(T…
阅读更多...
LabVIEW与C#的区别及重新开发自动测试程序的可行性分析

LabVIEW与C#的区别及重新开发自动测试程序的可行性分析

LabVIEW和C#是两种广泛使用的编程语言&#xff0c;各自有不同的应用领域和特点。本文将详细比较LabVIEW与C#在自动测试程序开发中的区别&#xff0c;并分析将已完成的LabVIEW自动测试程序重新用C#开发的合理性。本文帮助评估这种转换的必要性和潜在影响。 LabVIEW与C#的区别 开…
阅读更多...
C++编程：vector容器的简单模拟实现

C++编程：vector容器的简单模拟实现

前言&#xff1a; 在C标准库&#xff08;STL&#xff09;中&#xff0c;vector容器是最常见使用的动态数组。它结合了链表与数组的优点&#xff0c;提供了灵活的大小调整与高效的随机访问。本文将简单的对vector容器进行介绍并且对vector容器简单的模拟实现。 一、vector的文…
阅读更多...
uniapp实现路由拦截——实战案例（二）

uniapp实现路由拦截——实战案例（二）

uniapp如何实现登录路由拦截&#xff1f; 今天再次介绍一下 uni-simple-router 插件&#xff0c;记得最初使用时&#xff0c;是在三年以前了&#xff0c;这里简单介绍通过自动读取 pages.json 作为路由表的方式&#xff0c;欢迎指教~ 文章目录 uniapp如何实现登录路由拦截&…
阅读更多...
LangChain入门学习笔记（二）——LangChain表达式语言(LCEL)

LangChain入门学习笔记（二）——LangChain表达式语言(LCEL)

基于LangChain框架编写大模型应用的过程就像垒积木&#xff0c;其中的积木就是Prompts&#xff0c;LLMs和各种OutputParser等。如何将这些积木组织起来&#xff0c;除了使用基本Python语法调用对应类的方法&#xff0c;一种更灵活的方法就是使用位于LangChain-Core层中的LCEL&a…
阅读更多...
SwiftUI 6.0（Xcode 16）全新 @Entry 和 @Previewable 宏让开发妙趣横生

SwiftUI 6.0（Xcode 16）全新 @Entry 和 @Previewable 宏让开发妙趣横生

概览 如火如荼的 WWDC 2024 已进入第五天&#xff0c;苹果开发平台中众多海量新功能都争先恐后的喷薄欲出。 在这里就让我们从中挑两个轻松有趣的新功能展示给小伙伴们吧&#xff1a;它们分别是 全新的 Entry 和 Previewable 宏。 在本篇博文中&#xff0c;您将学到如下内容&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023