剑指offer汇总

二维数组中的查找
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    bool Find(int target, vector<vector<int>> array) {
        int m = array.size(), n = array[0].size();
        int row = 0, col = n - 1;
        while (row <= m - 1 && col >= 0) {
            if (array[row][col] == target) {
                return true;
            } else if (array[row][col] < target) {
                row++;
            } else {
                col--;
            }
        }
        return false;
    }
};

从尾到头打印链表
输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

#include <bits/stdc++.h>
using namespace std;
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
  public:
    vector<int> printListFromTailToHead(ListNode *head) {
        vector<int> res;
        auto cur = head;
        while (cur) {
            res.push_back(cur->val);
            cur = cur->next;
        }
        reverse(res.begin(), res.end());
        return res;
    }
};

重建二叉树
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

#include <bits/stdc++.h>
using namespace std;
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution {
  public:
    TreeNode *reConstructBinaryTree(vector<int> pre, vector<int> vin) {
        return helper(pre, vin, 0, 0, pre.size());
    }
    TreeNode *helper(vector<int> &pre, vector<int> &vin, int preStart,
                     int inStart, int length) {
        if (length == 0) {
            return NULL;
        }
        TreeNode *root = new TreeNode(pre[preStart]);
        if (length == 1) {
            return root;
        }
        int pos = find(vin.begin() + inStart, vin.begin() + inStart + length,
                       pre[preStart]) -
                  vin.begin();
        root->left = helper(pre, vin, preStart + 1, inStart, pos - inStart);
        root->right = helper(pre, vin, preStart + (pos - inStart) + 1, pos + 1,
                             (length - 1 - (pos - inStart)));
        return root;
    }
};

用两个栈实现队列
用两个栈来实现一个队列，完成队列的Push和Pop操作。队列中的元素为int类型。

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    void push(int node) { stack1.push(node); }

    int pop() {
        if (stack2.empty()) {
            while (!stack1.empty()) {
                stack2.push(stack1.top());
                stack1.pop();
            }
        }
        auto res = stack2.top();
        stack2.pop();
        return res;
    }

  private:
    stack<int> stack1;
    stack<int> stack2;
};

旋转数组的最小数字
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

#include <bits/stdc++.h>
using namespace std;
// lc153 154题
// 有重复元素的写法
class Solution {
  public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        int m = rotateArray.size(), left = 0, right = m - 1;
        while (left < right) {
            int mid = (left + right) / 2;
            if (rotateArray[mid] < rotateArray[right]) {
                right = mid;
            } else if (rotateArray[mid] > rotateArray[right]) {
                left = mid + 1;
            } else {
                right--;
            }
        }
        return rotateArray[left];
    }
};
// 这是没有重复元素的做法
class Solution_1 {
  public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        int left = 0, right = rotateArray.size() - 1;
        while (left < right) {
            int mid = (left + right) / 2;
            if (rotateArray[mid] < rotateArray[right]) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        return rotateArray[left];
    }
};

变态跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    int jumpFloorII(int number) { return 1 << (--number); }
};

矩形覆盖
我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

class Solution {
  public:
    int rectCover(int number) {
        if (number == 0 || number == 1) {
            return number;
        }
        int prev = 1, cur = 1;
        for (int i = 2; i <= number; i++) {
            int temp = cur;
            cur = cur + prev;
            prev = temp;
        }
        return cur;
    }
};

二进制中1的个数
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

class Solution {
  public:
    int NumberOf1(int n) {
        int res = 0;
        while (n) {
            n = n & (n - 1);
            res++;
        }
        return res;
    }
};

数值的整数次方
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

class Solution {
  public:
    double Power(double base, int exponent) {
        double result = 1.0;
        if (base == 0 && exponent < 0) {
            return 0;
        }
        for (int i = 0; i < abs(exponent); i++) {
            result *= base;
        }
        if (exponent < 0) {
            result = 1 / result;
        }
        return result;
    }
};

调整数组顺序使奇数位于偶数前面
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    void reOrderArray(vector<int> &array) {
        stable_partition(array.begin(), array.end(),
                         [](int a) { return (a & 1) == 1; });
    }
};

链表中倒数第k个结点
输入一个链表，输出该链表中倒数第k个结点。

#include <bits/stdc++.h>
using namespace std;
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};
class Solution {
  public:
    ListNode *FindKthToTail(ListNode *pListHead, unsigned int k) {
        if (pListHead == NULL || k == 0) {
            return nullptr;
        }
        int n = k;
        auto faster = pListHead, walker = pListHead;
        while (faster && n--) {
            faster = faster->next;
        }
        if (faster == NULL && n != 0) {
            return NULL;
        }
        while (faster) {
            walker = walker->next;
            faster = faster->next;
        }
        return walker;
    }
};

反转链表
输入一个链表，反转链表后，输出新链表的表头。

#include <bits/stdc++.h>
using namespace std;

struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution_0 {
  public:
    ListNode *ReverseList(ListNode *pHead) {
        if (pHead == NULL || pHead->next == NULL) {
            return pHead;
        }
        ListNode *pre = NULL, *cur = pHead;
        while (cur) {
            auto temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};

class Solution {
  public:
    ListNode *ReverseList(ListNode *pHead) {
        if (pHead == NULL || pHead->next == NULL) {
            return pHead;
        }
        auto next = pHead->next;
        auto p = ReverseList(next);
        next->next = pHead;
        pHead->next = NULL;
        return p;
    }
};

合并两个排序的链表
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

#include <bits/stdc++.h>
using namespace std;
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};
class Solution {
  public:
    ListNode *Merge(ListNode *pHead1, ListNode *pHead2) {
        ListNode *result = new ListNode(0);
        auto current = result;
        while (pHead1 && pHead2) {
            if (pHead1->val < pHead2->val) {
                current->next = pHead1;
                pHead1 = pHead1->next;
            } else {
                current->next = pHead2;
                pHead2 = pHead2->next;
            }
            current = current->next;
        }
        current->next = pHead1 ? pHead1 : pHead2;
        return result->next;
    }
};

树的子结构
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

#include <bits/stdc++.h>
using namespace std;
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

// lc572题
class Solution_0 {
  public:
    bool isSubtree(TreeNode *s, TreeNode *t) {
        if (isSameTree(s, t)) {
            return true;
        }
        if (s != NULL && ((isSubtree(s->left, t)) || isSubtree(s->right, t))) {
            return true;
        }
        return false;
    }
    bool isSameTree(TreeNode *t1, TreeNode *t2) {
        if (t1 != NULL && t2 != NULL && t1->val == t2->val) {
            return isSameTree(t1->left, t2->left) &&
                   isSameTree(t1->right, t2->right);
        }
        return t1 == NULL && t2 == NULL;
    }
};

二叉树的镜像
操作给定的二叉树，将其变换为源二叉树的镜像。

#include <bits/stdc++.h>
using namespace std;
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution {
  public:
    void Mirror(TreeNode *pRoot) {
        if (pRoot) {
            Mirror(pRoot->left);
            Mirror(pRoot->right);
            swap(pRoot->left, pRoot->right);
        }
    }
};

顺时针打印矩阵
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

#include <bits/stdc++.h>
using namespace std;

class Solution {
  public:
    vector<int> printMatrix(vector<vector<int>> &matrix) {
        vector<int> res;
        vector<vector<int>> dirs{{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
        vector<int> steps = {(int)matrix[0].size(), (int)matrix.size() - 1};
        int idir = 0;
        int h = 0, v = -1;
        while (steps[idir % 2]) {
            for (int i = 0; i < steps[idir % 2]; i++) {
                h += dirs[idir][0];
                v += dirs[idir][1];
                res.push_back(matrix[h][v]);
            }
            steps[idir % 2]--;
            idir = (idir + 1) % 4;
        }
        return res;
    }
};

包含min函数的栈
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数(时间复杂度应为O(1))。

#include <bits/stdc++.h>
using namespace std;

class Solution {
  public:
    void push(int value) {
        if (value <= minNum) {
            stk.push(minNum);
            minNum = value;
        }
        stk.push(value);
    }
    void pop() {
        if (stk.top() == minNum) {
            stk.pop();
            minNum = stk.top();
        }
        stk.pop();
    }
    int top() { return stk.top(); }
    int min() { return minNum; }

  private:
    stack<int> stk;
    int minNum = INT_MAX;
};

栈的压入、弹出序列
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。(注意：这两个序列的长度是相等的)

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    bool IsPopOrder(vector<int> pushV, vector<int> popV) {
        stack<int> stk;
        int j = 0;
        for (int i = 0; i < pushV.size(); i++) {
            stk.push(pushV[i]);
            while (!stk.empty() && stk.top() == popV[j]) {
                stk.pop();
                j++;
            }
        }
        return j == popV.size();
    }
};

从上往下打印二叉树
从上往下打印出二叉树的每个节点，同层节点从左至右打印。

#include <bits/stdc++.h>
using namespace std;
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution {
  public:
    vector<int> PrintFromTopToBottom(TreeNode *root) {
        queue<TreeNode *> q;
        vector<int> res;
        if (root != NULL) {
            q.push(root);
        }
        while (!q.empty()) {
            int m = q.size();
            for (int i = 0; i < m; i++) {
                auto it = q.front();
                res.push_back(it->val);
                q.pop();
                if (it->left) {
                    q.push(it->left);
                }
                if (it->right) {
                    q.push(it->right);
                }
            }
        }
        return res;
    }
};

二叉搜索树的后序遍历序列
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        if (sequence.empty()) {
            return false;
        }
        return helper(sequence, 0, sequence.size() - 1);
    }
    bool helper(vector<int> &sequence, int left, int right) {
        if (left >= right) {
            return true;
        }
        int i = right - 1;
        while (i >= left && sequence[i] > sequence[right]) {
            i--;
        }
        for (int j = i; j >= left; j--) {
            if (sequence[j] > sequence[right]) {
                return false;
            }
        }
        return helper(sequence, left, i) && helper(sequence, i + 1, right - 1);
    }
};

