操作

description

有n堆石子，每堆石子都有一定的数量，第i堆石子的数量用Ai表示。

任意两堆石子均可合并，一堆石子也可 以分成两堆非空的石子。

一次合并或一次分裂都算一次操作。

经过若干次操作以后，石子还剩m堆，告诉你m堆石子的数量Bi，问至少经历了几次操作。

Input

多组数据，第一行一个正整数T表示数据组数，对于每组数据：

第一行，首先一个数n，接下来是n个正整数表示A1~An。

第二行，首先一个数m，接下来是m个正整数表示B1~Bm。

保证A数组的和等于B数组的和。

Output

每组数据一个整数，表示至少经历了多少次操作，保证答案在int范围之内。

Example

standard input

1

1 6

3 1 2 3

standard output

2

Note

对于100%的数据，1 ≤ n,m ≤ 10，1 ≤ Ai,Bi ≤ 50，1 ≤ T ≤ 5

solution

法一：搜索加剪枝，上限是$O(n^n)$，但肯定跑不满

法二：状压$DP$

合并某些$A$中的数，然后再拆成$B$中的某些数

可以把这样的操作看成合并某些$A$中的数和某些$B$中的数，使之和相等即可

显然，最坏的操作上界是$A,B$都合成只剩一个数，$n-1+m-1=n+m-2$次操作

但是每当有一段$A$的合成数和$B$的一段合成数相同时，$A,B$就可以不再跟其它的数合并

$A,B$的操作数都减少$1$，一共减少了$2$次总操作数

也就是说，一段和相同，就会减少$2$次操作，而我们则想要和相同的段数越多越好

可以把$B$中的数取反合在$A$后面，和相同也就变成了求和等于$0$

设$f_i:$ 操作了$i$集合的数的最多段数，$su{m}_i:$ 选的$i$集合的数的和，如果为$0$，那么$f_i$则$+1$

最后的$f_{(1<<(n+m)-1)}$肯定会$+1$，但是这个多余贡献是不会减少总操作数的

code

#include <cstdio>
#include <iostream>
using namespace std;
int T, n, m;
int A[25], f[1 << 20], sum[1 << 20];int lowbit( int x ) {return x & ( -x );
}int main() {scanf( "%d", &T );while( T -- ) {scanf( "%d", &n );for( int i = 1;i <= n;i ++ )scanf( "%d", &A[i] );scanf( "%d", &m );for( int i = 1;i <= m;i ++ )scanf( "%d", &A[i + n] ), A[i + n] = - A[i + n];n += m, m = 1 << n, f[0] = 0;for( int i = 1;i < m;i ++ ) {sum[i] = 0, f[i] = 0;for( int j = 1;j <= n;j ++ )if( 1 << j - 1 & i ) {sum[i] = sum[i ^ ( 1 << j - 1 )] + A[j];f[i] = max( f[i ^ ( 1 << j - 1 )] + ( sum[i] == 0 ), f[i] );}}printf( "%d\n", n - 2 - ( f[m - 1] - 1 << 1 ) );}return 0;
}

异或

description

N 个数字，要求选择 M 次，每次从 N 个数中选出两个数(Ai,Aj)(但不能和之前某次选择 相同)

此次选择的得分为 Ai xor Aj。 求最大得分。

Input

第一行包含两个整数 N,M 接下来一行共 N 个整数描述 N 个数字。

Output

输出一个整数，表示最大得分除以 10^9+7 的余数

Example

Standard input

3 2

1 2 3

Standard output

5

Note

对于 100%的测试数据，N≤50000，0≤Ai≤10^9

solution

• 二分第$M$大的值$x$，check异或和大于等于$x$的个数

  • 建字典树，每个点记录经过其的个数$cnt$

  • 对每个$a_i$进行字典树查找，显然想要大于等于$x$就尽可能异或出现$1$

    $a_i$的$j$位为$1(0)$，那么就去字典树$now$的$0(1)$端的点找

    • 如果存在，必定会出现$1<<j$的贡献，加上之前路径上的贡献（记为$sum$)
      • 如果已经大于等于$x$，则直接加上该点的$cnt$，不用继续往下搜了
      • 如果还不够，$sum$累加该位贡献，继续下一位的搜索
    • 如果不存在，那么就只能放弃$j$位的贡献
      • 如果现在的$sum$加上假设后面位全为$1$的贡献和$(1<<j)-1$都不够，也不用搜了(不可能)
      • 否则，还是继续下一位的搜索

  • 为了卡常不$T$，字典树应只建一次在二分外面，那么就会造成统计大于等于$x$的异或个数时$(x,y),(y,x)$都被计算进入，所以真正的个数应该是要除以$2$的

