总结-辣鸡学长连学弟考试题都不会做

总结-辣鸡学长连学弟考试题都不会做

突然想起来写一写前一段时间做学弟的考试题被虐的的一些总结吧.
之前老张带着队长等三个人去了WC,高二就剩下了我和凤姐在机房.
老张要我那几天给高一的学弟们发他给的题,顺带讲一下.
坑爹的是竟然没有题解?!呃……而且我不会做啊(暴汗)……
于是接下来几天就陷入了死磕std的尴(huan)尬(le)局面……

(时至今日都还没改完这几个题,真是辣鸡啊……)

02.07 T1

题意概述

求$\sum_{i=1}^{n}i^k~mod~1234567891$($1\leq n\leq 10^9$,$1\leq k\leq 100$)

题目分析

这玩意儿叫做自然数幂和问题，其中解法很多,可以参见杜教WC2013的课件.
下面就讲一讲一种,利用二项式定理求解的方法.

二项式定理如下

$$(a+b)^k=\sum_{i=0}^{k}C_k^ia^ib^{k-i}$$

则有

$$(j+1)^{k+1}=\sum_{i=0}^{k+1}C_{k+1}^ij^i$$
$$(j+1)^{k+1}-j^{k+1}=\sum_{i=0}^kC_{k+1}^ij^i$$
将j从1到n求和
$$\sum_{j=1}^{n}(j+1)^{k+1}-j^{k+1}=\sum_{j=1}^{n}\sum_{i=0}^{k}C_{k+1}^ij^i$$
利用差分,则有
$$(n+1)^{k+1}-1^{k+1}=\sum_{j=1}^{n}\sum_{i=0}^{k}C_{k+1}^ij^i$$
对右边的式子求和顺序进行交换
$$(n+1)^{k+1}-1^{k+1}=\sum_{i=0}^{k}C_{k+1}^i\sum_{j=1}^{n}j^i$$
令
$$S_d(n)=\sum_{i=1}^{n}i^d$$
则有
$$(n+1)^{k+1}-1^{k+1}=\sum_{i=0}^{k}C_{k+1}^iS_i(n)$$
$$(n+1)^{k+1}-1^{k+1}=(k+1)*S_k(n)+\sum_{i=0}^{k-1}C_{k+1}^iS_i(n)$$
即
$$(k+1)*S_k(n)=(n+1)^{k+1}-1-\sum_{i=0}^{k-1}C_{k+1}^iS_i(n)$$

从前往后进行递推即可,时间复杂度$O(k^2)$

代码实现

#include<cstdio>
#include<cassert>
#include<iostream>
#include<algorithm>

using namespace std;

typedef long long ll;
const int maxn=100+5;
const ll MOD=1234567891;

ll qpow(ll x,ll y) {
    ll ret=1;
    while(y>0) {
        if(y&1) ret=ret*x%MOD;
        x=x*x%MOD;y>>=1;
    }
    return ret;
}

#define inv(x) qpow(x,MOD-2)

ll C[maxn][maxn],S[maxn];

int main() {
    freopen("sum.in","r",stdin);
    freopen("sum.out","w",stdout);
    int n,k;
    scanf("%d%d",&n,&k);
    for(int i=0;i<=k+1;i++) {//O(k^2)求组合数
        C[i][0]=1;
        for(int j=1;j<=i;j++) C[i][j]=(C[i-1][j-1]+C[i-1][j])%MOD;
    }
    S[0]=n;
    for(int i=1;i<=k;i++) {//1~n递推
        S[i]=(qpow(n+1,i+1)-1)%MOD;
        for(int j=0;j<i;j++)
            S[i]=(S[i]-C[i+1][j]*S[j]%MOD+MOD)%MOD;
        S[i]=S[i]*inv(i+1)%MOD;//注意要÷(i+1)
    }
    printf("%lld\n",S[k]);
    return 0;
}

02.08 T1

题意概述

给一个长度为$n(1 \leq n \leq 233333)$的自然数序列$\{a\}(0\leq a_i \leq 2333333)$,求出有多少个长度$s>1$的子序列,使得

$$C_{a_{k_1}}^{a_{k_2}}*C_{a_{k_2}}^{a_{k_3}}*...*C_{a_{k_{s-1}}}^{a_{k_s}} mod~2333 > 0$$
所得答案 $mod~998244353$

题目分析

