#include <iostream>
#include <queue>using namespace std;struct Node{int x, y;Node( int a= 0, int b= 0 ):x(a), y(b) {}
};bool operator<( Node a, Node b ){if( a.x== b.x ) return a.y> b.y;return a.x> b.x;
}int main(){priority_queue<Node> q;for( int i= 0; i< 10; ++i )q.push( Node( rand(), rand() ) );while( !q.empty() ){cout << q.top().x << ' ' << q.top().y << endl;q.pop();}getchar();return 0;
}

#include <iostream>
#include <queue>using namespace std;struct Node{int x, y;Node( int a= 0, int b= 0 ):x(a), y(b) {}
};struct cmp{bool operator() ( Node a, Node b ){if( a.x== b.x ) return a.y> b.y;return a.x> b.x; }
};int main(){priority_queue<Node, vector<Node>, cmp> q;for( int i= 0; i< 10; ++i )q.push( Node( rand(), rand() ) );while( !q.empty() ){cout << q.top().x << ' ' << q.top().y << endl;q.pop();}getchar();return 0;
}

#include<iostream>
#include<vector>
#include<string>
#include <cstdio>
#include<queue>
#include<algorithm>
using namespace std;
struct cmp {bool operator()(int a,int b) {return a > b;}
};struct node {int x;int y;
};bool operator<(node a, node b) {return a.x > b.y;
}ostream& operator<<(ostream& os,const node&a) {os << a.x << " " << a.y<< endl;return os;}
bool operator<<(node a, node b) {return a.x > b.y;
}int main() {//priority_queue<int> q;priority_queue<node> q;for (int i = 0; i < 5; ++i) {node a;cin >> a.x;cin >> a.y;q.push(a);}cout << q.top() << endl;system("pause");
}

