算法刷题记录(LeetCode 721-750)

*721. Accounts Merge

Union Find

class Solution {
    public static class UnionFind {
        int size;
        int[] parent;

        public UnionFind(int size) {
            this.size = size;
            this.parent = new int[size];
            for (int i = 1; i < size; i++) {
                parent[i] = i;
            }
        }

        public int find(int a) {
            //路径压缩
            if (parent[a] != a) {
                parent[a] = find(parent[a]);
            }
            return parent[a];
        }

        public void merge(int a, int b) {
            parent[find(a)] = find(b);
        }

        ;

    }

    public List<List<String>> accountsMerge(List<List<String>> accounts) {
        // 作用：存储每个邮箱属于哪个账户 ，同时 在遍历邮箱时，判断邮箱是否出现过[去重]
        // 格式：<邮箱，账户id>
        HashMap<String, Integer> mapper = new HashMap<>();
        UnionFind unionFind = new UnionFind(accounts.size());
        for (int i = 0; i < accounts.size(); i++) {
            for (int j = 1; j < accounts.get(i).size(); j++) {
                var currStr = accounts.get(i).get(j);
                if (mapper.containsKey(currStr)) {
                    unionFind.merge(i, mapper.get(currStr));
                } else {
                    mapper.put(currStr, i);
                }
            }
        }
        //进行完上面的步骤，同一个用户的所有邮箱已经属于同一个连通域了，但是就算在同一个连通域，不同的邮箱还是可能会对应不同的id
        // 作用： 存储每个账户下的邮箱
        // 格式： <账户id, 邮箱列表> >
        // 注意：这里的key必须是账户id，不能是账户名称，名称可能相同，会造成覆盖
        Map<Integer, List<String>> idToEmails = new HashMap<>();
        //将同一个连通域内的邮箱对应到同一个id【也就是第一次出现的id，比如4、5在同一个连通域，那么这个连通域对应的id就是4】
        for(Map.Entry<String, Integer> entry : mapper.entrySet()){
            int id = unionFind.find(entry.getValue());
            List<String> emails = idToEmails.getOrDefault(id, new ArrayList<>());
            emails.add(entry.getKey());
            idToEmails.put(id,emails);
        }
        //经过上面的步骤，已经做到了id和邮箱集合对应起来，接下来把用户名对应起来就可以了
        List<List<String>> res = new ArrayList<>();
        for(Map.Entry<Integer, List<String>> entry : idToEmails.entrySet()){
            List<String> emails = entry.getValue();
            Collections.sort(emails);
            List<String> tmp = new ArrayList<>();
            tmp.add(accounts.get(entry.getKey()).get(0));//先添加用户名
            tmp.addAll(emails);
            res.add(tmp);
        }
        return res;
    }
}

724. Find Pivot Index

    int pivotIndex(vector<int> &nums) {
            int sum = std::accumulate(nums.begin() + 1, nums.end(), 0);
            for (int i = 0; i < nums.size() - 1; ++i) {
                if (sum == 0) {
                    return i;
                }
                sum -= (nums[i] + nums[i + 1]);
            }
            return sum==0?nums.size()-1:-1;
    }

725. Split Linked List in Parts

class Solution {
public:
    vector<ListNode*> splitListToParts(ListNode* head, int k) {
        int length= getLength(head);
        int baseLength=length/k;
        int residual=length%k;
        auto* curr=head;
        vector<ListNode*> ans;
        for (int i = 0; i < residual; ++i) {
            ans.push_back(curr);
            for (int j = 0; j < baseLength; ++j) {
                curr=curr->next;
            }
            auto* end=curr;
            curr=end->next;
            end->next= nullptr;
        }
        if (baseLength==0){
            for (int i = residual; i < k; ++i) {
                ans.push_back(nullptr);
            }
            return ans;
        }
        for (int i = residual; i < k; ++i) {
            ans.push_back(curr);
            for (int j = 0; j < baseLength-1; ++j) {
                curr=curr->next;
            }
            auto* end=curr;
            curr=end->next;
            end->next= nullptr;
        }
        return ans;
    }
    int getLength(ListNode* head){
        int length=0;
        auto* curr=head;
        while(curr){
            length++;
            curr=curr->next;
        }
        return length;
    }
};

*726. Number of Atoms

使用多层hashmap

