leetcode笔记

82. Remove Duplicates from Sorted List II

　　https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii/

　　下面代码是自写hashmap版，练一下hashmap，用一般的map<int,int>红黑树map也能过。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */


class MyHash {
    static const int MAX = 123456;
    static const int MOD = 123447;
    static const int WHAT = 1237;
    static const int INVALID = -1234478;
    pair<int,int> a[MAX];
    bool used[MAX];
    int siz =0;
    int myhash(int key){
        if(siz==MOD)return MOD;
        int pos = key*WHAT%MOD;
        while(pos<0)pos=-(pos+1);
        while(used[pos] && a[pos].first!=key)pos = (pos+1)%MOD;
        return pos;
    }
public:
    int insert(pair<int,int> kv){
        int pos = myhash(kv.first);
        if(pos==MOD)return -1;
        if(!used[pos]){
            used[pos]=true;
            siz++;
        }
        a[pos] = kv;
        return 0;
    }
    int get(int key){
        int pos = myhash(key);
        if(a[pos].first==key)return a[pos].second;
        else return INVALID;
    }

    void add(int key, int ad){
        int pos = myhash(key);
        if(!used[pos]){
            insert(make_pair(key,0));
        }
        a[pos].second+=ad;
    }
};
 
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        MyHash count;
        ListNode* cur = head;
        while(cur!=NULL){
            count.add(cur->val,1);
            cur=cur->next;
        }
        ListNode newhead(0);
        newhead.next = head;
        cur=&newhead;
        while(cur!=NULL){
            while(cur->next !=NULL && count.get(cur->next->val)>1){
                cur->next = cur->next->next;
            }
            cur = cur->next;
        }
        return newhead.next;
    }
};

 

106. Construct Binary Tree from Inorder and Postorder Traversal

　　https://leetcode.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/

　　根据中序后序建树。

　　一般思想：后序里面越靠前面的越是根，找到中序的[st,ed]中最是根的，建个结点，再递归分支左结点、右结点。

　　进一步思想：每次找最是根的那个要找区间最值，能不能直接找到那个根？根据后序遍历的规律，左子树的点和右子树的点肯定是分开的两部分，左边和右边，其中每部分的最后一个就是那个子树的根节点。

　　

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
    map<int,int> mp;
    TreeNode* build(vector<int>& inorder, vector<int>& postorder, int inst, int ined , int post, int poed){
        if(inst>ined || post>poed)return NULL;
        int inmid = mp[postorder[poed]];
        TreeNode * ret = new TreeNode(inorder[inmid]);
        ret->left = build(inorder, postorder, inst, inmid-1, post, post + ((inmid-1) - inst));
        ret->right = build(inorder, postorder, inmid+1, ined,poed - 1 - (ined - (inmid+1)),poed - 1);
        return ret;
    }
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        for(int i=0; i<inorder.size(); i++){
            mp[inorder[i]] = i;
        }
        return build(inorder, postorder, 0, inorder.size()-1, 0, postorder.size()-1);
    }
};

 

 

130. Surrounded Regions

　　https://leetcode.com/problems/surrounded-regions/

　　给一个矩阵，有X有O，把不与边界相连的O fill成X。

　　宽搜。我深搜有的点RE了，可恶。

　　宽搜代码：

　　

#include<bits/stdc++.h>
using namespace std;
class Solution {
    const int gx[4] = {1,-1,0,0};
    const int gy[4] = {0,0,1,-1};
    int n;
    int m;
    void fill(vector<vector<char>>&board , int x, int y,char c){
        queue<int> qx;
        queue<int> qy;
        qx.push(x);
        qy.push(y);
        board[x][y] = c;
        while(!qx.empty()){
            x = qx.front();
            y = qy.front();
            qx.pop();
            qy.pop();
            for(int i=0; i<4; i++){
                int xx = x+gx[i];
                int yy = y+gy[i];
                if(xx<0 || xx>=n || yy<0 || yy>=m)continue;
                if(board[xx][yy]=='X'|| board[xx][yy]=='1')continue;
                board[xx][yy] = c;
                qx.push(xx);
                qy.push(yy);
            }
        }
    }
public:
    void solve(vector<vector<char>>& board) {
        if(board.empty())return;
        n = board.size();
        m = board[0].size();
        for(int i=0; i<n; i++){
            for(int j=0; j<m; j++){
                if((i==0 || j==0|| i==n-1 || j==m-1)&&board[i][j]=='O'){
                    fill(board, i, j,'1');
                }
            }
        }
        for(int i=1; i<n-1; i++){
            for(int j=1; j<m-1; j++){
                if(board[i][j]=='O'){
                    fill(board, i, j,'X');
                }
            }
        }
        for(int i=0; i<n; i++){
            for(int j=0; j<m; j++){
                if(board[i][j]=='1'){
                    board[i][j] = 'O';
                }
            }
        }
    }
};

