算法工程师<编程题>

<编程题>

1、[Maximum Product Subarray 求最大子数组乘积]

这个求最大子数组乘积问题是由最大子数组之和问题演变而来，但是却比求最大子数组之和要复杂，因为在求和的时候，遇到0，不会改变最大值，遇到负数，也只是会减小最大值而已。而在求最大子数组乘积的问题中，遇到0会使整个乘积为0，而遇到负数，则会使最大乘积变成最小乘积，正因为有负数和0的存在，使问题变得复杂了不少。比如，我们现在有一个数组[2, 3, -2, 4]，我们可以很容易的找出所有的连续子数组，[2], [3], [-2], [4], [2, 3], [3, -2], [-2, 4], [2, 3, -2], [3, -2, 4], [2, 3, -2, 4], 然后可以很轻松的算出最大的子数组乘积为6，来自子数组[2, 3].

那么我们如何写代码来实现自动找出最大子数组乘积呢，我最先想到的方比较简单粗暴，就是找出所有的子数组，然后算出每一个子数组的乘积，然后比较找出最大的一个，需要两个for循环，第一个for遍历整个数组，第二个for遍历含有当前数字的子数组，就是按以下顺序找出子数组: [2], [2, 3], [2, 3, -2], [2, 3, -2, 4],    [3], [3, -2], [3, -2, 4],    [-2], [-2, 4],    [4]。但是这么写，时间复杂度O(n²)不会达到要求，得想办法只用一次循环。其实这道题最直接的方法就是用动态规划DP来做，而且要用两个dp数组，其中f[i]表示子数组[0, i]范围内并且一定包含nums[i]数字的最大子数组乘积，g[i]表示子数组[0, i]范围内并且一定包含nums[i]数字的最小子数组乘积，初始化时f[0]和g[0]都初始化为nums[0]，其余都初始化为0。那么从数组的第二个数字开始遍历，此时的最大值和最小值只会在这三个数字之间产生，即f[i-1]*nums[i]，g[i-1]*nums[i]，和nums[i]。所以我们用三者中的最大值来更新f[i]，用最小值来更新g[i]，然后用f[i]来更新结果res即可，由于最终的结果不一定会包括nums[n-1]这个数字，所以f[n-1]不一定是最终解，不断更新的结果res才是，参见代码如下：

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        if (nums.empty()) return ;
        int res = nums[], mn = nums[], mx = nums[];
        for (int i = ; i < nums.size(); ++i) {
            int tmax = mx, tmin = mn;
            mx = max(max(nums[i], tmax * nums[i]), tmin * nums[i]);
            mn = min(min(nums[i], tmax * nums[i]), tmin * nums[i]);
            res = max(res, mx);
        }
        return res;
    }
};

下面这种方法也是用两个变量来表示当前最大值和最小值的，但是没有无脑比较三个数，而是对于当前的nums[i]值进行了正负情况的讨论：

1. 当遍历到一个正数时，此时的最大值等于之前的最大值乘以这个正数和当前正数中的较大值，此时的最小值等于之前的最小值乘以这个正数和当前正数中的较小值。

2. 当遍历到一个负数时，我们先用一个变量t保存之前的最大值mx，然后此时的最大值等于之前最小值乘以这个负数和当前负数中的较大值，此时的最小值等于之前保存的最大值t乘以这个负数和当前负数中的较小值。

3. 在每遍历完一个数时，都要更新最终的最大值。

P.S. 如果这里改成求最小值的话，就是求最小子数组乘积，并且时间复杂度是O(n)，参见代码如下：

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int res = nums[], mx = res, mn = res;
        for (int i = ; i < nums.size(); ++i) {
            if (nums[i] > ) {
                mx = max(mx * nums[i], nums[i]);
                mn = min(mn * nums[i], nums[i]);
            } else {
                int t = mx;
                mx = max(mn * nums[i], nums[i]);
                mn = min(t * nums[i], nums[i]);
            }
            res = max(res, mx);
        }
        return res;
    }
};

