水体
#include<cstdio>
#include<cstring>
using namespace std;
int main()
{
double n;
scanf("%lf",&n);
while(n>18.0) n=n/18.0;
if(n<=9) printf("181818181818\n");
else printf("ZBT\n");
return 0;
}

我来解释下大牛门的方法吧

设n=564

如果想要赢

就要想办法让对方在某次操作后使m>=63

为什么?

因为当m>=63

那么我们只要*9就可以赢了

要让对方使m>=63

我们就必须使m>=32

为什么?

因为当m>=32

即使对方操作再小——即*2

那么都会使m>=63

当然

即使对方*9，m也仅是>=288

所以必胜

以此类推

m>=4

m>=2

但是这都在一次可以控制的范围内

所以是ZBT赢了

说的不清楚

大家要好好再领悟下

总之就这样啦

胜(1,9]

负(9,18]

胜(18,162]

负(162,324]

......

胜(18^n,9*18^n]

负(9*18^n,18^(n+1)]

用实型做,主程序4行

var
  n:real;
begin
  read(n);
  while n>18 do n:=n/18;
  if n<=9 then write('181818181818')
  else write('ZBT')
end.

定义：f(x)表示不小于x的最小整数。
很显然[f(n/9),n]是必胜状态。
相对应的,[f((n/9)/2),f(n/9))是必败状态。

#include<iostream>
using namespace std;
int main()
{
double n;
cin>>n;
while(n>18.0) n=n/18.0;
if(n<=9.0) cout<<"181818181818";
else cout<<"ZBT";
}

定义：\(f(x)\)表示不小于x的最小整数。
很显然\([f(n/9),n]\)是必胜状态。
相对应的,\([f((n/9)/2),f(n/9)]\)是必败状态。
一步一步推下去，直到推出\(1\)的状态就行了。
还有,\(n\)可能会大于maxlongint,要用dword.

Pascal Code

var
n:dword;
t:longint;
begin
readln(n);
t:=9;
repeat
if n mod t=0 then n:=n div t //能整除时不用+1
else n:=n div t+1;
if t=2 then t:=9 //9变2，2变9
else t:=2;
until n=1;
if t=2 then writeln('181818181818')
else writeln('ZBT');
end.

毫无节操的博弈DP+部分记忆化搜索
注意完整记忆化,别乱return即可.

测试数据 #0: Accepted, time = 0 ms, mem = 20084 KiB, score = 4

测试数据 #1: Accepted, time = 0 ms, mem = 20080 KiB, score = 4

测试数据 #2: Accepted, time = 0 ms, mem = 20084 KiB, score = 4

测试数据 #3: Accepted, time = 7 ms, mem = 20084 KiB, score = 4

测试数据 #4: Accepted, time = 15 ms, mem = 20084 KiB, score = 4

测试数据 #5: Accepted, time = 15 ms, mem = 20080 KiB, score = 4

测试数据 #6: Accepted, time = 46 ms, mem = 20084 KiB, score = 4

测试数据 #7: Accepted, time = 62 ms, mem = 20080 KiB, score = 4

测试数据 #8: Accepted, time = 0 ms, mem = 20084 KiB, score = 4

测试数据 #9: Accepted, time = 0 ms, mem = 20084 KiB, score = 4

测试数据 #10: Accepted, time = 0 ms, mem = 20084 KiB, score = 4

测试数据 #11: Accepted, time = 31 ms, mem = 20084 KiB, score = 4

测试数据 #12: Accepted, time = 15 ms, mem = 20080 KiB, score = 4

测试数据 #13: Accepted, time = 15 ms, mem = 20080 KiB, score = 5

测试数据 #14: Accepted, time = 15 ms, mem = 20080 KiB, score = 5

测试数据 #15: Accepted, time = 15 ms, mem = 20080 KiB, score = 5

测试数据 #16: Accepted, time = 15 ms, mem = 20084 KiB, score = 5

测试数据 #17: Accepted, time = 0 ms, mem = 20084 KiB, score = 18

测试数据 #18: Accepted, time = 0 ms, mem = 20080 KiB, score = 5

测试数据 #19: Accepted, time = 15 ms, mem = 20088 KiB, score = 5

##Code

#include <cstdio>
#include <fstream>
#include <iostream>

#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>

#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>

typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;

#define DBG printf("*")

using namespace std;

ull n;

bool d[10000000];
bool used[10000000];

bool DFS(ull x) //can I win when I deal with number x?
{
if(x<10000000 && used[x]) return d[x];
if(x<10000000) used[x]=true;

for(ull i=2;i<=9;i++)
if(i*x>=n)
{
if(x<10000000) return d[x]=true;
else return true;
}

bool win=false;
for(ull i=2;i<=9;i++)
win|=!DFS(i*x);

if(x<10000000)
return d[x]=win;
else return win;
}

