• PAT A1034 Head of a Gang

    1034 Head of a Gang

    分数 30

    作者 CHEN, Yue

    单位 浙江大学

    One way that the police finds the head of a gang is to check people's phone calls. If there is a phone call between A and B, we say that A and B is related. The weight of a relation is defined to be the total time length of all the phone calls made between the two persons. A "Gang" is a cluster of more than 2 persons who are related to each other with total relation weight being greater than a given threshold K. In each gang, the one with maximum total weight is the head. Now given a list of phone calls, you are supposed to find the gangs and the heads.

    Input Specification:

    Each input file contains one test case. For each case, the first line contains two positive numbers N and K (both less than or equal to 1000), the number of phone calls and the weight threthold, respectively. Then N lines follow, each in the following format:

    Name1 Name2 Time

    where Name1 and Name2 are the names of people at the two ends of the call, and Time is the length of the call. A name is a string of three capital letters chosen from A-Z. A time length is a positive integer which is no more than 1000 minutes.

    Output Specification:

    For each test case, first print in a line the total number of gangs. Then for each gang, print in a line the name of the head and the total number of the members. It is guaranteed that the head is unique for each gang. The output must be sorted according to the alphabetical order of the names of the heads.

    Sample Input 1:

    1. 8 59
    2. AAA BBB 10
    3. BBB AAA 20
    4. AAA CCC 40
    5. DDD EEE 5
    6. EEE DDD 70
    7. FFF GGG 30
    8. GGG HHH 20
    9. HHH FFF 10

    Sample Output 1:

    1. 2
    2. AAA 3
    3. GGG 3

    Sample Input 2:

    1. 8 70
    2. AAA BBB 10
    3. BBB AAA 20
    4. AAA CCC 40
    5. DDD EEE 5
    6. EEE DDD 70
    7. FFF GGG 30
    8. GGG HHH 20
    9. HHH FFF 10

    Sample Output 2:

    0

    一个图的遍历，非要想着这么复杂，还想到了并查集。这个题在半年前看算法笔记的时候就看到过，当时还上手实践过，然而今天看到这个题，脑袋依旧是没开窍，这第一个代码就是今天写的，又长又臭。

    第二个代码的字符串转换为数字，不是用进制来进行转换的，值得学习。当字符串的长度是七八九十个的时候，用进制转换为数字当作数组的下标，明显不现实，但借助 一个map容器，就可简单将字符串转换为数字的大小控制在字符串的数量以内。看代码实现，这第二个是算法笔记上的代码。

    不管怎么说，只要从此掌握了这个转换方法，也不能说不是一种收获。

     * 输入的成员名字是英文，然而，用图遍历时，不管是邻接矩阵，还是邻接表，都需要
     * 用数组访问两个顶点是否连通，那么就需要将英文变为数字，同时，还需要用到原来
     * 的名字，因此，此时的数字也能返过去访问原来的名字，所以要将名字转换为的数字与
     * 名字相映射，用一个map容器记录就行。
     * 由于是一个不超过三个字符的名字，所以可以直接用26进制进行英文转换为数字。
     *
     * 同一个团伙的成员可以用并查集进行合并，头领记录该团伙的成员数量，其他成员指向
     * 该头领。最后再用图的遍历确定每个团队的首领。
     *
     * 最后注意计算团队总时长 > 阈值k时，题目要求的总时长是总时长/2，即两个人之间的通话
     * 只能算一次，通话时长总计需要除以2。

    1. /**
    2.  * 输入的成员名字是英文，然而，用图遍历时，不管是邻接矩阵，还是邻接表，都需要
    3.  * 用数组访问两个顶点是否连通，那么就需要将英文变为数字，同时，还需要用到原来
    4.  * 的名字，因此，此时的数字也能返过去访问原来的名字，所以要将名字转换为的数字与
    5.  * 名字相映射，用一个map容器记录就行。
    6.  * 由于是一个不超过三个字符的名字，所以可以直接用26进制进行英文转换为数字。
    7.  * 
    8.  * 同一个团伙的成员可以用并查集进行合并，头领记录该团伙的成员数量，其他成员指向
    9.  * 该头领。最后再用图的遍历确定每个团队的首领。
    10.  * 
    11.  * 最后注意计算团队总时长 > 阈值k时，题目要求的总时长是总时长/2，即两个人之间的通话
    12.  * 只能算一次，通话时长总计需要除以2。
    13. */
    14.  
    15. #include <iostream>
    16. #include <cstring>
    17. #include <algorithm>
    18. #include <map>
    19. #include <set>
    20. #include <vector>
    21.  
    22. using namespace std;
    23.  
    24. typedef pair<string,int> PSI;
    25.  
    26. //dfs返回的类型，total记录该团队的成员之间通话的总时间，maxv记录该团伙中打电话时长
    27. //最长的一个人的时长，h记录该成员的字符串映射的数字编号；
    28. struct Node
    29. {
    30.     int total, maxv, h;
    31. };
    32.  
    33. const int N = 3e5;
    34. int fath[N]; //并查集数组
    35. bool hs[N]; //该成员是否被访问过
    36. map<int,string> int_nm; //数字映名字
    37. int num[N]; //每个成员的通话时长
    38. vector<int> Adj[N]; //邻接表
    39. set<PSI> res; //记录结果
    40. int k;
    41.  
    42. //字符串转换为数字
    43. int Stoi(string s)
    44. {
    45.     int n = 1;
    46.     for(int i=0; i<s.size(); ++i)
    47.         n = n*27 + s[i] - 'A' + 1;
    48.     return n;
    49. }
    50.  
    51. //并查集的查找祖宗结点编号
    52. int find(int u)
    53. {
    54.     if(fath[u] < 0)
    55.         return u;
    56.     else 
    57.         return fath[u] = find(fath[u]);
    58.         //此处需要trturn，否则会出现段错误，想想也是
    59. }
    60.  
    61. //并查集合并函数
    62. void Union(string a, string b, int t)
    63. {
    64.     int u = Stoi(a), v = Stoi(b);
    65.     int_nm[u] = a, int_nm[v] = b;
    66.     Adj[u].push_back(v), Adj[v].push_back(u);
    67.     num[u] += t, num[v] += t;
    68.  
    69.     int fau = find(u), fav = find(v);
    70.     if(fau != fav)
    71.     {
    72.         fath[fau] += fath[fav]; //注意此处是加，不是相减
    73.         fath[fav] = fau;
    74.     }
    75. }
    76.  
    77. void Read()
    78. {
    79.     int n;
    80.     memset(fath, -1, sizeof(fath)); //注意初始化并查集数组
    81.     cin >> n >> k;
    82.     
    83.     while(n--)
    84.     {
    85.         string a, b;
    86.         int t;
    87.         cin >> a >> b >> t;
    88.         Union(a, b, t);
    89.     }
    90. }
    91.  
    92. Node dfs(int u)
    93. {
    94.     hs[u] = 1;
    95.     int total = num[u], maxval = num[u];
    96.     //cout << int_nm[u] << "->" << num[u] << endl;
    97.     
    98.     int h = u;
    99.     for(int i=0; i<Adj[u].size(); ++i)
    100.     {
    101.         int v = Adj[u][i];
    102.         if(hs[v] == 0)
    103.         {
    104.             //cout << int_nm[u] << "->" << int_nm[v] << endl;
    105.             auto ans = dfs(v);
    106.             
    107.             //搜索每个团队的首领
    108.             if(ans.maxv > maxval)
    109.             {
    110.                 h = ans.h;
    111.                 maxval = ans.maxv;
    112.             }
    113.             total += ans.total;
    114.         }
    115.     }
    116.     
    117.     return {total, maxval, h};
    118. }
    119.  
    120. void Deal()
    121. {
    122.     for(int i=0; i<N; ++i)
    123.     {
    124.         if(Adj[i].size()) //如果i有团队，
    125.         {
    126.             for(auto s : Adj[i])
    127.             {
    128.                 if(hs[s] == 0) //如果此时s还未被访问过
    129.                 {
    130.                     int fau = find(s);
    131.                     if(fath[fau] >= -2) //s所在的团队成员数量不足2，不满足题意
    132.                         continue;
    133.                     Node ans = dfs(s);
    134.                     
    135.                     //注意此处的团队通话时长总计需要除以2，因为返回的是团队中每个
    136.                     //人的通话总时长，而题目要求的是总时长/2 > 阈值k；
    137.                     if(ans.total/2.0 <= k)   continue; 
    138.                     res.insert({int_nm[ans.h], -fath[fau]});
    139.                    // cout << ans.total << "**" << ans.maxv << "**" << ans.h 
    140.                      //   << "**" << int_nm[ans.h] << "**" << num[ans.h] << endl;
    141.                 }
    142.             }
    143.         }
    144.     }
    145. }
    146.  
    147. void Print()
    148. {
    149.     cout << res.size() << endl;
    150.     for(auto s : res)
    151.         cout << s.first << ' ' << s.second << endl;
    152. }
    153.  
    154. int main()
    155. {
    156.     Read();
    157.     
    158.     Deal();
    159.     
    160.     Print();
    161.     
    162.     return 0;
    163. }

    2）《算法笔记》之代码：

    思路：
    输入的成员名字是英文，然而，用图遍历时，不管是邻接矩阵，还是邻接表，
    都需要用数组访问两个顶点是否连通，那么就需要将英文变为数字，同时，还
    需要用到原来的名字，因此，此时的数字也能返过去访问原来的名字，那么定
    义两个map容器便可。
    剩下的便是图的遍历了。同时要注意，进行图的遍历时，是从0这个顶点开始进行遍历的。

    第二个代码的字符串转换为数字，不是用进制来进行转换的，值得学习。当字符串的长度是七八九十个的时候，用进制转换为数字当作数组的下标，明显不现实，但借助 一个map容器，就可简单将字符串转换为数字的大小控制在字符串的数量以内。看代码实现，这第二个是算法笔记上的代码。

    1. /*
    2. 思路：
    3. 输入的成员名字是英文，然而，用图遍历时，不管是邻接矩阵，还是邻接表，
    4. 都需要用数组访问两个顶点是否连通，那么就需要将英文变为数字，同时，还
    5. 需要用到原来的名字，因此，此时的数字也能返过去访问原来的名字，那么定
    6. 义两个map容器便可。
    7. 剩下的便是图的遍历了。同时要注意，进行图的遍历时，是从0这个顶点开始进行遍历的。
    8. */
    9.  
    10. #include <iostream>
    11. #include <map>
    12. #include <vector>
    13.  
    14. using namespace std;
    15.  
    16. map<string, int> str_int;
    17. map<int, string> int_str;
    18. map<string, int> gang;
    19.  
    20. const int N = 2010;
    21. int w[N];
    22. vector<int> Adj[N];
    23. bool hs[N];
    24.  
    25. int n, k;
    26. int idx;
    27.  
    28. int change(string s)
    29. {
    30.     if(str_int.find(s) != str_int.end())
    31.         return str_int[s];
    32.     else
    33.         return idx++;
    34. }
    35.  
    36. void Read()
    37. {
    38.     cin >> n >> k;
    39.     while (n -- )
    40.     {
    41.         string a, b;
    42.         int t;
    43.         cin >> a >> b >> t;
    44.         int u = change(a), v = change(b);
    45.         str_int[a] = u, str_int[b] = v;
    46.         int_str[u] = a, int_str[v] = b;
    47.         w[u] += t, w[v] += t;
    48.         Adj[u].push_back(v), Adj[v].push_back(u);
    49.     }
    50. }
    51.  
    52. void dfs(int index, int &h, int &sum, int &num)
    53. {
    54.     hs[index] = 1;
    55.     if(w[index] > w[h])
    56.         h = index;
    57.     ++num;
    58.     sum += w[index];
    59.     
    60.     for(int i=0; i<Adj[index].size(); ++i)
    61.     {
    62.         int v = Adj[index][i];
    63.         if(hs[v] == 0)
    64.             dfs(v, h, sum, num);
    65.     }
    66. }
    67.  
    68. void Traver()
    69. {
    70.     for(int i=0; i<idx; ++i)
    71.     {
    72.         if(hs[i] == 0)
    73.         {
    74.             int h = i, sum = 0, num = 0;
    75.             dfs(i, h, sum, num);
    76.             if(sum/2.0 > k && num > 2)
    77.                 gang.insert({int_str[h], num});
    78.         }
    79.     }
    80.     
    81.     cout << gang.size() << endl;
    82.     for(auto s : gang)
    83.         cout << s.first << ' ' << s.second << endl;
    84. }
    85.  
    86. int main()
    87. {
    88.     Read();
    89.     
    90.     Traver();
    91.     
    92.     return 0;
    93.     
    94. }

    3）将自己用进制实现的字符串转换为数字的函数，变为算法笔记上的数字逐渐累加的函数。

    1. /**
    2.  * 输入的成员名字是英文，然而，用图遍历时，不管是邻接矩阵，还是邻接表，都需要
    3.  * 用数组访问两个顶点是否连通，那么就需要将英文变为数字，同时，还需要用到原来
    4.  * 的名字，因此，此时的数字也能返过去访问原来的名字，所以要将名字转换为的数字与
    5.  * 名字相映射，用一个map容器记录就行。
    6.  * 由于是一个不超过三个字符的名字，所以可以直接用26进制进行英文转换为数字。
    7.  * 
    8.  * 同一个团伙的成员可以用并查集进行合并，头领记录该团伙的成员数量，其他成员指向
    9.  * 该头领。最后再用图的遍历确定每个团队的首领。
    10.  * 
    11.  * 最后注意计算团队总时长 > 阈值k时，题目要求的总时长是总时长/2，即两个人之间的通话
    12.  * 只能算一次，通话时长总计需要除以2。
    13. */
    14.  
    15. #include <iostream>
    16. #include <cstring>
    17. #include <algorithm>
    18. #include <map>
    19. #include <set>
    20. #include <vector>
    21.  
    22. using namespace std;
    23.  
    24. typedef pair<string,int> PSI;
    25.  
    26. //dfs返回的类型，total记录该团队的成员之间通话的总时间，maxv记录该团伙中打电话时长
    27. //最长的一个人的时长，h记录该成员的字符串映射的数字编号；
    28. struct Node
    29. {
    30.     int total, maxv, h;
    31. };
    32.  
    33. const int N = 3e5;
    34. int fath[N]; //并查集数组
    35. bool hs[N]; //该成员是否被访问过
    36. map<int,string> int_nm; //数字映名字
    37. map<string, int> str_int;
    38. int num[N]; //每个成员的通话时长
    39. vector<int> Adj[N]; //邻接表
    40. set<PSI> res; //记录结果
    41. int k;
    42. int idx;
    43.  
    44. //字符串转换为数字
    45. int change(string s)
    46. {
    47.     if(str_int.find(s) != str_int.end())
    48.         return str_int[s];
    49.     else
    50.         return idx++;
    51. }
    52.  
    53. //并查集的查找祖宗结点编号
    54. int find(int u)
    55. {
    56.     if(fath[u] < 0)
    57.         return u;
    58.     else 
    59.         return fath[u] = find(fath[u]);
    60.         //此处需要trturn，否则会出现段错误，想想也是
    61. }
    62.  
    63. //并查集合并函数
    64. void Union(string a, string b, int t)
    65. {
    66.     int u = change(a), v = change(b);
    67.     int_nm[u] = a, int_nm[v] = b;
    68.     str_int[a] = u, str_int[b] = v;
    69.     Adj[u].push_back(v), Adj[v].push_back(u);
    70.     num[u] += t, num[v] += t;
    71.  
    72.     int fau = find(u), fav = find(v);
    73.     if(fau != fav)
    74.     {
    75.         fath[fau] += fath[fav]; //注意此处是加，不是相减
    76.         fath[fav] = fau;
    77.     }
    78. }
    79.  
    80. void Read()
    81. {
    82.     int n;
    83.     memset(fath, -1, sizeof(fath)); //注意初始化并查集数组
    84.     cin >> n >> k;
    85.     
    86.     while(n--)
    87.     {
    88.         string a, b;
    89.         int t;
    90.         cin >> a >> b >> t;
    91.         Union(a, b, t);
    92.     }
    93. }
    94.  
    95. Node dfs(int u)
    96. {
    97.     hs[u] = 1;
    98.     int total = num[u], maxval = num[u];
    99.     //cout << int_nm[u] << "->" << num[u] << endl;
    100.     
    101.     int h = u;
    102.     for(int i=0; i<Adj[u].size(); ++i)
    103.     {
    104.         int v = Adj[u][i];
    105.         if(hs[v] == 0)
    106.         {
    107.             //cout << int_nm[u] << "->" << int_nm[v] << endl;
    108.             auto ans = dfs(v);
    109.             
    110.             //搜索每个团队的首领
    111.             if(ans.maxv > maxval)
    112.             {
    113.                 h = ans.h;
    114.                 maxval = ans.maxv;
    115.             }
    116.             total += ans.total;
    117.         }
    118.     }
    119.     
    120.     return {total, maxval, h};
    121. }
    122.  
    123. void Deal()
    124. {
    125.     for(int i=0; i<idx; ++i)
    126.     {
    127.         if(Adj[i].size()) //如果i有团队，
    128.         {
    129.             for(auto s : Adj[i])
    130.             {
    131.                 if(hs[s] == 0) //如果此时s还未被访问过
    132.                 {
    133.                     int fau = find(s);
    134.                     if(fath[fau] >= -2) //s所在的团队成员数量不足2，不满足题意
    135.                         continue;
    136.                     Node ans = dfs(s);
    137.                     
    138.                     //注意此处的团队通话时长总计需要除以2，因为返回的是团队中每个
    139.                     //人的通话总时长，而题目要求的是总时长/2 > 阈值k；
    140.                     if(ans.total/2.0 <= k)   continue; 
    141.                     res.insert({int_nm[ans.h], -fath[fau]});
    142.                    // cout << ans.total << "**" << ans.maxv << "**" << ans.h 
    143.                      //   << "**" << int_nm[ans.h] << "**" << num[ans.h] << endl;
    144.                 }
    145.             }
    146.         }
    147.     }
    148. }
    149.  
    150. void Print()
    151. {
    152.     cout << res.size() << endl;
    153.     for(auto s : res)
    154.         cout << s.first << ' ' << s.second << endl;
    155. }
    156.  
    157. int main()
    158. {
    159.     Read();
    160.     
    161.     Deal();
    162.     
    163.     Print();
    164.     
    165.     return 0;
    166. }

  • 相关阅读:
    node.js --- MVC
    C认证笔记 - 计算机通识 - 信息单位
    【六祎 - Mac】Mac安装Nginx；Mac编译安装Nginx；
    C++ 重载运算符和重载函数
    ubuntu创建账号和samba共享目录
    电子科技大学编译原理复习笔记（四）：程序语言的设计
    Linux(CentOS7)搭建LAMP服务环境
    C语言基础知识
    【USRP】报错：Error: RuntimeError: [ad9361_device_t] BBPLL not locked
    【Leetcode】189. 轮转数组
  • 原文地址：https://blog.csdn.net/qq_51825761/article/details/127947147