21年10月第四周 力扣每日一题记录

本周每日一题 题目

  • lc476. 数字的补数
  • lc211. 添加与搜索单词 - 数据结构设计
  • lc453. 最小操作次数使数组元素相等
  • lc66. 加一
  • lc229. 求众数 II
  • lc492. 构造矩形

10-18 lc476. 数字的补数

  • 对示例做这样一个事,求num+答案+1,结果刚好是2^n,然后再用几个测试用例,发现也是这样,所以这就是本题的规律
  • 然后这个2^n是大于num的最小的n,所以答案如下
  • 用long来解决边界溢出
class Solution {
    public int findComplement(int num) {
        long n = 1;
        while(n<=num) n = n << 1;
        return (int)(n-num-1);
    }
}

10-19 lc211. 添加与搜索单词 - 数据结构设计

  • 就是一个字典树,然后加上万能匹符的逻辑
  • 好久没有写字典树了,好生疏,写了好久
  • 然后这里万能符匹配,要麻烦一点,需要递归调用,跳过当前字符,从next节点来匹配后序字符,看是否能够成功
class WordDictionary {
    //只需要来查询是否存在,而且单词的长度也有限,所以完全可以建立一个500*26的数组来记录每个位置的单词情况
    //还有就是是否要以当前字母结尾,所以就是一个字典树,得专门记录一个end的状态,才能统计
    //就是字典树,但难度还是有的,因为是有一个万能匹配符
    class WordTree{
        boolean end = false;
        WordTree[] next = new WordTree[26];//下一个数组,26个字母,未初始化
    }
    private WordTree root;

    /** Initialize your data structure here. */
    public WordDictionary() {
        root = new WordTree();
    }
    
    /** Adds a word into the data structure. */
    public void addWord(String word) {
        char[] ss = word.toCharArray();
        WordTree cur = this.root;
        for(char ch : ss){
            int i = ch-97;
            if(cur.next[i]==null)
                cur.next[i] = new WordTree();
            cur = cur.next[i];
        }
        cur.end = true;//end设置为true
    }
    
    /** Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. */
    public boolean search(String word) {
        return help(root,word);
    }

    private boolean help(WordTree cur, String word){
        if(cur==null) return false;
        char[] ss = word.toCharArray();
        for(int j=0; j<ss.length; j++){
            char ch = ss[j];
            if(ch=='.'){//当出现万能匹配符时,最多可能有26种可能,都要去尝试
                for(int i=0; i<26; i++)
                    if(help(cur.next[i],String.valueOf(ss,j+1,ss.length-j-1))) return true;
                return false;
            }
            int i = ch-97;
            if(cur.next[i]==null) return false;
            cur = cur.next[i];
        }
        return cur.end;
    }
}

10-20 lc453. 最小操作次数使数组元素相等

  • 这是一个数学题
 设变量t为最终平衡的数值,而x为我们最小操作数
 数值长度为n,和为sum
 可以得到  n*t = x*(n-1) + sum (1)
 然后对于我们数组中的最小值min,它有这样的等式关系 t - min = x (2)
 对于上面的等式,它是必须成立的,设想如果不等于,那么等式要么大于要么小于;大于的话,明显不平衡,小于的话,说明达不到平衡
 联立(1)(2)
 解得 x = sum - min * n;
class Solution {
   //n-1个元素增加1
   //如果每次都不给本轮最大值加,是不是就可以到最终结果了,一个贪心的思路,就总能够达到平衡
   //那么要求多少轮的话,每一轮都能知道,至少有多少个要加,这个复杂度高,不可能模拟的
   public int minMoves(int[] nums) {
       int sum = 0;
       int min = (int)1e9;
       for(int num: nums){
           if(num<min) min = num;
           sum += num;
       }
       return sum-min*nums.length;
   }
}

10-21 lc66. 加一

  • 就是一个大数加法
  • 唯一麻烦一点的是,返回数组,所以不知道返回数组的长度==原数组长度还是+1
  • 所以用list先存着,之后转数组,可我总是。。记不得java的List转int[],list.stream().mapToInt(i->i).toArray();
class Solution {
    //非负,整个数组就是一个数
    //所以这个就是一个加1的操作,大数加法,然后因为是数组,所以要考虑进位之后比之前多一位的情况,所以需要准备新数组
    //于是用List来存储,最终reverse,转换成数组
    public int[] plusOne(int[] digits) {
        List<Integer> list = new ArrayList<>();
        int t = 1;
        for(int i=digits.length-1; i>=0; i--){
            int d = digits[i];
            list.add((d+t)%10);
            t = (d + t)/10;
        }
        if(t!=0) list.add(t);
        Collections.reverse(list);//因为从低位开始,所以是反着的
        return list.stream().mapToInt(i->i).toArray();
    }
}

10-22 lc229. 求众数 II

  • 升级版的摩尔技术法,这里是求超过n/3的,和n/2不同
  • 本题是超过n/3,如果是大于等于n/3的,其实就不好求了,可能说要通过3个变量来求了,嗯,3个是可以的
  • 所以求>n/k的,用k-1个变量,注意continue(一轮只命中一个),求>=n/k的,用k个变量,注意continue,注意continue
class Solution {
    public List<Integer> majorityElement(int[] nums) {
        List<Integer> res = new ArrayList<>();
        if(nums==null || nums.length==0)return res;
        //升级版摩尔计数法
        //同时只有一个人进行++操作
        int cand1 = nums[0], cnt1 = 0;
        int cand2 = nums[0], cnt2 = 0;
        //找出两个众数
        for(int num : nums){
            if(cand1==num){
                cnt1++;
                continue;
            }
            if(cand2==num){
                cnt2++;
                continue;
            }
            if(cnt1==0){
                cand1 = num;
                cnt1++;
                continue;
            }
            if(cnt2==0){
                cand2 = num;
                cnt2++;
                continue;
            }
            cnt1--;
            cnt2--;
        }
        //这里count1和count2,有被抵消了,可能刚好为0,所以不行,要重新统计
        cnt1 = 0;
        cnt2 = 0;
        for(int num: nums)
            if(num==cand1) cnt1++;
            else if(num==cand2) cnt2++;


        if(cnt1>(int)nums.length/3)res.add(cand1);
        if(cnt2>(int)nums.length/3)res.add(cand2);
        return res;
    }
}

10-23 lc492. 构造矩形

  • 就是给定面积,求最接近正方形的矩形的长宽
  • 思路很简单,从平方数开始,往下减少,直到面积除以当前宽能够余数为0,就终止
class Solution {
    //尽量是正方形呗
    //先长后宽
    public int[] constructRectangle(int area) {
        int w = (int)Math.sqrt(area);
        while(area%w!=0) w--;
        return new int[]{area/w,w};
    }
}

你可能感兴趣的:(LeetCode,算法,leetcode,java)