ac自动机

最新推荐文章于 2024-02-22 00:23:59 发布
最新推荐文章于 2024-02-22 00:23:59 发布
阅读量176 收藏
点赞数
分类专栏： 字符串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CUCUC1/article/details/108164358
版权

https://blog.csdn.net/bestsort/article/details/82947639
https://www.cnblogs.com/cmmdc/p/7337611.html

关于ac自动机，原理还没有很懂，我先就目前的理解说一说我理解的原理，等更彻底的理解之后再来修改补充。

在匹配过程中，如果找到了一个模式串，就把这个串的fail指针指向的其所有的后缀串全部计算进去（应该是这样。。），如果失配了，也要找当前串的存在的后缀串并计算进去

关于建立Trie树，很简单，但是要记录一下这个单词在建立的时候有几次

fail指针，采用bfs的方法：（关于手写队列和stl都可以）
1、第一层节点要特殊处理，使第一层节点的fail指针全部指向根节点，然后将第一层节点全部加入队列
2、一个节点出队列，然后将其存在的子节点的fail指针指向父节点的fail指针指向的节点的具有相同子节点的节点（（有点绕是吧。。）可以看一下上面第一篇文章，里面的图片说明很直观容易理解，）但是要注意，如果父节点fail指向的节点子节点没有与之相同的节点，那就按照这个规律继续向上去找，如果到根节点都找不到，就说明不存在，那么就将这个节点的fail指针直接指向root
3、每一层都重复这个操作，直到Trie的所有节点全部都建立了fail指针

hdu 2222 Keywords Search

//AC自动机
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <queue>
#include <map>
#include <string>
#include <sstream>

using namespace std;

const int Size = 26;
const int MAXL = 55;
const int MAXl  = 1000000 + 5;

struct Trie
{
    int count;//前缀出现次数;
    int sum;//这个节点是不是一个单词的结尾，并记录这个单词在建树的时候出现了几次
    Trie *next[Size];//孩子节点数目
    Trie *fail;
    //bool isEnd;//判断到该点时，是否是一个单词
    //string name;
};

char pat[MAXL],text[MAXl];
int ans;

Trie *root;//建立根节点;

void init(Trie *node)
{
    node->count = node->sum = 0;
    memset(node->next,NULL,sizeof node->next);
    node->fail = NULL;
    //node->isEnd = false;
}

void Insert(const char *s)
{
    int len = strlen(s);
    int pos;
    Trie *p = root;
    for(int i = 0; i < len; i++){
        pos = s[i] - 'a';
        if(p->next[pos] == NULL){
            //如果这个字符在这个节点没有储存过，就建立一个新节点来储存
            p->next[pos] = new Trie;
            init(p->next[pos]);
        }
        p = p->next[pos];
        p->count++;
    }
    p->sum++;//表明当前位置为一个单词的节点
}

void build_fail_pointer()
{
    queue <Trie *> q;
    Trie *p = root;
    //将第一层存在的节点全部指向root节点
    for(int i = 0; i < Size; i++){
        if(p->next[i] != NULL){
            p->next[i]->fail = root;
            q.push(p->next[i]);
        }
    }
    while(!q.empty()){
        Trie *temp = q.front();
        q.pop();
        //依次回溯该节点的父节点的失败指针直到某节点的next[i]与该节点相同，
        //则把该节点的失败指针指向该next[i]节点；
        //若回溯到 root 都没有找到，则该节点的失败指针指向 root
        for(int i = 0; i < Size; i++){
            if(temp->next[i] != NULL){
                Trie *node = temp->fail;//将该结点的父结点的失败指针给node
                while(node != NULL){
                    if(node->next[i] != NULL){
                        temp->next[i]->fail = node->next[i];
                        break;
                    }
                    node = node->fail;
                }
                if(node == NULL){
                    //如果这个节点的fail指针匹配失败，那么就指向根节点
                    temp->next[i]->fail = root;
                }
                q.push(temp->next[i]);
            }
        }
    }
}

void find_ac_automaton()
{
    Trie *p = root;
    int pos;
    int len = strlen(text);
    for(int i =0; i < len; i++){
        pos = text[i] - 'a';
        while(p->next[pos] == NULL && p != root){
        //如果失配且下一个fail节点不是根节点，就往上找
            p = p->fail;
        }
        //找到上级节点的fail指针指向的节点是否含有当前字符
        p = p->next[pos];
        if(p == NULL){
            //如果没找到，就返回根节点从新开始找
            p = root;
        }
        Trie *tep = p;
        //向上查找fail指针指向的字符串，这些字符串的结尾都是这个字符（个人理解）
        //并把出现的模式串数量全部加进去
        while(tep != root && tep->sum != -1){
            ans += tep->sum;
            tep->sum = -1;//防止重复计算
            tep = tep->fail;
        }
    }
}