下面这道题使用了一个trick来将上面解法的分情况讨论合成了一种，在上面的解法中我们分析了当nums[i]为正数时，最大值和最小值的更新情况，为负数时，稍有不同的就是最小值更新时要用到之前的最大值，而不是更新后的最大值，所以我们才要用变量t来保存之前的结果。而下面这种方法的巧妙处在于先判断一个当前数字是否是负数，是的话就交换最大值和最小值。那么此时的mx就是之前的mn，所以mx的更新还是跟上面的方法是统一的，而在更新mn的时候，之前的mx已经保存到mn中了，而且并没有改变，所以可以直接拿来用。

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int res = nums[], mx = res, mn = res;
        for (int i = ; i < nums.size(); ++i) {
            if (nums[i] < ) swap(mx, mn);
            mx = max(nums[i], mx * nums[i]);
            mn = min(nums[i], mn * nums[i]);
            res = max(res, mx);
        }
        return res;
    }
};

再来看一种画风不太一样的解法，这种解法遍历了两次，一次是正向遍历，一次是反向遍历，相当于正向建立一个累加积数组，每次用出现的最大值更新结果res，然后再反响建立一个累加积数组，再用出现的最大值更新结果res，注意当遇到0的时候，prod要重置为1。至于为啥正反两次遍历就可以得到正确的结果了呢？主要还是由于负数个数的关系，因为负数可能会把最大值和最小值翻转，那么当有奇数个负数时，如果只是正向遍历的话，可能会出错，比如 [-1, -2, -3]，我们累加积会得到 -1，2，-6，看起来最大值只能为2，其实不对，而如果我们再反向来一遍，累加积为 -3，6，-6，就可以得到6了。所以当负数个数为奇数时，首次出现和末尾出现的负数就很重要，有可能会是最大积的组成数字，所以遍历两次就不会漏掉组成最大值的机会，参见代码如下：

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int res = nums[], prod = , n = nums.size();
        for (int i = ; i < n; ++i) {
            res = max(res, prod *= nums[i]);
            if (nums[i] == ) prod = ;
        }
        prod = ;
        for (int i = n - ; i >= ; --i) {
            res = max(res, prod *= nums[i]);
            if (nums[i] == ) prod = ;
        }
        return res;
    }
};

2、Maximal Square最大正方形

把数组中每一个点都当成正方形的左顶点来向右下方扫描，来寻找最大正方形。具体的扫描方法是，确定了左顶点后，再往下扫的时候，正方形的竖边长度就确定了，只需要找到横边即可，这时候我们使用直方图的原理，从其累加值能反映出上面的值是否全为1。

class Solution {
public:
    int maximalSquare(vector<vector<char> >& matrix) {
        int res = ;
        for (int i = ; i < matrix.size(); ++i) {
            vector<int> v(matrix[i].size(), );
            for (int j = i; j < matrix.size(); ++j) {
                for (int k = ; k < matrix[j].size(); ++k) {
                    if (matrix[j][k] == '') ++v[k];
                }
                res = max(res, getSquareArea(v, j - i + ));
            }
        }
        return res;
    }
    int getSquareArea(vector<int> &v, int k) {
        if (v.size() < k) return ;
        int count = ;
        for (int i = ; i < v.size(); ++i) {
            if (v[i] != k) count = ;
            else ++count;
            if (count == k) return k * k;
        }
        return ;
    }
};

下面这个方法用到了建立累计和数组的方法。原理是建立好了累加和数组后，我们开始遍历二维数组的每一个位置，对于任意一个位置(i, j)，我们从该位置往(0,0)点遍历所有的正方形，正方形的个数为min(i,j)+1，由于我们有了累加和矩阵，能快速的求出任意一个区域之和，所以我们能快速得到所有子正方形之和，比较正方形之和跟边长的平方是否相等，相等说明正方形中的数字均为1，更新res结果即可。

