可以帮忙解决这个概率dp吗

骑猪大侠 2019-09-23 08:04:49
链接：https://ac.nowcoder.com/acm/problem/21626
来源：牛客网

牛牛 和 牛妹 正在玩一个游戏

牛牛扔了a个b面的骰子

牛妹扔了c个d面的骰子

对于一个x面的骰子，每个面依次会写有1到x的数

一个玩家的得分就是每个骰子朝上的面的数字的总和，一个玩家能赢另一个玩家当且仅当得分严格大于另一个玩家，给你a,b,c,d,如果牛牛不可能赢，输出-1

否则假设你知道了牛牛赢了，但是不知道牛牛和牛妹的具体分数，返回牛牛的期望得分

input:输入一行，包含4个整数a,b,c,d (1 ≤ a,b,c,d ≤ 50)

output:输出一个浮点数，误差在1e-3以内

样例1: 1 2 1 5
输出 2.0
样例2: 3 1 1 3
输出 3.0
具体的可以进上面的网站
...全文
119 14 打赏 收藏 转发到动态 举报
写回复
用AI写文章
14 条回复
切换为时间正序
请发表友善的回复…
发表回复
骑猪大侠 2019-09-25
  • 打赏
  • 举报
 回复
引用 13 楼 你可以永远相信他 的回复:
[quote=引用 12 楼 Italink 的回复:] [quote=引用 10 楼 你可以永远相信他的回复:][quote=引用 9 楼 Italink 的回复:] 写了一个没格式化输出，且只能通过小数据的代码，看能不能提供一点什么思路 

#include <iostream>
#include <string>
#include <vector>
using namespace std;
vector<int> creat(const int& n) {
	vector<int> vc(n);
	for (int i = 0; i < n; i++)
		vc[i] = i + 1;
	return vc;
}
vector<int> getAllPossible(vector<int> vc,const int& num, const int &side) {
	for (int i = 1; i < num; ++i) {
		vector<int> t(vc.size() * side);
		for (int j = 0; j < vc.size(); ++j) 
			for (int k = 0; k < side; ++k) 
				t[j * side + k] = vc[j] + k + 1;
		vc = t;
	}
	return vc;
}
int main() {
	int a, b, c, d;
	cin >> a >> b >> c >> d;
	vector<int> boy = creat(b), girl = creat(d);
	pair<int, int> result{0,0};
	auto k = getAllPossible(boy, a, b);
	for (int& i : getAllPossible(boy, a, b)) {
		for (int& j : getAllPossible(girl, c, d)) {
			if (i > j) {
				result.first+=i;
				++result.second;
			}
		}
	}
	printf("%lf", result.first / (double)result.second);
	return 0;
}
可以说说你的思路吗，你的好像是对的，只是题目必
引用 1 楼 Italink 的回复:
写了一个没格式化输出，且只能通过小数据的代码，看能不能提供一点什么思路 

#include <iostream>
#include <string>
#include <vector>
using namespace std;
vector<int> creat(const int& n) {
	vector<int> vc(n);
	for (int i = 0; i < n; i++)
		vc[i] = i + 1;
	return vc;
}
vector<int> getAllPossible(vector<int> vc,const int& num, const int &side) {
	for (int i = 1; i < num; ++i) {
		vector<int> t(vc.size() * side);
		for (int j = 0; j < vc.size(); ++j) 
			for (int k = 0; k < side; ++k) 
				t[j * side + k] = vc[j] + k + 1;
		vc = t;
	}
	return vc;
}
int main() {
	int a, b, c, d;
	cin >> a >> b >> c >> d;
	vector<int> boy = creat(b), girl = creat(d);
	pair<int, int> result{0,0};
	auto k = getAllPossible(boy, a, b);
	for (int& i : getAllPossible(boy, a, b)) {
		for (int& j : getAllPossible(girl, c, d)) {
			if (i > j) {
				result.first+=i;
				++result.second;
			}
		}
	}
	printf("%lf", result.first / (double)result.second);
	return 0;
}
可以讲讲你的思路吗．我运行了一下，前面的数据都过了，就是后面数据范围都扩大后，内存超限了[/quote] 不好意思，今天才看到，因为50的50次方已经很大了，所以才会超限，我是通过排列组合，得到2个数组，分别是两人的得分所有情况，然后通过两种for，对比得到牛牛胜利的情况，最后计算期望[/quote]我已经根据你的思路写出来了，[/quote]我用的ｄｐ做的，把牛牛能赢的情况的总分算出来，再除牛牛能赢的总情况有多少种就可以了
骑猪大侠 2019-09-25
  • 打赏
  • 举报
 回复