void delTrie(Trie *root)
{
    for(int i = 0; i < Size; i++){
        if(root->next[i] != NULL){
            delTrie(root->next[i]);
        }
    }
    delete root;
}

int main()
{
    int t,n;
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        root = new Trie;
        init(root);
        while(n--){
            scanf("%s",pat);
            Insert(pat);
        }
        scanf("%s",text);
        build_fail_pointer();
        ans = 0;
        find_ac_automaton();
        printf("%d\n",ans);
        delTrie(root);
    }
    return 0;
}

hdu 5880
这个题，咋说呢，简单模板，但是做起来就跟神仙题一样，究极离谱（给自己的菜找借口），指针方法内存存爆了，也不知道为啥爆了，先贴一下吧，顺便学学数组的ac自动机操作。。
如果用指针内存爆了的问题解决了，再说这个代码是不是一定正确吧（狗头）

//AC自动机
//指针
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <queue>
#include <map>
#include <string>
#include <sstream>

using namespace std;

const int Size = 26;
const int MAXN = 1e6 + 10;

struct Trie
{
    //int count;//前缀出现次数;
    int sum;//这个节点是不是一个单词的结尾，并记录这个单词在建树的时候出现了几次
    Trie *next[Size];//孩子节点数目
    Trie *fail;
    //bool isEnd;//判断到该点时，是否是一个单词
    //string name;
}trie[MAXN];

char pat[MAXN],text[MAXN];
int cnt = 0;

Trie *root;//建立根节点;

void init(Trie *node)
{
    node->sum = 0;
    memset(node->next,NULL,sizeof node->next);
    node->fail = NULL;
    //node->isEnd = false;
}

Trie *Newndoe()
{
    Trie *p = &trie[cnt++];
    init(p);
    return p;
}

void Insert(const char *s)
{
    int len = strlen(s);
    int pos;
    Trie *p = root;
    for(int i = 0; i < len; i++){
        pos = s[i] - 'a';
        if(p->next[pos] == NULL){
            //如果这个字符在这个节点没有储存过，就建立一个新节点来储存
            p->next[pos] = Newndoe();
        }
        p = p->next[pos];
    }
    p->sum = len;//记录模式串长度，方便转变成'*'
}

void build_fail_pointer()
{
    queue <Trie *> q;
    Trie *p = root;
    //将第一层存在的节点全部指向root节点
    for(int i = 0; i < Size; i++){
        if(p->next[i] != NULL){
            p->next[i]->fail = root;
            q.push(p->next[i]);
        }
    }
    while(!q.empty()){
        Trie *temp = q.front();
        q.pop();
        //依次回溯该节点的父节点的失败指针直到某节点的next[i]与该节点相同，
        //则把该节点的失败指针指向该next[i]节点；
        //若回溯到 root 都没有找到，则该节点的失败指针指向 root
        for(int i = 0; i < Size; i++){
            if(temp->next[i] != NULL){
                Trie *node = temp->fail;//将该结点的父结点的失败指针给node
                while(node != NULL){
                    if(node->next[i] != NULL){
                        temp->next[i]->fail = node->next[i];
                        break;
                    }
                    node = node->fail;
                }
                if(node == NULL){
                    //如果这个节点的fail指针匹配失败，那么就指向根节点
                    temp->next[i]->fail = root;
                }
                q.push(temp->next[i]);
            }
        }
    }
}

void find_ac_automaton()
{
    Trie *p = root;
    int pos;
    int len = strlen(text);
    for(int i =0; i < len; i++){
        if(text[i] >= 'A' && text[i] <= 'Z'){
            pos = text[i] - 'A';
        }
        else if(text[i] >= 'a' && text[i] <= 'z'){
            pos = text[i] - 'a';
        }
        else{
            continue;
        }
        while(p->next[pos] == NULL && p != root){
        //如果失配且下一个fail节点不是根节点，就往上找
            p = p->fail;
        }
        //找到上级节点的fail指针指向的节点是否含有当前字符
        p = p->next[pos];
        if(p == NULL){
            //如果没找到，就返回根节点从新开始找
            p = root;
        }
        Trie *tep = p;
        //向上查找fail指针指向的字符串，这些字符串的结尾都是这个字符
        //并把出现的模式串数量全部加进去
        while(tep != root){//需要把所有出现的模式串都和谐掉，所以不需要去重操作
            if(tep->sum){
                for(int k = i; k > i - tep->sum; k--){
                    text[k] = '*';
                }
                break;//第一个后缀一定是最长的，不需要再转移到下一个fail指针
            }
            tep = tep->fail;
        }
    }
}

