幼儿园分班问题【Java】

75 阅读 0 评论 50 点赞

我是靠谱客的博主长情人生，这篇文章主要介绍幼儿园分班问题【Java】，现在分享给大家，希望可以做个参考。

幼儿园分班问题【Java】

题目描述

幼儿园两个班的小朋友在排队时混在了一起，每位小朋友都知道自己是否与前面一位小朋友是否同班，请你帮忙把同班的小朋友找出来。

小朋友的编号是整数，与前一位小朋友同班用Y表示，不同班用N表示。

输入描述

输入由空格分开的小朋友编号和是否同班的标志，如：

6/N 2/Y 3/N 4/Y 表示一共有4位小朋友

2和6是同班，3和2不同班，4和3同班。

小朋友总数<999

不考虑输入格式错误。

输出描述

输出每个班级的小朋友编号，用空格隔开

输出结果按编号大小升序排列

第一个分班的小朋友编号较小的排在第一队，输出在第一行

若只有一个班级，则第二行为空

若输入不符合要求，则输出“ERROR"

示例1

输入
复制代码1/N 2/Y 3/N 4/Y
```
1
2
1/N 2/Y 3/N 4/Y
```
输出
复制代码1 2 3 4
```
1
2
3
1 2
3 4
```
说明
复制代码2和1同一班，3与2不是同一个班，4和3同一班
```
1
2
2和1同一班，3与2不是同一个班，4和3同一班
```

解题思路

用一个对象表示一个小朋友在队伍的位置信息，然后统计每个小朋友的班级编号
分班到两个集合
对输出要求进行输出即可，注意排序
对输入异常（编号不能小于0，不能大于999）时，结束程序，并输出ERROR

代码

复制代码

import java.util.*;

public class Main {
    public static void main(String[] args) {
        // 处理输入
        Scanner input = new Scanner(System.in);
        String line = input.nextLine();
        String[] split = line.split(" ");
        Node[] nodes = new Node[split.length];
        boolean isFailed = false;
        for (int i = 0; i < split.length; i++) {
            String[] one = split[i].split("/");
            nodes[i] = new Node(Integer.parseInt(one[0]), Objects.equals(one[1], "Y"));
            if (nodes[i].value < 0 || nodes[i].value > 999) {
                isFailed = true;
            }
        }
        if (isFailed) {
            System.out.println("ERROR");
            return;
        }

// 先让第一个人加入1队
        nodes[0].clazz = 1;
        for (int i = 1; i < nodes.length; i++) {
            // 从第二个人开始，看他是否和前面一个人是同一队
            if (nodes[i].isTrue) {
                // 如果是，则判断前面一个是不是1队，否则加入2队
                nodes[i].clazz = nodes[i - 1].clazz == 1 ? 1 : 2;
            } else {
                // 如果不是，则判断前面一个是不是1队，如果不是，则加入1队
                nodes[i].clazz = nodes[i - 1].clazz == 1 ? 2 : 1;
            }
        }

// 上面已经确认每个人是属于哪个队伍，下面组装队伍，便于输出
        ArrayList<Integer> oneClass = new ArrayList<>();
        ArrayList<Integer> twoClass = new ArrayList<>();
        for (Node node : nodes) {
            if (node.clazz == 1) {
                oneClass.add(node.value);
            } else {
                twoClass.add(node.value);
            }
        }

// 处理输出,1队肯定不为空，如果2队为空，则第二行输出换行符
        if (twoClass.isEmpty()) {
            // 输出
            System.out.println(listToString(oneClass));
            System.out.println();
            return;
        }

// 第一个编号较小的队伍往前排，题目描述不是很清，如果是排序后再比较，可以自己适当修改下
        if (oneClass.get(0) < twoClass.get(0)) {
            System.out.println(listToString(oneClass));
            System.out.println(listToString(twoClass));
        } else {
            System.out.println(listToString(twoClass));
            System.out.println(listToString(oneClass));
        }
    }

private static String listToString(List<Integer> list) {
        Collections.sort(list);
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < list.size(); i++) {
            sb.append(list.get(i));
            if (i != list.size() - 1) {
                sb.append(" ");
            }
        }
        return sb.toString();
    }

private static class Node {
        int value;
        boolean isTrue;
        int clazz;

public Node(int value, boolean isTrue) {
            this.value = value;
            this.isTrue = isTrue;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
import java.util.*;

public class Main {
    public static void main(String[] args) {
        // 处理输入
        Scanner input = new Scanner(System.in);
        String line = input.nextLine();
        String[] split = line.split(" ");
        Node[] nodes = new Node[split.length];
        boolean isFailed = false;
        for (int i = 0; i < split.length; i++) {
            String[] one = split[i].split("/");
            nodes[i] = new Node(Integer.parseInt(one[0]), Objects.equals(one[1], "Y"));
            if (nodes[i].value < 0 || nodes[i].value > 999) {
                isFailed = true;
            }
        }
        if (isFailed) {
            System.out.println("ERROR");
            return;
        }

        // 先让第一个人加入1队
        nodes[0].clazz = 1;
        for (int i = 1; i < nodes.length; i++) {
            // 从第二个人开始，看他是否和前面一个人是同一队
            if (nodes[i].isTrue) {
                // 如果是，则判断前面一个是不是1队，否则加入2队
                nodes[i].clazz = nodes[i - 1].clazz == 1 ? 1 : 2;
            } else {
                // 如果不是，则判断前面一个是不是1队，如果不是，则加入1队
                nodes[i].clazz = nodes[i - 1].clazz == 1 ? 2 : 1;
            }
        }

        // 上面已经确认每个人是属于哪个队伍，下面组装队伍，便于输出
        ArrayList<Integer> oneClass = new ArrayList<>();
        ArrayList<Integer> twoClass = new ArrayList<>();
        for (Node node : nodes) {
            if (node.clazz == 1) {
                oneClass.add(node.value);
            } else {
                twoClass.add(node.value);
            }
        }

        // 处理输出,1队肯定不为空，如果2队为空，则第二行输出换行符
        if (twoClass.isEmpty()) {
            // 输出
            System.out.println(listToString(oneClass));
            System.out.println();
            return;
        }

        // 第一个编号较小的队伍往前排，题目描述不是很清，如果是排序后再比较，可以自己适当修改下
        if (oneClass.get(0) < twoClass.get(0)) {
            System.out.println(listToString(oneClass));
            System.out.println(listToString(twoClass));
        } else {
            System.out.println(listToString(twoClass));
            System.out.println(listToString(oneClass));
        }
    }

    private static String listToString(List<Integer> list) {
        Collections.sort(list);
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < list.size(); i++) {
            sb.append(list.get(i));
            if (i != list.size() - 1) {
                sb.append(" ");
            }
        }
        return sb.toString();
    }

    private static class Node {
        int value;
        boolean isTrue;
        int clazz;

        public Node(int value, boolean isTrue) {
            this.value = value;
            this.isTrue = isTrue;
        }
    }
}