这个题得感谢哈狗学长.

先分析一下$2333$,是一个质数.

合法序列需满足
1.$s>1$;
2.$∀1< i \leq s$,$a_{k_i}\leq a_{k_{i-1}}$;
3.$∀1< i \leq s$,$C_{a_{k_{i-1}}}^{a_{k_i}}$不为$2333$的倍数.

重点分析第三个要求,因为组合数结果一定为整数
由组合数公式可得

$$C_n^m=\frac{n!}{m!(n-m)!}$$
要使结果不为2333的倍数,一定有分子分母2333因子数相等.
又因为 $∀1\leq i\leq n, a_i < 2333^2$,所以可以表示为(以下用 $P$表示2333)
$$\left \lfloor \frac{n}{P} \right \rfloor=\left \lfloor \frac{m}{P} \right \rfloor+\left \lfloor \frac{n-m}{P} \right \rfloor$$
$$(n-n\%P)/P=(m-m\%P)/P+((n-m)-(n-m)\%P)/P$$
$$n-n\%P=m-m\%P+n-m-(n-m)\%P$$
$$n\%P=m\%P+(n-m)\%P$$
$$\because (n-m)\%P \geq 0$$
$$\therefore n\%P \geq m\%P$$

所以需满足
1.$n\geq m$
2.$n/P \geq m/P$
3.$n\%P \geq m\%P$

定义$dp[i]$表示到以第i个位置结尾的子序列的方案数.
转移方程为$dp[i]=\sum_{j=1}^{i-1}dp[j]|a_j\geq a_i~and~a_j/P \geq a_i/P~and~a_j\%P \geq a_i\%P$
可以考虑使用二维树状数组,由于是要在前面找比之小的,可以考虑将不等式左右同时取负.

代码实现

#include<cstdio>
#include<iostream>
#include<algorithm>

using namespace std;

const int P=2333;
const int MOD=998244353;
const int maxn=233333+10;

int bit[P+5][P+5];
int m[maxn],r[maxn];//m[i]=P-(a[i]/P),r[i]=P-(a[i]%P)

#define lowbit(x) (x&-x)

void add(int x,int y,int v) {
    for(int i=x;i<=P;i+=lowbit(i))
        for(int j=y;j<=P;j+=lowbit(j))
            (bit[i][j]+=v)%=MOD;
}

int sum(int x,int y) {
    int ret=0;
    for(int i=x;i>0;i-=lowbit(i))
        for(int j=y;j>0;j-=lowbit(j))
            (ret+=bit[i][j])%=MOD;
    return ret;
}

int dp[maxn],n,ans;

int main() {
    freopen("product.in","r",stdin);
    freopen("product.out","w",stdout);
    scanf("%d",&n);
    for(int i=1;i<=n;i++) {
        scanf("%d",&r[i]);
        m[i]=P-r[i]/P;//取反操作,便于找比之小的值
        r[i]=P-r[i]%P;
    }
    add(m[0]=1,r[0]=1,dp[0]=1);
    for(int i=1;i<=n;i++) {
        dp[i]=sum(m[i],r[i]);
        add(m[i],r[i],dp[i]);
        (ans+=(dp[i]-1))%=MOD;
    }
    printf("%d\n",ans);
    return 0;
}

02.08 T3

题意概述

对于一个$1$~$n$的排列$\{p\}$,对于某个$1\leq i \leq n$,有$p_{i-1}<~p_i>p_{i+1}$,则称$i$为一个峰(规定$p_0=p_{n+1}=0$),求出有多少个$1$~$n$的排列存在恰有$k$个峰.($1 \leq n \leq 10^9$,$k \leq 10$)
答案$mod~m$,$m$为输入数.($m \leq 1000$,多组数据$1\leq T \leq 10$)

题目分析

渐进地考虑峰个数的变化,分析插入一个值对峰个数的贡献.
对于一个$1$~$n$的任意排列,若有k个峰.现在尝试将数$n+1$插入,使其变成一个$1$~$n+1$的某一排列.
若将$n+1$插在峰与谷之间(这样的位置有$2k$个),则原来的一个峰会退化成谷,而$n+1$必然会成为峰,即峰个数不变;
若将$n+1$插在谷与谷之间(这样的位置有$n+1-2k$个),则没有峰会退化,则峰的个数增加$1$.

