洛谷——P1101 单词方阵

https://www.luogu.org/problem/show?pid=1101#sub

题目描述

给一nXn的字母方阵,内可能蕴含多个“yizhong”单词。单词在方阵中是沿着同一方向连续摆放的。摆放可沿着8个方向的任一方向,同一单词摆放时不再改变方向,单词与单词之间[color=red]可以[/color]交叉,因此有可能共用字母。输出时,将不是单词的字母用“*”代替,以突出显示单词。例如:

输入:
    8                     输出:
    qyizhong              *yizhong
    gydthkjy              gy******
    nwidghji              n*i*****
    orbzsfgz              o**z****
    hhgrhwth              h***h***
    zzzzzozo              z****o**
    iwdfrgng              i*****n*
    yyyygggg              y******g

输入输出格式

输入格式:

第一行输入一个数n。(7<=n<=100)。

第二行开始输入nXn的字母矩阵。

输出格式:

突出显示单词的nXn矩阵。

输入输出样例

输入样例#1:

7
aaaaaaa
aaaaaaa
aaaaaaa
aaaaaaa
aaaaaaa
aaaaaaa
aaaaaaa

输出样例#1:

*******
*******
*******
*******
*******
*******
*******

没什么好说的~~~洛谷字符串有毒~
 1 #include <algorithm>
 2 #include <iostream>
 3
 4 using namespace std;
 5
 6 int n,mark[119][119];
 7 int fx[8]={0,0,1,1,1,-1,-1,-1};
 8 int fy[8]={1,-1,0,1,-1,0,1,-1};
 9 char yz[7]= {‘y‘,‘i‘,‘z‘,‘h‘,‘o‘,‘n‘,‘g‘},word[119][119];
10
11 void print(int x,int y,int drict)
12 {
13     int cnt=0,xx=x,yy=y;
14     for(int i=0;i<7;i++)
15     {
16         if(word[x][y]==yz[i]) cnt++;
17         else break;
18         x+=fx[drict];y+=fy[drict];
19     }
20     if(cnt!=7) return ;
21     for(int i=0;i<7;i++)
22     {
23         mark[xx][yy]=1;
24         xx+=fx[drict];yy+=fy[drict];
25     }
26 }
27
28 int main()
29 {
30     cin>>n;
31     for(int i=1;i<=n;i++)
32         for(int j=1;j<=n;j++)
33             cin>>word[i][j];
34     for(int i=1;i<=n;i++)
35       for(int j=1;j<=n;j++)
36         if(word[i][j]==‘y‘)
37         for(int k=0;k<8;k++)
38          if(word[i+fx[k]][j+fy[k]]==‘i‘) print(i,j,k);
39     for(int i=1;i<=n;i++)
40     {
41         for(int j=1;j<=n;j++)
42             if(mark[i][j]) cout<<word[i][j];
43             else cout<<‘*‘;
44         cout<<endl;
45     }
46     return 0;
47 }
时间: 2024-10-06 04:49:44

洛谷——P1101 单词方阵的相关文章

洛谷P1101 单词方阵——S.B.S.

题目描述 给一nXn的字母方阵,内可能蕴含多个“yizhong”单词.单词在方阵中是沿着同一方向连续摆放的.摆放可沿着8个方向的任一方向,同一单词摆放时不再改变方向,单词与单词之间[color=red]可以[/color]交叉,因此有可能共用字母.输出时,将不是单词的字母用“*”代替,以突出显示单词.例如: 输入: 8 输出: qyizhong *yizhong gydthkjy gy****** nwidghji n*i***** orbzsfgz o**z**** hhgrhwth h***

洛谷 P1101 单词方阵

不算搜索的搜索 思路和很多人的一样,因为只要找到两个字母,方向就确定了,记录下方向,剩下的暴力即可. #include<iostream> #include<cstdio> #include<algorithm> using namespace std; int n; int fx[9][2]={{0,0},{1,0},{-1,0},{0,1},{0,-1},{1,1},{1,-1},{-1,1},{-1,-1}};//存方向,循环起来比较方便 char map[101

落谷P1101 单词方阵 //参考代码

1 #include<iostream> 2 #include <cstdio> 3 #include <cstring> 4 using namespace std; 5 const int N = 105; 6 char s[N][N], a[] = "yizhong"; 7 bool vis[N][N]; 8 int n; 9 int dx[8] = {0, 0, 1, -1, 1, 1, -1, -1}, 10 dy[8] = {1, -1,

落谷P1101 单词方阵 //未完成

1 #include<iostream>/*cout<<endl; 2 for(int i=1;i<=n;i++) 3 for(int j=0;j<n;j++){ 4 5 cout<<a[i][j]; 6 if(j==n-1)cout<<endl; 7 }*/ 8 #include<cstring> 9 #include<cstdio> 10 using namespace std; 11 const int wd=101

P1101 单词方阵【洛谷】

//题目----------------------------------------------------------------------------------------- 传送门: http://www.luogu.org/problem/show?pid=1101 P1101 单词方阵 题目描述 给一nXn的字母方阵,内可能蕴含多个“yizhong”单词.单词在方阵中是沿着同一方向连续摆放的.摆放可沿着8个方向的任一方向,同一单词摆放时不再改变方向,单词与单词之间[color=

Luogu P1101 单词方阵

明明是一道水题,我还找不出 bug 来...原本在 DFS 途中记录单词串,只好使用笨方法,在结尾加一个 for 记录单词串.终于过了. 思路:枚举图中每一个点进行 DFS,途中判断访问的点是否为连续元素("yizhong"字符串中连续),如果不是返回:进行下一层 DFS,如果返回值 True 则直接层层返回 True,强行退出. 1 /* P1101 单词方阵 2 * Au: GG 3 */ 4 #include <cstdio> 5 #include <cstdl

洛谷P1019单词接龙 搜索

洛谷P1019 单词接龙 这道题目 我用的是搜索 应为起点已经确认了,那就从这开始搜索,如果能接上去就接上去,回溯一下需要注意的就是一些细节问题,比方说不能被另一个单词完全覆盖等等 以及字符串是从零开始的问题 1 #include <cstdio> 2 #include <iostream> 3 #include <cstring> 4 #include <cstdlib> 5 #include <string> 6 #include <a

洛谷P1019 单词接龙

P1019 单词接龙 题目描述 单词接龙是一个与我们经常玩的成语接龙相类似的游戏,现在我们已知一组单词,且给定一个开头的字母,要求出以这个字母开头的最长的“龙”(每个单词都最多在“龙”中出现两次),在两个单词相连时,其重合部分合为一部分,例如 beast和astonish,如果接成一条龙则变为beastonish,另外相邻的两部分不能存在包含关系,例如at 和 atide 间不能相连. 输入输出格式 输入格式: 输入的第一行为一个单独的整数n (n<=20)表示单词数,以下n 行每行有一个单词,

洛谷 P1019 单词接龙 (DFS)

题目传送门 当时一看到这题,蒟蒻的我还以为是DP,结果发现标签是搜索-- 这道题的难点在于思路和预处理,真正的搜索实现起来并不难.我们可以用一个贪心的思路,开一个dic数组记录每个单词的最小重复部分,这样搜索的时候就可以很方便地查阅dic数组,而不是每次再计算一遍. 预处理是长这样子的: void f(string a,string b,int x,int y) { int a1=a.size()-1,b1=b.size()-1; for(int i=0;i<=b1;i++) //从第一个开始枚