题目链接
https://www.nowcoder.com/profile/6632135/test/17212550/117516#summary
1.题目描述
字符迷阵是一种经典的智力游戏。玩家需要在给定的矩形的字符迷阵中寻找特定的单词。
在这题的规则中,单词是如下规定的:
1. 在字符迷阵中选取一个字符作为单词的开头;
2. 选取右方、下方、或右下45度方向作为单词的延伸方向;
3. 以开头的字符,以选定的延伸方向,把连续得到的若干字符拼接在一起,则称为一个单词。
以图1为例,如果要在其中寻找单词”WORD”,则绿色框所标示的都是合法的方案,而红色框所标示的都是不合法的方案。
现在的问题是,给出一个字符迷阵,及一个要寻找的单词,问能在字符迷阵中找到多少个该单词的合法方案。注意合法方案是可以重叠的,如图1所示的字符迷阵,其中单词”WORD”的合法方案有4种。
1.1输入描述
输入的第一行为一个正整数T,表示测试数据组数。 接下来有T组数据。每组数据的第一行包括两个整数m和n,表示字符迷阵的行数和列数。接下来有m行,每一行为一个长度为n的字符串,按顺序表示每一行之中的字符。再接下来还有一行包括一个字符串,表示要寻找的单词。 数据范围: 对于所有数据,都满足1<=T<=9,且输入的所有位于字符迷阵和单词中的字符都为大写字母。要寻找的单词最短为2个字符,最长为9个字符。字符迷阵和行列数,最小为1,最多为99。 对于其中50%的数据文件,字符迷阵的行列数更限制为最多为20。
1.2输出描述
对于每一组数据,输出一行,包含一个整数,为在给定的字符迷阵中找到给定的单词的合法方案数。
1.3输入例子1
3
10 10
AAAAAADROW
WORDBBBBBB
OCCCWCCCCC
RFFFFOFFFF
DHHHHHRHHH
ZWZVVVVDID
ZOZVXXDKIR
ZRZVXRXKIO
ZDZVOXXKIW
ZZZWXXXKIK
WORD
3 3
AAA
AAA
AAA
AA
5 8
WORDSWOR
ORDSWORD
RDSWORDS
DSWORDSW
SWORDSWO
SWORD
1.4输出例子1
4
16
5
2.题目分析
对于该题,我并没有什么比较好的想法,可以说是用暴力解来做的。
2.1 题目分解
首先,在字符矩形寻找特定的单词,分解一下题目,把题目分成三部分来做:
1. 对于第一种情况,m行个字符串来说,计算每一个字符串有多少个特定的单词;
2. 对于第二种情况,n列个字符串来说,计算每一个字符串有多少个特定的单词;
3. 对于第三种情况,若干个对角线字符串来说,计算每一个字符串有多少个特定的单词。
2.2 题目推导
现在问题变成了:
1. 如何处理字符矩阵,将字符矩阵变成上述三种情况的字符串数组;
2. 对于每个字符串,如何寻找到特定单词的个数。
2.1 具体算法
依次来做:
1. 将字符矩阵变成上述三种情况的字符串数组:
这个就是硬编码能力了,无非就是横着打印数组,竖着打印数组,以及斜着打印数组的思想。
注意
,在斜着的情况下,如果m,n中的最小值,小于单词的长度,那个这种情况就不用考虑了。因为你会发现,斜着的字符串最长的情况下,为m,n中的小值,根本不可能出现能匹配到单词的情况。
2. 计算每一个字符串有多少个特定的单词:
我脑子里面的第一反应就是KMP算法
,复杂度低,更关键的是,KMP算法
返回的是匹配串的下标,对于字符串中有多个单词的情况,是非常有用的。
具体的做法是:
public static int processOneString(String s, String key) {
int count = 0;
int index = getIndexOf(s, key);
//对于字符串s存在单词key的情况下
if (index >= 0) {
//计算s及其字串中单词的数量
for (int j = 0; j <= s.length() - key.length();) {
index = getIndexOf(s.substring(j, s.length()), key);
if (index >= 0) {
//如果存在单词,那么下一次字串的起始位置是:
//返回的下标+1
j += (index + 1);
count++;
} else {
j++;
}
}
}
//对于字符串s存在单词key的情况下,什么也不做
return count;
}
3.完整的AC代码
import java.util.*;
public class FindString {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int T = in.nextInt();
in.nextLine();
for (int k = 0; k < T; k++) {
int m = in.nextInt();
int n = in.nextInt();
in.nextLine();
String[] ss = new String[m];
for (int i = 0; i < m; i++) {
ss[i] = in.nextLine();
}
String key = in.nextLine();
System.out.println(processRow(ss, key) + processCol(ss, key) + processDiagonal(ss, key));
}
in.close();
}
/**
* 处理第一种情况:即计算每一行的字串中包含要寻找的关键字的个数
* @param arr : 一个字符串数组
* @param key : 要寻找的关键字
* */
public static int processRow(String[] arr, String key) {
int res = 0;
for (int i = 0; i < arr.length; i++) {
res += processOneString(arr[i], key);
}
return res;
}
/**
* 处理第二种情况:即计算每一列的字串中包含要寻找的关键字的个数
* @param arr : 一个字符串数组
* @param key : 要寻找的关键字
* */
public static int processCol(String[] arr, String key) {
int res = 0;
int m = arr.length;
int n = arr[0].length();
String[] tempArr = new String[n];
//将行串转换为列
for (int col = 0; col < n; col++) {
StringBuilder sb = new StringBuilder();
for (int row = 0; row < m; row++) {
sb.append(arr[row].charAt(col));
}
tempArr[col] = sb.toString();
}
for (int i = 0; i < tempArr.length; i++) {
res += processOneString(tempArr[i], key);
}
return res;
}
/**
* 处理第三种情况:即计算对角线的字串中包含要寻找的关键字的个数
* @param arr : 一个字符串数组
* @param key : 要寻找的关键字
* */
public static int processDiagonal(String[] arr, String key) {
int res = 0;
int m = arr.length;
int n = arr[0].length();
//求输入矩阵行列的小值,如果min<key.length() 说明不可能有满足条件的情况出现
int min = m > n ? n : m;
if (min >= key.length()) {
LinkedList<String> list = new LinkedList<>();
//求对角线上的字符串,对角线出发点从(0,n-key.length())的位置开始
//因为长度小于key长度的字符都不符合要求
for (int col = n - key.length(); col >= 0; col--) {
StringBuilder sb = new StringBuilder();
int i = 0;
int j = col;
//i,j有一个达到m、n值,循环停止,一个斜着的字符串寻找完毕
while (i < m && j < n) {
sb.append(arr[i++].charAt(j++));
}
list.add(sb.toString());
}
//求对角线上的字符串,对角线出发点从(1,0)的位置开始,到(m - key.length(),0)位置结束
for (int row = 1; row <= m - key.length(); row++) {
StringBuilder sb = new StringBuilder();
int i = row;
int j = 0;
while (i < m && j < n) {
sb.append(arr[i++].charAt(j++));
}
list.add(sb.toString());
}
for (String s : list) {
res += processOneString(s, key);
}
}
return res;
}
/**
* 计算一个字符串中有多少个key
*
* @param s
* :输入的字符串
* @param key
* :要匹配的字串
*/
public static int processOneString(String s, String key) {
int count = 0;
int index = getIndexOf(s, key);
if (index >= 0) {
for (int j = 0; j <= s.length() - key.length();) {
index = getIndexOf(s.substring(j, s.length()), key);
if (index >= 0) {
j += (index + 1);
count++;
} else {
j++;
}
}
}
return count;
}
/**
* KMP算法,输出字串在原串中首次出现的下标,如果没有字串返回-1
* @param s
* :被匹配的串
* @param m
* :匹配串
* */
public static int getIndexOf(String s, String m) {
if (s == null || m == null || s.length() < 1 || s.length() < m.length()) {
return -1;
}
char[] ss = s.toCharArray();
char[] ms = m.toCharArray();
int si = 0;
int mi = 0;
int[] next = getNextArray(ms);
while (si < ss.length && mi < ms.length) {
if (ss[si] == ms[mi]) {
si++;
mi++;
} else if (next[mi] == -1) {
si++;
} else {
mi = next[mi];
}
}
return mi == ms.length ? si - mi : -1;
}
/**
* KMP算法中,计算match字符串的nextArr数组
* @param ms : match字符串
* */
public static int[] getNextArray(char[] ms) {
if (ms.length == 1) {
return new int[] { -1 };
}
int[] next = new int[ms.length];
next[0] = -1;
next[1] = 0;
int pos = 2;
int cn = 0;
while (pos < next.length) {
if (ms[pos - 1] == ms[cn]) {
next[pos++] = ++cn;
} else if (cn > 0) {
cn = next[cn];
} else {
next[pos++] = 0;
}
}
return next;
}
}