关于矩阵的算法

矩阵的最小路径和64

[[1,3,1],
[1,5,1],
[4,2,1]]
Given the above grid map, return 7. Because the path 1→3→1→1→1 minimizes the sum.

class Solution {    
public int minPathSum(int[][] grid) {   
   int m=grid.length,n=grid[0].length;    
     for(int i=1;i<n;i++){        
       grid[0][i]+=grid[0][i-1];   
     }      
     for(int i=1;i<m;i++){        
        grid[i][0]+=grid[i-1][0];      
     }     
     for(int i=1;i<m;i++){          
        for(int j=1;j<n;j++){             
            grid[i][j]+=Math.min(grid[i][j-1],grid[i-1][j]);        
        }      
     }      
       return grid[m-1][n-1];   
 }
 }

矩阵的总路径数62

统计从矩阵左上角到右下角的路径总数，每次只能向右或者向下移动。

public int uniquePaths(int m,int n){
  int[] dp=new int[n];
  Arrays.fill(dp,1);
  for(int i=1;i<m;i++){
    for(int j=1;j<n;j++){
       dp[j]=dp[j]+dp[j-1];
    }
  }
  return dp[n-1];

矩阵中的路径

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

public class Solution {
   public int[][] visit;
   public boolean hasPath(char[] matrix, int rows, int cols, char[] str){
       visit=new int[rows][cols];
       char[][] array=new char[rows][cols];
      //二维
       for(int i = 0; i < rows; i ++){
            for(int j = 0; j < cols; j++){
              array[i][j]=matrix[i*cols+j];
            }
        }
       // 调用find
        for(int i = 0; i < rows; i ++){
            for(int j = 0; j < cols; j++){
               if(find(array,rows,cols,str,i,j,0)){
                   return  true;
            }
        }
        return false;
  }
 public boolean  find(char[][] array, int rows, int cols, char[] str, int rpos,int cpos, int length){
    if(length>=str.length){
       return true;
    }
    if(rpos<0||cpos<0||rpos>=rows||cpos>=cols||array[rpos][cpos]!=str[length]||visit[rpos][cpos]==1){
    visit[rpos][cpos]==1;//是否再次进入格子
    boolean isSunc=find(array,rows,cols,str,rpos+1,cpos,length+1)
    ||find(array,rows,cols,str,rpos,cpos+1,length+1)
    ||find(array,rows,cols,str,rpos-1,cpos,length+1)
    ||find(array,rows,cols,str,rpos,cpos-1,length+1);
    visit[rpos][cpos]==0;
    return isSunc;
 }
}

顺时针打印矩阵

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
       ArrayList<Integet> list=new ArrayList<>();
       if(matrix==null||matrix.length==0||matrix[0].length==0){
         return list;
       }
       int up=0;
       int down=matrix.length-1;
       int left=0;
       int right=matrix[0].length-1;
       while(true){
         for(int col=left;col<=right;col++){
            list.add(matrix[up][col]);
         }
         up++;
         if(up>down){
            break;
         }
         for(int row=up;row<=down;row++){
            list.add(matrix[row][right];
         }
         right--;
         if(left>right){
           break;
         }
         for(int col=right;col>=left;col--){
            list.add(matrix[down][col];
         }
         down--;
         if(up > down){
                break;
         }
         for(int row=down;row>=up;row--){
            list.add(matrix[row][left];
         }
         left++;
         if(left > right){
                break;
         }
    }
    return list;
}
}