【PTA数据结构 | C语言版】集合相似度

本专栏持续输出数据结构题目集，欢迎订阅。

题目

给定两个整数集合，它们的相似度定义为：Nc /Nt ×100%。其中 Nc 是两个集合都有的不相等整数的个数，Nt 是两个集合一共有的不相等整数的个数。你的任务就是计算任意一对给定集合的相似度。

输入格式：
输入第一行给出一个正整数 n（≤50），是集合的个数。随后 n 行，每行对应一个集合。每个集合首先给出一个正整数 m（≤10^4），是集合中元素的个数；然后跟 m 个 [0,10^9] 区间内的整数。

之后一行给出一个正整数 k（≤2000），随后 k 行，每行对应一对需要计算相似度的集合的编号（集合从 1 到 n 编号）。数字间以空格分隔。

输出格式：
对每一对需要计算的集合，在一行中输出它们的相似度，为保留小数点后 2 位的百分比数字。

输入样例：
3
3 99 87 101
4 87 101 5 87
7 99 101 18 5 135 18 99
2
1 2
1 3

输出样例：
50.00%
33.33%

代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 哈希表节点结构
typedef struct Node {
    long long data;
    struct Node* next;
} Node;

// 哈希集合结构
typedef struct {
    Node** table;
    int size;          // 哈希表大小
    int elementCount;  // 集合中元素的数量（去重后）
} HashSet;

// 创建哈希集合
HashSet* createHashSet(int size) {
    HashSet* set = (HashSet*)malloc(sizeof(HashSet));
    set->size = size;
    set->elementCount = 0;
    set->table = (Node**)calloc(size, sizeof(Node*));
    return set;
}

// 哈希函数
int hash(HashSet* set, long long data) {
    // 处理负数情况
    if (data < 0) data = -data;
    return data % set->size;
}

// 向哈希集合中添加元素（不添加重复元素）
void addElement(HashSet* set, long long data) {
    int index = hash(set, data);
    Node* current = set->table[index];
    
    // 检查元素是否已存在
    while (current != NULL) {
        if (current->data == data) {
            return;  // 元素已存在，不重复添加
        }
        current = current->next;
    }
    
    // 添加新元素
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = set->table[index];
    set->table[index] = newNode;
    set->elementCount++;
}

// 检查元素是否在哈希集合中
int contains(HashSet* set, long long data) {
    int index = hash(set, data);
    Node* current = set->table[index];
    
    while (current != NULL) {
        if (current->data == data) {
            return 1;  // 元素存在
        }
        current = current->next;
    }
    return 0;  // 元素不存在
}

// 计算两个集合的相似度
double calculateSimilarity(HashSet* set1, HashSet* set2) {
    // 计算共同元素数量 Nc
    int Nc = 0;
    for (int i = 0; i < set1->size; i++) {
        Node* current = set1->table[i];
        while (current != NULL) {
            if (contains(set2, current->data)) {
                Nc++;
            }
            current = current->next;
        }
    }
    
    // 计算总元素数量 Nt = 集合1元素数 + 集合2元素数 - 共同元素数
    int Nt = set1->elementCount + set2->elementCount - Nc;
    
    // 计算相似度
    return (Nt == 0) ? 0.0 : (double)Nc / Nt * 100;
}

int main() {
    int n;
    scanf("%d", &n);
    
    // 哈希表大小选择一个较大的素数，减少冲突
    const int HASH_SIZE = 10007;
    HashSet* sets[50];  // 存储所有集合
    
    // 读取每个集合
    for (int i = 0; i < n; i++) {
        sets[i] = createHashSet(HASH_SIZE);
        int m;
        scanf("%d", &m);
        
        for (int j = 0; j < m; j++) {
            long long num;
            scanf("%lld", &num);
            addElement(sets[i], num);
        }
    }
    
    // 处理查询
    int k;
    scanf("%d", &k);
    
    for (int i = 0; i < k; i++) {
        int a, b;
        scanf("%d %d", &a, &b);
        // 集合编号从1开始，数组索引从0开始
        a--;
        b--;
        
        double similarity = calculateSimilarity(sets[a], sets[b]);
        printf("%.2f%%\n", similarity);
    }
    
    return 0;
}