LQ24fresh - 技术栈

[C. 录入成绩](#C. 录入成绩)

[D. 标记名字](#D. 标记名字)

[E. 奖杯排列](#E. 奖杯排列)

C. 录入成绩

（1）以国特 'G' 为切入点，枚举每一个 'G' 单独时是否为合法字符串，若合法 'G1' 有多少个

（2）用到的两个 string 函数：

**·**s.erase( i, a ) ：从第 i 个字符开始，删掉 a 个字符

**·**s.substr( i, a ) ：从第 i 个字符开始，截取 a 个字符

（3）map 统计每种奖项出现次数。确保每种奖项都出现过

#include<bits/stdc++.h>
#define int long long
using namespace std;

const int N = 1e5 + 5, INF = 1e18;
int t, n, cnt, ans;
string s;
map<string, int> mp;

signed main()
{
	cin >> s;
	int len = s.length();
	s = ' ' + s;
	for (int i = 1; i <= len; i ++)
	{
		mp.clear();
		if (s[i] == 'G')
		{
			string t = s;
			t.erase(i, 1); 
			for (int j = 1; j < len; j ++)
			{
				if (t[j] == 'G' && j + 1 < len)
					mp[t.substr(j, 2)] ++, j ++;
				else
					mp[t.substr(j, 1)] ++;
			}
			if (mp.find("G") == mp.end() && mp.size() == 7)    // 没有单独的 'G' 且所有奖项都出现过
				ans = max(ans, mp["G1"]);
		}
	}
	cout << ans;
	return 0;
}

D. 标记名字

（1）法一：记忆化搜索，一般是从大问题到小问题搜

（2）开不了 1e10 的数组，用 map 来离散化

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e5 + 5, INF = 1e18;

int T, n, ans;
string s;
map<int, int> mp;

int dfs(int n)
{
	if (mp.find(n) != mp.end())
		return mp[n];
	mp[n] = n - 1;
	for (int i = 2; i * i <= n; i ++)
	{
		if (n % i == 0)
		{
			mp[n] -= dfs(i);
			if (i * i != n)                // 如果不是完全平方数就会有两个约数，一块减掉
				mp[n] -= dfs(n / i);
		}
	}
	return mp[n];
}

signed main()
{
	cin >> n;
	cout << dfs(n);
	return 0;
}

（3）法二：欧拉函数：返回值为 1 - n 中与 n 互质的数的个数。只要不互质就能约分，就会重复

#include<bits/stdc++.h>
#define int long long
using namespace std;

const int N = 1e5 + 5, INF = 1e18;
int t, n, cnt, ans;
string s;

signed main()
{
    cin >> n;
    ans = n;
    for (int i = 2; i <= sqrt(n); i ++)
    {
        if (n % i == 0)
        {
            ans = ans / i * (i - 1);
            while (n % i == 0)
                n /= i;
        }
    } 
    if (n > 1)
        ans = ans / n * (n - 1);
    cout << ans;
    return 0;
}

E. 奖杯排列

（1）奖杯上的数字很大，用 map 来实现离散化

（2）mp1[ a[ i ] ] 代表以 a[ i ] 为结尾有多少个数列，mp2[ a[ i ] ] 代表当前位置前面 a[ i ] 出现了多少次。

（3）mp1[ a[ i ] ] 分两类转移：

**·**以 a[ i ] - k 为结尾的数列有多少个，以 a[ i ] 为结尾的数列就有多少个，只是在前者的最后再加上一个 a[ i ]。此时数列中个数大于等于三，因为以 a[ i ] 为结尾的数列至少有两个元素

**·**a[ i ] 与 a[ i ] - k 组成一个新的数列，因为 a[ i ] - k 无法单独成一个数列，因此不会被算入第一种情况。此时数列中个数等于二

#include<bits/stdc++.h>
#define int long long
using namespace std;

const int N = 2e5 + 5, INF = 1e18, mod = 1e9 + 7;
int t, n, k, cnt, ans, a[N];
string s;
map<int, int> mp1, mp2;

signed main()
{
	cin >> n >> k;
	for (int i = 1; i <= n; i ++)
		cin >> a[i];
	for (int i = 1; i <= n; i ++)
	{
        // 情况一
		if (mp1.find(a[i] - k) != mp1.end())
		{
			mp1[a[i]] += mp1[a[i] - k];
			mp1[a[i]] %= mod;
		}
        
        // 情况二
		if (mp2.find(a[i] - k) != mp2.end())
		{
			mp1[a[i]] += mp2[a[i] - k];
			mp1[a[i]] %= mod;
		}
		mp2[a[i]] ++;
	}
	map<int, int> :: iterator it;
	for (it = mp1.begin(); it != mp1.end(); it ++)
	{
		ans += it -> second;
		ans %= mod;
	}
	cout << ans; 
	return 0;
}