DFA

最新推荐文章于 2022-12-07 21:30:48 发布
最新推荐文章于 2022-12-07 21:30:48 发布
阅读量545 收藏
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq789045/article/details/52741565



最纯粹的Trie图题目

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<string>
#include<queue>
using namespace std;

struct Node
{
	Node* son[26];
	Node* prev;
	bool badNode;

	Node()
	{
		memset(son, 0, sizeof(son));
		prev = NULL;
		badNode = false;
	}
};

int ncount;

Node tree[200];

void insert(char * s)
{
	Node* p = tree;

	for (int i = 0; s[i] != '\0'; i++)
	{
		if (p->son[s[i] - 'a'] == NULL)
			p->son[s[i] - 'a'] = tree + ncount++;

		p = p->son[s[i] - 'a'];
	}
	p->badNode = true;
}

void buildDfa()
{

	deque<Node*> q;

	for (int i = 0; i < 26; i++)
	{
		if (tree[0].son[i])
		{
			tree[0].son[i]->prev = tree;
			q.push_back(tree[0].son[i]);
		}
	}

	while (!q.empty())
	{
		Node* p = q.front();
		q.pop_front();

		for (int i = 0; i < 26; i++)
		{
			Node *p2 = p->son[i];
			if (p2)
			{
				Node * prev = p->prev;
				while (prev)
				{
					if (prev->son[i])
					{
						p2->prev = prev->son[i];
						if (prev->son[i]->badNode)
							p2->badNode = true;
						break;
					}
					prev = prev->prev;
				}
				if (prev == NULL)
					p2->prev = tree;
				q.push_back(p2);
			}
		}
	}
}

bool searchDfa(char *s)
{
	Node *p = tree;
	for (int i = 0; s[i] != '\0'; i++)
	{
		while (p)
		{
			if (p->son[s[i] - 'a'])
			{
				p = p->son[s[i] - 'a'];
				if (p->badNode)
					return 1;
				break;
			}
			p = p->prev;
		}
		if (p == NULL)
			p = tree;

	}
	return false;
}


int main()
{
	ncount = 1;
	int n, m;

	char str[100];

	scanf("%d%d", &n, &m);

	for (int i = 0; i < n; i++)
	{
		scanf("%s", str);
		insert(str);
	}
	buildDfa();
	for (int i = 0; i < m; i++)
	{
		scanf("%s", str);
		if (searchDfa(str))
			printf("1\n");
		else
			printf("0\n");
	}


}


POJ 3987 病毒查找

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<string>
#include<queue>
#include<ctype.h>
#include<math.h>
using namespace std;



struct Node
{
	Node* last;
	bool isCalc;
	int whichWord;
	Node *prev, *son[26];
};

Node tree[250 * 1000 + 100];

queue<Node*> q;
int ncount;

char programStr[5100010];

int ansCount;

int visited[250 * 1000 + 100];

int n;

inline Node* newnode()
{
	tree[ncount].last = NULL;
	tree[ncount].isCalc = false;
	tree[ncount].prev = NULL;
	tree[ncount].whichWord = -1;
	for (int i = 0; i < 26; i++)
	{
		tree[ncount].son[i] = NULL;
	}
	return tree + ncount++;
}


inline void insert(char * s, int whichWord)
{
	Node* p = tree;

	for (int i = 0; s[i] != '\0'; i++)
	{
		if (p->son[s[i] - 'A'] == NULL)
			p->son[s[i] - 'A'] = newnode();

		p = p->son[s[i] - 'A'];
	}
	p->whichWord = whichWord;

}


void buildDfa()
{

	for (int i = 0; i < 26; i++)
	{
		if (tree[0].son[i])
		{
			tree[0].son[i]->prev = tree;
			q.push(tree[0].son[i]);
		}
	}

	while (!q.empty())
	{
		Node* p = q.front();
		q.pop();



		for (int i = 0; i < 26; i++)
		{
			if (p->son[i])
			{
				Node *prev = p->prev;
				while (prev)
				{
					if (prev->son[i])
					{
						p->son[i]->prev = prev->son[i];
						if (prev->son[i]->whichWord!=-1)
						{
							p->son[i]->last = prev->son[i];
						}
						else if (prev->son[i]->last)
						{
							p->son[i]->last= prev->son[i]->last;
						}
						break;
					}
					else
						prev = prev->prev;
				}
				if (prev == NULL)
					p->son[i]->prev = tree;
				q.push(p->son[i]);
			}
		}
	}
}


