NOI 2012 题解

最新推荐文章于 2022-02-10 00:10:08 发布
最新推荐文章于 2022-02-10 00:10:08 发布
阅读量631 收藏
点赞数 1
分类专栏： NOI历年
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25471829/article/details/46326351
版权

随机数生成器

(传送门)

题意

给出a,c,g,mod,x0,n,xn=(a*xn-1+c)%mod,求xn%g

分析

送分题，快速乘+矩阵乘+快速幂，构造矩阵也很容易，不多说了。

代码

 

#include <bits/stdc++.h>
using namespace std;

struct Martrix
{
    long long  a[2][2];
} x,ans;
long long  m,a,c,x0,n,g;

long long  quick_mult(long long  X,long long  Y)  
{
    long long  re=0;
    while(Y)  
    {
        if(Y&1) re+=X,re=(re>m?re-m:re);
        X+=X,X=(X>m?X-m:X);
        Y>>=1;
    }
    return re;
}

void operator *= (Martrix &x,Martrix y)  
{
    Martrix z;
    memset(&z,0,sizeof(z));
    for(int i=0;i<2;i++)  
        for(int j=0;j<2;j++)  
            for(int k=0;k<2;k++)  
                z.a[i][j]+=quick_mult(x.a[i][k],y.a[k][j]),z.a[i][j]=(z.a[i][j]>m?z.a[i][j]-m:z.a[i][j]);
    x=z;
}

void quick_power()  
{
    ans.a[0][0]=ans.a[1][1]=1;
    ans.a[1][0]=ans.a[0][1]=0;
    while(n)  
    {
        if(n&1) ans*=x;
        x*=x;
        n>>=1;
    }
}

int main()  
{
    cin>>m>>a>>c>>x0>>n>>g;
    x.a[0][0]=a%m;
    x.a[0][1]=0;
    x.a[1][0]=c%m;
    x.a[1][1]=1;
    quick_power();
    long long  xn=quick_mult(ans.a[0][0],x0)+ans.a[1][0];
    xn%=m;
    xn%=g;
    cout<<xn<<endl;
    return 0;
}

川藏骑行

(传送门)

题意