• 然后我们就确定了第$M$大的值$x$

  大于等于$x$的个数可能多于$M$个，最后的答案会涉及减去多余个数乘$x$的贡献

  多余个数的值一定是$x$，不然第$M$大就不可能是$x$

  第$M$大是$x$，意味着大于等于$x+1$的异或组合小于$M$个

• 最后就只剩下求值的问题了

  • 枚举$a_i$，边重构字典树边计算答案值和真正的个数，这样就不需要除以$2$了

  • 走法与上面同理

  • 怎么在计算$cnt$的同时计算$ans$，在确定不用继续往下搜的情况那里统计即可

    字典树重构时，开一个数组$on{e}_i:$ 经过该点的第$i$位为$1$的个数

    统计时，枚举位$j$，如果位$j$要产生$1<<j$的贡献，显然数要与$a_i$的$j$位不同才行

    • $a_i$的$j$位为$1$，则应该为$cnt-on{e}_j$的个数
    • $a_i$的$j$位为$0$，则就是$on{e}_j$的个数

code

#include <cstdio>
#include <iostream>
using namespace std;
#define mod 1000000007
#define maxn 50005
struct node {int cnt;int son[2], one[30];
}t[maxn * 29];
int n, m, tot, mid;
long long cnt, ans;
int digit[30], a[maxn];void read( int &x ) {x = 0; char s = getchar();while( s < '0' || s > '9' ) s = getchar();while( '0' <= s && s <= '9' ) {x = ( x << 1 ) + ( x << 3 ) + ( s ^ 48 );s = getchar();}
}long long dfs_cnt( int now, int d, int sum, int x ) {if( d < 0 ) return 0;long long num = 0;int k = x >> d & 1;if( t[now].son[k ^ 1] ) {if( sum + ( 1 << d ) >= mid ) num += t[t[now].son[k ^ 1]].cnt;else num += dfs_cnt( t[now].son[k ^ 1], d - 1, sum + ( 1 << d ), x );}if( t[now].son[k] && sum + ( 1 << d ) - 1 >= mid ) num += dfs_cnt( t[now].son[k], d - 1, sum, x );return num;
}long long calc() {long long num = 0;for( int i = 1;i <= n;i ++ )num += dfs_cnt( 0, 29, 0, a[i] );return ( num >> 1 );
}void add( int now, int x ) {for( int i = 29;~ i;i -- ) {int k = ( x >> i & 1 ) ^ 1;if( k ) ans = ( ans + ( 1ll << i ) * t[now].one[i] ) % mod;else ans = ( ans + ( 1ll << i ) * ( t[now].cnt - t[now].one[i] ) ) % mod;}
}long long dfs_sum( int now, int d, int sum, int x ) {if( d < 0 ) return 0;long long num = 0;int k = x >> d & 1;if( t[now].son[k ^ 1] ) {if( sum + ( 1 << d ) >= mid ) add( t[now].son[k ^ 1], x ), num += t[t[now].son[k ^ 1]].cnt;else num += dfs_sum( t[now].son[k ^ 1], d - 1, sum + ( 1 << d ), x );}if( t[now].son[k] && sum + ( 1 << d ) - 1 >= mid ) num += dfs_sum( t[now].son[k], d - 1, sum, x );return num;
}void solve() {for( int i = 0;i <= tot;i ++ )t[i].cnt = t[i].son[0] = t[i].son[1] = 0;tot = 0;for( int i = 1;i <= n;i ++ ) {int len = 0;for( int j = 29;~ j;j -- )if( a[i] >> j & 1 ) digit[++ len] = j;int now = 0;for( int j = 29;~ j;j -- ) {int c = a[i] >> j & 1;if( ! t[now].son[c] ) t[now].son[c] = ++ tot;now = t[now].son[c];t[now].cnt ++;for( int k = 1;k <= len;k ++ )t[now].one[digit[k]] ++;}cnt += dfs_sum( 0, 29, 0, a[i] );}
}int main() {read( n ), read( m );for( int i = 1;i <= n;i ++ ) {read( a[i] );int now = 0;for( int j = 29;~ j;j -- ) {int c = a[i] >> j & 1;if( ! t[now].son[c] ) t[now].son[c] = ++ tot;now = t[now].son[c];t[now].cnt ++;}}int l = 1, r = ( 1 << 30 ) - 1, val = 1;while( l <= r ) {mid = ( l + r ) >> 1;if( calc() >= m ) val = mid, l = mid + 1;else r = mid - 1;}mid = val;solve();printf( "%lld\n", ( ans - 1ll * val * max( 0ll, cnt - m ) % mod + mod ) % mod );return 0;
}

等级

description

数组A中有n个数，下标从1开始。

