【博弈论】P8144 [JRKSJ R4] BBWWBB|普及+

闻缺陷则喜何志丹2026-03-20 13:39

本文涉及知识点

博弈论

P8144 [JRKSJ R4] BBWWBB

题目描述

数轴上有 6 6 6 个棋子。初始，第 i i i 个棋子摆在 a i a_i ai， a a a 单调递增。

其中第 1 , 2 , 5 , 6 1,2,5,6 1,2,5,6 个棋子是黑色的，第 3 , 4 3,4 3,4 个棋子是白色的。

游戏过程中，同一个位置上可以同时存在任意个同样颜色的棋子。

有两方：黑方和白方。两方轮流进行操作：

  • 选择己方颜色的棋子，向左或向右移动一步。
  • 若准备移动到的位置上存在另一方的棋子且仅存在 1 1 1 个，那么可以移动同时将该棋子移除。
  • 若准备移动到的位置上存在多个另一方的棋子，那么不可以移动到这个位置。
  • 当一方不存在可以移动的棋子，该方被判输，游戏结束。

两方的目标都是在己方不输的前提下，尽可能的令对方输。两方均采取最优策略。

给定一方作为先手和每个棋子的位置，请判断，游戏是否会无限进行下去。

输入格式

本题多组数据。

第一行一个整数 T T T 表示数据组数。

下面 T T T 行，每行一组数据。

每组数据首先一个字符 c c c，为 B \texttt B B 或者 W \texttt W W。 c = B c=\texttt B c=B 表示黑方先手， c = W c=\texttt W c=W 表示白方先手。然后 6 6 6 个整数表示 a 1 ... 6 a_{1\dots 6} a1...6。

输出格式

对于每组询问，每行回答一个 Yes 或 No。Yes 表示游戏会无限进行下去，No 反之。

输入输出样例 #1

输入 #1

复制代码 
2
B 1 3 4 6 8 9
W 1 3 4 6 8 9

输出 #1

复制代码 
No
Yes

说明/提示

数据规模

对于 15 % 15\% 15% 的数据， c = B c=\texttt B c=B。

对于 100 % 100\% 100% 的数据， T ≤ 10 5 T\le10^5 T≤105， ∣ a i ∣ ≤ 10 9 |a_i| \le 10^9 ∣ai∣≤109， c ∈ { B , W } c\in\{\texttt B,\texttt W\} c∈{B,W}。保证 a a a 单调递增。

样例解释

对于第 1 1 1 组数据，其中一种局面变化如下：

cpp 复制代码 
B:
1 4 6 8 9
B B W B B
W:
1 4 5 8 9
B B W B B
B:
1 5 8 9
B B B B

对于第 2 2 2 组数据，其中一种局面变化如下：

cpp 复制代码 
W:
1 3 6 8 9
B W W B B
B:
1 3 6 8 8
B W W B B
W:
1 3 5 8 8
B W W B B
B:
1 3 5 7 8
B W W B B
W:
1 3 4 7 8
B W W B B
B:
1 3 4 7 7
B W W B B
W:
1 3 3 7 7
B W W B B
B:
1 3 3 6 7
B W W B B
W:
1 2 3 6 7
B W W B B
B:
2 3 6 7
B W B B
W:
2 6 7
W B B

此后白方每一步均控制 W 往左边走一步。无论黑方如何操作，游戏均可以无限进行下去。

博弈论

性质一 ：由于吃子的的方式一样，所以无法主动吃子。只能初始吃子或对方送子。
结论一 ：白棋赢不了。初始白棋无法吃第一个和第六个棋子，第一个棋子可以不断向左，不会送子。
性质二 ：就算白棋先手，也无法同时吃掉第二个和第五个棋子，如果初始能吃2个棋子。第二回合，黑棋会吃白棋棋子。
错误结论二 ：白棋必败。黑棋有两个和白棋左右相邻，令为b、c，另外一个和白棋不相邻，令为d。如果b和c和白棋的距离为1，则吃子。都为2，则移动d；否则向白棋方向移动。最终白棋无子可走。
性质三 ：兑子。某黑棋在x，两个白棋在x+2堆叠在一起。然后一枚白棋移到x+1。如果黑棋吃x+1的子，则x+2吃回来；如果白棋不动，则吃掉；如果白棋后退，将x+2的棋子叠到x+1。如果兑子成功，则逃出牢笼；如果对方退让，可以无限追兑。

