LintCode 解题记录17.10.21

前言

刷题的进度还是非常慢的，照这个进度，115道题估计过年前都刷不完。。真的是怠惰啊。

House Robber

题目描述

给定一个数组，要求每次不能取相邻的两个数，求能取到所有数的最大和。

思路

初读一遍，发现是最优化问题(最大化)，于是就思考最优化的两种思路 贪心和Dp。这里采用Dp的思想。我自己的思路就是采用 局部最优化与全局最优化的思想。设local[i]表示抢了第i家所能获得的最大利润，global[i]表示到第i家时所能获得的最大利润。那么递归关系如下:
local[i] = num[i] + global[i-2]; (1)
global[i] = max{local[i], global[i-1]}; (2)
写出这个递推式的思路如下：
1.针对local[i],假设我抢了第i家，那么第i-1家就不能抢，此时所能获得的最大利润就是抢劫前i-2家所能获得的最大利润加上第i家的利润，于是就得到式1
2.针对global[i]，就可以分为两种情况，抢劫第i家和没有抢劫第i家，如果抢劫了第i家，所能获得的最大利润就是local[i]，如果没有抢劫第i家，那么所能所得的最大利润就是抢劫了前i-1家所能获得的最大利润。
综合一下，得到下面的递推关系:
global[i] = max(global[i-2]+num[i], global[i-1]),我们只要初始化global[0],global[1]就好了，其中global[0] = num[0], global[1] = max(num[0], num[1]);

挑战

O(n)时间复杂度，O(1)空间复杂度。
显然上面的思路是O(n)的时间复杂度，O(n)的空间复杂度，接下来就是优化空间复杂度。于是我维护3个变量分别代表global[i],global[i-1],global[i-2]即可。然后只需要顺序遍历即可。

代码

    long long houseRobber(vector<int> &A) {        // write your code here        if (A.size() == 0) return 0;        if (A.size() == 1) return A[0];        long long res = 0, before = A[0], pre = max(A[0], A[1]);        //res = global[i], pre = global[i-1], before = global[i-2];        for (int i = 2; i < A.size(); i++) {            res = max(before + A[i], pre);            //i即将++,更新before与pre            before = pre;             pre = res;        }        return res;    }

House Robber II

题目描述

还是这个小偷，现在是这个数组首尾相连，问你最大的偷取价值。

思路

其实这题就是上一题稍微变形一下，即如果偷了第一家，那么就不能偷最后一家；如果偷了最后一家，那么就不能偷第一家，实际上这道题只需要用两次House Robber中的方法，最后返回两者中的较大值即可。

代码

    int houseRobber2(vector<int> nums) {        // write your code here        if (nums.size() == 0) return 0;        if (nums.size() == 1) return nums[0];        //houseRobber即为上一道题的方法        int a = houseRobber(vector<int>(nums.begin(), nums.end()-1));        int b = houseRobber(vector<int>(nums.begin()+1, nums.end()));        return max(a, b);    }

House RobberIII

题目描述

现在这片房子既不是用数组表示，也不是用圆圈表示，而是用了一颗二叉树来表示。不能直接抢劫两个直接相连的房子，仍然返回这个最大的利润值。

思路

树的题目自然是递归来做。此题中，对于某一节点，显然是分是否抢劫该节点两种情况来进行讨论。如果是对于两种情况分别进行递归，那恐怕会获得超时错误。因为你相当于搜索了这棵树两遍。为了避免这种情况，用一个长度为2的数组来进行存储数据，res[0]表示没有抢劫该节点，而res[1]表示抢劫了该节点。那么对于某一节点，首先递归计算其左子树得到left数组，然后递归计算右子树得到right，那么于是有
res[0] = max(left[0], left[1]) + max(right[0], right[1]) ; //没有抢劫该节点
res[1] = left[0] + right[0] + node->val; //抢劫了该节点

代码

    int houseRobber3(TreeNode * root) {        // write your code here        vector<int> res = helper(root);        return max(res[0], res[1]);    }    vector<int> helper(TreeNode *node) {        if (node == NULL) return vector<int>(2, 0);        vector<int> left = helper(node->left);        vector<int> right = helper(node->right);        vector<int> res(2, 0);        res[0] = max(left[0], left[1]) + max(right[0], right[1]);        res[1] = left[0] + right[0] + node->val;        return res;    }

Unique Binary Search Trees II

题目描述

给定一个n，产生所有不同的二叉搜索树，每一颗树都存储着1-n这n个数。

思路

递归。对于一个范围[start, end],从中任远一个作为根节点，然后把该范围划分成了左右两个数组。然后用左边的数组递归得到其左子树集合，以及同样的右子树集合。最后对于左子树集合中的每一个节点，与右子树集合中的每一个节点，拼接成一棵树，并把该数的根节点放入最终的答案中。

代码

    vector<TreeNode *> generateTrees(int n) {        // write your code here        if (n < 0) {            return vector<TreeNode*> {NULL};        }        return helper(1, n);    }    vector<TreeNode *> helper(int start, int end) {        vector<TreeNode *> res;        if (start > end) {            res.push_back(NULL);            return res;        }        for (int i = start; i <= end; i++) {            vector<TreeNode *> left = helper(start, i-1);            vector<TreeNode *> right = helper(i+1, end);            for (auto l: left) {                for (auto r: right) {                    TreeNode *root = new TreeNode(i);                    root->right = r;                    root->left = l;                    res.push_back(root);                }            }        }        return res;    }

注意

这道题可以说是非常能体现树、递归、以及二元查找树的紧密联系了。题目挺经典的。

K SumII

题目描述

给定了n个数，从中选取k个数，使他们的和为target。

思路

dfs。注意一下递归终止的条件。

代码

    vector<vector<int>> kSumII(vector<int> &A, int k, int target) {        // write your code here        vector<vector<int>> res;        vector<int> tmp;        dfs(res, tmp, A, k, target, 0);        return res;    }    void dfs(vector<vector<int>> &res, vector<int> tmp, vector<int> A, int k, int target, int idx) {        if (target <= 0 || k <= 0) {            if (target == 0 && k == 0) {                res.push_back(tmp);            }            return;        }        for (int i = idx; i < A.size(); i++) {            tmp.push_back(A[i]);            dfs(res, tmp, A, k-1, target-A[i], i+1);            tmp.pop_back();        }    }