实习+秋招刷题021-022（牛客刷题）剑指offer

021矩阵中的路径
题目描述

请设计一个函数，用来判断在一个n乘m的矩阵中是否存在一条包含某长度为len的字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。

关键解题思路
深度优先遍历（dfs）+递归
1、双循环先找到开始格子，并初始化一个二维数组来定义每个格子状态（是否被使用）、
2、递归：
结束条件：（1）当前格子越界、当前格子值不匹配、当前格子状态为已使用；
（2）当前各自为路径最后一个字符（且通过 （1）已经判断格子值是匹配的）。
返回值：false/true
本机任务：先将当前格子的flag[i][j]置为true，然后从当前格子上下左右移动，判断这四个位置是否有符合路径所想要的字符。如果没有，则flag[i][j]还原为false。
Solution

import java.util.*;
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param matrix char字符型二维数组 
     * @param word string字符串 
     * @return bool布尔型
     */
    public boolean hasPath (char[][] matrix, String word) {
        // write code here
        //深度优先遍历和递归
        boolean[][] flag = new boolean[matrix.length][matrix[0].length];
        for(int i=0; i<matrix.length; i++){
            for(int j=0; j<matrix[0].length; j++){
                if(dfs(matrix, word,i, j ,0,flag)){
                    return true;
                }
            }
        }
        return false;
    }
    boolean dfs(char[][] matrix, String word,int i, int j,int index, boolean[][] flag){
        //判断结束条件1：判断该格子是否越界或者该格子字符是否等于word.charAt(index)
        //越界判断一定要放在(matrix[i][j]!=word.charAt(index))判断前面，否则可能先出现数组越界行为。
        if(index>=word.length() || i<0 ||j<0 ||i>=matrix.length||j>=matrix[0].length ||(matrix[i][j]!=word.charAt(index)) || flag[i][j]==true){
        //    System.out.println("11111");
            return false;
        }
        //判断结束条件2：是否是最后一个字符，如果是最后一个字符就可结束（上面的判断中已经做完该格子字符是否等于word.charAt(index)）。
        if(index == word.length()-1){
            return true;
        }
        //设置flag[i][j],即[i][j]格子已使用
        flag[i][j] = true;
        if(
            dfs(matrix, word, i-1, j, index+1,flag)
           || dfs(matrix, word, i+1, j ,index+1,flag)
           || dfs(matrix, word, i, j-1,index+1,flag) 
           || dfs(matrix, word, i, j+1,index+1,flag)
        ){
            return true;
        }
        //该路径不符合，还原flag[i][j],即[i][j]格子没用过
        flag[i][j] = false;
        return false;
    }
}

022剪绳子
题目描述
给你一根长度为 n 的绳子，请把绳子剪成整数长的 m 段（ m 、 n 都是整数， n > 1 并且 m > 1 ， m <= n ），每段绳子的长度记为 k[1],…,k[m] 。请问 k[1]k[2]…k[m] 可能的最大乘积是多少？例如，当绳子的长度是 8 时，我们把它剪成长度分别为 2、3、3 的三段，此时得到的最大乘积是 18 .

关键解题思路
动态规划：就是先解决小问题，再解决大问题。（例如剪7米的绳子最优解，我先知道剪6米绳子的最优解）。
题目解读：这一题就是剪绳子可以考虑两个问题，1）剪与不剪；2）如果剪，怎么剪更好。要知道，值越大肯定是剪更好。
定义数组：dp[i]表示剪i米绳子的最优解。初始化dp[]数组每一个值为0；
初始化：dp[1]=1(不分)，dp[2]=2（不分更好），dp[3]=3不分更好。
递推公式：如果有一个长度为n的绳子，可以看成一段可分一段不可分，不可分的长度用j表示，另一端可分的最优解就是dp[n-j]（这就是先要解决的小问题）。然后遍历所有可能的j，找到最优解。
dp[i]= max(dp[i], jdp[i-j] ) 其中 j=0，1，2…i-1。

Solution

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param n int整型 
     * @return int整型
     */
    public int cutRope (int n) {
        // write code here
        //动态回归：从解决小问题（比n短绳子的最优解）出发，最后解决大问题。
        //剪绳最终有可能两种情况：1、绳子不分；2、绳子可分；
        //如果绳子可分，那么这段绳子分的方式就是由一段可分和一段不可分组成
        //定义数组变量：用dp[i]表示长度为i的绳子最优剪法后乘积。
        //递推公式：dp[i] = max(dp[i], j*dp[i-j]) j表示不可分的长度
        //初始化：dp[1]=1; dp[2]=2;
        if(n<=3){
            return n; 
        }
        if(n<0){
            return 0;
        }
        int[] dp = new int[n+1];
        dp[1] = 1;
        dp[2] = 2;
        dp[3] = 3;
        dp[4] = 4;
        for(int i=3; i<=n; i++){
            for(int j =0; j<i;j++){
                dp[i] = Math.max(dp[i], j*dp[i-j]);
            }
        }
        return dp[n];
    }
}