2017.8.29 达哥的随单题...

随

给出n个正整数a1,a2…an和一个质数mod.一个变量x初始为1.进行m次操作.每次在n个数中随机选一个ai,然后x=x*ai%mod.问m次操作之后x的取值的期望.

答案一定可以表示成a/b的精确分数形式.a和b可能很大,所以只需要输出a*(b^(10^9+5))模10^9+7的结果.

n<=10^5  m<=10^9  mod<=10^3  1<=ai<mod

solution

考试时明白了原根是什么，只可惜我就是脑子抽风，不会dp...

80分：

定义 f[i][j] 表示乘到第i次，x=j的概率 (当然概率是%1e9意义下的概率)

由于m很大，而状态转移可以写成矩阵乘的形式，所以可以用矩阵乘法优化到O(mod^3*logm)

100分：

O(n^2)求出mod的原根(原根rt：rt的1次方，2次方，...，mod-1次方可以取到1～mod-1的所有数)

所有的ai都可以用rt^k表示

所以这时 f[i][j] 表示乘到第i次，rt^j的概率，然后矩阵乘把状态矩阵输出，发现是循环矩阵

之后就优化到了O(n^2*logm)

#include <cstdio>
#include <cstring>
#include <iostream>
#define mem(a,b) memset(a,b,sizeof(a))
#define ll long long
using namespace std;
const int MOD=1000000007;
const int N=100066;
 
int n,m,mod;
int a2[N],num[1066],dui[1066];
int rt,mod_1;
ll a[1066][1066],f[1066],temp[1066][1066],gai;
bool flag[1066];
 
ll mi(ll a,int ci,int c)
{
  ll ans=1;
  while(ci)
  {
    if(ci&1)
      ans=ans*a%c;
    a=a*a%c;
    ci>>=1;
  }
  return ans;
}
 
int get_rt()
{
  int judge,temp;
  for(int i=1;i<mod;++i)
  {
    judge=0;temp=1;
    mem(flag,0);
    for(int j=1;j<mod;++j)
    {
      temp=temp*i%mod;
      if(flag[temp])
      {
        judge=1;
        break;
      }
      flag[temp]=1;
    }
    if(!judge)
      return i;
  }
}
 
void get_a2_dui()
{
  int temp=1;
  for(int i=1;i<mod;++i)
  {
    temp=temp*rt%mod;
    dui[temp]=i;
  }
}
 
void get_num()
{
  for(int i=1;i<=n;++i)
    ++num[dui[a2[i]]];
}
 
void build_a()
{
  for(int i=0;i<mod;++i)
    for(int j=1;j<mod;++j)
      a[i][(i+j)%mod_1]=(a[i][(i+j)%mod_1]+gai*num[j]%MOD)%MOD;
}
 
void cheng()
{
  f[0]=1;
  while(m)//横着是<mod-1，纵<mod
  {
    if(m&1)
    {
      for(int i=0;i<=mod;++i)
      {
        temp[0][i]=0;
        for(int k=0;k<=mod;++k)
          temp[0][i]=(temp[0][i]+f[k]*a[k][i]%MOD)%MOD;
      }
      for(int i=0;i<=mod;++i)
        f[i]=temp[0][i];
    }
    for(int i=0;i<=mod;++i)
    {
      temp[0][i]=0;
        for(int k=0;k<=mod;++k)
          temp[0][i]=(temp[0][i]+a[0][k]*a[k][i]%MOD)%MOD;
    }
     
    for(int i=0;i<=mod;++i)
      a[0][i]=temp[0][i];
     
    for(int i=1;i<=mod;++i)
    {
      a[i][0]=a[i-1][mod_1-1];
      for(int j=1;j<mod_1;++j)
        a[i][j]=a[i-1][j-1];
    }
    /*for(int i=0;i<mod;++i)
    {
      for(int j=0;j<mod_1;++j)
        printf("%lld ",a[i][j]);
      printf("
");
    }
    printf("
");*/
    m>>=1;
  }
}
 
int main(){
     
  //freopen("rand4.in","r",stdin);
  //freopen("2.txt","w",stdout);
   
  scanf("%d%d%d",&n,&m,&mod);
  mod_1=mod-1;
  for(int i=1;i<=n;++i)
    scanf("%d",&a2[i]);
  gai=mi(n,MOD-2,MOD);
  rt=get_rt();
  get_a2_dui();
  get_num();
  build_a();
  cheng();
  ll ans=0,temp=1;
  ans=(ans+temp*f[0]%MOD)%MOD;
  for(int i=1;i<=mod;++i)
  {
    temp=temp*rt%mod;
    ans=(ans+temp*f[i]%MOD)%MOD;
  }
  cout<<ans;
}

单