定义状态$dp[i][j]$表示$1$~$n$的所有排列中,恰有$j$个峰的排列有多少.
由前面可得,转移方程如下
$dp[i][j]=dp[i-1][j-1]*(i-2*j+2)+dp[i-1][j]*2j$

但是n太大了,一步一步递推显然是不行的.
那能不能用矩阵快速幂来加速呢？
轩神告诉我,若在转移方程中,转移而来的除了$dp$值之外,其他的应当为常数.
所以这个方程不能用单一的转移方程来加速.
但是由于$m$较小,在$mod~m$意义下,实则将参数控制在了一定的范围.
所以可以将这些转移矩阵都算出来,$1$~$m$转移矩阵依次相乘得到的矩阵作为一个转移矩阵,然后用矩阵快速幂优化.

代码实现

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>

using namespace std;

const int maxk=10+5;
const int maxm=1000+10;

int MOD;

struct Matrix {
    int M[maxk][maxk],n;
    Matrix(){memset(M,0,sizeof(M));n=10;}
    void init() {
        memset(M,0,sizeof(M));
        for(int i=0;i<=n;i++) M[i][i]=1;
    }
    Matrix operator * (const Matrix& rhs) const {
        Matrix ret;
        for(int i=0;i<=n;i++)
            for(int j=0;j<=n;j++)
                for(int k=0;k<=n;k++)
                    (ret.M[i][j]+=M[i][k]*rhs.M[k][j]%MOD)%=MOD;
        return ret;
    }
    Matrix operator *= (const Matrix& rhs) {
        return *this=*this*rhs;
    }
    Matrix operator ^ (int y) const {
        Matrix ret,x=*this;
        ret.init();
        while(y>0) {
            if(y&1) ret*=x;
            x*=x;y>>=1;
        }
        return ret;
    }
}A[maxm],M;

int main() {
    freopen("peaks.in","r",stdin);
    freopen("peaks.out","w",stdout);
    int T,n,k;
    scanf("%d",&T);
    while(T--) {
        scanf("%d%d%d",&n,&k,&MOD);
        for(int i=1;i<=MOD;i++) {
            A[i]=Matrix();
            for(int j=0;j<=k;j++) {
                A[i].M[j][j]=2*j%MOD;
                if(j) A[i].M[j-1][j]=((i-2*j+2)%MOD+MOD)%MOD;
            }
        }
        M.init();
        for(int i=1;i<=MOD;i++) M*=A[i];//算出一次循环的矩阵
        M=M^(n/MOD);//矩阵快速幂
        for(int i=1;i<=n%MOD;i++) M*=A[i];//余下的再乘起来
        printf("%d\n",M.M[0][k]);
    }
    return 0;
}

02.09 T1

题意概述

求出有多少个满足$0\leq x < 1$的有理数$x$,使得

$$a+ax+ax^2+ax^3+... \leq b$$
且对于任意满足要求的$x=\frac{p}{q}$,都有$gcd(p,q)=1$且$q\leq n$.
(多组数据,$1\leq T\leq 10^4$,$1\leq n\leq 10^4$,$1\leq a \leq 10$,$10^3\leq b\leq 10^4$)

题目分析

跟着汪神一起想了想这个题,最终发现是个套路题.

等比数列前$n$项和公式

$$S_n=\frac{a_1(1-q^n)}{1-q}$$
所以有

$$\frac{a(1-x^∞)}{1-x}\leq b$$
$$\because 0\leq x <1,\therefore x^∞\approx 0$$
即
$$a\leq (1-x)b$$
$$a\leq (1-\frac{p}{q})b$$
$$aq\leq b(q-p)$$
$$p\leq \frac{b-a}{b}q$$

即对于$q=1$~$n$,满足$p\leq \frac{b-a}{b}q$且$gcd(p,q)=1$的数的个数.

然后……就是套路了.
因为$1\leq a\leq 10$,$10^3\leq b\leq 10^4$,
所以$\frac{a}{b}_{max}=\frac{1}{100}$,则$\frac{b-a}{b}_{min}=\frac{99}{100}$.
即无论如何$\leq \frac{99}{100}q$的$p$是一定要取的,所以可以筛下$>\frac{99}{100}q$且与$q$互素的数.
那么总共不会超过$500000$个数,但是询问的组数较多,可以选择离线处理,按照$\frac{a}{b}$排序.

代码实现

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>

