zoukankan      html  css  js  c++  java
  • PAT Advanced Level 1094

    1094 The Largest Generation(25 分)

    A family hierarchy is usually presented by a pedigree tree where all the nodes on the same level belong to the same generation. Your task is to find the generation with the largest population.

    Input Specification:

    Each input file contains one test case. Each case starts with two positive integers N (<100) which is the total number of family members in the tree (and hence assume that all the members are numbered from 01 to N), and M (<N) which is the number of family members who have children. Then M lines follow, each contains the information of a family member in the following format:

    ID K ID[1] ID[2] ... ID[K]
    

    where ID is a two-digit number representing a family member, K (>0) is the number of his/her children, followed by a sequence of two-digit ID's of his/her children. For the sake of simplicity, let us fix the root ID to be 01. All the numbers in a line are separated by a space.

    Output Specification:

    For each test case, print in one line the largest population number and the level of the corresponding generation. It is assumed that such a generation is unique, and the root level is defined to be 1.

    Sample Input:

    23 13
    21 1 23
    01 4 03 02 04 05
    03 3 06 07 08
    06 2 12 13
    13 1 21
    08 2 15 16
    02 2 09 10
    11 2 19 20
    17 1 22
    05 1 11
    07 1 14
    09 1 17
    10 1 18

    Sample Output:

    9 4
    没难度 一次过 一看AC率高达0.57 大家都这么棒棒啊
    /**********************
    author: yomi
    date: 18.8.20
    ps:
    **********************/
    #include <iostream>
    #include <vector>
    #include <cstring>
    using namespace std;
    
    struct Node
    {
        vector<int>child;
        int id;
    }node[1010];
    bool vis[1010];
    int depth = 1, ans[1010];
    
    void dfs(int index)
    {
        if(node[index].child.size() == 0){
            return;
        }
        vis[index] = true;
        for(int i=0; i<node[index].child.size(); i++){
            if(!vis[node[index].child[i]]){
                ans[depth]++;
                depth++;
                dfs(node[index].child[i]);
                depth--;
            }
        }
    
    
    }
    int main()
    {
        int n, m, id, t, d;
        memset(ans, 0, sizeof(ans));
        cin >> n >> m;
        for(int i=0; i<m; i++){
            cin >> id >> t;
            for(int j=0; j<t; j++){
                cin >> d;
                node[id].child.push_back(d);
            }
        }
        dfs(1);
        int flag = 1;
        int Max = 0, ind;
        for(int i=1; i<1010; i++){
            if(ans[i] == 0)
                break;
            if(ans[i] > Max){
                Max = ans[i];
                flag = 0;
                ind = i;
            }
        }
        if(flag == 0)
            cout << Max << ' ' << ind+1;
        else{
            cout << "1 1";
        }
        return 0;
    }
    /**
    Sample Input:
    23 13
    21 1 23
    01 4 03 02 04 05
    03 3 06 07 08
    06 2 12 13
    13 1 21
    08 2 15 16
    02 2 09 10
    11 2 19 20
    17 1 22
    05 1 11
    07 1 14
    09 1 17
    10 1 18
    Sample Output:
    9 4
    **/
    /**********************
    author: yomi
    date: 18.8.20
    ps:
    **********************/
    #include <iostream>
    #include <vector>
    #include <cstring>
    using namespace std;
    struct Node
    {
        vector<int>child;
        int id;
    }node[1010];
    bool vis[1010];
    int depth = 1, ans[1010];
    void dfs(int index)
    {
        if(node[index].child.size() == 0){
            return;
        }
        vis[index] = true;
        for(int i=0; i<node[index].child.size(); i++){
            if(!vis[node[index].child[i]]){
                ans[depth]++;
                depth++;
                dfs(node[index].child[i]);
                depth--;
            }
        }

    }
    int main()
    {
        int n, m, id, t, d;
        memset(ans, 0, sizeof(ans));
        cin >> n >> m;
        for(int i=0; i<m; i++){
            cin >> id >> t;
            for(int j=0; j<t; j++){
                cin >> d;
                node[id].child.push_back(d);
            }
        }
        dfs(1);
        int flag = 1;
        int Max = 0, ind;
        for(int i=1; i<1010; i++){
            if(ans[i] == 0)
                break;
            if(ans[i] > Max){
                Max = ans[i];
                flag = 0;
                ind = i;
            }
        }
        if(flag == 0)
            cout << Max << ' ' << ind+1;
        else{
            cout << "1 1";
        }
        return 0;
    }
    /**
    Sample Input:
    23 13
    21 1 23
    01 4 03 02 04 05
    03 3 06 07 08
    06 2 12 13
    13 1 21
    08 2 15 16
    02 2 09 10
    11 2 19 20
    17 1 22
    05 1 11
    07 1 14
    09 1 17
    10 1 18
    Sample Output:
    9 4
    **/
  • 相关阅读:
    leetcode 131. Palindrome Partitioning
    leetcode 526. Beautiful Arrangement
    poj 1852 Ants
    leetcode 1219. Path with Maximum Gold
    leetcode 66. Plus One
    leetcode 43. Multiply Strings
    pytorch中torch.narrow()函数
    pytorch中的torch.repeat()函数与numpy.tile()
    leetcode 1051. Height Checker
    leetcode 561. Array Partition I
  • 原文地址:https://www.cnblogs.com/AbsolutelyPerfect/p/9506288.html
Copyright © 2011-2022 走看看