int main(){
    vector<vector<char> >board ={{'O','O'},{'O','O'}};
    Solution so;
    so.solve(board);
    return 0;
}

 

 

 137. Single Number II

　　https://leetcode.com/problems/single-number-ii/

　　好多数出现3次，只有一个数出现1次。

　　解法：https://discuss.leetcode.com/topic/22821/an-general-way-to-handle-all-this-sort-of-questions

　　代码：

　　

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        //00 01 10
        //01 10 00
        int a = 0;
        int b = 0;
        for(int x:nums){
            int na = (x & ~a & b) | (~x & a & ~b);
            int nb = (x & ~b & ~a)| (~x & ~a & b);
            a = na;
            b = nb;
        }
        return ~a & b;
    }
};

 

138. Copy List with Random Pointer

　　https://leetcode.com/problems/copy-list-with-random-pointer/

　　深拷贝带随机指针的链表。

　　不用额外空间的方法：把A->B->C 各个节点复制一份放在旁边，A->A`->B->B`->C->C`，然后x`->random = x`->random->next。然后再把这个拆成两个链表。

　　注意原来的链表不能破坏，要把它拆回原样。（我以为能随便乱搞，结果错了好久，可恶）

　　 

/**
 * Definition for singly-linked list with a random pointer.
 * struct RandomListNode {
 *     int label;
 *     RandomListNode *next, *random;
 *     RandomListNode(int x) : label(x), next(NULL), random(NULL) {}
 * };
 */
class Solution {
public:
    RandomListNode *copyRandomList(RandomListNode *head) {
        if(!head)return head;
        RandomListNode *cur = head, *x,*t;
        while(cur){
            t = cur->next;
            x = new RandomListNode(cur->label);
            x->next = t;
            x->random = cur->random;
            cur->next = x;
            cur = t;
        }
        cur = head;
        while(cur){
            cur = cur->next;
            if(cur->random) cur->random = (cur->random)->next;
            cur= cur->next;
        }
        x = head->next;
        cur = head;
        while(cur){
            t = cur->next;
            cur->next = cur->next->next;
            if(cur->next)t->next = cur->next->next;
            else t->next = NULL;
            cur = cur->next;
        }
        return x;
    }
};

 

 

146. LRU Cache

　　https://leetcode.com/problems/lru-cache/

　　LRU。每次满的时候把最久没用的那个踢出去。

　　单链表+map，查找O(logn) 冲突O(n)，因为要扫到最后一个。如果要冲突O(1)的话要双链表。

　　

https://leetcode.com/problems/lru-cache/

 双向链表，把插入和删除函数抽了出来，好像不错：

struct kvNode{
    int key;
    int val;
    kvNode *left, *right;
    kvNode(int k,int v):key(k), val(v),left(NULL), right(NULL){};
    kvNode():key(0),val(0),left(NULL),right(NULL){};
};
class LRUCache{
    int cnt = 0;
    int ma;
    kvNode h,tail;
    map<int,kvNode*> mp;
    void insert(kvNode* f, kvNode* now){;
        now->left = f;
        now->right = f->right;
        f->right->left = now;
        f->right = now;
    }
    void del(kvNode* now){
        now->left->right = now->right;
        now->right->left = now->left;
    }
public:
    LRUCache(int capacity) {
        ma = capacity;
        h.right=&tail;
        tail.left = &h;
        mp.clear();
    }
    
    int get(int key) {
        if(mp.find(key)!=mp.end()){
            kvNode *p = mp[key];
            del(p);
            insert(&h, p);
            return p->val;
        }
        return -1;
    }
    
    void set(int key, int value) {
        if(ma==0)return;
        if(mp.find(key)==mp.end()){
            if(cnt==ma){
                kvNode *q = tail.left;
                mp.erase(q->key);
                del(q);
                delete q;
                cnt--;
            }
            kvNode *p = new kvNode(key,value);
            insert(&h,p);
            mp[key] = p;
            cnt++;
        }else{
            kvNode *p = mp[key];
            p->val = value;
            del(p);
            insert(&h, p);
        }
    }
};

 

 

 

 

148. Sort List

 https://leetcode.com/problems/sort-list/

　　链表排序。

　　当然是用归并排序啦！都不用开多少新的空间。

　　不过第一次写的时候，居然写错，可恶，有点难。

　　关键在于，比如把AB分为A和B两份，我们要先存A之前的那个点aa、B之后的那个点bb，排完以后要他们连起来， aa->排完的->bb。

　　为了更方便排，先要把他们切开，写一个split(node, length)函数，把node开始的length个结点之后变成null，把结尾之后的那个点返回。

　　这样，就很容易排了！

　　

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
    ListNode* merge(ListNode* l, ListNode *r){
        ListNode temp(0);
        ListNode *cur = &temp;
        while(l && r){
            if(l->val < r->val){
                cur->next = l;
                cur = l;
                l = l->next;
            }else{
                cur->next = r;
                cur = r;
                r=r->next;
            }
        }
        if(l){
            cur->next = l;
        }else cur->next = r;
        cur = temp.next;
        return cur;
    }
    
    ListNode *split(ListNode *st, int w){
        for(int i=1;st&& i<w; i++)st = st->next;
        if(st==NULL)return NULL;
        ListNode *p = st->next;
        st->next = NULL;
        return p;
    }
public:
    ListNode* sortList(ListNode* head) {
        ListNode temp(0);
        ListNode *hh = &temp;
        hh->next = head;
        int siz=0;
        ListNode *cur = head;
        while(cur){
            siz++;
            cur=cur->next;
        }
        for(int w=1; w<=siz; w*=2){
            ListNode *tail = hh, *mid,*r;
            while(tail->next){
                mid = split(tail->next,w);
                r = split(mid,w);
                tail->next = merge(tail->next, mid);
                for(int i=0;(tail->next)&& i<2*w; i++){
                    tail = tail->next;
                }
                tail->next = r;
            }
        }
        return hh->next;
    }
};

 

 

 

168. Excel Sheet Column Title

171. Excel Sheet Column Number

　　https://leetcode.com/problems/excel-sheet-column-title/

　　https://leetcode.com/problems/excel-sheet-column-number/

　　168是列数转excel列号，1对应A，27对应AA。

　　171是反过来转，excel列号转列数。

　　解：因为这个和进制有一点差别，没法直接把字母当做26进制，只好认真观察，瞪眼法。

　　观察草稿：

A 1 Z 26
AA 27 = 26+1
AZ 52 = 26 + 26
BA 53 = 26*2 + 1
ZA      26*26 + 1
ZZ         26*26 + 26
AAA        26*26 + 26 + 1
AZZ        26*26 + 26*26 + 26

AA AZ -> A Z (X-1)%26
AA AZ -> A  (X-1) / 26
AAA AZZ -> AA AZ 

 

　　168代码：

class Solution {
public:
    string convertToTitle(int n) {
        string ret = "";
        while(n){
            int x = (n-1)%26;
            char c = 'A'+x;
            ret = c+ret;
            n = (n-1)/26;
        }
        return ret;
    }
};

 

　　171代码：

class Solution {
public:
    int titleToNumber(string s) {
        int ans=0;
        int bei=1;
        for(int i = s.size()-1; i>=0; i--){
            int x = s[i]-'A' + 1;
            ans += bei*x;
            bei*=26;
        }
        return ans;
    }
};

 

 

 

 

209. Minimum Size Subarray Sum

　　https://leetcode.com/problems/minimum-size-subarray-sum/

　　在数列中找 和大于等于s的连续子串 的最小长度。

　　1.求和不能每次都直接一个个加（O(n)），可以像我这样弄一个求和数组求（O(1)），或者在滑动窗口的时候维护（可能比较麻烦，求和数组比较直接）。

　　2.注意题目要求，如果没有满足需求的就返回0，包括数组为空的情况。

　　3.一顿滑动

　　4.补充：题目说做了O(n)的还要试试O(nlogn)的……what？看了别人的答案，O(n)的一般是滑动窗口不用求和数组，这样空间O(1)。O(nlogn)的是二分+求和数组的。

O(n)：

class Solution {
public:
    vector<int> a;
    int sum(int st, int ed){
        return a[ed+1] - a[st];
    }

    int minSubArrayLen(int s, vector<int>& nums) {
        int siz = nums.size();
        while(!a.empty())a.pop_back();
        a.push_back(0);
        for(int i=0; i<siz; i++)
            a.push_back(a[i] + nums[i]);
        int r=0,l=0;
        while(sum(l,r)<s && r<siz)r++;
        if(r>=siz)return 0;
        int ans = r-l+1;
        for(;r<siz;r++){
            while(r>l && sum(l+1,r)>=s)l++;
            ans = min(r-l+1, ans);
        }
        return ans;
    }
};

 

O(nlogn)：

#include<bits/stdc++.h>
using namespace std;
class Solution {
public:
    vector<int> a;
    int sum(int st, int ed) {
        return a[ed+1] - a[st];
    }

    int bs(int st,int ed, int s){
        int l=st, r=ed;
        int re = INT_MAX;
            while(l<=r){
                int mid = l + (r-l)/2;
                if(sum(st,mid)>=s)
                    r=mid-1;
                else l=mid+1;
            }
        if(l<=ed)re=l;
        return re;
    }

    int minSubArrayLen(int s, vector<int>& nums) {
        int siz = nums.size();
        while(!a.empty())a.pop_back();
        a.push_back(0);
        for(int i=0; i<siz; i++)
            a.push_back(a[i] + nums[i]);
        int ans = INT_MAX;
        for(int st=0; st<siz; st++){
            int x = bs(st,siz-1,s);
            if(x!=INT_MAX)
                ans = min(ans,x - st + 1);
        }
        return ans!=INT_MAX?ans:0;
    }
};

int main(){
    int s=7;
    int arr[]={2,3,1,2,4,3};
    vector<int> v(arr,arr+6);
    Solution so;
    int ans = so.minSubArrayLen(s,v);
    printf("%d\n",ans);
    return 0;
}

 

 

 

211. Add and Search Word - Data structure design 

　　https://leetcode.com/problems/add-and-search-word-data-structure-design/

　　做一个数据结构，支持插入字符串和判断字符串是否在，判断时支持用点.代替任意字母，其他的只能是a到z小写字母。

　　解：用字典树，遇到点的时候用26种递归去找。

　　

class TrieNode{
public:
    bool isKey;
    TrieNode* child[26];
    TrieNode():isKey(false){
        memset(child,NULL, sizeof(child));
    }
};

class WordDictionary {
    TrieNode root;
    bool find(const char *s, TrieNode *cur){
        int j=0;
        while(s[j]){
            char c = s[j];
            if(c!='.'){
                int q = c - 'a';
                if(cur->child[q]) cur = cur->child[q];
                else return false;
            }else{
                for(int i=0; i<26; i++){
                    if(cur->child[i]){
                        if(find(s+j+1, cur->child[i])) return true;
                    }
                }
                return false;
            }
            j++;
        }
        if(cur->isKey)return true;
        else return false;
    }
public:

    // Adds a word into the data structure.
    void addWord(string word) {
        TrieNode* cur = &root;
        for(char c:word){
            int q = c - 'a';
            if(cur->child[q] == NULL){
                cur ->child[q] = new TrieNode();
            }
            cur = cur->child[q];
        }
        cur->isKey = true;
    }

    // Returns if the word is in the data structure. A word could
    // contain the dot character '.' to represent any one letter.
    bool search(string word) {
        return find(word.c_str(), &root);
    }
};

// Your WordDictionary object will be instantiated and called as such:
// WordDictionary wordDictionary;
// wordDictionary.addWord("word");
// wordDictionary.search("pattern");

 

 

 

227. Basic Calculator II

　　https://leetcode.com/problems/basic-calculator-ii/

　　表达式求值，加减乘除，不带括号。

　　可恶，看了题解，发现这个不带括号的直接瞎比做就行了，我还想什么栈方法什么递归方法想了半天，简直逗，题解都是只要十几行的。

　　下面是没看题解写的。

　　=============分割线============

　　随机到这题发现我真的弱，这是基础题啊，我都不记得怎么做，需要认真复习了。

　　方法两种：

　　1.先用一个符号栈中缀转后缀，再用一个操作数栈进行后缀表达式求值。

　　2.用两个栈，一个符号栈一个操作数栈，直接对中缀表达式求值。

　　中缀转后缀的代码：

class Solution {
    map<char,int> priority;
    int cal(vector<int> v){
        stack<int> s;
        for(int x:v){
            if(x>=0)s.push(x);
            else{
                    char c = -x;
                    int z = s.top();
                    s.pop();
                    int y = s.top();
                    s.pop();
                    int w;
                    switch(c){
                        case '+':
                            w = y+z;
                            break;
                        case '-':
                            w=y-z;
                            break;
                        case '*':
                            w=y*z;
                            break;
                        case '/':
                            w=y/z;
                            break;
                    }
                    s.push(w);
                }
            }
        return s.top();
    }
    
    vector<int> mid2back(vector<int> v){
        vector<int> ret;
        stack<char> s;
        for(int x:v){
            if(x>=0)ret.push_back(x);
            else{
                char c = -x;
                while(!s.empty() && priority[s.top()]>=priority[c]){
                    ret.push_back(-s.top());
                    s.pop();
                }
                s.push(c);
            }
        }
        while(!s.empty()){
            ret.push_back(-s.top());
            s.pop();
        }
        return ret;
    }
    
    vector<int> str2vec(string s){
        vector<int> ret;
        int num=0;
        for(char c:s){
            if(c==' ')continue;
            if(c>='0' && c<='9') num = num*10 + (c - '0');
            else {
                ret.push_back(num);
                num=0;
                char ch = c;
                ret.push_back(-c);
            }
        }
        ret.push_back(num);
        return ret;
    }
    
public:
    Solution(){
        priority['*']=2;
        priority['/']=2;
        priority['+']=1;
        priority['-']=1;
    }

    int calculate(string s) {
        vector<int> midexp = str2vec(s);
        vector<int> backexp = mid2back(midexp);
        int ans = cal(backexp);
        return ans;
    }
};

　　思考：如果带括号怎么做？中缀转后缀的时候就要将括号消掉了，遇到右括号就要疯狂出栈直到消掉左括号。难道是左右括号优先级1，加减2，乘除3？特殊处理弹出左括号的时候就结束while，并且右括号不入栈，好像不错。不对，这样入左括号的时候，之前的就要弹光了，难道左括号特殊处理不管优先级就进站？好像可以。

 

312. Burst Balloons

　　https://leetcode.com/problems/burst-balloons/

　　有一排乘法恐狼先锋，你杀一个i号狼会收到a[i-1]*a[i]*a[i+1]的伤害，然后剩下的会连起来。求能受到的最大伤害。

　　和hdu 5115 Dire Wolf 题解 (ACM/ICPC 14 北京站 现场赛)  差不多。别人的题解：http://blog.163.com/infog@126/blog/static/783768072014114714157/

　　区间DP代码：

　　

class Solution {
public:
    int maxCoins(vector<int>& nums) {
        int f[nums.size()+1][nums.size()+1];
        memset(f,0,sizeof(f));
        int n=nums.size();
        for(int k=0; k<n; k++){
            for(int i=0; i+k<n; i++){
                int t=1;
                if(i-1>=0)t*=nums[i-1];
                if(i+k+1<n)t*=nums[i+k+1];
                for(int j=i; j<=i+k; j++){
                    f[i][i+k] = max(f[i][i+k], f[i][j-1] + f[j+1][i+k] + t*nums[j]);
                }
            }
        }
        return f[0][n-1];
    }
};

 

352. Data Stream as Disjoint Intervals

https://leetcode.com/problems/data-stream-as-disjoint-intervals/

　　做一个数据结构，支持插入数字，输出一堆区间。

　　用一个map记各个数字，指向Interval编号。

　　插入数字的时候维护区间左右端点， 合并区间的时候删Interval。

　　注意不仅要维护左右端点，当前插入点也要记一下，不然会重复插入，我这个错找了好久。 

/**
 * Definition for an interval.
 * struct Interval {
 *     int start;
 *     int end;
 *     Interval() : start(0), end(0) {}
 *     Interval(int s, int e) : start(s), end(e) {}
 * };
 */
class SummaryRanges {
    map<int,int> mp;
    map<int,Interval>itv;
    int n=0;
public:
    /** Initialize your data structure here. */
    SummaryRanges() {
        mp.clear();
        itv.clear();
        n=0;
    }
    
    void addNum(int val) {
        if(mp.find(val)==mp.end()){
            int l =val;
            int r = val;
            if(mp.find(val-1)!=mp.end()) l = min(l, itv[mp[val-1]].start);
            if(mp.find(val+1)!=mp.end()) r = max(r, itv[mp[val+1]].end);
            if(l==r){
                itv[n] = Interval(val,val);
                mp[val]=n;
                n++;
            }else if(l!=val && r!=val){
                itv.erase(mp[r]);
                itv[mp[l]].start = l;
                itv[mp[l]].end = r;
                mp[r]=mp[l];
                mp[val]=mp[l];// use for judge if val insert before
            }else{
                int x = (l==val)?r:l;
                itv[mp[x]].start = l;
                itv[mp[x]].end = r;
                mp[val] = mp[x];
            }
        }
    }
    
    static bool cmp(const Interval &x,const Interval &y){
        return x.start < y.start;
    }
    
    vector<Interval> getIntervals() {
        vector<Interval> ret;
        for(pair<int,Interval> it:itv){
            ret.push_back(it.second);
        }
        sort(ret.begin(), ret.end(), cmp);
        return ret;
    }
};

/**
 * Your SummaryRanges object will be instantiated and called as such:
 * SummaryRanges obj = new SummaryRanges();
 * obj.addNum(val);
 * vector<Interval> param_2 = obj.getIntervals();
 */

 

 

 

 

374. Guess Number Higher or Lower

https://leetcode.com/problems/guess-number-higher-or-lower/

幸运52猜数字，注意点：1.C++ 爆int，平均数要用x = l + (r-l)/2;

　　　　　　　　　　　　2.当l==r时就不用再猜一次了可以直接return。（不关键）

 

 

394. Decode String

https://leetcode.com/problems/decode-string/

递归：

class Solution {
    string decode(string s, int &i){
        int cnt=0;
        string ret = "";
        for(; s[i]!=']'; i++){
            if(s[i]>='0' && s[i]<='9'){
                cnt = cnt *10 + (s[i]-'0');
            }else if(s[i]=='['){
                i++;
                string t = decode(s,i);
                for(int j=0; j<cnt; j++)
                    ret += t;
                cnt = 0;
            }else ret += s[i];
        }
        return ret;
    }
public:
    string decodeString(string s) {
        int i=0;
        return decode(s+"]", i);
    }
};

 

非递归：

class Solution {
public:
    string decodeString(string s) {
        int i=0;
        stack<int> si;
        stack<string> ss;
        string t="";
        int cnt = 0;
        for(char c:s){
            if(c>='0' && c<='9'){
                cnt = cnt *10 + (c-'0');
            }else if(c=='['){
                si.push(cnt);
                cnt=0;
                ss.push(t);
                t="";
            }else if(c==']'){
                cnt = si.top();
                si.pop();
                string tt = t;
                t = ss.top();
                ss.pop();
                for(int j=0; j<cnt; j++)
                    t += tt;
                cnt = 0;
            }else t += c;
        }
        return t;
    }
};

 

 

450. Delete Node in a BST

　　https://leetcode.com/problems/delete-node-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) {}
 * };
 */
class Solution {
    int deleteLittle(TreeNode * cur){
        TreeNode * fa = cur;
        while(cur->left!=NULL){
            fa = cur;
            cur = cur->left;
        }
        int ret = cur->val;
        fa->left = cur->right;//this, I wrote wrong : fa->left = NULL, ouch! spend much time to find and fix it.
        return ret;
    }
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if(!root)return NULL;
        if(root->val ==key){
            if(!root->left)return root->right;
            if(!root->right)return root->left;
            if((root->right)->left!=NULL){
                root->val = deleteLittle(root->right);
            }else{
                root->val = root->right->val;
                root->right = root->right->right;
            }
        }else{
            if(key < root->val){
                root->left = deleteNode(root->left, key);
            }else 
                root->right = deleteNode(root->right, key);
        }
        return root;
    }
};

 

 

 

460. LFU Cache

　　https://leetcode.com/problems/lfu-cache/

　　LFU，Least Frequently Used (LFU) ，是冲突时先删频率最小的，频率相同的话删最久没用过的。（另外一种叫LRU，就是删最久没用过的）。

　　做完发现怎么是hard，可恶，不过复习了LRU LFU的概念。

　　这个关键是，冲突时怎么找到最小的那个。每次冲突都要找最小的，很容易想到需要一个能够支持插入、删除、快速找到最小的这三中操作的数据结构，这不就是，map嘛，底层是红黑树实现，插入删除查找都是Logn，无敌。如果是每次在数组里扫最小的，那是O(n)。

　　另外用key找value，这个我也用的map，总的时间复杂度大概，查找是logn，插入时冲突，也是logn，好像是这个样子，每次操作logn，m次操作mlogn。

　　题目提示说要O(1)操作，那key找value可以hash，这个找最小要怎么O(1)？等我想一想。

　　logn代码：

　　

class LFUCache {
    int capa;
    int used;
    typedef pair<pair<int,int>,pair<int,int> > p4i;// frequency, time, key, value
    vector<p4i> v;  //v[pos]
    map<int,int> mp;    //<key, pos>
    map<pair<int,int>, int> freqTimePos;    // frequency, time , pos
    int time;
public:
    LFUCache(int capacity) {
        capa = capacity;
        used=0;
        time=0;
        v.clear();
        mp.clear();
    }
    
    int get(int key) {
        if(mp.find(key)!=mp.end()){
            time++;
            int p = mp[key];
            freqTimePos.erase(v[p].first);
            v[p].first.second = time;
            v[p].first.first++;
            freqTimePos[v[p].first]=p;
            return v[p].second.second;
        }else return -1;
    }
    
    void put(int key, int value) {
        time++;
        if(mp.find(key)!=mp.end()){
            int p = mp[key];
            freqTimePos.erase(v[p].first);
            v[p].first.second = time;
            v[p].first.first++;
            freqTimePos[v[p].first]=p;
            v[p].second.second = value;
        }else{
            if(used<capa){
                used++;
                v.push_back(make_pair(make_pair(1,time),make_pair(key,value)));
                freqTimePos[v.back().first]=v.size()-1;
                mp[key]=v.size()-1;
            }else{
                if(capa==0)return;
                int ekey,epos;
                map<pair<int,int>, int>::iterator it = freqTimePos.begin();
                epos = it->second;
                ekey = v[epos].second.first;
                mp.erase(ekey);
                mp[key]=epos;
                freqTimePos.erase(v[epos].first);
                v[epos] = make_pair(make_pair(1,time),make_pair(key,value));
                freqTimePos[v[epos].first]=epos;
            }
        }
    }
};

/**
 * Your LFUCache object will be instantiated and called as such:
 * LFUCache obj = new LFUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */