PAT 1158 Telefraud Detection

原题链接：PAT 1158 Telefraud Detection (25分)(电话欺诈检测)
关键词：并查集
参考的浒鱼鱼的博客：19春第三题 PAT甲级 1158 Telefraud Detection (25分) 用这个方法最好

Telefraud（电信诈骗） remains a common and persistent problem in our society. In some cases, unsuspecting victims lose their entire life savings. To stop this crime, you are supposed to write a program to detect those suspects from a huge amount of phone call records.

A person must be detected as a suspect if he/she makes more than K short phone calls to different people everyday, but no more than 20% of these people would call back. And more, if two suspects are calling each other, we say they might belong to the same gang. A makes a short phone call to B means that the total duration of the calls from A to B is no more than 5 minutes.

Input Specification:

Each input file contains one test case. For each case, the first line gives 3 positive integers K (≤500, the threshold（阈值） of the amount of short phone calls), N (≤10​^3​​, the number of different phone numbers), and M (≤10^​5​​, the number of phone call records). Then M lines of one day’s records are given, each in the format:

caller receiver duration

where caller and receiver are numbered from 1 to N, and duration is no more than 1440 minutes in a day.

Output Specification:

Print in each line all the detected suspects in a gang, in ascending order of their numbers. The gangs are printed in ascending order of their first members. The numbers in a line must be separated by exactly 1 space, and there must be no extra space at the beginning or the end of the line.

If no one is detected, output None instead.

Sample Input 1:

5 15 31
1 4 2
1 5 2
1 5 4
1 7 5
1 8 3
1 9 1
1 6 5
1 15 2
1 15 5
3 2 2
3 5 15
3 13 1
3 12 1
3 14 1
3 10 2
3 11 5
5 2 1
5 3 10
5 1 1
5 7 2
5 6 1
5 13 4
5 15 1
11 10 5
12 14 1
6 1 1
6 9 2
6 10 5
6 11 2
6 12 1
6 13 1

Sample Output 1:

3 5
6

Note: In sample 1, although 1 had 9 records, but there were 7 distinct receivers, among which 5 and 15 both had conversations lasted more than 5 minutes in total. Hence 1had made 5 short phone calls and didn’t exceed the threshold 5, and therefore is not a suspect.

Sample Input 2:

5 7 8
1 2 1
1 3 1
1 4 1
1 5 1
1 6 1
1 7 1
2 1 1
3 1 1

Sample Output 2:

None

PAT题库类似题：

1034 Head of a Gang (30分)：
两种做法：
（1）并查集
（2）DFS

题目大意：

给定以下条件，作为电信诈骗团伙的判断：

1. 一个人给不同的K个以上的人打电话，其中给每个人的通话总和不超过5分钟的，称为短通话，短通话中只有不超过20%的人给他回电；
2. 满足1的两个人互相通话，就是同一个团伙。

根据通话记录，找到团伙的成员，按照从小到大的序号输出成员编号。

注意：

1.这道题适合用并查集：A和B关联，B和C关联，则认为A和C关联。
2.并查集在近三年的考题里就出现过这一次，最有效率的方式是能熟练运用两个并查集算法的函数：

int Findfather(int v){//这个递归写法最简单，而且包含路径压缩
    return v==father[v] ? v : (father[v] = Findfather(v));
//注意赋值运算符=的优先级没有三元运算符?:高，这里要加括号。
//引用来源：https://zhuanlan.zhihu.com/p/93647900
}
 
void Union(int a,int b){
    int faA = Findfather(a);
    int faB = Findfather(b);
    if(faA < faB){//这个得按照题目的意思变
        father[faA] = faB;
    }else if(faA > faB){
        father[faB] = faA;
    }
}

代码：

#include 

using namespace std;
const int maxn = 1000 + 10;
int cnt[maxn][maxn];
vector<int> vs;
int parents[maxn];
int finds(int x){
    return x == parents[x] ? x: parents[x] = finds(parents[x]);
}
int main()
{
    int k, n, m;
    scanf("%d %d %d", &k, &n, &m);
    for(int i = 0; i < m; ++i){
        int c, r, d;
        scanf("%d %d %d", &c, &r,&d);
        cnt[c][r] += d;
    }
    for(int i = 1; i <= n; ++i){
        int sum = 0, rsum = 0;
        for(int j = 1; j <= n; ++j){
            if(cnt[i][j] > 0 && cnt[i][j] <= 5) {
                ++sum;
                if(cnt[j][i] > 0) ++rsum;//统计回电话人数
            }
        }
        if(sum > k ){
            vs.push_back(i);
            if(sum > 0 && 1.0 * rsum / sum > 0.2) vs.pop_back();//去除回电话数大于20%的嫌疑人
        }

    }
    for(int i = 1; i <= n; ++i){
        parents[i] = i;
    }
    int sz = vs.size();
    for(int i = 0; i < sz; ++i){
        for(int j = i + 1; j < sz; ++j){
            if(cnt[vs[i]][vs[j]] > 0 && cnt[vs[j]][vs[i]] > 0){//嫌疑人之间有相互联系
                int L1 = finds(vs[i]), L2 = finds(vs[j]);
                if(L1 != L2){
                    if(L1 < L2) swap(L1, L2);
                    parents[L1] = L2;//小的编号作为leader
                }
            }
        }
    }
    map<int, vector<int>> mp;
    for(int i = 0; i < sz; ++i){
        int L = finds(vs[i]);
        mp[L].push_back(vs[i]);
    }
    if(mp.size() == 0){
        printf("None\n");
        return 0;
    }
    for(auto x: mp){
        sort(x.second.begin(), x.second.end());//gang内排序
        int kk = x.second.size();
        for(int i = 0; i < kk; ++i){
            printf("%d%c", x.second[i], i == kk - 1? '\n': ' ');
        }
    }
    return 0;
}

//https://blog.csdn.net/gl486546/article/details/88102211?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.nonecase&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.nonecase