update

Author: OneCodeMonkey

Diff for: contest/leetcode_week_251/leetcode_1945_sum_of_digits_of_string_after_convert.java

@@ -0,0 +1,31 @@
+// AC
+class Solution {
+    public int getLucky(String s, int k) {
+        int sumDigit = 0;
+        for (char c: s.toCharArray()) {
+            int temp = c - 'a' + 1;
+            if (temp < 10) {
+                sumDigit += temp;
+            } else {
+                sumDigit += (temp / 10) + (temp % 10);
+            }
+        }
+
+        int tranSumDigit = sumDigit;
+        if (k > 1) {
+            for (int i = 1; i < k; i++) {
+                int copy = tranSumDigit;
+                tranSumDigit = 0;
+                while (copy > 0) {
+                    tranSumDigit += copy % 10;
+                    copy /= 10;
+                }
+                if (tranSumDigit < 10) {
+                    break;
+                }
+            }
+        }
+
+        return tranSumDigit;
+    }
+}

Diff for: contest/leetcode_week_251/leetcode_1946_Largest_Number_After_Mutating_Substring.java

@@ -0,0 +1,25 @@
+// AC
+class Solution {
+    public String maximumNumber(String num, int[] change) {
+        int size = num.length();
+        StringBuilder ret = new StringBuilder();
+        boolean started = false, stopped = false, everChanged = false;
+        for (int i = 0; i < size; i++) {
+            int digit = Integer.parseInt(String.valueOf(num.charAt(i)));
+            if (change[digit] >= digit && !stopped) {
+                started = true;
+                ret.append(change[digit]);
+                if (change[digit] > digit) {
+                    everChanged = true;
+                }
+            } else {
+                ret.append(digit);
+                if (started && everChanged) {
+                    stopped = true;
+                }
+            }
+        }
+
+        return ret.toString();
+    }
+}

Diff for: leetcode_solved/[editing]leetcode_0077_Combinations.cpp

@@ -0,0 +1,29 @@
+// AC: Runtime: 18 ms, faster than 62.24% of Java online submissions for Combinations.
+// Memory Usage: 53.6 MB, less than 5.33% of Java online submissions for Combinations.
+// backtracking.
+// T:O(C(n, k)), S:O(C(n, k) * k)
+//
+class Solution {
+    public List<List<Integer>> combine(int n, int k) {
+        List<List<Integer>> ret = new LinkedList<>();
+        List<Integer> temp = new LinkedList<>();
+
+        backtracking(n, k, temp, ret, 1);
+
+        return ret;
+    }
+
+    public void backtracking(int n, int k, List<Integer> path, List<List<Integer>> out, int startIndex) {
+        List<Integer> pathCopy = new LinkedList<>(path);
+        if (path.size() == k) {
+            out.add(pathCopy);
+            return;
+        }
+
+        for (int i = startIndex; i <= n + pathCopy.size() - k + 1; i++) {
+            pathCopy.add(i);
+            backtracking(n, k, pathCopy, out, i + 1);
+            pathCopy.remove(pathCopy.size() - 1);
+        }
+    }
+}

Diff for: leetcode_solved/[editing]leetcode_0131_Palindrome_Partitioning.cpp

@@ -0,0 +1,26 @@
+// AC: Runtime: 1 ms, faster than 58.25% of Java online submissions for Subsets.
+// Memory Usage: 39.4 MB, less than 45.07% of Java online submissions for Subsets.
+// backtracking
+// T:O(2^n), S:O(n * 2^n)
+// 
+class Solution {
+    public List<List<Integer>> subsets(int[] nums) {
+        List<List<Integer>> ret = new LinkedList<>();
+        backtracking(nums, new LinkedList<>(), ret, 0);
+
+        return ret;
+    }
+
+    private void backtracking(int[] nums, List<Integer> path, List<List<Integer>> out, int startIndex) {
+        List<Integer> pathCopy = new LinkedList<>(path);
+        out.add(pathCopy);
+        if (startIndex >= nums.length) {
+            return;
+        }
+        for (int i = startIndex; i < nums.length; i++) {
+            pathCopy.add(nums[i]);
+            backtracking(nums, pathCopy, out, i + 1);
+            pathCopy.remove(pathCopy.size() - 1);
+        }
+    }
+}

Diff for: leetcode_solved/[editing]leetcode_0151_Reverse_Words_in_a_String.cpp

