程序员进阶之算法练习(三十四)LeetCode专场

前言

LeetCode上的题目是大公司面试常见的算法题,今天的目标是拿下5道算法题:
1、2、3题都是Medium的难度,大概是头条的面试题水准;
4、5题是Hard的难度,但是可以用取巧的做法,实现难度降到Medium和Easy的难度;

正文

1、3Sum

题目链接
题目大意:给出一个数组nums,数组包括n个整数(可能有重复);
现在需要从数组中选择三个数a、b、c,使得a+b+c=0;
输出所有可能性的组合;(重复的只输出一次)

Example:
Given array nums = [-1, 0, 1, 2, -1, -4],

A solution set is:
[
  [-1, 0, 1],
  [-1, -1, 2]
]

题目解析:

题目可以分解为两个子问题:
1、找到整数a、b、c,使得a+b+c=0;
2、重复的a、b、c只输出一次;

子问题1同样可以分解为两个问题:1、找到两个整数a、b,判断c=-a-b的数字是否存在;
那么可以用两个for循环确定a、b,再用一个for循环判断c=-a-b是否存在;
复杂度较高,但是可以解决,考虑子问题2;
子问题2可以通过缓存已经存在的解,每次进行遍历匹配解决;
至此,我们有一个不太优化的解决方案。

优化思路:
a、b、c重复因为有a+b+c=0的条件,只要a、b相同,则c必然相同;
那么可以先对数组nums排序,得到有序的数组;
接着对于每个数字nums[i],从[i+1, n]区间选出两个数字x和y(x<y),使得nums[i]+x+y=0;(a=nums[i], b=x, c=y)
可以知道,随着x的增大,y会不断变小;那么从i+1开始向右选择x,从n开始向左选择y,可以在O(N)的复杂度内遍历完所有组合;
当枚举完a=nums[i]的可能后,令a=nums[k],k>i并且nums[k]!=nums[i],这样也可以在O(N)的复杂度内遍历完a的所有可能;
总的时间复杂度是O(N^2);


class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>>  ret;
        sort(nums.begin(), nums.end());
        int n = (int)nums.size();
        int i = 0;
        while (i < n) {
            int x = i + 1;
            int y = n - 1;
            while (x < y) {
                int sum = nums[i] + nums[x] + nums[y];
                if (sum == 0) {
                    vector<int> tmp = {nums[i], nums[x], nums[y]};
                    ret.push_back(tmp);
                    while (x < n) {
                        ++x;
                        if (tmp[1] != nums[x]) {
                            break;
                        }
                    }
                }
                else if (sum < 0) {
                    ++x;
                }
                else { // sum > 0
                    --y;
                }
            }
            
            while (i < n) {
                ++i;
                
                if (nums[i] != nums[i - 1]) break;
            }
        }
        
        return ret;
    }
}leetcode;

2、Generate Parentheses

题目链接
题目大意
给出一个整数n,求n对括号组成的,所有可能的合法字符串;

例如,n=3,则有:

Example:
 [
 "((()))",
 "(()())",
 "(())()",
 "()(())",
 "()()()"
 ]

题目解析:

