🔥博客主页： A_SHOWY
🎥系列专栏：力扣刷题总结录 数据结构  云计算  数字图像处理  力扣每日一题_ 

【1】100212.统计前后缀下标对

100212. 统计前后缀下标对 Ihttps://leetcode.cn/problems/count-prefix-and-suffix-pairs-i/

熟练掌握判断前后缀的bool方法就好。

class Solution {
public:
 bool isPrefix(const string& str,const string& prefix){
             if(str.length() < prefix.length()){
                 return false;
             }
             return str.substr(0,prefix.length()) == prefix;
        }

        bool isSuffix(const string& str,const string& suf){
            if(str.length() < suf.length()){
                return false;
            }
            return str.substr(str.length() - suf.length()) == suf;
        }
    int countPrefixSuffixPairs(vector<string>& words) {
       int sum = 0;
       for(int i = 0; i < words.size(); ++i){
           for(int j = i + 1; j < words.size(); ++j){
               if(isPrefix(words[j],words[i]) && isSuffix(words[j],words[i])){
                   sum++;
               }
           }
       }
    return sum;

    }
};

【2】100229 最长公共前缀的长度

100229. 最长公共前缀的长度https://leetcode.cn/problems/find-the-length-of-the-longest-common-prefix/

这道题目是一个较为简单的哈希表的问题，难点是能否想到转换成将arr1的所有元素的前缀存入哈希表，然后对arr2进行遍历，找最长的公共前缀（找最大的数），从最大的数，除以10操作，直到包含在st哈希表中。

1. 将arr1的所有前缀存起来，让arr2从最大的数一直除以10找到最大（最长）公共前缀。
2. 时间复杂度，对于一个数M，其长度为logM，arr1的长度为m，arr2的长度为n， 所以时间复杂度是O（（m + n）log（M））

class Solution {
public:

    int longestCommonPrefix(vector<int>& arr1, vector<int>& arr2) {
        unordered_set<int> st;
        for(int x : arr1){
            for(;x;x /= 10){
                st.insert(x);
            }
        }
        int mres = 0;
        for(int x : arr2){
        for(;x && !st.contains(x); x /= 10);
            mres = max(mres,x);
        }
        
        return mres ? to_string(mres).length() : 0;
        
    }
}; 

 【3】出现频率最高的的质数

3044. 出现频率最高的质数https://leetcode.cn/problems/most-frequent-prime/

这道题目的主要特点就是繁琐，需要设置一个constexpr，然后要判断是否为质数，再进行循环模拟，最后求出出现次数最多的质数，如果一般多，还要比较大小。思路就是用哈希表存一下。

1. 首先是第一部分求质数，熟练了就好，记住i从2开始，不然会报错除以0
2. 第二部分就是记住constexpr设置8个方向，然后对每个点进行遍历，这里一定注意等号不要越界，每个方向一条道走到黑，只要不越界，然后记录这个数，判断是不是质数，是的话哈希表这个数就加一
3. 最后一部分是判断了遍历，看谁的值大，就是次数多。 

class Solution {
public:
   static constexpr int dirs[8][2] = {{1,0},{1,-1},{0,-1},{-1,-1},{-1,0},{-1,1},{0,1},{1,1}};
   bool is_prime(int n){
    for(int i = 2; i * i <= n; i++){
        if(n % i == 0) {
            return false;
        }
    }
        return true;
   }
   
    int mostFrequentPrime(vector<vector<int>>& mat) {
        int m = mat.size();
        int n = mat[0].size();
        unordered_map<int,int> mp;
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                for(auto &d : dirs){
                         int x = i + d[0];int y = j + d[1];
                         int v = mat[i][j];
                         while(x >= 0 && x < m && y >= 0 && y < n){
                             v= v * 10 + mat[x][y];
                             if(is_prime(v)){
                                 mp[v]++;
                             }
                             x += d[0];
                             y += d[1];
                         }
                }
            }
        }

        int ans = -1,mx_prime = 0;
            for(auto &[v,c] : mp){//v是数，c是个数
                if(c > mx_prime){
                         ans = v;
                         mx_prime = c;
                }
                else if(c == mx_prime){
                    ans = max(ans,v);
                }
            }
            return ans;
    }
};