2020/01/19

Author: wr786

C++/5315 Maximum 69 Number.cpp

@@ -0,0 +1,26 @@
+class Solution {
+public:
+    int maximum69Number (int num) {
+        int *d = new int[6];
+        d[1] = num / 10000;
+        d[2] = (num/1000) % 10;
+        d[3] = (num/100) % 10;
+        d[4] = (num/10) % 10;
+        d[5] = num % 10;
+        int start;
+        for(start=1; start<=5; start++) {
+            if(d[start] != 0) break;
+        }
+        int ret = 0; bool flag = true;
+        for(int i=start; i<=5; i++) {
+            if(flag) {
+                if(d[i] == 6) {
+                    flag = false;
+                    d[i] = 9;
+                }
+            }
+            ret = ret * 10 + d[i];
+        }
+        return ret;
+    }
+};

C++/5317 Delete Leaves With a Given Value.cpp

@@ -0,0 +1,21 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode* removeLeafNodes(TreeNode* root, int target) {
+        if(root->left != NULL) root->left = removeLeafNodes(root->left, target);
+        if(root->right != NULL) root->right = removeLeafNodes(root->right, target);
+        if(root->left == NULL && root->right == NULL) { // 叶子节点
+            if(root->val == target) return NULL;
+            else return root;
+        }
+        return root;
+    }
+};

C++/5318 Minimum Number of Taps to Open to Water a Garden.cpp

@@ -0,0 +1,36 @@
+class Solution {
+private:
+    struct Interval {
+        int left;
+        int right;
+    } itv[10001];
+    static bool cmp (Interval A, Interval B) {
+        if(A.left != B.left) return A.left < B.left;
+        else return A.right < B.right;
+    }
+public:
+    int minTaps(int n, vector<int>& ranges) {
+        for(int i=0; i<=n; i++) {
+            itv[i].left = max(0, i-ranges[i]);
+            itv[i].right = min(n, i+ranges[i]);
+        }
+        sort(itv, itv+n+1, cmp);
+        int leftmost = 0, cnt = 0, rightmost = 0;
+        for(int i=0; i<=n; i++) {
+            if(leftmost >= itv[i].left) {
+                rightmost = max(rightmost, itv[i].right);
+            } else { // 这一处超了
+                if(rightmost > leftmost) {
+                    leftmost = rightmost;
+                    rightmost = 0;
+                    cnt++;
+                    i--;
+                } else {
+                    return -1;
+                }
+            }
+        }
+        if(rightmost > leftmost) cnt++;
+        return cnt;
+    }
+};

Rust/5316 Print Words Vertically.rs

@@ -0,0 +1,32 @@
+impl Solution {
+    pub fn print_vertically(s: String) -> Vec<String> {
+        let mut ret : Vec<String> = Vec::new();
+        let mut maxlen = 0;
+        for word in s.split_whitespace() {
+            if word.len() > maxlen {
+                maxlen = word.len();
+            }
+        }
+        for i in 0..maxlen {
+            let mut curcol = String::new();
+            for word in s.split_whitespace() {
+                if(word.len() > i) {
+                    curcol.push_str(&word[i..i+1]);
+                } else {
+                    curcol = curcol + " ";  
+                }
+            }
+            let len = curcol.len();
+            let mut cnt = 0;
+            for ch in curcol.chars().rev() {
+                if(ch != ' ') {
+                    break;
+                }
+                cnt = cnt + 1;
+            }
+            curcol = curcol[0..len-cnt].to_string();
+            ret.push(curcol);
+        }
+        return ret;
+    }
+}