2023秋招算法题每日学习(13)

DAY 13

1.AcWing 873. 欧拉函数

考察点：欧拉函数 原理：容斥原理

 

 

 

 注：在使用欧拉函数公式的时候，要防止出现小数，应该把N(1-1/p)更改为N/p(p-1)

具体实现代码如下：

#include<iostream>

using namespace std;

int phi(int x)
{
    int res = x;
    for(int i = 2;i<=x/i;i++)
    {
        if(x%i==0) res = res/i*(i-1);//防止出现小数
        while(x%i==0) x/=i;
    }
    if(x>1) res = res/x*(x-1);
    return res;
}

int main()
{
    int n;
    cin>>n;
    while(n--)
    {
        int x;
        cin>>x;
        cout<<phi(x)<<endl;
    }
    return 0;
}

2.LeetCode 28. 找出字符串中第一个匹配项的下标

考察点：KMP算法 O(n+m)

KMP的经典思想就是:当出现字符串不匹配时，可以记录一部分之前已经匹配的文本内容，利用这些信息避免从头再去做匹配。

前缀表：

next数组就是一个前缀表（prefix table）

前缀表是用来回退的，它记录了模式串与主串(文本串)不匹配的时候，模式串应该从哪里开始重新匹配。

前缀表：记录下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀

最长公共前后缀：

字符串的前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串

 后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串

最长公共前后缀就是指：相同前后缀的长度

 

        下标5之前这部分的字符串（也就是字符串aabaa）的最长相等的前缀 和 后缀字符串是 子字符串aa ，因为找到了最长相等的前缀和后缀，匹配失败的位置是后缀子串的后面，那么我们找到与其相同的前缀的后面重新匹配就可以了。

如何计算前缀表：

最长相同前后缀的长度就是对应前缀表的元素

 可以看出模式串与前缀表对应位置的数字表示的就是：下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。

找到的不匹配的位置， 那么此时我们要看它的前一个字符的前缀表的数值是多少。为什么要前一个字符的前缀表的数值呢，因为要找前面字符串的最长相同的前缀和后缀。

 前缀表和NEXT数组

        next数组就可以是前缀表，但是很多实现都是把前缀表统一减一（右移一位，初始位置为-1）之后作为next数组。

使用next数组来匹配

        

 构造next数组

定义一个函数getNext来构建next数组，函数参数为指向next数组的指针，和一个字符串

void getNext(int* next, const string& s)

构造next数组其实就是计算模式串s，前缀表的过程。 主要有如下三步：

1. 初始化
2. 处理前后缀不相同的情况
3. 处理前后缀相同的情况

 具体操作见《代码随想录》

具体实现代码如下：(前缀表统一减一)

class Solution {
public:
    void getNext(int* next,const string &s)
    {
        int j = -1;
        next[0] = -1;
        for(int i = 1;i<s.size();i++)//注意i从1开始
        {
            while(j>=0&&s[i]!=s[j+1])
            {
                //前后缀不相等
                j = next[j];
            }
            if(s[i] == s[j+1])
            {
                //找到相同的前后缀
                j++;
            }
            next[i] = j;//将j(前缀的长度)赋值给next[i]
        }
    }

    int strStr(string haystack, string needle) //前缀表统一减一
    {
        if(needle.size() == 0)
        {
            return 0;
        }
        int next[needle.size()];
        getNext(next,needle);
        int j = -1;//next数组记录的起始位置为-1
        for(int i = 0;i<haystack.size();i++)//注意i从0开始匹配
        {
            while(j>=0&&haystack[i]!=needle[j+1])//不匹配
            {
                j = next[j];
            }
            if(haystack[i] == needle[j+1])
            {
                j++;//匹配时i和j同时向后退
            }
            if(j == needle.size()-1)
            {
                //匹配成功
                return(i-needle.size()+1);
            }
            
        }
        return -1;
    }
};

3. LeetCode 459 重复的子字符串

考察点：KMP算法

解法：移动匹配（调用find等库函数进行求解）和KMP算法 这里选择KMP算法

在由重复子串组成的字符串中，最长相等前后缀不包含的子串就是最小重复子串，这里拿字符串s：abababab 来举例，ab就是最小重复单位，如图所示：

 

步骤一：因为 这是相等的前缀和后缀，t[0] 与 k[0]相同， t[1] 与 k[1]相同，所以 s[0] 一定和 s[2]相同，s[1] 一定和 s[3]相同，即：，s[0]s[1]与s[2]s[3]相同 。

步骤二： 因为在同一个字符串位置，所以 t[2] 与 k[0]相同，t[3] 与 k[1]相同。

步骤三： 因为 这是相等的前缀和后缀，t[2] 与 k[2]相同 ，t[3]与k[3] 相同，所以，s[2]一定和s[4]相同，s[3]一定和s[5]相同，即：s[2]s[3] 与 s[4]s[5]相同。

步骤四：循环往复。

所以字符串s，s[0]s[1]与s[2]s[3]相同， s[2]s[3] 与 s[4]s[5]相同，s[4]s[5] 与 s[6]s[7] 相同。

正是因为 最长相等前后缀的规则，当一个字符串由重复子串组成的，最长相等前后缀不包含的子串就是最小重复子串。

具体实现代码如下：

class Solution {
public:
    void getNext(int* next,const string& s)
    {
        next[0] = -1;
        int j = -1;
        for(int i = 1;i<s.size();i++)
        {
            while(j>=0&&s[i]!=s[j+1])
            {
                j = next[j];
            }
            if(s[i] == s[j+1])
            {
                j++;
            }
            next[i] = j;
        }
    }

    bool repeatedSubstringPattern(string s) 
    {
        if(s.size() == 0)
        {
            return false;
        }
        int next[s.size()];
        getNext(next,s);
        int len = s.size();
        if(next[len-1]!=-1&&len%(len-(next[len-1]+1)) == 0)//next数组记录的是最长相等前后缀的长度，如果next[len-1]!=-1，说明有相同的前后缀；最长相等先后缀的长度为next[len-1]+1，数组长度为len，如果len%(len-(next[len-1]+1)) == 0，说明最小重复子串可以被整除，返回true
        {
            return true;
        }
        return false;
    }
};

4.AcWing 874 筛法求欧拉函数

考察点：欧拉函数 线性筛法

 

 具体实现代码如下：

#include<iostream>

using namespace std;

typedef long long LL;

const int N = 1000010;

int primes[N],cnt;//分别为存储质因子 数目
int euler[N];
bool st[N];

int get_euler(int n)
{
    euler[1] = 1;
    //线性筛法
    for(int i = 2;i<=n;i++)
    {
        if(!st[i])
        {
            primes[cnt++] = i;
            euler[i] = i - 1; //质数i的欧拉函数即为euler[i] = i - 1：1 ~ i−1均与i互质，共i−1个。
        }
        for(int j = 0;primes[j]<=n/i;j++)
        {
            int t = primes[j]*i;
            st[t] = true;
            if(i%primes[j] == 0)
            {
                  euler[t] = euler[i] * primes[j];
                  break;
            }
            euler[t] = euler[i]* (primes[j] - 1);
        }
    }
}

int main()
{
    int n;
    cin>>n;
    get_euler(n);
    LL res = 0;
    for(int i = 1;i<=n;i++) res+=euler[i];
    cout<<res<<endl;
    return 0;
    
}