PAT甲级题目翻译+答案 AcWing（哈希表）

1048 Find Coins (25 分)

题意 ：

• 给一序列，要求从中选出两个值使得它们的和恰好等于m，输出第一个值字典序最小且升序的方案

思路 ：

• 看似$O(n^2)$，其实可以一边输入一边操作，就变成$O(n)$
• 对于当前输入的这个数x，判断有没有恰好y=m-x这个数存在，如果有，就让它们中小的是v11，大的是v22，如果v11小于v1，那么v1是v11，v2是v22

#include <iostream>
#include <unordered_set>
using namespace std;

int n, m;
unordered_set<int> se;

int main()
{
    scanf("%d%d", &n, &m);
    
    int v1 = 1e9, v2;
    for (int i = 1, x; i <= n; i ++ )
    {
        scanf("%d", &x);
        int y = m - x;
        
        if (se.count(y))
        {
            if (x > y) swap(x, y);
            if (x < v1) v1 = x, v2 = y;
        }
        
        se.insert(x);
    }
    
    if (v1 == 1e9) puts("No Solution");
    else printf("%d %d\n", v1, v2);
}

1063 Set Similarity (25 分)

题意 ：

• 给一堆集合（可能包含相同元素），每次询问两个集合，问它们的 分别去重后，公有的个数 / 总共的个数

思路 ：

• 显然在输入集合的时候就要去重了

语法 ：

• 在printf中输出%，用"%%"即可

#include <iostream>
#include <unordered_set>

using namespace std;

const int N = 55;

int n;
unordered_set<int> S[N];

int main()
{
    scanf("%d", &n);

    for (int i = 1; i <= n; i ++ )
    {
        int m;
        scanf("%d", &m);
        while (m -- )
        {
            int x;
            scanf("%d", &x);
            S[i].insert(x);
        }
    }

    int k;
    scanf("%d", &k);
    while (k -- )
    {
        int a, b;
        scanf("%d%d", &a, &b);
        int nc = 0;
        for (auto x : S[a]) nc += S[b].count(x);
        int nt = S[a].size() + S[b].size() - nc;
        printf("%.1lf%%\n", (double)nc / nt * 100);
    }

    return 0;
}

1078 Hashing (25 分)

题意 ：

• distinct的序列插入到一个哈希表中，然后输出每个按顺序所给的输入数字的位置
• 哈希函数定义为key%TSize，TSize为哈希表的最大大小
• 利用只具有正增量的二次探测法来解决冲突Quadratic probing (with positive increments only) is used to solve the collisions.
• 注意，哈希表的大小最好是质数，如果用户给的最大大小不是质数，则必须将表的大小重新定义为大于用户给出的大小的最小素数
• 位置索引从0开始；如果无法插入某个数字，则输出-

思路 ：

• 哈希表一般有两种算法：拉链法和开放寻址法；这道题中是开放寻址法，也就是只具有正增量的二次探测法
• 开放寻址法，即，先映射，如果这个位置上有数，就顺次看后面一个位置；即，看的位置依次是$t,t+1^2,t+2^2,t+3^2$，当然还要%s
• 开放寻址法，必然用到find

#include <iostream>
using namespace std;

const int N = 1e4 + 10;

int s, n;
int h[N];

bool is_prime(int x)
{
    if (x == 1) return false;
    for (int i = 2; i * i <= x; i ++ )
        if (x % i == 0)
            return false;
    return true;
}

int find(int x)
{
    int t = x % s;
    
    for (int k = 0; k < s; k ++ )
    {
        int i = (t + k * k) % s;
        if (!h[i]) return i;
    }
    return -1;
}

int main()
{
    scanf("%d%d", &s, &n);
    
    while (!is_prime(s)) s ++ ;
    
    int x;
    for (int i = 0; i < n && scanf("%d", &x); i ++ )
    {
        int k = find(x);
        
        if (k == -1) printf("-");
        else
        {
            h[k] = x;
            printf("%d", k);
        }
        
        if (i != n - 1) printf(" ");
    }
}

1120 Friend Numbers (20 分)

• 思路 ：什么数据结构可以让我们既判重又排序呢？其实不用哈希表而用set会更好，可以少一步排序
• 语法 ：set默认从小到大排序；空格输出新方法（这题如果不判空格会wa）

#include <iostream>
#include <set>

using namespace std;

int main()
{
    int n;
    cin >> n;
    
    set<int> se;
    
    while (n -- )
    {
        int x;
        cin >> x;
        int s = 0;
        while (x) s += x % 10, x /= 10;
        se.insert(s);
    }
    
    cout << se.size() << endl;;
    
    bool is_first = true;
    for (auto x : se)
    {
        if (is_first) is_first = false;
        else cout << ' ';
        cout << x;
    }
    
    return 0;
}

1137 Final Grading (25 分)

题意 ：

• 想要获得一张合格证书，必须首先获得不少于 200 分的在线编程作业分，然后总评获得不少于 60 分（满分 100）。打印出获得合格证书的学生名单。

思路 ：

• 首先输入所有的信息，然后遍历哈希表中每一个结构体，先计算总评，然后如果分数符合获得合格证书的要求，就将它放入vector，然后对这个vector排序

语法 ：