int strToInt(char *s, int n)
{
	int sum = 0;

	for (int i = 0; i < n; i++)
	{
		sum += (s[i] - '0')*(int)pow(10, n - i - 1);
	}
	return sum;
}

inline void foo(Node * &p, const char &ch)
{
	while (p)
	{
		if (p->son[ch - 'A'])
		{
			p = p->son[ch - 'A'];
			break;
		}
		else
			p = p->prev;
	}
	if (p == NULL)
		p = tree;



	if (p->last && p->last->isCalc == false)
	{
		Node * temp = p->last;
		while (temp)
		{
			temp->isCalc = true;
			if(visited[temp->whichWord]==0)
			{
				ansCount++;
				visited[temp->whichWord]=1;
			}
			temp = temp->last;
		}
	}
	if (p->whichWord != -1 && p->isCalc == false)
	{
		p->isCalc = true;
		if(visited[p->whichWord]==0)
		{
			ansCount++;
			visited[p->whichWord]=1;
		}
	}
	

	
}

void searchDfa1(char *s)
{
	Node *p = tree;
	for (int i = 0; s[i] != '\0'; i++)
	{
		if (s[i] == '[')
		{
			int cnt = 0;
			i++;
			int i2 = i;
			while (isdigit(s[i]))
			{
				i++;
				cnt++;
			}
			int q = strToInt(s + i2, cnt);

			while (q--)
			{

				foo(p, s[i]);
			}
			i++;
		}
		else
		{
			foo(p, s[i]);

		}





	}
}

void searchDfa2(char *s)
{
	Node *p = tree;
	int len = strlen(s);
	for (int i = len - 1; i >= 0; i--)
	{
		if (s[i] == ']')
		{
			int cnt = 0;
			i--;
			char x = s[i];
			i--;
			while (isdigit(s[i]))
			{
				i--;
				cnt++;
			}
			int q = strToInt(s + i + 1, cnt);

			while (q--)
			{

				foo(p, x);
			}

		}
		else
		{
			foo(p, s[i]);

		}





	}
}




int main()
{
	int t;
	scanf("%d", &t);
	while (t--)
	{
		memset(visited,0,sizeof(visited));
		ncount = 0;
		ansCount = 0;
		newnode();//初始化根节点
		scanf("%d", &n);

		char str[1010];
		for (int i = 0; i < n; i++)
		{
			scanf("%s", str);
			insert(str, i);
		}

		scanf("%s", programStr);


		buildDfa();


		searchDfa1(programStr);

		searchDfa2(programStr);

		printf("%d\n", ansCount);


	}





}


POJ 1204 字谜

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<string>
#include<queue>
using namespace std;

#define INF 1001

struct Node
{
	int whichWord;
	Node *prev, *son[26];
};

Node tree[INF*INF];

queue<Node*> q;

struct Location
{
	int r, c, d;
};

Location ans[1001];

int  r, c, w, ncount;


char graph[INF][INF], tp[INF];


int dx[8] = { -1,-1,0,1,1,1 ,0 ,-1 };
int dy[8] = { 0 ,1 ,1,1,0,-1,-1,-1 };

Node* newnode()
{
	tree[ncount].prev = NULL;
	tree[ncount].whichWord = -1;
	for (size_t i = 0; i < 26; i++)
	{
		tree[ncount].son[i] = NULL;
	}
	return tree + ncount++;
}


void insert(char * s, int whichWord)
{
	Node* p = tree;
	int len = strlen(s);

	for (int i = len - 1; i >= 0; i--)
	{
		if (p->son[s[i] - 'A'] == NULL)
			p->son[s[i] - 'A'] = newnode();

		p = p->son[s[i] - 'A'];
	}
	p->whichWord = whichWord;
}


void buildDfa()
{
	Node *p = tree;
	for (int i = 0; i < 26; i++)
	{
		if (p->son[i])
		{
			p->son[i]->prev = tree;
			q.push(p->son[i]);
		}
	}

	while (!q.empty())
	{
		p = q.front();
		q.pop();



		for (int i = 0; i < 26; i++)
		{
			if (p->son[i])
			{
				Node *prev = p->prev;
				while (prev)
				{
					if (prev->son[i])
					{
						p->son[i]->prev = prev->son[i];
						break;
					}
					else
						prev = prev->prev;
				}
				if (prev == NULL)
					p->son[i]->prev = tree;
				q.push(p->son[i]);
			}
		}
	}
}


