Leetcode 模拟面试Ⅰ 记录

这周开始间接做一做模拟面试题，一个半小时随机三道题。

第一次很开心，运气好一个小时就搞出来了：

1.旋转字符串（简单）

题目链接：https://leetcode-cn.com/problems/rotate-string/

由于tag是简单，给的长度又都是100之内，当然开开心心的 O(n^2)暴力啦！

代码如下：

class Solution {
public:
    bool rotateString(string A, string B) {
        if(A.size() != B.size()) {
            return false;
        }
        int len = A.size();
        if(len == 0) {
            return true;
        }
        string s = A;
        s += s;	// 复制一遍，这样不用再倒回来，其实用 i % len 也可以
        for(int i = 0; i < len; i++) {
            int j = 0;
            for(j = 0; j < len; j++) {
                if(s[i + j] != B[j]) {
                    break;
                }
            }
            if(j == len) {
                return true;
            }
        }
        return false;
    }
};

2.Pow(x, n)（中等）

题目链接：https://leetcode-cn.com/problems/powx-n/

这道题前几天刚做过，其实就是快速幂的浮点数形式，模版没什么变化，多了一个指数可能为负的情况，就按照正的计算，最后取倒数就行了。

需要注意的是输入的 n 的范围，简单方法是把输入改成long型的就可以了。

代码如下：

class Solution {
public:
    double myPow(double x, long n) {
        double res = 1;
        double base = x;
        bool l = false;
        if(n < 0) {
            n = -1 * n;
            l = true;	// 记录是否为负指数
        }
        while(n) {
            if(n & 1) {
                res *= base;
            }
            base = base * base;
            n >>= 1;
            //cout << "res = " << res << ", base = " << base << endl;
        }
        if(l) {
            return 1 / res;
        }
        return res;
    }
};

3.下一个更大元素 II（中等）

题目链接：https://leetcode-cn.com/problems/next-greater-element-ii/

很开心能把这道题搞出来，思路就是维护一个栈，每次输入时看栈顶元素是否小于当前元素，如果是的话就弹出并记录结果，因为栈顶元素永远是比当前元素最近输入的，所以一旦当前元素大于栈顶元素，该栈顶元素的下一个更大的数就一定是当前元素。

我的代码：

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        stack<pair<int, int>> s;	//一个记录元素值，一个记录下标
        int len = nums.size();
        for(int i = 0; i < len; i++) {
            nums.push_back(nums[i]);
        }
        vector<int> res(len, -1);
        vector<bool> vis(nums.size(), 0);	//记录当前元素是否处理

        for(int i = 0; i < nums.size(); i++) {
            if(vis[i % len]) {
                if(s.empty()) {
                    continue;
                } else {
                    pair<int,int> pos = s.top();
                    while(pos.first < nums[i] && !s.empty()) {
                        res[pos.second % len] = nums[i];
                        vis[pos.second % len] = true;
                        s.pop();
                        if(s.empty()) {
                            break;
                        }
                        pos = s.top();
                    }
                }
                continue;
            }
            if(s.empty()) {
                s.push({nums[i], i});
            } else {
                pair<int,int> pos = s.top();
                printf("first: %d, second: %d\n", pos.first, pos.second);
                if(pos.first >= nums[i]) {
                    s.push({nums[i], i});
                } else {
                    while(pos.first < nums[i] && !s.empty()) {
                        res[pos.second % len] = nums[i];
                        vis[pos.second % len] = true;
                        s.pop();
                        if(s.empty()) {
                            break;
                        }
                        pos = s.top();
                    }
                    s.push({nums[i], i});
                }
                
            }
        }

        return res;
    }
};

调试了很长时间才搞定，大概思路是：
（1）栈记录元素值及其索引
（2）栈为空且当前元素未处理时压栈，若栈顶元素小于当前元素则弹出，记录到res数组中并记录当前元素状态为处理过（vis[i] = true）
（3）把数组复制一遍，遍历一次即完成

然后看了官方题解，思路跟我类似，但是做了很多简化：
（1）栈只记录索引，比较时直接在数组中O(1)读取：节省一半空间
（2）不设置状态数组vis，且不用复制数组，从后往前遍历，只要栈顶元素小于当前元素就一直弹出。

简化之后的代码：

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        vector<int> res(nums.size(), 0);
        stack<int> s;
        for(int i = 2 * nums.size() - 1; i >= 0; i--) {
            while(!s.empty() && nums[s.top()] <= nums[i % nums.size()]) {
                s.pop();
            }
            res[i % nums.size()] = s.empty() ? -1 : nums[s.top()];
            s.push(i % nums.size());
        }
        return res;
    }
};