Tuan dev

Topic1_Arrays/Day2207/Day2207_Tuan/1_TwoSum.txt

@@ -0,0 +1,16 @@
+//Complexity: O(n)
+
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        unordered_map<int, int> mp;
+        for(int i = 0;  i < nums.size(); i++){
+            if(mp.find(target - nums[i]) == mp.end()){
+                mp[nums[i]] = i;
+            }else{
+                return {mp[target-nums[i]], i};
+            }
+        }
+        return {-1, -1};
+    }
+};

Topic1_Arrays/Day2207/Day2207_Tuan/2_NumberOfIslands.txt

@@ -0,0 +1,41 @@
+//Complexity: O(n*m)
+
+class Solution {
+public:
+    int numIslands(vector<vector<char>>& grid) {
+        queue<pair<int, int>> q;
+        int rows = grid.size();
+        int cols = grid[0].size();
+        int cnt = 0;
+        vector<pair<int, int>> directions = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
+        for(int i = 0; i < rows; i++){
+            for(int j = 0; j < cols; j++){
+                if(grid[i][j] == '1'){
+                    pair<int, int> p;
+                    p.first = i;
+                    p.second = j;
+                    q.push(p);
+                    grid[i][j] = '0';
+                	++cnt;
+                	cout << cnt << "\n";
+                    while(!q.empty()){
+                    	pair<int, int> peek = q.front();
+						q.pop();
+						cout << peek.first << " " << peek.second << "\n";
+						for(pair<int, int> dir : directions){
+							int neighboor_x = peek.first + dir.first;
+							int neighboor_y = peek.second + dir.second;
+							if(neighboor_x >= 0 && neighboor_x < rows && neighboor_y >= 0 
+							&& neighboor_y < cols && grid[neighboor_x][neighboor_y] == '1'){
+								pair<int, int> neighboor = {neighboor_x, neighboor_y};
+								q.push(neighboor);
+								grid[neighboor_x][neighboor_y] = '0';
+							}
+						}
+					}
+                }
+            }
+        }
+        return cnt;
+    }
+};

Topic1_Arrays/Day2207/Day2207_Tuan/3_MergeSortedArrays.txt

@@ -0,0 +1,18 @@
+//Complexity: O(n+m)
+
+class Solution {
+public:
+    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
+        int i = m - 1, j = n - 1, k = n + m - 1;
+        while(j>=0){
+            if(i >= 0 && nums1[i] > nums2[j]){
+                nums1[k] = nums1[i];
+                i--; k--;
+            }
+            else{
+                nums1[k] = nums2[j];
+                j--; k--;
+            }
+        }
+    }
+};

Topic1_Arrays/Day2307/Day2307_Tuan/1_RandomPickWithWeight.txt

@@ -0,0 +1,30 @@
+// Time complexity: O(N + log N)
+// Using the interval between 2 index of cumulative sum to represent the Selection Possibility
+class Solution {
+private:
+    vector<int> cumulativeSum; 
+public:
+    Solution(vector<int>& w) {
+	// Calculate cumulative sum according to weight[i]
+        int sum = 0;
+        for(int weight : w){
+            sum += weight;
+            cumulativeSum.push_back(sum);
+        }
+    }
+    // Using binary search to find the possibility of random weight
+    int pickIndex() {
+	// +1 at the end of randWeight to include the last element 
+        int randWeight = rand() % cumulativeSum.back() + 1;
+        int low = 0, high = cumulativeSum.size()-1;
+        while(low < high){
+            int mid = (low + high) / 2;
+            if(randWeight <= cumulativeSum[mid]){
+                high = mid;
+            } else {
+                low = mid + 1;
+            }
+        }
+        return low;
+    }
+};

Topic1_Arrays/Day2307/Day2307_Tuan/2_MergeIntervals.txt

@@ -0,0 +1,22 @@
+//Complexity: O(n)
+
+class Solution {
+public:
+    vector<vector<int>> merge(vector<vector<int>>& intervals) {
+        sort(intervals.begin(), intervals.end());
+
+        vector<vector<int>> merged;
+        vector<int> previous = intervals[0];
+        for(int i = 1; i < intervals.size(); i++){
+            if(previous[1] >= intervals[i][0]){
+                previous[1] = max(previous[1], intervals[i][1]);
+            } else {
+                merged.push_back(previous);
+                previous = intervals[i];
+            }
+        }
+        merged.push_back(previous);
+
+        return merged;
+    }
+};

Topic1_Arrays/Day2307/Day2307_Tuan/3_BestTimeToBuyAndSellStock.txt

@@ -0,0 +1,17 @@
+//Complexity: O(n)
+
+class Solution {
+public:
+    int maxProfit(vector<int>& prices) {
+        int length = prices.size();
+        int buyPrice = prices[0];
+        int profit = 0;
+        for(int i = 1; i < length; i++){
+        	if(prices[i] < buyPrice){
+        		buyPrice = prices[i];
+			}
+            profit = max(profit, prices[i] - buyPrice);
+        }
+        return profit;
+    }
+};

Topic1_Arrays/Day2407/Day2407_Tuan/1_GroupAnagrams.txt

@@ -0,0 +1,22 @@
+// Time complexity: O(n) 
+// Space complexity: O(n) - Using map  
+// Explanation: Because all the anagrams have the same sorted string.
+//		So, using map to store <sorted string, vector<string>>.
+
+class Solution {
+public:
+    vector<vector<string>> groupAnagrams(vector<string>& strs) {
+        unordered_map<string, vector<string>> mp;
+        for(string str : strs){
+            string word = str;
+            sort(word.begin(), word.end());
+            mp[word].push_back(str);
+        }
+
+        vector<vector<string>> ans;
+        for(auto key : mp){
+            ans.push_back(key.second);
+        }
+        return ans;
+    }
+};

