LeetCode-第十六个星期

求和路径

LeetCode面试题 04.12，给定一个数，求一个二叉树按照顺序迭代相加后，等于该数的个数。

思路分析：
记录每一层的数据，然后从当前层开始向上叠加，等于的话总次数就加1，然后继续从当前层向下迭代，每一次回溯后当前层的值改变，这样就可以遍历完整个链路，得到结果。

public int pathSum(TreeNode root, int sum) {
        //获得最大的层数
        int deep = depth(root);
        int[] path = new int[deep];

        count(root, sum, path, 0);
        return res;
    }

    int res = 0;

    public void count(TreeNode root, int sum, int[] path, int deep) {
        if (root == null) {
            return;
        }
        //记录每一层的当前值
        path[deep] = root.val;
        int t = 0;
        //从子节点往上叠加
        for (int i = deep; i >= 0; i--) {
            //叠加上面的层的值
            t += path[i];
            //等于的次数加1
            if (t == sum) {
                res += 1;
            }
        }
        //层数+1，判断下一层的数
        count(root.left, sum, path, deep + 1);
        count(root.right, sum, path, deep + 1);
    }

    public int depth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        //递归获得最大层数
        return Math.max(depth(root.left), depth(root.right)) + 1;
    }

比较版本号

LeetCode165题，比较两个版本号的大小。

比较两个版本号 version1 和 version2。
如果 version1 > version2 返回 1，如果 version1 < version2 返回 -1， 除此之外返回 0。

你可以假设版本字符串非空，并且只包含数字和 . 字符。

 . 字符不代表小数点，而是用于分隔数字序列。

例如，2.5 不是“两个半”，也不是“差一半到三”，而是第二版中的第五个小版本。

你可以假设版本号的每一级的默认修订版号为 0。例如，版本号 3.4 的第一级（大版本）和第二级（小版本）修订号分别为 3 和 4。其第三级和第四级修订号均为 0。
 

示例 1:

输入: version1 = "0.1", version2 = "1.1"
输出: -1
示例 2:

输入: version1 = "1.0.1", version2 = "1"
输出: 1
示例 3:

输入: version1 = "7.5.2.4", version2 = "7.5.3"
输出: -1
示例 4：

输入：version1 = "1.01", version2 = "1.001"
输出：0
解释：忽略前导零，“01” 和 “001” 表示相同的数字 “1”。
示例 5：

输入：version1 = "1.0", version2 = "1.0.0"
输出：0
解释：version1 没有第三级修订号，这意味着它的第三级修订号默认为 “0”。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/compare-version-numbers
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路分析

以每一级作为分割线进行比较，最终比较完两个版本号的大小。

  int num1 = 0, num2 = 0, len1 = version1.length(), 
     len2 = version2.length(), p1 = 0, p2 = 0;
  while (p1 < len1 || p2 < len2) {
       //以一个完整的版本号做比较
       while (p1 < len1 && version1.charAt(p1) != '.') {
           //* 10是为了换成int数字比较如 70.1.1=就是7*10+0
           num1 = num1 * 10 + Character.getNumericValue(version1.charAt(p1));
           p1++;
       }

       while (p2 < len2 && version2.charAt(p2) != '.') {
           num2 = num2 * 10 + Character.getNumericValue(version2.charAt(p2));
           p2++;
       }
       if (num1 > num2) {
           return 1;
       }
       if (num2 > num1) {
           return -1;
       }
       p1++;
       p2++;
       num1 = 0;
       num2 = 0;
   }
   return 0;

组合总和 II

LeetCode40和第一个类似，求出数组中子数组相加的值，和目标值相等的组合。

给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用一次。

说明：

所有数字（包括目标数）都是正整数。
解集不能包含重复的组合。 
示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
所求解集为:
[
  [1, 7],
  [1, 2, 5],
  [2, 6],
  [1, 1, 6]
]
示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
所求解集为:
[
  [1,2,2],
  [5]
]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/combination-sum-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路分析
递归回溯需要注意去重和剪枝

public static List<List<Integer>> combinationSum2(int[] candidates, int target) {
        List<List<Integer>> result = new ArrayList<>();
        //为了去重
        Arrays.sort(candidates);
        find(0, candidates, target, 0, result, new ArrayList<>());
        return result;
    }

    private static void find(int start, int[] candidates, int target, int sum, List<List<Integer>> result, List<Integer> temp) {
        //等于目标值后，直接将临时表加入结果
        if (sum == target) {
            result.add(new ArrayList<>(temp));
            return;
        }

        for (int i = start; i < candidates.length; i++) {
            //如果和以及大于目标值则直接跳出循环
            if (sum + candidates[i]>target) {
                break;
            }
            //这里是为了去重
            if (i > start && candidates[i] == candidates[i - 1]) {
                continue;
            }
            //将当前值加入记录中
            temp.add(candidates[i]);
            //以当前值下一个点开始迭代
            find(i + 1, candidates, target, sum + candidates[i], result, temp);
            //删除当前值的记录
            temp.remove(temp.size() - 1);
        }
    }