【LeetCode】Array

[11] Container With Most Water [Medium]

O(n^2)的暴力解法直接TLE。

正确的解法是Two Pointers。 O(n)的复杂度。保持两个指针i,j；分别指向长度数组的首尾。如果a_i 小于a_j，则移动i向后（i++）。反之，移动j向前（j--）。如果当前的area大于了所记录的area，替换之。这个想法的基础是，如果i的长度小于j，无论如何移动j，短板在i，不可能找到比当前记录的area更大的值了，只能通过移动i来找到新的可能的更大面积。

class Solution {
public:
    int maxArea(vector<int>& height) {
        int i = 0;
        int j = height.size() - 1;
        int ans = 0;
        while(i < j) {
            int area = (j - i) * min(height[i], height[j]);
            ans = max(ans, area);
            if (height[i] <= height[j]) {
                ++i;
            }
            else {
                --j;
            }
        }
        return ans;
    }
};

 

[15] 3Sum [Medium]

它要求返回结果不重复，所以去重。不能用unique，会TLE，直接在循环里面跳过。

先排序，两根指针，夹逼定理

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        if (nums.size() < 3) {
            return result;
        }
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size(); ) {
            int j = i + 1;
            int k = nums.size() - 1;
            while (j < k) {
                if (nums[i] + nums[j] + nums[k] == 0) {
                    result.push_back(vector<int>{nums[i], nums[j], nums[k]});
                    ++j, --k;
                    while (j < k && nums[j-1] == nums[j]) { ++j; }
                    while (j < k && nums[k+1] == nums[k]) { --k; }
                }
                else if (nums[i] + nums[j] + nums[k] < 0) {
                    ++j;
                    while (j < k && nums[j-1] == nums[j]) { ++j; }
                }
                else {
                    --k;
                    while (j < k && nums[k+1] == nums[k]) { --k; }
                }
            }
            ++i;
            while (nums[i-1] == nums[i]) { ++i; }
        }
        return result;
    }
};

 

[16] 3Sum Closest [Medium]

三个数求和，返回离target最近的和。

Two Pointers， 跟15题一样， 先排序，两根指针左右夹逼。

class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
        int result = 0;
        int min_gap = INT_MAX;
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size() - 2; ++i) {
            int start = i + 1, end = nums.size() - 1;
            while (start < end) {
                int temp = nums[i] + nums[start] + nums[end];
                int gap = abs(temp - target);
                if (gap < min_gap) {
                    min_gap = gap;
                    result = temp;
                }
                if (temp == target) break;
                if (temp > target) {
                    --end;
                }
                else if (temp < target) {
                    ++start;
                }
            }
        }
        return result;
    }
};

 

[17] 4Sum [Medium]

四个数求和，求出和target相等的元组， 思路和3sum一个样，包括和去重的方式都一样。

还是先排序，然后两根指针。

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        if (nums.size() < 4) {
            return result;
        }
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size()-3; ) {
            for(int j = i+1; j < nums.size()-2; ) {
                int start = j + 1, end = nums.size() - 1;
                while (start < end) {
                    int sum = nums[i] + nums[j] + nums[start] + nums[end];
                    if (sum == target) {
                        result.push_back(vector<int>{nums[i], nums[j], nums[start], nums[end]});
                        ++start, --end;
                        while (start < end && nums[start-1] == nums[start]) {
                            ++start;
                        }
                        while (start < end && nums[end+1] == nums[end]) {
                            --end;
                        }
                    }
                    else if (sum < target) {
                        ++start;
                        while (start < end && nums[start-1] == nums[start]) {
                            ++start;
                        }
                    }
                    else {
                        --end;
                        while (start < end && nums[end+1] == nums[end]) {
                            --end;
                        }
                    }
                }
                ++j;
                while (nums[j-1] == nums[j]) { ++j; }
            }
            ++i;
            while(nums[i-1] == nums[i]) { ++i; }
        }
        return result;
    }
};

 

[45] Jump Game II [Hard]

这个题需要记忆。再考肯定不会。。。要记忆。。。

给你一个数组，数组元素的值是从当前index最多能往前面移动的步数，求到数组末尾最少移动的步数。

我是参考了这个：https://www.tianmaying.com/tutorial/LC45

