LeetCode每日十题---哈希表

题目描述1

笔者解答1.1

public int countPrimes(int n){
  if(n<3) return 0;
  int count=0;
  for(int i=2;i<n;i++){
    int flag=0;
    for(int j=2;j<=i/2;j++)
    {
       if(i%j==0)
       {
          flag=1;
          break;
       }
    }
    if(flag==0){
      count++;
    }
 }
}

笔者分析1.2

虽然这方法是以前的惯用方法，但应该没有比这方法更烂的了吧，也是今天我才了解到判断一个数是否为质数还可以有下面这样简单的方法。其实以前也注意到了原来写的方法比较次数有些多余，比如既然我已经比较出不是2的倍数，那我为什么还要比较是不是4的倍数呢？我们之所以还要往后遍历是因为我们想知道会不会是某一质数的倍数，那么好，下面就直接比较之前所有质数的倍数关系就行了。

public int countPrimes(int n){
   if(n<3) return 0;
   HashSet<Integer> primes=new HashSet<Integer>();
   for(int i=2;i<n;i++)
   {
     int flag=0;
     for(Integer prime:primes){
        if(i%prime==0){
          flag=1;
          break;
        }
     }
     if(flag==0){
       primes.add(i);
     }
   }
   return primes.size();
}
//虽然上面那种方法有点秀，但还是超时了，看看下面这个正确解答，有点意思
class Solution {
    public int countPrimes(int n) {
        int[] a=new int[n+1];
        int count=0;
        for(int i=2;i<n;i++)
           a[i]=1;
        for(int i=2;i<n;i++){
            if(a[i]!=0){
                count++;
                for(int j=2*i;j<n;j+=i)
                   a[j]=0;
            }
        }
        return count;
    }
}

题目描述2

笔者解答2.1

class Solution {
    public int countCharacters(String[] words, String chars) {
     Map<Character,Integer> match_map=new HashMap<Character,Integer>();
     int i=0;
     for(i=0;i<chars.length();i++){
         match_map.put(chars.charAt(i),match_map.getOrDefault(chars.charAt(i),0)+1);
     }
     int sum=0;
     for(i=0;i<words.length;i++){
         Map<Character,Integer> temp_map=new HashMap<Character,Integer>();
         for(int j=0;j<words[i].length();j++){
             temp_map.put(words[i].charAt(j),temp_map.getOrDefault(words[i].charAt(j),0)+1);
         }
         boolean match=true;
         for(Character c:temp_map.keySet()){
             if(match_map.get(c)==null){
                 match=false;
                 break;
             }else if(match_map.get(c)<temp_map.get(c)){
                 match=false;
                 break;
             }        
         }
         if(match){
            sum+=words[i].length();
         }
     }
     return sum;
    }
}

笔者分析2.2

虽然写出来了但效率太低了，下面给出优化的方法，如果是字母哈希表可以用数组代替。而且数组操作也是花里胡哨，各种函数，学到了。

class Solution {
    public int countCharacters(String[] words, String chars) {
        int[] hash = new int[26];
        for(char ch : chars.toCharArray()){
            hash[ch - 'a'] += 1;
        }
        int[] map = new int[26];
        int len = 0;
        for(String word : words){
            Arrays.fill(map, 0);
            boolean flag = true;
            for(char ch : word.toCharArray()){
                map[ch - 'a']++;
                if(map[ch - 'a'] > hash[ch - 'a']) flag = false;
            }
            len += flag ? word.length() : 0;    
        }
        return len;
    }
}

题目描述3

笔者解答3.1

class Solution {
    public int fourSumCount(int[] A, int[] B, int[] C, int[] D) {
         Map<Integer,Integer> abmap=new HashMap<Integer,Integer>();
         Map<Integer,Integer> cdmap=new HashMap<Integer,Integer>();
         int i,j;
         int length=A.length;
         for(i=0;i<length;i++){
             for(j=0;j<length;j++){
                 int temp=A[i]+B[j];
                 abmap.put(temp,abmap.getOrDefault(temp,0)+1);
                 temp=0-C[i]-D[j];
                 cdmap.put(temp,cdmap.getOrDefault(temp,0)+1);
             }
         }
         int count=0;
         for(Integer number:abmap.keySet()){
             int times=abmap.get(number);
             if(cdmap.get(number)!=null){
               int times_two=cdmap.get(number);
               count+=times_two*times;
             }
         }
         return count;
    }
}

笔者分析3.2

虽然算法效率不高，但比暴力算法还是优秀好多，将四个数拆成两组，求和存入哈希表，挺好的一个思路，将n的四次方，拆成两个n的平方，再平方，时间复杂度为O(n*n)。

总结

前两天准备考英语四六级去了，没写博客，今天继续，每日打卡十八天，以下图为证