力扣刷题序列 - 字符串篇

最新推荐文章于 2024-10-31 16:16:13 发布
最新推荐文章于 2024-10-31 16:16:13 发布
阅读量1k 收藏
点赞数
文章标签： leetcode c# 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56454895/article/details/130988927
版权

这里写目录标题

字符

1.520

在这里插入图片描述

class Solution {
   public boolean detectCapitalUse(String word) {
        int D1=0;
        int D2=0;
       boolean flg=false;
        for (int i = 0; i < word.length(); i++) {
            if (word.charAt(0)>= 'A' && word.charAt(0) <='Z' ){
                flg=true;
            }
            if (word.charAt(i) >= 'A' && word.charAt(i) <='Z'){
                D1++;
            }else {
                D2++;
            }
        }
        if (D1 == 1 && D2 == word.length()-1 && flg){
            return true;
        }else if (D2 == 0 || D1 == 0){
            return true;
        }
        return false;
    }
}

回文串的定义

2. 125

在这里插入图片描述

class Solution {
    public boolean isPalindrome(String s) {
       
        s=s.toLowerCase();
        StringBuilder stringBuilder=new StringBuilder();
        for (int k = 0; k < s.length(); k++) {
            if ((s.charAt(k) >= 'a' && s.charAt(k) <= 'z')||(s.charAt(k) >= '0' && s.charAt(k) <= '9')){
                stringBuilder.append(s.charAt(k));
            }
        }
        s=stringBuilder.toString();
         int i=0;
        int j=s.length()-1;
        while (i < j){
            
            if (s.charAt(i) == s.charAt(j)){
                i++;
                j--;
            }else {
                return false;
            }
        }
        return true;
    }
}

公共前缀

3. 14

在这里插入图片描述

class Solution {
     public String longestCommonPrefix(String[] strs) {
        if (strs == null || strs.length == 0) {
            return "";
        }
        String prefix = strs[0];
        int count = strs.length;
        for (int i = 1; i < count; i++) {
            prefix = longestCommonPrefix(prefix, strs[i]);
            if (prefix.length() == 0) {
                break;
            }
        }
        return prefix;
    }

    public String longestCommonPrefix(String str1, String str2) {
        int length = Math.min(str1.length(), str2.length());
        int index = 0;
        while (index < length && str1.charAt(index) == str2.charAt(index)) {
            index++;
        }
        return str1.substring(0, index);
    }
}

单词

4. 434

在这里插入图片描述

class Solution {
    public int countSegments(String s) {
      
     
        s = s.trim();
        if("".equals(s)){
            return 0;
        }
        //按空字符串分割（\s空字符-正则表达式  \s+空字符串 \\s+转义）
        String[] ss = s.split("\\s+");
        return ss.length;



    }

    }

5. 58

在这里插入图片描述

class Solution {
   public int lengthOfLastWord(String s) {
        char[] ch=s.toCharArray();
        boolean flg=false;
        int count=0;
        for (int i = ch.length-1; i >=0; i--) {
            if (ch[i]==' '&&flg){
                break;
            }else {
                if (ch[i]!=' '){
                    count++;
                    flg=true;
                }
            }
        }
        return count;           
    }
}

字符串的反转

6. 344

在这里插入图片描述

class Solution {
   public void reverseString(char[] s) {
        int i=0;
        int j=s.length-1;

        while (i < j){
            char ch=s[i];
            s[i]=s[j];
            s[j]=ch;
            i++;
            j--;
        }
   }
}

7. 541

在这里插入图片描述

class Solution {
   public String reverseStr(String s, int k) {
        int n = s.length();
        char[] arr = s.toCharArray();
        for (int i = 0; i < n; i += 2 * k) {
            reverse(arr, i, Math.min(i + k, n) - 1);
        }
        return new String(arr);
    }

    public void reverse(char[] arr, int left, int right) {
        while (left < right) {
            char temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left++;
            right--;
        }
    }
}

8. 557

在这里插入图片描述

class Solution {
   public String reverseWords(String s) {
        String[] ret=s.split(" ");
        StringBuilder stringBuilder=new StringBuilder();
        for (int i = 0; i < ret.length; i++) {
           
            int k=ret[i].length()-1;
            while (k >= 0){
                stringBuilder.append(ret[i].charAt(k));
                k--;
            }
            if (i != ret.length-1){
                stringBuilder.append(" ");
            }
        }
        return stringBuilder.toString();
    }
}

9. 151

在这里插入图片描述

