10.15模拟赛

10.15 模拟赛

原题场。

A 石子

暑假，概率与期望ppt中的经典例题的一道题。。

考虑令 $ x_i $ 表示第 $ i $ 堆石头在第几次被取。那么有

$ x_1 = sum_i{ [x_i leq x_1] } = 1 + sum_i{[x_i < x_1]} $

两边同时套一个期望，由期望的线性性

$ E(x_i) = 1 + sum_iE([x_i < x_1]) = 1 + sum_i{P([x_i < x_1])} $

然后求的就是第 $ i $ 堆石头比第一堆石头先取的概率。

这个可以感性理解一下，我们要么先取第一堆石头要么先去第 $ i $ 堆石头，其他堆的石头貌似一点作用也没有，因为取了其他的石头不影响这两堆的先后顺序。所以其实概率就是只有两堆石头，随机取，取到 $ i $ 堆的概率，就是 $ frac{a_i}{a_1 + a_i} $

对这个求和就好了。

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<vector>
#include<queue>
#include<stack>
#include<bitset>
#include<set>
using namespace std;
//#define int long long
typedef long long ll;
#define MAXN 200006 
#define MAXM 450
#define pb push_back
#define pii pair<int,int>
#define fi first
#define se second
#define mp make_pair
#define inf 0x3f3f3f3f
#define cmx( a , b ) a = max( a , b )
#define cmn( a , b ) a = min( a , b )
#define upd( a , b ) ( a = ( a + b ) % P )
//#define P 1000000007
int n;
int a[MAXN];
void read( signed& x ) {
	scanf("%d",&x);
}
void read( ll& x ) {
	scanf("%lld",&x);
}
long double res = 0.0;
int main() {
	read( n );
	for( int i = 1 ; i <= n ; ++ i ) {
		read( a[i] );
		if( i != 1 ) res += ( long double ) a[i] / ( a[i] + a[1] );
	}
	res += 1.0;
	printf("%.8Lf",res);
}

/*
 * Things you should pay attention to
 * inf is big enough?
 * out of bounds?
 * long long ?
 */

B 内存

首先，$ O( nmlog ) $ 的做法都会，就是枚举一下增加的数，然后二分判断就好了。

但是如何优化这个东西呢？可以考虑给增加的数字 $ (1 , m-1) $ 随机打乱，每次如果无法使当前答案更优秀就不继续选了。

为啥这样很优秀呢？我们假设对于新循环到的一个数 $ x $ ，新的这个数字比所有当前的数字都小的概率只有 $ frac{1}{i} $，所以最后期望只会跑 $ ln(n) $ 次二分check，总复杂度是 $ O(nm) $

其实这个结论挺可推广的呢！

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<vector>
#include<queue>
#include<stack>
#include<bitset>
#include<set>
using namespace std;
//#define int long long
typedef long long ll;
#define MAXN 200006 
#define MAXM 450
#define pb push_back
#define pii pair<int,int>
#define fi first
#define se second
#define mp make_pair
#define inf 0x3f3f3f3f
#define cmx( a , b ) a = max( a , b )
#define cmn( a , b ) a = min( a , b )
#define upd( a , b ) ( a = ( a + b ) % P )
//#define P 1000000007

