uvalive 7299 Boggle

Boggle is a game in which 16 dice with letters on each side are placed into a 4 × 4 grid. Players then attempt to find words using letters from adjacent dice. You must write a program to find words from letters in a Boggle-like grid. When forming a word, each letter must be adjacent in the grid (horizontally, vertically, or diagonally) to the previous letter, and each grid position (not necessarily each letter) may only appear once in each word. In normal Boggle, every side of each die contains a single letter with one exception. No side has the letter q by itself; instead, the 2 letters qu appear together. Similarly, when the letter q appears in one of the grids in this problem’s Boggle variant, it should be treated as qu.

Input Input consists of a dictionary of words followed by several letter grids.

The first line contains an integer W (1 ≤ W ≤ 200) indicating the number of words in the dictionary.
Each of the following W lines contains a string of 1 to 25 lowercase ASCII letters (a - z) representing
a unique word in the dictionary.
The dictionary is followed by 1 or more letter grids. Each begins with a line containing an integer
D (2 ≤ D ≤ 8) indicating the size of that grid (square of size D × D) or 0 (zero) indicating end of
input. The following D lines each contain D lowercase ASCII letters (a - z); each line represents a row
in the grid.
Output
For each grid, output consists of the following:
• A line for each dictionary word that was found in the grid, sorted alphabetically.
• A line containing a dash (-).

Sample Input
3
april
purple
quilt
5
rprit
ahqln
ietep
zrysg
ogwey
3
pel
aup
bcr
0

Sample Output
april
quilt
-
purple
-

题意：给出m个要查询的的单词，n组输入，对于每一个n×n的矩阵你可以与任意一边相邻的八个方向搜索，若能匹配到要查询的单词则输出，每组数据后输出一行“-”

若果遇到‘q’你需要把它替换成“qu”;

题解：dfs搜索八个方向，如果遇到‘q'，判断他下一个字符是否为’u'，若不是则返回，反之继续搜索它的后一个字符（‘u'已经搜索过了，所以cur++);不剪枝的会超时，剪枝的内容代码里会讲;

注意：输出时要将搜索到的单词按字典序排列

 #include<cstdio>
 #include<cstring>
 #include<iostream>
 #include<vector>
 #include<map>
 #include<algorithm>
 #define true 1
 #define false 0
 using namespace std;
 typedef long long LL;
 const int N=1e3+;
 vector<string>arr,str;
 int dis[][]= {{,},{-,},{,-},{,},{-,-},{-,},{,-},{,}};//方向数组
 int vis[N][N];//标记数组
 int m,n,flag,len;
 void solve();
 void Init()
 {
     arr.clear();
     memset(vis,,sizeof(vis));
 }
 void Input()
 {
     string s;
     cin>>m;
     for(int i=; i<m; i++)
     {
         cin>>s;
         str.push_back(s);
     }
     while(cin>>n&&n)
     {
         Init();
         for(int i=; i<n; i++)
         {
 
             cin>>s;
             arr.push_back(s);
         }
         solve();
     }
 
 }
 
 void dfs(int x,int y,int num,int cur)//x当前行，y当前列，num代表第几个单词，cur代表该单词的第几个字符
 {
     int cnt=str[num].size();
     if(cur>=cnt||flag||x>=n||y>=n)//如果当前cur大于等于该字符串的长度或该字符窜已经找到或者当前行的长度或列的高度大于矩阵的阶数，剪枝1
     {

         return ;
     }
     if(str[num][cur]=='q')//剪枝2
     {
         if(cur+<cnt&&str[num][cur+]=='u')//判断下一个字符是否为‘u'
         {
             cur++;
         }
         else
             return;
     }
     if(cur==cnt-)
     {
         flag=;
         return ;
     }
     for(int i=; i<; i++)//八方向搜索
     {
         int dx=x+dis[i][];
         int dy=y+dis[i][];
         if(dx>=&&dx<n&&dy>=&&dy<n&&!vis[dx][dy])//判断是否满足条件
         {
             if(arr[dx][dy]==str[num][cur+])
             {
                 vis[dx][dy]=true;//标记
                 dfs(dx,dy,num,cur+);
                 vis[dx][dy]=false;//标记还原
             }
         }
     }
 }
 void solve()
 {
     vector<string>s;
     for(int i=,len=str.size(); i<len; i++)
     {
         flag=;
         for(int j=; j<n; j++)
         {
             memset(vis,,sizeof(vis));
             for(int k=; k<n; k++)//找到与该单词第一个字符相等的矩阵的位置
             {
                 if(arr[j][k]==str[i][])
                 {
                 vis[j][k]=true;//标记
                 dfs(j,k,i,);
                 }
             }
             if(flag)//如果搜索到flag返回true
                 break;
         }
         if(flag)
             s.push_back(str[i]);
     }
     sort(s.begin(),s.end());//对字符串排序
     for(int i=,len=s.size(); i<len; i++)
         cout<<s[i]<<endl;
     cout<<"-"<<endl;
 }
 int main()
 {
     Input();
 }