Is It A Tree?

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static int n = 10001;
    public static int[] father = new int[n];//存储每个节点的父节点
    public static boolean[] isNode = new boolean[n]; //记录对应位置是否有节点
    public static int[] inDegree = new int[n];

    public static void init(){
        //对每个节点进行初始化，最开始每个节点都是一个单独的树
        for (int i = 0; i < n; i++) {
            father[i] = -1; //初始时刻每个节点的父节点都标记为-1
            isNode[i] = false;
            inDegree[i] = 0;
        }
    }

    public static boolean isTree(){
        //通过判断在这个图中，除了根节点，每个节点是否只有一个入度，对于根节点，是否只有一个节点入度为0
        int numRoot = 0; //记录根节点的个数：入度为0
        int node = 0; //记录节点个数
        for (int i = 0; i < n; i++) {
            if(!isNode[i]) continue; //此处没有节点，则继续下一次循环
            node++;
            if(inDegree[i] > 1){
                //有节点入度大于1，说明不是树
                return false;
            }
            if(inDegree[i] == 0){
                //是根节点
                numRoot++;
            }
        }

        //空树也是树
        if(node == 0) return true;
        else { //不是空树
            //如果树中的根节点个数大于1，肯定不是树
            if(numRoot > 1) return false;
            //接下来的情况只有根节点的个数为0或1
            //如果树中没有根节点，则不是树
            return numRoot != 0;
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int i = 1;
        init();
        while(sc.hasNextInt()){
            int start = sc.nextInt();
            int end = sc.nextInt();
            if(start < 0 && end < 0) break;
            if(start == 0 && end == 0 && isTree()){
                System.out.printf("Case %d is a tree.\n", i);
                i++;
                init(); //判断完一个图，继续判断下一个图
            }else if(start == 0 && end == 0){
                System.out.printf("Case %d is not a tree.\n", i);
                i++;
                init();
            }else {
                father[end] = start;
                isNode[start] = true;
                isNode[end] = true;
                inDegree[end]++;
            }
        }
    }
}

import java.util.*;
public class Main {
    // 判断是否有环
    public static boolean isCyclic(int[] nodes, int start) {    
        int parent = nodes[start];
        while (parent != -1 && nodes[parent] != -1) {
            if (parent == start)
                return true;
            parent = nodes[parent];
        }
        return false;
    }
    // 判断是否树
    public static void judge(int[] nodes, boolean isTree, int k) {
        int index = 0;
        for (; nodes[index] != -1; ++index) ;
        boolean hasCircle = isCyclic(nodes, index);
        if (!isTree || hasCircle) {
            System.out.println("Case " + k + " is not a tree.");
        } else {
            System.out.println("Case " + k + " is a tree.");
        }
    }
    public static void main(String[] args) {
        int k = 1;
        int[] nodes = new int[10001];
        // nodes保存的是父子节点，-1表示未访问
        for (int i = 0; i < nodes.length; ++i) {
            nodes[i] = -1;
        }
        
        boolean isTree = true;
        Scanner reader = new Scanner(System.in);
        while (reader.hasNext()) {
            String line = reader.nextLine();
            String[] number = line.split(" +");
            for (int i = 0; i < number.length - 1; i=i+2) {
                int j = i + 1;
                int from = Integer.valueOf(number[i]);
                int to = Integer.valueOf(number[j]);
                if (from + to == -2 || from + to == 0) {
                    break;
                } else {
                    // case 1: to指向自己
                    // case 2: to已赋值，并且不等于当前的from
                    // case 3: to和from重复赋值，相当于入度大于1
                    if (from == to || (nodes[to] != -1 && nodes[to] != from) || nodes[to] == from) {
                        isTree = false;
                    } else if (nodes[to] == -1) {
                        nodes[to] = from;
                    }
                }
            }
            judge(nodes, isTree, k);
            ++k;
            isTree = true;
        }
    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;

/*
 *	QQ:	825580813(一起来敲代码)
 *	思路:
 *		1,首先判断是不是自己指向自己 --> not
 *		2,申请一个HashMap用来保存每个节点的父节点的个数
 *		3,当输入 start end 时,这时,新添加的就有,start的父节点增加 0 个, end 的父节点增加一个
 *		4,最后只需要判断是否有多个节点的父节点为 0 或者 某个节点的父节点 大于1 即可.
 */
public class Main {
	
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		int time = 1;
		while (sc.hasNext()) {
			int start = sc.nextInt();
			int end = sc.nextInt();
			if (start == -1 && end == -1) {
				break;
			}
			HashMap<Integer, Integer> map = new HashMap<>();
			boolean isTree = true;
			while (start != 0 && end != 0) {
				if (start == end) {
					isTree = false;
				}
				if (map.containsKey(start)) {
					map.put(start, map.get(start) + 1);
				}
				else {
					map.put(start, 0);
				}
				if (map.containsKey(end)) {
					map.put(end, map.get(end) + 1);
				}
				else {
					map.put(end, 1);
				}
				start = sc.nextInt();
				end = sc.nextInt();
			}
			Set<Map.Entry<Integer, Integer>> set = map.entrySet();
			int nullParent = 0;
			for (Entry<Integer, Integer> entry : set) {
				if (nullParent > 1 || entry.getValue() > 1) {
					isTree = false;
					break;
				}
				if (entry.getValue() == 0) {
					nullParent++;
				}
			}
			if (isTree) {
				System.out.println("Case " + (time++) + " is a tree.");
			}
			else {
				System.out.println("Case " + (time++) + " is not a tree.");
			}
		}
		sc.close();
	}
	
}