LeetCode第175场周赛

1346. 检查整数及其两倍数是否存在

给你一个整数数组 arr，请你检查是否存在两个整数 N 和 M，满足 N 是 M 的两倍（即，N = 2 * M）。

更正式地，检查是否存在两个下标 i 和 j 满足：

• i != j
• 0 <= i, j < arr.length
• arr[i] == 2 * arr[j]

示例 1：

输入：arr = [10,2,5,3]
输出：true
解释：N = 10 是 M = 5 的两倍，即 10 = 2 * 5 。

public class Solution {
    public boolean checkIfExist(int[] arr) {
        int len = arr.length;
        for (int j = 1; j < len; j++) {
            for (int i = 0; i < j; i++) {
                if (arr[j] == 2 * arr[i] || arr[i] == 2 * arr[j]) {
                    return true;
                }
            }
        }
        return false;
    }
}

 

1347. 制造字母异位词的最小步骤数

难度中等5收藏分享切换为英文关注反馈

给你两个长度相等的字符串 s 和 t。每一个步骤中，你可以选择将 t 中的 任一字符 替换为 另一个字符。

返回使 t 成为 s 的字母异位词的最小步骤数。

字母异位词 指字母相同，但排列不同的字符串。

示例 1：

输出：s = "bab", t = "aba"
输出：1
提示：用 'b' 替换 t 中的第一个 'a'，t = "bba" 是 s 的一个字母异位词。


示例 2：

输出：s = "leetcode", t = "practice"
输出：5
提示：用合适的字符替换 t 中的 'p', 'r', 'a', 'i' 和 'c'，使 t 变成 s 的字母异位词。

        这道题我一开始犯了一个巨大的错误，首先这道题的题意很简单，首先想到的做法就是直接利用数据结构进行处理。结果我也不知道是那个弦出了问题，竟然用Set去做……

    public int minSteps(String s, String t) {
        if (s.equals(t)) {
            return 0;
        }
        Set<Character> set = new HashSet<>();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            set.add(c);
        }
        for (int j = 0; j < t.length(); j++) {
            char c = t.charAt(j);
            if (set.contains(c)) {  //不能用Set，无法存储相同的元素
                set.remove(c);
            }
        }
        if (set.size() == 0) {
            return 1;
        }
        return set.size();
    }

        正确的解法，使用两个数组分别记录两个字符串中的字符数量，然后分情况进行统计。

class Solution {
    public int minSteps(String s, String t) {
        int step = 0;
        int[] counterS = new int[26];
        int[] counterT = new int[26];
        for (int i = 0; i < s.length(); i++) {
            counterS[s.charAt(i) - 'a']++;  //统计s中每种字符出现的频率
            counterT[t.charAt(i) - 'a']++;    //统计t中每种字符出现的频率
        }
        // s有，t没有或者s的比t的多，t就要替换
        for (int i = 0; i < 26; i++) {
            if (counterS[i] == 0) {
                step += counterT[i];  //替换s没有的字母
            } else if (counterT[i] > counterS[i]) {
                step += counterT[i] - counterS[i];    //替换多余的部分
            }
        }
        return step;
    }
}

 

1348. 推文计数

请你实现一个能够支持以下两种方法的推文计数类 TweetCounts：

1. recordTweet(string tweetName, int time)

• 记录推文发布情况：用户 tweetName 在 time（以 秒 为单位）时刻发布了一条推文。

2. getTweetCountsPerFrequency(string freq, string tweetName, int startTime, int endTime)