void searchDfa(int rr, int cc, int kk)
{
	int nx = rr;
	int ny = cc;
	Node *p = tree;

	for (; 0 <= nx && nx < r && 0 <= ny && ny < c; nx += dx[kk], ny += dy[kk])
	{
		while (p)
		{
			if (p->son[graph[nx][ny] - 'A'])
			{
				p = p->son[graph[nx][ny] - 'A'];
				break;
			}
			else
				p = p->prev;
		}
		if (p == NULL)
			p = tree;


		Node* temp = p;
		while (temp != tree)
		{
			if (p->whichWord != -1)
			{
				ans[temp->whichWord].r = nx;
				ans[temp->whichWord].c = ny;
				ans[temp->whichWord].d = kk;
				//temp->whichWord = -1;
			}
			temp = temp->prev;
		}
	}
}


void search()
{
	for (int i = 0; i < c; i++)
	{
		searchDfa(0, i, 5);
		searchDfa(0, i, 4);
		searchDfa(0, i, 3);

		searchDfa(r - 1, i, 7);
		searchDfa(r - 1, i, 0);
		searchDfa(r - 1, i, 1);

	}

	for (int i = 0; i < r; i++)
	{
		searchDfa(i, 0, 1);
		searchDfa(i, 0, 2);
		searchDfa(i, 0, 3);

		searchDfa(i, c - 1, 7);
		searchDfa(i, c - 1, 6);
		searchDfa(i, c - 1, 5);
	}
}



int main()
{

	while (scanf("%d%d%d", &r, &c, &w) == 3)
	{
		ncount = 1;
		for (int i = 0; i < r; i++)
			scanf("%s", graph[i]);

		for (int i = 0; i < w; i++)
		{
			scanf("%s", tp);
			insert(tp, i);
		}

		buildDfa();

		search();

		for (int i = 0; i < w; i++)
		{
			printf("%d %d %c\n", ans[i].r, ans[i].c, 'A' + (ans[i].d + 4) % 8);
		}
	}

}


POJ 3691 DNA repair

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<string>
#include<queue>
#include<ctype.h>
#include<math.h>
using namespace std;


int chge(char ch)
{
	switch (ch)
	{
	case 'A':return 0;
	case 'C':return 1;
	case 'G':return 2;
	case 'T':return 3;
	default:
		exit(1);
	}
}



struct Node
{
	int prev;
	int child[4];
	bool badNode;
};

Node tree[20 * 50 + 100];

queue<int> q;
int ncount;
int n;
char pstr[25];
char str[1010];

int dp[1000 + 10][20 * 50 + 100];

int newnode()
{
	tree[ncount].badNode = false;
	tree[ncount].prev = -1;
	for (size_t i = 0; i < 4; i++)
	{
		tree[ncount].child[i] = -1;
	}
	return ncount++;
}

void insert()
{
	int p = 0;

	for (int i = 0; pstr[i] != '\0'; i++)
	{
		if (tree[p].child[chge(pstr[i])] == -1)
		{
			tree[p].child[chge(pstr[i])] = newnode();
		}

		p = tree[p].child[chge(pstr[i])];
	}
	tree[p].badNode = true;
}


void buildDfa()
{

	for (int i = 0; i < 4; i++)
	{
		if (tree[0].child[i] != -1)
		{
			tree[tree[0].child[i]].prev = 0;
			q.push(tree[0].child[i]);
		}
		else
		{
			tree[0].child[i] = 0;
		}
	}

	while (!q.empty())
	{
		int p = q.front();
		q.pop();



		for (int i = 0; i < 4; i++)
		{
			if (tree[p].child[i] != -1)
			{
				int prev = tree[p].prev;
				while (prev != -1)
				{
					if (tree[prev].child[i] != -1)
					{
						tree[tree[p].child[i]].prev = tree[prev].child[i];
						if (tree[tree[prev].child[i]].badNode)
							tree[tree[p].child[i]].badNode = true;
						break;
					}
					else
						prev = tree[prev].prev;
				}
				if (prev == -1)
				{
					tree[tree[p].child[i]].prev = 0;

				}
				q.push(tree[p].child[i]);
			}
			else
			{
				tree[p].child[i] = tree[tree[p].prev].child[i];
			}
		}
	}
}


