剑指offer之矩阵中的路径（深度优先搜索：DFS，递归）

 

题目

 

 

思路及代码

import java.util.*;
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param matrix string字符串 
     * @param rows int整型 
     * @param cols int整型 
     * @param str string字符串 
     * @return bool布尔型
     */
    /** 
    0、flag数组，对已访问过的字符进行标记，为boolean类型
    1、找到要搜索的字符串的第一个字符在矩阵中的位置，若不存在该字符，则不存在该路径；
    2、从该字符串字符在矩阵中的位置开始，向左、右、上、下进行搜索，若存在该字符的下一个字符，
       则标记为true,c重复过程2，否则记为false。若该四个方位均不存在该字符的下一个字符，
       返回该字符路径中的上一个位置，对当前方位的下一个方位进行搜索；
    3、搜索过程：
       从当前位置按左右上下的方位进行搜索，若搜索成功则当前位置变更为搜索成功的位置，继续按方位搜索；
       若搜索不成功，则说明不存在该路径
    */
    public boolean hasPath (String matrix, int rows, int cols, String str) {
        // write code here
        boolean [] flag = new boolean [rows*cols];//对已访问过的字符进行标记
        char [] juzhen = matrix.toCharArray();//将字符串转换为字符串数组
        char [] strs = str.toCharArray();
        for(int i= 0;i< rows;i++){
            for(int j=0;j< cols;j++){
                if(search(juzhen,strs,flag,rows,cols,i,j,0)) return true;
            }
        }
        return false;
    }
    //k代表当前匹配的给出路径的第k个字符
    public boolean search (char[] juzhen,char[] strs,boolean[] flag,int rows,int cols,int i,int j,int k){
        // 越界
        int next = i*cols + j;//按行遍历乘列
        if(i<0 ||i>=rows || j<0|| j>= cols || flag[next]== true || juzhen[next]!= strs[k] ){
            return false;
        }
        if (k == strs.length - 1)return true;//已查询到所查询数字的最后一个字符
            flag[next]= true;
            //利用逻辑运算符的“短路”特性依次向左、右、上、下进行搜索
            if( search(juzhen,strs,flag,rows,cols,i,j-1,k+1)||//左
                search(juzhen,strs,flag,rows,cols,i,j+1,k+1)||//右
                search(juzhen,strs,flag,rows,cols,i-1,j,k+1)||//上
                search(juzhen,strs,flag,rows,cols,i+1,j,k+1)//下
              )return true;
            flag[next] = false;
            return false;
//取消对该位置的标记，
/** 1 2 3 4
    5 6 7 8
比如路径为1267，假设遍历到2的时候对2进行标记，则在向右搜索到3的时候2会被重新搜索，若标记为已访问则不用走回头路。
        }
}

深度优先搜索

 

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param matrix string字符串 
     * @param rows int整型 
     * @param cols int整型 
     * @param str string字符串 
     * @return bool布尔型
     */
    /** 
    0、flag数组，对已访问过的字符进行标记，为boolean类型
    1、找到要搜索的字符串的第一个字符在矩阵中的位置，若不存在该字符，则不存在该路径；
    2、从该字符串字符在矩阵中的位置开始，向左、右、上、下进行搜索，若存在该字符的下一个字符，
       则标记为true,c重复过程2，否则记为false。若该四个方位均不存在该字符的下一个字符，
       返回该字符路径中的上一个位置，对当前方位的下一个方位进行搜索；
    3、搜索过程：
       从该位置向左
    */
    public boolean hasPath (String matrix, int rows, int cols, String str) {
        // write code here
        boolean [] flag = new boolean [rows*cols];//对已访问过的字符进行标记
        char [] juzhen = matrix.toCharArray();//将字符串转换为字符串数组
        char [] strs = str.toCharArray();
        for(int i= 0;i< rows;i++){
            for(int j=0;j< cols;j++){
                if(search(juzhen,strs,flag,rows,cols,i,j,0)) return true;
            }
        }
        return false;
    }
    //k代表当前匹配的给出路径的第k个字符
    public boolean search (char[] juzhen,char[] strs,boolean[] flag,int rows,int cols,int i,int j,int k){
        // 越界
        if(i<0 ||i>=rows || j<0|| j>= cols){
            return false;
        }else{
            int next = i*rows + cols;//即将查找的下一个字符位置
            if(flag[next]== true || juzhen[next]!= strs[k] ){
                return false;
            }else{
                flag[next]= true;
            }
            if (k==strs.length){
                return true;//已查询到所查询数字的最后一个字符
            }
            //利用逻辑运算符的“短路”特性依次向左、右、上、下进行搜索
            if( search(juzhen,strs,flag,rows,cols,i,j-1,k+1)||//左
                search(juzhen,strs,flag,rows,cols,i,j+1,k+1)||//右
                search(juzhen,strs,flag,rows,cols,i-1,j,k+1)||//上
                search(juzhen,strs,flag,rows,cols,i+1,j,k+1)//下
              )return true;
            flag[next] = false;
            return false;
        }
        
    }
}

import java.util.*;
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param matrix string字符串 
     * @param rows int整型 
     * @param cols int整型 
     * @param str string字符串 
     * @return bool布尔型
     */
    /** 
    0、flag数组，对已访问过的字符进行标记，为boolean类型
    1、找到要搜索的字符串的第一个字符在矩阵中的位置，若不存在该字符，则不存在该路径；
    2、从该字符串字符在矩阵中的位置开始，向左、右、上、下进行搜索，若存在该字符的下一个字符，
       则标记为true,c重复过程2，否则记为false。若该四个方位均不存在该字符的下一个字符，
       返回该字符路径中的上一个位置，对当前方位的下一个方位进行搜索；
    3、搜索过程：
       从该位置向左
    */
    public boolean hasPath (String matrix, int rows, int cols, String str) {
        // write code here
        boolean [] flag = new boolean [rows*cols];//对已访问过的字符进行标记
        char [] juzhen = matrix.toCharArray();//将字符串转换为字符串数组
        char [] strs = str.toCharArray();
        for(int i= 0;i< rows;i++){
            for(int j=0;j< cols;j++){
                if(search(juzhen,strs,flag,rows,cols,i,j,0)) return true;
            }
        }
        return false;
    }
    //k代表当前匹配的给出路径的第k个字符
    public boolean search (char[] juzhen,char[] strs,boolean[] flag,int rows,int cols,int i,int j,int k){
        // 越界
        int next = i*rows + j;
        if(i<0 ||i>=rows || j<0|| j>= cols || flag[next]== true || juzhen[next]!= strs[k] ){
            return false;
        }
             if (k==strs.length - 1)return true;//已查询到所查询数字的最后一个字符
              flag[next]= true;
            //利用逻辑运算符的“短路”特性依次向左、右、上、下进行搜索
            if( search(juzhen,strs,flag,rows,cols,i,j-1,k+1)||//左
                search(juzhen,strs,flag,rows,cols,i,j+1,k+1)||//右
                search(juzhen,strs,flag,rows,cols,i-1,j,k+1)||//上
                search(juzhen,strs,flag,rows,cols,i+1,j,k+1)//下
//                if(search(juzhen,strs,flag,rows,cols,i-1,j,k+1)||//左
//                 search(juzhen,strs,flag,rows,cols,i+1,j,k+1)||//右
//                 search(juzhen,strs,flag,rows,cols,i,j-1,k+1)||//上
//                 search(juzhen,strs,flag,rows,cols,i,j+1,k+1)//下
              )return true;
            flag[next] = false;
            return false;
        }
}