2022牛客寒假基础训练营第4场记录

题解链接
题目链接

J 区间合数的最小公倍数

知识点： 统计N个数的最小公倍数，也就是统计所有素数因子出现的最高次数，然后将其相乘即可。
比如：a = 2² × 3¹ ×5³ b = 2¹ × 3² ×5² 那么最小公倍数就是2² × 3² × 5³

#include <bits/stdc++.h>
#define N 30050
#define mem(a, v) memset(a, v, sizeof(a))
using namespace std;
int prime[N], p[N];
bool isprime[N];
const int mod = 1e9 + 7;

long long quick_power(long long base, long long power)
{
    long long result = 1;
    base %= mod;
    while (power)
    {
        if (power & 1)
        {
            result = (result * base) % mod;
        }
        power >>= 1;
        base = (base * base) % mod;
    }
    return result;
}

void get_prime(int n)
{
    int cnt = 0;
    memset(isprime, 1, sizeof(bool) * n);
    isprime[1] = 0;
    for (int i = 2; i <= n; i++)
    {
        if (isprime[i]) prime[++cnt] = i;
        for (int j = 1; j <= cnt && i * prime[j] <= n; j++)
        {
            isprime[i * prime[j]] = 0;
            if (i % prime[j] == 0) break;
        }
    }
    prime[0] = cnt;
}

int main()
{
    get_prime(30000);
    mem(p, 0);
    int a, b;
    cin >> a >> b;
    for (int i = a; i <= b; i++)
    {
        if (!isprime[i])
        {
            int x = i;
            for (int j = 1; x > 1; j++)
            {
                int cnt = 0;
                while (x > 1 && x % prime[j] == 0)
                {
                    cnt++;
                    x /= prime[j];
                }
                p[prime[j]] = max(p[prime[j]], cnt);
            }
        }
    }
    long long ans = 1;
    for (int i = 1; i <= prime[0]; i++)
        ans = (ans * quick_power(prime[i], p[prime[i]])) % mod;
    if (ans == 1)
        cout << "-1";
    else
        cout << ans;
    return 0;
}

G-子序列权值乘积

设计知识： 欧拉降幂
如果我们要求a^b%p 而b是一个很大的数，可以先将b对p-1取模，不会影响结果的正确性，前提是a和p互质。

这一题我们可以将数字先进行排序，因为子序列中只有最大和最小的才会被计算，那我们不妨将某个数 ai 取作这个序列中的最值，剩下的全部取比 ai 小或大的数，那么就可以转换成算 ai 前面数的组合数加上 ai 后面数的组合数 然后加上只取 ai 时会被算两遍的情况即可。

#include <bits/stdc++.h>
#define N 200005
using namespace std;

const long long mod = 1000000007;

long long quick_power(long long base, long long power, long long mod)
{
    long long result = 1;
    base %= mod;
    while (power)
    {
        if (power & 1)
        {
            result = (result * base) % mod;
        }
        power >>= 1;
        base = (base * base) % mod;
    }
    return result;
}
long long a[N];

int main()
{
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    int n;
    long long ans = 1;
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    sort(a + 1, a + n + 1);
    for (int i = 1; i <= n; i++)
    {
        long long l, r;
        //此处模取mod-1 用了欧拉降幂
        // l+r为左侧组合数加上右侧组合数加上ai取两次的情况（也就是ai被乘的次数）
        l = quick_power(2, i - 1, mod - 1);
        r = quick_power(2, n - i, mod - 1);
        ans *= quick_power(a[i], (l + r) % (mod - 1), mod);
        ans %= mod;
    }
    cout << ans;
    return 0;
}