提前预测世界杯冠军

0.前言

又一年的世界杯要开始了，不可避免的，我们要对比赛的结果进行预（jing）测（cai），那么如何科（yi）学（ben）严（zheng）谨（jing）的进行呢？

首先我们来看一下比赛规则

1.比赛规则

1.1小组赛阶段

32支参赛队通过抽签分为八个小组,每个小组分别有四支球队进行比赛，每支球队都必须和其他三支球队进行且只进行一场比赛,每组4个队循环比赛，共打6场，每场比赛90分钟，胜平负分别积3、1、0分。每个小组积分的前两名球队出线进入淘汰赛阶段的1/8决赛，共16支队，即“16强”。

1.2淘汰赛阶段

淘汰赛阶段的 90分钟内（含补时阶段）进球多的球队取胜，如果参赛双方在90分钟内（含补时阶段）无法决出胜负，将进行上下半场各15分钟的加时赛。加时赛阶段，如果两队仍未分出胜负，则通过每个球员的点球决出胜者

16强阶段开始采用淘汰赛制,淘汰赛阶段的对阵安排是

1/8决赛

A组第一对阵B组第二=胜者1
B组第一对阵A组第二=胜者2
C组第一对阵D组第二=胜者3
D组第一对阵C组第二=胜者4
E组第一对阵F组第二=胜者5
F组第一对阵E组第二=胜者6
G组第一对阵H组第二=胜者7
H组第一对阵G组第二=胜者8

获胜的8个队进入1/4决赛，即所谓“8强”

1/4决赛

胜者1对阵胜者3=胜者A
胜者2对阵胜者4=胜者B
胜者5对阵胜者7=胜者C
胜者6对阵胜者8=胜者D

1/4决赛的4个获胜队进入“4强”

半决赛

胜者A对阵胜者C
胜者B对阵胜者D

决赛

半决赛获胜两队进入决赛，失利的两队争夺三名

即如图所示的安排：

2.分析

今天我们主要对淘汰赛进行分析和预测，那么为了方便我们描述，为每一个队进行编号，如图所示：

 以`队1 `为例进行分析

1.如果队1想要在1/8决赛胜出,那么战胜队2即可
2.如果队1想要在1/4决赛胜出,那么在进1/8决赛的基础上，要战胜 胜者3
3.如果队1想要在半决赛胜出,那么在进1/4决赛的基础上，要战胜 胜者C
4.如果队1想要在决赛胜出,那么在进半决赛的基础上，要战胜 决赛2

3.计算

我们用
P(i,j)表示`队i`与`队j`相遇后，`队i`获胜的概率（假设已知）

我们用
p1(i)表示`队i`在`1/8决赛`胜出的概率
p2(i)表示`队i`在`1/4决赛`胜出的概率
p3(i)表示`队i`在`半决赛`胜出的概率
p4(i)表示`队i`在`决赛`胜出的概率

以队1为例进行分析

3.1 1/8决赛

1.如果队1想要在1/8决赛胜出,那么战胜队2即可

即

p1(1)=P(1,2);

3.2 1/4决赛

如果队1想要在1/4决赛胜出,那么在进1/8决赛的基础上，要战胜 胜者3

因为胜者3可能为队3和队4

如果`队1 `想要在`1/4决赛`胜出,那么在进`1/8决赛`的基础上，要战胜 `胜者3`

就变成了

如果`队1 `想要在`1/4决赛`胜出,那么在进`1/8决赛`的基础上，要战胜 

1.在`1/8决赛`中胜出的为`队3`时的`队3`，
2.在`1/8决赛`中胜出的为`队4`时的`队4`

即

p2(1)=p1(1)*(
p1(3)*P(1,3)
+p1(4)*P(1,4)
);

3.3 半决赛

如果队1想要在半决赛胜出,那么在进1/4决赛的基础上，要战胜 胜者C

因为胜者C可能为队5、队6、队7、队8

如果`队1 `想要在`半决赛`胜出,那么在进`1/4决赛`的基础上，要战胜 `胜者C`

就变成了

如果`队1 `想要在`半决赛`胜出,那么在进`1/4决赛`的基础上，要战胜 

1.在`1/4决赛`中胜出的为`队5`时的`队5`，
2.在`1/4决赛`中胜出的为`队6`时的`队6`
3.在`1/4决赛`中胜出的为`队7`时的`队7`，
4.在`1/4决赛`中胜出的为`队8`时的`队8`