二叉树中和为某一值的路径
输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)

#include <bits/stdc++.h>
using namespace std;
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution {
  public:
    vector<vector<int>> FindPath(TreeNode *root, int expectNumber) {
        vector<vector<int>> res;
        vector<int> path;
        helper(root, expectNumber, 0, res, path);
        return res;
    }
    void helper(TreeNode *root, int expectNumber, int current,
                vector<vector<int>> &res, vector<int> &path) {
        if (root) {
            current += root->val;
            path.push_back(root->val);
            if (root->left == nullptr && root->right == nullptr &&
                current == expectNumber) {
                res.push_back(path);
            }
            helper(root->left, expectNumber, current, res, path);
            helper(root->right, expectNumber, current, res, path);
            path.pop_back();
        }
    }
};

复制链表的复制
输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

#include <bits/stdc++.h>
using namespace std;
struct RandomListNode {
    int label;
    RandomListNode *next, *random;
    RandomListNode(int x) : label(x), next(NULL), random(NULL) {}
};
// lc138题
class Solution_1 {
  public:
    RandomListNode *copyRandomList(RandomListNode *head) {
        unordered_map<RandomListNode *, RandomListNode *> dir;
        RandomListNode *current = head;
        while (current) {
            dir[current] = new RandomListNode(current->label);
            current = current->next;
        }
        current = head;
        while (current) {
            dir[current]->next = current->next ? dir[current->next] : NULL;
            dir[current]->random =
                current->random ? dir[current->random] : NULL;
            current = current->next;
        }
        return dir[head];
    }
};

class Solution_2 {
  public:
    RandomListNode *copyRandomList(RandomListNode *head) { return clone(head); }
    RandomListNode *clone(RandomListNode *head) {
        if (head == NULL) {
            return head;
        }
        if (dir.count(head)) {
            return dir[head];
        }
        RandomListNode *root = new RandomListNode(head->label);
        dir[head] = root;
        root->next = clone(head->next);
        root->random = clone(head->random);
        return root;
    }

  private:
    unordered_map<RandomListNode *, RandomListNode *> dir;
};

二叉搜索树与双向链表
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

#include <bits/stdc++.h>
using namespace std;
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution {
  public:
    TreeNode *Convert(TreeNode *root) {
        if (root == nullptr) {
            return nullptr;
        }
        TreeNode *current = nullptr;
        helper(root, current);
        while (current->left) {
            current = current->left;
        }
        return current;
    }
    void helper(TreeNode *root, TreeNode *&pre) {
        if (root == nullptr) {
            return;
        }
        helper(root->left, pre);
        root->left = pre;
        if (pre) {
            pre->right = root;
        }
        pre = root;
        helper(root->right, pre);
    }
};

字符串的排列
输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

class Solution {
public:
    vector<string> Permutation(string str) {
        if (str == "") {
            return {};
        }
        vector<string> res;
        do {
            res.push_back(str);
        } while (next_permutation(str.begin(), str.end()));
        return res;
    }
};

数组中出现次数超过一半的数字
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        int counter = 0, m = numbers.size();
        int target = 0;
        for (int i = 0; i < m; i++) {
            if (counter == 0) {
                target = numbers[i];
            }
            if (target == numbers[i]) {
                counter++;
            } else {
                counter--;
            }
        }
        return count(numbers.begin(), numbers.end(), target) > m / 2 ? target
                                                                     : 0;
    }
};

最小的K个数
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        int m = input.size();
        if (k <= 0 || k > m) {
            return {};
        }
        priority_queue<int, vector<int>, less<int>> q;
        for (int i = 0; i < m; i++) {
            if (q.size() < k) {
                q.push(input[i]);
            } else if (q.top() > input[i]) {
                q.pop();
                q.push(input[i]);
            }
        }
        vector<int> res;
        while (!q.empty()) {
            res.push_back(q.top());
            q.pop();
        }
        return res;
    }
};

连续子数组的最大和
HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    int FindGreatestSumOfSubArray(vector<int> array) {
        int sum = 0, max_sum = INT_MIN;
        int m = array.size();
        for (int i = 0; i < m; i++) {
            sum = max(sum + array[i], array[i]);
            max_sum = max(max_sum, sum);
        }
        return max_sum;
    }
};

整数中1出现的次数
求出1-13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？为此他特别数了一下1-13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。

// lc233题
// https://leetcode.com/problems/number-of-digit-one/discuss/64381/4-lines-olog-n-cjavapython
class Solution {
  public:
    int NumberOf1Between1AndN_Solution(int n) {
        if (n <= 0) {
            return 0;
        }
        int res = 0;
        for (long long m = 1; m <= n; m *= 10) {
            int a = n / m, b = n % m;
            res += (a + 8) / 10 * m + (a % 10 == 1) * (b + 1);
        }
        return res;
    }
};

