AC自动机求定长不含关键词的串的种数

最新推荐文章于 2024-07-24 20:44:05 发布
最新推荐文章于 2024-07-24 20:44:05 发布
阅读量90 收藏
点赞数
分类专栏： 算法学习 做题笔记 文章标签： acm竞赛 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xhyu61/article/details/124464288
版权

题目大意

给定 m m m个字符串，求长度为 n n n的、给定的 m m m个字符串不是其子串的字符串的种类数量。

做法

对 m m m个字符串建立一个AC自动机。此时我们考虑这个AC自动机中fail指针的含义，就是失配后通过特定字母可以到达的结点位置。

那么，整个AC自动机上，基于trie树的节点之间的父子关系+fail指针构成了节点与节点之间的移动路线。

我们从AC自动机的 0 0 0号点(trie树的根)出发，每走一步就相当于增加了一个字母，那么最后就是看从 0 0 0开始，走 n n n步到达所有可以到达的点的方案数。

所谓可以到达的点，就是可以走到的节点。换言之，如果走到这个节点凑出了 m m m个字符串之一，那么就是不合法节点，即不可到达的点。反过来就是可以到达的。

什么样的点是不可到达的？如上所说，凑出了 m m m个字符串之一，即关键词的最后一个字母所代表的节点，一定是不可到达的。
根据fail指针的定义，我们也可以发现，如果一个节点可以通过fail指针失配到一个不可到达的节点，那么这个节点也一定是不可到达的。

统计出不可到达的点之后，我们来看每一个点走一步之后可以到达哪些位置。

一般这种题目AC自动机的节点数量会非常少，所以我们可以用二维数组 c n t cnt cnt存储节点与节点之间走一步能否达到的关系。我们遍历每一个可以达到的节点 u u u，如果他可以去另外一个可以达到的节点 v v v，那么我们令 c n t [ u ] [ v ] + + cnt[u][v]++ cnt[u][v]++。

全部统计完后，我们就获得了走一步之后，第 i i i个节点能否到第 j j j个节点了。将其封装成一个矩阵 A A A。如果我们要走 n n n步，那么就求出矩阵 A A A的 n n n次幂，然后求最终结果矩阵 B B B中对于所有 i ∈ [ 0 , t o t ] i∈[0,tot] i∈[0,tot]（tot是AC自动机中的点数）中 B [ 0 ] [ i ] B[0][i] B[0][i]的和。这个和就是题目的答案，即长度为 n n n的字符串中不包含 m m m个关键词的种类个数。

即：假设

A = [ a 0 , 0 a 0 , 1 ⋯ a 0 , t o t a 1 , 0 a 1 , 1 ⋯ a 1 , t o t ⋮ ⋮ ⋱ ⋮ a t o t , 0 a t o t , 1 ⋯ a t o t , t o t ] A= \left[ \begin{matrix} a_{0,0} & a_{0,1} & \cdots & a_{0,tot} \\ a_{1,0} & a_{1,1} & \cdots & a_{1,tot} \\ \vdots & \vdots & \ddots & \vdots \\ a_{tot,0} & a_{tot,1} & \cdots & a_{tot,tot} \end{matrix} \right] A=⎣⎢⎢⎢⎡​a0,0​a1,0​⋮atot,0​​a0,1​a1,1​⋮atot,1​​⋯⋯⋱⋯​a0,tot​a1,tot​⋮atot,tot​​⎦⎥⎥⎥⎤​

那么答案 a n s = a 0 , 0 + a 0 , 1 + a 0 , 2 + ⋯ + a 0 , t o t ans=a_{0,0}+a_{0,1}+a_{0,2}+\cdots +a_{0,tot} ans=a0,0​+a0,1​+a0,2​+⋯+a0,tot​，表示走 n n n步后从 0 0 0点走到各个点的方案数之和。

一般情况下 n n n会非常大，大约是 2 31 2^{31} 231的数量级，所以必须要用矩阵快速幂来加速矩阵运算。

POJ 2778 - DNA Sequence

和上面的题意完全一致。（或者说上面的题意是照着这个题目写的）
题目链接
传递的字母只有4个。