Topic1_Arrays/Day2407/Day2407_Tuan/3_3Sum.txt

@@ -0,0 +1,38 @@
+// Time complexity: O(n^2)
+// Space complexity: O(1) 
+// Explanation: Using 1 pivot i and 2 pointer j and k 
+//		Skip the duplicate elements
+
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        List<List<Integer>> res = new ArrayList<>();
+        Arrays.sort(nums);
+        int len = nums.length;
+        for(int i = 0; i < len - 2; i++){
+            // Skip duplicate elements in nums array to avoid duplicate triplets
+            if(i > 0 && nums[i] == nums[i-1])
+                continue;
+
+            // i is like the pivot
+            // j/k is left/right ptr of the rest interval 
+            int j = i + 1, k = len - 1;
+
+            while(j < k){
+                int sum = nums[i] + nums[j] + nums[k];
+                if(sum > 0){
+                    --k;
+                }else if(sum < 0){
+                    ++j;
+                }else{
+                    res.add(Arrays.asList(nums[i], nums[j], nums[k]));
+                    ++j;
+
+                    // Avoid duplicate nums[j] if nums[j] == nums[j-1]
+                    while(nums[j] == nums[j-1] && j < k)
+                        ++j;
+                }
+            }
+        }
+        return res;
+    }
+}

Topic1_Arrays/Day2507/Day2507_Tuan/3_FindCommonCharacters.txt

@@ -0,0 +1,25 @@
+// Time complexity: O(n) 
+// Space complexity: O(n) - n: words.length 
+// Explanation: Using 2d array to store the frequency of each word
+
+class Solution {
+    public List<String> commonChars(String[] words) {
+        int[][] freq = new int[words.length][26];
+        for (int i = 0; i < words.length; i++) {
+            for (char c : words[i].toCharArray()) {
+                freq[i][c - 'a']++;
+            }
+        }
+        List<String> res = new ArrayList<>();
+        for (int i = 'a'; i <= 'z'; i++) {
+            int min = Integer.MAX_VALUE;
+            for (int j = 0; j < freq.length; j++) {
+                min = Math.min(min, freq[j][i-'a']);
+            }
+            for (int j = 0; j < min; j++) {
+                res.add(String.valueOf((char) i));
+            }
+        }
+        return res;
+    }
+}

Topic1_Arrays/Day2607/Day2607_Tuan/3_MaximumSubarray.txt

@@ -0,0 +1,17 @@
+// Time complexity: O(n)
+// Space complexity: O(n) 
+// Explanation: Using array tracking the current sum to compare the previous sum and 
+//		Compare the previous sum and current num
+
+class Solution {
+    public int maxSubArray(int[] nums) {
+        int res = nums[0];
+        int[] currSum = new int[nums.length];
+        currSum[0] = nums[0];
+        for(int i = 1; i < nums.length; i++){
+            currSum[i] = Math.max(nums[i], nums[i] + currSum[i-1]); 
+            res = Math.max(currSum[i], res);
+        }
+        return res;
+    }
+}

Topic1_Arrays/Day2707/2707_Tuan/3_MajorityElement.txt

@@ -0,0 +1,17 @@
+// Time complexity: O(n)
+// Space complexity: O(n) 
+// Explanation: Using hash map to store frequency
+
+class Solution {
+    public int majorityElement(int[] nums) {
+        HashMap<Integer, Integer> hm = new HashMap<>();
+        int res = 0;
+        for(int num : nums){
+            hm.put(num, hm.getOrDefault(num, 0) + 1);
+            if(hm.get(num) > nums.length/2){
+                res = num;
+            }
+        }
+        return res;
+    }
+}

Topic2_LinkedList/LinkedList_HMTuan/1_ReverseLinkedList.txt

@@ -0,0 +1,30 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+    ListNode(int x, ListNode *next) : val(x), next(next) {}
+ };
+ */
+
+// Time Complexity: O(n)
+// Space Complexity: O(1)
+// Explanation: Using *temp to store the next pointer of head(head->next). 
+//              Because after that, the head->next will point to *rev pointer.
+// Expected: rev <- 1 <- 2 <- 3
+
+class Solution {
+public:
+    ListNode *reverseList(ListNode *head) {
+        ListNode *rev = nullptr;
+        while(head != nullptr){
+            ListNode *temp = head->next;
+            head->next = rev;
+            rev = head;
+            head = temp;
+        }
+        return rev;
+    }
+};

Topic2_LinkedList/LinkedList_HMTuan/2_Merge2SortedLists.txt

@@ -0,0 +1,47 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+
+// Time complexity: O(n+m)- n: size of list1, m: size of list2
+// Space complexity: O(1) - The algorithm merges the lists by rearranging the 'next' pointers of node. 
+//                          It does not create a new nodes -> no use additional data structure for storing nodes.
+// Explaination: Use a dummy node as starting point. 
+// 		 Then traverse 2 linked list and pick the smallest element to push back at each iterate.
+
+class Solution {
+public:
+    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
+        // Dummy node to act as the starting point
+        ListNode dummy;
+        ListNode *tail = &dummy;
+
+        // Traverse both lists
+        while (list1 != nullptr && list2 != nullptr) {
+            if (list1->val <= list2->val) {
+                tail->next = list1;
+                list1 = list1->next;
+            } else {
+                tail->next = list2;
+                list2 = list2->next;
+            }
+            tail = tail->next;
+        }
+
+        // Attach the remaining nodes
+        if (list1 != nullptr) {
+            tail->next = list1;
+        } else {
+            tail->next = list2;
+        }
+
+        // Return the merged list, starting from dummy.next
+        return dummy.next;
+    }
+};