class Solution {
   public String reverseWords(String s) {
        s=s.trim();
        String[] strings=s.split("\\s+");
       String ret=new String();
        for (int i = strings.length-1; i >= 0; i--) {
             if (i == 0){
                ret+=strings[i];
            }else {
                ret+=strings[i]+" ";
            }
        }
        return ret;
    }
}

字符的统计

10. 387

在这里插入图片描述

class Solution {
     public int firstUniqChar(String s) {
         if(s==null)return -1;
        int[] arr=new int[26];
        for (int i = 0; i < s.length(); i++) {
            arr[s.charAt(i)-97]++;
        }
        for (int i = 0; i < s.length(); i++) {
            if (arr[s.charAt(i)-'a']==1){
                return i;
            }
        }
        return -1;

    }
}

11. 389

在这里插入图片描述

class Solution {
    public char findTheDifference(String s, String t) {
        int[] cnt = new int[26];
        for (int i = 0; i < s.length(); ++i) {
            char ch = s.charAt(i);
            cnt[ch - 'a']++;
        }
        for (int i = 0; i < t.length(); ++i) {
            char ch = t.charAt(i);
            cnt[ch - 'a']--;
            if (cnt[ch - 'a'] < 0) {
                return ch;
            }
        }
        return ' ';
    }


}

12. 383

在这里插入图片描述

class Solution {
   public boolean canConstruct(String ransomNote, String magazine) {
        if (ransomNote.length() > magazine.length()) {
            return false;
        }
        int[] cnt = new int[26];
        for (char c : magazine.toCharArray()) {
            cnt[c - 'a']++;
        }
        for (char c : ransomNote.toCharArray()) {
            cnt[c - 'a']--;
            if(cnt[c - 'a'] < 0) {
                return false;
            }
        }
        return true;
    }
}

13. 242

在这里插入图片描述

class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()){
            return false;
        }
        int[] arr=new int[26];
        for (int i = 0; i < s.length(); i++) {
            char ch=s.charAt(i);
            arr[ch-'a']++;
        }
        for (int i = 0; i < t.length(); i++) {
            char ch=t.charAt(i);
            arr[ch - 'a']--;
            if ( arr[ch - 'a'] < 0){
                return false;
            }
        }
        for (int i:arr) {
            if (i != 0){
                return false;
            }
        }
        return true;
    }
}

14. 49

在这里插入图片描述

class Solution {
   public List<List<String>> groupAnagrams(String[] strs) {
        Map<String, List<String>> map = new HashMap<String, List<String>>();
        for (String str : strs) {
            char[] array = str.toCharArray();
            Arrays.sort(array);
            String key = new String(array);
            List<String> list = map.getOrDefault(key, new ArrayList<String>());
            list.add(str);
            map.put(key, list);
        }
        return new ArrayList<List<String>>(map.values());
    }
}

15. 451

在这里插入图片描述

class Solution {
   public String frequencySort(String s) {
        char[] cs = s.toCharArray();
        Map<Character, Integer> map = new HashMap<>();
        for (char c : cs)
            map.put(c, map.getOrDefault(c, 0) + 1);
        PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->{
            return a[1] != b[1] ? b[1] - a[1] : a[0] - b[0];
        });
        for (char c : map.keySet()) 
            q.add(new int[]{c, map.get(c)});
        
        StringBuilder sb = new StringBuilder();
        
        while (!q.isEmpty()) {
            int[] poll = q.poll();
            int c = poll[0], k = poll[1];
            while (k-- > 0) sb.append((char)(c));
        }
        
        return sb.toString();
    }
}

16. 423

在这里插入图片描述

class Solution {
    public String originalDigits(String s) {
        Map<Character, Integer> c = new HashMap<Character, Integer>();
        for (int i = 0; i < s.length(); ++i) {
            char ch = s.charAt(i);
            c.put(ch, c.getOrDefault(ch, 0) + 1);
        }

        int[] cnt = new int[10];
        cnt[0] = c.getOrDefault('z', 0);
        cnt[2] = c.getOrDefault('w', 0);
        cnt[4] = c.getOrDefault('u', 0);
        cnt[6] = c.getOrDefault('x', 0);
        cnt[8] = c.getOrDefault('g', 0);

        cnt[3] = c.getOrDefault('h', 0) - cnt[8];
        cnt[5] = c.getOrDefault('f', 0) - cnt[4];
        cnt[7] = c.getOrDefault('s', 0) - cnt[6];

        cnt[1] = c.getOrDefault('o', 0) - cnt[0] - cnt[2] - cnt[4];

        cnt[9] = c.getOrDefault('i', 0) - cnt[5] - cnt[6] - cnt[8];

        StringBuffer ans = new StringBuffer();
        for (int i = 0; i < 10; ++i) {
            for (int j = 0; j < cnt[i]; ++j) {
                ans.append((char) (i + '0'));
            }
        }
        return ans.toString();
    }
}

