网易游戏互娱2018秋招笔试题-字符迷阵

题目链接
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;
    }

}