由博采公司赔率倒推LPL各队互相获胜概率

最新推荐文章于 2023-02-15 11:22:24 发布

孤竹彧

最新推荐文章于 2023-02-15 11:22:24 发布

阅读量915

点赞数

分类专栏：记录

本文链接：https://blog.csdn.net/qq_33321609/article/details/88974858

版权

记录专栏收录该内容

2 篇文章 0 订阅

订阅专栏

作为一个只玩人机却看比赛的人，最近马上19年lpl春季赛季后赛了，我有点安耐不住，准备算算各队夺冠的概率。
但是各支队伍之间的获胜可能不一致，所以只能瞎写，所以这个不准

但是由此我突然想到，我可以通过赔率来倒推各支队伍的互相的获胜概率啊(倒推博彩机构的概率)
所以我就先查到了去年西方博彩公司给季后赛的概率
Rmap.put(“IG”, 1.83);
Rmap.put(“RNG”, 3.50);
Rmap.put(“RW”, 7.0);
Rmap.put(“EDG”, 17.0);
Rmap.put(“JDG”, 35.0);
Rmap.put(“SN”, 51.0);
Rmap.put(“TOP”, 81.0);
Rmap.put(“FPX”, 151.0);
去年东西部的战绩组成的分组是
leftList.add(“RW”);
leftList.add(“RNG”);
leftList.add(“SN”);
leftList.add(“TOP”);

rightList.add(“IG”);
rightList.add(“EDG”);
rightList.add(“JDG”);
rightList.add(“FPX”);
思路，先计算各队冲出各个分组的概率，在计算夺冠的概率，用计算的概率来和真实的比率进行比较，进行修正，最后得到博彩机构给出的概率
代码示例如下：

package com.guzy.zz.y19mon4.lplGailv;

import java.util.List;
import java.util.Map;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;

/**
 * Filename: Test.java Description: Company: sendinfo.com.cn Inc.
 * 
 * @author: guzhangyan
 * @date: 2019年4月1日 下午3:04:10
 */
/*
 */
public class Test3 {

	static Map<String, Double> map = Maps.newHashMap();
	static List<String> leftList = Lists.newArrayList();
	static List<String> rightList = Lists.newArrayList();

	static Map<String, Double> leftJMap = Maps.newHashMap();
	static Map<String, Double> rightJMap = Maps.newHashMap();
	static Map<String, Double> VMap = Maps.newHashMap();
	static Map<String, Double> Pmap = Maps.newHashMap();
	static Map<String, Double> Rmap = Maps.newHashMap();

	public static void main(String[] args) {
		//赔率的概率和(博采公司的利润)
		double key = 1.0 / 1.83 + 1.0 / 3.50 + 1.0 / 7 + 1.0 / 17 + 1.0 / 35 + 1.0 / 51 + 1.0 / 81 + 1.0 / 151;

		putMap();
		putRMap();
		addList();

		//多次修正
		for (int i = 0; i < 200; i++) {
			addJMap();
			addVMap();
			//将概率放到Pmap中
			for (String name : VMap.keySet()) {
				Pmap.put(name,+ 1 / VMap.get(name) / key);
			}
			changeMap(0.01);
		}
		for (int i = 0; i < 200; i++) {
			addJMap();
			addVMap();
			for (String name : VMap.keySet()) {
				Pmap.put(name,+ 1 / VMap.get(name) / key);
			}
			changeMap(0.001);
		}
		for (int i = 0; i < 200; i++) {
			addJMap();
			addVMap();
			for (String name : VMap.keySet()) {
				Pmap.put(name,+ 1 / VMap.get(name) / key);
			}
			changeMap(0.0001);
		}
		for (int i = 0; i < 200; i++) {
			addJMap();
			addVMap();
			for (String name : VMap.keySet()) {
				Pmap.put(name,+ 1 / VMap.get(name) / key);
			}
			changeMap(0.00001);
		}
		for (int i = 0; i < 200; i++) {
			addJMap();
			addVMap();
			for (String name : VMap.keySet()) {
				Pmap.put(name,+ 1 / VMap.get(name) / key);
			}
			changeMap(0.000001);
		}
		for (int i = 0; i < 200; i++) {
			addJMap();
			addVMap();
			for (String name : VMap.keySet()) {
				Pmap.put(name,+ 1 / VMap.get(name) / key);
			}
			changeMap(0.0000001);
		}
		addJMap();
		addVMap();
		System.out.println();
		//各队进入决赛概率
		for (String name : leftJMap.keySet()) {
			System.out.println(name + leftJMap.get(name));
		}
		for (String name : rightJMap.keySet()) {
			System.out.println(name + rightJMap.get(name));
		}
		System.out.println();
		//各队互相的胜率
		for (String name : map.keySet()) {
			System.out.println(name+map.get(name));
		}
		System.out.println();
		//各队的冠军赔率
		for (String name : VMap.keySet()) {
			System.out.println(name + ":" + 1 / VMap.get(name) / key);
		}
	}