class MinStack {
public:/** initialize your data structure here. */stack<int> s;stack<int> minStack;MinStack() {}void push(int x) {s.push(x);if(minStack.empty()){minStack.push(x);}else{//总是忘记加上else，只有非空的时候才能这样
            minStack.push(min(x,minStack.top()));}}void pop() {if(!s.empty()){s.pop();}if(!minStack.empty()){minStack.pop();} return;}int top() {//这里的top返回的是当前元素，不是需要返回最小值        if(!s.empty()){return s.top();}return 0;}int getMin() {if(!minStack.empty()){return minStack.top();}return 0;       }
};/*** Your MinStack object will be instantiated and called as such:* MinStack obj = new MinStack();* obj.push(x);* obj.pop();* int param_3 = obj.top();* int param_4 = obj.getMin();*/

class MyQueue {
public:/** Initialize your data structure here. */stack<int> newStack,oldStack;//newStack总是存储最新压入的元素
    MyQueue() {}/** Push element x to the back of queue. */void push(int x) {newStack.push(x);}/** Removes the element from in front of queue and returns that element. */int pop() {if(oldStack.empty()){while(!newStack.empty()){oldStack.push(newStack.top());newStack.pop();}}        int tmp = oldStack.top();oldStack.pop();return tmp;}/** Get the front element. */int peek() {if(oldStack.empty()){while(!newStack.empty()){oldStack.push(newStack.top());newStack.pop();}} return oldStack.top();}/** Returns whether the queue is empty. */bool empty() {        return newStack.empty() && oldStack.empty();}
};/*** Your MyQueue object will be instantiated and called as such:* MyQueue obj = new MyQueue();* obj.push(x);* int param_2 = obj.pop();* int param_3 = obj.peek();* bool param_4 = obj.empty();*/

class MyStack {
public:/** Initialize your data structure here. */queue<int> q;MyStack() {}/** Push element x onto stack. */void push(int x) {q.push(x);for(int i = 0;i < q.size() - 1;++i){q.push(q.front());q.pop();}       }/** Removes the element on top of the stack and returns that element. */int pop() {int tmp = q.front();q.pop();return tmp;}/** Get the top element. */int top() {        return q.front();}/** Returns whether the stack is empty. */bool empty() {return q.empty();}
};/*** Your MyStack object will be instantiated and called as such:* MyStack obj = new MyStack();* obj.push(x);* int param_2 = obj.pop();* int param_3 = obj.top();* bool param_4 = obj.empty();*/

class Solution {
public:int largestRectangleArea(vector<int>& height) {if(height.size() == 0){return 0;}int Max = 0;stack<int> s;vector<int> heights{height};heights.push_back(0);for(int i = 0;i < heights.size();++i){           while(!s.empty() && heights[i] < heights[s.top()]){int h = heights[s.top()];s.pop();//栈中存储的都是比目前索引小的元素int w = s.empty() ? i : (i - s.top() - 1);                Max = max(Max,h * w);}s.push(i);}return Max;}
};

struct TreeNode{int val;TreeNode* left;TreeNode* right;TreeNode(int x):val(x),left(NULL),right(NULL){}};
class solution{
public:TreeNode* maxTree(vector<int> A){if(A.size() == 0){return NULL;}stack<TreeNode*> s;for(int i = 0;i < A.size();++i){TreeNode* curN = new TreeNode(A[i]);while(!s.empty() && curN -> val > s.top() -> val){curN -> left = s.top();s.pop();}if(!s.empty()){stack.top() -> right = curN;}s.push(curN);}int len = s.size();while(len > 1){s.pop();--len;}return s.top();}};

/*** Definition of ListNode* class ListNode {* public:*     int val;*     ListNode *next;*     ListNode(int val) {*         this->val = val;*         this->next = NULL;*     }* }*/
class Solution {
public:/*** @param hashTable: A list of The first node of linked list* @return: A list of The first node of linked list which have twice size*/  int hashcode(int key, int capacity) {if(key < 0){return (key % capacity + capacity ) % capacity;}return key % capacity;} vector<ListNode*> rehashing(vector<ListNode*> hashTable) {// write your code hereif(hashTable.size() == 0){return {};}int size = 2 * hashTable.size();vector<ListNode*> result(size,NULL);for(auto node : hashTable){if(node == NULL){continue;}while(node != NULL){int key = node -> val;int capacity = size;int idx = hashcode(key,capacity);// ListNode* dummy = ;if(result[idx] == NULL){result[idx] = new ListNode(node -> val);}else{ListNode* dummy = result[idx];
//这里必须要使用一个dummy，因为数组中的元素必须是链表的索引while( dummy -> next  != NULL){dummy =  dummy -> next; }dummy -> next = new ListNode(node -> val);}node = node -> next;}}return result;}
};

class Node{
public:int key;int value;Node* prev;Node* next;Node(int k,int v):key(k),value(v),prev(nullptr),next(nullptr){}
};

struct Node{int key;int value;Node* prev;Node* next;Node(int k,int v):key(k),value(v),prev(nullptr),next(nullptr){}
};

class Node{
public:int key;int value;Node* prev;Node* next;Node(int k,int v):key(k),value(v),prev(nullptr),next(nullptr){}
};
class LRUCache {
public:LRUCache(int capacity) {//构造函数this -> capacity = capacity;dummyHead -> next = dummyTail;dummyTail -> prev = dummyHead;        }void moveToTail(Node* cur){cur -> prev = dummyTail -> prev;dummyTail -> prev = cur;cur -> prev -> next = cur;cur -> next = dummyTail;}int get(int key) {if(hash.find(key) == hash.end()){return -1;}Node* cur = hash[key];//remove currentcur -> prev -> next = cur -> next;cur -> next -> prev = cur -> prev;//move to tail
        moveToTail(cur);return  cur -> value;}void put(int key, int value) {//最近使用的放在tail//如果已经存在这个值比如已经有（4,1），那么再插入（4,4），key一样，但是value不一样，就需要对hash进行更新就行if (get(key) != -1) {hash[key] -> value = value;return;}//if fullNode* insertNode = new Node(key,value);if(hash.size() == capacity){hash.erase(dummyHead -> next -> key);//remove dummyHead -> next;Node* cur = dummyHead -> next;cur -> next -> prev = cur -> prev;cur -> prev -> next = cur -> next;// hash.insert(make_pair(key,insertNode));
            }//not full
        hash.insert(make_pair(key,insertNode));moveToTail(insertNode);}
private:int capacity;Node* dummyHead = new Node(-1,-1);Node* dummyTail = new Node(-1,-1);unordered_map<int,Node*> hash;};/*** Your LRUCache object will be instantiated and called as such:* LRUCache obj = new LRUCache(capacity);* int param_1 = obj.get(key);* obj.put(key,value);*/

class Solution {
public:int longestConsecutive(vector<int>& nums) {if(nums.size() == 0){return 0;}unordered_set<int> hashNums;for(int i : nums){hashNums.insert(i);}int res = 0;for(int tmp : nums){hashNums.erase(tmp);int left = tmp - 1;while(hashNums.count(left)){hashNums.erase(left);--left;}int right = tmp + 1;while(hashNums.count(right)){hashNums.erase(right);++right;}res = max(res,right - left - 1);//这个思维很好，免掉了还得找最大值的n次操作
        }return res;}
};

class Solution {
public:/*** @param nums: A list of integers* @return: A list of integers includes the index of the first number *          and the index of the last number*/vector<int> subarraySum(vector<int> nums){// write your code hereint len = nums.size();vector<int> ans;unordered_map<int, int> hashMap;hashMap.insert(make_pair(0, -1));int sum = 0;for (int i = 0; i < len; i++) {sum += nums[i];if (hashMap.find(sum) != hashMap.end()) {ans.push_back(hashMap.at(sum) + 1);ans.push_back(i);return ans;}hashMap.insert(make_pair(sum, i));}return ans;}};

class Solution {
public:vector<vector<string>> groupAnagrams(vector<string>& strs) {vector<vector<string>> result;if(strs.size() == 0){return result;}unordered_map<string,vector<string>> hashMap;//排序后一样的单词就压入对应的vector中for(int i = 0;i < strs.size();++i){string tmp = strs[i];sort(tmp.begin(),tmp.end());if(hashMap.find(tmp) != hashMap.end()){vector<string> vecStr;hashMap.insert({tmp,vecStr});}hashMap[tmp].push_back(strs[i]);}//遍历map，将每个string对应的变换词压入result中for(auto index = hashMap.begin();index != hashMap.end();++index){            result.push_back(index -> second);           }return result;}
};

class MedianFinder {
public:/** initialize your data structure here. */MedianFinder() {}void addNum(int num) {maxHeap.push(num);minHeap.push(maxHeap.top());maxHeap.pop();if(maxHeap.size() < minHeap.size()){maxHeap.push(minHeap.top());minHeap.pop();}}double findMedian() {int size= maxHeap.size() + minHeap.size();double result = 0;if(size == 0){return result;}if(size % 2 == 0){result = (maxHeap.top() + minHeap.top()) / 2.0;}else{result = maxHeap.top();}return result;}
private:priority_queue<int> maxHeap;priority_queue<int,vector<int>,greater<int>> minHeap;
};/*** Your MedianFinder object will be instantiated and called as such:* MedianFinder obj = new MedianFinder();* obj.addNum(num);* double param_2 = obj.findMedian();*/

class MedianFinder {
public:/** initialize your data structure here. */MedianFinder() {//minHeap,maxHeap;
    }void addNum(int num) {if( (maxHeap.size() + minHeap.size() ) % 2 == 1){//insert to maxHeap//first insert to minHeap,then find the min number ,put it to maxHeapif(minHeap.size() > 0 && num > minHeap[0]){minHeap.push_back(num);push_heap(minHeap.begin(),minHeap.end(),greater<int>());num = minHeap[0];pop_heap(minHeap.begin(),minHeap.end(),greater<int>());minHeap.pop_back();}maxHeap.push_back(num);push_heap(maxHeap.begin(),maxHeap.end(),less<int>());}else{//insert to minHeapif(maxHeap.size() > 0 && num < maxHeap[0]){maxHeap.push_back(num);push_heap(maxHeap.begin(),maxHeap.end(),less<int>());num = maxHeap[0];pop_heap(maxHeap.begin(),maxHeap.end(),less<int>());maxHeap.pop_back();}minHeap.push_back(num);push_heap(minHeap.begin(),minHeap.end(),greater<int>());//cout<< minHeap[0]<<endl;
        }}double findMedian() {double result = 0;int size = minHeap.size() + maxHeap.size();if(size == 0){return result;}if( (minHeap.size() + maxHeap.size() ) % 2 == 1){result = minHeap[0];cout<< minHeap[0]<<endl;}else{result = (minHeap[0] + maxHeap[0]) / 2.0;}return result;}
private:vector<int> minHeap;vector<int> maxHeap;
};/*** Your MedianFinder object will be instantiated and called as such:* MedianFinder obj = new MedianFinder();* obj.addNum(num);* double param_2 = obj.findMedian();*/

class Solution {
public:bool findWord(vector<vector<char>>& board, string word,int row,int col,int index)     {if(index == word.size()){return true;}if(row < 0 || row >= board.size() || col < 0 || col >= board[0].size() ||  board[row][col] != word[index]){return false;}board[row][col] = '0';bool result = findWord(board,word,row - 1,col,index + 1) ||findWord(board,word,row + 1,col,index + 1) ||findWord(board,word,row,col - 1,index + 1) ||findWord(board,word,row,col + 1,index + 1) ;board[row][col] = word[index];return result;}bool exist(vector<vector<char>>& board, string word) {if(word.size() == 0){return true;}if(board.empty() || board[0].empty()){return false;}       for(int row = 0;row < board.size();++row){for(int col = 0;col < board[row].size();++col){                if(findWord(board,word,row,col,0)){                    return true;}                 }}return false;}
};