引用 12 楼 Italink 的回复:
[quote=引用 10 楼 你可以永远相信他的回复:][quote=引用 9 楼 Italink 的回复:] 写了一个没格式化输出，且只能通过小数据的代码，看能不能提供一点什么思路 

#include <iostream>
#include <string>
#include <vector>
using namespace std;
vector<int> creat(const int& n) {
	vector<int> vc(n);
	for (int i = 0; i < n; i++)
		vc[i] = i + 1;
	return vc;
}
vector<int> getAllPossible(vector<int> vc,const int& num, const int &side) {
	for (int i = 1; i < num; ++i) {
		vector<int> t(vc.size() * side);
		for (int j = 0; j < vc.size(); ++j) 
			for (int k = 0; k < side; ++k) 
				t[j * side + k] = vc[j] + k + 1;
		vc = t;
	}
	return vc;
}
int main() {
	int a, b, c, d;
	cin >> a >> b >> c >> d;
	vector<int> boy = creat(b), girl = creat(d);
	pair<int, int> result{0,0};
	auto k = getAllPossible(boy, a, b);
	for (int& i : getAllPossible(boy, a, b)) {
		for (int& j : getAllPossible(girl, c, d)) {
			if (i > j) {
				result.first+=i;
				++result.second;
			}
		}
	}
	printf("%lf", result.first / (double)result.second);
	return 0;
}
可以说说你的思路吗，你的好像是对的，只是题目必
引用 1 楼 Italink 的回复:
写了一个没格式化输出，且只能通过小数据的代码，看能不能提供一点什么思路 

#include <iostream>
#include <string>
#include <vector>
using namespace std;
vector<int> creat(const int& n) {
	vector<int> vc(n);
	for (int i = 0; i < n; i++)
		vc[i] = i + 1;
	return vc;
}
vector<int> getAllPossible(vector<int> vc,const int& num, const int &side) {
	for (int i = 1; i < num; ++i) {
		vector<int> t(vc.size() * side);
		for (int j = 0; j < vc.size(); ++j) 
			for (int k = 0; k < side; ++k) 
				t[j * side + k] = vc[j] + k + 1;
		vc = t;
	}
	return vc;
}
int main() {
	int a, b, c, d;
	cin >> a >> b >> c >> d;
	vector<int> boy = creat(b), girl = creat(d);
	pair<int, int> result{0,0};
	auto k = getAllPossible(boy, a, b);
	for (int& i : getAllPossible(boy, a, b)) {
		for (int& j : getAllPossible(girl, c, d)) {
			if (i > j) {
				result.first+=i;
				++result.second;
			}
		}
	}
	printf("%lf", result.first / (double)result.second);
	return 0;
}
可以讲讲你的思路吗．我运行了一下，前面的数据都过了，就是后面数据范围都扩大后，内存超限了[/quote] 不好意思，今天才看到，因为50的50次方已经很大了，所以才会超限，我是通过排列组合，得到2个数组，分别是两人的得分所有情况，然后通过两种for，对比得到牛牛胜利的情况，最后计算期望[/quote]我已经根据你的思路写出来了，
Italink 2019-09-25
  • 打赏
  • 举报
 回复
引用 10 楼 你可以永远相信他的回复:
[quote=引用 9 楼 Italink 的回复:] 写了一个没格式化输出，且只能通过小数据的代码，看能不能提供一点什么思路 

#include <iostream>
#include <string>
#include <vector>
using namespace std;
vector<int> creat(const int& n) {
	vector<int> vc(n);
	for (int i = 0; i < n; i++)
		vc[i] = i + 1;
	return vc;
}
vector<int> getAllPossible(vector<int> vc,const int& num, const int &side) {
	for (int i = 1; i < num; ++i) {
		vector<int> t(vc.size() * side);
		for (int j = 0; j < vc.size(); ++j) 
			for (int k = 0; k < side; ++k) 
				t[j * side + k] = vc[j] + k + 1;
		vc = t;
	}
	return vc;
}
int main() {
	int a, b, c, d;
	cin >> a >> b >> c >> d;
	vector<int> boy = creat(b), girl = creat(d);
	pair<int, int> result{0,0};
	auto k = getAllPossible(boy, a, b);
	for (int& i : getAllPossible(boy, a, b)) {
		for (int& j : getAllPossible(girl, c, d)) {
			if (i > j) {
				result.first+=i;
				++result.second;
			}
		}
	}
	printf("%lf", result.first / (double)result.second);
	return 0;
}
可以说说你的思路吗，你的好像是对的，只是题目必
引用 1 楼 Italink 的回复:
写了一个没格式化输出，且只能通过小数据的代码，看能不能提供一点什么思路 

