HDOJ 7311 Noblesse Code —— 2023“钉耙编程”中国大学生算法设计超级联赛（3）（2023杭电多校第三场）_2023“钉耙编程”中国大学生算法设计超级联赛(3)

题目链接

题意：$T(1\le T\le 100)$组测试点，每次给定$n(1\le n\le 5\times 10^4)$个整数对$(a_i,b_i),(1\le a_i,b_i\le 10^{18})$，接下来进行$q(1\le q\le 5\times 10^4)$次询问，每次询问给出一个整数对$(A,B),(1\le A,B\le 10^{18})$，你有一种操作可以令$(A,B)$变为$(A+B,B)$或$(A,B+A)$，你可以对$(A,B)$进行任意次数操作，求这$n$对$(a_i,b_i)$中有几对可以被得到。$\sum n,\sum q\le 5\times 10^5$

题解：

观察$(A,B)\to (A+B,B),(A,B+A)$这个操作，不难联想到辗转相减法，又能联想到辗转相除法/欧几里得算法。
我们先考虑对于某一组特定的$(a,b)$，什么样的询问$(A,B)$可以经过多次操作得到$(a,b)$
不妨设$a>b$，将其逆向操作，发现$(a,b),(a-b,b),(a-2b,b),...,(a\mathrm{mod}b,b)$都可以经过操作得到$(a,b)$，同样地对$(a^{\prime }=a\mathrm{mod}b,b)$进行进一步缩小得到的$(a^{\prime },b),(a^{\prime },b-a^{\prime }),(a^{\prime },b-2a^{\prime }),..,(a^{\prime },b\mathrm{mod}{a}^{\prime })$，也可以经过操作得到$(a,b)$。

但是当$\frac{a}{b}$过大时中间的pair太多，因此需要进行压缩。对它进行欧几里得算法的一轮迭代会变为$(a\mathrm{mod}b,b)$，我们可以储存$(a\mathrm{mod}b,b)\to a$这个映射，当询问的$(A,B)$满足$A>B$、$B=b$、$A\mathrm{mod}b=a\mathrm{mod}b$、$A\le a$时，可以将$(A,B)$变为$(A+kb,B)$得到$(a,b)$。
举个例子，$(a,b)=(18,5)$，我们储存了$(3,5)\to 18$这个映射。现在询问的$(A,B)=(8,5)$，检查$(A\mathrm{mod}B,B)=(3,5)$，发现$B=b=5$且$A=8\le a=18$，所以$(8,5)$可以变为$(8+2\times 5,5)=(18,5)$

另外需要注意当$a_i=b_i$时，不可能从$A\ne B$的$(A,B)$得到，只能从$A=B=a_i=b_i$的$(A,B)$得到。

上述的方法是我的主要思路，接下来还要全面地考虑，我们需要储存这三样东西

1、记录映射1：$a<b,(a,b\mathrm{mod}a)\to Set(b)$，其中$(a,b)$是有所有$(a_i,b_i)$经过欧几里得算法得到的满足$a<b$的pair，$Set(b)$表示得到$(a,b\mathrm{mod}a)$的上一步的$b$

2、记录映射2：$a>b,(a\mathrm{mod}b,b)\to Set(a)$，其中$(a,b)$是有所有$(a_i,b_i)$经过欧几里得算法得到的满足$a>b$的pair，$Set(a)$表示得到$(a\mathrm{mod}b,b)$的上一步的$a$

3、记录$a_i=b_i=x$的数量

例如$(22,8)$经过欧几里得算法迭代得到$(6,8),(6,2),(0,2)$，则映射1种储存了 ( 6 , 2 ) → { 8 } (6,2)\to\{8\} (6,2)→{8}，映射2中储存了 ( 6 , 8 ) → { 22 } (6,8)\to\{22\} (6,8)→{22}， ( 0 , 2 ) → { 6 } (0,2)\to \{6\} (0,2)→{6}

对于询问的$(A,B)$

1、$A>B$，需要在映射2中查找$key=(A\mathrm{mod}B,B)$对应的$Set(a)$，$Set(a)$中大于等于$A$的元素个数即为答案

2、$A<B$，需要在映射1中查找$key=(A,B\mathrm{mod}A)$对应的$Set(b)$，$Set(b)$中大于等于$B$的元素个数即为答案

3、$A=B$，需要在映射1中查找$key=(A,0)$对应的$Set(b)$，答案加上$Set(b)$中大于等于$B$的元素个数；在映射2中查找$key=(0,B)$对应的$Set(a)$，答案加上$Set(a)$中大于等于$A$的元素个数；答案加上$a_i=b_i=A=B$的个数。