class Solution {
    public String countOfAtoms(String _formula) {
        char[] formula = _formula.toCharArray();
        int length = formula.length;
        Deque<TreeMap<String, Integer>> deque = new LinkedList<>();
        deque.addLast(new TreeMap<>());
        for (int i = 0; i < length; i++) {
            if (formula[i] == '(') {
                deque.addLast(new TreeMap<>());
            } else if (formula[i] == ')') {
                i++;
                int j = i + 1;
                int val=1;
                if (i < length && Character.isDigit(formula[i])) {
                    while (j < length && Character.isDigit(formula[j])) {
                        j++;
                    }
                    val = Integer.parseInt(String.valueOf(formula, i, j - i));
                    i=j-1;
                }
                else{
                    i--;
                }
                var currMap = deque.pollLast();
                var deeperMap = deque.peekLast();
                for (var key : currMap.keySet()) {
                    if (!deeperMap.containsKey(key)) {
                        deeperMap.put(key, currMap.get(key)*val);
                    } else deeperMap.merge(key, currMap.get(key) * val, Integer::sum);
                }
            } else {
                int j = i + 1;
                while (j < length && Character.isLetter(formula[j]) && Character.isLowerCase(formula[j])) {
                    j++;
                }
                String element = String.valueOf(formula, i, j - i);
                i = j;
                j = i + 1;
                int val = 1;
                if (i < length && Character.isDigit(formula[i])) {
                    while (j < length && Character.isDigit(formula[j])) {
                        j++;
                    }
                    val = Integer.parseInt(String.valueOf(formula, i, j - i));
                    i=j-1;
                }
                else{
                    i--;
                }
                var map = deque.getLast();
                if (!map.containsKey(element)) {
                    map.put(element, val);
                } else {
                    map.merge(element, val, Integer::sum);
                }
            }
        }
        StringBuilder res = new StringBuilder();
        var map=deque.getLast();
        for (var key : map.keySet()) {
            res.append(key);
            if (map.get(key)>1){
                res.append(map.get(key));
            }
        }
        return res.toString();
    }
}

728. Self Dividing Numbers

    vector<int> selfDividingNumbers(int left, int right) {
        vector<int>ans;
        for (int i = left; i <=right ; ++i) {
            int val=i;
            bool remove=false;
            while (val>0){
                int residual=val%10;
                if (residual==0){
                    remove= true;
                    break;
                }
                if (i%residual!=0){
                    remove= true;
                    break;
                }
                val/=10;
            }
            if (!remove){
                ans.push_back(i);
            }
        }
        return ans;
    }

**729. My Calendar I

Tree Map

class MyCalendar {

    TreeMap<Integer,Integer> map=new TreeMap<>();
    public MyCalendar() {

    }

    public boolean book(int start, int end) {
        Integer pre=map.floorKey(start);
        if (pre!=null&&pre==2&&pre==start){
            return false;
        }
        if (pre!=null&&(map.get(pre)==1)){
            return false;
        }
        Integer after=map.ceilingKey(start);
        if (after!=null&&after<end){
            return false;
        }
        if (start==end-1){
            map.put(start,2);
        }
        else{
            map.put(start,1);
            map.put(end-1,-1);
        }
        return true;
    }
}

733. Flood Fill

class Solution {
public:
    int src_color;
    int color;
    vector<vector<int>> image;
    vector<vector<int>> directions={{0,1},{0,-1},{1,0},{-1,0}};
    vector<vector<int>> floodFill(vector<vector<int>>& _image, int sr, int sc, int _color) {
        image=_image;
        src_color=image[sr][sc];
        color=_color;
        if (src_color==color){
            return image;
        }
        dfs(sr,sc);
        return image;
    }
    void dfs(int row,int column){
        if (row<0||row>=image.size()||column<0||column>=image[0].size()){
            return ;
        }
        if (image[row][column]==src_color){
            for (auto d:directions) {
                int new_row=row+d[0];
                int new_column=column+d[1];
                image[row][column]=color;
                dfs(new_row,new_column);
            }
        }

    }
};

735. Asteroid Collision