Code:

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<cstdlib>
#include<queue>
using namespace std;
typedef long long LL;
const LL p = 100000;
const int N = 15;
const int matSize = 150;

int bad[N * 15];

int getID(char c) {
	if (c == 'A') return 0;
	else if (c == 'T') return 1;
	else if (c == 'C') return 2;
	else return 3; 
}

int tot;
int tr[N * 15][5], fail[N * 15], idx[N * 15], val[N * 15], cnt[N];

struct AC_Automaton {
	void init() {
		tot = 0;
		memset(bad, 0, sizeof(bad));
	}
	 
	void insert(char *s, int id) {
		int u = 0;
		for (int i = 1; s[i]; ++i) {
			if (!tr[u][getID(s[i])]) tr[u][getID(s[i])] = ++tot;
			u = tr[u][getID(s[i])];
		}
		idx[u] = id; bad[u] = 1;
	}
	
	queue<int> q;
	
	void build() {
		for (int i = 0; i < 4; ++i) {
			if (tr[0][i]) q.push(tr[0][i]);
		}
		while (q.size()) {
			int u = q.front();
			q.pop();
			for (int i = 0; i < 4; ++i) {
				if (tr[u][i]) {
					fail[tr[u][i]] = tr[fail[u]][i];
					bad[u] |= bad[fail[u]];
					q.push(tr[u][i]);
				}
				else tr[u][i] = tr[fail[u]][i];
			}
		}
	}
	
	int query(char *t) {
		int u = 0, res = 0;
		for (int i = 1; t[i]; ++i) {
			u = tr[u][getID(t[i])];
			for (int j = u; j; j = fail[j]) val[j]++;
		}
		for (int i = 0; i <= tot; ++i) {
			if (idx[i]) {
				res = max(res, val[i]);
				cnt[idx[i]] = val[i];
			}
		}
		return res;
	}
}ac;

struct Matrix {
	int matA[150][150];
	inline Matrix() { memset(matA, 0, sizeof(matA)); }
	inline Matrix operator - (const Matrix &MAT_T) const {
		Matrix MAT_RES;
		for (int i = 0; i < matSize; ++i) for (int j = 0; j < matSize; ++j)
			MAT_RES.matA[i][j] = (matA[i][j] - MAT_T.matA[i][j]) % p;
		return MAT_RES;
	}
	inline Matrix operator + (const Matrix &MAT_T) const {
		Matrix MAT_RES;
		for (int i = 0; i < matSize; ++i) for (int j = 0; j < matSize; ++j)
			MAT_RES.matA[i][j] = (matA[i][j] + MAT_T.matA[i][j]) % p;
		return MAT_RES;
	}
	inline Matrix operator * (const Matrix &MAT_T) const {
		Matrix MAT_RES;
		for (int i = 0; i <= tot; ++i) {
			for (int j = 0; j <= tot; ++j) {
				MAT_RES.matA[i][j] = 0;
				LL res = 0;
				for (int k = 0; k <= tot; ++k) {
					res += ((LL)matA[i][k] * MAT_T.matA[k][j]);
				}
				MAT_RES.matA[i][j] = res % p;
			}
		}
		return MAT_RES;
	}
	inline Matrix operator ^ (LL MAT_X) const {
		Matrix MAT_RES, MAT_BAS;
		for (int i = 0; i < matSize; ++i) MAT_RES.matA[i][i] = 1;
		for (int i = 0; i < matSize; ++i) for (int j = 0; j < matSize; ++j)
			MAT_BAS.matA[i][j] = matA[i][j];
		while (MAT_X) {
			if (MAT_X&1ll)MAT_RES=MAT_RES*MAT_BAS; 
			MAT_BAS=MAT_BAS*MAT_BAS; MAT_X>>=1;
		}
		return MAT_RES;
	}
};

int n, m;
char s[15];

Matrix Power(Matrix &A, int a) {
	Matrix ans;
	for (int i = 0; i <= tot; ++i) {
		ans.matA[i][i] = 1;
	} 
	while (a) {
		if (a & 1) ans = ans * A;
		A = A * A;
		a >>= 1;
	}
	return ans;
}

