剑指offer2

/和为s的两个数字:
输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。
输入：nums = [2,7,11,15], target = 9
输出：[2,7] 或者 [7,2]/

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int l = 0, r = nums.size() - 1;
        vector<int> res;
        while (l < r) {
            int cur = nums[l] + nums[r];
            if (cur == target) {
                res.push_back(nums[l]); 
                res.push_back(nums[r]); 
                break;                  
            } else if (cur > target) {
                r--;
            } else {
                l++;
            }
        }
        return res;
    }
};

/和为s的连续正数序列
输入一个正整数 target ，输出所有和为 target 的连续正整数序列（至少含有两个数）。
序列内的数字由小到大排列，不同序列按照首个数字从小到大排列。
输入：target = 9
输出：[[2,3,4],[4,5]]/

class Solution {
public:
    vector<vector<int>> findContinuousSequence(int target) {
        vector<vector<int>> res;
        vector<int> path;
        int start = 1, limit = (target+1)/2;
        int l = start, r = 0, cursum = 0;
        while (l < limit) {
            if (r < limit && cursum < target) {
                r++;
                cursum += r;
            } else if (cursum > target) {
                cursum -= l;
                l++;
            } else if (cursum == target) {
                for (int i = l; i <= r; i++) {
                    path.push_back(i);
                }
                res.push_back(path);
                path.clear();
                cursum -= l;
                l++;
            } else {
                cursum -= l;
                l++;
            }
        }
        return res;
    }
};

/*翻转单词顺序：
输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。为简单起见，标点符号和普通字母一样处理。例如输入字符串"I am a student. “，则输出"student. a am I”。
*/

class Solution {
public:
    string reverseWords(string s) {
        string res;
        int n = s.size();
        if (n == 0) {
            return res;
        }
        int r = n-1;
        while (r >= 0) {
            while (r >= 0 && s[r] == ' ') {
                r--;
            }
            if (r < 0) {
                break;
            }
            int l = r;
            while (l >= 0 && s[l] != ' ') {
                l--;
            }
            res += s.substr(l+1, r-l);
            res += ' ';
            r = l;
        }
        if (!res.empty()) {
            res.pop_back();
        }
        return res;
    }
};

/左旋转字符串:
字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。
输入: s = “abcdefg”, k = 2
输出: “cdefgab”/

class Solution {
public:
    string reverseLeftWords(string s, int n) {
        int num = s.size();
        string res;
        if (num == 0) {
            return res;
        }
        res += s.substr(n, num-n);
        res += s.substr(0, n);
        return res;
    }
};

/滑动窗口的最大值:
给定一个数组 nums 和滑动窗口的大小 k，请找出所有滑动窗口里的最大值。
思路：单调队列/

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> res;
        if (k == 0) {
            return res;
        }
        deque<int> qmax;
        int i = 0;
        for (int i = 0; i < k; i++) {
            while (!qmax.empty() && nums[i] > nums[qmax.back()]) {
                qmax.pop_back();
            }
            qmax.push_back(i);
        }
        res.push_back(nums[qmax.front()]);
        for (int i = k; i < nums.size(); i++) {
            if (!qmax.empty() && qmax.front() <= i-k) {
                qmax.pop_front();
            }
            while (!qmax.empty() && nums[i] > nums[qmax.back()]) {
                qmax.pop_back();
            }
            qmax.push_back(i);
            res.push_back(nums[qmax.front()]);
        }
        return res;
    }
};

/队列的最大值:
请定义一个队列并实现函数 max_value 得到队列里的最大值，要求函数max_value、push_back 和 pop_front 的均摊时间复杂度都是O(1)。
若队列为空，pop_front 和 max_value 需要返回 -1/

class MaxQueue {
    deque<int> qmax;
    deque<int> q;
public:
    MaxQueue() {

    }
    
    int max_value() {
        if (qmax.empty()) {
            return -1;
        }
        return qmax.front();
    }
    
    void push_back(int value) {
        q.push_back(value);
        while (!qmax.empty() && value > qmax.back()) {
            qmax.pop_back();
        }
        qmax.push_back(value);
    }
    
    int pop_front() {
        if (q.empty()) {
            return -1;
        }
        int res = q.front();
        q.pop_front();
        if (!qmax.empty() && res == qmax.front()) {
            qmax.pop_front();
        }
        return res;
    }
};