【2020牛客NOIP赛前集训营-提高组（第一场）题解】（ 牛牛的方程式，牛牛的猜球游戏，牛牛的凑数游戏，牛牛的RPG游戏）
T1：牛牛的方程式
title
solution
因为浮点错误炸了70pts
这个三元一次不定方程呢，其实也没有特别难
只需要在二元一次不定方程\(Ax+By=C\)上面略作变化即可！
将其转化为二元一次不定方程，假设\(c，z\)为已知量
此时可以直接套用\(exgcd\)解出\(Ax+By=1……③\)的特殊值\(x,y\)
我们知道\(exgcd\)的有解要保证\(gcd(A,B)|C\)
即对于方程②而言，要求\(gcd(a,b)|(d-cz)\)
那么我们可以巧妙通过这一个限制，来检验\(z\)是否为整数
在代码中就是一句\(if\)判断
if( ( d - c ) % gcd( a, b ) == 0 ) YES;
但是！！！
别忘记，\(a,b,c,d,x,y,z\)都可以是\(0\)
就是这个\(0\)的原因，导致了爷的浮点错误
所以，赛后，化身诸葛亮，直接\(if-else\)选择结构大师上线
①：\(d=0\)，此时\(x=y=z=0\)是一组解，\(YES\)
②：\(d≠0,a=b=c=0\)，\(x,y,z\)无解，\(NO\)
③：\(a,b,c\)有且只有一个为\(0\)，假设为\(T\)，则直接判断\(T|d\)
能整除，\(YES\)，否则，\(NO\)
④：\(a,b,c\)有且只有两个为\(0\)，假设为\(S,T\)
该情况即为一般形式的\(Ax+By=C\)，\(exgcd\)直接搞就van事
⑤：\(a\times b\times c≠0\)
这个情况什么意思呢？就是在上面三元一次转二元一次最后判断\(z\)是否有解的时候
\(z\)可能等于\(0\)，那么就需要满足\(gcd(a,b)|d\)即可
具体详见代码——
code
#include <cstdio>
#include <iostream>
using namespace std;
#define ll long long
void exgcd( ll a, ll b, ll &d, ll &x, ll &y ) {
if( ! b ) d = a, x = 1, y = 0;
else {
exgcd( b, a % b, d, y, x );
y -= x * ( a / b );
}
}
int main() {
int T;
ll a, b, c, d;
scanf( "%d", &T );
while( T -- ) {
scanf( "%lld %lld %lld %lld", &a, &b, &c, &d );
if( ! d ) {
printf( "YES\n" );
continue;
}
if( ! a && ! b && ! c ) {
printf( "NO\n" );
continue;
}
if( ! a && ! b ) {
if( d % c ) printf( "NO\n" );
else printf( "YES\n" );
continue;
}
if( ! a && ! c ) {
if( d % b ) printf( "NO\n" );
else printf( "YES\n" );
continue;
}
if( ! b && ! c ) {
if( d % a ) printf( "NO\n" );
else printf( "YES\n" );
continue;
}
bool flag = 1;
ll gcd, x, y;
exgcd( max( a, b ), min( a, b ), gcd, x, y );
if( a && b && ( d % gcd == 0 || ( d - c ) % gcd == 0 ) ) flag = 0;
exgcd( max( a, c ), min( a, c ), gcd, x, y );
if( a && c && ( d % gcd == 0 || ( d - b ) % gcd == 0 ) ) flag = 0;
exgcd( max( b, c ), min( b, c ), gcd, x, y );
if( b && c && ( d % gcd == 0 || ( d - a ) % gcd == 0 ) ) flag = 0;
if( ! flag ) printf( "YES\n" );
else printf( "NO\n" );
}
return 0;
}
T2：牛牛的猜数游戏
title
solution
这道题刚开始做的时候，真的没想到怎么做，就敲了个暴力30pts，后两道做不动的时候，又跑回来康康，这一瞅不得了，直接干翻这道题
分享一下我的心路历程吧
看到一个区间\([l,r]\)的时候，脑海里常见的套路就应该出来
·线段树、树状数组
·差分\(S(r)-S(l-1)\)，时常伴随着从小到大排序操作
此题也不例外，我第一眼就往差分上面靠
企图通过\(S(r)-S(l-1)\)再排序搭配树状数组，线性求解
用\(map，hash\)保存杯子的排列
但是不出十秒，我就把自己扼杀在摇篮里了
因为这个杯子之间的排列似乎不支持减法直接求解
此时最明智的方法——暴力跑路
过了一个小时后，回来，就突然——心灵感应吧，我就觉得这道题在诱惑未成年犯罪
题面全身上下都充斥了——“我很简单，快来做我”
我一直没有放下差分的想法，我认为差分是肯定可以的！
于是，我开始手玩一波数据，\(l-1\)，\(r\)的杯子排列方式进行对比
惊奇发现，这个差分似乎可以从下标方面入手！！我不应该执着于具体的球不放
假设操作到\(l-1\)后的情况：\(1,5,3,2,4\)
然后操作到\(r\)后的情况：\(2,3,4,5,1\)
看似没啥关联，实则暗藏玄机——抛开对实际的球的执念
发现对于\(l-1\)的第一个位置的球不管是不是\(1\)，在\(r\)的时候都会出现在最后一个位置上！！
所以！！只需要线性跑\([1,i]\)操作后的球的排列
然后对于每一次查询\([l,r]\)，就去找\(l-1,r\)之间的对应关系，将其应用在最初始的有序排列上
不就刚好相当于把\([1,l-1]\)之间的交换操作影响去掉了吗
code
#include <cstdio>
#include <iostream>
using namespace std;
#define MAXN 100005
struct node {
int l, r;
}opt[MAXN], query[MAXN];
int n, m, cnt;
int base[15], p[15];
int f[MAXN][15];
int main() {
scanf( "%d %d", &n, &m );
for( int i = 1;i <= n;i ++ )
scanf( "%d %d", &opt[i].l, &opt[i].r );
for( int i = 1, l, r;i <= m;i ++ )
scanf( "%d %d", &query[i].l, &query[i].r );
for( int i = 0;i <= 9;i ++ )
f[0][i] = base[i] = i;
for( int i = 1;i <= n;i ++ ) {
swap( base[opt[i].l], base[opt[i].r] );
for( int j = 0;j <= 9;j ++ )
f[i][j] = base[j];
}
for( int i = 1;i <= m;i ++ ) {
int l = query[i].l, r = query[i].r;
for( int j = 0;j <= 9;j ++ )
for( int k = 0;k <= 9;k ++ )
if( f[l - 1][j] == f[r][k] ) {
p[k] = j;
break;
}
for( int j = 0;j < 9;j ++ )
printf( "%d ", p[j] );
printf( "%d\n", p[9] );
}
return 0;
}
T3：牛牛的凑数游戏
title
solution
一. 首先10pts的暴力，肯定是基本功过硬，前缀和能拿到
暴力yyds！！
二. 比赛时，我对【输入的\(a_i\)为\(2\)的非负整数幂】这个暴力分有很大的想法
因为每个数都有对应的二进制，意思就是如果\(2\)的每一个幂都被包含在区间里的话，每两个幂之间的数都可以被凑出来
但是我发现自己的时间复杂度\(O(n^2logn)\)
牛客的出题人真的蛮良心的了，这两个部分分的思路组合起来，差不多就是正解那个方向了
通过第一个暴力的前缀和可得
\([1,i]\)的\(a\)值和\(+1\)如果小于\(a_{i+1}\)，那么\((\sum_{i=1}^ia_i )+1\)肯定是凑不出来的
所以我们进行以下操作
假设上一个可能答案是\(last\)，且小于等于\(last\)的所有数都能被凑出来
求和所有\(a[i]\le last\)，记为\(S\)
下一个可能答案\(sum=last+1\)，求和所有\(a[i]\le sum\)，记为\(T\)
如果\(S=T\)，则表明\(sum\)无法被凑出来
每一次都把\(T\)置为上一次的答案\(last=T,sum=last+1\)
发现\(sum\)的取值是不断增大的，\(log\)级别
（可能你懵了，但是没瓜系，直接看代码一下子就懂了！）
可以采取可持久化\(trie\)树，把\(a_i\)拆分成二进制存储
code
#include <cstdio>
#define ll long long
#define MAX 1000000000
#define MAXN 100005
struct node {
int l, r;
ll sum;
}trie[MAXN * 40];
int n, m, cnt;
int root[MAXN], bit[40];
ll a[MAXN];
void hex( ll x ) {
if( x > MAX ) x = MAX + 1;//a[i]<=1000000000，x只是用来查询所有<=x的a值和，所以不用设得特别大
for( int i = 30;~ i;i -- ) bit[i] = ( x >> i ) & 1;
}
void insert( int &now, int pre, int id, int w ) {
trie[now = ++ cnt] = trie[pre];
if( id < 0 ) { trie[now].sum += w; return; }
if( ! bit[id] ) insert( trie[now].l, trie[pre].l, id - 1, w );
else insert( trie[now].r, trie[pre].r, id - 1, w );
trie[now].sum = trie[trie[now].l].sum + trie[trie[now].r].sum;
}
ll query( int now, int id ) {
if( id < 0 || ! now ) return trie[now].sum;
if( ! bit[id] ) return query( trie[now].l, id - 1 );
else return trie[trie[now].l].sum + query( trie[now].r, id - 1 );
}
int main() {
scanf( "%d %d", &n, &m );
for( int i = 1;i <= n;i ++ ) {
scanf( "%lld", &a[i] );
hex( a[i] );
insert( root[i], root[i - 1], 30, a[i] );
}
for( int i = 1, l, r;i <= m;i ++ ) {
scanf( "%d %d", &l, &r );
ll last = 0, ans = 1;
while( 1 ) {
hex( ans );
ll tmp = query( root[r], 30 ) - query( root[l - 1], 30 );
if( tmp == last ) { printf( "%lld\n", ans ); break; }
last = tmp, ans = tmp + 1;
}
}
return 0;
}
