每日一题补题记录3

​​​​​​1763. 最长的美好子字符串

当一个字符串 s 包含的每一种字母的大写和小写形式 同时 出现在 s 中，就称这个字符串 s 是 美好 字符串。比方说，"abABB" 是美好字符串，因为 'A' 和 'a' 同时出现了，且 'B' 和 'b' 也同时出现了。然而，"abA" 不是美好字符串因为 'b' 出现了，而 'B' 没有出现。

给你一个字符串 s ，请你返回 s 最长的 美好子字符串 。如果有多个答案，请你返回 最早 出现的一个。如果不存在美好子字符串，请你返回一个空字符串。

方法一：暴力枚举

class Solution {
    public String longestNiceSubstring(String s) {
        int n = s.length();
        String ans = "";
        for (int i = 0; i < n; i++) {
            //注意美好字符串长度至少>1,所以j从i+1开始
            for (int j = i + 1; j < n; j++) {
                //找到了美好子字符串，且长度大于当前答案
                if (check(s.substring(i, j + 1))&&j - i + 1 > ans.length()) 
                    ans = s.substring(i, j + 1);
            }
        }
        return ans;
    }
    boolean check(String s) {
        Set<Character> set = new HashSet<>();
        char[]array=s.toCharArray();
        for (char c : array) 
            set.add(c);
        for (char c : array) {
            //不清楚c的大小写形式，所以用a表示小写，b表示大写
            char a = Character.toLowerCase(c), b = Character.toUpperCase(c);
            //完美字符串要求每个字母的大小写都同时存在
            if (!set.contains(a) || !set.contains(b)) return false;
        }
        return true;
    }
}

方法二：前缀和

用cnt[i+1][j]记录0-i这i+1个字符中字符j的出现次数，然后可以用cnt来计算[l,r]这个区间的每个字符出现次数，如果每个字母大小写出现次数都为0或都不为0即为美好字符串

class Solution {
    public String longestNiceSubstring(String s) {
        int n = s.length();
        int[][] cnt = new int[n + 1][128];
        //从1开始逐渐构建cnt数组，注意因为大写在前小写在后，我们用-'A'来记录这个值
        for (int i = 1; i <= n; i++) {
            char c = s.charAt(i - 1);
            cnt[i] = cnt[i - 1].clone();
            cnt[i][c - 'A']++;
        }
        //idx记录找到的最长美好子串开始下标，len为对应长度
        int idx = -1, len = 0;
        for (int l = 0; l < n; l++) {
            for (int r = l + 1; r < n; r++) {
                //只考虑更长的子串
                if (r - l + 1 <= len) continue;
                int[] a = cnt[l], b = cnt[r + 1];
                if (check(a, b)) {
                    idx = l; len = r - l + 1;
                }
            }
        }
        //如果idx没有初始化，证明没有美好子串
        //只要初始化了，就返回当前子串
        return idx == -1 ? "" : s.substring(idx, idx + len);
    }
    //检查区间内的子串是否美好
    boolean check(int[] a, int[] b) {
        for (int i = 0; i < 26; i++) {
            int low = b[i] - a[i], up = b[i + 32] - a[i + 32]; // 'A' = 65、'a' = 97
            //两种不美好的情况
            if (low != 0 && up == 0) return false;
            if (low == 0 && up != 0) return false;
        }
        //美好子串
        return true;
    }
}

---

2.2 

2000. 反转单词前缀

给你一个下标从 0 开始的字符串 word 和一个字符 ch 。找出 ch 第一次出现的下标 i ，反转 word 中从下标 0 开始、直到下标 i 结束（含下标 i ）的那段字符。如果 word 中不存在字符 ch ，则无需进行任何操作。

例如，如果 word = "abcdefd" 且 ch = "d" ，那么你应该 反转 从下标 0 开始、直到下标 3 结束（含下标 3 ）。结果字符串将会是 "dcbaefd" 。
返回 结果字符串 。

简单易懂，双指针交换即可

一个小tips，我第一次提交犯错了，原因是返回array.toString(),但是这样的处理方式导致返回值很难理解，查阅资料之后了解到，toString()转换字符数组确实可能出现这样的问题，所以采用String.valueof或者new String都可以

class Solution {
    public String reversePrefix(String word, char ch) {
        int n=word.length(),index=-1;
        char[]array=word.toCharArray();
        for(int i=0;i<n;i++){
            if(array[i]==ch){
                index=i;
                break;
            }
        }
        int l=0,r=index;
        while(l<r){
            char c=array[l];
            array[l]=array[r];
            array[r]=c;
            l++;
            r--;
        }
        return String.valueOf(array);
    }
}

---

2.3

1414. 和为 K 的最少斐波那契数字数目

 给你数字 k ，请你返回和为 k 的斐波那契数字的最少数目，其中，每个斐波那契数字都可以被使用多次。

斐波那契数字定义为：

F1 = 1
F2 = 1
Fn = Fn-1 + Fn-2 ， 其中 n > 2 。
数据保证对于给定的 k ，一定能找到可行解。

贪心，找到所有<=k的斐波那契数，然后在数列中逆向寻找，每找到一个<=k的值从k中减去该值，直到k==0

class Solution {
    public int findMinFibonacciNumbers(int k) {
        if(k<4){
            return 1;
        }
        List<Integer>f=fib(k);
        int i=f.size()-1,ans=0;
        while(k>0&&i>=0){
            if(k>=f.get(i)){
                k-=f.get(i);
                ans++;
            }
            i--;
        }
        return  ans;
    }
    List<Integer>fib(int k){
        List<Integer>list=new ArrayList<>();
        list.add(1);
        list.add(1);
        list.add(2);
        list.add(3);
        int cur=3,i=4;
        while(cur<=k){
            cur=list.get(i-1)+list.get(i-2);
            list.add(cur);
            i++;
        }
        return list;
    }
}