/*
将每个位置都看作一个点，并从第i个点向它之后的nums[i]个点都连一条长度为1的有向边，而现在的问题就是从0号点到达size-1号点需要的最短距离，这就是一个很简单的最短路问题，实际上由于边的长度均为1，而且不存在环，我们可以用宽度优先搜索（时间复杂度为O(n^2)，即边数)来进行相关的计算。

不难发现，这道题目转换出的最短路问题存在三个条件：

边的长度均为1
不存在环
连出的边是连续的
我们是不是可以用这三个“很强”的条件来做一些优化呢，答案自然是肯定的！

——如果令f[i]表示从0号点到达i号点的最短路径，那么对于任意i<j，有f[i]<=f[j]，即f是非递减的，这个结论的证明是显然的，在此不作过多赘述。

在有了这样的结论之后，我们就会发现，其实对于f数组来说，它会是一段段的存在，先是一个0，然后是一段1，然后是一段2，依此类推，那么现在问题来了，每一段的长度是多少呢？

这个问题很好回答，如果我们令l[k]表示f数组中值为k的一段的左边界，r[k]表示f数组中值为k的一段的有边界，那么有

l[k] = r[k - 1] + 1，这是显然的
r[k] = max{i + nums[i] | l[k - 1] <= i <= r[k - 1]}，由于f值为k的位置一定是从f值为k-1的位置走来的，所以只需要看从所有f值为k-1的位置里最远可以到达的地方即可。
也就是说，我们可以在对nums的一遍扫描中，依次求出所有的l[k]和r[k]，而f数组也就自然求解出来了——答案也就得到了。
*/

 

class Solution {
public:
    int jump(vector<int>& nums) {
        int k = 0, l = 0, r = 0;
        while (r < nums.size()-1) {
            int next_r = r;
            for (int i = l; i <= r; ++i) next_r = max(next_r, nums[i]+i);
            ++k; l = r + 1; r = next_r; 
        }
        return k;
    }
};

 

[48] Rotate Image [Medium]

题目要求一个方阵顺时针旋转90°。

经过研究发现顺时针旋转90°，相当于先转置，再每行逆序。要学会矩阵转置的写法。

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        const int N = matrix.size();
        //trans
        for (int i = 0; i < N; ++i) {
            for (int j = i+1; j < N; ++j) {
                swap(matrix[i][j], matrix[j][i]);
            }
        }
        
        //reverse
        for (int i = 0; i < N; ++i) {
            int start = 0, end = N - 1;
            while (start < end) {
                swap(matrix[i][start++], matrix[i][end--]);
            }
        }
    }
};

 

[54] Spiral Matrix [Medium]

打印旋转矩阵。 设置有用的四个变量 beginx, beginy, endx, endy。然后用一个i去遍历。

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector<int> ans;
        if (matrix.size() == 0) {
            return ans;
        }
        const int m = matrix.size();
        const int n = matrix[0].size();
        int beginx = 0, beginy = 0;
        int endx = n-1, endy = m - 1;
        while (true) {
            for (int i = beginx; i <= endx; ++i) {
                ans.push_back(matrix[beginy][i]);
            }
            ++beginy;
            if (beginy > endy) break;
            
            for (int i = beginy; i <= endy; ++i) {
                ans.push_back(matrix[i][endx]);
            }
            --endx;
            if (beginx > endx) break;
            
            for (int i = endx; i >= beginx; --i) {
                ans.push_back(matrix[endy][i]);
            }
            --endy;
            if (beginy > endy) break;
            
            for (int i = endy; i >= beginy; --i) {
                ans.push_back(matrix[i][beginx]);
            }
            ++beginx;
            if (beginx > endx) break;
        }        
        return ans;
    }
};

 

[56] Merge Intervals [Hard]

合并线段(数轴) 参考57题。 在 Insert Interval的基础上，一个新的interval集合，然后每次从旧的里面取一个interval出来，然后插入到新的集合中。

/**
 * Definition for an interval.
 * struct Interval {
 *     int start;
 *     int end;
 *     Interval() : start(0), end(0) {}
 *     Interval(int s, int e) : start(s), end(e) {}
 * };
 */
class Solution {
public:
    vector<Interval> merge(vector<Interval>& intervals) {
        vector<Interval> ans;
        if (intervals.size() == 0) {
            return ans;
        }
        ans.push_back(intervals[0]);
        for (int i = 1; i < intervals.size(); ++i) {
            insert_interval(ans, intervals[i]);
        }
        return ans;
    }
    vector<Interval> insert_interval(vector<Interval>& intervals, Interval newInterval) {
        vector<Interval>::iterator it = intervals.begin();
        while (it != intervals.end()) {
            if (it->start > newInterval.end) {
                break;    
            }
            else if (it->end < newInterval.start) {
                it++;
                continue;
            }
            else {
                newInterval.start = min(newInterval.start, it->start);
                newInterval.end = max(newInterval.end, it->end);
                intervals.erase(it);
            }
        }
        intervals.insert(it, newInterval);
        return intervals;
    }
};

 

[57] Insert Interval [Hard]

先判断是否能放在最前面，然后在现有的intervals中一个一个遍历。有覆盖就更新newInterval，然后把原本的那段删除。

/**
 * Definition for an interval.
 * struct Interval {
 *     int start;
 *     int end;
 *     Interval() : start(0), end(0) {}
 *     Interval(int s, int e) : start(s), end(e) {}
 * };
 */