class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        if (matrix.empty() || matrix[].empty()) return ;
        int m = matrix.size(), n = matrix[].size(), res = ;
        vector<vector<int>> sum(m, vector<int>(n, ));
        for (int i = ; i < matrix.size(); ++i) {
            for (int j = ; j < matrix[i].size(); ++j) {
                int t = matrix[i][j] - '';
                if (i > ) t += sum[i - ][j];
                if (j > ) t += sum[i][j - ];
                if (i >  && j > ) t -= sum[i - ][j - ];
                sum[i][j] = t;
                int cnt = ;
                for (int k = min(i, j); k >= ; --k) {
                    int d = sum[i][j];
                    if (i - cnt >= ) d -= sum[i - cnt][j];
                    if (j - cnt >= ) d -= sum[i][j - cnt];
                    if (i - cnt >=  && j - cnt >= ) d += sum[i - cnt][j - cnt];
                    if (d == cnt * cnt) res = max(res, d);
                    ++cnt;
                }
            }
        }
        return res;
    }
};

还可以进一步的优化时间复杂度到O(n²)，做法是使用DP，建立一个二维dp数组，其中dp[i][j]表示到达(i, j)位置所能组成的最大正方形的边长。我们首先来考虑边界情况，也就是当i或j为0的情况，那么在首行或者首列中，必定有一个方向长度为1，那么就无法组成长度超过1的正方形，最多能组成长度为1的正方形，条件是当前位置为1。边界条件处理完了，再来看一般情况的递推公式怎么办，对于任意一点dp[i][j]，由于该点是正方形的右下角，所以该点的右边，下边，右下边都不用考虑，关心的就是左边，上边，和左上边。这三个位置的dp值suppose都应该算好的，还有就是要知道一点，只有当前(i, j)位置为1，dp[i][j]才有可能大于0，否则dp[i][j]一定为0。当(i, j)位置为1，此时要看dp[i-1][j-1], dp[i][j-1]，和dp[i-1][j]这三个位置，我们找其中最小的值，并加上1，就是dp[i][j]的当前值了，这个并不难想，毕竟不能有0存在，所以只能取交集，最后再用dp[i][j]的值来更新结果res的值即可。

class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        if (matrix.empty() || matrix[].empty()) return ;
        int m = matrix.size(), n = matrix[].size(), res = ;
        vector<vector<int>> dp(m, vector<int>(n, ));
        for (int i = ; i < m; ++i) {
            for (int j = ; j < n; ++j) {
                if (i ==  || j == ) dp[i][j] = matrix[i][j] - '';
                else if (matrix[i][j] == '') {
                    dp[i][j] = min(dp[i - ][j - ], min(dp[i][j - ], dp[i - ][j])) + ;
                }
                res = max(res, dp[i][j]);
            }
        }
        return res * res;
    }
};

下面这种解法进一步的优化了空间复杂度，此时只需要用一个一维数组就可以解决，为了处理边界情况，padding了一位，所以dp的长度是m+1，然后还需要一个变量pre来记录上一个层的dp值，我们更新的顺序是行优先，就是先往下遍历，用一个临时变量t保存当前dp值，然后看如果当前位置为1，则更新dp[i]为dp[i], dp[i-1], 和pre三者之间的最小值，再加上1，来更新结果res，如果当前位置为0，则重置当前dp值为0，因为只有一维数组，每个位置会被重复使用。

class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        if (matrix.empty() || matrix[].empty()) return ;
        int m = matrix.size(), n = matrix[].size(), res = , pre = ;
        vector<int> dp(m + , );
        for (int j = ; j < n; ++j) {
            for (int i = ; i <= m; ++i) {
                int t = dp[i];
                if (matrix[i - ][j] == '') {
                    dp[i] = min(dp[i], min(dp[i - ], pre)) + ;
                    res = max(res, dp[i]);
                } else {
                    dp[i] = ;
                }
                pre = t;
            }
        }
        return res * res;
    }
};

3、Subsets子集和

