BUPT 大二训练-博弈

最新推荐文章于 2018-04-09 00:19:56 发布
最新推荐文章于 2018-04-09 00:19:56 发布
阅读量869 收藏
点赞数
分类专栏： 数学 & 博弈论 & FFT & 位运算 文章标签： bupt 博弈 ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013007900/article/details/37890493
版权

比赛网址


HDU 3595 GG and MM


EVERY SG：

在验算的过程中，我们可以发现如果X,Y，X>Y而且X / Y==1，则每次从X中取走Y，这步的选择是固定的，但是当X / Y>=2的情况就不一样了，可以控制步数。

在这个游戏中，由于是Every_SG,我们考虑的是步数，

首先，利用辗转相除法计算最原始的步奏

其次，看谁如果拥有第一个X/Y>=2，便具有优先权，可以控制，将 所有的X/Y>=2控制在自己手中，到了最后一个让自己获胜。以上的策略全部由奇偶来决定，如果在某一步操作的时候，第一个和第二个满足X / Y >=2的点，之间原始步奏的奇偶性，如果是相同的奇偶性那么就不需要改变步数，如果是不同的奇偶性，那么就要将步数加一以实现最优策略，   以此得到最大的步数，判断奇偶。 

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>

using namespace std;


template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1; char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
//-------------------------------------------------------------------

const int INF=0x3f3f3f3f;
const int MAXN=1010;

int Gcd(int a,int b)
{
    int j=-1;//even   0   odd  1
    int step=0,num=2;
    int f[110]={1,a,b};
    while(f[num])
    {
        f[num+1]=f[num-1]%f[num];
        num++;
    }
    step=num-2;
    for(int i=1;i<num-1;i++)
        if(f[i]>=2*f[i+1])
        {
            if(j>0&&(i&1)!=(j&1))
                step++;
            j=i;
        }
    return step;
}

int main()
{
	int n;
	while(read(n))
	{
		int p,q,ans=0;
		for(int i=0;i<n;i++)
		{
			read(p);read(q);
			if(q>p)
                swap(p,q);
			ans=max(Gcd(p,q),ans);
		}
		if(!(ans&1))
			puts("GG");
		else
			puts("MM");
	}
    return 0;
}



POJ 1704 Georgia and Bob

StairCase博弈：

将之转化为Nim博弈，把两个棋子的距离看成一堆石子，因为如果你把左边的棋子移动任意步数，右边的棋子跟着移动相同步数就会抵消（例 2 3 3 等同于 2），这样就转换成Nim游戏了。注意，如果是奇数个的棋子，则将右边挡板当做棋子辅助运算。

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>

using namespace std;


template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1; char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
//-------------------------------------------------------------------

const int MAXN=1200;

int a[MAXN];

int main()
{
	int ans,T,i,n;
	read(T);
	while(T--)
	{
		read(n);
		ans=0;
		for(i=0;i<n;i++)
			read(a[i]);
		sort(a,a+n);
		for(i=n-1;i>=1;i-=2)
			ans^= a[i]-a[i-1]-1;
		if(n&1)
			ans^=a[0]-1;
		if(!ans)
		   puts("Bob will win");
  		else
		   puts("Georgia will win");
	 }
	 return 0;
}



HDU 1730 Northcott Game

将之转化为NIM游戏，将把每行黑白子的初始距离设为每堆石子的初始数量，当然不同的是，这个石子不仅可以取，还可以增加，但是因为这个增加的数量是有界限的（比如，白棋左移3格，黑棋左移3格，他们之间的差是不变的，因此可以认为和最初的状态是一样的，无论如何增加，一定会某一棋子到达边界，导致棋子之间的距离再无法增加）。


#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>

using namespace std;

template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1; char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
//-------------------------------------------

int main()
{
	int n,m,sum=0;
	while(read(n)&&read(m))
	{
		sum=0;
		for(int i=0;i<n;i++)
		{
			int x,y;
			read(x);read(y);
			sum^=(int)fabs(x-y)-1;	
		}
		if(sum)
			puts("I WIN!");
		else
			puts("BAD LUCK!");
	}
	return 0;
}



 POJ 2925 Nim

简单NIM游戏的变形：

记n1^n2^n3..^n[m]=x

显然若x=0,则该局势为奇异局势，必输。

如果把ni变成x^ni，则n1^n2^...^n[i-1]^n[i+1]^...^n[m]^x^ni=0，为奇异局势。显然如果ni>x^ni，如果能ni堆中拿走ni-x^ni张牌，则一定会获胜。