	//比较pmap(按照现有胜率概率计算出的冠军赔率)与Rmap(真实赔率)比较，进行概率的修正
	private static void changeMap(double changeN) {
		for (String name : map.keySet()) {
			String[] names = name.split("-");
			if(Pmap.get(names[0])>Rmap.get(names[0])&&Pmap.get(names[1])<Rmap.get(names[1])&&
					map.get(name)<1-changeN*30) {
				map.put(name, map.get(name)+changeN);
			}
			if(Pmap.get(names[0])<Rmap.get(names[0])&&Pmap.get(names[1])>Rmap.get(names[1])&&
					map.get(name)>changeN*30) {
				map.put(name, map.get(name)-changeN);
			}
		}
		
	}

	//真实赔率
	private static void putRMap() {
		Rmap.put("IG", 1.83);
		Rmap.put("RNG", 3.50);
		Rmap.put("RW", 7.0);
		Rmap.put("EDG", 17.0);
		Rmap.put("JDG", 35.0);
		Rmap.put("SN", 51.0);
		Rmap.put("TOP", 81.0);
		Rmap.put("FPX", 151.0);
	}

	//计算各队获胜概率
	private static void addVMap() {
		for (int i = 0; i <= 3; i++) {
			VMap.put(leftList.get(i), get(leftList.get(i)));
			VMap.put(rightList.get(i), get(rightList.get(i)));
		}

	}

	//计算进入决赛概率
	public static void addJMap() {
		for (int i = 0; i <= 3; i++) {
			leftJMap.put(leftList.get(i), getJ(leftList.get(i)));
			rightJMap.put(rightList.get(i), getJ(rightList.get(i)));
		}

	}

	//左侧队伍的决赛对手只可能是右侧
	public static double get(String name) {
		double lv = 0;
		if (leftJMap.containsKey(name)) {
			for (String rightName : rightJMap.keySet()) {
				lv += map.get(name + "-" + rightName) * rightJMap.get(rightName);
			}
			return lv * leftJMap.get(name);
		}
		if (rightJMap.containsKey(name)) {
			for (String leftName : leftJMap.keySet()) {
				lv += (1 - map.get(leftName + "-" + name)) * leftJMap.get(leftName);
			}
			return lv * rightJMap.get(name);
		}
		return lv;
	}

	//因为冒泡赛机制，不同队伍队伍进去的概率计算方式不一致
	public static double getJ(String name) {
		if (leftList.contains(name)) {
			if (leftList.indexOf(name) == 3) {
				return getGai(leftList.get(3), leftList.get(2)) * getGai(leftList.get(3), leftList.get(1))
						* getGai(leftList.get(3), leftList.get(0));
			}
		}
		if (leftList.contains(name)) {
			if (leftList.indexOf(name) == 2) {
				return getGai(leftList.get(2), leftList.get(3)) * getGai(leftList.get(2), leftList.get(1))
						* getGai(leftList.get(2), leftList.get(0));
			}
		}
		if (leftList.contains(name)) {
			if (leftList.indexOf(name) == 1) {
				return (1 - getGai(leftList.get(3), leftList.get(2)) * getGai(leftList.get(3), leftList.get(1))
						- getGai(leftList.get(2), leftList.get(3)) * getGai(leftList.get(2), leftList.get(1)))
						* getGai(leftList.get(1), leftList.get(0));
			}
		}
		if (leftList.contains(name)) {
			if (leftList.indexOf(name) == 0) {
				return 1 - getJ(leftList.get(3)) - getJ(leftList.get(2)) - getJ(leftList.get(1));
			}
		}

		if (rightList.contains(name)) {
			if (rightList.indexOf(name) == 3) {
				return getGai(rightList.get(3), rightList.get(2)) * getGai(rightList.get(3), rightList.get(1))
						* getGai(rightList.get(3), rightList.get(0));
			}
		}
		if (rightList.contains(name)) {
			if (rightList.indexOf(name) == 2) {
				return getGai(rightList.get(2), rightList.get(3)) * getGai(rightList.get(2), rightList.get(1))
						* getGai(rightList.get(2), rightList.get(0));
			}
		}
		if (rightList.contains(name)) {
			if (rightList.indexOf(name) == 1) {
				return (1 - getGai(rightList.get(3), rightList.get(2)) * getGai(rightList.get(3), rightList.get(1))
						- getGai(rightList.get(2), rightList.get(3)) * getGai(rightList.get(2), rightList.get(1)))
						* getGai(rightList.get(1), rightList.get(0));
			}
		}
		if (rightList.contains(name)) {
			if (rightList.indexOf(name) == 0) {
				return 1 - getJ(rightList.get(3)) - getJ(rightList.get(2)) - getJ(rightList.get(1));
			}
		}

		return 0;
	}

