8 problems

Author: zhuli19901106

delete-operation-for-two-strings_1_AC.cpp

@@ -0,0 +1,45 @@
+#include <string>
+#include <vector>
+using std::string;
+using std::vector;
+
+class Solution {
+public:
+    int minDistance(string word1, string word2) {
+        return word1.size() + word2.size() - 2 * LCS(word1, word2);
+    }
+private:
+    int LCS(const string &s1, const string &s2) {
+        int ls1 = s1.size();
+        int ls2 = s2.size();
+        if (ls1 == 0 || ls2 == 0) {
+            return 0;
+        }
+        if (ls1 < ls2) {
+            return LCS(s2, s1);
+        }
+        
+        vector<vector<int>> dp(2, vector<int>(ls2 + 1, 0));
+        int f, nf;
+        int i, j;
+        
+        f = 0;
+        nf = !f;
+        for (i = 1; i <= ls1; ++i) {
+            dp[f][0] = 0;
+            for (j = 1; j <= ls2; ++j) {
+                if (s1[i - 1] == s2[j - 1]) {
+                    dp[f][j] = dp[nf][j - 1] + 1;
+                } else {
+                    dp[f][j] = max(dp[f][j - 1], dp[nf][j]);
+                }
+            }
+            f = !f;
+            nf = !f;
+        }
+        int res = dp[nf][ls2];
+        dp.clear();
+        
+        return res;
+    }
+};

design-in-memory-file-system_1_AC.cpp

@@ -0,0 +1,251 @@
+// I hate multiple inheritance, but I hate this problem even more.
+// So be it.
+#include <map>
+#include <string>
+#include <vector>
+using std::map;
+using std::string;
+using std::vector;
+
+static const int TYPE_FILE = 1;
+static const int TYPE_DIR = 2;
+
+class Node {
+public:
+    Node(const string &_name): name(_name) {}
+    
+    string getName() {
+        return name;
+    }
+    
+    virtual int type() = 0;
+protected:
+    string name;
+};
+
+class FileInterface {
+public:
+    virtual string getContent() = 0;
+    virtual void appendContent(const string &s) = 0;
+    virtual void setContent(const string &s) = 0;
+};
+
+class FileNode: public Node, public FileInterface {   
+public:
+    FileNode(const string &_name): Node(_name), content("") {}
+    
+    virtual int type() {
+        return TYPE_FILE;
+    }
+    
+    virtual string getContent() {
+        return content;
+    }
+    
+    virtual void appendContent(const string &s) {
+        content += s;
+    }
+    
+    virtual void setContent(const string &s) {
+        content = s;
+    }
+protected:
+    string content;
+};
+
+class DirInterface {
+public:
+    virtual Node *getChild(const string &_name) = 0;
+    virtual void addChild(const string &_name, Node *_node) = 0;
+    virtual vector<string> getList() = 0;
+};
+
+class DirNode: public Node, public DirInterface {
+public:
+    DirNode(const string &_name): Node(_name) {}
+    
+    virtual int type() {
+        return TYPE_DIR;
+    }
+    
+    virtual Node *getChild(const string &_name) {
+        if (child.find(_name) != child.end()) {
+            return child[_name];
+        } else {
+            return NULL;
+        }
+    }
+    
+    virtual void addChild(const string &_name, Node *_node) {
+        if (_name == "" || _node == NULL) {
+            return;
+        }
+        
+        Node *ptr = getChild(_name);
+        if (ptr != NULL) {
+            delete ptr;
+        }
+        child[_name] = _node;
+    }
+
+    virtual vector<string> getList() {
+        vector<string> res;
+        for (auto &p: child) {
+            res.push_back(p.first);
+        }
+        return res;
+    }
+protected:
+    map<string, Node *> child;
+};
+
+class FileSystem {
+public:
+    FileSystem() {
+        root = new DirNode("");
+    }
+    
+    vector<string> ls(string path) {
+        vector<string> vt = tokenize(path);
+        Node *ptr = root;
+        Node *ptr1;
+        
+        // Needed for type casting
+        DirInterface *pd;
+        FileInterface *pf;
+        
+        for (auto &tk: vt) {
+            if (ptr->type() != TYPE_DIR) {
+                return vector<string>();
+            }
+            pd = (DirNode *)ptr;
+            if ((ptr1 = pd->getChild(tk)) == NULL) {
+                return vector<string>();
+            }
+            ptr = ptr1;
+        }
+        if (ptr->type() == TYPE_DIR) {
+            pd = (DirNode *)ptr;
+            return pd->getList();
+        } else {
+            vector<string> res;
+            res.push_back(ptr->getName());
+            return res;
+        }
+    }
+    
+    void mkdir(string path) {
+        vector<string> vt = tokenize(path);
+        Node *ptr = root;
+        Node *ptr1;
+        
+        // Needed for type casting
+        DirInterface *pd;
+        FileInterface *pf;
+        
+        for (auto &tk: vt) {
+            pd = (DirNode *)ptr;
+            if ((ptr1 = pd->getChild(tk)) == NULL) {
+                ptr1 = new DirNode(tk);
+                pd->addChild(tk, ptr1);
+            }
+            ptr = ptr1;
+        }
+    }
+    
+    void addContentToFile(string filePath, string content) {
+        vector<string> vt = tokenize(filePath);
+        Node *ptr = root;
+        Node *ptr1;
+        
+        // Needed for type casting
+        DirInterface *pd;
+        FileInterface *pf;
+        
+        int n = vt.size();
+        int i;
+        for (i = 0; i < n - 1; ++i) {
+            pd = (DirNode *)ptr;
+            if ((ptr1 = pd->getChild(vt[i])) == NULL) {
+                ptr1 = new DirNode(vt[i]);
+                pd->addChild(vt[i], ptr1);
+            }
+            ptr = ptr1;
+        }
+        pd = (DirNode *)ptr;
+        if ((ptr1 = pd->getChild(vt[n - 1])) == NULL) {
+            ptr1 = new FileNode(vt[n - 1]);
+            pd->addChild(vt[n - 1], ptr1);
+        }
+        ptr = ptr1;
+        
+        if (ptr->type() == TYPE_DIR) {
+            // Error
+            return;
+        }
+        pf = (FileNode *)ptr;
+        pf->appendContent(content);
+    }
+    
+    string readContentFromFile(string filePath) {
+        vector<string> vt = tokenize(filePath);
+        Node *ptr = root;
+        Node *ptr1;
+        
+        // Needed for type casting
+        DirInterface *pd;
+        FileInterface *pf;
+        
+        for (auto &tk: vt) {
+            pd = (DirNode *)ptr;
+            if ((ptr1 = pd->getChild(tk)) == NULL) {
+                // Error
+                return "";
+            }
+            ptr = ptr1;
+        }
+        if (ptr->type() != TYPE_FILE) {
+            // Error
+            return "";
+        }
+        pf = (FileNode *)ptr;
+        return pf->getContent();
+    }
+private:
+    Node *root;
+    
+    vector<string> tokenize(const string &s) {
+        vector<string> v;
+        string tk;
+        
+        int ls = s.size();
+        int i = 0;
+        while (true) {
+            while (i < ls && s[i] == '/') {
+                ++i;
+            }
+            if (i >= ls) {
+                break;
+            }
+            while (i < ls && s[i] != '/') {
+                tk.push_back(s[i++]);
+            }
+            v.push_back(tk);
+            tk.clear();
+            if (i >= ls) {
+                break;
+            }
+        }
+        
+        return v;
+    }
+};
+
+/**
+ * Your FileSystem object will be instantiated and called as such:
+ * FileSystem obj = new FileSystem();
+ * vector<string> param_1 = obj.ls(path);
+ * obj.mkdir(path);
+ * obj.addContentToFile(filePath,content);
+ * string param_4 = obj.readContentFromFile(filePath);
+ */