把数组排成最小的数
输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    string PrintMinNumber(vector<int> numbers) {
        sort(numbers.begin(), numbers.end(), [](int a, int b) {
            string str_a = to_string(a), str_b = to_string(b);
            return str_a + str_b < str_b + str_a;
        });
        string res;
        int m = numbers.size();
        for (int i = 0; i < m; i++) {
            res += to_string(numbers[i]);
        }
        return res;
    }
};

丑数
把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    int GetUglyNumber_Solution(int index) {
        if (index <= 0) {
            return 0;
        }
        vector<int> nums(index, 0);
        nums[0] = 1;
        int one = 0, two = 0, three = 0;
        for (int i = 1; i < index; i++) {
            nums[i] = min(nums[one] * 2, min(nums[two] * 3, nums[three] * 5));
            if (nums[one] * 2 == nums[i]) {
                one++;
            }
            if (nums[two] * 3 == nums[i]) {
                two++;
            }
            if (nums[three] * 5 == nums[i]) {
                three++;
            }
        }
        return nums[index - 1];
    }
};

第一个只出现一次的字符位置
在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    int FirstNotRepeatingChar(string str) {
        unordered_map<char, int> dir;
        int m = str.size();
        for (int i = 0; i < m; i++) {
            dir[str[i]]++;
        }
        for (int i = 0; i < m; i++) {
            if (dir[str[i]] == 1) {
                return i;
            }
        }
        return -1;
    }
};

数组中的逆序对
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。即输出P%1000000007

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    int InversePairs(vector<int> data) {
        int m = data.size();
        vector<int> copy(m, 0);
        return merge_pair(data, copy, 0, m - 1);
    }
    long merge_pair(vector<int> &data, vector<int> &copy, int left, int right) {
        if (left < right) {
            int mid = (left + right) / 2;
            long left_result = merge_pair(data, copy, left, mid);
            long right_result = merge_pair(data, copy, mid + 1, right);
            long other = merge_two_arr(data, copy, left, mid, right);
            return (left_result + right_result + other) % 1000000007;
        }
        return 0;
    }
    long merge_two_arr(vector<int> &data, vector<int> &copy, int left, int mid,
                       int right) {
        long result = 0;
        int i = mid, j = right, k = right;
        while (i >= left && j > mid) {
            if (data[i] > data[j]) {
                copy[k--] = data[i--];
                result += j - mid;
            } else {
                copy[k--] = data[j--];
            }
        }
        while (i >= left) {
            copy[k--] = data[i--];
        }
        while (j > mid) {
            copy[k--] = data[j--];
        }
        for (int i = left; i <= right; i++) {
            data[i] = copy[i];
        }
        return result;
    }
};

两个链表的第一个公共结点
输入两个链表，找出它们的第一个公共结点。

#include <bits/stdc++.h>
using namespace std;
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};
class Solution {
  public:
    ListNode *FindFirstCommonNode(ListNode *pHead1, ListNode *pHead2) {
        int m = 0, n = 0;
        auto current1 = pHead1, current2 = pHead2;
        while (current1) {
            current1 = current1->next;
            m++;
        }
        while (current2) {
            current2 = current2->next;
            n++;
        }
        if (m < n) {
            swap(pHead1, pHead2);
        }
        int diff = abs(m - n);
        current1 = pHead1, current2 = pHead2;
        while (diff--) {
            current1 = current1->next;
        }
        while (current1 != current2) {
            current1 = current1->next;
            current2 = current2->next;
        }
        return current1;
    }
};

数字在排序数组中出现的次数
统计一个数字在排序数组中出现的次数。

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    int GetNumberOfK(vector<int> data, int k) {
        auto it1 = lower_bound(data.begin(), data.end(), k);
        auto it2 = upper_bound(data.begin(), data.end(), k);
        return it2 - it1;
    }
};

二叉树的深度
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

#include <bits/stdc++.h>
using namespace std;
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution {
  public:
    int TreeDepth(TreeNode *pRoot) {
        if (pRoot == nullptr) {
            return 0;
        }
        return 1 + max(TreeDepth(pRoot->left), TreeDepth(pRoot->right));
    }
};

平衡二叉树
输入一棵二叉树，判断该二叉树是否是平衡二叉树。

#include <bits/stdc++.h>
using namespace std;
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution {
  public:
    bool IsBalanced_Solution(TreeNode *pRoot) {
        int deep = 0;
        return IsBalanced_Solution(pRoot, deep);
    }
    bool IsBalanced_Solution(TreeNode *root, int &deep) {
        if (root == nullptr) {
            deep = 0;
            return true;
        }
        int left = 0, right = 0;
        if (IsBalanced_Solution(root->left, left) &&
            IsBalanced_Solution(root->right, right) && abs(left - right) <= 1) {
            deep = max(left, right) + 1;
            return true;
        }
        return false;
    }
};

