POJ 1204 Word Puzzles AC自己主动机题解

AC自己主动机的灵活运用,本题关键是灵活二字。

由于数据不是非常大。时间要求也不高的缘故。所以本题有人使用暴力法也过了。有人使用Trie。然后枚举八个方向,也过了。只是速度非常慢。

当然有人使用AC自己主动机没AC的,在讨论区里喊AC自己主动机超时的,那是由于不会灵活运用。或者是硬套模板的,AC了速度也不会快。

给出本人的算法思路:

1 把须要查找的keyword建立Trie, 然后构造AC自己主动机

2 查找的时候分八个方向查找,比方棋盘是board[N][M]。那么就能够循环i(0->N-1)。然后每次把board[i]当做一个文本。做过HDU的key word那道题目的人都知道怎样搜索一个文本中有多少keyword出现,这样不就把本题转换为查找文本keyword的问题了。 只是本题是须要八个方向的八个文本都搜索一遍,八是个不大的常数。其它方向怎样构造一个文本。就能够自己思考一下,不难。

3 记录结果就看个人的编程能力了,这里的技巧是逆转keyword建立Trie。那么搜索到尾就是每一个keyword的开头了。

AC自己主动机尽管高级,可是也还是一个算法工具。套模板。一大抄的代码没什么意义的,还是彻底消化掉,然后灵活运用才是关键。

对于本题写出高效的算法,那么是超过5星级难度的。

以下给出个上面思路的实现算法,速度非常快的。

出处: http://blog.csdn.net/kenden23

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

const int MAX_LEN = 1001;
const int ARR_SIZE = 26;
char board[MAX_LEN][MAX_LEN];
char word[MAX_LEN], gDir[MAX_LEN];
int gIndices[MAX_LEN][2];
int L, C, W;

inline int getIndex(char ch) { return ch-‘A‘; }

struct Node
{
	int n, index;
	Node *fail;
	Node *arr[ARR_SIZE];
};

void clearNode(Node *p)
{
	p->n = 0;
	p->index = 0;
	p->fail = NULL;
	for (int i = 0; i < ARR_SIZE; i++)
	{
		p->arr[i] = NULL;
	}
}

Node gPool[MAX_LEN*MAX_LEN];
int gPoolId;
Node *Trie;

void insertTrie(char w[], int index)
{
	Node *pCrawl = Trie;
	int len = strlen(w);
	for (int i = len-1; i >= 0; i--)//逆向插入字符串。方便找到起头节点
	{
		int id = getIndex(w[i]);
		if (!pCrawl->arr[id])
		{
			pCrawl->arr[id] = &gPool[gPoolId++];
			clearNode(pCrawl->arr[id]);
		}
		pCrawl = pCrawl->arr[id];
	}
	pCrawl->n++;
	pCrawl->index = index;
}

void buildFail()
{
	queue<Node *> qu;
	qu.push(Trie);
	while (!qu.empty())
	{
		Node *pCrawl = qu.front();
		qu.pop();
		for (int i = 0; i < ARR_SIZE; i++)
		{
			if (!pCrawl->arr[i]) continue;
			pCrawl->arr[i]->fail = Trie;
			Node *fail = pCrawl->fail;
			while (fail)
			{
				if (fail->arr[i])
				{
					pCrawl->arr[i]->fail = fail->arr[i];
					break;
				}
				fail = fail->fail;
			}
			qu.push(pCrawl->arr[i]);
		}
	}
}

void searchDirect(int r, int c, int rDir, int cDir, char dir)
{
	Node *pCrawl = Trie;
	while (0<=r && 0<=c && r < L && c < C)
	{
		int id = getIndex(board[r][c]);
		while (!pCrawl->arr[id] && pCrawl != Trie) pCrawl = pCrawl->fail;
		if (pCrawl->arr[id])
		{
			pCrawl = pCrawl->arr[id];
			Node *tmp = pCrawl;
			while (tmp && tmp->n != -1)
			{
				if (tmp->n)//record results
				{
					gIndices[tmp->index][0] = r;
					gIndices[tmp->index][1] = c;
					gDir[tmp->index] = dir;
				}
				tmp->n = -1;
				tmp = tmp->fail;
			}
		}
		r += rDir, c += cDir;	//Watch out, if we use "continue"!
	}
}

void searchAll()
{
	char dir = ‘E‘, counterDir = ‘A‘;
	for (int c = 0; c < C; c++)
	{
		searchDirect(L-1, c, -1, 0, dir);
		searchDirect(0, c, 1, 0, counterDir);
	}
	dir = ‘G‘, counterDir = ‘C‘;
	for (int r = 0; r < L; r++)
	{
		searchDirect(r, 0, 0, 1, dir);
		searchDirect(r, C-1, 0, -1, counterDir);
	}
	dir = ‘H‘, counterDir = ‘D‘;
	for (int c = 0; c < C; c++)
	{
		searchDirect(0, c, 1, 1, dir);
		searchDirect(L-1, c, -1, -1, counterDir);
	}
	for (int r = 1; r < L; r++)
	{
		searchDirect(r, 0, 1, 1, dir);
		searchDirect(r, C-1, -1, -1, counterDir);
	}
	dir = ‘F‘, counterDir = ‘B‘;
	for (int c = 0; c < C; c++)
	{
		searchDirect(L-1, c, -1, 1, dir);
		searchDirect(0, c, 1, -1, counterDir);
	}
	for (int r = 0; r < L; r++)
	{
		searchDirect(r, 0, -1, 1, dir);
		searchDirect(r, C-1, 1, -1, counterDir);
	}
}

