徒手挖地球二八周目

徒手挖地球二八周目

NO.62 不同路径 中等

思路一：动态规划 只能向下或向右，就是无法后退或者绕路且到达终点的步数是确定的。

dp[][]数组的含义：dp[i][j]就是到到i行j列的位置有多少种走法。

初始化：dp[0][0]~dp[0][n-1]即第一列和dp[0][0]~dp[0][n-1]即第一行因为只有向下或向右移动，所以都只有1走法可以到达。

状态转移：除了第一行、第一列，dp[i][j]=dp[i-1][j]+dp[i][j-1]，还是因为只能向下或向右移动，所以dp[i][j]的一定是从其上面的[i][j-1]或左面的[i-1][j]移动而来。

public int uniquePaths(int m, int n) {
    int[][] dp=new int[m][n];
    //初始化
    for (int i = 0; i < m; i++) dp[i][0]=1;
    for (int j = 0; j < n; j++) dp[0][j]=1;
    //状态转移
    for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
            dp[i][j]=dp[i-1][j]+dp[i][j-1];
        }
    }
    return dp[m-1][n-1];
}

时间复杂度：O(m*n)

NO.63 不同路径II 中等

思路一：动态规划 这道题和上一题作为姊妹题，没什么太大变化，只是多了障碍物这个因素。

dp[][]数组的含义：和上一题一样。

初始化：dp[0][0]~dp[0][n-1]即第一列和dp[0][0]~dp[0][n-1]即第一行因为只有向下或向右移动，所以在第一个障碍物之前的位置都是1，障碍物即障碍物之后的位置都是无法到达所以是0。

状态转移：如果[i][j]是障碍物则无法到达所以是0，否则依然是dp[i][j]=dp[i-1][j]+dp[i][j-1]，还是因为只能向下或向右移动，所以dp[i][j]的一定是从其上面的[i][j-1]或左面的[i-1][j]移动而来。

public int uniquePathsWithObstacles(int[][] obstacleGrid) {
    int m = obstacleGrid.length,n=obstacleGrid[0].length;
    int[][] dp=new int[m][n];
    //初始化
    for (int i = 0; i < m; i++) {
        if (obstacleGrid[i][0]==0)dp[i][0]=1;
        else break;
    }
    for (int j = 0; j < n; j++) {
        if (obstacleGrid[0][j]==0)dp[0][j]=1;
        else break;
    }
    //状态转移
    for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
            if (obstacleGrid[i][j]==1)dp[i][j]=0;
            else dp[i][j]=dp[i-1][j]+dp[i][j-1];
        }
    }
    return dp[m-1][n-1];
}

时间复杂度：O(m*n)

NO.543 二叉树的直径 简单

思路一：深度优先遍历 这道题比较明显，立刻就能想到深度搜索，关键是怎么找到最长的。

一开始就陷入了一个误区，我觉着最大直径一定有根节点，所以根节点左子树找到最深的路径leftMax、右子树找到最深路径rightMax，最后总的最深路径就是leftMax+rightMax。很朴实的想法，但是明显是错误的。如果树是空的就错了，即使树不空但是根节点的左子树或者右子树为空也可能会出错，形如下图。

最初的这个想法浪费了不少时间，但是通过学习别人的思路发现最初的错误方法有一小部分是正确的。

虽然最大直径不一定经过根节点，但是一定经过某个节点(废话)，这个某节点的左子树最深路径和右子树最深路径之和就是最大直径。

我们要找的是路径和而不是节点和，这一点要牢记。

根据这个左右子树最大深度之和的方式，深度优先遍历将所有节点的最大直径都算出来，取最大即可。递归深搜到每个叶子节点，触底返回节点左右最深的路径+1。

int ans=0;
public int diameterOfBinaryTree(TreeNode root) {
    if (root==null)return ans;
    dfs(root);
    return ans;
}
private int dfs(TreeNode root) {
    //为空，没有路径
    if (root==null)return 0;
    //深搜
    int leftMax=dfs(root.left);
    int rightMax=dfs(root.right);
    //每个子树根的最大直径
    ans=Math.max(ans,leftMax+rightMax);
    //+1因为子树的根到父节点之间有一条边
    return Math.max(leftMax,rightMax)+1;
}

时间复杂度：O(n)

NO.1013 将数组分成和相等的三个部分 简单

思路一：双指针法 一个数组能分成和相等的三部分，则这个数组元素总sum和必定是3的倍数，如不是则否定。

双指针头尾开始同时遍历，寻找最左部分和最右部分总和等于sum/3的位置，并且寻找过程中要给中间部分留有余地(中间部分至少是一个元素)。

public boolean canThreePartsEqualSum(int[] A) {
    //元素总和必须是3的倍数
    int sum=0;
    for (int i : A) {
        sum+=i;
    }
    if (sum%3!=0)return false;
    //双指针找和等于sum/3的左右部分
    int left=0,right=A.length-1,leftSum=A[0],rightSum=A[A.length-1];
    //+1给中间部分留有"余地"
    while (left+1<right){
        if (leftSum == sum / 3 && rightSum == sum / 3) {
            return true;
        }
        if (leftSum != sum / 3) {
            leftSum+=A[++left];
        }
        if (rightSum != sum / 3) {
            rightSum+=A[--right];
        }
    }
    return false;
}

时间复杂度：O(n)

思路二：计数器法 和思路一差不多，先判断元素总和是否满足条件。

顺序遍历，count计数器记录有多少部分的和等于sum/3。

如果count>=3，则true。为什么是>=？例如[1,-1,1,-1,1,-1,1,-1]，count==4这个数组依然符合要求。

public boolean canThreePartsEqualSum(int[] A) {
    //元素总和必须是3的倍数
    int sum = 0;
    for (int i : A) {
        sum += i;
    }
    if (sum % 3 != 0) return false;
    //顺序遍历找等于sum/3的部分
    int count = 0, partialSum = 0;
    for (int i : A) {
        partialSum += i;
        if (partialSum == sum/3) {
            partialSum=0;
            count++;
        }
    }
    return count>=3;
}

时间复杂度：O(n)

---

本人菜鸟，有错误请告知，感激不尽！

更多题解和学习记录博客:博客、github