我定义的$Set$可以用vector实现，预处理时对所有$a_i,b_i$使用欧几里得算法进行迭代，存入map<pair<ll,ll>,vector<ll>>，做完$n$个pair后对map中所有vector进行排序。询问时二分查找出大于等于某个数的个数。

接下俩来析复杂度：

令值域$C=10^{18}$，每一对$(a_i,b_i)$会加入$O(\log C)$个映射，共$O(n\log C)$个pair。map上插入、查询复杂度$O(\log (n\log C))$ or $O(1)$，将所有pair存入map总复杂度为$O(n\log C\log (n\log C))$ or $O(n\log n\log C)$。（or后面的是用hashmap代替map，下文中同理）

因为对map的某个key，每一对$(a_i,b_i)$最多为该key对应的vector提供一个元素，因此每个vector中最多$n$个元素。所有vector中元素个数之和为$O(n\log C)$，全部排序一遍的复杂度为$O(\sum siz{e}_i\log siz{e}_i)$，不大于$O(n\log n\log C)$，最坏情况为有$\log C$个长为$n$的vector。

每次询问需要在map上根据key进行查询$O(\log (n\log C))$ or $O(1)$，并在vector上二分查找$O(\log n)$，查询总复杂度为$O(q\log (n\log C))$。另外还需要储存$a=b$的个数，时间复杂度为$O(n\log n+q\log n)$，就忽略了。

综上，时间复杂度为$O(n\log C\log (n\log C)+q\log (n\log C))$，空间复杂度为$O(n\log C)$。顺带提一句，$\log (n\log C)=\log n+\log \log C$，而$\log \log C<\log n$，因此$O(\log (n\log C))$同$O(\log n)$。我的程序运行时间是7.5秒左右，时限只有10秒，还好常数不太大。当然也可以用unordered_map代替map，自定义一个哈希函数，例如$(a,b)$的哈希值为$[a\times (10^{18}+7)+b]\mathrm{mod}(10^9+9)$，将复杂度优化为$O(n\log n\log C+q\log n)$ （理论复杂度实际上没有变，只是常数稍微减小）

#include<bits/stdc++.h>

using namespace std;
using ll = long long;
const int N = 5e4 + 5;
int n, q;
ll a[N], b[N];
map<pair<ll, ll>, vector<ll>> mpA; // a>b (a,b)->vector b+ka
map<pair<ll, ll>, vector<ll>> mpB; // a<b (a,b)->vector a+kb
map<ll, int> mpC; // mpC[x]: a=b=x的个数
void work() {
    mpA.clear();
    mpB.clear();
    mpC.clear();
    cin >> n >> q;
    for (int i = 1; i <= n; ++i) {
        cin >> a[i] >> b[i];
    }
    for (int i = 1; i <= n; ++i) {
        ll x = a[i], y = b[i];
        if (x == y) {
            ++mpC[x];
        }
        else {
            while (x && y) {
                if (x > y) {
                    ll tx = x;
                    x %= y;
                    mpB[{x, y}].emplace_back(tx);
                }
                else {
                    ll ty = y;
                    y %= x;
                    mpA[{x, y}].emplace_back(ty);
                }
            }
        }
    }
    for (auto &pr: mpA) {
        sort(pr.second.begin(), pr.second.end());
    }
    for (auto &pr: mpB) {
        sort(pr.second.begin(), pr.second.end());
    }
    while (q--) {
        ll A, B;
        cin >> A >> B;
        ll ans = 0;
        if (A > B) {
            auto it = mpB.find({A % B, B});
            if (it != mpB.end()) {
                auto &v = it->second;
                ans = v.end() - lower_bound(v.begin(), v.end(), A);
            }
        }
        else if (A == B) {
            auto it1 = mpA.find({A, 0});
            if (it1 != mpA.end()) {
                auto &v1 = it1->second;
                ans += v1.end() - lower_bound(v1.begin(), v1.end(), A);
            }
            auto it2 = mpB.find({0, A});
            if (it2 != mpB.end()) {
                auto &v2 = it2->second;
                ans += v2.end() - lower_bound(v2.begin(), v2.end(), A);
            }
            auto it3 = mpC.find(A);
            if (it3 != mpC.end()) {
                ans += it3->second;
            }
        }
        else {
            auto it = mpA.find({A, B % A});
            if (it != mpA.end()) {
                auto &v = it->second;
                ans = v.end() - lower_bound(v.begin(), v.end(), B);
            }
        }
        cout << ans << "\n";
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int T = 1;
    cin >> T;
    while (T--) {
        work();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92