数组中只出现一次的数字
一个整型数组里除了两个数字之外，其他的数字都出现了偶数次。请写程序找出这两个只出现一次的数字。

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    void FindNumsAppearOnce(vector<int> data, int *num1, int *num2) {
        int m = data.size();
        if (m < 2) {
            return;
        }
        int res = 0;
        for (int i = 0; i < m; i++) {
            res ^= data[i];
        }
        int firstBit = first_bit(res);
        *num1 = 0, *num2 = 0;
        int bit_s = 1 << firstBit;
        for (int i = 0; i < m; i++) {
            if (data[i] & bit_s) {
                *num1 ^= data[i];
            } else {
                *num2 ^= data[i];
            }
        }
    }
    int first_bit(int num) {
        int index = 0;
        while (num && (num & 1) == 0) {
            num >>= 1;
            index++;
        }
        return index;
    }
};

和为S的连续正数序列
小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    vector<vector<int>> FindContinuousSequence(int sum) {
        vector<vector<int>> res;
        int left = 1, right = 2;
        int current_sum = left + right;
        while (left < (1 + sum) / 2) {
            if (current_sum >= sum) {
                if (current_sum == sum) {
                    vector<int> re;
                    for (int i = left; i <= right; i++) {
                        re.push_back(i);
                    }
                    res.push_back(re);
                }
                current_sum -= left;
                left++;
            } else {
                right++;
                current_sum += right;
            }
        }
        return res;
    }
};

和为S的两个数字
输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    vector<int> FindNumbersWithSum(vector<int> array, int sum) {
        int m = array.size();
        vector<int> res;
        for (int i = 0, j = m - 1; i < j;) {
            int c_sum = array[i] + array[j];
            if (c_sum < sum) {
                i++;
            } else if (c_sum > sum) {
                j--;
            } else {
                res = {array[i], array[j]};
                i++, j--;
                break;
            }
        }
        return res;
    }
};

左旋转字符串
汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    string LeftRotateString(string str, int n) {
        if (str.empty() || str.size() < n) {
            return str;
        }
        reverse(str.begin(), str.begin() + n);
        reverse(str.begin() + n, str.end());
        reverse(str.begin(), str.end());
        return str;
    }
};

翻转单词顺序列
牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    string ReverseSentence(string str) {
        vector<string> res;
        int m = str.size();
        if (str.find_first_not_of(' ') == string::npos) {
            return str;
        }
        for (int i = 0; i < m; i++) {
            if (str[i] != ' ') {
                int j = i;
                while (i < m && str[i] != ' ') {
                    i++;
                }
                res.push_back(str.substr(j, i - j));
            }
        }
        string str_res;
        reverse(res.begin(), res.end());
        int n = res.size();
        for (int i = 0; i < n - 1; i++) {
            str_res += res[i] + " ";
        }
        str_res += (n != 0 ? res[n - 1] : "");
        return str_res;
    }
};

扑克牌顺子
LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_)...他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子.....LL不高兴了,他想了想,决定大\小王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何，如果牌能组成顺子就输出true，否则就输出false。为了方便起见,你可以认为大小王是0。

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    bool IsContinuous(vector<int> numbers) {
        if (numbers.empty()) {
            return false;
        }
        sort(numbers.begin(), numbers.end());
        int m = numbers.size();
        int num_zero = 0;
        for (int i = 0; i < m && numbers[i] == 0; i++) {
            num_zero++;
        }
        for (int i = num_zero + 1; i < m; i++) {
            if (numbers[i] == numbers[i - 1]) {
                return false;
            }
            num_zero -= (numbers[i] - numbers[i - 1] - 1);
        }
        return num_zero >= 0;
    }
};

孩子们的游戏
每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0...m-1报数....这样下去....直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!^_)。

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    int LastRemaining_Solution(int n, int m) {
        if (n < 1 || m < 1) {
            return -1;
        }
        int last = 0;
        for (int i = 2; i <= n; i++) {
            last = (last + m) % i;
        }
        return last;
    }
};

求1+2+3+...+n
求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

class Solution {
  public:
    int Sum_Solution(int n) {
        int res = n;
        n && (res += Sum_Solution(n - 1));
        return res;
    }
};

不用加减乘除做加法
写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。

class Solution {
  public:
    int Add(int num1, int num2) {
        int sum = 0, carry = 0;
        do {
            sum = num1 ^ num2;
            carry = (num1 & num2) << 1;
            num1 = sum;
            num2 = carry;
        } while (num2);
        return num1;
    }
};