如果数组中某一段满足其中的所有元素可以组成一个公差为k的等差数 列，则这一段具备k的等级。

需要注意的是，一个数可以算作公差为任意整数的等差数列。

现在有m个操作，分为两类：

1 X Y: 表示X位置的数变成Y

2 L R K: 表示查询[L,R]是否 等级为k。

Input

第一行两个正整数n,m。 第二行n个非负整数Ai。 接下来m行每一行表示一个操作，格式上文已给出。

强制在线：在本题中x,y,l,r都是经过加密的，需要异或你之前输出的Yes的个数来进行解密。

由于输入量较大，建议使用快读。

Output

对于每个操作2，输出一行，”Yes”表示可以达到等级K，”No”表示不可以。

Example

standard input

5 3

1 3 2 5 6

2 1 5 1

1 5 4

2 1 5 1

standard output

No

Yes

Note

对于100%的数据，1 ≤ n,m ≤ 300000，0 ≤ Ai,y ≤ 10^9，1 ≤ l ≤ r ≤ n，1 ≤ x ≤ n，0 ≤ k ≤ 10^9

solution

法一：长达$7k$的无脑码农题

• 线段树维护区间最大值
• 线段树维护区间最小值
• 线段树维护区间是否重复——set/map离散化
• 线段树维护区间差的$gcd$
• 如果是等差数列公差为$k$，必然满足
  • 最大值$-$最小值$=(r-l)\ast k$
  • 区间无重复
  • $gcd=k$

法二：数学真是太强了！

既然是等差数列，则必定满足等差数列的一次方和，二次方和$...$高次方和的多个公式

显然可以线段树维护区间的一次方和，二次方和$...$

判断是否跟公式一一符合即可

至于能否被卡，显然是次方维护越多就越难被卡掉

窃以为到三次方就唯一确定是否是等差数列了

不过本题只用维护到平方和即可

具体公式推导可详见博主置顶数学公式证明博文，Thanks♪(･ω･)ﾉ

code

#include <cstdio>
#include <iostream>
using namespace std;
#define inf 0x7f7f7f7f
#define int long long
#define maxn 300005
struct node {int Min, Max, sum1, sum2;
}t[maxn << 2];
int n, m;
int a[maxn];void read( int &x ) {x = 0; char s = getchar();while( s < '0' || s > '9' ) s = getchar();while( '0' <= s && s <= '9' ) {x = ( x << 1 ) + ( x << 3 ) + ( s ^ 48 );s = getchar();}
}void merge( node &t, node x, node y ) {t.Max = max( x.Max, y.Max );t.Min = min( x.Min, y.Min );t.sum1 = x.sum1 + y.sum1;t.sum2 = x.sum2 + y.sum2;
}void build( int num, int l, int r ) {if( l == r ) {t[num].Max = t[num].Min = t[num].sum1 = a[l];t[num].sum2 = a[l] * a[l];return;}int mid = ( l + r ) >> 1;build( num << 1, l, mid );build( num << 1 | 1, mid + 1, r );merge( t[num], t[num << 1], t[num << 1 | 1] );
}void modify( int num, int l, int r, int pos ) {if( l == r ) {t[num].Max = t[num].Min = t[num].sum1 = a[l];t[num].sum2 = a[l] * a[l];return;}int mid = ( l + r ) >> 1;if( pos <= mid ) modify( num << 1, l, mid, pos );else modify( num << 1 | 1, mid + 1, r, pos );merge( t[num], t[num << 1], t[num << 1 | 1] );
}node query( int num, int l, int r, int L, int R ) {if( L <= l && r <= R ) return t[num];int mid = ( l + r ) >> 1;node ans = { inf, -inf, 0, 0 };if( L <= mid ) merge( ans, ans, query( num << 1, l, mid, L, R ) );if( mid < R ) merge( ans, ans, query( num << 1 | 1, mid + 1, r, L, R ) );return ans;
}signed main() {scanf( "%lld %lld", &n, &m );for( int i = 1;i <= n;i ++ )scanf( "%lld", &a[i] );build( 1, 1, n );int opt, x, y, l, r, k, cnt = 0;while( m -- ) {scanf( "%lld", &opt );if( opt & 1 ) {scanf( "%lld %lld", &x, &y );x ^= cnt, y ^= cnt;if( a[x] == y ) continue;else a[x] = y; modify( 1, 1, n, x );}else {scanf( "%lld %lld %lld", &l, &r, &k );l ^= cnt, r ^= cnt;node MS = query( 1, 1, n, l, r );if( MS.Max - MS.Min != ( r - l ) * k ) {printf( "No\n" );continue;}int N = r - l + 1, a = MS.Min;if( N * a + N * ( N - 1 ) / 2 * k != MS.sum1 ) {printf( "No\n" );continue;}if( N * a * a + N * ( N - 1 ) * k * a + ( N - 1 ) * N * ( 2 * N - 1 ) / 6 * k * k != MS.sum2 ) {printf( "No\n" );continue;}cnt ++;printf( "Yes\n" );}}return 0;
}

