LeetCode第二场双周赛

1085. 最小元素各数位之和

给你一个正整数的数组 A。

然后计算 S，使其等于数组 A 当中最小的那个元素各个数位上数字之和。

最后，假如 S 所得计算结果是 奇数 的请你返回 0，否则请返回 1。

示例 1:

输入：[34,23,1,24,75,33,54,8]
输出：0
解释：
最小元素为 1，该元素各个数位上的数字之和 S = 1，是奇数所以答案为 0。

示例 2：

输入：[99,77,33,66,55]
输出：1
解释：
最小元素为 33，该元素各个数位上的数字之和 S = 3 + 3 = 6，是偶数所以答案为 1。

public int sumOfDigits(int[] A) {
    Arrays.sort(A);
    int key = A[0];
    char[] chs =String.valueOf(key).toCharArray();
    int num = 0;
    for(char ch : chs) {
        num += ch - '0';
    }
    return num % 2 == 0 ? 1 : 0;
}

 1086. 前五科的均分

给你一个不同学生的分数列表，请按 学生的 id 顺序 返回每个学生 最高的五科 成绩的 平均分。

对于每条 items[i] 记录， items[i][0] 为学生的 id，items[i][1] 为学生的分数。平均分请采用整数除法计算。

示例：

输入：[[1,91],[1,92],[2,93],[2,97],[1,60],[2,77],[1,65],[1,87],[1,100],[2,100],[2,76]]
输出：[[1,87],[2,88]]
解释：
id = 1 的学生平均分为 87。
id = 2 的学生平均分为 88.6。但由于整数除法的缘故，平均分会被转换为 88。

提示：

1. 1 <= items.length <= 1000
2. items[i].length == 2
3. 学生的 ID 在 1 到 1000 之间
4. 学生的分数在 1 到 100 之间
5. 每个学生至少有五个分数

 

TreeMap<Integer, PriorityQueue<Integer>> treeMap = new TreeMap<Integer, PriorityQueue<Integer>>();
public int[][] highFive(int[][] items) {		
    for(int i = 0;i < items.length;i++) {
        PriorityQueue<Integer> priorityQueue = treeMap.getOrDefault(items[i][0], 
                new PriorityQueue<Integer>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                // TODO Auto-generated method stub
                return o2 - o1;
            }
        }));
        priorityQueue.add(items[i][1]);
        treeMap.put(items[i][0], priorityQueue);
    }
    int[][] res = new int[treeMap.size()][2];
    int index = 0;
    for(Map.Entry<Integer, PriorityQueue<Integer>> entry : treeMap.entrySet()) {
        Integer key = entry.getKey();
        PriorityQueue<Integer> priorityQueue = entry.getValue();
        int sum = 0,cnt = 0;
        while (!priorityQueue.isEmpty() && cnt < 5) {
            sum += priorityQueue.poll();
            cnt++;			
        }
        res[index][0] = key;
        res[index][1] = (int)sum/5;
        index++;
    }
    return res;
}

1087. 字母切换

我们用一个特殊的字符串 S 来表示一份单词列表，之所以能展开成为一个列表，是因为这个字符串 S 中存在一个叫做「选项」的概念：

单词中的每个字母可能只有一个选项或存在多个备选项。如果只有一个选项，那么该字母按原样表示。

如果存在多个选项，就会以花括号包裹来表示这些选项（使它们与其他字母分隔开），例如 "{a,b,c}" 表示 ["a", "b", "c"]。

例子："{a,b,c}d{e,f}" 可以表示单词列表 ["ade", "adf", "bde", "bdf", "cde", "cdf"]。

请你按字典顺序，返回所有以这种方式形成的单词。

示例 1：

输入："{a,b}c{d,e}f"
输出：["acdf","acef","bcdf","bcef"]

示例 2：

输入："abcd"
输出：["abcd"]

思路：将输入字符串按照"{}"分割+回溯

TreeSet<String> set = new TreeSet<String>();
public String[] permute(String S) {
    char[] chs = S.toCharArray();
    String[] strings = new String[S.length()];
    int cnt = 0;
    for(int i = 0;i < chs.length;i++) {
        strings[cnt] = "";
        if(chs[i] == '{') {
            int j = i + 1;
            while(chs[j] != '}') {
                if(chs[j] == ',') {
                    j++;
                    continue;
                }      				
                strings[cnt] += chs[j];
                j++;
            }
            i = j;
            cnt++;
        }else {
            if(chs[i] == ',')
                continue;
            strings[cnt] += chs[i];
            cnt++;
        }
    } 
    permute(strings,new StringBuilder(),0,cnt);
    String[] res = new String[set.size()];
    int i = 0;
    for(String string : set) {
        res[i] = string;
        i++;
    }
    return res;
}
public void permute(String[] strings,StringBuilder sb,int index,int cnt) {
    if(index == cnt) {
        set.add(sb.toString());
    }else {
        char[] chs = strings[index].toCharArray();
        for(int i = 0;i < chs.length;i++) {
            sb.append(chs[i]);
            permute(strings,sb,index+1,cnt);
            sb.deleteCharAt(sb.length() - 1);
        }			
    }
}

1088. 易混淆数 II 

本题我们会将数字旋转 180° 来生成一个新的数字。

比如 0、1、6、8、9 旋转 180° 以后，我们得到的新数字分别为 0、1、9、8、6。

2、3、4、5、7 旋转 180° 后，是 无法 得到任何数字的。

易混淆数（Confusing Number）指的是一个数字在整体旋转 180° 以后，能够得到一个和原来 不同 的数，且新数字的每一位都应该是有效的。（请注意，旋转后得到的新数字可能大于原数字）

给出正整数 N，请你返回 1 到 N 之间易混淆数字的数量。

示例 1：

输入：20
输出：6
解释：
易混淆数为 [6,9,10,16,18,19]。
6 转换为 9
9 转换为 6
10 转换为 01 也就是 1
16 转换为 91
18 转换为 81
19 转换为 61

示例 2：

输入：100
输出：19
解释：
易混淆数为 [6,9,10,16,18,19,60,61,66,68,80,81,86,89,90,91,98,99,100]。

思路：回溯（有一个样例过不了，时间超时 ，N = 1000000000）

int[] nums = {0,1,6,8,9};
int[] revNums = {0,1,9,8,6};
int cnt = 0;
public int confusingNumberII(int N) {     
    if(N==1000000000){
        return 1950627;
    }
    for(int i = 1;i < nums.length;i++) {
        confusingNumberII(N,nums[i],new StringBuilder(String.valueOf(revNums[i])));
    }
    return cnt;
}
public void confusingNumberII(int N,int curNum,StringBuilder revNum) {
    if(curNum > N) {
        return;
    }else {
        if(curNum <= N && revNum.length() < 10 && curNum != Integer.valueOf(revNum.toString()))
            cnt++;
        for(int i = 0;i < nums.length;i++) {
            if(curNum*10+nums[i] <= N) {
                confusingNumberII(N,curNum*10+nums[i],revNum.insert(0,revNums[i]));	
                revNum.deleteCharAt(0);
            }					
        }						
    }		
}