Leetcode刷题 2021.01.18

Leetcode1509 三次操作后最大值与最小值的最小差

给你一个数组 nums ，每次操作你可以选择 nums 中的任意一个元素并将它改成任意值。

请你返回三次操作后， nums 中最大值与最小值的差的最小值。

不太懂三次有什么特殊的含义，可能就像数据处理的时候删除掉几个异常值，使得留下来的数据间距较小。思路也是比较简单的，既然要删除三个，那删除的肯定是最小的三个或者最大的三个中的元素。直接的想法就是排序，然后算下几种情况的最小值就行了。另一种做法是在遍历的时候维护最大的四个数和最小的四个数。

class Solution {
    public int minDifference(int[] nums) {
        int n = nums.length;
        if (n <= 4) return 0;
        Arrays.sort(nums);
        int i = 3, j = nums.length - 1, min = Integer.MAX_VALUE;
        //不是删最小的就是删最大的
        for(int k = 0; k < 4; k++){
            min = Math.min(min, nums[j] - nums[i]);
            i--;
            j--;
        }
        return min;
    }

}

Leetcode1578 避免重复字母的最小删除成本

给你一个字符串 s 和一个整数数组 cost ，其中 cost[i] 是从 s 中删除字符 i 的代价。

返回使字符串任意相邻两个字母不相同的最小删除成本。

请注意，删除一个字符后，删除其他字符的成本不会改变。

这题也是比较常规的双指针了，既然不能相邻，就找连续的字母中代价最
大的那个就行了。比较基础。

class Solution {
    public int minCost(String s, int[] cost) {
        char[] arr = s.toCharArray();
        int i = 0, j = 0, res = 0;
        //双指针常规写法，注意边界
        while (j < arr.length){
            int max = i;
            //注意边界，找连续相同的字母，过程中保留cost最大的
            while (j < arr.length && arr[j] == arr[i]){
                if (cost[j] > cost[max]){
                    max = j;
                }
                j++;
            }
            //有连续相同字母的话
            if (i + 1 != j){
            	//除了最大代价的那个其他全部删掉
                for(int k = i; k < j; k++){
                    if (k != max){
                        res += cost[k];
                    }
                }
            }
            i = j;
        }

        return res;
    }
}

Leetcode721 账户合并

给定一个列表 accounts，每个元素 accounts[i] 是一个字符串列表，其中第一个元素 accounts[i][0] 是 名称 (name)，其余元素是 emails 表示该账户的邮箱地址。

现在，我们想合并这些账户。如果两个账户都有一些共同的邮箱地址，则两个账户必定属于同一个人。请注意，即使两个账户具有相同的名称，它们也可能属于不同的人，因为人们可能具有相同的名称。一个人最初可以拥有任意数量的账户，但其所有账户都具有相同的名称。

合并账户后，按以下格式返回账户：每个账户的第一个元素是名称，其余元素是按字符 ASCII 顺序排列的邮箱地址。账户本身可以以任意顺序返回。

知道是并查集题，但是编码想不出来，总觉得哪里不对。然后越想越复杂，最后就乱了。后面看了官方题解，没有注释想了半天，参考了题解中的一份代码，思路才理清楚了。维护一个map，key是邮箱，value是第几个accout。并查集合并的就是有相同邮箱的account。

class Solution {
    public List<List<String>> accountsMerge(List<List<String>> accounts) {
        List<List<String>> res = new ArrayList<>();
        int n = accounts.size();
        //维护map,key是邮箱，value是第几个accout
        Map<String, Integer> map = new HashMap<>();
        //并查集
        UninonFind uf = new UninonFind(n);

        for(int i = 0; i < n; i++){
            List<String> account = accounts.get(i);
            for(int j = 1; j < account.size(); j++){
                String temp = account.get(j);
                //如果存在相同的email,就合并两个account
                if (map.containsKey(temp)){
                    uf.union(i, map.get(temp));
                }
                map.put(temp, i);
            }
        }
        //处理输出，因为要排序，用TreeSet
        Map<Integer, TreeSet<String>> map2 = new HashMap<>();
        for(int i = 0; i < n; i++){
            int index = uf.find(i);
            List<String> account = accounts.get(i);
            List<String> email = account.subList(1,account.size());
            //相同的根的话，放到一起，email放到TreeSet里面
            if (map2.containsKey(index)){
                map2.get(index).addAll(email);
            }else{
                map2.put(index, new TreeSet<>(email));
            }
        }
		//处理输出
        for(Integer key : map2.keySet()){
            List<String> temp = new ArrayList<>();
            temp.add(accounts.get(key).get(0));
            TreeSet<String> val = map2.get(key);
            temp.addAll(val);
            res.add(temp);
        }


        return res;
    }

    class UninonFind{
        int[] parent;

        public UninonFind(int n){
            parent = new int[n];
            for(int i = 0; i < n; i++){
                parent[i] = i;
            }
        }

        public int find(int i){
            if (i == parent[i]){
                return parent[i];
            }
            return parent[i] = find(parent[i]);
        }

        public void union(int i, int j){
            int root1 = find(i);
            int root2 = find(j);
            if (root1 == root2) return;
            parent[root1] = root2;
        }
    }
}