17-06-02模拟赛

T1:

经过推算可以发现斐波那契数列第n项前缀和等于第n+2项的数-1，即s[n]=f[n+2]-1.

所以斐波那契数列的[l,r]项的区间和可以看作s[r]-s[l-1]，即f[r+2]-f[l+1].

考虑到l,r的范围及取模的需要，用矩阵乘法快速幂并将乘法改为快速乘以保证不超出范围即可。

原理为

Tips:快速乘和快速幂的原理相同，把其中一个乘数拆为二进制，转乘法为加法（类比快速幂，快速幂是转幂运算为乘法），这样就可以边加边取模。

Code:

#include<cstdio>
#include<cstring>
#include<algorithm>
#define ull unsigned long long
using namespace std;
struct ma{
    ull mat[2][2];
}a,b;
inline ull in(){ 
    ull x=0;bool f=0; char c; 
    for (;(c=getchar())<'0'||c>'9';f=c=='-'); 
    for (x=c-'0';(c=getchar())>='0'&&c<='9';x=(x<<3)+(x<<1)+c-'0'); 
    return f?-x:x; 
}
ull n,mod,l,r,matl,matr;
ull qmult(ull a,ull b){
    if (a<b) swap(a,b);ull c=0;
    while (b){
        if  (b&1) c=(c+a)%mod;
        b>>=1;a=(a<<1)%mod;
    }
    return c%mod;
}
ma mtmult(ma a,ma b){
    ull sum=0;ma c;
    memset(c.mat,0,sizeof(c.mat));
    for (int i=0;i<2;++i)
    for (int j=0;j<2;++j){
        sum=0;
        for (int k=0;k<2;++k)
        sum=(sum+qmult(a.mat[i][k],b.mat[k][j]))%mod;
        c.mat[i][j]=sum;
    }
    return c;
} 
ma mtpow(ma a,ull x){
    ma c;
    memset(c.mat,0,sizeof(c.mat));
    for (int i=0;i<2;++i) c.mat[i][i]=1;
    while (x){
        if (x&1) c=mtmult(c,a);
        x>>=1;a=mtmult(a,a);
    }
    return c;
}
ull mtcult(ull x)
{
    if (!x) return 0LL;if (x<3) return 1LL;
    memset(a.mat,0,sizeof(a.mat));memset(b.mat,0,sizeof(b.mat));
    for (int i=0;i<2;++i) b.mat[i][0]=1;
    for (int i=0;i<2;++i) a.mat[i][1]=1;a.mat[1][0]=1;
    a=mtpow(a,x-2);a=mtmult(a,b);return a.mat[1][0]%mod;
}
int main()
{
    n=in();mod=in();
    while (n--){
        l=in();r=in();matl=matr=0;
        matl=mtcult(l+1);matr=mtcult(r+2);
        printf("%lld
",(matr+mod-matl)%mod);
    }
    return 0;
}

T2:

先考虑m=1的情况：
设先取第i双水晶鞋比先取第j双水晶鞋优，则d_i*(W-w_i)+d_j*(W-w_i-w_j)<d_j*(W-w_j)+d_i*(W-w_i-w_j)，其中W表示总权值。

由此可得di*wj<d_j*w_i，也就是说，当i,j满足该式时，i先取比j先取更优。

这样的结论只有在i,j相邻时是正确的，若要保证这样排序是正确的，必须证明：当i先比j先优，且j先比k先优时，i先比k先优。

我们发现这个结论满足这个性质。因此排序即可。

若m>1，我们发现若两双水晶鞋的编号对m取模不同余，那么取两双鞋的先后顺序不会对答案产生影响。

因此枚举余数，每次将模m等于该余数的水晶鞋取出排序并分别统计答案即可。

最后注意答案可能会超出long long的范围，因此需将答案用两个long long 存储。

Code:

#include<cstdio>
#include<cstring>
#include<algorithm>
#define ll long long
#define MN 200005
#define Mx 1000000000000000000LL
using namespace std;
inline ll in(){ 
    ll x=0;bool f=0; char c; 
    for (;(c=getchar())<'0'||c>'9';f=c=='-'); 
    for (x=c-'0';(c=getchar())>='0'&&c<='9';x=(x<<3)+(x<<1)+c-'0'); 
    return f?-x:x;
}
ll d[MN],w[MN],pos[MN];
ll n,m,a1,a2;
bool cmp(ll x,ll y){
    return (1LL*d[x]*w[y]<1LL*d[y]*w[x]);
}
int main()
{
    n=in();m=in();
    for (int i=1;i<=n;++i) d[i]=in(),w[i]=in();
    for (int i=1;i<=m;++i){
        ll cnt=0,sum=0;
        for (int j=i;j<=n;j+=m) pos[++cnt]=j,sum+=w[j];
        sort(pos+1,pos+cnt+1,cmp);
        for (int j=1;j<=cnt;++j){
            sum-=w[pos[j]];a2+=1LL*d[pos[j]]*sum;
            if (a2>Mx) ++a1,a2-=Mx;
        }
    }if (!a1) printf("%lld",a2);else printf("%lld%018lld",a1,a2); 
    return 0;
}

T3:

依题意可知该无向连通图为一棵树。

考虑对该树上的节点进行差分。

注意到每个节点的贡献是与它深度差不超过m的祖先，所以可将将该节点加上该节点的精华值，离该节点距离为m的祖先处减去该节点的精华值，统计答案时从叶节点往上加即可。

Code:

#include<cstdio>
#include<cstring>
#include<algorithm>
#define MN 1000005
using namespace std;
inline int in(){ 
    int x=0;bool f=0; char c; 
    for (;(c=getchar())<'0'||c>'9';f=c=='-'); 
    for (x=c-'0';(c=getchar())>='0'&&c<='9';x=(x<<3)+(x<<1)+c-'0'); 
    return f?-x:x; 
}
struct edge{
    int to,next;
}e[MN<<1];
int head[MN],lev[MN],dif[MN],w[MN];
int n,m,x,y,cnt=0,top,dep;
void ins(int x,int y){
    e[++cnt].to=y;e[cnt].next=head[x];head[x]=cnt;
}
void dfs(int u,int fa){
    top=(dep-m<0)?0:dep-m;
    dif[u]+=w[u];dif[lev[top]]-=w[u];lev[++dep]=u;
    for (int i=head[u];i;i=e[i].next){
        int v=e[i].to;
        if (v==fa) continue;
        dfs(v,u);dif[u]+=dif[v];
    }--dep;
}
int main()
{
    n=in();m=in();
    for (int i=1;i<=n;++i) w[i]=in();
    for (int i=1;i<n;++i){
        x=in();y=in();ins(x,y);ins(y,x);
    }dfs(1,0);
    for (int i=1;i<=n;++i) printf("%d
",dif[i]);
    return 0;
}

T4:区间动规。

f[i][j][l][r](l,r=0 or 1)表示在i到j的区间中左端法力类型为l，右端法力类型为r时得到的最大法术强度。

注意处理由于受到了一些段强制选择法力的约束而产生的不可能得到的状态。

转移方程为f[l][r][l1][r1]=max{f[l][k][l1][r2]+f[k+1][r][l2][r1]+a[l1^l2][l]*a[l1^l2][k+1]+a[r1^r2][k]*a[r1^r2][r]}.

时间复杂度为O(16*n³)。

Code:

#include<cstdio>
#include<cstring>
#include<algorithm>
#define MN 202
#define inf 0x3fffffff
using namespace std;
inline int in(){ 
    int x=0;bool f=0; char c; 
    for (;(c=getchar())<'0'||c>'9';f=c=='-'); 
    for (x=c-'0';(c=getchar())>='0'&&c<='9';x=(x<<3)+(x<<1)+c-'0'); 
    return f?-x:x; 
}
int f[MN][MN][2][2],a[2][MN],col[MN];
int n,m1,m2,x,ans=-inf;
int main()
{
    n=in();m1=in();m2=in();memset(col,-1,sizeof(col));
    for (int i=1;i<=m1;++i) x=in(),col[x]=0;
    for (int i=1;i<=m2;++i) x=in(),col[x]=1;
    for (int i=1;i<=n;++i) a[1][i]=in(),a[0][i]=in();
    for (int i=1;i<=n;++i) f[i][i][0][1]=f[i][i][1][0]=-inf;
    for (int i=1;i<=n;++i)
    for (int j=i;j<=n;++j){
    if (col[i]>=0) f[i][j][col[i]^1][0]=f[i][j][col[i]^1][1]=-inf;
    if (col[j]>=0) f[i][j][0][col[j]^1]=f[i][j][1][col[j]^1]=-inf;}
    for (int i=1;i<n;++i)
    for (int l=1,r=i+1;r<=n;++l,++r)
    for (int l1=0;l1<=1;++l1)
    for (int r1=0;r1<=1;++r1)
    if (f[l][r][l1][r1]!=-inf)
    for (int k=l;k<r;++k)
    for (int r2=0;r2<=1;++r2)
    for (int l2=0;l2<=1;++l2)
    f[l][r][l1][r1]=max(f[l][r][l1][r1],f[l][k][l1][r2]+f[k+1][r][l2][r1]+a[l1^l2][l]*a[l1^l2][k+1]+a[r1^r2][k]*a[r1^r2][r]);
    for (int l=0;l<=1;++l)
    for (int r=0;r<=1;++r) ans=max(ans,f[1][n][l][r]);
    printf("%d",ans);return 0;
}