合法的字符串指的是左右括号数量相同,并且每一个左括号,都能在其右边找到一个右括号;
类似”)(“这样就是不合法的字符串。
理解定义之后,考虑长度为2*n的字符串中第i个字符应该怎么填:
假设此刻已经具有的左括号有left个,右括号有right个;
如果left>right,比如说”(()”,则可以放左括号=>”(()(“,也可以放右括号=>”(())”
如果left==right,比如说”(())”,那么只能放左括号=>”(())”
如果left<right,此时为不合法序列,我们不应该出现这种情况;

在此过程中,需要注意保证左右括号的数量不要超过n个;


class Solution {
public:
    
    void dfs(vector<string> &ret, string &str, int left, int right) {
        if (left > 0) {
            str.push_back('(');
            dfs(ret, str, left - 1, right);
            str.pop_back();
        }
        
        if (left < right && right > 0) { // 必须保证right > left,这样的字符串才是合法的
            str.push_back(')');
            dfs(ret, str, left, right - 1);
            str.pop_back();
        }
        
        if (left == 0 && right == 0) {
            ret.push_back(str);
        }
        
        
    }
    
    vector<string> generateParenthesis(int n) {
        vector<string> ret;
        string tmp;
        dfs(ret, tmp, n, n);
        return ret;
    }
}leetcode;

3、Kth Largest Element in an Array

题目链接
题目大意

一个存放乱序整数的数组,找到数组中第k大的数字;

Example 1:

Input: [3,2,1,5,6,4] and k = 2
Output: 5
Example 2:

Input: [3,2,3,1,2,4,5,5,6] and k = 4
Output: 4

题目解析:

从样例的数据可以看出,第k大就是从小到大排序,第k个的数字;
那么一种简单的办法就是对数组进行排序,然后输出第k个数字;

还有一种做法是建一个大小为k的最大堆,然后遍历数组,把每个数字放进堆中,如果堆大小超过k,则弹出堆顶的数字;
这样一轮过后,就有一个大小为k的最大堆,堆顶就是第k大的数字;

最后是一种理论(平均)最优解法,从数组中取第一个数字x,遍历数组,按照<x和>x分成两组left和right;
如果left==k-1,那么数字x就是第k大数字;
如果left<k-1,那么从right中继续这个筛选过程;(注意right中筛选不是第k个大,要去掉left+1的数量)
如果left>k-1,那么从left中继续这个筛选过程;

这里附上最简单的实现,两行代码;

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        sort(nums.begin(), nums.end());
        return nums[nums.size() - k];
    }
};

4、Number of Digit One

题目链接
题目大意
给出一个数字n(n<1000),求出在区间[1, n]中所有数字中,1的数量。

Example:
 Given n = 13,
 Return 6, because digit 1 occurred in the following numbers: 1, 10, 11, 12, 13.
 

题目解析:

因为数字n比较小,考虑直接通过数学方式来解决。
例如数字315,可以分割成个十百三个位数上1的数量来分别统计;
个位数:315个1;
十位数:31个10;
百位数:3个100;
每个位数上可能有0、1、大于1的情况,(x+8)/10可以过滤出大于1的情况;

在特别考虑每个位数为1的情况,比如315中的十位数;
上面的统计方式还漏掉了310~315的三种情况,这种情况可以用x%i + 1来过滤出来。


class Solution {
public:
    int countDigitOne(int n) {
        int ret = 0;
        for (long long i = 1; i <= n; i *= 10) {
            ret += (n / i + 8) / 10 * i; // 对应位数上1的数量;
            if (n / i % 10 == 1) {
                ret += n % i + 1;
            }
        }
        return ret;
    }
}leetcode;

其他解法:
题目正解的做法是采用 数位dp的思想。
先预处理出1, 10, 100, 1000 … 这些数字以下的1的数量;
再从左到右遍历n的字符,求出1的数量。
这才是hard难度的解法,但是学习价值不大。

5、Find Median from Data Stream

题目链接
题目大意
实现一个数据结构,其中有两个函数:
1、addNum 添加一个数字;
2、findMedian 找到已有数字的中位数;

Example:
 addNum(1)
 addNum(2)
 findMedian() 返回 1.5
 addNum(3)
 findMedian() 返回 2
 

题目解析:

插入,可以用链表;
找中位数,可以用朴素的遍历;
这样,每次的时间复杂度O(N)。

另外一种简单的实现是:把链表分成两部分,维护一个最大堆,一个最小堆。
这样只要每次看看数字的大小,分别放到左右两个堆就行;
为了方便寻找中位数,要保证最大堆和最小堆的size大小差别不超过1;

每次操作的复杂度都是O(logN);


struct Node {
    int first, second;
    Node(){}
    Node(int f, int s) {
        first = f;
        second = s;
    }
    bool operator < (const Node tmp) const {
        if (first != tmp.first) {
            return first > tmp.first;
        }
        else {
            return second > tmp.second;
        }
    }
};


class MedianFinder {
    
public:
    priority_queue<int> little;
    priority_queue<int, vector<int>, greater<int> > big;
    /** initialize your data structure here. */
    MedianFinder() {
        
    }
    
    void addNum(int num) {
        little.push(num);
        big.push(little.top());
        little.pop();
        if (little.size() < big.size()) {
            little.push(big.top());
            big.pop();
        }
        cout << findMedian() << endl;
    }
    
    double findMedian() {
        double ret = 0.0;
        if (little.size() == big.size()) {
            ret = (little.top() + big.top()) / 2.0;
        }
        else {
            ret = little.top();
        }
        return ret;
    }
}leetcode;

其他解法:
老老实实用链表+遍历。

总结

做LeetCode的题目有一些数据结构一定要掌握,就是堆!
算法面试题无非就是问思路和实现,堆是一种高效的数据结构,解题的基础数据结构工具之一,同时具备使用非常简单的特点。
熟悉常用数据结构和具体使用场景,比如说题目2用到了栈的思想,题目3是堆的思想,题目5是链表的实现。

    原文作者:落影loyinglin
    原文地址: https://www.jianshu.com/p/452423986672
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