把字符串转换成整数
将一个字符串转换成一个整数(实现Integer.valueOf(string)的功能，但是string不符合数字要求时返回0)，要求不能使用字符串转换整数的库函数。数值为0或者字符串不是一个合法的数值则返回0。

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    int StrToInt(string str) {
        if (str.empty()) {
            return 0;
        }
        int m = str.size(), num = 0;
        int sign = str[0] == '-' ? -1 : 1;
        for (int i = (str[0] == '-' || str[0] == '+' ? 1 : 0); i < m; i++) {
            if (!isdigit(str[i])) {
                return 0;
            }
            num = num * 10 + str[i] - '0';
        }
        return sign * num;
    }
};

数组中重复的数字
在一个长度为n的数组里的所有数字都在0到n-1的范围内。数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    bool duplicate(int numbers[], int length, int *duplication) {
        if (numbers == nullptr || length <= 0) {
            return false;
        }
        for (int i = 0; i < length; i++) {
            if (numbers[i] != i) {
                if (numbers[i] == numbers[numbers[i]]) {
                    *duplication = numbers[i];
                    return true;
                }
                swap(numbers[i], numbers[numbers[i]]);
            }
        }
        return false;
    }
};

构建乘积数组
给定一个数组A[0,1,...,n-1],请构建一个数组B[0,1,...,n-1],其中B中的元素B[i]=A[0]A[1]...A[i-1]A[i+1]...A[n-1]。不能使用除法。

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    vector<int> multiply(const vector<int> &A) {
        int m = A.size();
        vector<int> left(m, 1), right(m, 1), res(m, 0);
        for (int i = 1; i < m; i++) {
            left[i] = left[i - 1] * A[i - 1];
        }
        for (int i = m - 2; i >= 0; i--) {
            right[i] = right[i + 1] * A[i + 1];
        }
        for (int i = 0; i < m; i++) {
            res[i] = left[i] * right[i];
        }
        return res;
    }
};

正则表达式匹配
给定一个数组A[0,1,...,n-1],请构建一个数组B[0,1,...,n-1],其中B中的元素B[i]=A[0]A[1]...A[i-1]A[i+1]...A[n-1]。不能使用除法。

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    bool match(char *str, char *pattern) {
        string s(str), p(pattern);
        int m = s.length(), n = p.length();
        vector<vector<bool>> dp(m + 1, vector<bool>(n + 1, false));
        dp[0][0] = true;
        for (int i = 0; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (p[j - 1] != '*') {
                    dp[i][j] = i > 0 && dp[i - 1][j - 1] &&
                               (p[j - 1] == '.' || s[i - 1] == p[j - 1]);
                } else {
                    dp[i][j] = dp[i][j - 2] ||
                               (i > 0 && dp[i - 1][j] &&
                                (s[i - 1] == p[j - 2] || p[j - 2] == '.'));
                }
            }
        }
        return dp[m][n];
    }
};

表示数值的字符串
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100","5e2","-123","3.1416"和"-1E-16"都表示数值。但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是。

class Solution {
public:
    bool isNumeric(char *str) {
        bool sign = false, decimal = false, hasE = false;
        int m = strlen(str);
        for (int i = 0; i < m; i++) {
            if (str[i] == 'e' || str[i] == 'E') {
                if (i == m - 1 || hasE) {
                    return false;
                }
                hasE = true;
            } else if (str[i] == '+' || str[i] == '-') {
                if (sign && str[i - 1] != 'e' && str[i - 1] != 'E') {
                    return false;
                }
                if (!sign && i > 0 && str[i - 1] != 'e' && str[i - 1] != 'E') {
                    return false;
                }
                sign = true;
            } else if (str[i] == '.') {
                if (hasE || decimal) {
                    return false;
                }
                decimal = true;
            } else if (str[i] < '0' || str[i] > '9') {
                return false;
            }
        }
        return true;
    }
};

字符流中第一个不重复的字符
请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    // Insert one char from stringstream
    void Insert(char ch) {
        res.push_back(ch);
        dir[ch]++;
    }
    // return the first appearence once char in current stringstream
    char FirstAppearingOnce() {
        int m = res.size();
        for (int i = 0; i < m; i++) {
            if (dir[res[i]] == 1) {
                return res[i];
            }
        }
        return '#';
    }

  private:
    string res;
    map<char, int> dir;
};

链表中环的入口结点
给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

#include <bits/stdc++.h>
using namespace std;
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
  public:
    ListNode *EntryNodeOfLoop(ListNode *pHead) {
        auto faster = pHead, walker = pHead, entry = pHead;
        while (faster && faster->next) {
            faster = faster->next->next;
            walker = walker->next;
            if (faster == walker) {
                while (entry != walker) {
                    walker = walker->next;
                    entry = entry->next;
                }
                return entry;
            }
        }
        return NULL;
    }
};

删除链表中重复的结点
在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

#include <bits/stdc++.h>
using namespace std;
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
  public:
    ListNode *deleteDuplication(ListNode *pHead) {
        if (pHead == nullptr || pHead->next == nullptr) {
            return pHead;
        }
        ListNode *result = new ListNode(-1);
        result->next = pHead;
        auto prev = result, current = pHead;
        while (current) {
            while (current->next && current->val == current->next->val) {
                current = current->next;
            }
            if (prev->next == current) {
                prev = current;
            } else {
                prev->next = current->next;
            }
            current = current->next;
        }
        return result->next;
    }
};