/*void delTrie(Trie *root)
{
    for(int i = 0; i < Size; i++){
        if(root->next[i] != NULL){
            delTrie(root->next[i]);
        }
    }
    delete root;
}*/

int main()
{
    int t,n;
    scanf("%d",&t);
    while(t--){
        cnt = 0;
        scanf("%d",&n);
        root = Newndoe();
        while(n--){
            scanf("%s",pat);
            Insert(pat);
        }
        cin.get();
        gets(text);
        build_fail_pointer();
        find_ac_automaton();
        puts(text);
        /*for(int i = 0; i < cnt; i++){
            trie[i].sum = 0;
            for(int j = 0; j < Size; j++){
                trie[i].next[j] = NULL;
            }
            trie[i].fail = NULL;
        }*/
    }
    return 0;
}

对于数组的建立fail指针，为什么一步就可以呢？因为对于没有出现的字符，它会把父节点fail指针指向的节点的与其字符相同的子节点存起来，这样就省略的如果当前节点存在，但是其父节点fail指针指向的节点与之相同字符的子节点不存在，就会向上找的过程，因为上层节点在建立fail指针的时候，已经给你预处理好了，所以只需要直接取父节点fail指针指向的节点的具有相同字符的值就可以，如果其值是指向根节点的，那就说明，当前要建立fail指针的节点，也指向根节点

//hdu 5880
//数组，ac自动机
#include <iostream>
#include <string>
#include <cstring>
#include  <cmath>
#include <cstdio>
#include <cstdlib>
#include <map>
#include <queue>

using namespace std;

const int MAXN = 1e6 + 10;
const int Size = 26;

int fail[MAXN],trie[MAXN][Size],val[MAXN],nNode;
//失败指针，字典树（数组实现），记录模式串长度，子典树节点
char s[MAXN];

int tran(char ch)
{
        return tolower(ch) - 'a';
}

int newNode()
{
        for(int i = 0; i < Size; i++){
                trie[nNode][i] = 0;
                fail[i] = 0;
        }
        val[nNode] = 0;
        return nNode++;
}

void Insert(const char *s)
{
        int u = 0;
        int len = strlen(s);
        for(int i = 0; i < len; i++){
                if(!trie[u][tran(s[i])]){
                        trie[u][tran(s[i])] = newNode();
                }
                u = trie[u][tran(s[i])];
        }
        //在结尾处记录模式串长度
        val[u] = len;
}

void build_ac_fail_pointer()
{
        queue <int> q;
        fail[0]  = 0;
        for(int  i = 0; i < Size; i++){
                if(trie[0][i]){
                        fail[trie[0][i]] = 0;//第一层fail指针指向根结点
                        q.push(trie[0][i]);
                }
                else{
                        fail[trie[0][i]] = 0;
                }

        }
        while(!q.empty()){
                int u = q.front();
                q.pop();
                for(int i = 0; i < Size; i++){
                        if(trie[u][i]){
                                fail[trie[u][i]] = trie[fail[u]][i];
                                q.push(trie[u][i]);
                        }
                        else{
                                //向上找上级，找到的第一个用fail指针指向，但是如果没有上级满足
                                //那么肯定其父节点fail指针的  ℹ  节点对应的值为0，就不用向指针方法一样不断向上找了
                                //上面同理
                                trie[u][i] = trie[fail[u]][i];
                        }
                }
        }
}

//替换字符
void Query(char *s)
{
        int len = strlen(s);
        int u = 0;
        for(int i = 0; i <  len; i++){
                //判断是否为字符,是则返回非0不是返回0
                if( !isalpha ( s[i] ) ){
                        //如果不是字符，那么就从根结点从新开始找
                        u = 0;
                        continue;
                }
                //如果是字符，那么就直接取最大后缀，如果没有不存在，那么长度肯定为0
                u = trie[u][tran(s[i])];
                for(int j = u;  j != 0;  j = fail[j]){
                        if(val[j]){
                                for(int k = i; k > i - val[j]; k--){
                                        s[k] = '*';
                                }
                        }
                }
        }
}