class Solution {
public:
    vector<Interval> insert(vector<Interval>& intervals, Interval newInterval) {
        vector<Interval>::iterator it = intervals.begin();
        while (it != intervals.end()) {
            if (it->start > newInterval.end) {
                break;
            }
            else if (it->end < newInterval.start) {
                ++it;
                continue;
            }
            else {
                newInterval.start = min(it->start, newInterval.start);
                newInterval.end = max(it->end, newInterval.end);
                intervals.erase(it);
            }
        }
        intervals.insert(it, newInterval);
        return intervals;
    }
};

 

[59] Spiral Matrix II [Medium]

跟前一题Spiral Matrix的区别是前一题是遍历， 这个题是造一个矩阵出来。 思路写法都一样。

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> matrix(n, vector<int>(n, 0));
        if (n == 0) {
            return matrix;
        }
        int number = 1;
        int beginx = 0, beginy = 0, endx = n - 1, endy = n - 1;
        while (true) {
            for (int i = beginx; i <= endx; ++i) {
                matrix[beginy][i] = number++;
            }
            ++beginy;
            if (beginy > endy) { break; }
            
            for (int i = beginy; i <= endy; ++i) {
                matrix[i][endx] = number++;
            }
            --endx;
            if (beginx > endx) { break; }

            for (int i = endx; i >= beginx; --i) {
                matrix[endy][i] = number++;
            }            
            --endy;
            if (beginy > endy) { break; }
            
            for (int i = endy; i >= beginy; --i) {
                matrix[i][beginx] = number++;
            }
            ++beginx;
            if (beginx > endx) { break; }
        }
        return matrix;
    }
};

 

[73] Set Matrix Zeroes [Medium]

如果矩阵中一个元素为0， 那么把该元素所在的行和列都置零。O(1)的空间复杂度

思路：有个简单的O(m+n)的空间复杂度的，就是设两个布尔数组，来控制行和列是否为0.

但是如果要降低到O(1)的话，就可以牺牲第0行和第0列来存这两个数组。提前用两个变量保存好第0行，第0列是否置0.

class Solution {
public:
    void setZeroes(vector<vector<int>>& matrix) {
        const int m = matrix.size();
        if (m == 0) return;
        const int n = matrix[0].size();
        bool row_has_zero = false;
        bool col_has_zero = false;
        for (size_t i = 0; i < m; ++i) {
            if (matrix[i][0] == 0) {
                col_has_zero = true;
                break;
            }
        }
        for (size_t j = 0; j < n; ++j) {
            if (matrix[0][j] == 0) {
                row_has_zero = true;
                break;
            }
        }
        
        for (size_t i = 1; i < m; ++i) {
            for (size_t j = 1; j < n; ++j) {
                if (matrix[i][j] == 0) {
                    matrix[i][0] = 0;
                    matrix[0][j] = 0;
                }
            }
        }
        
        for (size_t i = 1; i < m; ++i) {
            for (size_t j = 1; j < n; ++j) {
                if (matrix[i][0] == 0 || matrix[0][j] == 0) {
                    matrix[i][j] = 0;
                }
            }
        }
        
        if (col_has_zero == true) {
            for (size_t i = 0; i < m; ++i) {
                matrix[i][0] = 0;
            }
        }
        
        if (row_has_zero == true) {
            for (size_t j = 0; j < n; ++j) {
                matrix[0][j] = 0;
            }
        }
        return;
    }
};

 

[118] Pascal's Triangle [Easy]

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> ans;
        if (numRows == 0) return ans;
        for (size_t i = 0; i < numRows; ++i) {
            vector<int> ans_row(i+1, 1);
            if (i == 0 || i == 1) {
                ans.push_back(ans_row);
                continue;
            }
            for (size_t j = 1; j < i ; ++j) {
                ans_row[j] = ans[i-1][j-1] + ans[i-1][j];
            }
            ans.push_back(ans_row);
        }
        return ans;
    }
};

 

[119] Pascal's Triangle II [Easy]

只要求O(k)的额外空间。我自己写的解法用了两个数组，其实一个就够了。

class Solution {
public:
    vector<int> getRow(int rowIndex) {
       vector<int> ans(rowIndex+1, 1);
       vector<int> help(rowIndex+1, 0);
       if (rowIndex == 0 || rowIndex == 1) {
           return ans;
       }
       for (size_t i = 2; i < rowIndex+1; ++i) {
           help = ans;
           for (size_t j = 1; j < i; ++j) {
                ans[j] = help[j-1] + help[j];       
           }
           ans[i] = 1;
       }
       return ans;
    }
};

一个数组的还没看懂（好困，睡了==）

class Solution {
public:
    vector<int> getRow(int rowIndex) {
        vector<int> A(rowIndex+1, 0);
        A[0] = 1;
        for(int i=1; i<rowIndex+1; i++)
            for(int j=i; j>=1; j--)
                A[j] += A[j-1];
        return A;
    }
};