A
题目描述
就是要求按一定格式输出图案，模拟题。
标程
B
题目描述
签到题
标程
C
题目描述
要求求ABABBABA和ABABBABA型的日期
虽然是八位数，但其实只要挨个检查年份即可，最多一万次循环，实际肯定没有那么多。
标程
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define hash_t map
int tr(int n){
int s = 0;
while(n) s=s*10+n%10, n/=10;
return s;
}
inline bool isLeaf(int year){return year%400==0||(year%100&&year%4==0);}
bool isOK(int y,int m,int d){
if(d<=0||d>31) return false;
switch(m){
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:return d <= 31;
case 4:
case 6:
case 9:
case 11:return d <= 30;
case 2: return d <= 28 + (isLeaf(y)?1:0);
default:return false;
}
return false;
}
/// 判回文
bool f1(int year){
int md = tr(year);
int d = md % 100, m = md / 100;
return isOK(year, m, d);
}
/// 判ABAB
inline bool abab(int year){
int a = year / 1000;
int b = year / 100 % 10;
int c = year / 10 % 10;
int d = year % 10;
return a==c&&b==d&&a!=b;
}
inline bool f2(int year){
return abab(year)&&f1(year);
}
void solute(){
int date;
scanf("%d",&date);
int year = date / 10000;
int md = date % 10000;
int ans1 = -1,ans2 = -1;
if(f1(year)){
int tmp = tr(year);
if(tmp>md) ans1 = year * 10000 + tmp;
}
if(f2(year)){
int tmp = tr(year);
if(tmp>md) ans2 = year * 10000 + tmp;
}
while(ans1==-1||ans2==-1){
++year;
if(year>9999) break;
if(-1==ans1&&f1(year)){
int tmp = tr(year);
ans1 = year * 10000 + tmp;
}
if(-1==ans2&&f2(year)){
int tmp = tr(year);
ans2 = year * 10000 + tmp;
}
}
printf("%d\n%d\n",ans1,ans2);
}
int main(){
// freopen("1.txt","r",stdin);
solute();
return 0;
}
D
题目描述
令
F
F
F为
F
i
b
o
n
a
c
c
i
Fibonacci
Fibonacci数列，给定
0
<
n
,
m
,
p
<
1
0
18
0<n,m,p<10^{18}
0<n,m,p<1018，求
Σ
i
=
1
n
F
(
i
)
m
o
d
F
(
m
)
m
o
d
p
\Sigma_{i=1}^{n}{F(i)}\space mod\space {F(m)}\space mod\space p
Σi=1nF(i) mod F(m) mod p
解法
数非常大，显然需要能够快速求
F
i
b
o
n
a
c
c
i
Fibonacci
Fibonacci数。可以参考根据递推公式构造系数矩阵用于快速幂。如果直接写的话，
p
y
t
h
o
n
python
python应该不超过15分，C++分数还要低一点，因为第90多个
F
i
b
Fib
Fib数已经超过了64位范围。
还要考虑求和问题，这个比较简单，令:
S
(
n
)
=
Σ
i
=
1
n
F
(
i
)
S(n)=\Sigma_{i=1}^{n}{F(i)}
S(n)=Σi=1nF(i)
则
S
(
n
+
1
)
=
Σ
i
=
1
n
+
1
F
(
i
)
S(n+1)=\Sigma_{i=1}^{n+1}{F(i)}
S(n+1)=Σi=1n+1F(i)
所以
S
(
n
)
+
S
(
n
+
1
)
=
F
(
1
)
+
(
F
(
1
)
+
F
(
2
)
)
+
(
F
(
2
)
+
F
(
3
)
)
+
⋯
+
(
F
(
n
)
+
F
(
n
+
1
)
)
=
F
(
1
)
+
F
(
3
)
+
F
(
4
)
+
⋯
+
F
(
n
+
1
)
+
F
(
n
+
2
)
S(n)+S(n+1)=F(1)+\big(F(1)+F(2)\big)+\big(F(2)+F(3)\big)+\cdots +\big(F(n)+F(n+1)\big) =F(1)+F(3)+F(4)+\cdots + F(n+1)+F(n+2)
S(n)+S(n+1)=F(1)+(F(1)+F(2))+(F(2)+F(3))+⋯+(F(n)+F(n+1))=F(1)+F(3)+F(4)+⋯+F(n+1)+F(n+2)
注意到
F
(
1
)
=
F
(
2
)
F(1)=F(2)
F(1)=F(2)
所以
上
式
右
边
=
S
(
n
+
1
)
+
F
(
n
+
2
)
−
F
(
1
)
上式右边=S(n+1)+F(n+2)-F(1)
上式右边=S(n+1)+F(n+2)−F(1)
所以最后得到
S
(
n
)
=
F
(
n
+
2
)
−
1
S(n)=F(n+2)-1
S(n)=F(n+2)−1
如果只有一个取模运算，那使用矩阵快速幂就已经可以解决问题了。对于加减乘运算，取模都符合分配律，但是模运算本身不符合。即
a
%
m
%
p
≠
(
a
%
p
)
%
(
m
%
p
)
a \% m\%p\neq (a\%p)\%(m\%p)
a%m%p=(a%p)%(m%p)
所以必须先计算出
F
(
m
)
F(m)
F(m)的完整数值，然后再计算取模意义下的
F
(
n
+
2
)
F(n+2)
F(n+2)。由于
m
m
m可能非常巨大，所以即使使用快速幂也牵涉到大数的计算，速度非常慢。必然超时。
这里有一个简单优化，即
当
m
≥
n
+
2
当m\ge n+2
当m≥n+2时，就不用再对
F
(
m
)
F(m)
F(m)取模了，直接计算模
p
p
p意义下的
F
(
n
+
2
)
F(n+2)
F(n+2)即可。原题只要做了这个优化就OK了。本题加强了数据，这样做的话应该也只有50分左右。
需要考虑
F
i
b
Fib
Fib数之间取模的计算方法，首先显然有：
F
n
%
F
m
=
F
n
−
1
%
F
m
+
F
n
−
2
%
F
m
F_{n}\%F_{m}=F_{n-1}\%F_{m}+F_{n-2}\%F_{m}
Fn%Fm=Fn−1%Fm+Fn−2%Fm
其次依次考虑：
F
n
+
1
≡
F
n
−
1
(
m
o
d
F
n
)
F_{n+1}\equiv F_{n-1}(mod\space F_{n})
Fn+1≡Fn−1(mod Fn)
F
n
+
2
≡
F
n
−
1
(
m
o
d
F
n
)
F_{n+2}\equiv F_{n-1}(mod\space F_{n})
Fn+2≡Fn−1(mod Fn)
F
n
+
3
≡
2
F
n
−
1
−
F
n
≡
F
n
−
3
(
m
o
d
F
n
)
F_{n+3}\equiv 2F_{n-1}-F_{n}\equiv F_{n-3}(mod\space F_{n})
Fn+3≡2Fn−1−Fn≡Fn−3(mod Fn)
F
n
+
4
≡
F
n
−
3
+
F
n
−
1
−
F
n
≡
−
F
n
−
4
(
m
o
d
F
n
)
F_{n+4}\equiv F_{n-3}+F_{n-1}-F_{n}\equiv -F_{n-4}(mod \space F_{n})
Fn+4≡Fn−3+Fn−1−Fn≡−Fn−4(mod Fn)
注意到
F
n
+
2
≡
F
n
−
1
−
F
n
≡
−
F
n
+
2
(
m
o
d
F
n
)
F_{n+2}\equiv F_{n-1}-F_{n}\equiv -F_{n+2}(mod\space F_{n})
Fn+2≡Fn−1−Fn≡−Fn+2(mod Fn)
因此可以得出规律：
F
n
+
k
≡
{
F
n
−
k
(
m
o
d
F
n
)
,
k
是
奇
数
−
F
n
−
k
(
m
o
d
F
n
)
,
k
是
偶
数
F_{n+k} \equiv\begin{cases} F_{n-k}(mod\space F_{n}),\quad k是奇数 \\-F_{n-k}(mod\space F_{n}),\quad k是偶数\end{cases}
Fn+k≡{Fn−k(mod Fn),k是奇数−Fn−k(mod Fn),k是偶数
显然这个式子要满足
k
≤
n
k\le n
k≤n。
当
k
>
n
k\gt n
k>n时，考虑如下格式：
F
n
+
n
+
1
≡
F
n
+
n
+
F
n
+
n
−
1
(
m
o
d
F
(
n
)
)
F_{n+n+1}\equiv F_{n+n}+F_{n+n-1}(mod\space F(n))
Fn+n+1≡Fn+n+Fn+n−1(mod F(n))
前一项必然为0，而后一项则是
±
F
1
\pm F_1
±F1，正负号取决于
n
n
n的奇偶。所以需要分开推导。
最后推导的规律是：
当
n
n
n是偶数，是周期为
2
n
2n
2n的函数。注意全部是在模
F
n
F_n
Fn意义下，以下省略了取模操作。
F
n
+
k
≡
{
F
n
−
k
,
k
<
n
且
k
是
奇
数
−
F
n
−
k
,
k
<
n
且
k
是
偶
数
F
k
−
n
,
n
<
k
<
2
n
0
,
k
是
n
的
倍
数
F
n
+
k
%
(
2
n
)
,
2
n
<
k
F_{n+k} \equiv\begin{cases} F_{n-k},\quad k\lt n且k是奇数 \\-F_{n-k},\quad k\lt n且k是偶数 \\F_{k-n}, \quad n\lt k\lt 2n\\ 0, \quad k是n的倍数\\F_{n+k\%(2n)}, \quad 2n\lt k\end{cases}
Fn+k≡⎩⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎧Fn−k,k<n且k是奇数−Fn−k,k<n且k是偶数Fk−n,n<k<2n0,k是n的倍数Fn+k%(2n),2n<k
当
n
n
n是奇数，是周期为
4
n
4n
4n的函数。
F
n
+
k
≡
{
F
n
−
k
(
m
o
d
F
n
)
,
k
<
n
且
k
是
奇
数
−
F
n
−
k
(
m
o
d
F
n
)
,
k
<
n
且
k
是
偶
数
−
F
k
−
n
,
n
<
k
<
2
n
−
F
3
n
−
k
,
2
n
<
k
<
3
n
且
k
是
奇
数
F
3
n
−
k
,
2
n
<
k
<
3
n
且
k
是
偶
数
F
k
−
3
n
,
3
n
<
k
<
4
n
0
,
k
是
n
的
倍
数
F
n
+
k
%
(
4
n
)
,
4
n
<
k
F_{n+k} \equiv\begin{cases} F_{n-k}(mod\space F_{n}),\quad k\lt n且k是奇数 \\-F_{n-k}(mod\space F_{n}),\quad k\lt n且k是偶数 \\ -F_{k-n}, \quad n\lt k \lt 2n\\-F_{3n-k},\quad 2n\lt k\lt 3n且k是奇数\\F_{3n-k},\quad 2n\lt k\lt 3n且k是偶数\\F_{k-3n}, \quad 3n\lt k\lt 4n\\0, \quad k是n的倍数\\F_{n+k\%(4n)}, \quad 4n\lt k\end{cases}
Fn+k≡⎩⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎧Fn−k(mod Fn),k<n且k是奇数−Fn−k(mod Fn),k<n且k是偶数−Fk−n,n<k<2n−F3n−k,2n<k<3n且k是奇数F3n−k,2n<k<3n且k是偶数Fk−3n,3n<k<4n0,k是n的倍数Fn+k%(4n),4n<k
有了这个公式，就不需要计算
F
m
F_m
Fm本身了，只需要计算特定的
F
i
b
Fib
Fib数再对
p
p
p取模即可，而这个可以用矩阵快速幂直接求得。时间复杂度为
O
(
8
l
o
g
(
m
i
n
(
n
,
m
)
)
)
O\bigg(8log\big(min(n,m)\big)\bigg)
O(8log(min(n,m)))
最后还有一个点，因为
p
p
p非常巨大，使得即使取模运算乘法也有可能溢出，因此将乘法写成加法的形式，仿照快速幂，在
l
o
g
log
log时间内完成乘法操作。这有一个测试点，不考虑这个C++和Java得不到满分。当然python可以不用考虑这个。
标程
C++和python分别提供一个标程。
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define hash_t map
typedef long long llt;
llt MOD = 0;
/// 取模运算
inline llt addMod(llt a,llt b){return (a%MOD+b%MOD)%MOD;}
inline llt subMod(llt a,llt b){return (a%MOD-b%MOD+MOD)%MOD;}
llt mulMod(llt a,llt b){
a%=MOD, b%=MOD;
if(a<b) swap(a,b);
llt ret = 0LL;
while(b){
if(b&1) ret = addMod(ret,a);
a = addMod(a,a);
b>>=1;
}
return ret;
}
typedef llt matrix_t[2][2] ;
/// Fib矩阵
void genFib(matrix_t&a){
a[0][0] = 0LL;
a[0][1] = a[1][0] = a[1][1] = 1LL;
}
/// I
void genI(matrix_t&a){
a[0][0] = a[1][1] = 1;
a[0][1] = a[1][0] = 0;
}
/// 矩阵运算，a、b、c各不相同
void mulMat(const matrix_t&a,const matrix_t&b,matrix_t&c){
c[0][0] = addMod(mulMod(a[0][0],b[0][0]),mulMod(a[0][1],b[1][0]));
c[0][1] = addMod(mulMod(a[0][0],b[1][0]),mulMod(a[0][1],b[1][1]));
c[1][0] = addMod(mulMod(a[1][0],b[0][0]),mulMod(a[1][1],b[1][0]));
c[1][1] = addMod(mulMod(a[1][0],b[1][0]),mulMod(a[1][1],b[1][1]));
}
/// a = a * b
void mulMatAss(matrix_t&a,const matrix_t&b){
llt c[2][2] = {0LL};
c[0][0] = addMod(mulMod(a[0][0],b[0][0]),mulMod(a[0][1],b[1][0]));
c[0][1] = addMod(mulMod(a[0][0],b[1][0]),mulMod(a[0][1],b[1][1]));
c[1][0] = addMod(mulMod(a[1][0],b[0][0]),mulMod(a[1][1],b[1][0]));
c[1][1] = addMod(mulMod(a[1][0],b[1][0]),mulMod(a[1][1],b[1][1]));
a[0][0] = c[0][0];
a[0][1] = c[0][1];
a[1][0] = c[1][0];
a[1][1] = c[1][1];
}
/// 矩阵快速幂
void power(matrix_t&a,llt n,matrix_t&ans){
genI(ans);
while(n){
if(n&1) mulMatAss(ans,a);
mulMatAss(a,a);
n >>= 1;
}
}
/// 求Fib数列的第n项
llt fib(llt n){
matrix_t a,ans;
genFib(a);
power(a,n,ans);
return ans[0][1];
}
/// 求(Fib[n+k]%Fib[n])%p
llt fib(llt n,llt k){
if(k%n==0) return 0LL;
if(n&1){ // n是奇数，以4n为周期
k %= (n+n+n+n);
if(k<n){
return (k&1)?fib(n-k):subMod(fib(n),fib(n-k));
}
if(k<n+n){
return subMod(fib(n),fib(k-n));
}
if(k<n+n+n){
return (k&1)?subMod(fib(n),fib(n+n+n-k)):fib(n+n+n-k);
}
return fib(k-n-n-n);
}
/// n是偶数，以2n为周期
k %= (n+n);
if(k<n){
return (k&1)?fib(n-k):subMod(fib(n),fib(n-k));
}
return fib(k-n);
}
void solute(){
llt n,m,p;
cin>>n>>m>>p;
MOD = p;
if(1==p||1==m){
puts("0");
}else if(n+2<=m){ // 直接求即可
printf("%lld\n",(fib(n+2)-1+p)%p);
}else{ // 否则要求出fn%fm
printf("%lld\n",subMod(fib(m,n+2-m),1));
}
}
int main(){
//freopen("1.txt","r",stdin);
solute();
return 0;
}
# coding=utf-8
import sys
sys.setrecursionlimit(10**6)
class Mat(object):
a = [[0,0],[0,0]]
def __init__(self):
self.a = [[0,0],[0,0]]
def mul(self, rhs):
r = Mat()
for i in range(2):
for j in range(2):
for k in range(2):
r.a[i][j] += self.a[i][k] * rhs.a[k][j]
return r
def mulMod(self, rhs, mod):
r = Mat()
for i in range(2):
for j in range(2):
for k in range(2):
r.a[i][j] += self.a[i][k] * rhs.a[k][j] % mod
return r
def add(self, rhs):
r = Mat()
for i in range(2):
for j in range(2):
r.a[i][j] = self.a[i][j] + rhs.a[i][j]
return r
def mulVector(self,x):
return [self.a[0][0]*x[0]+self.a[0][1]*x[1],self.a[1][0]*x[0]+self.a[1][1]*x[1]]
def pow(mat,n):
r = Mat()
r.a[0][0] = r.a[1][1] = 1
while n != 0:
if n%2 == 1: r = r.mul(mat)
mat = mat.mul(mat)
n //= 2
return r
def powMod(mat, n, mod):
r = Mat()
r.a[0][0] = r.a[1][1] = 1
while n != 0:
if n%2 == 1: r = r.mulMod(mat,mod)
mat = mat.mulMod(mat,mod)
n //= 2
return r
def f(n):
mat = Mat()
mat.a[1][0] = mat.a[1][1] = mat.a[0][1] = 1
mat = pow(mat, n)
r = mat.mulVector([0,1])
return r[0]
def fmod(n,mod):
mat = Mat()
mat.a[1][0] = mat.a[1][1] = mat.a[0][1] = 1
mat = powMod(mat, n, mod)
r = mat.mulVector([0,1])
return r[0] % mod
def ffmod(n,k,mod): # 求fib(n+k)%fib(n)%mod
if k%n==0: return 0
if n%2==0:
k = k % (n+n)
if k < n: return fmod(n-k,mod) if k%2==1 else (fmod(n,mod)-fmod(n-k,mod)+mod)%mod
else: return fmod(k-n,mod)
k = k % (n+n+n+n)
if k<n: return fmod(n-k,mod) if k%2==1 else (fmod(n,mod)-fmod(n-k,mod)+mod)%mod
if k<n+n: return (fmod(n,mod)-fmod(k-n,mod)+mod)%mod
if k<n+n+n:return (fmod(n,mod)-fmod(n+n+n-k,mod)+mod)%mod if k%2==1 else fmod(n+n+n-k,mod)
return fmod(k-n-n-n,mod)
n,m,p = [int(i) for i in input().split()]
if 1==p or 1==m:print(0)
elif n+2<=m:print((fmod(n+2,p)-1+p)%p)
else:print((ffmod(m,n+2-m,p)+p-1)%p)
E
题目描述
给一个 2 × N 2\times N 2×N的矩形格子，问不重复的走遍一共有多少种方法。必须挨个走，对角线也可。
解法
显然是个 D P DP DP。参考这里。我的想法似乎会导致一个 O ( N 2 ) O(N^2) O(N2)的算法，所以懒得想了。
F
题目描述
在一行棋盘上放字母，形成LOL者获胜
解法
显然是一个博弈的题目，因此用自顶向下的 D P DP DP实现即可。题目给定的星号数量不超过14，而 3 14 3^{14} 314不超过500万，因此可以用三进制数来表示当前局面。然后注意胜平负的返回规则即可。
标程
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
typedef vector<int> vi;
int const SIZE = 4783000; // 3^14多一点
int const WINE = 1;
int const LOST = 2;
int const DRAW = 4;
int const I2L[] = {'*','L','O'};
int L2I[256];
int const ANS[] = {0,1,-1,0,0};
int POW[16] = {1,3,9};
int D[SIZE];
vi PosOfStar; // 记录*号的位置
char A[23];
int N; // 字符串的长度
//解码，得到字符串
void decode(int code,char a[]){
for(int i=0;A[i];++i){
if(A[i]!='*') a[i] = A[i];
else a[i]=I2L[code%3],code/=3;
}
}
//编码
int encode(char const a[]){
int ret = 0;
for(vi::const_iterator it=PosOfStar.begin(),eit=PosOfStar.end();it!=eit;++it){
ret = ret * 3 + a[*it];
}
return ret;
}
int dp(int code){
if(D[code]) return D[code];
char a[23];
decode(code,a); // 解出当前局面
int ret = 0;
for(int i=0,n=PosOfStar.size();i<n;++i){
int p = PosOfStar[i];
if(a[p]!='*') continue;
/// 检查是否能赢
if(0<p&&p<N-1&&'L'==a[p-1]&&'L'==a[p+1]) return D[code] = WINE;
if(p<N-2&&'O'==a[p+1]&&'L'==a[p+2]) return D[code] = WINE;
if(2<=p&&'L'==a[p-2]&&'O'==a[p-1]) return D[code] = WINE;
/// 放L
a[p] = 'L';
ret |= dp(code+POW[i]*L2I['L']);
a[p] = '*';
if(ret&LOST) return D[code] = WINE; //对方输了我就赢了
/// 放O
a[p] = 'O';
ret |= dp(code+POW[i]*L2I['O']);
a[p] = '*';
if(ret&LOST) return D[code] = WINE;
}
return D[code] = ret ? ((ret&DRAW) ? DRAW : LOST) : DRAW;
}
void solute(){
L2I['*'] = 0, L2I['L'] = 1, L2I['O'] = 2;
for(int i=2;i<=14;++i) POW[i] = POW[i-1] * 3;
int nofkase;
scanf("%d",&nofkase);
while(nofkase--){
memset(D,0,sizeof(D));
PosOfStar.clear();
scanf("%s", A);
for(N=0;A[N];++N){
if('*'==A[N]){
PosOfStar.pb(N);
}
}
printf("%d\n",ANS[dp(0)]);
}
}
int main(){
//freopen("1.txt","r",stdin);
solute();
return 0;
}
G
题目描述
签到题，给定字符串，统计字母数量
标程
# encoding=tuf-8
from collections import Counter
from math import *
import sys
sys.setrecursionlimit(10 ** 6)
def solute():
s = input()
if len(s)>1000: raise Exception('xx')
cn = Counter(s)
ansk, ansv = 0, 0
for k, v in cn.most_common():
if v > ansv or (v==ansv and k<ansk): ansk, ansv = k, v
print(ansk)
print(ansv)
if __name__ == '__main__':
# sys.stdin = open("1.txt","r")
solute()
H
题目描述
一种无聊的扑克牌游戏。双方轮流放牌，如果有一样点数的牌，就把这之间的牌收归己有。一方无牌则输。
解法
规模不大，直接模拟。原题提示游戏可能会死循环，但原题样例其实并没有这种情况。加了一组能够死循环的样例，所以需要进行局面判断，否则会T一个点。这个样例也非常简单，4张一样的牌，各拿两张，开始游戏即可。
局面判断用了字符串hash以及STL的pair和set。不过下面的代码是有bug的，因为判断局面时需要考虑table，而此代码没有考虑，也懒得更改了。因为也想不出这样的测试点。
标程
#include <bits/stdc++.h>
using namespace std;
#define mp make_pair
typedef pair<int,int> pii;
typedef set<pii> spii;
unsigned int BKDRHash(string const&s){
unsigned int seed = 131; // 31 131 1313 13131 131313 etc..
unsigned int hash = 0;
for(string::const_iterator it=s.begin(),eit=s.end();it!=eit;++it){
hash = hash * seed + *it;
}
return (hash & 0x7FFFFFFF);
}
spii Set;
void solute(){
Set.clear();
string a,b;
cin>>a>>b;
string table;
char cur;
while(1){
// a走，a在前
if(Set.find(mp(BKDRHash(a),BKDRHash(b)))!=Set.end()){
cout<<-1<<endl;
break;
}
Set.insert(mp(BKDRHash(a),BKDRHash(b)));
LA:
// a走一步
cur = a[0];a.erase(a.begin());
// 检查table中是否有cur
string::iterator it = find(table.begin(),table.end(),cur);
if(it!=table.end()){
a.push_back(cur);
reverse_copy(it,table.end(),back_inserter(a));
table.erase(it,table.end());
goto LA;//a继续
}else if(a.empty()){ //a输了
cout<<b<<endl;
break;
}
table.insert(table.end(),cur);
//检查是否有重复
if(Set.find(mp(BKDRHash(b),BKDRHash(a)))!=Set.end()){
cout<<-1<<endl;
break;
}
Set.insert(mp(BKDRHash(b),BKDRHash(a)));
LB:
//b走
cur = b[0];b.erase(b.begin());
it = find(table.begin(),table.end(),cur);
if(it!=table.end()){
b.push_back(cur);
reverse_copy(it,table.end(),back_inserter(b));
table.erase(it,table.end());
goto LB;//a继续
}else if(b.empty()){ //b输了
cout<<a<<endl;
break;
}
table.insert(table.end(),cur);
}
}
int main(){
// freopen("1.txt","r",stdin);
solute();
return 0;
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