int main() {
	scanf("%d%d", &m, &n);
	ac.init();
	for (int i = 1; i <= m; ++i) {
		scanf("%s", s + 1);
		ac.insert(s, i);
	}
	ac.build();
	Matrix A;
	for (int i = 0; i <= tot; ++i) {
		if (bad[i]) continue;
		for (int j = 0; j <= 3; ++j) {
			int nxt = tr[i][j];
			if (!bad[nxt]) ++A.matA[i][nxt];
		}
	}
	A = Power(A, n);
	LL ans = 0;
	for (int i = 0; i <= tot; ++i) {
		ans = (ans + A.matA[0][i]);
	} 
	printf("%d", ans % p);
	return 0;
}

HDU 2243 - 考试路茫茫——单词情结

这个题和上一个题刚好反过来，是求长度不超过 n n n的所有串里包含 m m m个关键词中任意一个或多个的串的种类数量。

解法

既然是反过来的题目，那我们也反过来解。我们会求不包含这些词的串的数量，那我们就求所有可能的串的种数-不包含这些词的串的数量，就是我们要求的答案。

所有可能的串的种数非常好求。长度为 1 1 1的串的数量是 26 26 26，长度为 2 2 2的串的数量是 2 6 2 26^2 262，长度为 3 3 3的串的数量是 2 6 3 26^3 263……

所以所有可能的串的总数 S = 2 6 1 + 2 6 2 + ⋯ + 2 6 n S=26^1+26^2+\cdots+26^n S=261+262+⋯+26n。

但是这道题目 n n n非常大，是 2 31 2^{31} 231级别的，所以 O ( n ) O(n) O(n)是不行的。我们考虑用矩阵来求。我们可以列出以下矩阵乘法式：

[ 26 1 0 1 ] n [ 1 1 ] = [ S + 1 1 ] \left[ \begin{matrix} 26 & 1 \\ 0 & 1 \end{matrix} \right]^n \left[ \begin{matrix} 1 \\ 1 \end{matrix} \right] = \left[ \begin{matrix} S+1 \\ 1 \end{matrix} \right] [260​11​]n[11​]=[S+11​]

这样的话利用矩阵快速幂就可以在 O ( log ⁡ n ) O(\log n) O(logn)的时间复杂度里求出 S S S。

现在来求长度不超过 n n n的不包含 m m m个关键词的串的种数。我们现在会求长度固定的串的种数。假设我们获得的移动一位的矩阵是 A A A。如果定长的话，我们令 B = A n B=A^n B=An，如果
B = [ b 0 , 0 b 0 , 1 ⋯ b 0 , t o t b 1 , 0 b 1 , 1 ⋯ b 1 , t o t ⋮ ⋮ ⋱ ⋮ b t o t , 0 b t o t , 1 ⋯ b t o t , t o t ] B= \left[ \begin{matrix} b_{0,0} & b_{0,1} & \cdots & b_{0,tot} \\ b_{1,0} & b_{1,1} & \cdots & b_{1,tot} \\ \vdots & \vdots & \ddots & \vdots \\ b_{tot,0} & b_{tot,1} & \cdots & b_{tot,tot} \end{matrix} \right] B=⎣⎢⎢⎢⎡​b0,0​b1,0​⋮btot,0​​b0,1​b1,1​⋮btot,1​​⋯⋯⋱⋯​b0,tot​b1,tot​⋮btot,tot​​⎦⎥⎥⎥⎤​

那么对于长度为 n n n的串的种类数量 a n s n = b 0 , 0 + b 0 , 1 + ⋯ + b 0 , t o t ans_n=b_{0,0}+b_{0,1}+\cdots+b_{0,tot} ansn​=b0,0​+b0,1​+⋯+b0,tot​。

我们现在要求的是 a n s 1 + a n s 2 + ⋯ + a n s n ans_1+ans_2+\cdots+ans_n ans1​+ans2​+⋯+ansn​。

我们不能 O ( n ) O(n) O(n)求，那么就需要借助矩阵来求。这里有一个小技巧，我们只需要把整个矩阵尺寸放大一圈，外围都用 0 0 0和 1 1 1填充，像这个样子——