#include <iostream>
#include <string>
#include <vector>
using namespace std;
vector<int> creat(const int& n) {
	vector<int> vc(n);
	for (int i = 0; i < n; i++)
		vc[i] = i + 1;
	return vc;
}
vector<int> getAllPossible(vector<int> vc,const int& num, const int &side) {
	for (int i = 1; i < num; ++i) {
		vector<int> t(vc.size() * side);
		for (int j = 0; j < vc.size(); ++j) 
			for (int k = 0; k < side; ++k) 
				t[j * side + k] = vc[j] + k + 1;
		vc = t;
	}
	return vc;
}
int main() {
	int a, b, c, d;
	cin >> a >> b >> c >> d;
	vector<int> boy = creat(b), girl = creat(d);
	pair<int, int> result{0,0};
	auto k = getAllPossible(boy, a, b);
	for (int& i : getAllPossible(boy, a, b)) {
		for (int& j : getAllPossible(girl, c, d)) {
			if (i > j) {
				result.first+=i;
				++result.second;
			}
		}
	}
	printf("%lf", result.first / (double)result.second);
	return 0;
}
可以讲讲你的思路吗．我运行了一下，前面的数据都过了，就是后面数据范围都扩大后，内存超限了[/quote] 不好意思，今天才看到，因为50的50次方已经很大了，所以才会超限，我是通过排列组合，得到2个数组，分别是两人的得分所有情况，然后通过两种for，对比得到牛牛胜利的情况，最后计算期望
骑猪大侠 2019-09-25
  • 打赏
  • 举报
 回复
引用 9 楼 Italink 的回复:
写了一个没格式化输出，且只能通过小数据的代码，看能不能提供一点什么思路 

#include <iostream>
#include <string>
#include <vector>
using namespace std;
vector<int> creat(const int& n) {
	vector<int> vc(n);
	for (int i = 0; i < n; i++)
		vc[i] = i + 1;
	return vc;
}
vector<int> getAllPossible(vector<int> vc,const int& num, const int &side) {
	for (int i = 1; i < num; ++i) {
		vector<int> t(vc.size() * side);
		for (int j = 0; j < vc.size(); ++j) 
			for (int k = 0; k < side; ++k) 
				t[j * side + k] = vc[j] + k + 1;
		vc = t;
	}
	return vc;
}
int main() {
	int a, b, c, d;
	cin >> a >> b >> c >> d;
	vector<int> boy = creat(b), girl = creat(d);
	pair<int, int> result{0,0};
	auto k = getAllPossible(boy, a, b);
	for (int& i : getAllPossible(boy, a, b)) {
		for (int& j : getAllPossible(girl, c, d)) {
			if (i > j) {
				result.first+=i;
				++result.second;
			}
		}
	}
	printf("%lf", result.first / (double)result.second);
	return 0;
}
大佬思路是正确的
骑猪大侠 2019-09-24
  • 打赏
  • 举报
 回复
引用 9 楼 Italink 的回复:
写了一个没格式化输出，且只能通过小数据的代码，看能不能提供一点什么思路 

#include <iostream>
#include <string>
#include <vector>
using namespace std;
vector<int> creat(const int& n) {
	vector<int> vc(n);
	for (int i = 0; i < n; i++)
		vc[i] = i + 1;
	return vc;
}
vector<int> getAllPossible(vector<int> vc,const int& num, const int &side) {
	for (int i = 1; i < num; ++i) {
		vector<int> t(vc.size() * side);
		for (int j = 0; j < vc.size(); ++j) 
			for (int k = 0; k < side; ++k) 
				t[j * side + k] = vc[j] + k + 1;
		vc = t;
	}
	return vc;
}
int main() {
	int a, b, c, d;
	cin >> a >> b >> c >> d;
	vector<int> boy = creat(b), girl = creat(d);
	pair<int, int> result{0,0};
	auto k = getAllPossible(boy, a, b);
	for (int& i : getAllPossible(boy, a, b)) {
		for (int& j : getAllPossible(girl, c, d)) {
			if (i > j) {
				result.first+=i;
				++result.second;
			}
		}
	}
	printf("%lf", result.first / (double)result.second);
	return 0;
}
可以说说你的思路吗，你的好像是对的，只是题目必
引用 1 楼 Italink 的回复:
写了一个没格式化输出，且只能通过小数据的代码，看能不能提供一点什么思路 

