提前预测世界杯冠军

作者: 新手村的0级玩家 | 来源:发表于2018-06-15 15:39 被阅读57次
    淘汰赛阶段的对阵安排

    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总结

    然而,我们一切计算的基础是:

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

    相关文章

      网友评论

        本文标题:提前预测世界杯冠军

        本文链接:https://www.haomeiwen.com/subject/mefmeftx.html