即

p3(1)=p2(1)*(
p2(5)*P(1,5)
+p2(6)*P(1,6)
+p2(7)*P(1,7)
+p2(8)*P(1,8)
);

3.4 决赛

如果队1想要在决赛胜出,那么在进半决赛的基础上，要战胜 决赛2

因为决赛2可能为队9、队10、队11、队12、队13、队14、队15、队16

如果`队1 `想要在`决赛`胜出,那么在进`半决赛`的基础上，要战胜 `决赛2`

就变成了

如果`队1 `想要在`决赛`胜出,那么在进`半决赛`的基础上，要战胜 

1.在`半决赛`中胜出的为`队9`时的`队9`，
2.在`半决赛`中胜出的为`队10`时的`队10`
3.在`半决赛`中胜出的为`队11`时的`队11`，
4.在`半决赛`中胜出的为`队12`时的`队12`
5.在`半决赛`中胜出的为`队13`时的`队13`，
6.在`半决赛`中胜出的为`队14`时的`队14`
7.在`半决赛`中胜出的为`队15`时的`队15`，
8.在`半决赛`中胜出的为`队16`时的`队16`

即

p4(1)=p3(1)*(
p3(9)*P(1,9)
+p3(10)*P(1,10)
+p3(11)*P(1,11)
+p3(12)*P(1,12)
+p3(13)*P(1,13)
+p3(14)*P(1,14)
+p3(15)*P(1,15)
+p3(16)*P(1,16)
);

4.代码实现

import java.util.Scanner;

/**
 * @Title:Main_3.java 
 * @author Stone6762  
 * @CreationTime 2018年6月15日 下午3:15:12
 * @Description:
 */
public class Main_3 {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        while (scan.hasNext()) {
            double[][] p = new double[17][17];
            for (int i = 1; i < p.length; i++) {
                for (int j = 1; j < p.length; j++) {
                    p[i][j]=scan.nextDouble();
                }
            }
            double[] p_1 = new double[17];
            double[] p_2 = new double[17];
            double[] p_3 = new double[17];
            double[] p_4 = new double[17];
            // 第一轮比赛，16进8，每队的获胜几率为：1个
            for (int i = 1; i <=8; i++) {
                p_1[i*2-1]=p[i*2-1][i*2];
                p_1[i*2]=1-p[i*2-1][i*2];
            }
            //第二轮，8进4，每队的获胜几率为2个
            for (int i = 1; i <=4; i++) {
                //i*4-3获胜，在胜了第一轮的基础上， 胜了第二轮可能碰到的i*4-1和i*4的概率
                p_2[i*4-3]=p_1[i*4-3]*(p_1[i*4]*p[i*4-3][i*4]+p_1[i*4-1]*p[i*4-3][i*4-1]);
                p_2[i*4-2]=p_1[i*4-2]*(p_1[i*4]*p[i*4-2][i*4]+p_1[i*4-1]*p[i*4-2][i*4-1]);

                p_2[i*4-1]=p_1[i*4-1]*(p_1[i*4-3]*p[i*4-1][i*4-3]+p_1[i*4-2]*p[i*4-1][i*4-2]);
                p_2[i*4]=  p_1[i*4]  *(p_1[i*4-3]*p[i*4][i*4-3]+p_1[i*4-2]*p[i*4][i*4-2]);
            }           

