leetcode hot/91-95

461-汉明距离

两个整数之间的 汉明距离 指的是这两个数字对应二进制位不同的位置的数目。

给你两个整数 x 和 y，计算并返回它们之间的汉明距离。

示例 1：

输入：x = 1, y = 4 输出：2 解释：
1 (0 0 0 1) 4 (0 1 0 0)
             ↑          ↑
上面的箭头指出了对应二进制位不同的位置。

class Solution {
    public int hammingDistance(int x, int y) {
        //两个数异或（异或，只有不同时候才为1）
        int s = x^y,ans=0;
        while(s!=0){
            //s&(s-1)依次去掉最左边的1
            s = s &(s-1);
            ans++;
        }
        return ans;
    }
}

494-目标和

class Solution {
    int count = 0;
    public int findTargetSumWays(int[] nums, int target) {
        backTrack(nums,target,0,0);
        return count;
    }
    private void backTrack(int[] nums, int target, int index, int sum){
        if(index==nums.length){
            if (sum == target) {
                count++;
            }
        }else{
            backTrack(nums,target,index+1,sum+nums[index]);
            backTrack(nums,target,index+1,sum-nums[index]);
        }
    }
}

538-把二叉搜索树转换为累加树

给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。

提醒一下，二叉搜索树满足下列约束条件：

节点的左子树仅包含键 小于 节点键的节点。
节点的右子树仅包含键 大于 节点键的节点。
左右子树也必须是二叉搜索树。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    int sum = 0;
    //即排除当前节点左分支外其他节点的总和
    //就是中序遍历中该点以及该节点前面的数的和
    public TreeNode convertBST(TreeNode root) {
        if(root !=null){
            convertBST(root.right);
            System.out.println("right"+root.right);
            sum += root.val;
            root.val =sum;
            convertBST(root.left);
            System.out.println("left"+root.left);
        }
        return root;
    }
}

543-二叉树的直径

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    int ans;
    public int diameterOfBinaryTree(TreeNode root) {
        ans = 1;
        depth(root);
        //多计算一个根节点，因此减一
        return ans-1;
    }
    private int depth(TreeNode node){
        //递归结束条件
        if(node==null) return 0;
        int L= depth(node.left);
        int R = depth(node.right);
        // 计算d_node即L+R+1 并更新ans
        ans = Math.max(ans,L+R+1);
        return Math.max(L,R)+1;
    }
}

560. 和为K的子数组

给定一个整数数组和一个整数 k，你需要找到该数组中和为 k 的连续的子数组的个数。

示例 1 :

输入:nums = [1,1,1], k = 2
输出: 2 , [1,1] 与 [1,1] 为两种不同的情况。

注意：：上面pre[j-1] == pre[i]-k,然后去map中查找是否存在pre[j-1]，其实就是就去pre[j-1]–>即间接找pre[i]-pre[j-1]–>连续子数组[j,j]的和

更好的解析

class Solution {
    public int subarraySum(int[] nums, int k) {
        int count= 0,pre= 0;
        Map<Integer,Integer> map = new HashMap<>();
        map.put(0,1);
        for(int i = 0;i<nums.length;i++){
            //当前位置前缀和
            pre += nums[i];
            if(map.containsKey(pre-k)){
                count += map.get(pre-k);
            }
            //放入当前前缀和
            map.put(pre,map.getOrDefault(pre,0)+1);
        }
        return count;
    }
}