leetcode 第 172 場周賽

很久沒寫題了

6 和 9 組成的最大數字

隨便寫的，不夠簡潔。

class Solution {
public:
    int maximum69Number (int num) {
        int nnum = 0;
        while(num){
            int temp = num % 10;
            nnum = nnum*10 + temp;
            num /= 10;
        }
        int new_num = 0, flag = 1;
        while(nnum){
            int temp = nnum % 10;
            if(temp==6 && flag){
                flag = 0;
                new_num = new_num*10 + 9;
            }else{
                new_num = new_num*10 + temp;
            }
            nnum /= 10;
        }
        return new_num;
    }
};

豎直打印單詞

class Solution {
    public List<String> printVertically(String s) {
        String [] arr = s.split("\\s+");
        
        int len = 0;
        for(String ss : arr){
            len = Math.max(len, ss.length());
        }
        
        List<String> list = new ArrayList<String>();
        
        for(int i=0; i<len; i++){
            String ad = "";
            for(String ss : arr){
                if(ss.length() >= i+1){
                    ad = ad + ss.charAt(i);
                }else ad = ad + " ";
            }
            int idx = 1000;
            for(int j=ad.length()-1; j>0; j--){
                if(ad.charAt(j) == ' '){
                    idx = Math.min(idx, j);  
                } else{
                    break;
                }
            }
            if(idx != 1000) ad = ad.substring(0, idx);
            list.add(ad);
        }
        
        
        return list;
    }
}

刪除給定值的葉子節點

不要被題面誤導了，雖然說了這樣一句話，重複此過程直到不能繼續刪除，但實際只需要一個後序遍歷就可以實現從葉子向根逐層刪除target葉節點。

/**
 * 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* DFS(TreeNode* root, int target) {
        if(root == NULL) return NULL;
        root -> left = DFS(root -> left, target);
        root -> right = DFS(root -> right, target);
        if(!root -> left && !root -> right && root -> val == target) {
            root = NULL;
        }
        return root;
    }
    TreeNode* removeLeafNodes(TreeNode* root, int target) {
        if(root == NULL) return NULL;
        return DFS(root, target);
    }
};

灌溉花園的最少水龍頭數目

就是貪心，經典區間覆蓋問題。

struct Node {
    int start;
    int end;
    Node() : start(0), end(0) {}
    Node(int s, int e) : start(s), end(e) {}
}node[10010];
bool cmp(Node& x , Node& y) {
    return x.start<y.start||(x.start==y.start&&x.end>y.end);
}

class Solution {
public:
    int minTaps(int n, vector<int>& ranges) {
        int len = ranges.size();
        for(int i = 0; i < len; i++) {
            node[i] = Node(max(0, i - ranges[i]), min(i + ranges[i], n));
        }
        sort(node, node + len, cmp);
        if(node[0].start > 0) return -1;
        
        int r = 0; // 左邊界最少要覆蓋的點
        int cnt = 0; 
        
        for(int i = 0; i < len; i++) {
            if(node[i].start - node[i].end == 0) continue;
            int ma = r, j, flag = 1;
            for(j = i; j < len; j++) {
                if(node[j].start <= r){
                    ma = max(ma, node[j].end);
                    flag = 0;
                } else {
                    j--;
                    break;
                }
            }
            if(flag) return -1;
            r = ma; i = j; cnt++;
            if(r == n) break;
        }
        if(r == n) return cnt;
	    else return -1;
    }
};