17. 657

在这里插入图片描述

class Solution {
    public boolean judgeCircle(String moves) {
        int u=0;
        int d=0;
        int l=0;
        int r=0;
        
        for (int i = 0; i < moves.length(); i++) {
            char ch=moves.charAt(i);
            if (ch == 'U'){
                u++;
            }else if (ch == 'D'){
                d++;
            }else if (ch == 'L'){
                l++;
            }else {
                r++;
            }
        }
        if (d == u && l == r){
            return true;
        }
        return false;
    }
}

18. 551

在这里插入图片描述

class Solution {
   public boolean checkRecord(String s) {
        int A=0;
        int L=0;
        int P=0;
        for (int i = 0; i < s.length(); i++) {
            char ch=s.charAt(i);
            if (ch == 'A'){
                A++;
                L=0;
                if(A >= 2)return false;
            }else if (ch == 'L'){
                L++;
                if(L >= 3)return false;
            }else if (ch == 'P'){
                P++;
                L=0;
            }
        }
       return true;
    }
}

19. 696

在这里插入图片描述

class Solution {
   public int countBinarySubstrings(String s) {
        List<Integer> counts = new ArrayList<Integer>();
        int ptr = 0, n = s.length();
        while (ptr < n) {
            char c = s.charAt(ptr);
            int count = 0;
            while (ptr < n && s.charAt(ptr) == c) {
                ++ptr;
                ++count;
            }
            counts.add(count);
        }
        int ans = 0;
        for (int i = 1; i < counts.size(); ++i) {
            ans += Math.min(counts.get(i), counts.get(i - 1));
        }
        return ans;
    }
}

20. 467

在这里插入图片描述

在这里插入代码片

数字与字符间的转换

21.412

在这里插入图片描述

public List<String> fizzBuzz(int n) {
        /*给你一个整数 n ，找出从 1 到 n 各个整数的 Fizz Buzz 表示，并用字符串数组 answer（下标从 1 开始）返回结果，其中：
answer[i] == "FizzBuzz" 如果 i 同时是 3 和 5 的倍数。
answer[i] == "Fizz" 如果 i 是 3 的倍数。
answer[i] == "Buzz" 如果 i 是 5 的倍数。
answer[i] == i （以字符串形式）如果上述条件全不满足。*/
        List<String> res = new LinkedList<>();
        for(int i =0 ;  i < n ; i++){
            int k = i+1;
            if(k % 3 == 0 && k % 5 == 0){
                res.add("FizzBuzz");
            }else if(k % 3 == 0){
                res.add("Fizz");
            }else if( k % 5 == 0){
                res.add("Buzz");
            }else{
                res.add(String.valueOf(k));
            }
        }
        return res;
    }

22.506

在这里插入图片描述

public String[] findRelativeRanks(int[] score) {
          /*给你一个长度为 n 的整数数组 score ，其中 score[i] 是第 i 位运动员在比赛中的得分。所有得分都 互不相同 。
        运动员将根据得分 决定名次 ，其中名次第 1 的运动员得分最高，名次第 2 的运动员得分第 2 高，依此类推。运动员的名次决定了他们的获奖情况：
        名次第 1 的运动员获金牌 "Gold Medal" 。
        名次第 2 的运动员获银牌 "Silver Medal" 。
        名次第 3 的运动员获铜牌 "Bronze Medal" 。
        从名次第 4 到第 n 的运动员，只能获得他们的名次编号（即，名次第 x 的运动员获得编号 "x"）。
        使用长度为 n 的数组 answer 返回获奖，其中 answer[i] 是第 i 位运动员的获奖情况。*/
        int n = score.length;
        String[] desc = {"Gold Medal", "Silver Medal", "Bronze Medal"};
        int[][] arr = new int[n][2];

        for (int i = 0; i < n; ++i) {
            arr[i][0] = score[i];
            arr[i][1] = i;
        }
        Arrays.sort(arr, (a, b) -> b[0] - a[0]);
        String[] ans = new String[n];
        for (int i = 0; i < n; ++i) {
            if (i >= 3) {
                ans[arr[i][1]] = Integer.toString(i + 1);
            } else {
                ans[arr[i][1]] = desc[i];
            }
        }
        return ans;
    }

23.539

在这里插入图片描述

public int findMinDifference(List<String> timePoints) {
        Collections.sort(timePoints);
        int ans = Integer.MAX_VALUE;
        int t0Minutes = getMinutes(timePoints.get(0));
        int preMinutes = t0Minutes;
        for (int i = 1; i < timePoints.size(); ++i) {
            int minutes = getMinutes(timePoints.get(i));
            ans = Math.min(ans, minutes - preMinutes); // 相邻时间的时间差
            preMinutes = minutes;
        }
        ans = Math.min(ans, t0Minutes + 1440 - preMinutes); // 首尾时间的时间差
        return ans;
    }

    public int getMinutes(String t) {
        return ((t.charAt(0) - '0') * 10 + (t.charAt(1) - '0')) * 60 + (t.charAt(3) - '0') * 10 + (t.charAt(4) - '0');
    }

24.553

在这里插入图片描述
解法: 求一个数的最小值,应该怎么求,应该从头除到尾,就是它所在的最小,所以如果我们想让分母变小,分子变大的话,就应该保留第一个数,然后从第二个数从头除到尾.

class Solution {
    public String optimalDivision(int[] nums) {
        int n = nums.length;        
        if (n == 1) {
            return String.valueOf(nums[0]);
        }
        if (n == 2) {
            return String.valueOf(nums[0]) + "/" + String.valueOf(nums[1]);
        }
        StringBuffer res = new StringBuffer();
        res.append(nums[0]);
        res.append("/(");
        res.append(nums[1]);
        for (int i = 2; i < n; i++) {
            res.append("/");
            res.append(nums[i]);
        }
        res.append(")");
        return res.toString();
    }
}

537

在这里插入图片描述
分开俩个数,然后用乘法乘出来转字符串就行

 public String complexNumberMultiply(String num1, String num2) {
        String[] complex1 = num1.split("\\+|i");
        String[] complex2 = num2.split("\\+|i");
        int real1 = Integer.parseInt(complex1[0]);
        int imag1 = Integer.parseInt(complex1[1]);
        int real2 = Integer.parseInt(complex2[0]);
        int imag2 = Integer.parseInt(complex2[1]);
        return String.format("%d+%di", real1 * real2 - imag1 * imag2, real1 * imag2 + imag1 * real2);
    }

592—

在这里插入图片描述

640

在这里插入图片描述

作者：宫水三叶
链接：https://leetcode.cn/problems/solve-the-equation/solutions/1736347/by-ac_oier-fvee/

在这里插入图片描述

class Solution {
    public String solveEquation(String s) {
        int x = 0, num = 0, n = s.length();
        char[] cs = s.toCharArray();
        for (int i = 0, op = 1; i < n; ) {
            if (cs[i] == '+') {
                op = 1; i++;
            } else if (cs[i] == '-') {
                op = -1; i++;
            } else if (cs[i] == '=') {
                x *= -1; num *= -1; op = 1; i++;
            } else {
                int j = i;
                while (j < n && cs[j] != '+' && cs[j] != '-' && cs[j] != '=') j++;
                if (cs[j - 1] == 'x') x += (i < j - 1 ? Integer.parseInt(s.substring(i, j - 1)) : 1) * op;
                else num += Integer.parseInt(s.substring(i, j)) * op;
                i = j;
            }
        }
        if (x == 0) return num == 0 ? "Infinite solutions" : "No solution";    
        else return "x=" + (num / -x);
    }
}

38

在这里插入图片描述

 public String countAndSay(int n) {
        String str = "1";
        for (int i = 2; i <= n; ++i) {
            StringBuilder sb = new StringBuilder();
            int start = 0;
            int pos = 0;

            while (pos < str.length()) {
                while (pos < str.length() && str.charAt(pos) == str.charAt(start)) {
                    pos++;
                }
                sb.append(Integer.toString(pos - start)).append(str.charAt(start));
                start = pos;
            }
            str = sb.toString();
        }
        
        return str;
    }

子序列

392

在这里插入图片描述

 public boolean isSubsequence(String s, String t) {
        /*给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
        字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。
        （例如，"ace"是"abcde"的一个子序列，而"aec"不是）。
        进阶：
        如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，
        你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？*/
        // 判断是否存在这个字符 , 第二判断字符顺序是不是在了
        int fast =0 ,slow = 0;//快慢指针
        while (fast < t.length()){
            if (slow < s.length() &&s.charAt(slow) == t.charAt(fast)){
                slow++;
            }
            fast++;
        }
        return slow == s.length();

    }

524

在这里插入图片描述

class Solution {
     public boolean isSubsequence(String s, String t) {
        /*给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
        字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。
        （例如，"ace"是"abcde"的一个子序列，而"aec"不是）。
        进阶：
        如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，
        你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？*/
        // 判断是否存在这个字符 , 第二判断字符顺序是不是在了
        int fast =0 ,slow = 0;//快慢指针
        while (fast < t.length()){
            if (slow < s.length() &&s.charAt(slow) == t.charAt(fast)){
                slow++;
            }
            fast++;
        }
        return slow == s.length();

    }
     public String findLongestWord(String s, List<String> dictionary) {
        int fast=0,slow=0;
        int len =0,k =0;
        for (int i = 0; i < dictionary.size(); i++) {
            if (isSubsequence(dictionary.get(i),s)){

                if (dictionary.get(i).length() > len){
                    len = dictionary.get(i).length();
                    k = i;
                }else if (dictionary.get(i).length() == len){
                   if (dictionary.get(i).compareTo(dictionary.get(k)) <  0){
                       k = i;
                   }
                }

            }
        }
         if (len == 0)return "";
        return dictionary.get(k);
    }
}

521

在这里插入图片描述

public int findLUSlength(String a, String b) {
        /*给你两个字符串 a 和 b，请返回 这两个字符串中 最长的特殊序列  的长度。如果不存在，则返回 -1 。
            「最长特殊序列」 定义如下：该序列为 某字符串独有的最长子序列（即不能是其他字符串的子序列） 。
            字符串 s 的子序列是在从 s 中删除任意数量的字符后可以获得的字符串。
            例如，"abc" 是 "aebdc" 的子序列，因为删除 "aebdc" 中斜体加粗的字符可以得到 "abc" 。
            "aebdc" 的子序列还包括 "aebdc" 、 "aeb" 和 "" (空字符串)。*/
       
        if(a.equals(b))
            return -1;
        return a.length() > b.length() ? a.length() : b.length();
    }

522

在这里插入图片描述

高精度运算

66

在这里插入图片描述

public int[] plusOne(int[] digits) {

        for (int i = digits.length - 1; i >= 0; i--) {
            if (digits[i] == 9) {
                digits[i] = 0;
            } else {
                digits[i] += 1;
                return digits;
            }

        }
        //如果所有位都是进位，则长度+1
        digits= new int[digits.length + 1];
        digits[0] = 1;
        return digits;
    }

67

在这里插入图片描述

public String addBinary(String a, String b) {
        /*给你两个二进制字符串 a 和 b ，以二进制字符串的形式返回它们的和。*/
        StringBuilder res = new StringBuilder(); // 返回结果
        int i = a.length() - 1; // 标记遍历到 a 的位置
        int j = b.length() - 1; // 标记遍历到 b 的位置
        int carry = 0; // 进位
        while (i >= 0 || j >= 0 || carry != 0) { // a 没遍历完，或 b 没遍历完，或进位不为 0
            int digitA = i >= 0 ? a.charAt(i) - '0' : 0; // 当前 a 的取值
            int digitB = j >= 0 ? b.charAt(j) - '0' : 0; // 当前 b 的取值
            int sum = digitA + digitB + carry; // 当前位置相加的结果
            carry = sum >= 2 ? 1 : 0; // 是否有进位
            sum = sum >= 2 ? sum - 2 : sum; // 去除进位后留下的数字
            res.append(sum); // 把去除进位后留下的数字拼接到结果中
            i --;  // 遍历到 a 的位置向左移动
            j --;  // 遍历到 b 的位置向左移动
        }
        return res.reverse().toString(); // 把结果反转并返回
    }

415

在这里插入图片描述
定义两个指针 i和 j分别指向 num1 和 num2的末尾，即最低位，同时定义一个变量 add 维护当前是否有进位，然后从末尾到开头逐位相加即可。你可能会想两个数字位数不同怎么处理，这里我们统一在指针当前下标处于负数的时候返回 0，等价于对位数较短的数字进行了补零操作，这样就可以除去两个数字位数不同情况的处理，具体可以看下面的代码。

class Solution {
     public String addStrings(String num1, String num2) {
        int i = num1.length() - 1, j = num2.length() - 1, add = 0;
        StringBuffer ans = new StringBuffer();
        while (i >= 0 || j >= 0 || add != 0) {
            int x = i >= 0 ? num1.charAt(i) - '0' : 0;
            int y = j >= 0 ? num2.charAt(j) - '0' : 0;
            int result = x + y + add;
            ans.append(result % 10);
            add = result / 10;
            i--;
            j--;
        }
        // 计算完以后的答案需要翻转过来
        ans.reverse();
        return ans.toString();
    }


}

字符串匹配

28

在这里插入图片描述
KMP算法

class Solution {
    public int strStr(String haystack, String needle) {
       return getIndexOf(haystack,needle);
    }
    public static int getIndexOf(String s,String m){
        if (s == null || m == null || m.length() >s.length() || m.length() < 1){
            return -1;
        }
        char[] str1 = s.toCharArray();
        char[] str2 = m.toCharArray();
        int i1= 0;
        int i2 = 0;
        int[] next = getNextArray(str2);//O(M)
        while (i1 < str1.length && i2 < str2.length){
            //i2 == str2.length的时候代表着,肯定匹配到了
            //O(N)
            if (str1[i1] == str2[i2]){
                //如果相等,继续往后匹配
                i1++;
                i2++;
            }else if (next[i2] == -1){
                //如果没有前缀和后缀匹配的,那没办法,只能往后走了
                i1++;
            }else {
                //如果不等,则找前缀和后缀最大的那个
                //要验证之前走过的是否有与str2匹配的情况
                i2 = next[i2];
            }
        }
        return i2 == str2.length ? i1-i2:-1;
    }
    public static int[] getNextArray(char[] ms){
        if (ms.length == 1){
            return new int[]{-1};
        }
        int[] next = new int[ms.length];
        next[0] = -1;
        next[1] = 0;
        int i = 2;
        int cn = 0;//即代表那个位置的值与i-1的值比
        while (i < next.length){
            if (ms[i-1] == ms[cn]){
                next[i++] = ++cn;
            }else if (cn > 0){
                //当前跳到cn位置的字符,和i-1位置的对应不上
                cn = next[cn];
            }else {
                //当cn为-1的时候,代表跳到了0下标的位置了
                next[i++] = 0;
            }
        }
        return next;
    }
}

686

在这里插入图片描述
本质还是kmp,先让字符串a 叠加的长度超过字符串b,然后调用kmp即可

class Solution {
    public int repeatedStringMatch(String a, String b) {
        StringBuilder sb = new StringBuilder();
        int ans = 0;
        while (sb.length() < b.length() && ++ans > 0) sb.append(a);
        sb.append(a);
        int idx = strStr(sb.toString(), b);
        if (idx == -1) return -1;
        return idx + b.length() > a.length() * ans ? ans + 1 : ans;
    }

    int strStr(String ss, String pp) {
        if (pp.isEmpty()) return 0;
        
        // 分别读取原串和匹配串的长度
        int n = ss.length(), m = pp.length();
        // 原串和匹配串前面都加空格，使其下标从 1 开始
        ss = " " + ss;
        pp = " " + pp;

        char[] s = ss.toCharArray();
        char[] p = pp.toCharArray();

        // 构建 next 数组，数组长度为匹配串的长度（next 数组是和匹配串相关的）
        int[] next = new int[m + 1];
        // 构造过程 i = 2，j = 0 开始，i 小于等于匹配串长度 【构造 i 从 2 开始】
        for (int i = 2, j = 0; i <= m; i++) {
            // 匹配不成功的话，j = next(j)
            while (j > 0 && p[i] != p[j + 1]) j = next[j];
            // 匹配成功的话，先让 j++
            if (p[i] == p[j + 1]) j++;
            // 更新 next[i]，结束本次循环，i++
            next[i] = j;
        }

        // 匹配过程，i = 1，j = 0 开始，i 小于等于原串长度 【匹配 i 从 1 开始】
        for (int i = 1, j = 0; i <= n; i++) {
            // 匹配不成功 j = next(j)
            while (j > 0 && s[i] != p[j + 1]) j = next[j];
            // 匹配成功的话，先让 j++，结束本次循环后 i++
            if (s[i] == p[j + 1]) j++;
            // 整一段匹配成功，直接返回下标
            if (j == m) return i - m;
        }
        return -1;
    }
}

459

在这里插入图片描述
解决方法: 枚举一半的字符串长度,来进行匹配