using namespace std;

const int maxn=10000+10;

int gcd(int a,int b) {
    return b?gcd(b,a%b):a;
}

vector<int>v[maxn];
int phi[maxn],cnt[maxn];

void init(int n) {
    phi[1]=1;
    for(int i=2;i<=n;i++) if(!phi[i])
        for(int j=i;j<=n;j+=i) {
            if(!phi[j]) phi[j]=j;
            phi[j]=phi[j]/i*(i-1);
        }
    for(int i=2;i<=n;i++)
        for(int j=i-1;j>0;j--)
            if(100*j<=99*i) break;//一定会有,不用筛
            else if(gcd(i,j)==1) v[i].push_back(j),++cnt[i];
}

struct Ask {
    int n,a,b,id;
    bool operator < (const Ask& rhs) const {
        return a*rhs.b>b*rhs.a;
    }
    void input(int x) {
        scanf("%d%d%d",&n,&a,&b);id=x;
    }
}ask[maxn];

int ans[maxn];

int main() {
    freopen("series.in","r",stdin);
    freopen("series.out","w",stdout);
    init(10000);
    int T,n,a,b,id;
    scanf("%d",&T);
    for(int i=0;i<T;i++) ask[i].input(i);
    sort(ask,ask+T);//离线处理,按照a/b由大到小排序
    for(int i=0;i<T;i++) {
        n=ask[i].n;a=ask[i].a;b=ask[i].b;id=ask[i].id;
        for(int i=1;i<=n;i++) ans[id]+=phi[i];//先加上全部的,之后再见
        for(int i=1;i<=n;i++)
            while(cnt[i]&&v[i][cnt[i]-1]*b<=i*(b-a)) --cnt[i];离线处理,每次只会增多
        for(int i=1;i<=n;i++) ans[id]-=cnt[i];
    }
    for(int i=0;i<T;i++) printf("%d\n",ans[i]);
    return 0;
}

02.09 T2

题意概述

有n个人,编号依次为$0$~$n-1$.
每次选择是k倍数的人踢出去,然后剩下的人重新从$0$开始编号,直至所有人都被踢出去.(0也是k的倍数)
现在需要求出第$i(1\leq i \leq n)$次踢出去人的初始编号$a_i$.
最终答案输出

$$\sum_{i=1}^na_ip^{i-1}~mod~10^9+7$$
$p$为大于等于$n$的最小质数.
(多组数据, $1\leq T\leq 10$, $1\leq n \leq 10^6$, $1\leq k \leq 10^9$)

题目分析

晚上改题的时候,突然知道这个题怎么做了,感动.

若定义$dp[i]$表示i号位置是在第几轮被踢出去的,那么对于一个位置$p$
若$p\%k=0$,则$dp[p]=1$.
若$p\%k!=0$,则当前$p$位置会在重组后到一个新的位置,且恰好比这个新位置的$dp$值大$1$,即$dp[p]=dp[p/k+1]+1$.

如此,即可在$O(n)$的时间里得到每个位置出去是在第几轮.
然后按照轮数,从小到大,同一轮也从小到大遍历(用链表或者vector),依次编号即可得到$\{a\}$.
按照题中要求,求出答案即可.

代码实现

#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>

using namespace std;

typedef long long ll;
const int MOD=1e9+7;
const int maxn=1000000+10;

int is_prime(int n) {
    int m=sqrt(n);
    for(int i=2;i<=m;i++) if(n%i==0) return 0;
    return 1;
}

int d[maxn];
vector<int>a[maxn];

int main() {
    freopen("joseph.in","r",stdin);
    freopen("joseph.out","w",stdout);
    int T,n,k,p;
    scanf("%d",&T);
    while(T--) {
        scanf("%d%d",&n,&k);p=n;
        while(!is_prime(p)) ++p;
        for(int i=1;i<=n;i++) a[i].clear();
        for(int i=0;i<n;i++) {//O(n)的dp递推
            d[i]=(i%k?d[i-(i/k+1)]+1:1);
            a[d[i]].push_back(i);
        }
        ll ans=0,pow=1;
        for(int i=1;i<=n;i++)
            for(int j=0;j<a[i].size();j++) {
                ans=(ans+pow*a[i][j]%MOD)%MOD;
                pow=(pow*p)%MOD;
            }
        printf("%lld\n",ans);
    }
    return 0;
}