Merge pull request #1733 from mkwkw/main

[mkwkw] WEEK 02 Solutions

Author: mkwkw

3sum/mkwkw.cpp

@@ -0,0 +1 @@
+//set-up

climbing-stairs/mkwkw.cpp

@@ -0,0 +1,20 @@
+//Dynamic Programming
+//dp[n] = dp[n-1]+dp[n-2]
+class Solution {
+public:
+    int climbStairs(int n) {
+        int dp[46];
+        
+        dp[0] = 0;
+        dp[1] = 1;
+        dp[2] = 2;
+
+        for(int i=3; i<=n; i++)
+        {
+            dp[i] = dp[i-1]+dp[i-2];
+        }
+
+        return dp[n];
+
+    }
+};

product-of-array-except-self/mkwkw.cpp

@@ -0,0 +1 @@
+//set-up 

valid-anagram/mkwkw.cpp

@@ -0,0 +1,37 @@
+//map: key:alphabet, value:count
+//if t is an anagram of s
+// 1. same length
+// 2. same content of map
+class Solution {
+public:
+    bool isAnagram(string s, string t) {
+        
+        //1. different length -> false
+        if(s.length()!=t.length())
+        {
+            return false;
+        }
+
+        //2. different map -> false
+        map<char, int> sMap, tMap;
+        for(int i=0; i<s.length(); i++)
+        {
+            sMap[s[i]]++;
+            tMap[t[i]]++;
+        }
+
+        for(auto c : sMap)
+        {
+            if(tMap.find(c.first)==tMap.end())
+            {
+                return false;
+            }
+            if(tMap[c.first] != c.second)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+};

validate-binary-search-tree/mkwkw.cpp

@@ -0,0 +1,81 @@
+//Optimize complexity
+class Solution {
+public:
+    vector<int> productExceptSelf(vector<int>& nums) {
+        
+        vector<int> answer(nums.size(), 1);
+        //production before nums[i] from index 0
+        int before = 1;
+
+        for(int i=0; i<nums.size()-1; i++)
+        {
+            before *= nums[i];
+            answer[i+1] *= before;
+        }
+
+        //nums[i] 기준 앞에서 production 해놓은 것에 nums[i] 기준 뒤에 것들을 production from index n-1
+        //production after nums[i] to answer[i-1]
+        // answer[i-1] * after
+        int after = 1;
+        for(int i=nums.size()-1; i>0; i--)
+        {
+            after *= nums[i];
+            answer[i-1] *= after;
+        }
+
+        return answer;
+    }
+};
+
+
+
+//using division operation
+/*
+class Solution {
+public:
+    vector<int> productExceptSelf(vector<int>& nums) {
+        int zeroCnt = 0;
+        int allProduct = 1;
+        vector<int> answer(nums.size());
+
+        for(int i=0; i<nums.size(); i++)
+        {
+            allProduct *= nums[i];
+            if(nums[i]==0)
+            {
+                zeroCnt++;
+            }
+        }
+
+        if(zeroCnt == 0)
+        {
+            for(int i=0; i<nums.size(); i++)
+            {
+                answer[i] = allProduct/nums[i];
+            }
+        }
+        else if(zeroCnt == 1)
+        {
+            int zeroIdx = 0;
+            int allProductWithoutZero = 1;
+
+            for(int i=0; i<nums.size(); i++)
+            {
+                if(nums[i]==0)
+                {
+                    zeroIdx = i;
+                }
+                else
+                {
+                    allProductWithoutZero *=nums[i];
+                    answer[i] = 0;
+                 }
+            }
+
+            answer[zeroIdx] = allProductWithoutZero;
+        }
+        
+        return answer;
+    }
+};
+*/