夏季实训-1.4欧洲冠军联赛

【问题描述】

   欧洲冠军联赛常被誉为全世界最具影响力的俱乐部级赛事。在比赛的小组赛阶段，欧洲的各个足球俱乐部被分为八个小组，每个小组中四支球队。每个小组中的球队按照如下规则排序：

球队会根据比赛结果获得积分。一场比赛的双方被称为主队和客队。如果其中一方进球数多于另一方，那么进球较多的一方获得3 分，另一方获得0 分。如果双方打成平手，则各得1分。

球队的净胜球数是其进球数减去失球数（不考虑该球队在比赛中作为主队还是客队）。

积分较高的球队排名更加靠前。

如果两支球队积分相同，那么净胜球数较多的球队排名靠前。

  小组的各队伍进行循环赛，即每两支球队之间进行两场比赛，双方交替作为主队。给定一个小组内12 场比赛的结果，请求出小组的出线队伍：即排名第一和第二的两支球队。

保证答案唯一。

【输入形式】

  输入的第一行包含一个整数T，代表测试数据的组数。接下来是 T 组数据。

  每组数据共有12 行，每行描述一场比赛，格式为：“主队队名主队进球数vs. 客队进球数客队队名”，其中“主队队名”和“客队队名”为字符串，“主队进球数”和“客队进球数”为两球队在本场比赛中各自的进球数量。    

1 ≤ T ≤ 50

球队队名仅包含小写英文字母

球队队名长度不超过10 个字符

0 ≤ 进球数 ≤ 100

【输出形式】

   对于每组数据，输出一行，包含两个字符串，代表排名第一和第二的球队的队名。

【样例输入】

2
manutd 8 vs. 2 arsenal
lyon 1 vs. 2 manutd
fcbarca 0 vs. 0 lyon
fcbarca 5 vs. 1 arsenal
manutd 3 vs. 1 fcbarca
arsenal 6 vs. 0 lyon
arsenal 0 vs. 0 manutd
manutd 4 vs. 2 lyon
arsenal 2 vs. 2 fcbarca
lyon 0 vs. 3 fcbarca
lyon 1 vs. 0 arsenal
fcbarca 0 vs. 1 manutd
a 3 vs. 0 b
a 0 vs. 0 c
a 0 vs. 0 d
b 0 vs. 0 a
b 4 vs. 0 c
b 0 vs. 0 d
c 0 vs. 0 a
c 0 vs. 0 b
c 1 vs. 0 d
d 3 vs. 0 a
d 0 vs. 0 b
d 0 vs. 0 c
【样例输出】

manutd fcbarca
d b
【样例说明】

第一组数据：每支球队的积分与净胜球数分别为：

manutd：16 分，净胜球数12。

manutd：8 分，净胜球数 4。

manutd：5 分，净胜球数 −5。

manutd：4 分，净胜球数 −11。

第二组数据：每支球队的积分与净胜球数分别为：

d：7 分，净胜球数 2。

b：7 分，净胜球数 1。

a：7 分，净胜球数 0。

c：7 分，净胜球数 −3。

所有球队的积分相同，但是净胜球数较多的队伍排名更加靠前。

#include <iostream>
#include <map>
#include "string"
using  namespace std;
struct team { //设置每个队伍的结构体
    string name = "0";
    int score = 0;
    int jingqiu = 0;

};


struct game  //设置每场比赛大结构体
{
    string zhu;
    int q1;
    string ke;
    int q2;

}arr[12];




int main() {
    int num = 0;
    cin >> num;
    map<int,string>score1;//存放最后输出的top1 top2
    int count=0; //记录放了多少个top
    string vs;//接受vs。

    for (int m = 0; m < num; m++) {

        team t[4];
        game arr[12];

        for (int j = 0; j < 12; j++) {
            cin >> arr[j].zhu >> arr[j].q1 >> vs >> arr[j].q2 >> arr[j].ke;
            int flag = 0;
            for (int k = 0; k < 4; k++) {
                if (t[k].name == arr[j].zhu) {
                    flag = 1;
                    break;
                }
            }
            if (flag == 0) {
                for (int k = 0; k < 4; k++) {
                    if (t[k].name == "0") {
                        t[k].name = arr[j].zhu;
                        break;
                    }
                }
            }

        }


        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 12; j++) {
                if (t[i].name == arr[j].zhu) {//若为主队
                    if (arr[j].q1 > arr[j].q2) {
                        t[i].score += 3;
                        t[i].jingqiu += arr[j].q1 - arr[j].q2;
                    }
                    if (arr[j].q1 == arr[j].q2) {
                        t[i].score += 1;
                        t[i].jingqiu += arr[j].q1 - arr[j].q2;
                    }
                    if (arr[j].q1 < arr[j].q2) {
                        t[i].jingqiu += arr[j].q1 - arr[j].q2;
                    }
                }

                if (t[i].name == arr[j].ke) {//若为客队
                    if (arr[j].q1 > arr[j].q2) {
                        //   t[i].score+=3;
                        t[i].jingqiu += arr[j].q2 - arr[j].q1;
                    }
                    if (arr[j].q1 == arr[j].q2) {
                        t[i].score += 1;
                        //  t[i].jingqiu+=arr[j].q1-arr[j].q2;
                    }
                    if (arr[j].q1 < arr[j].q2) {
                        t[i].score += 3;
                        t[i].jingqiu += arr[j].q2 - arr[j].q1;
                    }
                }
            }
        }


        for(int top=0;top<2;top++)
        {

            int max1 = 0;
            int max2 = 0;
            int index = 0;
            for (int i = 0; i < 4; i++) {
                if (max1 <= t[i].score) max1 = t[i].score;
            }
            for (int j = 0; j < 4; j++) {
                if (t[j].score == max1) {
                    if (t[j].jingqiu > max2) 
						{
							 max2 = t[j].jingqiu;
                  	 		 index = j;
						}	
                }
            }

            score1[count]=t[index].name;
            count++;
            t[index].score = 0;
            t[index].jingqiu = -10000;

        }
        
    }
    for(int i=0;i<2*count;)
    {
        cout<<score1[i]<<" "<<score1[i+1]<<endl;
        i++;
        i++;
    }
    return 0;
}