[剑指offer]

 

题目描述

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。 例如 a b c e s f c s a d e e 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。

 

 

题目链接：

https://www.nowcoder.com/practice/c61c6999eecb4b8f88a98f66b273a3cc?tpId=13&tqId=11218&rp=3&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

 

 

 

 

 

package com.sunshine.OFFER66_SECOND;

import org.junit.Test;

public class A65_hasPath {


    @Test
    public void test() {
        char[] matrix = new char[]{'a', 'b', 'c', 'e', 's', 'f', 'c', 's', 'a', 'd', 'e', 'e'};
        char[] str = {'b', 'c', 'c', 'e', 'd'};
        boolean b = hasPath(matrix, 3, 4, str);
        System.out.println(b);
    }

    int rows;
    int cols;
    boolean ans = false;

    public boolean hasPath(char[] matrix, int rows, int cols, char[] str) {
        this.rows = rows;
        this.cols = cols;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                boolean[] flags = new boolean[rows * cols];
                BFS(matrix, flags, i, j, str, 0);
                if (ans) {
                    return ans;
                }
            }
        }
        return ans;
    }

    private void BFS(char[] matrix, boolean[] flags, int x, int y, char[] str, int pos) {
        if (!check(flags, x, y) || ans || pos >= str.length) {
            return;
        }
        int cur = x * cols + y;
        if (matrix[cur] == str[pos]) {
            flags[cur] = true;
            if (pos + 1 == str.length) {
                ans = true;
                return;
            }
            BFS(matrix, flags, x + 1, y, str, pos + 1);
            BFS(matrix, flags, x - 1, y, str, pos + 1);
            BFS(matrix, flags, x, y + 1, str, pos + 1);
            BFS(matrix, flags, x, y - 1, str, pos + 1);
        }
        return;
    }

    private boolean check(boolean[] flags, int x, int y) {
        if (x >= 0 && x < rows && y >= 0 && y < cols && !flags[x * cols + y]) {
            return true;
        }
        return false;
    }
}