            //第三轮  4进2，每队获胜的几率为  4个
            for (int i = 1; i <=2; i++) {
                //i*8-7获胜，在胜了第二轮的基础上， 胜了第二轮可能碰到的i*8和i*8-1  i*8-2的概率
                p_3[i*8-7]=p_2[i*8-7]*(
                         p_2[i*8]*p[i*8-7][i*8]
                        +p_2[i*8-1]*p[i*8-7][i*8-1]
                        +p_2[i*8-2]*p[i*8-7][i*8-2]
                        +p_2[i*8-3]*p[i*8-7][i*8-3]);
                p_3[i*8-6]=p_2[i*8-6]*(
                         p_2[i*8]*p[i*8-6][i*8]
                        +p_2[i*8-1]*p[i*8-6][i*8-1]
                        +p_2[i*8-2]*p[i*8-6][i*8-2]
                        +p_2[i*8-3]*p[i*8-6][i*8-3]);
                p_3[i*8-5]=p_2[i*8-5]*(
                         p_2[i*8]*p[i*8-5][i*8]
                        +p_2[i*8-1]*p[i*8-5][i*8-1]
                        +p_2[i*8-2]*p[i*8-5][i*8-2]
                        +p_2[i*8-3]*p[i*8-5][i*8-3]);
                p_3[i*8-4]=p_2[i*8-4]*(
                         p_2[i*8]*p[i*8-4][i*8]
                        +p_2[i*8-1]*p[i*8-4][i*8-1]
                        +p_2[i*8-2]*p[i*8-4][i*8-2]
                        +p_2[i*8-3]*p[i*8-4][i*8-3]);

                p_3[i*8-3]=p_2[i*8-3]*(
                         p_2[i*8-7]*p[i*8-3][i*8-7]
                        +p_2[i*8-6]*p[i*8-3][i*8-6]
                        +p_2[i*8-5]*p[i*8-3][i*8-5]
                        +p_2[i*8-4]*p[i*8-3][i*8-4]);
                p_3[i*8-2]=p_2[i*8-2]*(
                         p_2[i*8-7]*p[i*8-2][i*8-7]
                        +p_2[i*8-6]*p[i*8-2][i*8-6]
                        +p_2[i*8-5]*p[i*8-2][i*8-5]
                        +p_2[i*8-4]*p[i*8-2][i*8-4]);

                p_3[i*8-1]=p_2[i*8-1]*(
                         p_2[i*8-7]*p[i*8-1][i*8-7]
                        +p_2[i*8-6]*p[i*8-1][i*8-6]
                        +p_2[i*8-5]*p[i*8-1][i*8-5]
                        +p_2[i*8-4]*p[i*8-1][i*8-4]);
                p_3[i*8]=p_2[i*8]*(
                         p_2[i*8-7]*p[i*8][i*8-7]
                        +p_2[i*8-6]*p[i*8][i*8-6]
                        +p_2[i*8-5]*p[i*8][i*8-5]
                        +p_2[i*8-4]*p[i*8][i*8-4]);

            }   
            //第四轮 冠军，  8个
            p_4[1]=p_3[1]*(
                    p_3[16]*p[1][16]
                    +p_3[15]*p[1][15]
                    +p_3[14]*p[1][14]
                    +p_3[13]*p[1][13]
                    +p_3[12]*p[1][12]
                    +p_3[11]*p[1][11]
                    +p_3[10]*p[1][10]
                    +p_3[9]*p[1][9]);

            p_4[2]=p_3[2]*(
                    p_3[16]*p[2][16]
                    +p_3[15]*p[2][15]
                    +p_3[14]*p[2][14]
                    +p_3[13]*p[2][13]
                    +p_3[12]*p[2][12]
                    +p_3[11]*p[2][11]
                    +p_3[10]*p[2][10]
                    +p_3[9]*p[2][9]);

            p_4[3]=p_3[3]*(
                    p_3[16]*p[3][16]
                    +p_3[15]*p[3][15]
                    +p_3[14]*p[3][14]
                    +p_3[13]*p[3][13]
                    +p_3[12]*p[3][12]
                    +p_3[11]*p[3][11]
                    +p_3[10]*p[3][10]
                    +p_3[9]*p[3][9]);
            p_4[4]=p_3[4]*(
                    p_3[16]*p[4][16]
                    +p_3[15]*p[4][15]
                    +p_3[14]*p[4][14]
                    +p_3[13]*p[4][13]
                    +p_3[12]*p[4][12]
                    +p_3[11]*p[4][11]
                    +p_3[10]*p[4][10]
                    +p_3[9]*p[4][9]);

            p_4[5]=p_3[5]*(
                    p_3[16]*p[5][16]
                    +p_3[15]*p[5][15]
                    +p_3[14]*p[5][14]
                    +p_3[13]*p[5][13]
                    +p_3[12]*p[5][12]
                    +p_3[11]*p[5][11]
                    +p_3[10]*p[5][10]
                    +p_3[9]*p[5][9]);