int main()
{

	int caseCnt = 1;
	while (scanf("%d", &n) == 1 && n != 0)
	{

		ncount = 0;
		newnode();


		for (int i = 0; i < 1000 + 10; i++)
			for (int j = 0; j < 20 * 50 + 100; j++)
				dp[i][j] = 1 << 30;


		for (int i = 0; i < n; i++)
		{
			scanf("%s", pstr);
			insert();
		}
		scanf("%s", str);
		buildDfa();

		int len = strlen(str);
		dp[0][0] = 0;
		for (int i = 1; i <= len; i++)
		{
			for (int j = 0; j < ncount; j++)
			{
				if (dp[i - 1][j] != 1 << 30)
				{
					for (int k = 0; k < 4; k++)
					{
						if (tree[tree[j].child[k]].badNode == false)
						{
							if (chge(str[i - 1]) == k)
								dp[i][tree[j].child[k]] = min(dp[i][tree[j].child[k]], dp[i - 1][j]);
							else
								dp[i][tree[j].child[k]] = min(dp[i][tree[j].child[k]], dp[i - 1][j] + 1);
						}
					}
				}
			}
		}

		int ans = 1 << 30;
		for (int i = 0; i < ncount; i++)
			if (tree[i].badNode == false && ans>dp[len][i])
			{
				ans = dp[len][i];
			}

		printf("Case %d: ", caseCnt++);
		if (ans == 1 << 30)
			printf("-1\n");
		else
			printf("%d\n", ans);
	}
}



POJ 1625 不包含单词的语句个数

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<string>
#include<queue>
#include<ctype.h>
#include<map>
#include<math.h>
using namespace std;


struct Node
{
	int prev;
	int child[55];
	bool badNode;
};

Node tree[10 * 50 + 100];

queue<int> q;
int ncount;

map<char, int> charToInt;
int acount;

int n, m, p;

char pstr[15];




int newnode()
{

	tree[ncount].badNode = false;
	tree[ncount].prev = -1;
	for (int i = 0; i < n; i++)
	{
		tree[ncount].child[i] = -1;
	}
	return ncount++;
}

void insert()
{
	int p = 0;

	for (int i = 0; pstr[i] != '\0'; i++)
	{
		if (tree[p].child[charToInt[pstr[i]]] == -1)
		{
			tree[p].child[charToInt[pstr[i]]] = newnode();
		}

		p = tree[p].child[charToInt[pstr[i]]];
	}
	tree[p].badNode = true;
}


void buildDfa()
{

	for (int i = 0; i < n; i++)
	{
		if (tree[0].child[i] != -1)
		{
			tree[tree[0].child[i]].prev = 0;
			q.push(tree[0].child[i]);
		}
		else
		{
			tree[0].child[i] = 0;
		}
	}

	while (!q.empty())
	{
		int p = q.front();
		q.pop();



		for (int i = 0; i < n; i++)
		{
			if (tree[p].child[i] != -1)
			{
				int prev = tree[p].prev;
				while (prev != -1)
				{
					if (tree[prev].child[i] != -1)
					{
						tree[tree[p].child[i]].prev = tree[prev].child[i];
						if (tree[tree[prev].child[i]].badNode)
							tree[tree[p].child[i]].badNode = true;
						break;
					}
					else
						prev = tree[prev].prev;
				}
				if (prev == -1)
				{
					tree[tree[p].child[i]].prev = 0;

				}
				q.push(tree[p].child[i]);
			}
			else
			{
				tree[p].child[i] = tree[tree[p].prev].child[i];
			}
		}
	}
}


struct BigInteger
{
	int A[25];
	enum
	{
		MOD = 10000
	};
	BigInteger()
	{
		memset(A, 0, sizeof(A)); A[0] = 1;
	}
	void set(int x)
	{
		memset(A, 0, sizeof(A)); A[0] = 1; A[1] = x;
	}
	void print()
	{
		printf("%d", A[A[0]]);
		for (int i = A[0] - 1; i > 0; i--)
		{
			if (A[i] == 0)
			{
				printf("0000"); continue;
			}
			for (int k = 10; k*A[i] < MOD; k *= 10) printf("0");
			printf("%d", A[i]);
		}
		printf("\n");
	}
	int& operator [] (int p)
	{
		return A[p];
	}
	const int& operator [] (int p) const
	{
		return A[p];
	}
	BigInteger operator + (const BigInteger& B)
	{
		BigInteger C;
		C[0] = max(A[0], B[0]);
		for (int i = 1; i <= C[0]; i++)
			C[i] += A[i] + B[i], C[i + 1] += C[i] / MOD, C[i] %= MOD;
		if (C[C[0] + 1] > 0) C[0]++;
		return C;
	}
	BigInteger operator * (const BigInteger& B)
	{
		BigInteger C;
		C[0] = A[0] + B[0];
		for (int i = 1; i <= A[0]; i++)
			for (int j = 1; j <= B[0]; j++)
			{
				C[i + j - 1] += A[i] * B[j], C[i + j] += C[i + j - 1] / MOD, C[i + j - 1] %= MOD;
			}
		if (C[C[0]] == 0) C[0]--;
		return C;
	}
};