int main()
{
	Trie = &gPool[0];
	while (scanf("%d %d %d", &L, &C, &W) != EOF)
	{
		clearNode(Trie);
		gPoolId = 1;
		getchar();
		for (int i = 0; i < L; i++)
		{
			gets(board[i]);
		}
		for (int i = 0; i < W; i++)
		{
			gets(word);
			insertTrie(word, i);
		}
		buildFail();
		searchAll();
		for (int i = 0; i < W; i++)
		{
			printf("%d %d %c\n", gIndices[i][0], gIndices[i][1], gDir[i]);
		}
	}
	return 0;
}
时间: 2024-11-05 13:39:48

POJ 1204 Word Puzzles AC自己主动机题解的相关文章

POJ 1204 Word Puzzles AC自动机题解

AC自动机的灵活运用,本题关键是灵活二字. 因为数据不是很大,时间要求也不高的缘故,所以本题有人使用暴力法也过了,有人使用Trie也过了. 当然有人使用AC自动机没AC的,在讨论区里喊AC自动机超时的,那是因为不会灵活运用,或者是硬套模板的,AC了速度也不会快. 给出本人的算法思路: 1 把需要查找的关键字建立Trie, 然后构造AC自动机 2 查找的时候分八个方向查找,比如棋盘是board[N][M],那么就可以循环i(0->N-1),然后每次把board[i]当做一个文本,做过HDU的key

POJ 1204 Word Puzzles (AC自动机)

Word Puzzles Time Limit: 5000MS   Memory Limit: 65536K Total Submissions: 9926   Accepted: 3711   Special Judge Description Word puzzles are usually simple and very entertaining for all ages. They are so entertaining that Pizza-Hut company started us

POJ 1204 Word Puzzles | AC 自动鸡

题目: 给一个字母矩阵和几个模式串,矩阵中的字符串可以有8个方向 输出每个模式串开头在矩阵中出现的坐标和这个串的方向 题解: 我们可以把模式串搞成AC自动机,然后枚举矩阵最外围一层的每个字母,向八个方向进行匹配 代码中danger标记为判断这个节点是不是一个模式串的结尾, 这道题可以直接字符串反向构建AC自动机,匹配到的就是开头(代码是正向) #include<cstdio> #include<algorithm> #include<cstring> #include&

[POJ 1204]Word Puzzles(Trie树暴搜)

Description Word puzzles are usually simple and very entertaining for all ages. They are so entertaining that Pizza-Hut company started using table covers with word puzzles printed on them, possibly with the intent to minimise their client's percepti

[POJ 1204]Word Puzzles(Trie树暴搜&amp;amp;AC自己主动机)

Description Word puzzles are usually simple and very entertaining for all ages. They are so entertaining that Pizza-Hut company started using table covers with word puzzles printed on them, possibly with the intent to minimise their client's percepti

POJ 1625 Censored! (AC自己主动机 + 高精度 + DP)

题目链接:Censored! 解析:AC自己主动机 + 高精度 + 简单DP. 字符有可能会超过128.用map映射一下就可以. 中间的数太大.得上高精度. 用矩阵高速幂会超时,简单的DP就能解决时间的问题. AC代码: #include <iostream> #include <string.h> #include <algorithm> #include <stdio.h> #include <queue> #include <map&

【 POJ - 1204 Word Puzzles】(Trie+爆搜)

Word Puzzles Time Limit: 5000MS Memory Limit: 65536K Total Submissions: 10782 Accepted: 4076 Special Judge Description Word puzzles are usually simple and very entertaining for all ages. They are so entertaining that Pizza-Hut company started using t

poj 1204 Word Puzzles 静态trie数解决多模式串匹配问题

题意: 给一个二维字符数组和w个模式串,求这w个模式串在二维字符数组的位置. 分析: 静态trie树. 代码: //poj 1204 //sep9 #include <iostream> using namespace std; const int maxN=1024; const int maxM=270*maxN; char str[maxN][maxN]; char s[maxN]; int vis[27],query_id[maxM],ans[maxN][3]; int num,x,y

poj 1204 Word Puzzles(字典树)

题目链接:http://poj.org/problem?id=1204 思路分析:由于题目数据较弱,使用暴力搜索:对于所有查找的单词建立一棵字典树,在图中的每个坐标,往8个方向搜索查找即可: 需要注意的是查找时不能匹配了一个单词就不在继续往该方向查找,因为在某个坐标的某个方向上可能会匹配多个单词,所以需要一直 查找直到查找到该方向上最后一个坐标: 代码如下: #include <cstdio> #include <cstring> #include <iostream>