这道求子集合的问题，由于其要列出所有结果，按照以往的经验，肯定要是要用递归来做。这道题其实它的非递归解法相对来说更简单一点，下面我们先来看非递归的解法，由于题目要求子集合中数字的顺序是非降序排列的，所有我们需要预处理，先给输入数组排序，然后再进一步处理，最开始我在想的时候，是想按照子集的长度由少到多全部写出来，比如子集长度为0的就是空集，空集是任何集合的子集，满足条件，直接加入。下面长度为1的子集，直接一个循环加入所有数字，子集长度为2的话可以用两个循环，但是这种想法到后面就行不通了，因为循环的个数不能无限的增长，所以我们必须换一种思路。我们可以一位一位的往上叠加，比如对于题目中给的例子[1,2,3]来说，最开始是空集，那么我们现在要处理1，就在空集上加1，为[1]，现在我们有两个子集[]和[1]，下面我们来处理2，我们在之前的子集基础上，每个都加个2，可以分别得到[2]，[1, 2]，那么现在所有的子集合为[], [1], [2], [1, 2]，同理处理3的情况可得[3], [1, 3], [2, 3], [1, 2, 3], 再加上之前的子集就是所有的子集合了。

// Non-recursion
class Solution {
public:
    vector<vector<int> > subsets(vector<int> &S) {
        vector<vector<int> > res();
        sort(S.begin(), S.end());
        for (int i = ; i < S.size(); ++i) {
            int size = res.size();
            for (int j = ; j < size; ++j) {
                res.push_back(res[j]);
                res.back().push_back(S[i]);
            }
        }
        return res;
    }
};

整个添加的顺序为：

[]
[1]
[2]
[1 2]
[3]
[1 3]
[2 3]
[1 2 3]

下面来看递归的解法，相当于一种深度优先搜索，参见http://www.cnblogs.com/TenosDoIt/p/3451902.html，由于原集合每一个数字只有两种状态，要么存在，要么不存在，那么在构造子集时就有选择和不选择两种情况，所以可以构造一棵二叉树，左子树表示选择该层处理的节点，右子树表示不选择，最终的叶节点就是所有子集合，树的结构如下：

                        []
                   /          \
                  /            \
                 /              \
              []                []
           /       \           /    \
          /         \         /      \
       [ ]       []       []     []
      /     \     /   \     /   \    / \
  [  ] [ ] [ ] [] [ ] [] [] []

// Recursion
class Solution {
public:
    vector<vector<int> > subsets(vector<int> &S) {
        vector<vector<int> > res;
        vector<int> out;
        sort(S.begin(), S.end());
        getSubsets(S, , out, res);
        return res;
    }
    void getSubsets(vector<int> &S, int pos, vector<int> &out, vector<vector<int> > &res) {
        res.push_back(out);
        for (int i = pos; i < S.size(); ++i) {
            out.push_back(S[i]);
            getSubsets(S, i + , out, res);
            out.pop_back();
        }
    }
};

整个添加的顺序为：

[]
[1]
[1 2]
[1 2 3]
[1 3]
[2]
[2 3]
[3]

最后我们再来看一种解法，这种解法是CareerCup书上给的一种解法，想法也比较巧妙，把数组中所有的数分配一个状态，true表示这个数在子集中出现，false表示在子集中不出现，那么对于一个长度为n的数组，每个数字都有出现与不出现两种情况，所以共有2ⁿ中情况，那么我们把每种情况都转换出来就是子集了，我们还是用题目中的例子, [1 2 3]这个数组共有8个子集，每个子集用对应序号的二进制表示，把是1的位对应原数组中的数字取出来就是一个子集，八种情况都取出来就是所有的子集了。

	1	2	3	Subset
0	F	F	F	[]
1	F	F	T	3
2	F	T	F	2
3	F	T	T	23
4	T	F	F	1
5	T	F	T	13
6	T	T	F	12
7	T	T	T	123

class Solution {
public:
    vector<vector<int> > subsets(vector<int> &S) {
        vector<vector<int> > res;
        sort(S.begin(), S.end());
        int max =  << S.size();
        for (int k = ; k < max; ++k) {
            vector<int> out = convertIntToSet(S, k);
            res.push_back(out);
        }
        return res;
    }
    vector<int> convertIntToSet(vector<int> &S, int k) {
        vector<int> sub;
        int idx = ;
        for (int i = k; i > ; i >>= ) {
            if ((i & ) == ) {
                sub.push_back(S[idx]);
            }
            ++idx;
        }
        return sub;
    }
};