矩阵

description

有一个$n\ast n$的01矩阵，当它每一行、每一列都恰好有两个位置是1的时候，称为配对矩阵

请问从$1\ast 1$到$n\ast n$的所有01矩阵中有多少矩阵为配对矩阵。

设 f[i]表示边长为i的配对矩阵的个数，即询问：${\sum }_{i=1}^n{f}_i$

Input

第一行一个正整数n。

Output

一行一个整数表示所求答案模上998244353的值。

Example

standard input

2

standard output

1

样例解释：唯一的矩阵是 n=2，所有位置都是1的矩阵。

Note

对于100%的数据，1 ≤ n ≤ 10^7

solution

法一：王者打表前七个，找规律猜出$DP$转移方程

法二：正常人的推理

转换题意为：

• 有$1\times n$的序列 $\to$ 一共有$n$列
• 一共$n$次操作 $\to$ $n$行
• 第$i$次选两个格子进行操作$+1\to$ 第$i$行选择两个$1$的列位置
• 每一列$1$的位置 $\to$ 两次顺序操作$i,j$选择了该位置
• 最后使得每个格子的数都恰好是$2$

也就是说，如果第$i$次操作选择了$j,k$意味着第$i$行的$j,k$列为$1$，第$j,k$列的其中有个$1$是在$i$行

$f_i$定义不变，$g_i:$ 长度序列为$i$已经进行了一次操作(已经有两个位置为$1$，剩下$i-1$次操作)的方案数

• $f_i$的转移

  • $f_{i-2}\times (i-1)\times C_i^2$，两次操作都选择同样的两个格子

    • 那么两次操作顺序不会造成影响，是等价的，所以是在$i$次操作中任选两次操作$C_i^2$
    • 剩下$i-2$长度的空序列$f_{i-2}$
    • 考虑新增行的位置(随便考虑一个位置固定也行)是一定要填的，剩下的有$C_{i-1}^i=(i-1)$种选择

    

  • $g_{i-1}\times C_{i-1}^2\times A_i^2$，两次操作格子不同

    • 剩下$i-1$长度序列且有两个已经为$1$，$g_{i-1}$

    • 与固定新增块相连的两个块随便选，$C_{i-1}^2$

    • 在$i$次操作中选两次操作，操作顺序不同，是不等价的，$A_i^2$

      

• $g_i$的转移

  • $f_{i-2}\times (i-1)$，直接进行一次两个$1$位置的操作

    • 剩下$i-2$长度的空序列，$f_{i-2}$

    • $(i-1)$次操作中，进行一次操作，$C_{i-1}^1=i-1$

      

  • $f_{i-3}\times (i-2)\times A_{i-1}^2$，两个操作额外选的位置相同

    • 剩下$i-3$长度的空序列，$f_{i-3}$

    • 额外配对位置选择有$(i-2)$

    • $i-1$次操作中，两个操作的顺序不同结果不同，$A_{i-2}^2$

      

  • $g_{i-2}\times A_{i-2}^2\times A_{i-1}^2$，各自选的格子互不相同

    • 剩下$i-2$长度且已有两个格子为$1$的序列，$g_{i-2}$

    • 两个格子选择不同结果不同，与原两个格子的配对顺序也不同，$A_{i-2}^2$

    • $i-2$次操作中，两个操作的顺序不同结果不同，$A_{i-2}^2$

      

code

#include <cstdio>
#define int long long
#define maxn 10000005
#define mod 998244353
int f[maxn], g[maxn];
int n, ans;int C( int x ) {return x * ( x - 1 ) / 2 % mod;
}int A( int x ) {return x * ( x - 1 ) % mod;
}signed main() {scanf( "%lld", &n );f[0] = f[2] = g[2] = ans = 1;for( int i = 3;i <= n;i ++ ) {f[i] = ( f[i] + f[i - 2] * ( i - 1 ) % mod * C( i ) ) % mod;f[i] = ( f[i] + g[i - 1] * C( i - 1 ) % mod * A( i ) ) % mod; g[i] = ( g[i] + f[i - 2] * ( i - 1 ) ) % mod;g[i] = ( g[i] + f[i - 3] * ( i - 2 ) % mod * A( i - 1 ) ) % mod;g[i] = ( g[i] + g[i - 2] * A( i - 2 ) % mod * A( i - 1 ) ) % mod;ans = ( ans + f[i] ) % mod;}printf( "%lld\n", ans );return 0;
}