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

本周每日一题 题目

• lc482. 密钥格式化
• lc284. 窥探迭代器
• lc414. 第三大的数
• lc434. 字符串中的单词数
• lc187. 重复的DNA序列
• lc352. 将数据流变为多个不相交区间
• lc441. 排列硬币

10-04 lc482. 密钥格式化

• 今天是个简单题，也是非常简单的一道题
• 给一个字符串，经过处理
• 然后给k值，将字符串分成多个k字符的分组，第一个小于等于k，那么很简单，第一个直接是n%k就可以了，后面的全部是k，当然，如果结果是0，那么每个都是k，第一个就置为k
• 简单题，直接看代码，不多bb

class Solution {
    //按照-来分割字符串，然后第一个分组小于等于k，至少有一个，后面的要刚好包含k个字符
    //然后因为只有字母，所以要转成大写，这个有api
    //也就是第一个至少有1，但是有多少是按照后面的整除的情况来的
    public String licenseKeyFormatting(String s, int k) {
        char[] ss = String.join("",s.split("-")).toUpperCase().toCharArray(); //去掉破折号，并转大写,转成char数组
        int n = ss.length;
        //每一个的数量
        int each = n%k==0?k:n%k; //初始为第一个的数量，后面置为k
        //重组
        StringBuilder sb = new StringBuilder();
        for(int i=0; i<n; i++){
             if(each==0){
                 sb.append('-');
                 each = k;
             }
             sb.append(ss[i]);
             each--;
        }
        return sb.toString();
    }
}

10-05 lc284. 窥探迭代器

• 这题一上来有点懵，搞不懂为什么
• 看了java iterator的api，大概知道了，原始的api提供给我们hasNext()方法和next()方法，而我们自己要去实现peek()方法，该方法是返回下一个元素，而指针并不移动
• 这里有个细节在于，我的peek其实只管用一次，就是在我用peek之后，我会返回下一个元素，而指针不动，那我再peek一次，还是之前的那个元素，因为指针并不移动
• 所以这里的思路就是，使用一个int变量peekElement作为peek值的缓存
• 如果使用了peek，那么我就调用原始api的next方法，将返回的值保存到peekElement中去，如果之后再peek，我都返回这个值，而如果之后调用了next方法，那么我就将peekElement返回，然后保证它只使用一次
• 也就是说，我调用peek的时候，其实已经调用了next，只是通过缓存的方式，欺骗用户，让用户以为我的指针没动
• 然后对应的，hasNext，next方法等，逻辑都要对peekElement先进行判断，这里我还加上了判空的逻辑，虽然题目没有要求

class PeekingIterator implements Iterator<Integer> {
    //通过原生的api明显是不能完成peek这个操作的，所以要自己用单独的方式实现
    //其次就是我不next的情况下，最多只能peek一次，也就是我只要存储一个数据就可以了，这个数据是前一个的
    //只要它不为0，那么就返回它，但只能使用一次
    private Iterator<Integer> iterator;
    private int peekElement = 0;// 0 代表无数据

	public PeekingIterator(Iterator<Integer> iterator) {
	    // initialize any member here.
        this.iterator = iterator;
	}
	
    // Returns the next element in the iteration without advancing the iterator.
	public Integer peek() {
        if(peekElement!=0) return peekElement;//peek可以无限用
        if(iterator.hasNext()) peekElement = iterator.next();
        return peekElement;
	}
	
	// hasNext() and next() should behave the same as in the Iterator interface.
	// Override them if needed.
	@Override
	public Integer next() {
        int res = 0;
        if(peekElement!=0||!iterator.hasNext()){
            res = peekElement;
            peekElement = 0;//只能使用一次
        }
        else res = iterator.next();
	    return res;
	}
	
	@Override
	public boolean hasNext() {
	    return iterator.hasNext()||peekElement!=0; //当peekElement不为0时，说明
	}
}

10-06 lc414. 第三大的数

• 写的有点懵。。一直在想怎么写的更优雅，结果一直都不优雅
• 两种解法，都差不多

class Solution {
    //需要是第三大的不同的数字，如果相同，则认为是一个
    //用三个变量来记录
    public int thirdMax(int[] nums) {
        long first = Long.MIN_VALUE;
        long second = Long.MIN_VALUE;
        long third = Long.MIN_VALUE;
        //先从小数来更新，就会出错，所以从大数来看
        for(int num: nums){
            long cur = num;
            if(cur>first){//swap
                long t = cur;
                cur = first;
                first = t;
            }
            else if(cur==first) continue;
            if(cur>second){//swap
                long t = cur;
                cur = second;
                second = t;
            }
            else if(cur==second) continue;
            if(cur>third){//swap
                long t = cur;
                cur = third;
                third = t;
            }
        }
        if(third!=Long.MIN_VALUE) return (int)third;
        return (int)first;
    }
}