#include <iostream>
#include <string>
#include <vector>
using namespace std;
vector<int> creat(const int& n) {
	vector<int> vc(n);
	for (int i = 0; i < n; i++)
		vc[i] = i + 1;
	return vc;
}
vector<int> getAllPossible(vector<int> vc,const int& num, const int &side) {
	for (int i = 1; i < num; ++i) {
		vector<int> t(vc.size() * side);
		for (int j = 0; j < vc.size(); ++j) 
			for (int k = 0; k < side; ++k) 
				t[j * side + k] = vc[j] + k + 1;
		vc = t;
	}
	return vc;
}
int main() {
	int a, b, c, d;
	cin >> a >> b >> c >> d;
	vector<int> boy = creat(b), girl = creat(d);
	pair<int, int> result{0,0};
	auto k = getAllPossible(boy, a, b);
	for (int& i : getAllPossible(boy, a, b)) {
		for (int& j : getAllPossible(girl, c, d)) {
			if (i > j) {
				result.first+=i;
				++result.second;
			}
		}
	}
	printf("%lf", result.first / (double)result.second);
	return 0;
}
可以讲讲你的思路吗．我运行了一下，前面的数据都过了，就是后面数据范围都扩大后，内存超限了
Italink 2019-09-23
  • 打赏
  • 举报
 回复
写了一个没格式化输出，且只能通过小数据的代码，看能不能提供一点什么思路



#include <iostream>

#include <string>

#include <vector>

using namespace std;

vector<int> creat(const int& n) {

	vector<int> vc(n);

	for (int i = 0; i < n; i++)

		vc[i] = i + 1;

	return vc;

}

vector<int> getAllPossible(vector<int> vc,const int& num, const int &side) {

	for (int i = 1; i < num; ++i) {

		vector<int> t(vc.size() * side);

		for (int j = 0; j < vc.size(); ++j) 

			for (int k = 0; k < side; ++k) 

				t[j * side + k] = vc[j] + k + 1;

		vc = t;

	}

	return vc;

}

int main() {

	int a, b, c, d;

	cin >> a >> b >> c >> d;

	vector<int> boy = creat(b), girl = creat(d);

	pair<int, int> result{0,0};

	auto k = getAllPossible(boy, a, b);

	for (int& i : getAllPossible(boy, a, b)) {

		for (int& j : getAllPossible(girl, c, d)) {

			if (i > j) {

				result.first+=i;

				++result.second;

			}

		}

	}

	printf("%lf", result.first / (double)result.second);

	return 0;

}
wowpH 2019-09-23
  • 打赏
  • 举报
 回复
引用 7 楼 你可以永远相信他 的回复:
引用 6 楼 wowpH 的回复:
引用 5 楼 wowpH 的回复:
那什么是期望分啊，我晕了。
刚注册了账号，看了全题。。。他有5组数据，你就贴了2组。。。还是最没用的两组。。。我现在懂期望的意思了。
好难，不会做。。。
骑猪大侠 2019-09-23
  • 打赏
  • 举报
 回复
引用 6 楼 wowpH 的回复:
引用 5 楼 wowpH 的回复:
那什么是期望分啊，我晕了。
刚注册了账号，看了全题。。。他有5组数据，你就贴了2组。。。还是最没用的两组。。。我现在懂期望的意思了。
wowpH 2019-09-23
  • 打赏
  • 举报
 回复
引用 5 楼 wowpH 的回复:
那什么是期望分啊，我晕了。
刚注册了账号，看了全题。。。他有5组数据，你就贴了2组。。。还是最没用的两组。。。我现在懂期望的意思了。
wowpH 2019-09-23
  • 打赏
  • 举报
 回复
引用 4 楼 你可以永远相信他 的回复:
题目想让你求得分的期望
那什么是期望分啊，我晕了。
骑猪大侠 2019-09-23
  • 打赏
  • 举报
 回复