二叉树的下一个结点
给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。

#include <bits/stdc++.h>
using namespace std;
struct TreeLinkNode {
    int val;
    struct TreeLinkNode *left;
    struct TreeLinkNode *right;
    struct TreeLinkNode *next;
    TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
};

class Solution {
  public:
    TreeLinkNode *GetNext(TreeLinkNode *pNode) {
        if (pNode == nullptr) {
            return nullptr;
        }
        if (pNode->right) {
            pNode = pNode->right;
            while (pNode->left) {
                pNode = pNode->left;
            }
            return pNode;
        }
        while (pNode->next) {
            if (pNode->next->left == pNode) {
                return pNode->next;
            }
            pNode = pNode->next;
        }
        return NULL;
    }
};

对称的二叉树
请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。

#include <bits/stdc++.h>
using namespace std;
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution {
  public:
    bool isSymmetrical(TreeNode *pRoot) {
        if (pRoot != NULL) {
            return isMirrorTree(pRoot->left, pRoot->right);
        }
        return true;
    }
    bool isMirrorTree(TreeNode *p, TreeNode *q) {
        if (p == NULL || q == NULL)
            return (p == q);
        return p->val == q->val && isMirrorTree(p->left, q->right) &&
               isMirrorTree(p->right, q->left);
    }
};

按之字形顺序打印二叉树
请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

#include <bits/stdc++.h>
using namespace std;
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution {
  public:
    vector<vector<int>> Print(TreeNode *pRoot) {
        vector<vector<int>> res;
        if (pRoot == nullptr) {
            return res;
        }
        bool left_to_right = true;
        queue<TreeNode *> q;
        q.push(pRoot);
        while (!q.empty()) {
            int m = q.size();
            vector<int> temp;
            for (int i = 0; i < m; i++) {
                auto e = q.front();
                q.pop();
                if (e->left) {
                    q.push(e->left);
                }
                if (e->right) {
                    q.push(e->right);
                }
                temp.push_back(e->val);
            }
            if (!left_to_right) {
                reverse(temp.begin(), temp.end());
            }
            res.push_back(temp);
            left_to_right = !left_to_right;
        }
        return res;
    }
};

把二叉树打印成多行
从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。

#include <bits/stdc++.h>
using namespace std;
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution {
  public:
    vector<vector<int>> Print(TreeNode *pRoot) {
        vector<vector<int>> res;
        if (pRoot == nullptr) {
            return res;
        }
        queue<TreeNode *> q;
        q.push(pRoot);
        while (!q.empty()) {
            int m = q.size();
            vector<int> temp;
            for (int i = 0; i < m; i++) {
                auto e = q.front();
                q.pop();
                if (e->left) {
                    q.push(e->left);
                }
                if (e->right) {
                    q.push(e->right);
                }
                temp.push_back(e->val);
            }
            res.push_back(temp);
        }
        return res;
    }
};

序列化二叉树
请实现两个函数，分别用来序列化和反序列化二叉树

#include <bits/stdc++.h>
using namespace std;
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution {
  public:
    char *Serialize(TreeNode *root) {
        ostringstream out;
        serialize(root, out);
        char *result = new char[out.str().length() + 1];
        strcpy(result, out.str().c_str());
        return result;
    }
    void serialize(TreeNode *root, ostringstream &out) {
        if (root == NULL) {
            out << "# ";
            return;
        }
        out << root->val << " ";
        serialize(root->left, out);
        serialize(root->right, out);
    }
    TreeNode *Deserialize(char *str) {
        istringstream in(str);
        return deserialize(in);
    }
    TreeNode *deserialize(istringstream &in) {
        string word;
        in >> word;
        if (word == "#") {
            return NULL;
        }
        TreeNode *root = new TreeNode(stoi(word));
        root->left = deserialize(in);
        root->right = deserialize(in);
        return root;
    }
};

二叉搜索树的第k个结点
给定一棵二叉搜索树，请找出其中的第k小的结点。例如，（5，3，7，2，4，6，8）中，按结点数值大小顺序第三小结点的值为4。

#include <bits/stdc++.h>
using namespace std;
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution {
  public:
    TreeNode *res = nullptr;
    TreeNode *KthNode(TreeNode *pRoot, int k) {
        inorder(pRoot, k);
        return res;
    }
    void inorder(TreeNode *root, int &k) {
        if (!res && root && k > 0) {
            inorder(root->left, k);
            k--;
            if (k == 0) {
                res = root;
                return;
            }
            inorder(root->right, k);
        }
    }
};

数据流中的中位数