int main()
{
        int t;
        scanf("%d",&t);
        while(t--){
                nNode = 0;
                newNode();
                int n;
                scanf("%d",&n);
                while(n--){
                        scanf("%s",s);
                        Insert(s);
                }
                build_ac_fail_pointer();
                getchar();
                //linux下不能使用gets。。使用fgets替代,但是不知道为啥就tle了
                //cin.get(s,MAXN );
               // fgets(s,MAXN -  5,stdin);
                gets(s);
                Query(s);
                puts(s);
        }
        return 0;
}

洛谷3808
模板题

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
#include <string>
#include <cmath>
#include <cstdlib>

using namespace std;

const int MAXN = 1000005;
const int Size = 26;

int trie[MAXN][Size],fail[MAXN * Size],cnt[MAXN],nNode;
int ans;
string s;

int newnode()
{
	for(int i = 0; i < Size; i++){
		trie[nNode][i] = 0;
	}
	fail[nNode] = 0;
	cnt[nNode] = 0;
	return nNode++;
}

void Insert(const string  &s)
{
	int len = s.size();
	int u = 0;
	for(int i = 0; i < len; i++){
		int pos = s[i] - 'a';
		if( !trie[u][pos] ){
			trie[u][pos] = newnode();
		} 
		u = trie[u][pos];
	}
	//记录该字符串出现次数
	cnt[u]++;
}

void build_ac_fail_pointer()
{
	queue <int> q;
	fail[0] = 0;
	for(int i = 0; i < Size; i++){
		if( trie[0][i] ){
			fail[trie[0][i]] = 0;
			q.push(trie[0][i]);
		}
		else{
			fail[trie[0][i]] = 0;
		}
	}
	while ( !q.empty())
	{
		int u = q.front();
		q.pop();
		for(int i= 0; i < Size; i++){
			if( trie[u][i] ){
				fail[trie[u][i]] = trie[fail[u]][i];
				q.push(trie[u][i]);
			}
			else{
				trie[u][i]  = trie[fail[u]][i];
			}
		}
	}	
}

void Query(const string &s)
{
	int len = s.size();
	int u = 0;
	for(int i = 0; i < len; i++){
		int pos = s[i] - 'a';
		u = trie[u][pos];
		for(int j = u; j && cnt[j] != -1; j = fail[j]){
			ans += cnt[j];
			cnt[j] = -1;
		}
	}
}

int main()
{
	int n;
	cin>>n;
	newnode();//很重要，因为根节点是0，如果没有这一步，插入的时候，会从根节点新建节点
	while(n--){
		cin>>s;
		Insert(s);
	}
	build_ac_fail_pointer();
	cin>>s;
	Query(s);
	cout<<ans<<endl;
	return 0;
}

洛谷3796
模板题，先把输入的字符按照输入的顺序编号（建议不要从0开始编号，个人认为会比较麻烦）
然后在建树的时候，在字符串尾部位置标记上我们给定的序号
在扫描模式串的时候，只要这个序号出现一次，那么相应的字符串出现次数则加一，最后求出出现次数最多的字符串即可

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
#include <string>
#include <cmath>
#include <cstdlib>

using namespace std;

const int MAXN = 1000005;
const int Size = 26;

int trie[MAXN][Size],fail[MAXN],cnt[MAXN],nNode,vis[MAXN];
string s[151],T;

void init()
{
	memset(trie,0,sizeof(trie));
	memset(fail,0,sizeof(fail));
	memset(cnt,0,sizeof(cnt));
	memset(vis,0,sizeof(vis));
	nNode  = 1;
}

int newnode()
{
	for(int i = 0; i < Size; i++){
		trie[nNode][i] = 0;
	}
	fail[nNode] = 0;
	cnt[nNode] = 0;
	return nNode++;
}

void Insert(const string  &s,int i)
{
	int len = s.size();
	int u = 0;
	for(int i = 0; i < len; i++){
		int pos = s[i] - 'a';
		if( !trie[u][pos] ){
			trie[u][pos] = newnode();
		} 
		u = trie[u][pos];
	}
	//记录该字符串的标号
	cnt[u] = i;
}

void build_ac_fail_pointer()
{
	queue <int> q;
	fail[0] = 0;
	for(int i = 0; i < Size; i++){
		if( trie[0][i] ){
			fail[trie[0][i]] = 0;
			q.push(trie[0][i]);
		}
		else{
			fail[trie[0][i]] = 0;
		}
	}
	while ( !q.empty())
	{
		int u = q.front();
		q.pop();
		for(int i= 0; i < Size; i++){
			if( trie[u][i] ){
				fail[trie[u][i]] = trie[fail[u]][i];
				q.push(trie[u][i]);
			}
			else{
				trie[u][i]  = trie[fail[u]][i];
			}
		}
	}	
}