	private static double getGai(String name, String otherName) {
		if (map.containsKey(name + "-" + otherName)) {
			return map.get(name + "-" + otherName);
		}
		return 1 - map.get(otherName + "-" + name);
	}

	//排位顺序
	public static void addList() {
		leftList.add("RW");
		leftList.add("RNG");
		leftList.add("SN");
		leftList.add("TOP");

		rightList.add("IG");
		rightList.add("EDG");
		rightList.add("JDG");
		rightList.add("FPX");

	}

	//各支队伍的初始获胜概率(左胜)
	public static void putMap() {
		map.put("TOP-SN", 0.4);
		map.put("TOP-RNG", 0.3);
		map.put("TOP-RW", 0.3);
		map.put("TOP-IG", 0.2);
		map.put("TOP-EDG", 0.3);
		map.put("TOP-JDG", 0.5);
		map.put("TOP-FPX", 0.35);

		map.put("SN-RNG", 0.4);
		map.put("SN-RW", 0.4);
		map.put("SN-IG", 0.25);
		map.put("SN-EDG", 0.4);
		map.put("SN-JDG", 0.6);
		map.put("SN-FPX", 0.5);

		map.put("RNG-RW", 0.45);
		map.put("RNG-IG", 0.3);
		map.put("RNG-EDG", 0.4);
		map.put("RNG-JDG", 0.6);
		map.put("RNG-FPX", 0.6);

		map.put("RW-IG", 0.4);
		map.put("RW-EDG", 0.5);
		map.put("RW-JDG", 0.7);
		map.put("RW-FPX", 0.5);

		map.put("IG-EDG", 0.7);
		map.put("IG-JDG", 0.8);
		map.put("IG-FPX", 0.7);

		map.put("EDG-JDG", 0.6);
		map.put("EDG-FPX", 0.5);

		map.put("JDG-FPX", 0.4);
	}

}

结果如下：

TOP0.04360315535059255
RW0.35844071831011826
RNG0.5394882006790938
SN0.05846792566019538
EDG0.14571409305083202
JDG0.07702546313442381
IG0.7531656880497453
FPX0.024094755764998886

SN-RW0.40253760000000016
TOP-RW0.35630920000000016
RW-JDG0.5797659999999998
RW-FPX0.6266381000000002
RW-EDG0.5176445000000003
RW-IG0.30114259999999976
IG-FPX0.8254954999999996
RNG-EDG0.7542707000000003
IG-JDG0.7786233999999994
SN-EDG0.42018210000000017
IG-EDG0.7165018999999997
SN-JDG0.4823036
SN-RNG0.26591139999999985
JDG-FPX0.6468721000000004
RNG-FPX0.8632643
RNG-JDG0.7563921999999997
EDG-FPX0.6089935999999999
EDG-JDG0.46212149999999985
SN-FPX0.6291757000000002
RNG-RW0.7366261999999999
TOP-FPX0.5329473000000001
TOP-JDG0.43607520000000005
TOP-IG0.20745180000000002
TOP-RNG0.2696829999999999
SN-IG0.25368019999999997
TOP-SN0.45377160000000005
TOP-EDG0.37395370000000017
RNG-IG0.3877688000000001

TOP:80.99997831970843
RW:6.9999984090185485
EDG:16.999989856530835
RNG:3.500000152489087
SN:50.999982034484496
JDG:35.00000805701675
IG:1.8300002064493592
FPX:150.99993403612348

可以看到，计算出来的冠军赔率和给出的赔率基本一致
所以可以看出来,18年夏季赛季后赛西方还是很看好IG的，就算对上RNG，RNG也只有38.8%不到的胜率
各队直接的差距最大的属RNG-FPX,RNG获胜概率高于86.3%

孤竹彧

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
由博采公司赔率倒推LPL各队互相获胜概率

作为一个只玩人机却看比赛的人，最近马上19年lpl春季赛季后赛了，我有点安耐不住，准备算算各队夺冠的概率。但是各支队伍之间的获胜可能不一致，所以只能瞎写，所以这个不准package com.guzy.zz.y19mon4.lplGailv;import java.util.List;import java.util.Map;import com.google.common.colle...
复制链接

扫一扫