球赛排名问题

问题描述

大学生足协决定举办全国性的大学生足球赛，由每个学校派遣一支队伍代表该校参赛。比赛分区分为几个赛区进行，最终的总决赛中，将有不超过n支队伍参加。经过激烈的角逐，有机会参与总决赛的队伍已经决出。

协会对比赛的规则进行了调整，以便使得比赛更具有观赏性。
1. 总决赛的参赛队伍为n支，n为偶数；
2. 进入前1/2的队伍才有资格进入淘汰赛；
3. 队伍按积分排名，具体规则为：胜一场积3分；平一场积1分；负一场积0分。队伍首先按积分降序排列，积分相同按净胜球数降序排列，仍然相同的按进球数降序排列。
4. 基于上述规则，尚未出现有排名歧义的情况发生。

随着赛程的进行，目前各个队伍对战的结果已经确定了，小B负责确定进入淘汰赛的名单，她向你求助，你能帮她吗？
输入
测试数据有多组，每组测试数据的第一行为一个整数n（1=< n <=50），为参与总决赛的球队数，随后的n行为球队的名字，由不超过30个的大小写拉丁字母构成。随后的n*(n-1)/2行为赛事的开展情况，每行的格式为name1-name2 num1:num2，表示两支队伍的比分情况（0=< num1, num2<=100）。确保不会有两支队伍同名，也不会出现队伍自己通自己比赛的情况，且每场比赛仅出现一次。

样例输入

4
A
B
C
D
A-B 1:1
A-C 2:2
A-D 1:0
B-C 1:0
B-D 0:3
C-D 0:3
2
a
A
a-A 2:1

样例输出

A
D
a

思路分析

代码实现

package xunfei;

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Scanner;

public class Main2 {
    public static void main(String[] args) {
        // 接收输入
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int N = Integer.parseInt(sc.nextLine());
            HashMap<String, Team> kv = new HashMap<>();

            // 接收队伍名称
            for (int n=0; n<N; n++) {
                String name = sc.nextLine();
                kv.put(name, new Team(name));
            }

            // 接收N*(N-1)/2行输入
            int rows = N*(N-1) >> 1;
            for (int row=0; row<rows; row++) {
                String[] arr = sc.nextLine().split(" ");
                String[] names = arr[0].split("-");
                String[] values = arr[1].split(":");

                String namea = names[0];
                String nameb = names[1];

                int valuea = Integer.parseInt(values[0]);
                int valueb = Integer.parseInt(values[1]);

                int scorea = 0, scoreb = 0;
                if (valuea > valueb) {
                    scorea = 3;
                    scoreb = 0;

                    kv.get(namea).score += scorea;
                    kv.get(namea).pure += valuea-valueb;
                    kv.get(namea).hit += valuea;

                    kv.get(nameb).score += scoreb;
                    kv.get(nameb).hit += valueb;
                } else if (valuea == valueb) {
                    scorea=1;
                    scoreb=1;

                    kv.get(namea).score += scorea;
                    kv.get(namea).hit += valuea;

                    kv.get(nameb).score += scoreb;
                    kv.get(nameb).hit += valueb;
                } else {
                    scorea = 0;
                    scoreb = 3;

                    kv.get(namea).score += scorea;
                    kv.get(namea).hit += valuea;

                    kv.get(nameb).score += scoreb;
                    kv.get(nameb).pure += valueb-valuea;
                    kv.get(nameb).hit += valueb;
                }
            }

            // 获取value
            Collection<Team> c = kv.values();
            LinkedList<Team> list = new LinkedList<>();
            for (Team t : c) {
                list.add(t);
            }
            Collections.sort(list);

            System.out.println(list.toString());
        }

        sc.close();

    }
}

// 定义球队类
class Team extends Object implements Comparable<Team>{
    public String name = null;  // 名称
    public int pure = 0;        // 净胜球数目
    public int hit = 0;         // 进球数目

    public int score = 0;       // 总积分

    public Team(String name, int pure, int hit) {
        this.name = name;
        this.pure = pure;
        this.hit = hit;
    }

    public Team(String name) {
        this(name, 0, 0);
    }

    @Override
    public int compareTo(Team o) {
        if (this.score != o.score) {
            return -this.score + o.score;
        } else if (this.pure != o.pure) {
            return -this.pure + o.pure;
        } else {
            return -this.hit + o.hit;
        }
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return name;
    }

}