给一个n个点的树，有n-1条边，每一个点有一个权值，定义a[i]为i这个点的权值，定义dis(i，j)为i到j的树上距离，dis(i,i)=0

定义b[i]=∑a[j]*dis(i,j)

有两种情况：

1.给定a[i]，求出b[i]

2.给定b[i]，求出a[i]

solution

对于树上的一对fa和son，我们发现b[fa]和b[son]的差别只是由于他俩之间的边做出贡献

定义 sum为整棵树的取值之和 pre[i]=sum-val[i](以i为根的子树权值和) suf[i]=val[i]

而 pre[i]和suf[i] 都是可以通过一遍O(n)的dfs求出

那么得到n-1个关系 b[fa]-b[son]=-pre[fa]+suf[son]

第一种情况：

由b[fa]可以推到b[son] 即

b[son]=b[fa]+pre[fa]-suf[fa]

所以先dfs一遍求出b[root]

再递推即可

第二种情况：

b[fa]-b[son]=-pre[fa]+suf[son]+ sum=pre[fa]+suf[son]

                  ↓

b[fa]-b[son]=2*suf[son]-sum

把n-1个关系相加得

temp=2*(∑suf[k](1<=k<=n，k!=root))-(n-1)*sum的值

得到的n-1个关系 只是a[i]之间的关系，与它们的具体取值无关

而 b[root]=∑suf[k](1<=k<=n，k!=root)

(temp+b[root]*2)/(n-1)=sum

求出来sum再回代即可求出suf[i]，最后差分求出a[i]

#include <cstdio>
#include <iostream>
#include <cstring>
#define mem(a,b) memset(a,b,sizeof(a))
#define ll long long
using namespace std;
const int N=200066;
int read()
{
  int ans=0,flag=1;char q=getchar();
  while(q<'0'||q>'9'){if(q=='-')flag=-1;q=getchar();}
  while(q>='0'&&q<='9'){ans=ans*10+q-'0';q=getchar();}
  return ans*flag;
}
struct son
{
    int v,next;
};
son a1[N*4];
int first[N*4],e;
void addbian(int u,int v)
{
  a1[e].v=v;
  a1[e].next=first[u];
  first[u]=e++;
}
 
int T;
int kk,n;
int u,o;
int a[N],b[N];
 
int fa[N];
 
int val[N],dep[N];
void dfs0(int x)
{
  val[x]=a[x];
  for(int i=first[x];i!=-1;i=a1[i].next)
  {
    int temp=a1[i].v;
    if(temp==fa[x])continue;
    dep[temp]=dep[x]+1;
    fa[temp]=x;
    dfs0(temp);
    val[x]+=val[temp];
  }
}
 
void dfs00(int x)
{
  for(int i=first[x];i!=-1;i=a1[i].next)
  {
    int temp=a1[i].v;
    if(fa[x]==temp)continue;
    b[temp]=b[x]+val[1]-val[temp]-val[temp];
    dfs00(temp);
  }
}
 