void Query(const string &s)
{
	int len = s.size();
	int u = 0;
	for(int i = 0; i < len; i++){
		int pos = s[i] - 'a';
		u = trie[u][pos];
		for(int j = u; j; j = fail[j]){
			if(cnt[j]){
				vis[cnt[j]]++;//如果有模式串标记，更新出现次数
			}
		}
	}
}
 
int main()
{
	int n;
	while(cin>>n,n){
		init();
		//newnode();//很重要，因为根节点是0，如果没有这一步，插入的时候，会从根节点新建节点
		for(int i = 1; i <= n; i++){
			cin>>s[i];
			Insert(s[i],i);//利用输入字符串的顺序来给字符串标序，也可以用map
		}
		build_ac_fail_pointer();
		cin>>T;
		Query(T);
		int ans = 0;
		for(int i = 1; i <= n; i++){
			ans = max(ans,vis[i]);
		}
		cout<<ans<<endl;
		for(int i = 1; i <= n; i++){
			if(vis[i] == ans){
				cout<<s[i]<<endl;
			}
		}
	}
	return 0;
}
Cu1ii*
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AC自动机
03-06
**AC自动机（Aho-Corasick算法）**是一种高效的字符串搜索算法，它基于字典树（Trie）数据结构，能够一次性查找多个模式串在文本中的出现情况。AC自动机的主要优势在于避免了对同一个文本位置多次进行模式匹配，大大...
ac自动机.pptx
07-14
要学AC自动机需要自备两个前置技能:KMP和trie树(其实个人感觉不会kmp也行,失配指针的概念并不难) 其中,KMP是用于一对一的字符串匹配,而trie虽然能用于多模式匹配,但是每次匹配失败都需要进行回溯,如果模式串很长的话...
AC 自动机
orz
08-25 1253
AC 自动机 引入 AC 自动机是一种用于解决多模式串以及一主串匹配的字符串算法。 问题通常是给出若干个模式串 S 以及主串 T，询问若干个模式串分别在主串中的某些信息。 AC 自动机构建在 Trie 的结构基础上，结合了 KMP 算法的失配指针思想。 在进行多模式串匹配前，只有两个步骤需要去实现： 将所有模式串扔进一棵 Trie 树中。 对于 Trie 上的所有节点构建失配指针。 AC 自动机的时间复杂度约为 O(n+m)O(n+m)O(n+m)。 算法思想 AC 自动机其实就是在 Trie
关于 AC 自动机
weixin_43501634的博客
02-22 2123
AC 自动机，全称 Aho-Corasick 自动机，是一种用于字符串搜索的算法，由 Alfred V. Aho 和 Margaret J. Corasick 在 1975 年提出。这个算法是为了解决在一个主文本字符串中查找多个模式字符串（或称为“关键词”）的问题，它可以在线性时间内完成搜索，非常高效。在计算机科学中，Aho-Corasick 算法是 Alfred V. Aho 和 Margaret J. Corasick 于 1975 年发明的一种字符串搜索算法。
AC自动机算法
懒猫的脚印
08-15 1298
ac自动机，双数组
ac自动机详解
dajiangyou123456的博客
01-27 318
转自大佬的blog：https://www.cnblogs.com/cmmdc/p/7337611.html 简介： 首先简要介绍一下AC自动机：Aho-Corasick automation，该算法在1975年产生于贝尔实验室，是著名的多模匹配算法之一。一个常见的例子就是给出n个单词，再给出一段包含m个字符的文章，让你找出有多少个单词在文章里出现过。要搞懂AC自动机，先得有模式树（字典树）Tri...
java ac自动机_Java实现AC自动机全文检索示例
weixin_42488997的博客
02-23 365
第一步，构建Trie树，定义Node类型：/*** Created by zhaoyy on 2017/2/7.*/interface Node {char value();boolean exists();boolean isRoot();Node parent();Node childOf(char c);Node fail();void setFail(Node node);void set...
java ac自动机_ac自动机java版
weixin_35952929的博客
02-23 332
【实例简介】从别的共享资源下载的java版ac自动机，已验证使用非常好。【实例截图】【核心代码】ahocorasick_java-1.1└── ahocorasick_java-1.1├── ahocorasick│ ├── pom.xml│ ├── src│ │ └── main│ │ └── java│ │ └── org│ │ ...
AC自动机_AC自动机模板_
09-30
AC自动机，全称为Aho-Corasick自动机，是一种字符串搜索算法，广泛应用于信息学奥林匹克竞赛、数据结构与算法竞赛以及文本处理等领域。它的主要功能是高效地在一个字符串集合中进行多模式匹配，即同时查找多个模式串...
AC自动机模板
12-08
**AC自动机（Aho-Corasick Algorithm）模板** AC自动机是一种字符串搜索算法，它在文本中查找多个模式串的出现情况。该算法由艾伦·科拉斯和戈登·科拉斯在1975年提出，是KMP算法和后缀自动机的结合，具有高效性和...
中文高性能AC自动机代码
11-05
**AC自动机（Aho-Corasick算法）**是一种在字符串搜索中用于高效查找多个模式串的算法。在中文文本处理中，AC自动机尤其适用，因为它能够一次性处理大量关键词，避免了对文本的多次扫描。这个算法由Aho和Corasick在...
基于贝叶斯网络BO-Transformer-BiLSTM实现负荷数据回归预测附matlab代码.rar
07-27
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
易语言 - 易语言我的世界3D源码
07-27
易语言我的世界3D源码
avif-0.5.0-cp37-cp37m-manylinux2010_i686.whl
07-27
python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！
pillow-10.4.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl
07-27
基本介绍 名称与起源：Pillow，原名为PIL（Python Imaging Library），但PIL只支持Python 2版本。随着Python 3的普及，Pillow作为PIL的一个分支出现，兼容Python 3并提供更多的功能和改进。 主要功能：Pillow支持多种图像格式的打开、保存、显示以及基本的图像操作和处理，如裁剪、缩放、旋转、翻转、滤镜应用等。 跨平台性：Pillow库可以在不同的操作系统上运行，包括Windows、Linux和MacOS等。 主要功能模块 Pillow库包含多个功能模块，每个模块都提供了特定的图像处理功能。以下是一些常用的模块： Image：用于处理图像文件，提供打开、保存、调整大小、旋转、裁剪、滤镜等功能。 ImageDraw：提供在图像上绘制各种形状（如线条、矩形、圆形）和文本的功能。 ImageFont：用于加载和使用TrueType字体文件，以便在图像上绘制文本时设置字体样式、大小和颜色。 ImageFilter：提供各种滤镜效果，如模糊、锐化、边缘增强等，用于图像增强、特效处理和图像识别等应用。 ImageEnhance：用于调整图像的亮度、对比度、颜色饱和度等参数，使图像更加清晰、明亮或具有特定的调色效果。 高级功能 除了基本的图像处理功能外，Pillow还支持一些高级功能，如色彩空间转换、直方图均衡化等。这些功能可以帮助用户进行更复杂的图像处理和分析。
[毕设]智能车辆租赁与调度系统.zip
最新发布
07-27
[毕设]智能车辆租赁与调度系统
ThinkPHP5开发的多小区物业管理系统源码修复版+安装说明
07-27
很适合做物业的一套源码,基于 ThinkPHP5 + Bootstrap 倾力打造的多小区物业管理系统源码，操作简单，功能完善，用户体验良好。 至简物业管理系统功能模块说明 统计分析 以小区为单位，统计如下数据： 小区总栋数 小区总户数 小区总人数 小区租户数量 小区每月收费金额统计 小区车位统计 小区车辆统计 小区宠物统计 小区报修统计 小区管理 主要功能：小区概述，坐落地址，占地面积，开发商名称，物业公司名称，绿化率等信息。房产信息管理：记录每个住户的基本信息，包括户主，房间数，单元信息，楼层 业主信息管理：记录业主基本信息、业主家庭成员、车辆、宠物等信息。 停车位管理：记录车位基本信息（车位编号）、记录车位的使用情况（租或买），费用等信息。 资产设备管理：公共设备管理，比如电梯，路灯，垃圾桶，配电箱管理等等。 收费管理：主要功能模块：收费项目定义、缴费记录管理。 值班管理：以日历的形式，对小区保安的值班情况进行管理。 权限管理：详细的操作权限控制，不仅仅是菜单
python ac自动机
09-02
Python AC自动机是一个用于字符串匹配的算法，它可以高效地在一段文本中查找多个预定义的模式。它的实现可以使用多种库，其中包括ac自动机python和ahocorasick-python。 ac自动机python是一个对标准的ac自动机算法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值