class Solution {
    public int[] asteroidCollision(int[] asteroids) {
        Deque<Integer> deque=new LinkedList<>();
        deque.push(asteroids[0]);
        for (int i=1;i<asteroids.length;i++){
            if (deque.isEmpty()){
                deque.addLast(asteroids[i]);
                continue;
            }
            if ((deque.peekLast()^asteroids[i])>0||deque.peekLast()<0){
                deque.addLast(asteroids[i]);
                continue;
            }
            while (!deque.isEmpty()&&deque.peekLast()>0&&asteroids[i]<0&&Math.abs(deque.peekLast())<Math.abs(asteroids[i])){
                deque.pollLast();
            }
            if (deque.isEmpty()){
                deque.addLast(asteroids[i]);
                continue;
            }
            if (deque.peekLast()>0&&asteroids[i]<0){
                if (Math.abs(deque.peekLast())==Math.abs(asteroids[i])){
                    deque.pollLast();
                }
            }
            else{
                deque.addLast(asteroids[i]);
            }
        }
        return deque.stream().mapToInt(i->i).toArray();
    }
}

738. Monotone Increasing Digits

    public int monotoneIncreasingDigits(int n) {
        char[] org=String.valueOf(n).toCharArray();
        int curr_digit=0;
        for (int i=0;i<org.length-1;i++){
            if (org[i]>org[i+1]){
                org[curr_digit]--;
                for (int j=curr_digit+1;j<org.length;j++){
                    org[j]='9';
                }
                return Integer.parseInt(String.valueOf(org));
            }
            else if (org[i]==org[i+1]){
                continue;
            }else{
                curr_digit=i+1;
            }
        }
        return n;
    }

** 743. Network Delay Time

Dijkstra Algo

    int networkDelayTime(vector<vector<int>>& times, int n, int k) {
        static int MIN_VAL=0x3f3f3f3f;
        vector<vector<pair<int,int>>> adjacent_matrix(n+1);
        for (auto vec:times) {
            adjacent_matrix[vec[0]].emplace_back(make_pair(vec[1],vec[2]));
        }
        vector<int> delay(n+1,MIN_VAL);
        delay[k]=0;
        for (int i = 1; i <= n; ++i) {
            int x=-1;
            for (int j = 1; j <= n; ++j) {
                if (!adjacent_matrix[j].empty()&&(x==-1||delay[j]<delay[x])){
                    x=j;
                }
            }
            if (x==-1){
                break;
            }
            for (auto val:adjacent_matrix[x]) {
                delay[val.first]= min(delay[val.first],delay[x]+val.second);
            }
            adjacent_matrix[x].clear();
        }
        int max_delay=delay[1];
        for (int i = 2; i < delay.size(); ++i) {
            max_delay= max(max_delay,delay[i]);
        }
        if (max_delay==MIN_VAL){
            return -1;
        }
        return max_delay;
    }

744. Find Smallest Letter Greater Than Target

    char nextGreatestLetter(vector<char>& letters, char target) {
        int left=0;
        int right=letters.size()-1;
        while(left<right){
            int mid=(left+right)/2;
            if (letters[mid]<=target){
                left=mid+1;
            }
            else{
                right=mid;
            }
        }
        return letters[left]>target?letters[left]:letters[0];
    }

747. Largest Number At Least Twice of Others

    int dominantIndex(vector<int>& nums) {
        int biggest=0;
        int second_biggest=0;
        int idx=-1;
        int second_idx=-1;
        for(int i=0;i<nums.size();i++){
            int val=nums[i];
            if (val>biggest){
                second_biggest=biggest;
                biggest=val;
                second_idx=idx;
                idx=i;

            }
            else if (val>second_biggest){
                second_biggest=val;
                second_idx=i;
            }
        }
        return second_biggest*2<=biggest?idx:-1;
    }

748. Shortest Completing Word

class Solution {
    public String shortestCompletingWord(String licensePlate, String[] words) {
        HashMap<Character,Integer> alphabet=new HashMap<>();
        for (var ch:licensePlate.toCharArray()){
            if (Character.isLetter(ch)){
                if (Character.isUpperCase(ch)){
                    alphabet.merge((char) (ch+32),1,Integer::sum);
                }
                else{
                    alphabet.merge(ch,1,Integer::sum);
                }
            }
        }
        String answer=new String(new char[101]);
        continue2: for (var str:words){
            char[] currCount=new char[26];
            for (var ch:str.toCharArray()){
                currCount[ch-'a']++;
            }
            for (var key: alphabet.keySet()){
                if (alphabet.get(key)>currCount[key-'a']){
                    continue continue2;
                }
            }
            if (str.length()<answer.length()){
                answer=str;
            }

        }
        return answer;
    }
}