void work0()
{
  for(int i=1;i<=n;++i)
    a[i]=read();
  mem(b,0);mem(fa,0);mem(val,0);
  mem(dep,0);
   
  dfs0(1);
  for(int i=2;i<=n;++i)
    b[1]+=dep[i]*a[i];
  dfs00(1);
  for(int i=1;i<=n;++i)
    printf("%d ",b[i]);
  printf("
");
}
 
void dfs1(int x)
{
  for(int i=first[x];i!=-1;i=a1[i].next)
  {
    int temp=a1[i].v;
    if(temp==fa[x])continue;
    fa[temp]=x;
    a[temp]=b[x]-b[temp];
    dfs1(temp);
  }
}
 
void dfs11(int x)
{
  for(int i=first[x];i!=-1;i=a1[i].next)
  {
    int temp=a1[i].v;
    if(temp==fa[x])continue;
    a[x]-=a[temp];
    dfs11(temp);
  }
}
 
void work1()
{
  for(int i=1;i<=n;++i)
    b[i]=read();
  mem(a,0);mem(fa,0);
   
  dfs1(1);
  ll SUM=0;
  for(int i=2;i<=n;++i)
    SUM+=a[i];
  SUM-=(2*b[1]);
  SUM=-SUM;
  SUM/=(n-1);
  for(int i=2;i<=n;++i)
    a[i]=((a[i]+SUM)>>1);
  a[1]=SUM;
  dfs11(1);
  //printf("SUM=%d
",SUM);
  for(int i=1;i<=n;++i)
    printf("%d ",a[i]);
  printf("
");
}
 
int main(){
   
  //freopen("single9.in","r",stdin);
  //freopen("2.txt","w",stdout);
   
  T=read();
  while(T--)
  {
    mem(a1,0);mem(first,-1);e=0;
    n=read();
    for(int i=1;i<n;++i)
    {
      u=read();o=read();
      addbian(u,o);
      addbian(o,u);
    }
    kk=read();
    if(kk==1)work1();
    else work0();
  }
}

题

你在平面直角坐标系上.

你一开始位于(0,0).

每次可以在上/下/左/右四个方向中选一个走一步.

即:从(x,y)走到(x,y+1),(x,y-1),(x-1,y),(x+1,y)四个位置中的其中一个.

允许你走的步数已经确定为n.现在你想走n步之后回到(0,0).但这太简单了.你希望知道有多少种不同的方案能够使你在n步之后回到(0,0).当且仅当两种方案至少有一步走的方向不同,这两种方案被认为是不同的.

答案可能很大所以只需要输出答案对10^9+7取模后的结果.(10^9+7=1000000007,1和7之间有8个0)

这还是太简单了,所以你给能够到达的格点加上了一些限制.一共有三种限制,加上没有限制的情况,一共有四种情况,用0,1,2,3标号:

0.没有任何限制,可以到达坐标系上所有的点,即能到达的点集为{(x,y)|x,y为整数}

1.只允许到达x轴非负半轴上的点.即能到达的点集为{(x,y)|x为非负数,y=0}

2.只允许到达坐标轴上的点.即能到达的点集为{(x,y)|x=0或y=0}

3.只允许到达x轴非负半轴上的点,y轴非负半轴上的点以及第1象限的点.即能到达的点集为{(x,y)|x>=0,y>=0}

typ=2,n<=1000  typ=3,n<=100000   typ=1,n<=100000  typ=0,n<=100000

solution

注意一下走的步数必须是偶数

---

tpy=0

ans=∑( C(n,i)*C(i,i/2)*C(n-i,(n-i)/2) )

解释：

C(n,i)是从n步里选出i步水平走

C(i,i/2)是从i步里选出i/2步向右走

C(n-i,(n-i)/2)是从n-i步里选出(n-i)/2步向上走

---

tpy=1

ans=Catalan[n/2]

解释：

向左、右走 就相当于 左、右括号

---

tpy=2

定义 f[i] 为走i步回到原点的方案数

f[i]=∑( f[k]*Catalan[(i-k)/2-1]*4 )

ans=f[n]

解释：

Catalan[(i-k)/2-1]意为走i-k步第一次回到原点的方案数 = (0,1)向上走再回来的方案数

---

tpy=3

ans=∑( C(n,i)*Catalan[i]*Catalan[ (n-i)/2 ] )

#include<cstdio>
#include<cstring>
#include<iostream>
#define ll long long
#define C(n,m) (jie[(n)]*jieni[(m)]%mod*jieni[(n)-(m)]%mod)
#define can(n) (C(((n)<<1),(n))*ni[(n)+1]%mod)
using namespace std;
const int mod=1000000007;
const int N=100066;
 
int n,kk;
 
ll jie[N],jieni[N],ni[N];
void chu()
{
  ni[1]=1;
  for(int i=2;i<N;++i)
    ni[i]=(ll)(mod-mod/i)*ni[mod%i]%mod;
   
  jie[0]=jieni[0]=jie[1]=jieni[1]=1;
  for(int i=2;i<N;++i)
  {
    jie[i]=jie[i-1]*(ll)i%mod;
    jieni[i]=jieni[i-1]*ni[i]%mod;
  }
}
 
void work0()
{
  ll ans=0,temp;
  for(int i=0;i<=n;i+=2)
  {
    temp=1;
    temp=temp*C(n,i)%mod*C(i,(i>>1))%mod*C((n-i),((n-i)>>1))%mod;
    ans=(ans+temp)%mod;
  }
  cout<<ans;
}
 
void work1()
{
  cout<<can((n>>1));
}
 
ll f[N];
void work2()
{
  f[0]=1;
  for(int i=2;i<=n;i+=2)
    for(int j=2;j<=i;j+=2)
      f[i]=(f[i]+f[i-j]*can((j>>1)-1)%mod*4%mod)%mod;
  cout<<f[n];
}
 
void work3()
{
  ll ans=0,temp;
  for(int i=0;i<=n;i+=2)
  {
    temp=1;
    temp=temp*C(n,i)%mod*can((i>>1))%mod*can(((n-i)>>1))%mod;
    ans=(ans+temp)%mod;
  }
  cout<<ans;
}
 
int main(){
   
  //freopen("problem.in","r",stdin);
  //freopen("problem.out","w",stdout);
   
  chu();
   
  scanf("%d%d",&n,&kk);
   
  if(kk==0)work0();
  else if(kk==1)work1();
  else if(kk==2)work2();
  else work3();
   
  return 0;   
}

总结

总的来说这套题还是不难的

我考的不好主要是刷题太少，老是没有感觉