#include <bits/stdc++.h>
using namespace std;
class MedianFinder {
  public:
    /** initialize your data structure here. */
    MedianFinder() {}
    void addNum(int num) {
        min_heap.push(num);
        max_heap.push(min_heap.top());
        min_heap.pop();
        if (max_heap.size() > min_heap.size()) {
            auto temp = max_heap.top();
            max_heap.pop();
            min_heap.push(temp);
        }
    }

    double findMedian() {
        if (max_heap.size() == min_heap.size()) {
            return (max_heap.top() + min_heap.top()) / 2.0;
        } else {
            return min_heap.top();
        }
    }

  private:
    priority_queue<int, vector<int>, less<int>> max_heap;
    priority_queue<int, vector<int>, greater<int>> min_heap;
};

滑动窗口的最大值
给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}；针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    vector<int> maxSlidingWindow(vector<int> &nums, int k) {
        vector<int> res;
        deque<int> dq;
        int m = nums.size();
        for (int i = 0; i < m; i++) {
            while (!dq.empty() && dq.front() <= i - k) {
                dq.pop_front();
            }
            while (!dq.empty() && nums[dq.back()] < nums[i]) {
                dq.pop_back();
            }
            dq.push_back(i);
            if (i >= k - 1) {
                res.push_back(nums[dq.front()]);
            }
        }
        return res;
    }
};

矩阵中的路径
请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则之后不能再次进入这个格子。例如 a b c e s f c s a d e e 这样的3 X 4 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    bool hasPath(char *matrix, int rows, int cols, char *str) {
        if (matrix == nullptr || rows < 1 || cols < 1 || str == nullptr) {
            return false;
        }
        vector<vector<bool>> visited(rows, vector<bool>(cols, false));
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (helper(matrix, rows, cols, i, j, str, 0, visited)) {
                    return true;
                }
            }
        }
        return false;
    }
    bool helper(char *matrix, int rows, int cols, int ii, int jj, char *str,
                int length, vector<vector<bool>> &visited) {
        if (str[length] == '\0') {
            return true;
        }
        if (!isInVaildBoardary(rows, cols, ii, jj) ||
            matrix[ii * cols + jj] != str[length] || visited[ii][jj]) {
            return false;
        }
        visited[ii][jj] = true;
        for (int i = 0; i < direction.size(); i++) {
            int xx = ii + direction[i][0];
            int yy = jj + direction[i][1];
            if (helper(matrix, rows, cols, xx, yy, str, length + 1, visited)) {
                return true;
            }
        }
        visited[ii][jj] = false;
        return false;
    }
    bool isInVaildBoardary(int rows, int cols, int row, int col) {
        int m = rows, n = cols;
        if (row >= 0 && row < m && col >= 0 && col < n) {
            return true;
        }
        return false;
    }

  private:
    vector<vector<int>> direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
};

机器人的运动范围
地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？

#include <bits/stdc++.h>
using namespace std;
class Solution {
  public:
    int movingCount(int threshold, int rows, int cols) {
        if (rows <= 0 || cols <= 0 || threshold < 0) {
            return 0;
        }
        int res = 0;
        vector<vector<bool>> visited(rows, vector<bool>(cols, 0));
        helper(threshold, rows, cols, 0, 0, visited, res);
        return res;
    }
    void helper(int threshold, int rows, int cols, int row, int col,
                vector<vector<bool>> &visited, int &res) {
        visited[row][col] = true;
        res++;
        for (int i = 0; i < direction.size(); i++) {
            int xx = row + direction[i][0], yy = col + direction[i][1];
            if (isInVaildBoardary(rows, cols, xx, yy) && !visited[xx][yy] &&
                getDigit(xx, yy) <= threshold) {
                helper(threshold, rows, cols, xx, yy, visited, res);
            }
        }
    }
    int getDigit(int row, int col) {
        string s = to_string(row), s1 = to_string(col);
        return accumulate(s.begin(), s.end(), 0,
                          [](int sum, char a) { return sum + a - '0'; }) +
               accumulate(s1.begin(), s1.end(), 0,
                          [](int sum, char a) { return sum + a - '0'; });
    }
    bool isInVaildBoardary(int rows, int cols, int row, int col) {
        int m = rows, n = cols;
        if (row >= 0 && row < m && col >= 0 && col < n) {
            return true;
        }
        return false;
    }

  private:
    vector<vector<int>> direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
};

最后编辑于：2018.09.09 21:14:07

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 212,029评论 6赞 492
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 90,395评论 3赞 385
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 157,570评论 0赞 348
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 56,535评论 1赞 284
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 65,650评论 6赞 386
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 49,850评论 1赞 290
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 39,006评论 3赞 408
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 37,747评论 0赞 268
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,207评论 1赞 303
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 36,536评论 2赞 327
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,683评论 1赞 341
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 34,342评论 4赞 330
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 39,964评论 3赞 315
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,772评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,004评论 1赞 266
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 46,401评论 2赞 360
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 43,566评论 2赞 349

剑指offer汇总

推荐阅读更多精彩内容