算法刷题记录-Hash(LeetCode)

820. Short Encoding of Words

思路

Hashset有个特点remove的元素不在set里面的话，是删除不了什么东西的。例如题目中的样例，time me bell，删除ime 的话是什么都不会发生的。利用这一点，我们可以把每个string元素从第一位开始从set中删除。

代码

    public int minimumLengthEncoding(String[] words) {
        Set<String> set = new HashSet<>(Arrays.asList(words));
        for (String word : words) {
            for (int i = 1; i < word.length(); i++) {
                set.remove(word.substring(i));
            }
        }
        System.out.println(set);
        int ans = 0;
        for (String word : set) {
            ans += word.length() + 1;
        }
        return ans;
    }

869. Reordered Power of 2

思路

预先将$1<=k<=10^9$范围内2的幂的字符串表示的长度存入HashMap中，并将其具体值存入HashSet中。将新输入的数字转化为字符串，首先判断hashmap中是否存在长度为k的2的幂，若无则一定不可以重组为2的幂。若存在，则对长度等于字符串的2的幂的每个字符串逐个比较字符数量，若一致则存在返回ture。

代码

class Solution {
    static HashMap<Integer, HashSet<String>> map=new HashMap<>();
    static  {
        int base=1;
        while (base<1000000000){
            int digits=String.valueOf(base).length();
            if (!map.containsKey(digits)){
                map.put(digits,new HashSet<>());
                map.get(digits).add(String.valueOf(base));
            }
            else{
                map.get(digits).add(String.valueOf(base));
            }
            base*=2;
        }
    }
    public boolean reorderedPowerOf2(int n) {

        char[] digits=String.valueOf(n).toCharArray();
        int[] cnts=new int[10];
        for (char ch:digits){
            cnts[ch-'0']++;
        }
        if (!map.containsKey(digits.length)){
            return false;
        }
        continue2: for (String key:map.get(digits.length)){
            int[] cnts_cpy=new int[10];
            System.arraycopy(cnts,0,cnts_cpy,0,10);
            for (char ch:key.toCharArray()){
                cnts_cpy[ch-'0']--;
                if (cnts_cpy[ch-'0']<0){
                    continue continue2;
                }
            }
            return true;
        }
        return false;
    }
}

890. Find and Replace Pattern

思路

创建两个HashMap 实现1对1双射

代码

class Solution {
    public List<String> findAndReplacePattern(String[] words, String _pattern) {
        List<String> res=new ArrayList<>();
        char[] pattern=_pattern.toCharArray();
        continue2: for (String word:words){
            HashMap<Character,Character> mapping=new HashMap<>();
            HashMap<Character,Character> reverseMapping=new HashMap<>();
            for (int i=0;i<word.length();i++){
                if (!mapping.containsKey(word.charAt(i))&&!reverseMapping.containsKey(pattern[i])){
                    mapping.put(word.charAt(i),pattern[i]);
                    reverseMapping.put(pattern[i],word.charAt(i));
                }
                else if (mapping.containsKey(word.charAt(i))&& mapping.get(word.charAt(i))==pattern[i]){
                    continue;
                }
                else{
                    continue continue2;
                }
            }
            res.add(word);
        }
        return res;
    }
}

2829 Determine the Minimum Sum of a k-avoiding Array

思路

采取hashset的方式，从小到大逐渐遍历每一个数，并将k关于起的互补数即$a+b=k$置入结果中。知道放满n个元素的结果。

代码

    public int minimumSum(int n, int k) {
        HashSet<Integer> set=new HashSet<>();
        int sum=0;
        int elements=0;
        int base=1;
        while (elements<n){
            if (!set.contains(base)){
                set.add(k-base);
                sum+=base;
                elements++;
            }
            base++;
        }
        return sum;
    }

911. Online Election

思路

首先定义counter，用于保存当前时间t的票型，定义curr_idx为历史最高得票者、定义curr_cnt为历史最高票数。
定义TreeMaptimeSeries用于存储在不同时间下的领先者。
对时间从1-n进行遍历，在counter中对当前的票数以及最高者进行判断：

• 若当前票数大于历史最高票curr_cnt对其进行更新。
• 若当前最高票者票数大于或等于curr_cnt。判断是否与历史最高票者是否一致，不一致则在timeSeries插入最高票数为其的时间戳(t,curr_idx)。
• 对于任意输入t,通过timeSeries.get(timeSeries.floorKey(t)方法获取最接近t的最高票人即可。

代码

public class TopVotedCandidate {

    TreeMap<Integer,Integer> timeSeries=new TreeMap<>();
    HashMap<Integer,Integer> counter=new HashMap<>();
    public TopVotedCandidate(int[] persons, int[] times) {
        init(persons,times);
    }
    public void init(int[] persons, int[] times){
        int curr_idx=-1;
        int curr_cnt=0;
        for (int i = 0; i < times.length; i++) {
            counter.merge(persons[i],1,Integer::sum);
            if (counter.get(persons[i])==curr_cnt){
                if (curr_idx!=persons[i]){
                    curr_idx=persons[i];
                    timeSeries.put(times[i],curr_idx);
                }
            }
            if (counter.get(persons[i])>curr_cnt){
                curr_cnt=counter.get(persons[i]);
                if (curr_idx!=persons[i]){
                    curr_idx=persons[i];
                    timeSeries.put(times[i],curr_idx);
                }
            }
        }
    }

    public int q(int t) {
        return timeSeries.get(timeSeries.floorKey(t));
    }
}