int main()
{
cin>>n;

cout<<(DFS(1)?"181818181818":"ZBT")<<endl;

return 0;
}

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

├ 测试数据 11：答案正确... 0ms

├ 测试数据 12：答案正确... 0ms

├ 测试数据 13：答案正确... 0ms

├ 测试数据 14：答案正确... 0ms

├ 测试数据 15：答案正确... 0ms

├ 测试数据 16：答案正确... 0ms

├ 测试数据 17：答案正确... 0ms

├ 测试数据 18：答案正确... 0ms

├ 测试数据 19：答案正确... 0ms

├ 测试数据 20：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

晕啊 原来是begin end 这对括号没加 晕晕晕

我的理解“div 18”错了.....

为什么题解都是“/18”啊.......

水题……秒杀……

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

├ 测试数据 11：答案正确... 0ms

├ 测试数据 12：答案正确... 0ms

├ 测试数据 13：答案正确... 0ms

├ 测试数据 14：答案正确... 0ms

├ 测试数据 15：答案正确... 0ms

├ 测试数据 16：答案正确... 0ms

├ 测试数据 17：答案正确... 0ms

├ 测试数据 18：答案正确... 0ms

├ 测试数据 19：答案正确... 0ms

├ 测试数据 20：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

var n:real;

begin

readln(n);

while n>18 do

n:=n/18;

if n

多谢各位大牛指点

AC

水题

难度3？我白做了...难度1挺合适

庆祝50T!!!

╭︿︿︿╮

{/ ︿︿ /}

( (oo) )

︶ ︶ ︶

const maxn=1000000;

var

a:array[0..maxn] of boolean;

n,i,j:longint;

begin

read(n);

a[1]:=true;

for i:=2 to n do

begin

for j:=i div 9 to i div 2 do if a[j]=false then a[i]:=true;

end;

if a[n] then writeln(n);

end.

n2的程序。。。(ln(n)/ln(18))的算法原理是什么？？？？

无语了

program vijos;

var n:real;

begin

readln(n);

while n>18 do n:=n/18;

if n

我的题解被删了

顶顶顶顶顶顶顶顶顶顶顶顶顶●●●●●●●●●●●●●顶顶顶

顶顶●●●●●●●●●●顶顶顶顶顶●●●●●顶顶顶顶顶顶顶

顶●●●●●●●●●●●顶顶顶顶顶顶●●●顶顶顶顶顶顶顶顶

顶顶顶●●●●●●●顶顶顶顶顶顶顶顶●●●顶顶顶顶顶顶顶顶

顶顶顶顶顶顶●●●顶顶顶顶顶顶顶●●●●●●●●●顶顶顶顶

顶顶顶顶顶顶●●●顶顶顶顶顶●●●●●●●●●●●顶顶顶顶

顶顶顶顶顶顶●●●顶顶顶顶●●●●●顶顶顶顶●●●●顶顶顶

顶顶顶顶顶顶●●●顶顶顶顶●●●●顶顶顶顶顶顶●●●顶顶顶

顶顶顶顶顶顶●●●顶顶顶顶●●●顶顶●●●顶顶●●●顶顶顶

顶顶顶顶顶顶●●●顶顶顶顶●●●顶顶●●●顶顶●●●顶顶顶

顶顶顶顶顶顶●●●顶顶顶顶●●●顶顶●●●顶顶●●●顶顶顶

顶顶顶顶顶顶●●●顶顶顶顶●●●顶顶●●●顶顶●●●顶顶顶

顶顶顶顶顶顶●●●顶顶顶顶●●●顶顶●●●顶顶●●●顶顶顶

顶顶顶顶顶顶●●●顶顶顶顶●●●顶顶●●●顶顶●●●顶顶顶

顶●●顶顶●●●●顶顶顶顶顶顶顶顶●●●●●●顶顶顶顶顶顶

顶●●●●●●●●顶顶顶顶顶顶顶●●●●顶●●●●顶顶顶顶

顶顶●●●●●●●顶顶顶顶顶顶●●●●顶顶顶●●●●顶顶顶

顶顶顶●●●●●●顶顶顶顶顶●●●●●顶顶顶顶●●●●顶顶

顶顶顶顶顶●●●顶顶顶顶顶●●●●●顶顶顶顶顶顶●●●●顶

顶顶顶顶顶顶顶顶顶顶顶顶●●●●●顶顶顶顶顶顶顶顶●●●●

顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶

这种题目都三级？

一句赋值语句

加一句if语句就行了