Leetcode61-70 刷题笔记（非困难题目）

61.旋转链表

该题目我们的主要思路可以从旋转链表 -> 找到链表环的断开位置。

1.首先需要将链表成环，并且记录链表长度。
2.将旋转次数进行缩减（比如转几圈和转一圈的位置是一样的），使用于length取余的方式。
3.寻找断开点

    public ListNode rotateRight(ListNode head, int k) {
        if(head == null) {return null;}
        //将链表成环
        ListNode temp = head;
        int length = 1;
        while(temp.next != null) {
            temp = temp.next;
            length++;
        }
        temp.next = head;
        k %= length;

        //开始寻找断开地点
        temp = head;
        int target = length - k;
        for(int i=1; i<target; i++) {
            temp = temp.next;
        }

        ListNode ans = temp.next;
        temp.next = null;
        return ans;
    }

62.不同路径

该题目就是一个简单的动态规划的题目，规定只能向下向右走，那么我们只需要记录能到达改点的次数即可。

    //动态规划
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n];
        dp[0][0] = 1;
        
        for(int i=0; i<m; i++) {
            for(int j=0; j<n; j++) {
                //可以往右走
                if(j + 1 < n) {
                    dp[i][j + 1] += dp[i][j];
                }
                if(i + 1 < m) {
                    dp[i +1 ][j] += dp[i][j];
                }
            } 
        }
        
        return dp[m - 1][n - 1];
    }

63.不同路径2

62题的变种，没有区别。

    //动态规划（1位障碍物）
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        int[][] dp = new int[m][n];
        //开始位置就有障碍
        if(obstacleGrid[0][0] == 1) {
            return 0;
        }
        dp[0][0] = 1;

        for(int i=0; i<m; i++) {
            for(int j=0; j<n; j++) {
                //可以往右走
                if(j + 1 < n && obstacleGrid[i][j + 1] == 0) {
                    dp[i][j + 1] += dp[i][j];
                }
                if(i + 1 < m && obstacleGrid[i + 1][j] == 0) {
                    dp[i +1 ][j] += dp[i][j];
                }
            }
        }

        return dp[m - 1][n - 1];
    }

64.最小路径和

该题目也是经典动态规划算法，因为限定了只能向右向下运动。

此时我们需要注意我们的思维不应该是从起点出发判断向下向右那一边小走那边（贪心算法思想，寻求局部最优解），因为这样走是无法得到全局的最优解的。

所以我们的思维应该由向下向右移动 -> 向上向左移动，类似于我们已知目的地，寻求目的地的上一步的最小值（用dp数组保存），我们dp数组保存的就是能够到达改点的最小值。

    //最小路径和（动态规划）
    public int minPathSum(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;

        int[][] dp = new int[m][n];
        dp[0][0] = grid[0][0];

        for(int i=0; i<m; i++) {
            for(int j=0; j<n; j++) {
                //跳过起点
                if(i == 0 && j == 0) {continue;}
                //说明是第一列，只能向上，不能向左
                if(j - 1 < 0) {
                    dp[i][j] += dp[i - 1][j] + grid[i][j];
                    continue;
                }
                //说明是第一行，只能向左，不能向右
                if(i - 1 < 0) {
                    dp[i][j] += dp[i][j - 1] + grid[i][j];
                    continue;
                }
                //说明向上向左都可以
                dp[i][j] += Math.min(dp[i - 1][j],dp[i][j - 1]) + grid[i][j];
            }
        }

        return dp[m - 1][n - 1];
    }

66.加一

就是一个进位问题，记得处理一下

    // + 1 运算（就是一个进位的考虑）
    public int[] plusOne(int[] digits) {
        int index = digits.length - 1;
        int carry = 1;
        
        while(carry == 1 && index >= 0) {
            if(digits[index] == 9) {
                //发生进位
                digits[index--] = 0;
                //发生进位则仍需要继续处理
            }else {
                digits[index]++;
                carry = 0;
                //处理结束，退出循环即可
            }
        }
        
        if(carry == 1) {
            int[] ans = new int[digits.length + 1];
            ans[0] = 1;
            for(int i=1; i<ans.length; i++) {
                ans[i] = digits[i - 1];
            }
            
            return ans;
        }else {
            return digits;
        }
    }

二进制求和

也是一个进位问题

    //二进制相加（位数均为 1 则进位）
    public String addBinary(String a, String b) {
        int a_index = a.length() - 1;
        int b_index = b.length() - 1;
        int carry = 0;
        StringBuilder stringBuilder = new StringBuilder();
        
        while(a_index >= 0 && b_index >= 0) {
            int a_a = a.charAt(a_index) - '0';
            int b_b = b.charAt(b_index) - '0';
            int sum = a_a + b_b + carry;
            
            if(sum > 1) {
                carry = sum / 2;
                stringBuilder.append(sum % 2);
            }else {
                stringBuilder.append(sum);
                carry = 0;
            }
            a_index--;
            b_index--;
        }
        
        while(a_index >= 0) {
            int a_a = a.charAt(a_index) - '0';
            int sum = a_a + carry;

            if(sum > 1) {
                carry = sum / 2;
                stringBuilder.append(sum % 2);
            }else {
                stringBuilder.append(sum);
                carry = 0;
            }
            a_index--;
        }
        
        while(b_index >= 0) {
            int b_b = b.charAt(b_index) - '0';
            int sum = b_b + carry;
            
            if(sum > 1) {
                carry = sum / 2;
                stringBuilder.append(sum % 2);
            }else {
                stringBuilder.append(sum);
                carry = 0;
            }
            b_index--;
        }
        
        if(carry != 0) {
            stringBuilder.append('1');
        }
        
        return stringBuilder.reverse().toString();
    }

69.x的平方根

使用的是二分查找法。每当在我们二分出一个范围的时候，如果mid的二次方小于x，说明我们的mid正在不断的接近x的真正开根，但是mid * mid 又 <= x，根据这个特定我们可以记录跳出循环的mid值即为目标。

    // x 的平方根（二分查找）
    public int mySqrt(int x) {
        if(x == 0) {return 0;}

        int left = 1;
        int right = x;
        int ans = 1;
        while(left <= right) {
            //防止越界
            int mid = left + (right - left) / 2;
            if(mid * mid == x) {
                return mid;
            }else if(mid * mid < x) {
                //此时小说明 mid 在不断靠近 x
                ans = mid;
                left = mid + 1;
            }else {
                right = mid - 1;
            }
        }

        return ans;
    }

70.跳台阶

这个题也是典型的动态规划问题，当前的路径数我们只需要加上跳一步+跳两步对应台阶数的总和即可。（即状态转移方程）

    //爬楼梯
    public int climbStairs(int n) {
        if(n == 0) {return 0;}
        if(n == 1) {return 1;}
        int[] dp = new int[n];
        dp[0] = 1;
        dp[1] = 2;
        for(int i=2; i<n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }

        return dp[n - 1];
    }