A = [ a 0 , 0 a 0 , 1 ⋯ a 0 , t o t 1 a 1 , 0 a 1 , 1 ⋯ a 1 , t o t 1 ⋮ ⋮ ⋱ ⋮ ⋮ a t o t , 0 a t o t , 1 ⋯ a t o t , t o t 1 0 0 ⋯ 0 1 ] A= \left[ \begin{matrix} a_{0,0} & a_{0,1} & \cdots & a_{0,tot} & 1 \\ a_{1,0} & a_{1,1} & \cdots & a_{1,tot} & 1 \\ \vdots & \vdots & \ddots & \vdots & \vdots \\ a_{tot,0} & a_{tot,1} & \cdots & a_{tot,tot} & 1 \\ 0 & 0 & \cdots & 0 & 1 \end{matrix} \right] A=⎣⎢⎢⎢⎢⎢⎡​a0,0​a1,0​⋮atot,0​0​a0,1​a1,1​⋮atot,1​0​⋯⋯⋱⋯⋯​a0,tot​a1,tot​⋮atot,tot​0​11⋮11​⎦⎥⎥⎥⎥⎥⎤​

我们试着来给他乘方，令 A i A^i Ai的右上角元素为 x i x_i xi​，我们惊奇地发现，有

x i = 1 + a n s 1 + ⋯ + a n s i − 1 x_i=1+ans_1+\cdots + ans_{i-1} xi​=1+ans1​+⋯+ansi−1​

那么有

x n = 1 + a n s 1 + ⋯ + a n s n − 1 x_n=1+ans_1+\cdots+ans_{n-1} xn​=1+ans1​+⋯+ansn−1​

如果 B = A n B=A^n B=An，那么我们可以通过 B B B求得 a n s n ans_n ansn​：

a n s n = b 0 , 0 + b 0 , 1 + ⋯ + b 0 , t o t ans_n=b_{0,0}+b_{0,1}+\cdots+b_{0,tot} ansn​=b0,0​+b0,1​+⋯+b0,tot​

而 x n = b 0 , t o t + 1 x_n=b_{0,tot+1} xn​=b0,tot+1​， a n s 0 = 1 ans_0=1 ans0​=1，所以我们长度不超过 n n n的所有不包含给出的字符串的串的种数 a n s ans ans：

a n s = b 0 , 0 + b 0 , 1 + ⋯ + b 0 , t o t + 1 − 1 ans=b_{0,0}+b_{0,1}+\cdots+b_{0,tot+1}-1 ans=b0,0​+b0,1​+⋯+b0,tot+1​−1

那么包含给出的 m m m个字符串中的一个或多个的字符串的种数就是 S − a n s S-ans S−ans。

注意unsigned long long输出。

Code:

#include<bits/stdc++.h>
using namespace std;
typedef unsigned long long LL;
const LL matSize = 50;
const LL N = 8;

LL n, m;
LL tot;
LL tr[N * 10][26], fail[N * 10], bad[N * 10], val[N * 10], cnt[N];

struct AC_Automaton {
	void init() {
		memset(fail, 0, sizeof(fail));
		memset(tr, 0, sizeof(tr));
		memset(val, 0, sizeof(val));
		memset(cnt, 0, sizeof(cnt));
		memset(bad, 0, sizeof(bad));
		tot = 0;
	}
	
	void insert(char *s, int id) {
		int u = 0;
		for (int i = 1; s[i]; ++i) {
			if (!tr[u][s[i] - 'a']) tr[u][s[i] - 'a'] = ++tot;
			u = tr[u][s[i] - 'a'];
		}
		bad[u] = 1;
	}
	
	queue<int> q;
	
	void build() {
		for (int i = 0; i < 26; ++i) {
			if (tr[0][i]) q.push(tr[0][i]);
		}
		while (q.size()) {
			int u = q.front();
			q.pop();
			for (int i = 0; i < 26; ++i) {
				if (tr[u][i]) {
					fail[tr[u][i]] = tr[fail[u]][i];
					bad[u] |= bad[fail[u]];
					q.push(tr[u][i]);
				}
				else tr[u][i] = tr[fail[u]][i];
			}
		}
	}
}ac;