erect-the-fence_1_AC.cpp

@@ -0,0 +1,81 @@
+// Damn, convex hull.
+/**
+ * Definition for a point.
+ * struct Point {
+ *     int x;
+ *     int y;
+ *     Point() : x(0), y(0) {}
+ *     Point(int a, int b) : x(a), y(b) {}
+ * };
+ */
+#include <algorithm>
+#include <vector>
+using std::sort;
+using std::vector;
+
+int crossProduct(const Point &p1, const Point &p2, const Point &p3)
+{
+    return (p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y);
+}
+
+Point mp;
+bool comparator(const Point &p1, const Point &p2)
+{
+    // Left turn
+    int d = crossProduct(mp, p1, p2);
+    if (d != 0) {
+        return d > 0;
+    }
+    d = abs(p1.x - mp.x) + abs(p1.y - mp.y) - abs(p2.x - mp.x) - abs(p2.y - mp.y);
+    if (d != 0) {
+        return d < 0;
+    }
+    return false;
+}
+
+class Solution {
+public:
+    vector<Point> outerTrees(vector<Point> &points) {
+        auto &vp = points;
+        int n = vp.size();
+        if (n < 3) {
+            return vp;
+        }
+        
+        int mi = 0;
+        int i;
+        for (i = 1; i < n; ++i) {
+            if (vp[i].x < vp[mi].x || (vp[i].x == vp[mi].x && vp[i].y < vp[mi].y)) {
+                mi = i;
+            }
+        }
+        swap(vp[0], vp[mi]);
+        mp = vp[0];
+        sort(vp.begin() + 1, vp.end(), comparator);
+        
+        vector<Point> res;
+        res.push_back(mp);
+        
+        int pr;
+        for (i = 1; i <= n; ++i) {
+            while (res.size() >= 2 && 
+                (pr = crossProduct(res[res.size() - 2], res[res.size() - 1], vp[i % n])) < 0) {
+                res.pop_back();
+            }
+            res.push_back(vp[i % n]);
+        }
+        res.pop_back();
+        if (res.size() == n) {
+            return res;
+        }
+        
+        // Check for colinear points that have been left out.
+        i = n - 2;
+        while (i >= 1 && crossProduct(mp, vp[i], vp[n - 1]) == 0) {
+            res.push_back(vp[i]);
+            --i;
+        }
+        
+        return res;
+    }
+};