11.25 NOIP模拟赛2 题解#

T1 数对（pair）#

给定 $n$ 个正整数，求满足 $a_i$ 是 $a_j$ 倍数的数对数量。

题目分析#

$(O(n\sqrt n))$ 做法#

对于每个数 $a_i$ 求出它的因数，用桶来存储每个数作为因数的出现次数，循环统计答案即可。

$O(n\log n)$ 做法#

对于每个数 $a_i$ 求出其不大于 $\max_{i=1}^{n}a_i$ 的所有倍数，同样用桶存储每个数作为其余数倍数的出现次数，统计答案即可。复杂度为调和 $O(n\log n)$ 。

Code#

1
// #pragma GCC optimize(1, 2, 3, "Ofast", "inline")
2
#include <bits/stdc++.h>
3
using namespace std;
4
#define ll long long
5
#define int ll
6
// #define ONLINEJUDGE
7
// #define MULTI_CASES
8
const int MaxN = 2e5 + 100;
9
const int MaXN = 5e5 + 100;
10
const int INF = 1e9;
11
int T = 1, N, M;
12
int a[MaxN];
13
int vis[MaXN];
14
int ans[MaXN];
15
inline void Solve()
16
{
17
    cin >> N;
18
    int maxn = 0;
19
    for (int i = 1; i <= N; i++)
20
    {
21
        cin >> a[i];
22
        // vis[a[i]]=1;
23
        vis[a[i]]++;
24
        maxn = max(maxn, a[i]);
25
    }
26
    for (int i = 1; i <= N; i++)
27
    {
28
        if (ans[a[i]])
29
        {
30
            // ans[a[i]]++;
31
            continue;
32
        }
33
        for (int j = 1; j * a[i] <= maxn; j++)
34
        {
35
            ans[a[i]] += vis[a[i] * j];
36
            if (j == 1)
37
            {
38
                ans[a[i]]--;
39
            }
40
        }
41
    }
42
    int sum = 0;
43
    for (int i = 1; i <= N; i++)
44
    {
45
        sum += ans[a[i]];
46
    }
47
    cout << sum << endl;
48
}
49
signed main()
50
{
51
#ifndef ONLINEJUDGE
52
    freopen("pair.in", "r", stdin);
53
    freopen("pair.out", "w", stdout);
54
#endif
55
    ios::sync_with_stdio(0);
56
    cin.tie(0), cout.tie(0);
57

58
#ifdef MULTI_CASES
59
    cin >> T;
60
    while (T--)
61
#endif
62
        Solve();
63
    // fclose(stdin);
64
    // fclose(stdout);
65
    return 0;
66
}

T2 运货（transport）#

题目分析#

首先，对于每个货物，最优的小车出发时间应为其到达卸货口的时间减去小车到货架的时间，所以我们可以将所有的小车出发时间存储下来，对其从小到大排序，可以得到一个序列 $a_i$ 。显然通过贪心的思想，每辆小车在这个序列中的时间出发才是最优的。

题目要求最少花费的时间，那么显然可以发现，所有小车走了最远的那辆车所花费的时间就是最短时间。我们对于 $a_i$ ，运送它的小车编号应为 $i\mod M$ ，这辆小车运输完 $a_i$ 后的花费时间应该为 $\max(max_{i\mod M},a_i)$ ，那么对于 $M$ 个小车分别求出其最多花费的时间，统计答案即可。

Code#

1
// #pragma GCC optimize(1, 2, 3, "Ofast", "inline")
2
#include <bits/stdc++.h>
3
using namespace std;
4
#define ll long long
5
#define int ll
6
// #define ONLINEJUDGE
7
// #define MULTI_CASES
8
const int MaxN = 2e5 + 100;
9
const int INF = 1e9;
10
int T = 1, N, M;
11
int a[MaxN];
12
int ans[2010];
13
inline void Solve()
14
{
15
    cin >> N >> M;
16
    // for (int i = 1; i <= M; i++)
17
    // {
18
    //     q.push(0);
19
    // }
20
    // int ans = 0;
21
    vector<int> f;
22
    for (int i = 0; i < N; i++)
23
    {
24
        int len;
25
        cin >> len;
26
        for (int j = 1; j <= len; j++)
27
        {
28
            int x;
29
            cin >> x;
30
            f.push_back(x - i - 1);
31
        }
32
    }
33
    sort(f.begin(), f.end());
34
    for (int i = 0; i < (int)f.size(); i++)
35
    {
36
        ans[i % M] = max(ans[i % M], f[i]) + N + 1;
37
    }
38
    int sum = 0;
39
    for (int i = 0; i < M; i++)
40
    {
41
        sum = max(sum, ans[i]);
42
    }
43
    cout << sum << endl;
44
}
45
signed main()
46
{
47
#ifndef ONLINEJUDGE
48
    freopen("transport.in", "r", stdin);
49
    freopen("transport.out", "w", stdout);
50
#endif
51
    ios::sync_with_stdio(0);
52
    cin.tie(0), cout.tie(0);
53

54
#ifdef MULTI_CASES
55
    cin >> T;
56
    while (T--)
57
#endif
58
        Solve();
59
    // fclose(stdin);
60
    // fclose(stdout);
61
    return 0;
62
}