struct Matrix
{
	LL ms = matSize;
	LL matA[matSize][matSize];
	inline Matrix() { memset(matA, 0, sizeof(matA)); }
	inline Matrix operator - (const Matrix &MAT_T) const {
		Matrix MAT_RES;
		for (int i = 0; i < ms; ++i) for (int j = 0; j < ms; ++j)
			MAT_RES.matA[i][j] = (matA[i][j] - MAT_T.matA[i][j]);
		return MAT_RES;
	}
	inline Matrix operator + (const Matrix &MAT_T) const {
		Matrix MAT_RES;
		for (int i = 0; i < ms; ++i) for (int j = 0; j < ms; ++j)
			MAT_RES.matA[i][j] = (matA[i][j] + MAT_T.matA[i][j]);
		return MAT_RES;
	}
	inline Matrix operator * (const Matrix &MAT_T) const {
		Matrix MAT_RES; LL MAT_R;
		for (int i = 0; i < ms; ++i) for (int k = 0; k < ms; ++k){
			MAT_R = matA[i][k];
			for (int j = 0; j < ms; ++j)
				MAT_RES.matA[i][j]+=(MAT_T.matA[k][j]*MAT_R);
		}
		return MAT_RES;
	}
	inline Matrix operator ^ (LL MAT_X) const {
		Matrix MAT_RES, MAT_BAS;
		for (int i = 0; i < ms; ++i) MAT_RES.matA[i][i] = 1;
		for (int i = 0; i < ms; ++i) for (int j = 0; j < ms; ++j)
			MAT_BAS.matA[i][j] = matA[i][j];
		while (MAT_X) {
			if (MAT_X&1)MAT_RES=MAT_RES*MAT_BAS; 
			MAT_BAS=MAT_BAS*MAT_BAS; MAT_X>>=1;
		}
		return MAT_RES;
	}
}ts;

char x[300];
LL S;

void main2() {
	ac.init();
	for (int i = 1; i <= n; ++i) {
		scanf("%s", x + 1);
		ac.insert(x, i);
	}
	ac.build();
	Matrix ans; ans.ms = 2;
	ans.matA[0][0] = ans.matA[1][0] = 1;
	LL res = 0;
	for (int i = 1; i <= 8; ++i) {
		LL tmp = 1;
		for (int j = 1; j <= i; ++j) {
			tmp *= 26;
		}
		res += tmp;
	}
	ans = (ts ^ m) * ans;
	S = ans.matA[0][0];
	Matrix A; A.ms = tot + 3;
	for (int i = 0; i <= tot; ++i) {
		if (bad[i]) continue;
		for (int j = 0; j < 26; ++j) {
			if (!bad[tr[i][j]]) {
				++A.matA[i][tr[i][j]];
			} 
		}
	}
	for (int i = 0; i <= tot + 1; ++i) {
		A.matA[i][tot + 1] = 1;
	}
	A = A ^ m;
	LL fix = 0;
	for (int i = 0; i <= tot + 1; ++i) {
		fix += A.matA[0][i];
	}
	printf("%I64u\n", S - fix);
}