• 因为不能像go语言那样快速交换，所以这里写起来很丑，不然就三个swap，就很舒服了
• 还有一种下面的写法，稍微短一些，看起来也还好

class Solution {
    public int thirdMax(int[] nums) {
        long first = Long.MIN_VALUE;
        long second = Long.MIN_VALUE;
        long third = Long.MIN_VALUE;
        for(int num: nums){
            if(num>first){
                third = second;
                second = first;
                first = num;
            } 
            else if(num>second&&num<first){
                third = second;
                second = num;
            }
            else if(num>third&&num<second) third = num;
        }
        return (int)(third ==Long.MIN_VALUE? first:third);
    }
}

• 这里都通过long来解决边界，边界值太恶心了，要附加很多逻辑，不如用long

10-07 lc434. 字符串中的单词数

• 简单题，就是需要自己去实现split，来解决空格问题

class Solution {
    //连续的不是空格的字符
    //测试用例太少了，只能试试了
    //"",",,,,     a, eaefa"
    public int countSegments(String s) {
        s += " ";
        char[] ss = s.toCharArray();
        int cnt = 0;
        for(int i=0; i<ss.length; i++){
            if(ss[i]==' '&&i>0&&ss[i-1]!=' ')
                cnt++;
        }
        return cnt;
    }

}

10-08 lc187. 重复的DNA序列

• 题目没读清楚，就赶着做，有点蠢了，没看到目标子串的长度为10，所以就写了个O(n2)的，太蠢了
• 因为限制了长度为10，所以实际上也就只有n-9个子串，那么把所有的子串放到set中去，如果重复，就加入结果集，如此便可以实现题目要求
• 这里记录一个api，String s = new String(char[] chs, int offeset, int count), 这是从char数组中生成String的方法，很好用
• 其实这里的问题在于，生成了过多的String，对gc其实蛮有压力的

class Solution {
    public List<String> findRepeatedDnaSequences(String s) {
        Set<String> set = new HashSet<>(); //存储出现元素
        Set<String> res = new HashSet<>(); //存储结果元素
        char[] ss = s.toCharArray();
        for(int i=0; i<ss.length-9; i++){
            String cur = new String(ss,i,10);
            if(set.contains(cur)) res.add(cur);
            set.add(cur);
        }
        //set转list
        return new ArrayList<String>(res);
    }
}

10-09 lc352. 将数据流变为多个不相交区间

• 这题很好，但是写题目的人很辣鸡，题意没写清楚，我真是服了
• 意思是，将连续的数字给写成一个区间
• 难点在于，需要不断的插入新的数，导致情况变化，所以每次进行统计
• 我这里是O(n2)方解法的，每次都是暴力解

class SummaryRanges {
    //这题出的很垃圾，题目意思没有讲清楚，导致看了示例之后更懵了，搞不清楚是为啥
    //终于明白了，这题的意思是连续的进行合并成一个区间，不连续的单独作为一个区间
    //O(n2)暴力解，用什么数据结构来存储呢，能够o1的存，然后O(n)的取
    //直接用数组存储就好了，因为范围有限
    private int[] vals;
    public SummaryRanges() {
        vals = new int[10001];
    }

    public void addNum(int val) {
        vals[val] = 1;
    }
    
    public int[][] getIntervals() {
        List<int[]> list = new ArrayList<>();
        int i = 0;
        while(i<=10000){
            while(i<=10000&&vals[i]==0) i++;
            if(i>10000) break;
            int[] cur = new int[2];
            cur[0] = i;
            cur[1] = i;
            while(i<=10000&&vals[i]!=0) i++;
            cur[1] = i-1;
            list.add(cur);
        }
        int[][] res = new int[list.size()][2];
        for(i=0; i<res.length; i++){
            int[] cur = list.get(i);
            res[i][0] = cur[0];
            res[i][1] = cur[1];
        }
        return res;
    }
}

10-10 lc441. 排列硬币

• 是一个简单题，反正就很简单
• 用求和公式来，首先找到平方数，向上取整，让后往下找，知道求和公式结果小于等于当前的n
• 因为这里数会越界，所以全程用long来进行处理，就能解决
• 同时，平方数离答案的距离已经很近了，这里就不用再用Ologn了，直接On往下遍历就行了

class Solution {
    //最后一行可以不完整，而前面必须完整i行必须有i个
    //最简单的思路，这是一个累加和，直接从1一直加到大于这个数，然后返回前一个就可以，这样会超时
    //用求和公式来，(1+k)*k/2 = (k+k2)/2--> 2n的平方根，然后分别往下去找
    public int arrangeCoins(int n) {
        long t = 2*(long)n;
        long i = (long)Math.sqrt(t)+1;//向上取整,此时累加是大于2n的
        while(sum(i)>t) i--;
        return (int)i;
    }

    private long sum(long sqrt){
        return (1+sqrt)*sqrt;
    }
}