5주차 문제 풀이 5개 추가

Author: hwi-middle

best-time-to-buy-and-sell-stock/hwi-middle.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int maxProfit(vector<int>& prices) {
+        int res = 0;
+        int minPrice = prices[0];
+        int len = prices.size();
+        for (int i = 0; i < len; ++i)
+        {
+            res = max(res, prices[i] - minPrice);
+            minPrice = min(minPrice, prices[i]);
+        }
+
+        return res;
+    }
+};

encode-and-decode-strings/hwi-middle.cpp

@@ -0,0 +1,33 @@
+class Codec {
+public:
+
+    // Encodes a list of strings to a single string.
+    string encode(vector<string>& strs) {
+        string str;
+        for(auto& s : strs)
+        {
+            str += s;
+            str.push_back(3);
+        }
+
+        return str;
+    }
+
+    // Decodes a single string to a list of strings.
+    vector<string> decode(string s) {
+        vector<string> v;
+        v.reserve(200);
+        string str_buf;
+        istringstream iss(s);
+        while (getline(iss, str_buf, (char)3)) 
+        {
+            v.push_back(str_buf);
+        }
+
+        return v;
+    }
+};
+
+// Your Codec object will be instantiated and called as such:
+// Codec codec;
+// codec.decode(codec.encode(strs));

group-anagrams/hwi-middle.cpp

@@ -0,0 +1,59 @@
+class Solution {
+private:
+    struct chnum
+    {
+        int cnt[26];
+
+        chnum()
+        {
+            memset(cnt, 0, sizeof(int) * 26);
+        }
+
+        bool operator==(const chnum& other) const
+        {
+            for (int i = 0; i < 26; ++i)
+            {
+                if (this->cnt[i] != other.cnt[i]) return false;
+            }
+            return true;
+        }
+    };
+
+struct chnumHash
+    {
+        size_t operator()(const chnum& key) const
+        {
+            size_t seed = 5381; 
+            for (int i = 0; i < 26; ++i)
+            {
+                seed = ((seed << 5) + seed) + key.cnt[i];
+            }
+            return seed;
+        }
+    };
+
+public:
+    vector<vector<string>> groupAnagrams(vector<string>& strs) {
+        unordered_map<chnum, vector<string>, chnumHash> ns;
+        for (auto& str : strs)
+        {
+            chnum n;
+            for (auto ch : str)
+            {
+                n.cnt[ch - 'a']++;
+            }
+
+            ns[n].push_back(str);
+        }
+
+        vector<vector<string>> v;
+        v.reserve(ns.size());
+
+        for (auto& p : ns)
+        {
+            v.push_back(move(p.second));
+        }
+
+        return v;
+    }
+};

implement-trie-prefix-tree/hwi-middle.cpp

@@ -0,0 +1,68 @@
+class Trie
+{
+public:
+	Trie()
+	{
+        mRoot = make_unique<Node>();
+	}
+
+	void insert(string word)
+	{
+		Node* curNode = mRoot.get();
+		for (char c : word)
+		{
+            auto& child = curNode->children[c - 'a'];
+    		if (child == nullptr)
+			{
+				child = make_unique<Node>();
+			}
+
+			curNode = child.get();
+		}
+
+		curNode->isWord = true;
+	}
+
+	bool search(string word)
+	{
+		Node* curNode = mRoot.get();
+		for (char c : word)
+		{
+            auto& child = curNode->children[c - 'a'];
+			if (child == nullptr)
+			{
+				return false;
+			}
+
+			curNode = child.get();
+		}
+
+		return curNode->isWord;
+	}
+
+	bool startsWith(string prefix)
+	{
+		Node* curNode = mRoot.get();
+		for (char c : prefix)
+		{
+            auto& child = curNode->children[c - 'a'];
+			if (child == nullptr)
+			{
+				return false;
+			}
+
+			curNode = child.get();
+		}
+
+		return true;
+	}
+
+private:
+	struct Node
+	{
+		bool isWord = false;
+		unique_ptr<Node> children[26];
+	};
+
+	unique_ptr<Node> mRoot;
+};

word-break/hwi-middle.cpp

@@ -0,0 +1,39 @@
+class Solution {
+public:
+    bool wordBreak(string s, vector<string>& wordDict) {
+        this->s = s;
+        return solve(0, wordDict);
+    }
+
+    bool solve(int start, vector<string>& wordDict)
+    {
+        if (memo.contains(start))
+        {
+            return memo[start];
+        }
+
+        if (start == s.size())
+        {
+            return true;
+        }
+
+        for (auto& str : wordDict)
+        {
+            if (s.substr(start, str.size()) == str)
+            {
+                if (solve(start + str.size(), wordDict))
+                {
+                    memo[start] = true;
+                    return true;
+                }
+            }
+        }
+
+        memo[start] = false;
+        return false;
+    }
+
+private:
+    string s;
+    unordered_map<int, bool> memo;
+};