LeetCode笔记（二叉树的直径）

543. 二叉树的直径** - easy

返回的时路径长，不是节点数

一

1. 自己写的时候用分治法的思路，分成左右中三部分，取其中的最大值；但这样做相当于以root为根时算一次左右的深度，再以root->left和root->right为根时，再算一次其左右的深度，这样会有相当大的重复计算量，所以需要耗费很长时间（平均64 ms…）

//12.03
//12.27
class Solution {
	//需要一个helper计算并返回深度（返回左右较大的那个）
    int helper(TreeNode* root) {
        if(root == nullptr) return -1;

        return max(helper(root->left), helper(root->right))+1;
    }
public:
    int diameterOfBinaryTree(TreeNode* root) {
        if(root == nullptr) return 0;

        int left = helper(root->left);
        int right = helper(root->right);
        int sum = 0;
        
        if(left >= 0) sum += left+1;
        if(right >= 0) sum += right+1;
        return max(max(diameterOfBinaryTree(root->left), diameterOfBinaryTree(root->right)), sum);
    }
};

二

2. 用全局变量sum记录每个节点的max(diameter, sum)，这样就可以避免多次重复计算（个人感觉比起第一种做法，这种做法像动态规划，用sum来减少递归计算的次数）

//12.03
//12.27
class Solution {
    int sum = 0;
    int helper(TreeNode* root) {
        if(root == nullptr) return 0;

        int left = helper(root->left);
        int right = helper(root->right);
        sum = max(left+right+1, sum);
        return max(left, right)+1;
    }
public:
    int diameterOfBinaryTree(TreeNode* root) {
        if(root == nullptr) return 0;

        helper(root);
        return sum-1;
    }
};

70. 爬楼梯 - easy

经典动态规划

//13.42
//13.46
class Solution {
public:
    int climbStairs(int n) {
        if(n <= 1) return 1;
        if(n == 2) return 2;

        vector<int> cnt(n+1, 1);
        cnt[2] = 2;
        for(int i = 3; i <= n; i++) {
            cnt[i] = cnt[i-1]+cnt[i-2];
        }

        return cnt[n];
    }
};

1. 两数之和 - easy

可以用unordered_map来加快速度，这里我用的是map

//13.48
//13.07
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        map<int, int> num_index;
        vector<int> ans;
        for(int i = 0; i < nums.size(); i++) {
            int tmp = target-nums[i];
            auto x = num_index.find(tmp);
            if(x != num_index.end() && x->second != i) {
                ans.push_back(x->second);
                ans.push_back(i);
                return ans;
            }
            num_index[nums[i]] = i;
        }

        return ans;
    }
};

64. 最小路径和 - medium

经典动态规划

//14.46
//14.57
class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        vector<vector<int>> ans(grid.size(), vector<int>(grid[0].size(), 0));

        ans[0][0] = grid[0][0];
        for(int i = 1; i < grid[0].size(); i++) {
            ans[0][i] = ans[0][i-1]+grid[0][i];
        }
        for(int i = 1; i < grid.size(); i++) {
            ans[i][0] = ans[i-1][0]+grid[i][0];
        }
        for(int i = 1; i < grid.size(); i++) {
            for(int k = 1; k < grid[0].size(); k++) {
                ans[i][k] = min(ans[i-1][k], ans[i][k-1])+grid[i][k];
            }
        }

        return ans[ans.size()-1][ans[0].size()-1];
    }
};