int main()
{

	int caseCnt = 1;
	while (scanf("%d%d%d", &n, &m, &p) == 3)
	{

		ncount = 0;
		newnode();
		acount = 0;

		BigInteger dp[51][101];
		dp[0][0].set(1);


		scanf("%s", pstr);

		for (int i = 0; pstr[i] != '\0'; i++)
		{
			charToInt[pstr[i]] = acount++;

		}

		for (int i = 0; i < p; i++)
		{
			scanf("%s", pstr);
			insert();
		}

		buildDfa();




		for (int i = 1; i <= m; i++)
		{
			for (int j = 0; j < ncount; j++)
			{

				for (int k = 0; k < n; k++)
				{
					if (tree[tree[j].child[k]].badNode == false)
					{
						dp[i][tree[j].child[k]] = dp[i][tree[j].child[k]] + dp[i - 1][j];
					}
				}

			}
		}

		BigInteger ans;

		for (int i = 0; i < ncount; i++)
		{

			ans = ans + dp[m][i];
		}

		ans.print();


	}
}



The Book List


#include<stdio.h>
#include<map>
#include<string>
#include<iostream>
#include<set>
using namespace std;



struct Node
{
	map<string, int> category;
	set<string> book;
};

Node tree[1508];

int ncount;


string address;




void Insert(int cur, int root)
{
	int i = cur;
	string word;
	while (i < address.size() && address[i] != '/')
	{
		word += address[i];
		i++;
	}



	if (address[i] == '/')//category
	{


		if (tree[root].category.count(word) == 0)//不存在这个目录，新建节点
		{
			tree[root].category[word] = ++ncount;
		}

		Insert(i + 1, tree[root].category[word]);

	}
	else//book
	{

		tree[root].book.insert(word);
	}

}

void showSpace(int n)
{
	for (int i = 0; i < n; i++)
		printf("    ");
}

void show(int depth, int root)
{
	for (auto cate : tree[root].category)
	{
		showSpace(depth - 1);
		printf("%s\n", cate.first.c_str());
		show(depth + 1, cate.second);
	}

	for (auto b : tree[root].book)
	{
		showSpace(depth - 1);
		printf("%s\n", b.c_str());
	}
}

void init()
{
	for (int i = 0; i <= ncount; i++)
	{
		tree[i].book.clear();
		tree[i].category.clear();
	}

	ncount = 0;
}

int main()
{
	int caseCnt = 1;
	ncount = 0;
	//freopen("a.txt", "w", stdout);
	while (getline(cin, address))
	{


		do
		{
			if (address == "0")
			{
				printf("Case %d:\n", caseCnt++);
				show(1, 0);
				init();
			}
			else
				Insert(0, 0);

		} while (getline(cin, address));

		return 0;
	}

}


