leetcode随记备忘（12）

二进制求和

这道题思路和10进制求和差不多，先共同计算，然后再单独计算，并用一个carry表示进位。但是有所不同的是二进制的数的表示是下标大的在低位，所以下标控制上要注意。（其实完全可以把给定的两个字符串先reverse再操作，我蠢了）。最后结果也要reverse。代码如下：

class Solution {
public:
    string addBinary(string a, string b) {
        string res;
        int carry = 0;
        int l = min(a.size(), b.size());
        for(int i = 1; i <= l; i++){
            int num = (a[a.size() - i] - '0') + (b[b.size() - i] - '0') + carry;
            if(num == 3){
                carry = 1;
                res += '1';
            }
            else if(num == 2){
                carry = 1;
                res += '0';
            }
            else if(num == 1){
                carry = 0;
                res += '1';
            }
            else if(num == 0){
                carry = 0;
                res += '0';
            }
        }
        if(a.size() > l){
            for(int i = a.size() - l - 1; i >= 0; i--){
                int num = a[i] - '0' + carry;
                if(num == 2){
                    carry = 1;
                    res += '0';
                }
                else if(num == 1){
                    carry = 0;
                    res += '1';
                }
                else if(num == 0){
                    carry = 0;
                    res += '0';
                }
            }
        }
        else if(b.size() > l){
            for(int i = b.size() - l - 1; i >= 0; i--){
                int num = b[i] - '0' + carry;
                if(num == 2){
                    carry = 1;
                    res += '0';
                }
                else if(num == 1){
                    carry = 0;
                    res += '1';
                }
                else if(num == 0){
                    carry = 0;
                    res += '0';
                }
            }
        }
        if(carry == 1)
            res += '1';
        reverse(res.begin(), res.end());
        return res;
    }
};

括号

典型的DFS，用两个数分别表示左右括号还剩余的数量，如果左剩的多就返回。然后将左右都剩余0的情况写入结果。代码如下：

class Solution {
public:
    vector<string> res;
    vector<string> generateParenthesis(int n) {
        if(n <= 0)
            return res;
        string s = "";
        helper(s, n, n);
        return res;
    }
    void helper(string & s, int left, int right){
        if(left > right || left < 0 || right < 0)
            return;
        if(left == 0 && right == 0){
            res.push_back(s);
            return;
        }
        string ss = s + '(';
        string sb = s + ')';
        helper(ss, left-1, right);
        helper(sb, left, right-1);
        return;
    }
};

迷路的机器人

经典的DFS+回溯，对于每个节点，向下或者右边扩展。如果两边都无法扩展，将往此节点走的路径pop出去。这里有一个trick可以省去visited数组，即可以直接将这种无法扩展的节点置为1.代码如下：

class Solution {
public:
    bool dfs(vector<vector<int>>& g, int x, int y, vector<vector<int>>& path) {
        int m = g.size();
        int n = g[0].size();

        if (g[x][y] == 1) return false;

        if (x ==  m - 1 && y == n - 1) {
            path.push_back({x, y});
            return true;
        }

        path.push_back({x, y});
        if (x + 1 < m && dfs(g, x + 1, y, path)) {
            return true;
        }
        if (y + 1 < n && dfs(g, x, y + 1, path)) {
            return true;
        }

        path.pop_back();
        g[x][y] = 1; //不可达
        return false;
    }

    vector<vector<int>> pathWithObstacles(vector<vector<int>>& obstacleGrid) {
        vector<vector<int>> path;
        dfs(obstacleGrid, 0, 0, path);
        return path;
    }
};

求和路径

这道题的思路是首先求出树高，然后建立一个大小等于树高的数组来记录路径，然后preorder这棵树，并用当前节点的值赋给此层的路径，再计算path数组的和。如果恰好等于target就记录下来。代码如下：

class Solution {
public:
    int res = 0;
    int pathSum(TreeNode* root, int sum) {
        int high = get_high(root);
        vector<int> path(high);
        get_sum(root, path, 0, sum);
        return res;
    }

    int get_high(TreeNode* root){
        if(!root) return 0;
        return max(get_high(root->left), get_high(root->right)) + 1;
    }

    void get_sum(TreeNode* root, vector<int>& path, int level, int sum){
        if(!root) return;
        path[level] = root->val;
        int s = 0;
        for(int i = level; i >= 0; i--){
            s += path[i];
            if(s == sum)
                res++;
        }
        get_sum(root->left, path, level+1, sum);
        get_sum(root->right, path, level+1, sum);
    }
};