所以只用统计ni中比x^ni大于的个数，结果就是先拿者获胜的种数。


<pre name="code" class="cpp">#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>

using namespace std;


template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1; char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
//-------------------------------------------------------------------
int main (){int n,t,a[1111];while(scanf("%d",&n) && n != 0){int temp=0;for(int i=0;i<n;i++){scanf("%d",&t);temp^=t;a[i]=t;}int ans=0;if(temp!=0){for(int i=0;i<n;i++){int k = 0; for(int j=0;j<n;j++) if(i!=j) k^=a[j];//只要能够取到K个，就能够根据对称原理获胜 if(k<=a[i]) ans++;}}printf("%d\n",ans);}return 0;} 

 

 

POJ 1067 取石子游戏
 

裸Wythoff博弈：
 

你可以根据公式直接得出答案，也可以根据sg推出答案
 

 

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>

using namespace std;


template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1; char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
//-------------------------------------------------------------------

int main()
{
	int m,n;
	while(read(m)&&read(n))
	{
		if(m>n)
			swap(m,n);
		int k = n - m;
		int data = floor(k*(1.0+sqrt(5.0))/2);
		puts(data == m ? "0" : "1");
	}
	return 0;
}
 

 

 

 

HDU 1907 John
 
 

裸反NIM游戏：
 

 

 
  

 

 
  

 

 
  

 
 

 

 

 

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>

using namespace std;


template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1; char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
//-------------------------------------------------------------------


int main()
{
	int T,n;
    read(T);
    int ans,a,mi;
    while(T--)
    {
        ans=0;mi=-1;
        read(n);
        for(int i=0;i<n;i++)
        	read(a),ans^=a,mi=max(mi,a);
         if(mi>1)
         	if(ans>0)
                puts("John");
          	else
                puts("Brother");
         else
         	if(!ans)
                puts("John");
         	else
                puts("Brother");
    }
    return 0;
}
 

 

 

 


 
 


 
 

HDU 1922 a simple stone game
 
 

K倍动态减法游戏：
 

详见论文http://wenku.baidu.com/view/32782dea81c758f5f61f67a8.html?re=view
 

 

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>

using namespace std;

template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1; char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
//------------------------------------------------------------------------

const int MAXN=2000010;

int a[MAXN],b[MAXN];
int n,k,cas=1;

int main()
{
	int T;
	read(T);
	while(T--)
	{
		read(n);read(k);
		int i=0,j=0;
		a[0]=b[0]=1;
		while(a[i]<n)
		{
			i++;
			a[i]=b[i-1]+1;
			while(a[j+1]*k<a[i])
				j++;
			if(a[j]*k<a[i])
				b[i]=b[j]+a[i];
			else
				b[i]=a[i];
		}
		printf("Case %d: ",cas++);
		if(a[i]==n)
			puts("lose");
		else
		{
			int ans;
			while(n)
			{
				if(n>=a[i])
				{
					n-=a[i];
					ans=a[i];
				}
				i--;
			}
			printf("%d\n",ans);
		}
	}
	return 0;
}
 

 

 

 


 

                

        

        

    

  


    

      

        

            

              
                
                  SuPhoebe
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
bupt-sse-web

				
			

			

				

					05-11
				

			

		

		

			
				
"bupt-sse-web"项目是一个专注于电子政务系统Web后台开发的开源项目，主要使用Java技术栈。在本文中，我们将深入探讨这个项目的核心技术和它在电子政务中的应用。  一、Java技术栈详解  1. **Spring框架**：作为Java...

			
		

	



                

              
                



	

		

			

				
					
BUPT-Net-Login

				
			

			

				

					05-15
				

			

		

		

			
				
"BUPT-Net-Login" 是一个基于Objective-C编写的项目，主要针对北京邮电大学（BUPT）的网络登录需求。该项目旨在提供便捷的网络账号管理功能，帮助用户更高效地处理网络登录过程，同时增加了安全性措施。下面将详细...

			
		

	



                


  
              

                


	

		

			

				
					
bupt-ncov-report-tgbot:Telegram机器人向BUPT提交2019-nCoV每日报告

				
			

			

				

					05-14
				

			

		

		

			
				
BUPT 2019-nCoV报告机器人 要求 Python3（开发3.7.4）  点子 运行pip install -r requirements.txt以安装必需的组件。 部署方式 将include/config.example.py复制到include/config.py 。  使用您自己的机器人令牌和...

			
		

	





	

		

			

				
					
bupt大二下c++课设.zip

					
最新发布

				
			

			

				

					01-06
				

			

		

		

			
				
【标题】"bupt大二下c++课设.zip" 提示我们这是一份来自北京邮电大学（BUPU）大二下学期的C++课程设计项目。这个项目的重点很可能是让学生深入理解和实践C++编程语言，通过实际的项目开发来提升他们的编程技能和问题...

			
		

	



		

			
		



	

		

			

				
					
bupt-sse-service

				
			

			

				

					05-11
				

			

		

		

			
				
"bupt-sse-service"是一个基于Java开发的项目，主要关注于电子政务系统的dubbo接口实现。Dubbo是阿里巴巴开源的一款高性能、轻量级的服务治理框架，它专注于服务调用的透明性和微服务架构的支持。在这个项目中，...

			
		

	





	

		

			

				
					
4和7是一个幸运数字

				
			

			

				

					Mr.Phoebe的专栏
				

				

					04-04
					
					6885
					
				

			

		

		

			
				
一个比较有趣的面试题

题意：

仅由4和7组成的十进制数字被称为幸运数字，如，4，7，44，47。

那么仅由幸运数字乘积得到的数字为超级幸运数字，如，28 = 4 * 7。

现在给你两个数字表示上下限，让你求这段区间内有多少个超级幸运数字。总共有1000组查询，上下限最多到1012101210^{12}。

思路：

第一想法是容斥搞一下，但是其实非常难，因为除了爆搜很难去构造出仅由幸运数字...

			
		

	





	

		

			

				
					
模拟退火算法分析

				
			

			

				

					Mr.Phoebe的专栏
				

				

					02-05
					
					3392
					
				

			

		

		

			
				
一. 爬山算法 ( Hill Climbing )
         介绍模拟退火前，先介绍爬山算法。爬山算法是一种简单的贪心搜索算法，该算法每次从当前解的临近解空间中选择一个最优解作为当前解，直到达到一个局部最优解。
         爬山算法实现很简单，其主要缺点是会陷入局部最优解，而不一定能搜索到全局最优解。如图1所示：假设C点为当前解，爬山算法搜索到A点这个局部最优解就会停止搜索，因为

			
		

	





	

		

			

				
					
HDU 5307 He is Flying【FFT】

				
			

			

				

					Mr.Phoebe的专栏
				

				

					07-24
					
					2044
					
				

			

		

		

			
				
题意： 
有n段路，每段路长度为sis_i，你从节点i到节点j，可以获得一个开心值j−i+1j-i+1，然后问你，主人公走过了所有总长度为ss的段，问你有多少开心值。 
思路： 
首先想到的就是类似于组合数学那样，于是就想到了母函数： 
(∑ix∑si)(∑x−∑si−1)−(∑x∑si)(∑(i−1)x−∑si−1)(\sum ix^{\sum s_i})(\sum x^{-\sum s_{i-1

			
		

	





	

		

			

				
					
位运算趣题

				
			

			

				

					Mr.Phoebe的专栏
				

				

					09-04
					
					1808
					
				

			

		

		

			
				
一个CMU的同学问了我几道题。/*
 * divpwr2 - Computer x/(2^n). for 0<= n <=30
 * Legel ops: ! ~ & ^ | + << >>
 * Max ops: 15
 */int divpwr(int x, int n)
{
    int tmp = ((x^(x>>31))) + !!(x>>31))>>n;
    return (tmp

			
		

	





	

		

			

				
					
Google Code Jam 2018: Qualification Round

				
			

			

				

					Mr.Phoebe的专栏
				

				

					04-09
					
					1720
					
				

			

		

		

			
				
资格赛，除了最后一题比较有趣以外，其他都比较简单

Saving The Universe Again

贪心 
一开始想着尽可能将S往前移，但是想了想觉得这样移动好多次，可能才等于后面的S往前移一位的成果。 
所以就变成尽可能地将C往末尾移（末尾一段连续的C就不用考虑了），即，每一次移动减少的伤害最大。

int T,n;
vi a1,a2;

int main()
{
    cin&gt;&...

			
		

	





	

		

			

				
					
HDU 5035 Delivery

				
			

			

				

					Mr.Phoebe的专栏
				

				

					09-21
					
					1632
					
				

			

		

		

			
				
公式题
概率论书上原题

			
		

	





	

		

			

				
					
BUPT 2014新生暑假个人排位赛11

				
			

			

				

					Mr.Phoebe的专栏
				

				

					08-06
					
					1514
					
				

			

		

		

			
				
488. 小妹妹个数

			
		

	





	

		

			

				
					
HDU 5358 First One

				
			

			

				

					Mr.Phoebe的专栏
				

				

					08-06
					
					1226
					
				

			

		

		

			
				
这题你必须严格地写出O(nlog(n))O(nlog(n))的时间复杂度，我们尝试了下O(nlog(n)2)O(nlog(n)^2)，结果不行，而且卡常数卡得特别死。首先枚举log(SUM)log(SUM)的值，从1~33，每次固定左端点ii，然后用尺取法枚举出符合位数的SUM[l,r]SUM[l,r]，这里面的sum的对数值相同，可以直接统一计算。 
所以总体复杂度为O(nlog(n))O(nlo

			
		

	





	

		

			

				
					
HDU 5292 Pocket Cube

				
			

			

				

					Mr.Phoebe的专栏
				

				

					07-21
					
					1072
					
				

			

		

		

			
				
结论题 
问了学长怎么做的，学长告诉我这个结论，然后说，会玩魔方的人都知道啊… 
//      whn6325689
//        Mr.Phoebe
//        http://blog.csdn.net/u013007900
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>

			
		

	





	

		

			

				
					
HDU 4923 Room and Moor

				
			

			

				

					Mr.Phoebe的专栏
				

				

					08-07
					
					1063
					
				

			

		

		

			
				
先按照




#include
#include
#include
#include
#include
#include
#include
#define pi acos(-1.0)
#define eps 1e-8
#define ll long long
#define L 1000050
#define N 100050
#define Mod 1000000007
#defin

			
		

	





	

		

			

				
					
UVA 12298 Super Poker II（FFT）

				
			

			

				

					Mr.Phoebe的专栏
				

				

					06-07
					
					1020
					
				

			

		

		

			
				
题意： 
每个花色恰好选择一张牌 
能够构成点数和大小为N的方案数 
用类似生成函数的想法，多项式的幂值表示大小，前面的系数表示的是方案数 
因此想到了多项式乘法，用FFT来优化//      whn6325689
//      Mr.Phoebe
//      http://blog.csdn.net/u013007900
#include <algorithm>
#include <iost

			
		

	





	

		

			

				
					
LightOJ 1356 && LightOJ 1336

				
			

			

				

					Mr.Phoebe的专栏
				

				

					05-07
					
					966
					
				

			

		

		

			
				
LightOJ 1356

如果把不独立的两个数a和b建立关系，那么问题就是找到一个最大的集合，使得集合中的任意两个数不相关，这有点像二分图中最大独立集的概念。
然后问题就是建立二分图。如果两个数a和b相关，即存在一个素数k使得a=b*k，如果对a和b做质因子分解，它们质因子的个数一定是一奇一偶，因为a比b多一个质因子k。那么我们就可以用质因子个数的奇偶性来建二分图。
前段时间的编程之美中

			
		

	





	

		

			

				
					
BUPT 2014新生暑假个人排位赛02

				
			

			

				

					Mr.Phoebe的专栏
				

				

					07-17
					
					962
					
				

			

		

		

			
				
A. 丁神去谷歌

			
		

	





	

		

			

				
					
ZOJ 3899 State Reversing【NTT】

				
			

			

				

					Mr.Phoebe的专栏
				

				

					09-16
					
					959
					
				

			

		

		

			
				
题意： 
有N（有序号）个怪兽，给出M（1～M）个房间，每个房间的初始状态为1，接下来有D次操作，每次操作是选择一个区间使得区间内房间的状态反转（0->1 , 1->0），每次操作后计算将这N个怪兽放进所有状态为1的房间内，且每个状态为1的房间非空的方案数。（注意房间之间不可辨别。两种方案一样，当且仅当两种方案中存在两个房间，里面的怪兽数量以及编号一致）思路：  
用线段树来更新available的

			
		

	





	

		

			

				
					
BUPT信安大二下操作系统核心知识点总结

				
			

			

				

					
				

			

		

		

			
				
本文档对大二下学期的BUPT信息安全专业操作系统课程知识点进行了详尽整理，涵盖了操作系统的基本概念、功能、发展、特征、运行机制、体系结构以及重要的管理模块。  1. **操作系统的功能和目标**：  - 操作系统作为...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值