qq789045
关注
dfa确定有限自动机定义_确定性有限自动机（DFA）
07-21 6520
dfa确定有限自动机定义In Deterministic Finite Automata (DFA), for a given input symbol the machine will move to which next state can be determined and hence it is named as deterministic automata. The number of ...
nfa转dfa以及dfa的最小化程序
05-16
NFA（Non-Deterministic Finite Automaton，非确定性有限状态自动机）和DFA（Deterministic Finite Automaton，确定性有限状态自动机）是两种常见的FSA类型。本程序主要涉及将NFA转换为DFA，并对生成的DFA进行最小化...
DFA算法的简单说明与案例实现以及优化思路
xb565517830的博客
06-08 7108
1.背景 项目中需要对敏感词做一个过滤，首先有几个方案可以选择： a.直接将敏感词组织成String后，利用indexOf方法来查询。 b.传统的敏感词入库后SQL查询。 c.利用Lucene建立分词索引来查询。 d.利用DFA算法来进行。 首先，项目收集到的敏感词有几千条，使用a方案肯定不行。其次，为了方便以后的扩展性尽量减少对数据库的依赖，所以放弃b方案。然后Lucene本身作为本地索引，敏感词增加后需要触发更新索引，并且这里本着轻量原则不想引入更多的库，所以放弃c方案。于是我们选定d方案为
编译原理（二）词法分析：3.记号的识别―NFA与DFA
sandalphon4869的博客
11-18 7366
文章目录NFA状态转换矩阵 两种有限自动机（FA，Finite Automation）: NFA（Nondeterministic Finite Automata，不确定的有限自动机） DFA （Deterministic Finite Automata，确定的有限自动机） 三种转化形式 NFA 的抽象定义 状态转换图 状态转换矩 NFA M =（S，∑，move，s0，F） 其中： ...
编译原理读书笔记(3/12)
chacha1989的专栏
02-28 1260
第3章 词法分析 词法分析的作用是扫描源程序，识别程序中的一个个单词，如变量标识符、程序的保留字等。 3.1 词法分析程序的设计 3.1.1 词法分析程序与语法分析程序的接口方式 词法分析是先于语法分析的，是语法分析的基础。两者的结合有两种方式：第一种是先扫描一遍源程序，只进行词法分析，词法分析的结果存放到一个中间文件中，这个中间文件作为语法分析的输入。第二种方式是将词法分析构建成一个调用方法，在语法分析过程中随时调用词法分析程序。本书介绍的PL/0编译程序属于第二种方式，在这种方式下，词法分析和语法分析放
DFA和NFA的五元组定义，DFA和NFA的区别
tanxinji的博客
04-16 1万+
1.DFA的五元组定义:  DFA是一个确定有限自动机DFA， M是一个五元组  M = (S,∑,M,S0,F)  S: state非空有穷状态集合  ∑: 字母表，可输入符号  S0:start唯一初态 ,S0∈S  F:Finish为终态集合，表示结束状态  M:Move是一个从Sx∑到S中一个状态的转换函数集合。  flip() 将读转换成写。将写转换成读 ...
正则式转NFA、NFA转DFA、DFA转MFA（DFA最小化）.zip
10-20
包含正则式转NFA、NFA转DFA（NFA确定化）、DFA转MFA（DFA最小化）三个程序，以及对应报告简述类的设计、包含的变量和思路。详细介绍参考：https://blog.youkuaiyun.com/newlw/article/details/123116153
去趋势波动分析DFA 多维DFA
10-25
去趋势波动分析（Detrended Fluctuation Analysis, DFA）是一种广泛应用在复杂系统研究中的统计方法，特别是用于分析时间序列的长期自相关性。这种方法由Peng等人在1994年提出，主要目的是定量地测量非线性系统的...
DFA.rar_活前缀dfa_活前缀的DFA
09-24
在计算机科学领域，特别是编译器设计和形式语言理论中，活前缀（Live Prefix）是与自动机，特别是确定性有限自动机（Deterministic Finite Automaton，简称DFA）密切相关的一个概念。活前缀 DFA 是一种特殊类型的...
编译原理NFA转DFA实现（python）.zip
12-08
在编译原理中，非确定有限自动机（Non-Deterministic Finite Automaton，简称NFA）和确定有限自动机（Deterministic Finite Automaton，简称DFA）是两种重要的概念。NFA转DFA是编译器设计的一个关键步骤，它有助于...
编译原理——DFA与NFA及子集法将DFA转换成NFA
SWEENEY_HE的博客
11-09 6253
1. DFA与NFA的定义 (1) 概述 有穷自动机又称有限自动机，是识别正规文法的语言以及其所表示的集合，包括 DFA(Deterministic Finite Automata)确定的有穷自动机和NFA(Nondeterministic Finite Automata)不确定的有穷自动机。 (2) DFA 一个确定的有穷自动机M是一个五元组：     &...
【计算理论】计算理论考前学习总结
Ohh24的博客
12-07 2414
计算理论的考前学习总结，总结的比较简单
一文搞定有穷状态自动机（FA）——DFA、NFA区别、转换以及DFA化简
热门推荐
学习永无止境
06-21 5万+
有穷状态自动机（Finite Automata, FA）分为确定的和不确定的，简称为DFA和NFA。 确定有穷自动机（DFA） 形式定义： 表示形式为： 注意：终态是用两个圆圈表示的，图中的3号即为DFA的终态。 不确定的有穷自动机（NFA） 形式定义： DFA与NFA的区别 DFA与NFA的区别在于，NFA的状态转换过程中可以有空串，如下图即为NFA。 这就导致了一个问题：开始之后，在给出字符a或b之前，我们能够确定当前是处于1状态还是2状态吗？很显然，我们是无法确定的，因此才被称为不确定的有穷自
自动机，状态机，有限自动机，有限状态机，有限状态自动机，非确定下有限状态自动，确定性有限状态自动机的区别于联系
Monet Zheng的查漏补缺
07-24 2万+
这几个概念晕了几天了，搞明白了就来备注一下 FSM（Finite State Machine） FAM（Finite Automata Machine） DFA（Determinate Finite Automata） NFA（Non-Determinate Finite Automat） 自动机：自动机是有限状态机(FSM)的数学模型。 状态机：我们现在所说的
DFA和NFA
hooopo的专栏
12-14 1027
1.历史： 引用 正则表达式萌芽于1940年代的神经生理学研究，由著名数学家Stephen Kleene第一个正式描述。具体地说，Kleene归纳了前述的神经生理学研究，在一篇题为《正则集代数》的论文中定义了“正则集”，并在其上定义了一个代数系统，并且引入了一种记号系统来描述正则集，这种记号系统被他称为“正则表达式”。在理论数学的圈子里被研究了几十年之后，1968年，后来发明了UNIX系统...
【编译原理】关于NFA和DFA-集合定义的探索
NJU phd 在读。
03-24 6038
文章目录1 NFA的几个组成部分2 DFA，Deterministic Finite Automata，确定的有限状态自动机。3 伪码描述 1 NFA的几个组成部分 1、一个有限的状态集合S，比如说上面的4个状态0、1、2、3，状态也可以有冗余，不过能简化肯定简化更好； 2、一个输入符号集合∑，即输入字母表（input alphabet），要记住，我们假设了代表空串的ε不是∑中的元素，要是一个字符...
DFA算法的实现与最小化
我飞故我在的专栏
03-24 4万+
有限自动机分为确定有限自动机（DFA）和不确定有限自动机（NFA），这里介绍DFA,即确定有限自动机。 1. DFA的形式定义 从形式上说，一个有限状态自动机可以用下面的5个参数来定义: Q: 状态q0, q1, ... , qN的有限集合Σ: 有限的输入符号字母表q0: 初始状态F: 终极状态的集合， F∈Qδ(q, i): 状态之间的转移函数或转移矩阵。给定一个状态q∈Q和一个输入符
形式语言与自动机：实验二——DFA识别句子
拾灬Tao的博客
11-22 2060
一、实验目的： 加深对DFA工作原理的理解。 二、实验内容： 1.设计固定DFA。也就是说用if-then-else（一般用来实现字母表中只有两个字母的情况）、switch（大于两个字母的情况）、for（用于控制输入字符串，长度为n的字符串，for循环n次）等语句表示DFA。一个函数定义一个DFA； 2.设计文件形式存储DFA。设计文件格式，DFA动态生成，使用字符串来验证DFA的有效性和正确性；（使用面向对象的方法。对于k个状态的DFA，生成相应的k个状态对象；状态转换应通过对象间的消息传递来实现） 3.
[转]NFA/DFA算法
heiyeluren的blog（黑夜路人的开源世界）
01-19 6633
作者：陈梓瀚  (http://www.cppblog.com/vczh/)1、问题概述随着计算机语言的结构越来越复杂，为了开发优秀的编译器，人们已经渐渐感到将词 法分析独立出来做研究的重要性。不过词法分析器的作用却不限于此。回想一下我们的老师刚刚开始向我们讲述程序设计的时候，总是会出一道题目：给出一个填入 了四则运算式子的字符串，写程序计算该式子的结果。除此之外，我们有时候建立了比较复杂的配置文
NFA与DFA转换及DFA最小化的实现方法
在计算机科学与信息技术领域，NFA（非确定有限自动机）与DFA（确定有限自动机）是基础理论与算法的核心概念之一。它们在编译原理、正则表达式处理、词法分析、搜索算法、形式语言和自动机理论中都有广泛的应用。 ##...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值