            p_4[6]=p_3[6]*(
                    p_3[16]*p[6][16]
                    +p_3[15]*p[6][15]
                    +p_3[14]*p[6][14]
                    +p_3[13]*p[6][13]
                    +p_3[12]*p[6][12]
                    +p_3[11]*p[6][11]
                    +p_3[10]*p[6][10]
                    +p_3[9]*p[6][9]);
            p_4[7]=p_3[7]*(
                    p_3[16]*p[7][16]
                    +p_3[15]*p[7][15]
                    +p_3[14]*p[7][14]
                    +p_3[13]*p[7][13]
                    +p_3[12]*p[7][12]
                    +p_3[11]*p[7][11]
                    +p_3[10]*p[7][10]
                    +p_3[9]*p[7][9]);
            p_4[8]=p_3[8]*(
                    p_3[16]*p[8][16]
                    +p_3[15]*p[8][15]
                    +p_3[14]*p[8][14]
                    +p_3[13]*p[8][13]
                    +p_3[12]*p[8][12]
                    +p_3[11]*p[8][11]
                    +p_3[10]*p[8][10]
                    +p_3[9]*p[8][9]);

            p_4[16]=p_3[16]*(
                    p_3[1]*p[16][1]
                    +p_3[2]*p[16][2]
                    +p_3[3]*p[16][3]
                    +p_3[4]*p[16][4]
                    +p_3[5]*p[16][5]
                    +p_3[6]*p[16][6]
                    +p_3[7]*p[16][7]
                    +p_3[8]*p[16][8]);

            p_4[15]=p_3[15]*(
                    p_3[1]*p[15][1]
                    +p_3[2]*p[15][2]
                    +p_3[3]*p[15][3]
                    +p_3[4]*p[15][4]
                    +p_3[5]*p[15][5]
                    +p_3[6]*p[15][6]
                    +p_3[7]*p[15][7]
                    +p_3[8]*p[15][8]);

            p_4[14]=p_3[14]*(
                    p_3[1]*p[14][1]
                    +p_3[2]*p[14][2]
                    +p_3[3]*p[14][3]
                    +p_3[4]*p[14][4]
                    +p_3[5]*p[14][5]
                    +p_3[6]*p[14][6]
                    +p_3[7]*p[14][7]
                    +p_3[8]*p[14][8]);
            p_4[13]=p_3[13]*(
                    p_3[1]*p[13][1]
                    +p_3[2]*p[13][2]
                    +p_3[3]*p[13][3]
                    +p_3[4]*p[13][4]
                    +p_3[5]*p[13][5]
                    +p_3[6]*p[13][6]
                    +p_3[7]*p[13][7]
                    +p_3[8]*p[13][8]);
            p_4[12]=p_3[12]*(
                    p_3[1]*p[12][1]
                    +p_3[2]*p[12][2]
                    +p_3[3]*p[12][3]
                    +p_3[4]*p[12][4]
                    +p_3[5]*p[12][5]
                    +p_3[6]*p[12][6]
                    +p_3[7]*p[12][7]
                    +p_3[8]*p[12][8]);


            p_4[11]=p_3[11]*(
                    p_3[1]*p[11][1]
                    +p_3[2]*p[11][2]
                    +p_3[3]*p[11][3]
                    +p_3[4]*p[11][4]
                    +p_3[5]*p[11][5]
                    +p_3[6]*p[11][6]
                    +p_3[7]*p[11][7]
                    +p_3[8]*p[11][8]);

            p_4[10]=p_3[10]*(
                    p_3[1]*p[10][1]
                    +p_3[2]*p[10][2]
                    +p_3[3]*p[10][3]
                    +p_3[4]*p[10][4]
                    +p_3[5]*p[10][5]
                    +p_3[6]*p[10][6]
                    +p_3[7]*p[10][7]
                    +p_3[8]*p[10][8]);

            p_4[9]=p_3[9]*(
                    p_3[1]*p[9][1]
                    +p_3[2]*p[9][2]
                    +p_3[3]*p[9][3]
                    +p_3[4]*p[9][4]
                    +p_3[5]*p[9][5]
                    +p_3[6]*p[9][6]
                    +p_3[7]*p[9][7]
                    +p_3[8]*p[9][8]);
            for (int i = 1; i <=15 ; i++) {
                System.out.print(p_4[i]+ " ");
            }           
            System.out.println(p_4[16]);
        }
    }
}

5总结

然而，我们一切计算的基础是：

已知两队相遇后，其中一队获胜的概率