• stu.calc();
• Student(): p(-1), m(-1), f(-1), s(0) {}
• void calc()
• 四舍五入函数 s = round(m * 0.4 + f * 0.6);
• round函数在cmath头文件中

#include <iostream>
#include <algorithm>
#include <vector>
#include <unordered_map>
#include <cmath>
using namespace std;

struct Student
{
    string id;
    int p, m, f, s;
    
    Student() : p(-1), m(-1), f(-1), s(0) {}
    
    void calc()
    {
        if (m > f) s = round(m * 0.4 + f * 0.6);
        else s = f;
    }
    
    bool operator< (const Student &t) const
    {
        if (s != t.s) return s > t.s;
        return id < t.id;
    }
};

int main()
{
    int P, M, N;
    scanf("%d%d%d", &P, &M, &N);
    
    unordered_map<string, Student> hash;
    
    string id;
    int grade;
    for (int i = 0; i < P; i ++ )
    {
        cin >> id >> grade;
        hash[id].id = id;
        hash[id].p = grade;
    }
    for (int i = 0; i < M; i ++ )
    {
        cin >> id >> grade;
        hash[id].id = id;
        hash[id].m = grade;
    }
    for (int i = 0; i < N; i ++ )
    {
        cin >> id >> grade;
        hash[id].id = id;
        hash[id].f = grade;
    }
    
    vector<Student> students;
    
    for (auto &item : hash)
    {
        auto &stu = item.second;
        stu.calc();
        
        if (stu.p >= 200 && stu.s >= 60)
            students.push_back(stu);
    }
    
    sort(students.begin(), students.end());
    
    for (int i = 0; i < students.size(); i ++ )
    {
        auto &stu = students[i];
        cout << stu.id << ' ' << stu.p << ' ' << stu.m << ' ' << stu.f << ' ' << stu.s << endl;
    }
}

1144 The Missing Number (20 分)

• 思路 ：这里用while比用for方便，就是找一个从1开始连续增加的数字
• 语法 ：set的insert和find均为$O(logn)$，count为$O(k+logn)$

#include <iostream>
#include <unordered_set>

using namespace std;

int main()
{
    int n;
    cin >> n;
    
    unordered_set<int> se;
    
    while (n -- )
    {
        int x;
        cin >> x;
        se.insert(x);
    }
    
    int res = 1;
    
    while (se.count(res)) res ++ ;
    cout << res;
    
    return 0;
}

1145 Hashing - Average Search Time (25 分)

题意 ：

• 首先将一个由若干个不同正整数构成的整数序列插入到一个哈希表中，然后尝试从表中查找另一个整数键值序列，并输出平均查找时间（查找时间指查找某个值是否在表中所进行的比较操作的次数）。
• 利用只具有正增量的二次探测法来解决冲突。
• 注意，哈希表的大小最好是素数，如果用户给出的最大大小不是素数，则必须将表大小重新定义为大于用户给出的大小的最小素数。
• 注意： 如果查找了 TSize 次，每次查找的位置上均有数，但都不等于要查找的数，则认为查找时间是 TSize+1。

#include <iostream>

using namespace std;

const int N = 10010;

int s, n, m;
int h[N];

bool is_prime(int x)
{
    if (x == 1) return false;

    for (int i = 2; i * i <= x; i ++ )
        if (x % i == 0)
            return false;

    return true;
}

int find(int x, int &cnt)
{
    int t = x % s;

    cnt = 1;
    for (int k = 0; k < s; k ++, cnt ++ )
    {
        int i = (t + k * k) % s;
        if (!h[i] || h[i] == x) return i;
    }

    return -1;
}

int main()
{
    cin >> s >> n >> m;

    while (!is_prime(s)) s ++ ;

    for (int i = 0; i < n; i ++ )
    {
        int x, count;
        cin >> x;

        int t = find(x, count);
        if (t == -1) printf("%d cannot be inserted.\n", x);
        else h[t] = x;
    }

    int cnt = 0;
    for (int i = 0; i < m; i ++ )
    {
        int x, count;
        cin >> x;
        find(x, count);
        cnt += count;
    }

    printf("%.1lf\n", (double)cnt / m);

    return 0;
}

1149 Dangerous Goods Packaging (25 分)

题意 ：

• 本题给定一张不相容物品的清单，需要你检查每一张集装箱货品清单，判断它们是否能装在同一只箱子里。

思路 ：

• 对于每个询问，只要检查每一对关系即可，因此，只需要开两个数组存储

#include <iostream>
#include <unordered_set>
using namespace std;

const int N = 1e4 + 10;

int n, m;
int a[N], b[N];

int main()
{
    scanf("%d%d", &n, &m);
    
    for (int i = 0; i < n; i ++ ) scanf("%d%d", &a[i], &b[i]);
    
    int cnt;
    while (m -- )
    {
        scanf("%d", &cnt);
        
        unordered_set<int> se;
        int x;
        while (cnt -- )
        {
            scanf("%d", &x);
            se.insert(x);
        }
        
        bool success = true;
        
        for (int i = 0; i < n; i ++ )
            if (se.count(a[i]) && se.count(b[i]))
            {
                success = false;
                break;
            }
        
        if (!success) puts("No");
        else puts("Yes");
    }
}