int main() {
	ts.ms = 2;
	ts.matA[0][0] = 26; ts.matA[0][1] = 1;
	ts.matA[1][0] = 0; ts.matA[1][1] = 1;
	while (~scanf("%lld%lld", &n, &m)) {
		main2();
	}
	return 0;
}
xhyu61
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AC自动机_AC自动机模板_
09-30
AC自动机，全称为Aho-Corasick自动机，是一种字符串搜索算法，广泛应用于信息学奥林匹克竞赛、数据结构与算法竞赛以及文本处理等领域。它的主要功能是高效地在一个字符串集合中进行多模式匹配，即同时查找多个模式串...
HDU 6143 Killer Names （容斥/第二类Stirling数）
普通で歩む
08-18 262
思路：考虑左边选i个字符组成长度为n的串，那么右边只能从m-i中选1个/2个/3个。。。m-i个数构成长度为n的串。所以问题就转化成了求i个字符（i个字符都出现）构成长度为n的串的个数，设这个为f(x)f(x)。 我们可知 f(i)=in−∑i−1j=1Cji∗f(j)f(i) = i^n - \sum_{j=1}^{i-1} C_i^j * f(j) 式子意思为：从所有的可能中减去只用其中j种
后缀自动机 AC自动机
qq_62539009的博客
05-10 811
ps：这两个自动机算是字符串算法里最抽象的了。AC自动机还好学会了，后缀自动机断断续续学了两天没学会，只搞懂了大概。关于构造后缀自动机的第三种情况拆点总觉得似懂非懂。先给个板子，以后再补详解。（希望不咕~） void ex_sam(int c){ int p=las,np=las=++cnt;num[cnt]=1; tre[np].len=tre[p].len+1; for(;p&&!tre[p].ch[c];p=tre[p].fa)tre[p].ch[c]=np
AC自动机 C语言 ACM 字符串匹配|AC自动机C语言.rar
10-04
AC自动机，全称为Aho-Corasick自动机，是一种字符串搜索算法，广泛应用于文本处理、数据挖掘等领域。它在ACM（国际大学生程序设计竞赛）中也是一项重要的算法技能，因为它能高效地解决字符串匹配问题，特别是面对...
36丨AC自动机：如何用多模式串匹配实现敏感词过滤功能？1
08-03
AC自动机是一种高效的多模式串匹配算法，主要应用于文本处理中的敏感词过滤、关键词搜索等功能。它的全称为Aho-Corasick算法，由Aho和Corasick在1975年提出。AC自动机在Trie树的基础上进行了扩展，增加了失败指针，...
ac自动机.pptx
07-14
其中,KMP是用于一对一的字符串匹配,而trie虽然能用于多模式匹配,但是每次匹配失败都需要进行回溯,如果模式串很长的话会很浪费时间,所以AC自动机应运而生,如同Manacher一样,AC自动机利用某些操作阻止了模式串匹配阶段...
AC自动机实现多模式串匹配，支持中文
12-25
AC自动机，全称为Aho-Corasick自动机，是一种在文本中高效地进行多模式串匹配的算法。它的核心思想是构建一个自动机结构，该结构能够在一次遍历文本的过程中，同时匹配多个模式串，大大提高了搜索效率，避免了对每一...
算法-KMP字符串匹配
xx_xb的博客
07-23 163
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 385
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 642
AtCoder Beginner Contest 363 ABCDE
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
最新发布
danaaaa的博客
07-24 733
二叉搜索树向左或向右指明方向，不用遍历整个树。
2024.7.19 刷题总结
TheJustice_的博客
07-19 303
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
插入和选择排序
c23856的博客
07-20 529
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
Python鲁汶意外莱顿复杂图拓扑分解算法
跨学科知识视角展现
07-24 744
:dart:算法池化和最佳分区搜索：:pen:网格搜索 | :pen:发现算法池 | :pen:返回指定图的最佳划分 | :pen:返回指定图的最佳分区 | :dart:适应度和聚类比较功能：:pen:图的划分 | :pen:节点度 | :pen:给定算法检测到社群总数 | :pen:图密度 | :pen:社群顶点的度数之和 | :pen:解之间的预期一致 | :pen:联合熵 | :pen:平均内部度、所有可能的节点对的平均路径长度 | :pen:节点指向社群外的边平均比例 | :pen:现有边距离社群比
【常微分方程】
qq_74285286的博客
07-24 242
常微分方程笔记
python实现图像缩放算法
qq_42568323的博客
07-20 397
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
LeetCode977 有序数组的平方
daishabby2486的博客
07-24 574
LeetCode977 有序数组的平方的解题记录。
算法力扣刷题记录 五十六【501.二叉搜索树中的众数】
danaaaa的博客
07-21 883
求众数方法
【刷题汇总 -- 压缩字符串(一)、chika和蜜柑、 01背包】
m0_69455439的博客
07-19 1163
今日刷题汇总day018 -- 压缩字符串(一)、chika和蜜柑、 01背包
字符串匹配算法详解：KMP、BF、BM与AC自动机
"本文主要介绍了多种字符串匹配算法，包括单模字符串匹配的BF算法、KMP算法、BM算法和Horspool算法，以及多模字符串匹配的AC自动机、Wu-Manber算法和Backward Oracle Matching算法。这些算法在文本处理、数据搜索等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值