T3 找爸爸（daddy）#

题目分析#

题目要求DNA序列的最大相似程度，考虑 $dp$ 做法，可以得出 $dp_{i,j,k}$ 表示 a序列长度为 $i$ ，b序列长度为 $j$ ，末尾有/无空格（ $k=0$ 无空格， $k=1$ 表示a序列有空格， $k=2$ 表示b序列末尾有空格）时的最大相似程度。

关于空格，对于每段连续空格，相似程度为 $-A-B\times (k-1)$ 因为 $A,B$ 都是正整数，所以其相似程度一定为负数。对于一个空格，会减少 $A$ 点相似度，如果在后面多添加一个空格，则会进一步减少 $B$ 点相似度。

状态转移方程如下：

$dp_{i,j,0}=\max(dp_{i-1,j-1,0},dp_{i-1,j-1,1},dp_{i-1,j-1,2})+a_{s1_i,s2_j}$

$dp_{i,j,1}=\max(dp_{i-1,j,0}-A,dp_{i-1,j,1}-B,dp_{i-1,j,2}-A)$

$dp_{i,j,2}=\max(dp_{i,j-1,0}-A,dp_{i,j-1,1}-A,dp_{i,j-1,2}-B)$

Code#

1
// #pragma GCC optimize(1, 2, 3, "Ofast", "inline")
2
#include <bits/stdc++.h>
3
using namespace std;
4
#define ll long long
5
#define int ll
6
// #define ONLINEJUDGE
7
// #define MULTI_CASES
8
const int MaxN = 2e3 + 100;
9
const int INF = 1e18;
10
int T = 1, N, M;
11
int a[10][10];
12
int dp[MaxN][MaxN][4];
13
int A, B;
14

15
int g(int k)
16
{
17
    return -A - B * (k - 1);
18
}
19
inline void Solve()
20
{
21
    string s1, s2;
22
    cin >> s1 >> s2;
23
    s1 = ' ' + s1;
24
    s2 = ' ' + s2;
25
    map<char, int> mp;
26
    mp['A'] = 1;
27
    mp['T'] = 2;
28
    mp['G'] = 3;
29
    mp['C'] = 4;
30
    for (int i = 1; i <= 4; i++)
31
    {
32
        for (int j = 1; j <= 4; j++)
33
        {
34
            cin >> a[i][j];
35
        }
36
    }
37
    cin >> A >> B;
38
    for (int i = max(s1.size(), s2.size()); i >= 1; i--)
39
    {
40
        dp[0][i][0] = dp[i][0][0] = dp[0][i][2] = dp[i][0][1] = dp[0][i][1] = dp[i][0][2] = -INF;
41
        dp[0][i][1] = dp[i][0][2] = g(i);
42
    }
43
    for (int i = 1; i < s1.size(); i++)
44
    {
45
        for (int j = 1; j < s2.size(); j++)
46
        {
47
            dp[i][j][0] = max({dp[i - 1][j - 1][0], dp[i - 1][j - 1][1], dp[i - 1][j - 1][2]}) + a[mp[s1[i]]][mp[s2[j]]];
48
            dp[i][j][1] = max({dp[i - 1][j][0] - A, dp[i - 1][j][1] - B, dp[i - 1][j][2] - A});
49
            dp[i][j][2] = max({dp[i][j - 1][0] - A, dp[i][j - 1][1] - A, dp[i][j - 1][2] - B});
50
        }
51
    }
52
    cout << max({dp[s1.size() - 1][s2.size() - 1][0], dp[s1.size() - 1][s2.size() - 1][1], dp[s1.size() - 1][s2.size() - 1][2]}) << endl;
53
}
54
signed main()
55
{
56
#ifndef ONLINEJUDGE
57
    freopen("daddy.in", "r", stdin);
58
    freopen("daddy.out", "w", stdout);
59
#endif
60
    ios::sync_with_stdio(0);
61
    cin.tie(0), cout.tie(0);
62

63
#ifdef MULTI_CASES
64
    cin >> T;
65
    while (T--)
66
#endif
67
        Solve();
68
    // fclose(stdin);
69
    // fclose(stdout);
70
    return 0;
71
}

11.25 NOIP模拟赛2 题解#

T1 数对（pair）#

题目分析#

(O(nn))(O(n\sqrt n))(O(nn​)) 做法#

O(nlog⁡n)O(n\log n)O(nlogn)做法#

Code#

T2 运货（transport）#

题目分析#

Code#

T3 找爸爸（daddy）#

题目分析#

Code#

$(O(n\sqrt n))$ 做法#

$O(n\log n)$ 做法#