@@ -0,0 +1,43 @@
+// AC: Runtime: 16 ms, faster than 22.78% of Java online submissions for Palindrome Partitioning.
+// Memory Usage: 63.3 MB, less than 22.41% of Java online submissions for Palindrome Partitioning.
+// backtracking
+// T:O(2^(n - 1), S:O(n * 2^(n - 1))
+// 
+class Solution {
+    public List<List<String>> partition(String s) {
+        List<List<String>> ret = new LinkedList<>();
+        backtracking(s, 0, new LinkedList<>(), ret, 0);
+
+        return ret;
+    }
+
+    private void backtracking(String s, int curLen, List<String> path, List<List<String>> out, int startIndex) {
+        List<String> pathCopy = new LinkedList<>(path);
+        if (curLen >= s.length()) {
+            out.add(pathCopy);
+            return;
+        }
+
+        for (int i = startIndex; i < s.length(); i++) {
+            if (isPalindrome(s.substring(startIndex, i + 1))) {
+                pathCopy.add(s.substring(startIndex, i + 1));
+                curLen += i - startIndex + 1;
+                backtracking(s, curLen, pathCopy, out, i + 1);
+                curLen -= i - startIndex + 1;
+                pathCopy.remove(pathCopy.size() - 1);
+            } else {
+                continue;
+            }
+        }
+    }
+
+    private boolean isPalindrome(String str) {
+        for (int i = 0, j = str.length() - 1; i < j; i++, j--) {
+            if (str.charAt(i) != str.charAt(j)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

Diff for: leetcode_solved/[editing]leetcode_0216_Combination_Sum_III.cpp

@@ -0,0 +1,26 @@
+// AC: Runtime: 4 ms, faster than 84.91% of Java online submissions for Reverse Words in a String.
+// Memory Usage: 38.7 MB, less than 97.68% of Java online submissions for Reverse Words in a String.
+// split by single space, judge if every part is empty string, record non-empty substrings, and combine substrings reverse.
+// T:O(n), S:O(n)
+// 
+class Solution {
+    public String reverseWords(String s) {
+        List<String> words = new ArrayList<>();
+        String[] arr = s.split(" ");
+        for (String item: arr) {
+            if (!"".equals(item)) {
+                words.add(item);
+            }
+        }
+        StringBuilder ret = new StringBuilder();
+        int size = words.size();
+        for (int i = size - 1; i >= 0; i--) {
+            ret.append(words.get(i));
+            if (i != 0) {
+                ret.append(" ");
+            }
+        }
+
+        return ret.toString();
+    }
+}

Diff for: leetcode_solved/[editing]leetcode_0328_Odd_Even_Linked_List.cpp

@@ -0,0 +1,33 @@
+// AC: Runtime: 1 ms, faster than 28.80% of Java online submissions for Combination Sum III.
+// Memory Usage: 36.9 MB, less than 30.36% of Java online submissions for Combination Sum III.
+// backtracking
+// T:O(C(n, k)), S:O(k)
+// 
+class Solution {
+    public List<List<Integer>> combinationSum3(int k, int n) {
+        List<List<Integer>> ret = new LinkedList<>();
+        int sum = 0;
+        backtracking(sum, n, k, new LinkedList<>(), ret, 1);
+        return ret;
+    }
+
+    private void backtracking(int curSum, int n, int k, List<Integer> path, List<List<Integer>> out, int startIndex) {
+        if (curSum > n) {
+            return;
+        }
+        List<Integer> pathCopy = new LinkedList<>(path);
+        if (path.size() == k) {
+            if (curSum == n) {
+                out.add(pathCopy);
+            }
+            return;
+        }
+        for (int i = startIndex; i <= 9 + pathCopy.size() - k + 1; i++) {
+            curSum += i;
+            pathCopy.add(i);
+            backtracking(curSum, n, k, pathCopy, out, i + 1);
+            curSum -= i;
+            pathCopy.remove(pathCopy.size() - 1);
+        }
+    }
+}

Diff for: leetcode_solved/[editing]leetcode_0386_Lexicographical_Numbers.cpp

@@ -0,0 +1,31 @@
+// AC: Runtime: 0 ms, faster than 100.00% of Java online submissions for Odd Even Linked List.
+// Memory Usage: 38.6 MB, less than 60.27% of Java online submissions for Odd Even Linked List.
+// divide the original linked-list into odd-list and even-list, and concat even-list to end of odd-list.
+// T:O(n), S:O(1)
+// 
+class Solution {
+    public ListNode oddEvenList(ListNode head) {
+        if (head != null) {
+            ListNode odd = head, even = head.next, oddHead = odd, evenHead = even;
+            while (even != null && even.next != null) {
+                odd.next = odd.next.next;
+                even.next = even.next.next;
+                odd = odd.next;
+                even = even.next;
+            }
+            odd.next = evenHead;
+        }
+
+        return head;
+    }
+}
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */