8月算法训练------第二天（字符串）解题报告

题目类型：字符串
题目难度：简单

第一题、2278. 字母在字符串中的百分比

1. 题目链接：2278. 字母在字符串中的百分比
2. 思路分析：
   这一题很简单，只需遍历一遍字符串，找出与letter相同的字符个数，然后再除以s的长度就行了，记得结果要乘100哦。
3. 代码：

class Solution {
    public int percentageLetter(String s, char letter) {
        if(s.length() == 0) return 0;
        char[] ch = s.toCharArray();
        int sum = 0;
        for(char c : ch){
            if(c == letter){
                sum++;
            }
        }
        return sum * 100 / s.length();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

第二题、551. 学生出勤记录 I

1. 题目链接：551. 学生出勤记录 I
2. 思路分析：
   先满足第一个条件，当字符串中出现A的个数大于等于2时就返回false；
   然后再遍历一次字符串，看其中是否有"LLL"的子串，如果有，则返回false；
   当以上两种条件都不满足，就返回true。
3. 代码：

class Solution {
    public boolean checkRecord(String s) {
        char[] ch = s.toCharArray();
        int sumA = 0;
        for(int i = 0; i < s.length(); i++){
            if(ch[i] == 'A'){
                sumA++;
            }
        }
        if(sumA >= 2){
            return false;
        }
        for(int i = 0; i <= s.length() - 3; i++){
            if(s.substring(i, i+3).equals("LLL")){
                return false;
            }
        }
        
        return true;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

第三题、2255. 统计是给定字符串前缀的字符串数目

1. 题目链接：2255. 统计是给定字符串前缀的字符串数目
2. 思路分析：
   遍历字符数组，当字符串的前缀等于words[i]时，就认为words[i]是s的前缀，就将结果加1。
3. 代码：

class Solution {
    public int countPrefixes(String[] words, String s) {
        int res = 0;
        for(String str : words){
            if(str.length() <= s.length()){
                if(s.substring(0, str.length()).equals(str)){
                    res++;
                }
            }
        }
        return res;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

第四题、1071. 字符串的最大公因子

1. 题目链接：1071. 字符串的最大公因子
2. 思路分析：
   这一题要用到辗转相除法。
   我们如何判断str1和str2有共同的公因子呢？
   这里方法很巧妙，也很简单，就是将str1与str2拼接，然后和str2与str1拼接进行比较，结果相同则说明他们有公共因子。
   当我们知道它们有公共因子时，就需要找出这个公共因子是啥，这里就需要用到辗转相除法了，辗转相除法也不难，用代码很好实现。
3. 代码：

class Solution {
    public String gcdOfStrings(String str1, String str2) {
        if(!str1.concat(str2).equals(str2.concat(str1))){
            return "";
        }
        return str1.substring(0, gdc(str1.length(), str2.length()));
    }
    public int gdc(int a, int b){
        int reminder = a % b;
        while(reminder != 0){
            a = b;
            b = reminder;
            reminder = a % b;
        }
        return b;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

剑指offer

题目类型：递归和回溯
题目难度：中等

第五题、剑指 Offer 12. 矩阵中的路径

1. 题目链接：剑指 Offer 12. 矩阵中的路径
2. 思路分析：
   运用深度优先算法，思路逻辑就是：
   看当前矩阵中的数board[i][j]，先要判断的时i和j是否越界，如果越界或者当前位与word的第k位不同，则返回false；
   然后判断能返回true的情况，能走到这一步肯定是board[i][j]与word[k]相等，这是只需判断k==word.length-1是否成立，若成立，则说明已经匹配完成，可以匹配的上，就返回true。
   将递归结束条件列举完了，接下来就是递归体了。
   首先，需要将当前遍历的位设置为空字符，以表示当前位置已经遍历过，然后将左右下上依次进行dfs，这四个方向只要其中有一个能与当前位保持一致，就判定为能行。
   最后将这个结果返回就行。
3. 代码：

class Solution {

    public boolean exist(char[][] board, String word) {
        int m = board.length, n = board[0].length;
        char[] words = word.toCharArray();
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                if(dfs(board, words, i, j, 0)){
                    return true;
                }
            }
        }
        return false;
    }
    public boolean dfs(char[][] board, char[] words, int i, int j, int k){
        if(i > board.length - 1 || i < 0 || j > board[0].length - 1 || j < 0 || board[i][j] != words[k]){
            return false;
        }
        if(k == words.length - 1){
            return true;
        }
        board[i][j] = '\0';
        boolean res = dfs(board, words, i+1, j, k+1) || dfs(board, words, i-1, j, k+1) ||
                        dfs(board, words, i, j+1, k+1)||dfs(board, words, i, j-1, k+1);
        board[i][j] = words[k];
        return res;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

第六题、面试题13. 机器人的运动范围

1. 题目链接：面试题13. 机器人的运动范围
2. 代码：

class Solution {
    int m;
    int n;
    int k;
    boolean[][] visited;

    public int movingCount(int m, int n, int k) {
        this.m = m;
        this.n = n;
        this.k = k;
        visited = new boolean[m][n];
        return dfs(0, 0, 0, 0);
    }

    public int dfs(int i, int j, int si, int sj) {
        if (i >= m || j >= n || k < si + sj || visited[i][j]) return 0;
        visited[i][j] = true;
        return 1 + dfs(i + 1, j, (i + 1) % 10 != 0 ? (si + 1) : (si - 8), sj) +
                dfs(i, j + 1, si, (j + 1) % 10 != 0 ? (sj + 1) : (sj - 8));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21