• 返回从开始时间 startTime（以 秒 为单位）到结束时间 endTime（以 秒 为单位）内，每 分 minute，时 hour 或者 日 day （取决于 freq）内指定用户 tweetName 发布的推文总数。
• freq 的值始终为 分 minute，时 hour 或者 日 day 之一，表示获取指定用户 tweetName 发布推文次数的时间间隔。
• 第一个时间间隔始终从 startTime 开始，因此时间间隔为 [startTime, startTime + delta*1>,  [startTime + delta*1, startTime + delta*2>, [startTime + delta*2, startTime + delta*3>, ... , [startTime + delta*i, min(startTime + delta*(i+1), endTime + 1)>，其中 i 和 delta（取决于 freq）都是非负整数。

示例：

输入：
["TweetCounts","recordTweet","recordTweet","recordTweet","getTweetCountsPerFrequency","getTweetCountsPerFrequency","recordTweet","getTweetCountsPerFrequency"]
[[],["tweet3",0],["tweet3",60],["tweet3",10],["minute","tweet3",0,59],["minute","tweet3",0,60],["tweet3",120],["hour","tweet3",0,210]]

输出：
[null,null,null,null,[2],[2,1],null,[4]]

        难点在于题意的理解，可使用TreeMap存储数据。

class TweetCounts {
    Map<String, TreeMap<Integer, Integer>> map;
    
    public TweetCounts() {
        map = new HashMap<>();
    }

    public void recordTweet(String tweetName, int time) {
        if(!map.containsKey(tweetName)) {
            map.put(tweetName, new TreeMap<>());
        }
        TreeMap<Integer, Integer> count = map.get(tweetName);
        count.put(time, count.getOrDefault(time, 0) + 1);
    }

    public List<Integer> getTweetCountsPerFrequency(String freq, String tweetName, int startTime, int endTime) {
        List<Integer> result = new ArrayList<>();
        if(!map.containsKey(tweetName)) return result;
        TreeMap<Integer, Integer> treeMap = map.get(tweetName);
        int step = "minute".equals(freq) ? 60 : ("hour".equals(freq) ? 3600 : 3600 * 24);
        int cursor = startTime;
        while(cursor <= endTime) {
            int next = cursor + step > endTime ? endTime + 1: cursor + step;
            int count = 0;
            for(int i : treeMap.subMap(cursor, next).values()) count += i;
            result.add(count);
            cursor = next;
        }
        return result;
    }
}

 

1349. 参加考试的最大学生数

给你一个 m * n 的矩阵 seats 表示教室中的座位分布。如果座位是坏的（不可用），就用 '#' 表示；否则，用 '.' 表示。

学生可以看到左侧、右侧、左上、右上这四个方向上紧邻他的学生的答卷，但是看不到直接坐在他前面或者后面的学生的答卷。请你计算并返回该考场可以容纳的一起参加考试且无法作弊的最大学生人数。

学生必须坐在状况良好的座位上。

示例 1：

输入：seats = [["#",".","#","#",".","#"],
              [".","#","#","#","#","."],
              ["#",".","#","#",".","#"]]
输出：4
解释：教师可以让 4 个学生坐在可用的座位上，这样他们就无法在考试中作弊。 

class Solution {
    private char[][] seats = null;// 座位情况
    private int m = 0;// 排数
    private int n = 0;// 列数
    private Integer[][] memory = null;
    private int max = 0;

    public int maxStudents(char[][] seats) {
        this.seats = seats;
        m = seats.length;
        n = seats[0].length;
        max = 1 << n;  
        memory = new Integer[m][max];
        return dfs(0, 0);
    }

    private int dfs(int row, int pre) {
        if (row == m) {
            return 0;
        }
        if (memory[row][pre] != null) {
            return memory[row][pre];
        }
        int res = 0;
        for (int i = 0; i < max; ++i) {
            // 检查是否符合要求
            if (isValid(row, i, pre)) {
                int maxBackRow = dfs(row + 1, i);// 第row排以后的最大人数
                int stuNum = Integer.bitCount(i);// 第row排的人数
                res = Math.max(res, maxBackRow + stuNum);// 更新结果
            }
        }
        memory[row][pre] = res;// 保存结果，不要漏掉这句
        return res;
    }

    private boolean isValid(int row, int cur, int pre) {
        for (int i = 0; i < n; ++i) {
            if ((cur & (1 << i)) == 0) {
                continue;
            }
            if (seats[row][i] == '#') {
                return false;
            }
            if (i > 0) {
                // 检查左侧座位是否有人
                if (isStu(seats[row][i - 1], cur, i - 1)) {
                    return false;
                }
                // 检查左前方座位是否有人
                if (row > 0 && isStu(seats[row - 1][i - 1], pre, i - 1)) {
                    return false;
                }
            }
            if (i < n - 1) {
                // 检查右侧是否有人
                if (isStu(seats[row][i + 1], cur, i + 1)) {
                    return false;
                }
                // 检查右前方是否有人
                if (row > 0 && isStu(seats[row - 1][i + 1], pre, i + 1)) {
                    return false;
                }
            }
        }
        return true;
    }

    private boolean isStu(char seat, int flag, int index) {
        if (seat == '.' && (flag & (1 << index)) != 0) {
            return true;  //座位有学生
        }
        return false;  //座位是坏的或者没有学生
    }
}