游戏可以无限的唯一可能就是：白棋吃一个棋子，然后兑一个棋子。条件一：先手。条件二：有且只有一枚棋子相邻,且相邻的黑旗不和令一枚黑旗相邻。

代码

核心代码

cpp 复制代码 
#include <iostream>
#include <sstream>
#include <vector>
#include<map>
#include<unordered_map>
#include<set>
#include<unordered_set>
#include<string>
#include<algorithm>
#include<functional>
#include<queue>
#include <stack>
#include<iomanip>
#include<numeric>
#include <math.h>
#include <climits>
#include<assert.h>
#include<cstring>
#include<list>
#include<array>

#include <bitset>
using namespace std;

template<class T1, class T2>
std::istream& operator >> (std::istream& in, pair<T1, T2>& pr) {
	in >> pr.first >> pr.second;
	return in;
}

template<class T1, class T2, class T3 >
std::istream& operator >> (std::istream& in, tuple<T1, T2, T3>& t) {
	in >> get<0>(t) >> get<1>(t) >> get<2>(t);
	return in;
}

template<class T1, class T2, class T3, class T4 >
std::istream& operator >> (std::istream& in, tuple<T1, T2, T3, T4>& t) {
	in >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t);
	return in;
}

template<class T = int>
vector<T> Read() {
	int n;
	cin >> n;
	vector<T> ret(n);
	for (int i = 0; i < n; i++) {
		cin >> ret[i];
	}
	return ret;
}
template<class T = int>
vector<T> ReadNotNum() {
	vector<T> ret;
	T tmp;
	while (cin >> tmp) {
		ret.emplace_back(tmp);
		if ('\n' == cin.get()) { break; }
	}
	return ret;
}

template<class T = int>
vector<T> Read(int n) {
	vector<T> ret(n);
	for (int i = 0; i < n; i++) {
		cin >> ret[i];
	}
	return ret;
}

template<int N = 1'000'000>
class COutBuff
{
public:
	COutBuff() {
		m_p = puffer;
	}
	template<class T>
	void write(T x) {
		int num[28], sp = 0;
		if (x < 0)
			*m_p++ = '-', x = -x;

		if (!x)
			*m_p++ = 48;

		while (x)
			num[++sp] = x % 10, x /= 10;

		while (sp)
			*m_p++ = num[sp--] + 48;
		AuotToFile();
	}
	void writestr(const char* sz) {
		strcpy(m_p, sz);
		m_p += strlen(sz);
		AuotToFile();
	}
	inline void write(char ch)
	{
		*m_p++ = ch;
		AuotToFile();
	}
	inline void ToFile() {
		fwrite(puffer, 1, m_p - puffer, stdout);
		m_p = puffer;
	}
	~COutBuff() {
		ToFile();
	}
private:
	inline void AuotToFile() {
		if (m_p - puffer > N - 100) {
			ToFile();
		}
	}
	char  puffer[N], * m_p;
};