骑N段路，第i段有3个参数：长度Si，风阻系数 ki，风速vi'。某时刻骑车速度为v，受到的风阻大小为 F = ki ( v - vi' )2，消耗能量E =ki ( v - vi' )2 s）。体能值是 Eu ，设计一种方案，最短的时间到达目的地。

分析

拉格朗日乘数法

v_i>v'_i，v_i随lambda单调，故二分常数解出v_i并判定。

代码

 

#include <bits/stdc++.h>
using namespace std;

const int maxn=10000+10;
const double eps=1e-10;
int n;
double E;
double k[maxn],v1[maxn],v[maxn];
double s[maxn],kms[maxn];

void cal(double lambda)
{
    for(int i=0;i<n;i++)
    {
        double l=v1[i],r=1e20;
        while(r-l>=eps)
        {
            double m=(l+r)*0.5;
            if(k[i]*m*m*(m-v1[i])<lambda) l=m;
            else r=m;
        }
        v[i]=l;
    }
}

int main()
{
    scanf("%d%lf",&n,&E);
    for(int i=0;i<n;i++)
    {
        scanf("%lf%lf%lf",&s[i],&k[i],&v1[i]);
        kms[i]=k[i]*s[i];
    }
    int cao=90;
    double l=0,r=1e15;
    while(r-l>=eps)
    {
        double m=(l+r)*0.5,sum=0;
        cal(m);
        for(int i=0;i<n;i++)
            sum += kms[i]*(v[i]-v1[i])*(v[i]-v1[i]);
        if(sum<E) l=m;
        else r=m;
    }
    double ans=0;
    for(int i=0;i<n;i++)
        ans+=s[i]/v[i];
    printf("%lf\n",ans);        
    return 0;
}

魔幻棋盘

(传送门)

题意

给定一个矩阵，支持两种操作：

1.将某个子矩阵中的每个值增加一个数

2.询问某个子矩阵中的所有数的GCD 已知所有询问恒过定点(x,y)

分析

维护一个二维线段树支持子矩阵修改和子矩阵查询

但这是不正确的 因为GCD(x+k,y+k)!=k+GCD(x,y)

由于GCD与修改标记不能相容，因此无法支持区间修改区间查询

解决这个问题，先要横向向中心差分，然后纵向向中心差分，那么就得到了要求的矩阵

那么询问时由于e这个值没变，因此我们直接去线段树上找到相应子矩阵的GCD就是原矩阵相应子矩阵的GCD

到这个题我第一次写二维线段树，代码写的特别冗长，这里给出别人的代码。

代码

 

#include <bits/stdc++.h>  
using namespace std;

const int MAXN=500500;
int m,n,q;
  
struct Array{  
    long long memory[MAXN];
    long long* operator [] (int x)  
    {  
        return &memory[(x-1)*n];
    }  
}a;
  
long long GCD(long long x,long long y)  
{  
    return y?GCD(y,x%y):x;
}  
  
inline long long Abs(long long x)  
{  
    return x<0?-x:x;
}  
  
struct Segtree{  
    Segtree *ls,*rs;
    long long val;
    Segtree():ls(0x0),rs(0x0),val(0ll) {}  
    friend void Build_Tree(Segtree* &p,int x,int y,long long a[])  
    {  
        int mid=x+y>>1;
        p=new Segtree;
        if(x==y)  
        {  
            p->val=a[mid];
            return ;
        }  
        Build_Tree(p->ls,x,mid,a);
        Build_Tree(p->rs,mid+1,y,a);
        p->val=GCD(p->ls->val,p->rs->val);
        //普通线段树  
    }  
    void Modify(int x,int y,int pos,long long val)  
    {  
        int mid=x+y>>1;
        if(x==y)  
        {  
            this->val+=val;
            return ;
        }  
        if(pos<=mid) ls->Modify(x,mid,pos,val);
        else rs->Modify(mid+1,y,pos,val);
        this->val=GCD(ls->val,rs->val);
    }  
    long long Get_Ans(int x,int y,int l,int r)  
    {  
        int mid=x+y>>1;
        if(x==l&&y==r)  
            return val;
        if(r<=mid) return ls->Get_Ans(x,mid,l,r);
        if(l>mid) return rs->Get_Ans(mid+1,y,l,r);
        return GCD( ls->Get_Ans(x,mid,l,mid) , rs->Get_Ans(mid+1,y,mid+1,r) );
    }  
    friend void Union(Segtree* &p,Segtree *p1,Segtree *p2,int x,int y)  
    {  
        int mid=x+y>>1;
        if(!p) p=new Segtree;
        if(x==y)  
        {  
            p->val=GCD(p1->val,p2->val);
            return ;
        }  
        Union(p->ls,p1->ls,p2->ls,x,mid);
        Union(p->rs,p1->rs,p2->rs,mid+1,y);
        p->val=GCD(p->ls->val,p->rs->val);
    }  
};
  
struct abcd{  
    abcd *ls,*rs;
    Segtree *tree;
    abcd():ls(0x0),rs(0x0),tree(0x0) {}  
    friend void Build_Tree(abcd* &p,int x,int y,Array& a)  
    {  
        int mid=x+y>>1;
        p=new abcd;
        if(x==y)  
        {  
            Build_Tree(p->tree,1,n,a[mid]);
            return ;
        }  
        Build_Tree(p->ls,x,mid,a);
        Build_Tree(p->rs,mid+1,y,a);
        Union(p->tree,p->ls->tree,p->rs->tree,1,n);
    }  
    void Modify(int x,int y,int pos1,int pos2,long long val)  
    {  
        int mid=x+y>>1;
        if(x==y)  
        {  
            tree->Modify(1,n,pos2,val);
            return ;
        }  
        if(pos1<=mid) ls->Modify(x,mid,pos1,pos2,val);
        else rs->Modify(mid+1,y,pos1,pos2,val);
        long long lval=ls->tree->Get_Ans(1,n,pos2,pos2);
        long long rval=rs->tree->Get_Ans(1,n,pos2,pos2);
        long long this_val=tree->Get_Ans(1,n,pos2,pos2);
        tree->Modify(1,n,pos2,GCD(lval,rval)-this_val);
    }  
    long long Get_Ans(int x,int y,int l1,int r1,int l2,int r2)  
    {  
        int mid=x+y>>1;
        if(x==l1&&y==r1)  
            return tree->Get_Ans(1,n,l2,r2);
        if(r1<=mid) return ls->Get_Ans(x,mid,l1,r1,l2,r2);
        if(l1>mid) return rs->Get_Ans(mid+1,y,l1,r1,l2,r2);
        return GCD( ls->Get_Ans(x,mid,l1,mid,l2,r2) ,   
                    rs->Get_Ans(mid+1,y,mid+1,r1,l2,r2) );
    }  
}*root;
  
int main()  
{
    int i,j,x,y,p,x1,y1,x2,y2;
    long long val;
    cin>>m>>n>>x>>y>>q;
    for(i=1;i<=m;i++)  
        for(j=1;j<=n;j++)  
            #ifdef ONLINE_JUDGE  
                scanf("%lld",&a[i][j]);
            #else  
                scanf("%I64d",&a[i][j]);
            #endif  
    for(i=1;i<=m;i++)  
    {  
        for(j=1;j<y;j++)  
            a[i][j]-=a[i][j+1];
        for(j=n;j>y;j--)  
            a[i][j]-=a[i][j-1];
    }  
    for(j=1;j<=n;j++)  
    {  
        for(i=1;i<x;i++)  
            a[i][j]-=a[i+1][j];
        for(i=m;i>x;i--)  
            a[i][j]-=a[i-1][j];
    }  
    Build_Tree(root,1,m,a);
    for(i=1;i<=q;i++)  
    {  
        scanf("%d",&p);
        if(p==0)  
        {  
            scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
            x1=x-x1;y1=y-y1;x2=x+x2;y2=y+y2;
            long long ans=root->Get_Ans(1,m,x1,x2,y1,y2);
            ans=Abs(ans);
            #ifdef ONLINE_JUDGE  
                printf("%lld\n",ans);
            #else  
                printf("%I64d\n",ans);
            #endif  
        }  
        else  
        {  
            scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
            #ifdef ONLINE_JUDGE  
                scanf("%lld",&val);
            #else  
                scanf("%I64d",&val);
            #endif  
  
            if( x1<=x && y1<=y && x1-1>0 && y1-1>0 )  
                root->Modify(1,m,x1-1,y1-1,val);
            else if( x1<=x && y1>y && x1-1>0 )  
                root->Modify(1,m,x1-1,y1,-val);
            else if( x1>x && y1<=y && y1-1>0 )  
                root->Modify(1,m,x1,y1-1,-val);
            else if( x1>x && y1>y )  
                root->Modify(1,m,x1,y1,val);
            //左上端点(x1,y1)  
  
            if( x1<=x && y2>=y && x1-1>0 && y2+1<=n )  
                root->Modify(1,m,x1-1,y2+1,val);
            else if( x1<=x && y2<y && x1-1>0 )  
                root->Modify(1,m,x1-1,y2,-val);
            else if( x1>x && y2>=y && y2+1<=n )  
                root->Modify(1,m,x1,y2+1,-val);
            else if( x1>x && y2<y )  
                root->Modify(1,m,x1,y2,val);
            //右上端点(x1,y2)  
  
            if( x2>=x && y1<=y && x2+1<=m && y1-1>0 )  
                root->Modify(1,m,x2+1,y1-1,val);
            else if( x2<x && y1<=y && y1-1>0 )  
                root->Modify(1,m,x2,y1-1,-val);
            else if( x2>=x && y1>y && x2+1<=m )  
                root->Modify(1,m,x2+1,y1,-val);
            else if( x2<x && y1>y )  
                root->Modify(1,m,x2,y1,val);
            //左下端点(x2,y1)  
  
            if( x2>=x && y2>=y && x2+1<=m && y2+1<=n )  
                root->Modify(1,m,x2+1,y2+1,val);
            else if( x2<x && y2>=y && y2+1<=n )  
                root->Modify(1,m,x2,y2+1,-val);
            else if( x2>=x && y2<y && x2+1<=m )  
                root->Modify(1,m,x2+1,y2,-val);
            else if( x2<x && y2<y )  
                root->Modify(1,m,x2,y2,val);
            //右下端点(x2,y2)  
  
            if( x1<=x && x2>=x )  
            {  
                if( y1<=y && y1-1>0 ) root->Modify(1,m,x,y1-1,-val);
                else if( y1>y ) root->Modify(1,m,x,y1,val);
                //左端点(x,y1)  
                if( y2>=y && y2+1<=n ) root->Modify(1,m,x,y2+1,-val);
                else if( y2<y ) root->Modify(1,m,x,y2,val);
                //右端点(x,y2)  
            }  
  
            if( y1<=y && y2>=y )  
            {  
                if( x1<=x && x1-1>0 ) root->Modify(1,m,x1-1,y,-val);
                else if( x1>x ) root->Modify(1,m,x1,y,val);
                //上端点(x1,y)  
                if( x2>=x && x2+1<=m ) root->Modify(1,m,x2+1,y,-val);
                else if( x2<x ) root->Modify(1,m,x2,y,val);
                //下端点(x2,y)  
            }  
  
            if( x1<=x && x2>=x && y1<=y && y2>=y )  
                root->Modify(1,m,x,y,val);
        }  
    }  
    return 0;
}

迷失游乐园

(传送门)

题意

n个点、m条边(m只可能等于n或者n-1)。，从当前位置出发，每次随机去一个和当前景点有道路相连的景点，同一个景点不去两次(包括起始景点)。直到当前景点的相邻景点都已经访问过为止。所有经过的景点按顺序构成一条非重复路径，求期望长度。每个景点作为起始点的概率是一样的。

分析

图为树或环加外向树

树：对节点x，考虑向下走和向上走两种情况，期望分别为down[x]和up[x]

环加外向树：对环上每棵树的down[]，同上，考虑环上节点的up[]，k^2大暴力硬算，非环节点的up[]，可由环上节点up[]求出,方法仍同上

无路可走期望=0.0

代码

 

#include <bits/stdc++.h>
using namespace std;

const int  MAXN=100000+10;
int n,m;
int g[MAXN],nxt[MAXN<<1],w[MAXN<<1],v[MAXN<<1],ed,pre[MAXN],ch[MAXN],d[MAXN],fw[MAXN],st,sum;
int cnt,a[MAXN<<1],s[MAXN<<1];
double up[MAXN],down[MAXN],ans,p;
bool vis[MAXN],in[MAXN];
inline void add(int x,int y,int z)
{
  d[x]++;v[++ed]=y;w[ed]=z;nxt[ed]=g[x];g[x]=ed;
}
 
 
void dfs1(int x,int f)
{
  for(int i=g[x];i;i=nxt[i])
    if(v[i]!=f&&!in[v[i]])
        dfs1(v[i],x),ch[x]++,down[x]+=down[v[i]]+w[i];
  if(ch[x])down[x]/=ch[x];
}
 
 
void dfs2(int x,int f)
{
  for(int i=g[x];i;i=nxt[i])
    if(v[i]!=f&&!in[v[i]])
    {
      up[v[i]]=w[i];
      if(d[x]>1)
        up[v[i]]+=(up[x]*(d[x]-ch[x])+down[x]*ch[x]-w[i]-down[v[i]])/(d[x]-1);
      dfs2(v[i],x);
    }
}
 
 
void find(int x,int f,int l)
{
  if(st)return;
  pre[x]=f;fw[x]=l;
  if(vis[x])
  {
    st=f;
    return;
  }
  vis[x]=1;
  for(int i=g[x];i;i=nxt[i])
    if(v[i]!=f)
      find(v[i],x,w[i]);
}
 
 
int main()
{
  scanf("%d%d",&n,&m);
  for(int i=0;i<m;i++)
  {
    int x,y,z;
    scanf("%d%d%d",&x,&y,&z);
    add(x,y,z);
    add(y,x,z);
  }
  if(m<n)
  {
    dfs1(1,0);
    dfs2(1,0);
  }
  else
  {
    find(1,0,0);
    in[a[cnt=1]=st]=1;
    for(int i=pre[st];i!=st;i=pre[i])
      in[a[++cnt]=i]=1;
    for(int i=1;i<=cnt;i++)
    {
      a[i+cnt]=a[i];
      s[i+1]=s[i+cnt+1]=fw[a[i]];
    }
    for(int i=1;i<=cnt;i++)
      dfs1(a[i],0);
    for(int i=1;i<=cnt;i++)
    {
      int j;
      //i->j
      j=i+1;p=0.5;sum=s[j];
      up[a[i]]+=p*(sum+down[a[j]])*ch[a[j]]/(ch[a[j]]+1);
      p/=ch[a[j]]+1;
      for(j=i+2;j<i+cnt-1;j++)
      {
        sum+=s[j];
        up[a[i]]+=p*(sum+down[a[j]])*ch[a[j]]/(ch[a[j]]+1);
        p/=ch[a[j]]+1;
      }
      j=i+cnt-1;
      sum+=s[j];
      up[a[i]]+=p*(sum+down[a[j]]);
      //j<-i
      j=i+cnt-1;p=0.5;sum=s[j+1];
      up[a[i]]+=p*(sum+down[a[j]])*ch[a[j]]/(ch[a[j]]+1);
      p/=ch[a[j]]+1;
      for(j=i+cnt-2;j>i+1;j--)
      {
        sum+=s[j+1];
        up[a[i]]+=p*(sum+down[a[j]])*ch[a[j]]/(ch[a[j]]+1);
        p/=ch[a[j]]+1;
      }
      j=i+1;
      sum+=s[j+1];
      up[a[i]]+=p*(sum+down[a[j]]);
    }
    for(int i=1;i<=cnt;i++)
      dfs2(a[i],0);
  }
  for(int i=1;i<=n;i++)
    ans+=(down[i]*ch[i]+up[i]*(d[i]-ch[i]))/d[i];
  printf("%.5f",ans/n);
  return 0;
}

美食节

(传送门)

题意

n种菜品，每个同学选一个， m个厨师。每个厨师就会同时开始做菜，会按照要求的顺序进行制作，并且每次只能制作一人份。他将菜品用1, 2, ..., n依次编号，厨师用1, 2,..., m依次编号，将第j个厨师制作第i种菜品的时间记为 ti,j。每个同学的等待时间为所有厨师开始做菜起，到自己那份菜品完成为止的时间总长度。总等待时间为所有同学的等待时间之和。知道 pi个同学点了第i种菜品（i=1, 2, ..., n），求最小的总等待时间是多少。

分析

看了一下不满足无后效性所以无法用dp来做，那就考虑它是一道网络流题目。费用流图比较好建，有一个重点是考虑动态加边，即某位厨师在做倒数第k道菜后，再把他做倒数第k+1道菜的边加上

代码

 

#include <bits/stdc++.h>
using namespace std;

#define S 0
#define T 100001
const int INF=0x3f3f3f3f;
const int MAXN=100000+5;

int n,m,tot,ans,t[45][105],c[45];

int cnt=1,head[MAXN];
struct Edge
{
    int from,to,next,c,v;
} edges[MAXN*10];
void ins(int u,int v,int w,int c)
{
    edges[++cnt].from=u;
    edges[cnt].to=v;
    edges[cnt].next=head[u];
    head[u]=cnt;
    edges[cnt].c=c;
    edges[cnt].v=w;
}
void addEdge(int u,int v,int w,int c)
{
    ins(u,v,w,c);
    ins(v,u,0,-c);
}

int d[MAXN],q[MAXN],from[MAXN];
bool vis[MAXN];
bool spfa()
{
    memset(d,0x3f,sizeof(d));
    int h=0,t=1;
    q[0]=0,d[0]=0,vis[0]=1;
    while(h!=t)
    {
        int now=q[h++];
        if(h==T) h=0;
        for(int i=head[now];i;i=edges[i].next)
            if(edges[i].v && d[edges[i].to]>d[now]+edges[i].c)
            {
                d[edges[i].to]=d[now]+edges[i].c;
                from[edges[i].to]=i;
                if(!vis[edges[i].to])
                {
                    vis[edges[i].to]=1;
                    q[t++]=edges[i].to;
                    if(t==T) t=0;
                }
            }
        vis[now]=0;
    }
    return (d[T]!=INF);
}

void mcmf()
{
    int x=INF,a,b,y;
    for(int i=from[T];i;i=from[edges[i].from])
    {
        x=min(x,edges[i].v);
        if(edges[i].from==0)
        {
			y=edges[i].to;
			a=(y-1)/tot+1;
			b=y%tot+1;
		}
    }
    for(int i=from[T];i;i=from[edges[i].from])
    {
		edges[i].v-=x;
		edges[i^1].v+=x;
		ans+=edges[i].c*x;
	}
    for(int i=1;i<=m;i++)//考虑动态加边，某位厨师在做倒数第k道菜后再把他做倒数第k+1道菜的边加上
        addEdge((a-1)*tot+b,n*tot+i,1,b*t[i][a]);
}

int main()
{
    scanf("%d%d",&m,&n);
    for(int i=1;i<=m;i++)
    {
       scanf("%d",&c[i]);
       tot+=c[i];
    }
    for(int i=1;i<=m;i++)
        for(int j=1;j<=n;j++)
            scanf("%d",&t[i][j]);
    for(int i=1;i<=n*tot;i++)
        addEdge(0,i,1,0);
    for(int i=1;i<=m;i++)
        addEdge(n*tot+i,T,c[i],0);
    for(int i=1;i<=n;i++)
       for(int k=1;k<=m;k++)
          addEdge((i-1)*tot+1,n*tot+k,1,t[k][i]);
    while(spfa())
        mcmf();
    printf("%d",ans);
    return 0;
}

xsy97051
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
noi2012试题
12-01
noi比赛试题如何取得题解，大家可以共同学习的PASCAL利器
NOI2018day2后面两个题的题解pdf
07-22
NOI2018day2的情报中心与多边形的两个出题人讲解的pdf
NOI 2012
weixin_30551947的博客
06-04 130
[NOI2012]随机数生成器 矩阵乘法，要注意两数相乘时，可能会爆long long，用快速乘。 #include <iostream> #include <cstdio> #include <cstring> #include <algorithm> using namespace std; long lon...
bzoj2877: [Noi2012]魔幻棋盘 树套数+差分
IED98的专栏
07-13 1361
神题，只能膜拜题解。然后发现了差分这个东西，所谓差分就是sigma{a[i]}=b[i]; a[i]=b[i]-b[i-1];(是不是和辗转相减很像。。。。。) 我们再来看一下二维的怎么做。。然后我们换一种维护的方法。因为题目要求一定会查询到守护者a[x, y]，所以我们以(x, y)为原点，建立直角座标系。二维的一样是得差分，对于第四象限的点：b[i, j] = a[i, j] - a[i-1
Noip2012普及组题解：质因数分解（C++）
liuzich的博客
08-20 1097
题目描述 已知正整数n是两个不同的质数的乘积，试求出较大的那个质数。 输入描述: 输入只有一行，包含一个正整数n。 输出描述: 输出只有一行，包含一个正整数p，即较大的那个质数。 示例1 输入 21 输出 7 备注: 对于60%的数据，6≤n≤1000。 对于100%的数据，6≤n≤2*109。 通过这道题，我发现一个现象，Noip年纪越大的题目难度越大，尽管这是签到题，难度却比后面几年大。 由于这是两个数的乘积，所以求出其中一个就可以得到另一个了，所以我们只需找到小的那个数。 代码： #
兔农 题解 NOI2011
12-29
兔农 题解 NOI 高端矩阵乘法 有模板的意义
noi模拟题2
07-22
AFO后发福利，noi模拟题（有代码，有解题报告），可对拍
noi2016 旷野大计算 题解1
08-03
（听说跳蚤国已占领 NOI 题面了，但我们确实是分开写的题面 233）吕凯风 王逸松 于纪平 张瑞喆旷野大计算旷野大计算题目大意1图片来源：电影《赤壁》吕凯风
力扣每日一题2021-11-30第N位数字
wcy1034036507的博客
11-30 749
第N位数字400.第N位数字题目描述思路模拟Python实现Java实现 400.第N位数字 题目描述 第N位数字 思路 模拟 很容易能发现如下规律： 1位数有9个，共有19个数字 2位数有90个，共有290个数字 3位数有900个，共有3*900个数字 … 如果想知道第N为数字，相当于要找到它是几位数，在那位数中是第几个数字，然后找到这个数字的第几位。 Python实现 class Solution: def findNthDigit(self, n: int) -> int:
【题解】Luogu P2081 [NOI2012]迷失游乐园
weixin_38167363的博客
02-20 147
原题传送门 这是当时冬令营课上讲的题，咕咕咕到了现在 如果这题没有环套树的话，就很套路了 需要两个数组up[i]和down[i]，down[i]表示从i点第一步向下走的期望距离，up[i]表示从i点第一步向上走的期望距离，先求down，然后求up \(down[i]=\frac{\sum_{j|son[i]}(down[j]+len(i,j))}{son[i]}\) \(up[i]=\f...
NOI 2012 随机数生成器
lleozhang的博客
09-17 195
看到全是矩阵的题解，我来一发递推+分治 其实这题一半和poj1845很像（或是1875？一个叫Sumdiv的题） 言归正传，我们看看怎么由f(0)推出f(n) 我们发现，题目中给出了f(n)=af(n-1)+c（取模略过） 那么顺着递推，可得：f(n-1)=af(n-2)+c 代入，得： f(n)=a^2 f(n-2)+(a+1)c 继续递推，得： f(n)=a^n f( 0 )+...
NOIP 2012 题解
阿蒋的专栏
08-11 3079
【D1T1vigenere密码】 P1778vigenere密码 Accepted 标签：[显示标签] 描述16世纪法国外交家Blaise de Vigenère设计了一种多表密码加密算法——Vigenère密码。Vigenère密码的加密解密算法简单易用，且破译难度比较高，曾在美国南北战争中为南军所广泛使用。 在密码学中，我们称需要加密的信息为明文，用M表示；称加
noi2012
worldbuster的专栏
04-18 622
Day1: 骑行川藏(cycling) 题目大意： 总共有n段路程，且已知每段路程的长度s，风阻系数k，风速vi'。 如果在某一时刻的速度是vi，那么所受的风阻大小 F = ki * (vi - vi') ^ 2，如果某段路程 i 的速度都是vi，那么，消耗的能量W = F * sii 已知所消耗的能量之和不能超过Eu，求最短时间T = sigma( si / vi) 题解： 0、需
数学简单 LeetCode292. Nim 游戏 NC230 Nim游戏
31楼下小黑的博客
02-10 1785
NC230 Nim游戏 描述 这是一个经典的博弈。 你和你的朋友，两个人玩一个游戏。 1.桌子上有 n 个石头 2.你和你的朋友轮流取石头，你先手。 3.每一回合可以取 1~3 个石头。 4.轮到你的朋友时桌上没有石头则你获胜，则你的朋友获胜。 你和你的朋友都尽力让自己获胜，如果你有方法必胜，则返回 true ，如果你的朋友有方法必胜，则返回 false import java.util.*; public class Solution { public boolean NimGame (int n
Singapore NOI2012 MODSUM题解
weixin_30273501的博客
09-03 331
MODSUM（modsum.pas/c/cpp） 【问题描述】 在本题中，你得到了一个含有n个参数的函数f： f(x1,…,x2)=(((x1+x2+…+xn)4+2*(x1+x2+…+xn)2) mod 5)+1 为了避免出现争议，函数f只接受整数参数。你的任务是计算f的所有函数值的和，每个参数xi是从vi到wi之间的整数。也就是说，你需要计算 例如，如果n=3，v1=2，w1=3...
[NOI2012]
weixin_30955617的博客
04-26 123
来自FallDream的博客，未经允许，请勿转载，谢谢。 一天一套noi 简直了.... 昨天勉强做完了noi2011 今天教练又丢出来一套noi2012 去掉提答还有5题 勉强做了3题 先占个坑 剩下的明天补补吧 Upd : 终于补完了 2012什么丧题啊 D1T1 随机数生成器 栋栋最近迷上了随机算法，而随机数是生成随机算法的基础。栋栋准备使用线性同余法（Linear C...
NOI 2013 题解
xsy_victory的专栏
06-02 1025
树的计数 向量内积 矩阵游戏 书法家 快餐店
NOI 2002 题解
xsy_victory的专栏
05-29 1013
贪吃的九头龙 银河英雄传说 荒岛野人 机器人M号
NOI 2003 题解
xsy_victory的专栏
05-29 942
木棒游戏 文本编辑器 数据生成器 智破连环阵
[NOI1995] 石子合并 题解
最新发布
08-28
对于这个问题，可以使用动态规划来解决。我们可以定义一个二维数组dp，其中dp[i][j]表示将区间[i, j]的石子合并成一堆所需要的最小代价。 首先，我们可以考虑合并长度为2的石子堆，即dp[i][j] = dp[i][i+1] + dp[i+...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值