class Solution {
    public boolean repeatedSubstringPattern(String s) {
        int n = s.length();
        for (int i = 1; i * 2 <= n; ++i) {
            if (n % i == 0) {
                boolean match = true;
                for (int j = i; j < n; ++j) {
                    if (s.charAt(j) != s.charAt(j - i)) {
                        match = false;
                        break;
                    }
                }
                if (match) {
                    return true;
                }
            }
        }
        return false;
    }
}
Mriacles
关注
力扣刷题总结-字符串翻转
weixin_40966030的博客
08-25 418
1、给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。 ...
力扣刷题—字符串
m0_38057941的博客
04-06 300
1.14. 最长公共前缀 最长公共前缀 编写一个函数来查找字符串数组中的最长公共前缀。 如果不存在公共前缀，返回空字符串 “”。 1.解题思路（横向对比） 1.新建变量comm储存当前的公共前缀，初始化为字符串数组的元素； 2.对每一个字符串s进行遍历，comm与s的字符从前向后进行比较，遇到不同的时跳出； 3.当公共部分长度为0时，跳出。 class Solution { public String longestCommonPrefix(String[] strs) {
力扣刷题篇——字符串
weixin_59796310的博客
06-02 751
力扣刷题篇——字符串
力扣分类刷题（字符串第一次）
j15941558855的博客
05-31 147
字符串 344.反转字符串：reverse，直接双指针swap。 541.反转字符串II:基本上同上，注意reverse要用迭代器reverse(s.begin() + temp ,s.begin() + temp + k); 剑指Offer 05.替换空格：注意两点：一个是用s.resize(s.size() + count * 2);不用memset，直接用字符串的resize，另一个是要从后往前遍历替换。 从前向后填充就是O(n^2)的算法了，因为每次添加元素都要将添加元素之后的所.
力扣刷题----42. 接雨水
愿你历尽千帆，归来仍是少年。
07-28 942
动态规划（Dynamic Programming，简称DP）是一种在数学、管理科学、计算机科学、经济学和生物信息学等领域中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。动态规划经常用于求解具有重叠子问题和最优子结构性质的问题。这里的“重叠子问题”是指在递归算法中反复出现的问题，而“最优子结构”是指问题的最优解包含其子问题的最优解。
力扣刷题 -- BFS 与 DFS
I_am_toutu的博客
07-24 1006
(2) 利用队列 que，将入度为 0 的点，放到队列中 【当顶点的入度为 0 ，相当于对应的课程已经学习完了，若仍有些课程的入度不为 0，说明图中存在环，无法被选，完成不了所有课】；(3) 从队列中得到入度为 0 的顶点，假设将这个顶点去掉，则对应的被指向的顶点的入度应被减一；比如 {1：[3, 4]} 表明为顶点 1 同时指向 3 和 4，in[3] = 2 相当于顶点 3 的入度为 2；(2) 若存在一条从顶点A到顶点B的路径，那么在序列中顶点A出现在顶点 B 的前面。方式二：双向 BFS。
力扣刷题 -- 树
I_am_toutu的博客
07-09 1116
尽管 vals 数组的元素不是有序的，但 左子树的区间的整体值 一定小于 右子树区间整体的值，因此我们可以在 [left+1, right] 区间内使用二分法查找第一个大于根节点值的位置，从而确定右子树的起始位置；：使用递归完成二叉树的构建，在递归函数内需要确定右边界的开始索引，因此可以从根节点的开始往后遍历，找到第一个比它大的元素。举例【前序遍历 + BST】：[2,1,3]，[5, 3, 1, 4, 7]，[5, 2, 1, 3, 7, 6, 9, 8, 10]。当队列不为空时，取出队列中的节点；
力扣刷题 --（复习动态规划）
分享技术，分享经验
08-28 1285
确定DP数组（或表）中的状态代表什么。状态通常是对问题的某一方面的描述，可以是一个数组或矩阵中的一个元素。
Leetcode刷题笔记-字符串总结
o_0u0_o的博客
04-25 325
首先明确两个概念：子串与子序列。 比如一个字符串“aaabbc”的一个子串为“aaa”。而“abc”是它的一个子序列。即子串必须是在字符串中连续的，而子序列可不连续，但在字符串中的索引需要是升序的（“cba”就不是子序列）。 回文字符串 回文字符串指正序遍历和逆序遍历完全相同的字符串。 一个简单的题目认识回文字符串。 “回文串”是一个正读和反读都一样的字符串，比如“level”或者“noon”等等就是回文串。花花非常喜欢这种拥有对称美的回文串，生日的时候她得到两个礼物分别是字符串A和字符串B。现在她非
力扣刷题算法截图汇总2021
04-02
2021年的力扣刷题算法截图汇总是一个珍贵的学习资源，它可能包含了当年力扣上的热门问题及其解决方案的截图。由于标签为"python"，我们可以推断这些截图主要涉及使用Python语言解决这些问题。 在Python编程中，解决...
leetcode中国-LeetCode-Notes:力扣刷题，力扣探索学习，分享交流
06-29
:water_wave:力扣刷题，力扣探索学习，我的LeetCode刷题学习计划:rocket: :water_wave:为了促进刷题学习，我建立了这个仓库促进我刷题 我的Github： 我的LeetCode： 联系我？:clinking_beer_mugs: :closed_mailbox_...
力扣刷题笔记总结记录666
01-13
给定一个字符串 s，请你判断该字符串是否是有效的括号序列。 四、链表的用法举例 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 本资源摘要信息涵盖了链表、...
C++ | Leetcode C++题解之第514题自由之路
Ddddddd_158的博客
10-27 403
C++ | Leetcode C++题解之第514题自由之路
Java | Leetcode Java题解之第514题自由之路
m0_57195758的博客
10-27 291
Java | Leetcode Java题解之第514题自由之路
力扣-最小覆盖子串
Dennis_nafla的博客
10-29 248
可以定义一个distance这样的int变量，当移动右指针后，如果此时右指针指向的字符在当前窗口中的个数严格小于t中所需要的个数，那么distance++。滑动窗口，初始时左右指针都指向s的第一个字符,对于每个遍历到的窗口，判断当前窗口是否包含了t中所需要的所有字符，不是的话就移动右指针，是的话就移动左指针。在移动左指针前,如果此时左指针指向的字符在当前窗口中的个数等于t中所需要的个数，那么distance--。给定一个字符串s,和目标字符串t，需要找出s中包含t中所有字符且长度最小子串，输出这个子串。
【二分查找】【三种写法】——在排序数组中查找元素的第一个和最后一个位置#力扣hot100
最新发布
weixin_47868976的博客
10-31 718
给你一个按照非递减顺序排列的整数数组nums，和一个目标值target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值target，返回[-1, -1]。必须设计并实现时间复杂度为O(log n)的算法解决此问题。
LeetCode115：不同的子序列
Ricky_youngone的博客
10-29 239
这个是因为先判断s[i - 1]==t[i - 1]的话，第一种情况就是我们的s和t串都往前走一个单位，这个算一个，然后再加上能够符合这个条件的方案，也即是dp[i - 1][j]，这个就是t串不走了，但是s串能往前走，并且还相等的。这里就把dp[i][0] = 1;这个也需要我们去画一个2*2的方格，然后去看到这个dp[i][j]是从哪两个方向推导出来的，比如这个题，就可以从由上到下，由左到右推导出来这个公式，那么遍历顺序就直接从1开始就好。dp含义：以i-1为结尾的s中有以j-1为结尾的t的个数为。
【LeetCode】每日一题 2024_10_29 生成不含相邻零的二进制字符串（DFS）
Locky136的博客
10-29 300
【LeetCode】每日一题 2024_10_29 生成不含相邻零的二进制字符串（DFS）
力扣中等题——顺次数
WenJGo的博客
10-28 608
力扣每日一题——中等难度，简单思想，面向测试用例编程，有趣的题解实现！新手也能学会！！！！
力扣刷题--LCR 135. 报数python
07-23
"LCR 135. 报数" 是力扣（LeetCode）上的一个问题编号，它是一个经典的Python编程题目，涉及到数组操作和游戏策略。在这个“报数”游戏中，给定一个非空整数数组 `nums` 和两个整数 `m` 和 `n`，玩家轮流从数组中选择一个元素并将其乘以 `m` 或者除以 `n`（除数必须是正整数），直到数组所有元素变为相同的值。如果数组中的最后一个元素不是 1，那么游戏结束，当前玩家失败。 以下是你可以参考的基本思路： 1. 初始化变量 `target` 为数组的最大元素，这将是游戏的目标值。 2. 遍历数组计算目标值 `target`，同时更新每个元素的最小倍数，即 `minTimes[i] = log(target / nums[i])`，表示让 nums[i] 变为 target 所需的最小步数。 3. 创建一个布尔数组 `visited` 来标记哪些元素已经被选过。 4. 使用递归模拟游戏过程：对于每个未访问过的元素，检查当前玩家能否通过操作使其满足目标条件；然后递归地尝试对手的操作。 5. 返回最后一位玩家是否可以达到获胜状态，也就是目标值为 1。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值