haha

Author: Jie Feng

codeforces/437B

@@ -0,0 +1,30 @@
+#include<iostream>
+#include<vector>
+using namespace std;
+
+
+
+bool find_element_in_matrix(vector<vector<int> >a, int x){
+    int n = a.size();
+    if (n == 0) return false;
+    int m = a[0].size();
+
+    int iL = 0, iR = n-1;
+    while(iL <= iR){
+        int iM = (iL + iR) >> 1;
+        if (a[iM][0] > x)
+            iR = iM - 1;
+        else iL = iM+1;
+    }
+    if (iR == -1) return false;
+
+    int jL = 0, jR = m-1;
+    while(jL <= jR){
+        int jM = (jL + jR) >> 1;
+        if (a[iR][jM] > x)
+            jR = jM - 1;
+        else jL = jM + 1;
+    }
+    if (jR == -1 || a[iR][jR] != x)  return false;
+    else return true;
+}

codeforces/437B.o

@@ -0,0 +1,74 @@
+#include <map>
+using namespace std;
+
+struct DoubleList{
+    int key;
+    int val;
+    DoubleList *next, *pre;
+    DoubleList():next(NULL), pre(NULL){}
+    DoubleList(int key, int val):key(key), val(val), next(NULL), pre(NULL){
+    }
+};
+
+class LRUCache{
+private:
+    DoubleList *head, *tail;
+    map<int, DoubleList*> M;
+    int capacity;
+public:
+    LRUCache(int capacity):capacity(capacity) {
+        head = new DoubleList();
+        tail = new DoubleList();
+        head->next = tail;
+        tail->pre = head;
+    }
+    void disConnect(DoubleList* cur){
+        cur->pre->next = cur->next;
+        cur->next->pre = cur->pre;
+    }
+    void insertHead(DoubleList* cur){
+        cur->next = head->next;
+        head->next->pre = cur;
+        
+        head->next = cur;
+        cur->pre = head;
+    }
+    int get(int key) {
+        if (M.find(key) == M.end()) return -1;
+        else{
+            DoubleList* cur = M[key];
+            if (cur != head->next){
+                disConnect(cur);
+                insertHead(cur);
+            }
+            return cur->val;
+        }
+    }
+    
+    void eraseLast(){
+        DoubleList* erase = tail->pre;
+        M.erase(erase->key); // !!!
+        
+        erase->pre->next = tail;
+        tail->pre = erase->pre;
+        
+        free(erase);
+    }
+    void add(int key, int value){
+        DoubleList* cur = new DoubleList(key, value);
+        M[key] = cur;
+        insertHead(cur);
+    }
+    void set(int key, int value) {
+        if (M.find(key) == M.end()){
+            if (M.size() == capacity)
+                eraseLast();
+            add(key, value);
+        }else {
+            DoubleList* cur = M[key];
+            disConnect(cur);
+            insertHead(cur);
+            cur->val = value;
+        }
+    }
+};

codeforces/438C

@@ -1,4 +1,4 @@
-target= convert-BST-to-doublelinkedlist
+target= lru-cache
 
 all:
 	#g++ -o $(target) -g $(target).cpp -w

codeforces/438C.o

@@ -0,0 +1,101 @@
+#include<string>
+#include<iostream>
+#include<queue>
+#include<vector>
+#include<map>
+#include<set>
+using namespace std;
+
+
+
+class solution{
+private:
+    int totalIndex = 0;
+    int n;
+    map<string, int> label2Index;
+    vector<string> index2Label;
+    vector<int> indegree;
+    vector<set<int> > edges;
+    vector<bool> visited;
+    inline int setIndex(string s){
+        if(label2Index.find(s) == label2Index.end())
+            label2Index[s] = totalIndex++;
+    }
+    void dumpIndex(set<pair<string,string> > P){
+        for (auto i = P.begin(); i != P.end(); i++){
+            setIndex(i->first);
+            setIndex(i->second);
+        }
+
+        n = label2Index.size();
+        index2Label = vector<string>(n);
+        indegree = vector<int>(n, 0);
+        edges = vector<set<int> >(n);
+
+        for (auto i = label2Index.begin(); i != label2Index.end(); i++){
+            index2Label[i->second] = i->first;
+        }
+    }
+public:
+    solution(){
+    }
+    bool validTree(int x){
+        visited = vector<bool>(n, false);
+        queue<int> Q;
+        Q.push(x);
+        int visitedNum = 0;
+        while(!Q.empty()){
+            int u = Q.front();
+            Q.pop();
+            visited[u] = true;
+            visitedNum++;
+            for (auto i = edges[u].begin(); i != edges[u].end(); i++){
+                if (!visited[*i]){
+                    Q.push(*i);
+                }else return false;
+            }
+        }
+        return visitedNum == n;
+    }
+    void printTree(int u, int level){
+        cout << string(level, ' ') << index2Label[u] << endl;
+        for (auto i = edges[u].begin(); i != edges[u].end(); i++){
+            printTree(*i, level+1);
+        }
+    }
+    void printTreeFromPairSet(set<pair<string,string> > P){
+        dumpIndex(P);
+        for (auto i = P.begin(); i != P.end(); i++){
+            int i1 = label2Index[i->first];
+            int i2 = label2Index[i->second];
+            edges[i1].insert(i2);
+            indegree[i2]++;
+        }
+
+        int head = -1;
+        int countHeads = 0;
+        for (int i = 0; i < indegree.size(); i++){
+            if (indegree[i] == 0){ 
+                head = i;
+                countHeads++;
+            }
+        }
+        if (countHeads != 1 || !validTree(head)){
+            cout << "These pairs can't consist a Tree!!!" << endl;
+        }else{
+            printTree(head, 0);
+        }
+    }
+};
+
+int main(){
+    set<pair<string, string> > P;
+    P.insert(make_pair("a", "b"));
+    P.insert(make_pair("b", "c"));
+    P.insert(make_pair("a", "d"));
+    P.insert(make_pair("d", "e"));
+    P.insert(make_pair("d", "f"));
+    P.insert(make_pair("d", "g"));
+    solution s;
+    s.printTreeFromPairSet(P);
+}

codeforces/temp.o

@@ -0,0 +1,25 @@
+class Solution {
+public:
+    int search(int A[], int n, int target) {
+        int L = 0, R = n-1;
+        if (target >= A[0]){
+            while(L <= R){
+                int M = (L + R) >> 1;
+                if (A[M] < A[0]) R = M - 1;
+                else if (target < A[M]) R = M - 1;
+                else L = M + 1;
+            }
+            if (R != n && A[R] == target) return R;
+            else return -1;
+        }else{
+            while(L <= R){
+                int M = (L + R) >> 1;
+                if (A[M] >= A[0]) L = M + 1;
+                else if (target < A[M]) R = M - 1;
+                else L = M + 1;
+            }
+            if (R != n && A[R] == target) return R;
+            else return -1;
+        }
+    }
+};