LeetCode打卡--Google面试题二

Google面试题二

LeetCode 66. Plus One

class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        int t = 1;
        //这里使用的是高精度加法，模拟进位即可；类似的高精度乘法等
        for(int i = digits.size()-1; i >= 0; i--)
        {
            int &x = digits[i];
            t += x;
            x = t % 10;
            t /= 10;
        }
        //如果最后一位还有进位
        if(t)
        {
            //因为这里是0是高位，所有要挪动一位
            digits.push_back(0);
            for(int i = digits.size() - 1; i > 0; i--)digits[i] = digits[i-1];
            digits[0] = 1;
        }
        return digits;
    }
};

LeetCode 326. Power of Three

class Solution {
public:
    //这里当然也可以用循环和递归一直除3，时间复杂度差不多
    bool isPowerOfThree(int n) {
        return n > 0 && 1162261467 % n == 0;
    }
};

LeetCode 883. Projection Area of 3D Shapes

class Solution {
public:
    int projectionArea(vector<vector<int>>& grid) {
        if(grid.empty() || grid[0].empty())return 0;
        int res = 0;
        int n = grid.size(), m = grid[0].size();

        //首先转换为二进制，把非0转化为0,0转化为1，然后再取非相加
        for(int i = 0; i < n; i++)
            for(int j = 0; j < m; j++)
                res += !(!grid[i][j]);

        //取行列的最大值即可
        for(int i = 0; i < n; i++)
        {
            int h = 0;
            for(int j = 0; j < m; j++)h = max(h,grid[i][j]);
            res += h;
        }

        for(int j = 0; j < m; j++)
        {
            int h = 0;
            for(int i = 0; i < n; i++)h = max(h, grid[i][j]);
            res += h;
        }
        return res;
    }
};

LeetCode 230. Kth Smallest Element in a BST

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
// left = 左子树的个数
// 1.if k <= left, return dfs(root->left, k);
// 2.if k == left+1, return root->val;
// 3.if k > left+1, return dfs(root->right, k - left - 1);

class Solution {
public:
    int kthSmallest(TreeNode* root, int k) {
        return dfs(root, k);
    }

    int dfs(TreeNode* root, int &k)
    {
        if(!root)return 0;
        int left = dfs(root->left, k);
        if(k <= 0)return left;
        if(--k == 0)return root->val;
        return dfs(root->right, k);
    }
};

LeetCode 139. Word Break

// 这里用到了动态规划
// 用哈希表来查询

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        unordered_set<string> S;
        for(auto word : wordDict) S.insert(word);

        int n = s.size();
        vector<bool> f(n + 1, false);
        f[0] = true;

        for(int i = 1; i <= n; i++)
            for(int j = 0; j < i; j++)
            {
                if(S.count(s.substr(j, i - j)) && f[j])
                {
                    f[i] = true;
                    break;
                }
            }
        return f[n];
    }
};

LeetCode 930. Binary Subarrays With Sum

// 这里用了前缀和
// 然后把是s[i] - S转换成了f[s[i] - S]

class Solution {
public:
    int numSubarraysWithSum(vector<int>& A, int S) {
        int n = A.size();
        vector<int> sum(n+1, 0), f(n+1, 0);

        for(int i = 0; i < n; i++)sum[i+1] = sum[i] + A[i];

        f[0] = 1;

        int res = 0;

        for(int i = 1; i <= n; i++)
        {
            if(sum[i] >= S)res += f[sum[i] - S];
            f[sum[i]]++;
        }
        return res;
    }
};

LeetCode 228. Summary Ranges

class Solution {
public:

    string rangeToString(int st, int ed)
    {
        if(st == ed)return to_string(st);
        return to_string(st)+"->"+to_string(ed);
    }

    vector<string> summaryRanges(vector<int>& nums) {
        vector<string> res;
        if(nums.empty())return res;
        int st = nums[0], ed = nums[0];
        for(int i = 1; i < nums.size(); i++)
        {
            int x = nums[i];
            if(x > ed+1)
            {
                res.push_back(rangeToString(st, ed));
                st = ed = x;                
            }
            else ed++;
        }
        res.push_back(rangeToString(st, ed));
        return res;
    }
};

LeetCode 57. Insert Interval

class Solution {
public:
    vector<vector<int>> insert(vector<vector<int>>& intervals, vector<int>& newInterval) {
        vector<vector<int>> res;
        bool has_in = false;
        for(auto interval : intervals)
        {
            if(interval[0] > newInterval[1])
            {
                if(!has_in)
                {
                    res.push_back(newInterval);
                    has_in = true;            
                }
                res.push_back(interval);
            }
            else if(interval[1] < newInterval[0])
            {
                res.push_back(interval);
            }
            else
            {
                newInterval[0] = min(newInterval[0], interval[0]);
                newInterval[1] = max(newInterval[1], interval[1]);
            }
        }

        if(!has_in)res.push_back(newInterval);
        return res;
    }
};
//思路简单，但是容易错

LeetCode 224. Basic Calculator

class Solution {
public:

    void calc(stack<char> &op, stack<int> &num)
    {
        int y = num.top();
        num.pop();
        int x = num.top();
        num.pop();
        if(op.top() == '+')num.push(x+y);
        else num.push(x-y);
        op.pop();
    }

    int calculate(string s) {
        stack<char> op;
        stack<int> num;

        for(int i = 0; i < s.size(); i++)
        {
            char c = s[i];
            if(c == ' ')continue;
            if(c == '(' || c == '+' || c == '-')op.push(c);
            else if (c == ')')
            {
                op.pop();
                if(op.size() && op.top() != '(')
                {
                    calc(op, num);
                }
            }
            else
            {
                int j = i;
                while(j < s.size() && isdigit(s[j])) j++;
                num.push(atoi(s.substr(i, j - i).c_str()));
                i = j - 1;
                if(op.size() && op.top() != '(')
                {
                    calc(op, num);
                }
            }
        }

        return num.top();
    }
};
//不明觉厉

LeetCode 857. Minimum Cost to Hire K Workers

// 这个题需要绕一下
// x[i] = w[i] / q[i]
// 把所有工人按x[i]从小到大排序
// 枚举x = x[i], 此时可以满足所有0......1的工人，从中选择q最小的k个人

class Solution {
public:
    double mincostToHireWorkers(vector<int>& quality, vector<int>& wage, int K) {
        int n = quality.size();
        vector<pair<double, int> >workers;
        for(int i = 0; i < n; i++)workers.push_back({wage[i] * 1.0 / quality[i], quality[i]});
        sort(workers.begin(), workers.end());

        priority_queue<int> heap;
        double res = 1e9;
        int sum = 0;
        for(auto worker : workers)
        {
            heap.push(worker.second);
            sum += worker.second;
            if(heap.size() > K)
            {
                sum -= heap.top();
                heap.pop();
            }
            if(heap.size() == K)res = min(res, sum * worker.first);
        }
        return res;
    }
};