引用 3 楼 wowpH 的回复:
[quote=引用 2 楼 你可以永远相信他 的回复:] [quote=引用 1 楼 wowpH 的回复:] 牛牛的最大值和牛妹的最小值比较就行了吧。 还是我理解有误？
还要算期望得分啊ｅｍｍ[/quote]期望分难道不是越大越好？谁不期望自己得分高。而且从这两组数据来看，2.0 和 3.0 是最高分。[/quote]题目想让你求得分的期望
wowpH 2019-09-23
  • 打赏
  • 举报
 回复
引用 2 楼 你可以永远相信他 的回复:
[quote=引用 1 楼 wowpH 的回复:] 牛牛的最大值和牛妹的最小值比较就行了吧。 还是我理解有误？
还要算期望得分啊ｅｍｍ[/quote]期望分难道不是越大越好？谁不期望自己得分高。而且从这两组数据来看，2.0 和 3.0 是最高分。
骑猪大侠 2019-09-23
  • 打赏
  • 举报
 回复
引用 1 楼 wowpH 的回复:
牛牛的最大值和牛妹的最小值比较就行了吧。 还是我理解有误？
还要算期望得分啊ｅｍｍ
wowpH 2019-09-23
  • 打赏
  • 举报
 回复
牛牛的最大值和牛妹的最小值比较就行了吧。 还是我理解有误？
算法之动态规划总结（11种DP类型，70道全部搞懂）
简介 参考文章，将所有的DP问题分成11大类，本文将这些题目的解法进行探讨。所有题目均来自leetcode。 题目 1、线性 DP 最经典单串： 最长上升子序列 最经典双串： 最长公共子序列 经典问题： 三角形最小路径和 最大子序和 乘积最大子数组 鸡蛋掉落（DP+二分） 俄罗斯套娃信封问题 打家劫舍系列: (打家劫舍3 是树形DP) 打家劫舍 打家劫舍 II 股票系列: 买卖股票的最佳时机 买卖股票的最佳时机 II 买卖股票的最佳时机 III 买卖股票的最佳时机 IV
设计模式（Design Pattern,DP）
文章目录设计模式的产生背景1、 设计模式的六大设计原则1.1 开闭原则：Open Closed Principle，OCP1.1.1 开闭原则的定义1.1.2 开闭原则的作用1.2 单一职责原则：Single responsibility principle，SRP1.2 .2 单一职责原则的优点1.3 里氏替换原则：Liskov Substitution Principle，LSP1.3.1 里氏替换原则的定义1.3.2 里氏替换原则的作用 设计模式的产生背景 “设计模式”这个术语最初并不是出现在软件设计
（6）Determistic Policy Gradient (DPG)
DDPG用到的DPG
『概率DP』守卫者的挑战
题目描述 打开了黑魔法师Vani的大门，队员们在迷宫般的路上漫无目的地搜寻着关押applepi的监狱的所在地。突然，眼前一道亮光闪过。“我，Nizem，是黑魔法圣殿的守卫者。如果你能通过我的挑战，那么你可以带走黑魔法圣殿的地图……”瞬间，队员们被传送到了一个擂台上，最初身边有一个容量为K的包包。 擂台赛一共有N项挑战，各项挑战依次进行。第i项挑战有一个属性ai，如果ai>=0，表示这次挑战成...
LeetCode DP基础
线性DP 序列DP 计数DP 路径DP 组合DP lc.509 lc.70 lc.746 lc.53 lc.198 lc.213 lc.256 lc.265 lc.121 lc.714 lc.309 lc.152 lc.485 lc.487 lc.1004 lc.376 lc.1746 lc.1230 lc.1143 lc.1035 lc.712 lc.300 lc.673 lc.354 lc.368 lc.446 lc.740 lc.978 lc.1035 lc.1143 lc.1473 ···
C++ 语言

64,690

社区成员

250,497

社区内容

发帖
与我相关
我的任务
社区描述
C++ 语言相关问题讨论，技术干货分享，前沿动态等
c++ 技术论坛（原bbs）
社区管理员
  • C++ 语言社区
  • encoderlee
  • paschen
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
  1. 请不要发布与C++技术无关的贴子
  2. 请不要发布与技术无关的招聘、广告的帖子
  3. 请尽可能的描述清楚你的问题，如果涉及到代码请尽可能的格式化一下

试试用AI创作助手写篇文章吧

+ 用AI写文章