leetcode刷题(被围绕的区域、字符串相乘、图像的渲染)

好久没有写博客了，由于自己最近准备一些找工作用的知识笔记，将java的基础知识在重新的准备复习，复习的相关笔记记录在个人的博客上，有并发编程的对一些框架、jvm的理解，希望有什么错误可以给我一些提示。
博客地址

1.被围绕的区域

1.1 题目描述

给定二维矩阵，其中有X和O两种字母，替换所有被X包围的O，边界以及边界相连的O不被替换

例如：
X X X X
X O O X
X X O X
X O X X

更改后
X X X X
X X X X
X X X X
X O X X

题目传送门

1.2 题目分析

由于边界上的O不会被替换，因此将边界上以及边界相连的所有的O修改为另外一个字母，然后遍历数组将O替换为X，将原先的O替换回来
例如上面的例子中的中间过程有

X X X X
X O O X
X X O X
X K X X

1.3 代码如下

class Solution {
    int n;
    int m;
    public void solve(char[][] board) {
        n = board.length;
        if(n<=0) return;
         m = board[0].length;
         //替换上次边界以及边界相连的O的值
        for (int i = 0; i < n; i++) {
            changeO(board, i, 0);
            changeO(board, i, m - 1);
        }
        //替换左右边界以及边界相连的值
        for (int i = 1; i < m - 1; i++) {
            changeO(board, 0, i);
            changeO(board, n - 1, i);
        }
        //比那里将所有O转换成X，将所有原先的O替换为原值
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (board[i][j] == 'K') {
                    board[i][j] = 'O';
                } else if (board[i][j] == 'O') {
                    board[i][j] = 'X';
                }
            }
        }
    }
    //遇到一个边界的O时，判断其上下左右是否有O，将所有与边界相连的O递归转换为K字符
    public  void changeO(char[][] board,int i,int j){
        if (i < 0 || i >= n || j < 0 || j >= m || board[i][j] != 'O') {
            return;
        }
        board[i][j] = 'K';
        changeO(board,i+1,j);
        changeO(board,i-1,j);
        changeO(board,i,j+1);
        changeO(board,i,j-1);
    }
}

2.图像的渲染

2.1 题目描述

给定一个表示图像的二维数组，其中的各个元素表示图像的像素值，数组在0-65535之间，给定一个位置和一个新的数值将其位置的像素替换为新的数值并将上下左右连接的与该位置相同的数值修改为新的数值。
例如：
输入：[[1,1,1],[1,1,0],[1,0,1]] sr = 1,sc = 1,newColro = 2
输出：[[2,2,2],[2,2,0],[2,0,1]]

题目传送门

2.2 题目分析

本来想将该题目放在第三个，由于这道题目与前面一道有着类似的程序结构，根据题目的输入定位到指定的修改位置，将原始值记录下来，将当前的值进行修改，从当前位置向四周进行扩散，知道到达边界停止。

2.3 代码如下

class Solution {
    public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
         floodFill(image,sr,sc,image[sr][sc],newColor);
        return image;
    }
    public  void floodFill(int[][] image, int sr, int sc,int oldColor, int newColor) {
    //边界条件，当前的元素到达上、下、左、右边界停止，当前的元素值不和旧的值相等不进行更改，如果当前的新值与旧值相同也不需要改变
        if(sr<0||sr>=image.length||sc<0||sc>=image[0].length||image[sr][sc]!=oldColor||image[sr][sc]==newColor) return;
        //替换旧元素
        image[sr][sc] = newColor;
        //上、下、左、右四个范围判断并修改元素
        floodFill(image,sr+1,sc,oldColor,newColor);
        floodFill(image,sr-1,sc,oldColor,newColor);
        floodFill(image,sr,sc+1,oldColor,newColor);
        floodFill(image,sr,sc-1,oldColor,newColor);
    }
}

3.字符串相乘

3.1 题目描述

给定两个使用字符串表示的大整数，计算两个整数的乘积，并将结果用字符串表示返回，不能使用BigInteger类型进行操作。

例如
输入 num1 = “123” num2 = “456”
输出 res = “56088”

题目传送门

3.2 题目分析

按照算数运算的方式，每一位都与另一个数字的每一位进行相乘计算，然后将乘积的结果进行累加计算。个人的计算可能比较复杂与繁琐，对于大数相乘有更简单的实现，自己没能够理解，使用了比较笨的方法。

123 * 456
123 * 6 = 738 个位的结果为原值
123 * 5 = 615 十位的结果为6150
123 * 4 = 492 百位的结果为49200
对各个乘积的结果进行累加操作
49200+6150+738 = 56088

3.3 代码如下

class Solution {
    public String multiply(String num1, String num2) {
         if(num1.equals("0")||num2.equals("0"))return "0";
         int len1= num1.length();
        int len2 = num2.length();
        String resval = "0";
        //循环计算各个位并进行累加，使用字符串记录元素的返回值
        for(int i=len2-1;i>=0;i--){
             StringBuilder res = new StringBuilder();
            char ch = num2.charAt(i);
            //将第一个数与第二个数的某一位进行乘积，
            res.append(mul(num1,ch));
            //对每个位置进行补0操作
            for (int j = 0; j < len2-1-i; j++) {
                res.append(0);
            }
            //将两个字符串进行相加的操作，获取结果
            resval = add(resval,res.toString());
        }
        return resval;
    }
    //将一个字符串与一个字符进行相乘计算
  public  String mul(String s1,char ch){
        Integer val = ch - '0';
        StringBuilder res = new StringBuilder();
        int  ml = 0;
        int carry = 0;
        for(int i=s1.length()-1;i>=0;i--){
            int temp = (s1.charAt(i)-'0')*val+carry;
            ml = temp%10;
            carry = temp/10;
            res.append(ml);
        }
        if(carry!=0) {
            res.append(carry);
        }
        return res.reverse().toString();
    }
    //将两个字符串进行相加计算
    public  String add(String num1,String num2){
        int index1 = num1.length()-1;
        int index2 = num2.length()-1;
        StringBuilder res = new StringBuilder();
        int carry = 0;
        while(index1>=0&&index2>=0){
            int temp = (num1.charAt(index1--)-'0')+(num2.charAt(index2--)-'0')+carry;
            res.append(temp%10);
            carry=temp/10;
        }
        while(index1>=0){
            int temp = (num1.charAt(index1--)-'0')+carry;
            res.append(temp%10);
            carry=temp/10;
        }
        while(index2>=0){
            int temp = (num2.charAt(index2--)-'0')+carry;
            res.append(temp%10);
            carry=temp/10;
        }
        if(carry!=0) {
            res.append(carry);
        }
        return res.reverse().toString();
    }
}