template<int N = 1'000'000>
class CInBuff
{
public:
	inline CInBuff() {}
	inline CInBuff<N>& operator>>(char& ch) {
		FileToBuf();
		while (('\r' == *S) || ('\n' == *S) || (' ' == *S)) { S++; }//忽略空格和回车
		ch = *S++;
		return *this;
	}
	inline CInBuff<N>& operator>>(int& val) {
		FileToBuf();
		int x(0), f(0);
		while (!isdigit(*S))
			f |= (*S++ == '-');
		while (isdigit(*S))
			x = (x << 1) + (x << 3) + (*S++ ^ 48);
		val = f ? -x : x; S++;//忽略空格换行		
		return *this;
	}
	inline CInBuff& operator>>(long long& val) {
		FileToBuf();
		long long x(0); int f(0);
		while (!isdigit(*S))
			f |= (*S++ == '-');
		while (isdigit(*S))
			x = (x << 1) + (x << 3) + (*S++ ^ 48);
		val = f ? -x : x; S++;//忽略空格换行
		return *this;
	}
	template<class T1, class T2>
	inline CInBuff& operator>>(pair<T1, T2>& val) {
		*this >> val.first >> val.second;
		return *this;
	}
	template<class T1, class T2, class T3>
	inline CInBuff& operator>>(tuple<T1, T2, T3>& val) {
		*this >> get<0>(val) >> get<1>(val) >> get<2>(val);
		return *this;
	}
	template<class T1, class T2, class T3, class T4>
	inline CInBuff& operator>>(tuple<T1, T2, T3, T4>& val) {
		*this >> get<0>(val) >> get<1>(val) >> get<2>(val) >> get<3>(val);
		return *this;
	}
	template<class T = int>
	inline CInBuff& operator>>(vector<T>& val) {
		int n;
		*this >> n;
		val.resize(n);
		for (int i = 0; i < n; i++) {
			*this >> val[i];
		}
		return *this;
	}
	template<class T = int>
	vector<T> Read(int n) {
		vector<T> ret(n);
		for (int i = 0; i < n; i++) {
			*this >> ret[i];
		}
		return ret;
	}
	template<class T = int>
	vector<T> Read() {
		vector<T> ret;
		*this >> ret;
		return ret;
	}
private:
	inline void FileToBuf() {
		const int canRead = m_iWritePos - (S - buffer);
		if (canRead >= 100) { return; }
		if (m_bFinish) { return; }
		for (int i = 0; i < canRead; i++)
		{
			buffer[i] = S[i];//memcpy出错			
		}
		m_iWritePos = canRead;
		buffer[m_iWritePos] = 0;
		S = buffer;
		int readCnt = fread(buffer + m_iWritePos, 1, N - m_iWritePos, stdin);
		if (readCnt <= 0) { m_bFinish = true; return; }
		m_iWritePos += readCnt;
		buffer[m_iWritePos] = 0;
		S = buffer;
	}
	int m_iWritePos = 0; bool m_bFinish = false;
	char buffer[N + 10], * S = buffer;
};


template<class ELE = int >
class ITreeArrSumOpe
{
public:
	virtual void Assign(ELE& dest, const ELE& src) = 0;
	virtual ELE Back(const ELE& n1, const ELE& n2) = 0;
};

template<class ELE = int >
class CTreeArrAddOpe :public ITreeArrSumOpe<ELE>
{
public:
	virtual void Assign(ELE& dest, const ELE& src) {
		dest += src;
	}
	virtual ELE Back(const ELE& n1, const ELE& n2) {
		return n1 - n2;
	}
};

template<class ELE = int, class ELEOpe = CTreeArrAddOpe<ELE> >
class CTreeArr
{
public:
	CTreeArr(int iSize) :m_vData(iSize + 1)
	{

	}
	void Add(int index, ELE value)
	{
		if ((index < 0) || (index >= m_vData.size() - 1)) { return; }
		index++;
		while (index < m_vData.size())
		{
			m_ope.Assign(m_vData[index], value);
			index += index & (-index);
		}
	}
	ELE Sum(int index)//[0...index]之和
	{
		index++;
		ELE ret = 0;
		while (index)
		{
			m_ope.Assign(ret, m_vData[index]);
			index -= index & (-index);
		}
		return ret;
	}
	ELE Sum() { return Sum(m_vData.size() - 2); }
	ELE Get(int index)
	{
		return m_ope.Back(Sum(index), Sum(index - 1));
	}
private:
	ELEOpe m_ope;
	vector<ELE> m_vData;
};

class Solution {
public:
	bool Ans(char ch, vector<int>& v) {
		int cnt = (v[1] + 1 == v[2]) + (v[3] + 1 == v[4]);
		if (1 != cnt) { return false; }
		if ('B' == ch) { return false; }
		if ((v[1] + 1 == v[2]) && (v[0] + 1 != v[1])) { return true; }
		return (v[3] + 1 == v[4]) && (v[4] + 1 != v[5]);
	}
};

