1004 Counting Leaves（30 分）

A family hierarchy is usually presented by a pedigree tree. Your job is to count those family members who have no child.

Input Specification:

Each input file contains one test case. Each case starts with a line containing 0~100, the number of nodes in a tree, and M (< N), the number of non-leaf nodes. Then M lines follow, each in the format:

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

where ID is a two-digit number representing a given non-leaf node, K is the number of its children, followed by a sequence of two-digit ID’s of its children. For the sake of simplicity, let us fix the root ID to be 01.

The input ends with N being 0. That case must NOT be processed.

Output Specification:

For each test case, you are supposed to count those family members who have no child for every seniority level starting from the root. The numbers must be printed in a line, separated by a space, and there must be no extra space at the end of each line.

The sample case represents a tree with only 2 nodes, where 01 is the root and 02 is its only child. Hence on the root 01 level, there is 0 leaf node; and on the next level, there is 1leaf node. Then we should output 0 1 in a line.

Sample Input:

2 1
01 1 02

Sample Output:

0 1

answer

import java.util.*; /** * Created by Boolean on 2018/8/8. */ public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int numbers = scanner.nextInt(); int num_noleaf = scanner.nextInt(); int i = 0; int[] levels = new int[numbers]; DNode[] nodes = new DNode[numbers]; levels[0] = 0; int max_level=0; for(i=0;i<numbers;i++) { DNode dNode = new DNode(i); nodes[i] = dNode; } while(num_noleaf>0) { int vertext = scanner.nextInt(); int num_child = scanner.nextInt(); LinkedList<BNode> bNodes = new LinkedList<>(); while (num_child-->0) { int child = scanner.nextInt(); BNode newNode = new BNode(child-1); bNodes.add(newNode); levels[child-1] = levels[vertext-1]+1; if(levels[child-1]>max_level) max_level = levels[child-1]; } nodes[vertext-1].setBList(bNodes); num_noleaf--; } BFS(nodes,numbers,levels,max_level); DFS(nodes,numbers,levels,max_level); } static class DNode{ private int vertex; private LinkedList<BNode> BList; DNode(int vertex,LinkedList<BNode> BList) { this.vertex = vertex; this.BList = BList; } public DNode(int vertex) { this.vertex = vertex; } public void setBList(LinkedList<BNode> BList){ this.BList = BList; } } private static class BNode{ private int vertex; private Boolean hasChild = false; BNode(int vertex){ this.vertex = vertex; } } //广度遍历算法 private static void BFS(DNode[] dNodes,int numbers,int[] levels,int sum_level) { Queue<DNode> queue = new LinkedList<>();//辅助队列 Boolean[] visited = new Boolean[numbers];//记录结点是否被访问过 int[] res = new int[100];//结果集 for(int i=0;i<numbers;i++)visited[i]=false; visited[0] = true; queue.offer(dNodes[0]);//根结点入队，若是图，则函数参数需要加vertex作为起始结点 if(dNodes[0].BList==null){System.out.printf("1");return;}//只有一个根结点 else System.out.printf("0"); //队列为空则完成遍历 while (!queue.isEmpty()) { DNode dNode = queue.poll(); int index = 0; //遍历所有邻接结点 while (dNode.BList!=null&&index<dNode.BList.size()) { int child_ver = dNode.BList.get(index).vertex; if(!visited[child_ver]) { if(dNodes[child_ver].BList==null){ visited[child_ver]=true;//leaf-node++ res[levels[child_ver]]++; } else { visited[child_ver] = true; queue.offer(dNodes[child_ver]);//入队列 } } index++; } } //输出leaf-node数 for(int i=1;i<=sum_level;i++) { System.out.printf(" %d",res[i]); } } }

//深度遍历
    private static void DFS(DNode[] dNodes,int numbers,int[] levels,int sum_level)
    {
        DNode dNode = dNodes[0];//根结点
        Boolean[] visited = new Boolean[numbers];
        for(int i=0;i<numbers;i++)visited[i]=false;
        int[] res = new  int[numbers];
        //dfs遍历
        dfs_fun(dNode,visited,dNodes,levels,res);
        //根结点是否为空
        if(dNode.BList!=null) System.out.printf("0");
        else System.out.printf("1");
        //输出结果集
        for(int i=1;i<=sum_level;i++) System.out.printf(" %d",res[i]);
    }
    private static void dfs_fun(DNode vertex,Boolean[] visited,DNode[] dNodes,int[] levels,int[] res)
    {
        visited[vertex.vertex] = true;
        int index = 0;
        //遍历邻接结点
        for(int i=0;vertex.BList!=null&&i<vertex.BList.size();i++)
        {
            int node = vertex.BList.get(index).vertex;
            if(!visited[node])
            {
                index++;
                if(dNodes[node].BList==null){ res[levels[node]]++;}
                //递归调用
                dfs_fun(dNodes[node],visited,dNodes,levels,res);
            }
        }
    }