int n , m , k , blo;
int A[MAXN] , S[MAXN] , smid[MAXN];
void read( signed& x ) {
	scanf("%d",&x);
}
void read( ll& x ) {
	scanf("%lld",&x);
}
int a[MAXN];
bool chk( int x ) {
	int cur = 0 , kel = 0;
	for( int i = 1 ; i <= n ; ++ i ) {
		if( a[i] > x ) return false;
		if( cur + a[i] > x ) cur = a[i] , ++ kel;
		else cur += a[i];
	}
	if( cur ) ++ kel;
	return kel <= k;
}
int P[MAXN];
int main() {
	cin >> n >> m >> k;
	blo = log2( n );
	for( int i = 1 ; i <= n ; ++ i ) read( A[i] ) , a[i] = A[i];
	int l = 0 , r = 1e9;
	while( l <= r ) {
		int mid = l + r >> 1;
		if( chk( mid ) ) r = mid - 1;
		else l = mid + 1;
	}
	int cures = l;
	for( int i = 1 ; i < m ; ++ i ) 
		P[i] = i;
	random_shuffle( P + 1 , P + m );
	for( int i = 1 ; i < m ; ++ i ) {
		int j = P[i];
		for( int i = 1 ; i <= n ; ++ i ) a[i] = ( A[i] + j ) % m;
		if( ! chk( cures - 1 ) ) continue;
		int l = 0 , r = cures - 1;
		while( l <= r ) {
			int mid = l + r >> 1;
			if( chk( mid ) ) r = mid - 1;
			else l = mid + 1;
		}
		cures = l;
	}
	printf("%d
",cures);
}

/*
 * Things you should pay attention to
 * inf is big enough?
 * out of bounds?
 * long long ?
 */

C 子集

如果把 $ n $ 分解质因数，$ n = prod_i p_i^{c_i} $ ，对于每一个素数，必然有至少一个子集中的数不含这个因子，同时也必然有一个子集中的数字含有这个数字的 $ c_i $ 次方。然后就可以考虑容斥了！

正常的容斥是所有情况减去不存在 0 次方的情况， 再去掉不存在 $ c_i $ 的情况，然后加上不存在的情况就好了。

这样的情况数是 $ 4^k $ 的，$ k $ 最大是 16 左右，所以挂掉了。

但是我们注意到 不存在0次方和不存在 $ c_i $ 次方的情况对答案的贡献是一样的！（都少了一个）所以可以 合并考虑。然后复杂度就是 $ 3^k $ 了

怎么质因数分解呢？简单的做法是直接 $ Pollard-Rho $ ，但是我们也可以对 $ 10^6 $ 内的约数给拿出来，$ m $ 最多只有2个大于 $ 10^6 $ 的质数相乘，则 $ m = p , p^2 , pq $ 这三种形式。而且我们不关系分解后究竟是多少，我们只关心每个质数的系数，所以这样就可以了。

死因：Miller-robbin 没龟速乘。。。。

后面还有一个python版本的

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<vector>
#include<queue>
#include<stack>
#include<bitset>
#include<set>
using namespace std;
#define int long long
typedef long long ll;
#define MAXN 200006 
#define MAXM 450
#define pb push_back
#define pii pair<int,int>
#define fi first
#define se second
#define mp make_pair
#define inf 0x3f3f3f3f
#define cmx( a , b ) a = max( a , b )
#define cmn( a , b ) a = min( a , b )
#define upd( a , b ) ( a = ( a + b ) % P )
#define P 998244353
int n;
void read( signed& x ) {
	scanf("%d",&x);
}
void read( ll& x ) {
	scanf("%lld",&x);
}

inline ll mul(ll a,ll b,ll p){
    a %= p; b %= p;
    if(p<=1e9)return 1ll*a*b%p;
    if(p<=1e12)return (((a*(b>>20)%p)<<20)%p+a*(b&(1<<20)-1))%p;
    ll d=1ll*floor(a*(long double)b/p);
	ll res=(a*b-d*p)%p;if(res<0)res += p;
    return res;
}

int power(int x, int a , int p) {
	int cur = x % P , ans = 1;
	while( a ) {
		if( a & 1 ) ans = mul( ans , cur , p );
		cur = mul( cur , cur , p ) , a >>= 1;
	}
	return ans;
}

bool prime(int x) {
	for(int i = 1; i <= 30; i++) {
		int p = 1ll * rand() * rand() % x * rand() % x + 1;
		while(p == x) p = 1ll * rand() * rand() % x * rand() % x + 1;
		if(power(p, x - 1 , x) != 1) return false;
	}
	return true;
}

int val[MAXN], tp , ans = 0;
void dfs(int now, int rev) {
	if(now == tp + 1) {
		int tmp = 1;
		for( int i = 1; i <= tp; i++ ) tmp *= (val[i] + 1), tmp  %= P - 1;
		ans = (ans + rev * (power(2, tmp , P) - 1) ) % P;
		return;
	}
	dfs(now + 1, rev);
	if(val[now] >= 1) -- val[now] , dfs(now + 1, (P - 2) * rev % P), ++ val[now];
	if(val[now] >= 2) val[now] -= 2, dfs(now + 1, rev), val[now] += 2;
}
signed main() {
	srand( 19260817 );
	read( n );
	for(int i = 2 ; i <= 1000000 && n > 1; i++) { // primes lower than 1e6
		if( !( n % i ) ) ++ tp;
		while( !( n % i ) ) val[tp]++ , n /= i;
	}
	if(n > 1) { 
		if( prime(n) ) val[++tp] = 1; // n == prime * ppp
		else if( (int)sqrt(n) * (int)sqrt(n) == n ) val[++tp] = 2; // n == prime * prime * ppp
		else val[ ++tp ] = 1, val[ ++tp ] = 1; // elsewhise, val = 1
	}
	dfs(1, 1);
	cout << ( ans + P ) % P ;
}

/*
 * Things you should pay attention to
 * inf is big enough?
 * out of bounds?
 * long long ?
 */

import random
import math

n = 0
P = 998244353

def power( x , a , p ):
    cur = x % p
    ans = 1
    while( a ):
        if( a & 1 ):
            ans = ans * cur % p
        cur = cur * cur % p
        a >>= 1
    return ans

def prime( x ):
    for i in range( 1 , 31 ): 
        p = random.randint( 1 , x - 1 )
        if( power( p , x - 1 , x ) != 1 ):
            return 0
    return 1

val = []
tp = 0
ans = 0

def dfs( now , rev ):
    global tp , ans , P
    if( now == tp + 1 ):
        tmp = 1
        for i in range( 1 , tp + 1 ):
            tmp = tmp * ( val[i] + 1 ) % ( P - 1 )
        ans = ( ans + rev * ( power( 2 , tmp , P ) - 1 ) ) % P
        return
    dfs( now + 1 , rev )
    if( val[now] >= 1 ):
        val[now] = val[now] - 1
        dfs( now + 1 , ( P - 2 ) * rev % P )
        val[now] = val[now] + 1
    if( val[now] >= 2 ):
        val[now] = val[now] - 2
        dfs( now + 1 , rev )
        val[now] = val[now] + 2
    return

n = int(input())
val.append( 0 )
for i in range( 2 , 1000001 ):
    if( n <= 1 ):
        break
    if( n % i == 0 ):
        tp = tp + 1
        val.append( 0 )
    while( n % i == 0 ):
        val[tp] = val[tp] + 1
        n //= i
if( n > 1 ):
    if( prime( n ) == 1 ):
        tp = tp + 1 
        val.append( 1 )
    else:
        if( int(math.sqrt( n )) * int( math.sqrt( n ) ) == n ):
            tp = tp + 1
            val.append( 2 )
        else:
            tp = tp + 1
            val.append( 1 )
            tp = tp + 1
            val.append( 1 )
dfs( 1 , 1 )
print( ( ans + P ) % P )