int main() {
#ifdef _DEBUG
	freopen("a.in", "r", stdin);
#endif // DEBUG	
	//ios::sync_with_stdio(0); cin.tie(nullptr);
	CInBuff<> in; COutBuff<10'000'000> ob;
	int T;
	in >> T;
	char ch;
	for (int i = 0; i < T; i++) {
		in >> ch;
		auto a = in.Read<int>(6);
#ifdef _DEBUG		
		//printf("ch='%c'", ch);
		//Out(a, "a=");
		//Out(ch, "ch=");
		//Out(B, "B=");
		//Out(que, "que=");
		//Out(B, "B=");
#endif // DEBUG	
		auto res = Solution().Ans(ch, a);
		cout << (res ? "Yes" : "No") << "\n";
	}
	return 0;
}

单元测试

cpp 复制代码 
	char ch;
		vector<int>v;
		TEST_METHOD(TestMethod11)
		{
			ch = 'B',v = { 1,3,4,6,8,9 };
			auto res = Solution().Ans(ch, v);
			AssertEx(false, res);
		}
		TEST_METHOD(TestMethod12)
		{
			ch = 'W', v = { 1,3,4,6,8,9 };
				auto res = Solution().Ans(ch,v);
			AssertEx(true, res);
		}
		TEST_METHOD(TestMethod13)
		{
			ch = 'W', v = { 1,3,5,6,8,9 };
			auto res = Solution().Ans(ch, v);
			AssertEx(false, res);
		}
		TEST_METHOD(TestMethod14)
		{
			ch = 'W', v = { 3,4,5,6,8,9 };
			auto res = Solution().Ans(ch, v);
			AssertEx(false, res);
		}
		TEST_METHOD(TestMethod15)
		{
			ch = 'W', v = { 3,4,5,6,7,9 };
			auto res = Solution().Ans(ch, v);
			AssertEx(false, res);
		}

扩展阅读

我想对大家说的话
工作中遇到的问题，可以按类别查阅鄙人的算法文章，请点击《算法与数据汇总》。
学习算法：按章节学习《喜缺全书算法册》，大量的题目和测试用例，打包下载。重视操作
有效学习：明确的目标 及时的反馈 拉伸区（难度合适） 专注
闻缺陷则喜(喜缺)是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛
失败+反思=成功 成功+反思=成功

视频课程

先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

如何你想快速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

测试环境

操作系统：win7 开发环境： VS2019 C++17

或者 操作系统：win10 开发环境： VS2022 C++17

如无特殊说明，本算法用**C++**实现。

相关推荐
l1t2 小时前
Qwen 3.5plus一步做对的欧拉计划701题
算法·动态规划·欧拉计划
Book思议-2 小时前
【数据结构实战】链表找环入口的经典问题：快慢指针法
c语言·数据结构·算法·链表
tankeven2 小时前
HJ135 计树
c++·算法
㓗冽2 小时前
时间转换-进阶题12
c++·算法
不知名。。。。。。。。2 小时前
仿muduo库实现高并发---请求HttpRequest模块 响应HttpResponse模块
服务器·c++
炽烈小老头2 小时前
【 每天学习一点算法 2026/03/19】子集
学习·算法
我能坚持多久2 小时前
【初阶数据结构11】——链式二叉树知识补充
数据结构·算法
liuyao_xianhui2 小时前
优选算法_两数之和_位运算_C++
java·开发语言·数据结构·c++·算法·链表·动态规划
靠沿2 小时前
【优选算法】专题十六——BFS解决最短路径问题
redis·算法·宽度优先
热门推荐
01GitHub 镜像站点02Qwen3.5 开源全解析：从 0.8B 到 397B，代际升级 + 全场景选型指南03OpenClaw 使用和管理 MCP 完全指南04Labelme从安装到标注：零基础完整指南05AI 编程三剑客：Spec-Kit、OpenSpec、Superpowers 深度对比与实战指南06UV安装并设置国内源07小黑课堂计算机二级WPSoffice题库软件下载安装教程（2026年3月最新版）08OpenClaw Control UI安全上下文访问配置09Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services10让 Trae IDE 智能体 “读懂”文档 Excel+PDF+DOCX ：mcp-documents-reader 工具使用指南