TOP 91 - 95

461. 汉明距离

我的思路

先异或一下这两个数，得到他们有哪几位不同，变成xor变量中的1，然后求1的个数，使用n &= (n - 1)的做法。

494. 目标和

我的思路

使用队列完成树，把每一种情况罗列出来，然后计算值为target的数量
时间复杂度为O(2^N)n为20 约为100w

题解思路

使用dp最高遍历次数为为19 * 1000 * 4 次数为8W

• dp[i][j],其中，i为遍历到数组第i个数，j为和为j，dp[i][j]为遍历到i行时和为j的个数
• 状态转移方程dp[i][j] = dp[i - 1][j - nums[i]] + dp[i - 1][j + nums[i]] 即当前target可由前面某一个数 再加nums[i]得到,也可由前面某一个数 - nums[i]得到
• j∈[-sum,sum] 但是j在sum时,[j - sum]也有可能出现,如上一条[j - nums[i]],所以j从[-sum]开始为了使下标不为0,所以中间值为2*max(sum) == 2000
• 还有个需要注意的地方,nums[0]为0的时候dp[0][j] 不为1为2,虽然值都为0,但是有+``-两种符号

vector > dp(nums.size(), vector(4001, 0));
int sum = accumulate(nums.begin(), nums.end(), 0);
if (nums[0] == 0) {
    dp[0][2000] = 2;
}
else {
    dp[0][2000 + nums[0]] = 1;
    dp[0][2000 - nums[0]] = 1;
}        
for (int i = 1; i < nums.size(); ++i) {
    for (int j = -sum; j < sum + 1; ++j) {
        dp[i][j + 2000] = dp[i - 1][j + 2000 - nums[i]] + dp[i - 1][j + 2000 + nums[i]];
    }
}
return dp[nums.size() - 1][target + 2000];

再优化的方法

将dp[i][j] = dp[i - 1][j - nums[i]] + dp[i - 1][j + nums[i]]优化为

dp[i][j +nums[i]] += dp[i - 1][j];
dp[i][j -nums[i]] += dp[i - 1][j];

也比较符合从上而下处理（和之前回溯的做法一样的顺序）的习惯，也通过判断dp[i - 1][j] > 0来缩减了边界,下面是优化后的代码

vector > dp(nums.size(), vector(2001, 0));
int sum = accumulate(nums.begin(), nums.end(), 0);
if (nums[0] == 0) {
    dp[0][1000] = 2;
}
else {
    dp[0][1000 + nums[0]] = 1;
    dp[0][1000 - nums[0]] = 1;
}        
for (int i = 1; i < nums.size(); ++i) {
    for (int j = -sum; j < sum + 1; ++j) {
        if (dp[i - 1][j + 1000] > 0) {
            dp[i][j + 1000 + nums[i]] += dp[i - 1][j + 1000];
            dp[i][j + 1000 - nums[i]] += dp[i - 1][j + 1000];
        }
    }
}
return dp[nums.size() - 1][target + 1000];

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

我的思路

据题解说，我的思路是反序中序遍历,使用全局变量sum存右边所有的值
我还额外开了一个void的dfs,返回什么无所谓的话,放在主函数里就可以了

if (root != nullptr) {
    convertBST(root -> right);
    sum += root -> val;
    root -> val = sum;
    convertBST(root -> left);
}
return root;

543. 二叉树的直径

我的思路【failed】

递归最大长度显然是行不通的,可以递归的有左子树或者右子树的最大深度.然后我一开始的想法是返回左右子树的最大长度,root加左右子树的最大长度和return上来的最长路径相比,这样返回值就有好几个了

题解思路

不需要返回最大路径,使用全局变量,保存最大路径就可以了.其他和我的思路一样

int ans = 0;
int diameterOfBinaryTree(TreeNode* root) {
    maxLRlen(root);
    return ans - 1;
}

int maxLRlen(TreeNode* root) {
    if (root == nullptr) {
        return 0;
    }
    int left = maxLRlen(root -> left);
    int right = maxLRlen(root -> right);
    ans = max(ans, left + right + 1);
    return max(left, right) + 1;
}

560. 和为K的子数组

题解思路1：超时

我的思路是用一个前缀和数组,从右往前减到7.其实这样这个前缀和数组就没有什么意义了
i从左往右，j从右往左.找到前缀和为sum - k的,有几个cnt在这个i下就加几

for (int i = 0; i < nums.size(); ++i) {
    int sum = 0;
    for (int j = i; j >= 0; --j) {
        sum += nums[j];
        if (sum == k) {
            cnt++;
        }
    }
}

题解思路2:使用哈希表+前缀和

使用哈希表find时间复杂度为O(n)的特点,减少时间

unordered_map m;
int pre = 0;
m[0] = 1;
int cnt = 0;
for (int i = 0; i < nums.size(); ++i) {
    pre += nums[i];
    if(m.find(pre - k) != m.end()) {
        cnt += m[pre - k];
    }
    m[pre]++;
}
return cnt;

需要注意的地方：

• 找的是pre - k是否存在
• cnt += m[pre - k]
  以[7,2,-3,1,7] k==7为例子,前缀和是7,9,6,7,14 前缀和14在第一个7和第二个7之间的数组都是和为7的数组,所以要cnt要加m[pre - k];