NOI2013 小Q的修炼 题解

最新推荐文章于 2022-01-29 23:47:17 发布
最新推荐文章于 2022-01-29 23:47:17 发布
阅读量4.1k 收藏
点赞数 2
分类专栏： IOI/NOI/CTSC/APIO等题解 文章标签： 题解 NOI 提交答案题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiangshibiao/article/details/51459029
版权

感觉这种题答都没有题解，而我又想在这里保存一下代码，就写一份题解咯。


【题意】


一共有M个变量。

有一系列的操作，按顺序标为1~N。操作分为三种：

①普通操作：将一个变量加上一个量。

②条件跳转：给出两个量A、B和两个编号P、Q。

如果A<B那么跳到编号为P的操作，否则跳到编号为Q的操作。

③选择跳转：给出两个编号P、Q。在P和Q中任选一个跳过去。

注意以上的“量”可以是常量，也可以是目前某一个变量的值。

如果什么时候跳转到的编号不在1~N之间，则视为退出游戏。

你要给出选择跳转的决策，使退出游戏的时候第一个变量的值尽量的大。

（数据隐藏条件：跳转满足拓扑序）



【Case1和Case2】

 

C1的决策只有20个，直接DFS一下。

（顺便要写一个比较DJ的读入和模拟器）

发现C2跑了几秒也跑出来了QAQ。

#include<bits/stdc++.h>
#define N 1005
#define x first
#define y second
#define mk make_pair
using namespace std;
typedef pair<bool,int> Pair;
int P[N],Q[N],sign[N],ch[N],ret[N];
Pair A[N],B[N];char str[N][3];
int n,m,ans;
Pair read(){
  char tmp[10];int d;
  scanf("%s%d",tmp,&d);
  if (tmp[0]!='c') fprintf(stderr,"%s %d\n",tmp,d);
  if (tmp[0]=='c') return mk(0,d);
  return mk(1,d);
}
int Read(){
  char tmp[10];
  scanf("%s",tmp);
  return tmp[0]=='+'?1:-1;
}
void DFS(int k,vector<int>now){
  //fprintf(stderr,"%d\n",k);
  for (;k<=n&&str[k][0]!='s';){
    if (str[k][0]=='v') now[A[k].y]+=(B[k].x?now[B[k].y]:B[k].y)*sign[k],k++;
    if (str[k][0]=='i'){
      int t1=A[k].x?now[A[k].y]:A[k].y;
      int t2=B[k].x?now[B[k].y]:B[k].y;
      if (t1<t2) k=P[k];else k=Q[k];
    }
  }
  if (k>n){
    if (now[1]>ans){
      freopen("train2.out","w",stdout);
      fprintf(stderr,"%d\n",ans);
      for (int i=1;i<=*ch;i++)
        printf("%d ",ch[i]);
      ans=now[1];
    }
  }else{
    ch[++*ch]=1;DFS(P[k],now);--*ch;
    ch[++*ch]=2;DFS(Q[k],now);--*ch;
  }
}
int main(){
  freopen("train2.in","r",stdin);
  freopen("train2.out","w",stdout);
  scanf("%d%d",&n,&m);
  for (int i=1;i<=n;i++){
    
    scanf("%s",str[i]);int t;
    if (str[i][0]=='v') scanf("%d",&t),A[i]=mk(1,t),sign[i]=Read(),B[i]=read();
    if (str[i][0]=='i') A[i]=read(),B[i]=read(),scanf("%d%d",&P[i],&Q[i]);
    if (str[i][0]=='s') scanf("%d%d",&P[i],&Q[i]);
    fprintf(stderr,"%d %s\n",i,str[i]);
  }
  fprintf(stderr,"%s\n",str[n]);
  vector<int>now;
  for (int i=0;i<=m+2;i++) 
    now.push_back(i);
  DFS(1,now);
  
}


【Case3】

 

观察数据，发现可以分成一些互不干扰的块。

每一个块里有10个决策，每个决策会增加或减少编号为3~12的变量。

然后块的结尾会依据这3~12的变量给最终要求的1变量增加或减少值。

为什么称为“互不干扰”呢？因为每一块结尾都会把3~12的变量都清空。

然后只要对每一个块分别爆搜，把答案合并起来即可。

//#include<bits/stdc++.h>
#include<stdio.h>
#include<algorithm>
#include<cstring>
#include<vector>
#include "Windows.h"
#define N 350005
#define x first
#define y second
#define mk make_pair
using namespace std;
typedef pair<bool,int> Pair;
int P[N],Q[N],sign[N],ch[66],ret[66],now[66];
Pair A[N],B[N];char str[N][3];
int n,m,ans,best,st;
Pair read(){
  char tmp[10];int d;
  scanf("%s%d",tmp,&d);
  if (tmp[0]=='c') return mk(0,d);
  return mk(1,d);
}
int Read(){
  char tmp[10];scanf("%s",tmp);
  return tmp[0]=='+'?1:-1;
}
void DFS(int x){
  //fprintf(stderr,"%d ",x);
  if (x>10){
    int get=0,b=10*12+st;
    for (int i=b;i<b+170;i++){
      //fprintf(stderr,"%d\n",i);
      if (str[i][0]=='i'){
        int t1=A[i].x?now[A[i].y]:A[i].y;
        int t2=B[i].x?now[B[i].y]:B[i].y;
        if (t1<t2) i=P[i]-1;else i=Q[i]-1;
      }else if (A[i].y==1)
        get+=sign[i]*(B[i].x?now[B[i].y]:B[i].y);
    }
    if (get>best) 
      best=get,memcpy(ret,ch,sizeof(ch));
    return;
  }
  ch[x]=2;DFS(x+1);
  int b=st+(x-1)*12;
  for (int i=1;i<=10;i++)
    now[i+2]+=B[b+i].y;
  ch[x]=1;DFS(x+1);
  for (int i=1;i<=10;i++)
    now[i+2]-=B[b+i].y;
}
int main(){
  freopen("train3.in","r",stdin);
  freopen("train3.out","w",stdout);
  scanf("%d%d",&n,&m);
  for (int i=1;i<=n;i++){
    scanf("%s",str[i]);int t;
    if (str[i][0]=='v') scanf("%d",&t),A[i]=mk(1,t),sign[i]=Read(),B[i]=read();
    if (str[i][0]=='i') A[i]=read(),B[i]=read(),scanf("%d%d",&P[i],&Q[i]);
    if (str[i][0]=='s') scanf("%d%d",&P[i],&Q[i]);
  }fprintf(stderr,"Start\n");
  for (st=1;st<=n;st+=170){
    best=0;
    for (int i=3;i<=12;i++) now[i]=0;
    DFS(1);
    ans+=best;fprintf(stderr,"%d %d\n",st,best);
    for (int k=1;k<=10;k++)
      printf("%d ",ret[k]);
  }fprintf(stderr,"%d\n",ans);
  return 0;
}


【Case4~6】

 

发现只有两个变量。

2变量的增减都比较小，而且所有的条件跳转都只和2变量有关。

这就可以想到按顺序DP下去，每次记录当前2变量的值是多少即可。

最后再回去输出方案。说起来比较轻松，实际还是有很多细节的。

为了方便，DP的意义可以从“做完第i个操作，2变量的值为k”改成“做第i个操作之前，2变量的值为k”这样。

写完之后大概改一下也可以过第5个点。

//#include<bits/stdc++.h>
#include<stdio.h>
#include<algorithm>
#include<cstring>
#include<vector>
#define N 10005
#define x first
#define y second
#define mk make_pair
using namespace std;
typedef pair<bool,int> Pair;
int P[N],Q[N],sign[N];
Pair A[N],B[N];char str[N][3];
struct data{
  int v,prei,prek,ch;
  void Min(int _v,int _ch,int _prei,int _prek){
    if (_v<=v) return;
    v=_v;ch=_ch;prei=_prei;prek=_prek;
  }
  int operator < (const data &b)const{return v<b.v;}
}F[6005][N],ans;int n,m;
Pair read(){
  char tmp[10];int d;
  scanf("%s%d",tmp,&d);
  if (tmp[0]=='c') return mk(0,d);
  return mk(1,d);
}
int Read(){
  char tmp[10];
  scanf("%s",tmp);
  return tmp[0]=='+'?1:-1;
}
int Case=0;
void DFS(int i,int k){
  //fprintf(stderr,"%d %d\n",i,k);
  //if ((++Case)==20) return;
  if (i<=2) return;
  DFS(F[i][k].prei,F[i][k].prek);
  if (F[i][k].ch>-1) printf("%d ",F[i][k].ch);
}
int main(){
  freopen("train5.in","r",stdin);
  freopen("train5.out","w",stdout);
  scanf("%d%d",&n,&m);
  for (int i=1;i<=n;i++){
    scanf("%s",str[i]);int t;
    if (str[i][0]=='v') scanf("%d",&t),A[i]=mk(1,t),sign[i]=Read(),B[i]=read();
    if (str[i][0]=='i') A[i]=read(),B[i]=read(),scanf("%d%d",&P[i],&Q[i]);
    if (str[i][0]=='s') scanf("%d%d",&P[i],&Q[i]);
  }
  //F[i][k] 做第i行之前，v2的值为k的最大的v1的值
  //for (int i=0;i<=n+1;i++) F[i]=f[i]+N/2;int bug=0;
  for (int i=0;i<=n+1;i++) for (int k=0;k<N;k++) F[i][k].v=-1e9;
  F[2][5000].v=0;ans.v=-1e9;
  for (int i=2;i<=n;i++)
    for (int k=0;k<N;k++) 
      if (F[i][k].v>-1e9){
        //printf("%d %d %d\n",i,k,F[i][k].v);
        if (str[i][0]=='v'){
          int newk=k,newv=F[i][k].v;
          if (A[i].x&&A[i].y==2)
            newk+=sign[i]*B[i].y;
          else if (A[i].x&&A[i].y==1)
            newv+=sign[i]*B[i].y;
          //if (i==6)
            //fprintf(stderr,"%d %d\n",newv,newk);
          F[i+1][newk].Min(newv,-1,i,k);
        }else if (str[i][0]=='i'){
          //if (bug) fprintf(stderr,"%d %d\n%d %d\n",A[i].x,A[i].y,B[i].x,B[i].y);
          int t1=A[i].x?k:A[i].y;
          int t2=B[i].x?k:B[i].y,newi;
          //if (bug) fprintf(stderr,"%d %d\n",t1,t2);
          if (t1<t2) newi=P[i];else newi=Q[i];
          //if (bug) fprintf(stderr,"Newi:%d\n",newi);
          if (i==8)
            fprintf(stderr,"%d %d %d %d\n",t1,t2,newi,F[i][k].v);
          if (newi>=1&&newi<=n)
            F[newi][k].Min(F[i][k].v,-1,i,k);
          else ans=max(ans,(data){F[i][k].v,i,k});
        }else {
          if (P[i]>=1&&P[i]<=n)
            F[P[i]][k].Min(F[i][k].v,1,i,k);
          else ans=max(ans,(data){F[i][k].v,i,k});
          if (Q[i]>=1&&Q[i]<=n)
            F[Q[i]][k].Min(F[i][k].v,2,i,k);
          else ans=max(ans,(data){F[i][k].v,i,k});
        }
      }
  fprintf(stderr,"Type1Ans:%d %d\n",ans.v,n);
  for (int k=0;k<N;k++)
    ans=max(ans,(data){F[n+1][k].v,n+1,k});
  fprintf(stderr,"Type2Ans:%d\n",ans.v);
  DFS(ans.prei,ans.prek);
}



【Case7~8】

 

首先和之前的一个点差不多，发现这些操作可以分成几组，每组格式类似。

发现每组的开头有些和2变量有关的判断：若2的值怎么怎么样强制你跳到后面一块。

否则的话，你也有对这一块的决策权：即你仍然有机会能跳出这一块。

如果你跳进这一块的话，可以像之前爆搜的那样搜出一些变量的取值。

在最外面再套一个DP，记录变量2的状态、决策是否进去某一块啥的。

找方案的时候可能更加麻烦。

//#include<bits/stdc++.h>
#include<stdio.h>
#include<algorithm>
#include<cstring>
#include<vector>
#include "Windows.h"
#define N 35005
#define M 1005
#define x first
#define y second
#define mk make_pair
using namespace std;
typedef pair<bool,int> Pair;
int ret[205][21],best[205];
int P[N],Q[N],sign[N],ch[21],now[66];
Pair A[N],B[N];char str[N][3];
int F[N][M],pre[N][M],walk[N][M],extra[N][M];
int n,m,ans,st,i,k,newk,tmp,tot;
Pair read(){
  char tmp[10];int d;
  scanf("%s%d",tmp,&d);
  if (tmp[0]=='c') return mk(0,d);
  return mk(1,d);
}
int Read(){
  char tmp[10];scanf("%s",tmp);
  return tmp[0]=='+'?1:-1;
}
void DFS(int x){
  //fprintf(stderr,"%d ",x);
  if (x>10){
    int get=0,b=st+12*10;
    for (int i=b;i<st+175;i++){
      //fprintf(stderr,"%d\n",i);
      if (str[i][0]=='i'){
        int t1=A[i].x?now[A[i].y]:A[i].y;
        int t2=B[i].x?now[B[i].y]:B[i].y;
        if (t1<t2) i=P[i]-1;else i=Q[i]-1;
      }else if (A[i].y==1)
        get+=sign[i]*(B[i].x?now[B[i].y]:B[i].y);
    }
    if (get>best[tot]) 
      best[tot]=get,memcpy(ret[tot],ch,sizeof(ch));
    return;
  }
  ch[x]=2;DFS(x+1);
  int b=st+(x-1)*12;
  for (int i=1;i<=10;i++)
    now[i+2]+=B[b+i].y;
  ch[x]=1;DFS(x+1);
  for (int i=1;i<=10;i++)
    now[i+2]-=B[b+i].y;
}
void BACK(int i,int k){
  if (i<=1) return;
  fprintf(stderr,"%d %d %d %d %d\n",i,k,F[i][k],walk[i][k],extra[i][k]);
  BACK(i-1,pre[i][k]);
  if (walk[i][k]!=-1) 
    printf("%d ",walk[i][k]),assert(walk[i][k]>0);
  if (extra[i][k])
    for (int c=1;c<=10;c++)
      printf("%d ",ret[extra[i][k]][c]);
}
int main(){
  freopen("train8.in","r",stdin);
  freopen("train8.out","w",stdout);
  scanf("%d%d",&n,&m);
  for (i=1;i<=n;i++){
    scanf("%s",str[i]);int t;
    if (str[i][0]=='v') scanf("%d",&t),A[i]=mk(1,t),sign[i]=Read(),B[i]=read();
    if (str[i][0]=='i') A[i]=read(),B[i]=read(),scanf("%d%d",&P[i],&Q[i]);
    if (str[i][0]=='s') scanf("%d%d",&P[i],&Q[i]);
  }fprintf(stderr,"Start\n");
  for (st=6;st<=n;st+=175){
    best[++tot]=0;
    assert(str[st][0]=='s');
    for (i=3;i<=12;i++) now[i]=0;
    DFS(1);
    fprintf(stderr,"%d %d\n",st,best[tot]);
    for (k=1;k<=10;k++)
      assert(ret[tot][k]>0);
  }
  for (i=0;i<=tot+1;i++)
    for (k=0;k<M;k++) F[i][k]=-1e9;
  F[1][1000]=0;assert(tot==200);
  for (i=1;i<=tot;i++)
    for (k=0;k<M;k++)
      if (F[i][k]>-1e9){
        //fprintf(stderr,"%d %d %d\n",i,k,F[i][k]);
        st=1+(i-1)*175+1;
        assert(str[st][0]=='i'&&A[st].y==2);
        if (k<B[st].y){
          if (F[i][k]>F[i+1][k])
            F[i+1][k]=F[i][k],pre[i+1][k]=k,walk[i+1][k]=-1,extra[i+1][k]=0;
          continue;
        }st+=2;assert(str[st][0]=='s');
        if (F[i][k]>F[i+1][k])
          F[i+1][k]=F[i][k],pre[i+1][k]=k,walk[i+1][k]=2,extra[i+1][k]=0;
        ++st;assert(A[st].y==2&&B[st].x==0);
        //fprintf(stderr,"%d %d\n",sign[st],B[st].y);
        newk=k+sign[st]*B[st].y;
        if (newk>k) 
          fprintf(stderr,"%d %d\n",i,k);
        assert(newk<=k);
        //fprintf(stderr,"%d\n",F[i][k]+best[i]);
        if (F[i][k]+best[i]>F[i+1][newk])
          F[i+1][newk]=F[i][k]+best[i],pre[i+1][newk]=k,walk[i+1][newk]=1,extra[i+1][newk]=i;
      }
  fprintf(stderr,"%d %d\n",F[tot][500],F[tot+1][500]);
  for (k=0;k<M;k++)
    if (F[tot+1][k]>ans)
      ans=F[tot+1][k],tmp=k;
  fprintf(stderr,"%d\n",ans);
  BACK(tot+1,tmp);
  return 0;
}



【Case9~10】

 

这两个点感觉和之前的特别像。

但是我用之前的程序跑怎么也跑不过。后来发现了一些坑。

首先，循环节的长度稍微变化了一下。

然后假设循环节的长度为L，我发现操作数竟然不是L的倍数！

这是怎么回事呢？大概看一下，发现几千行的一个地方不是按照原来的规律在变化。

可以称这些地方为"噪点”。

如果再找出一行“噪点”，就可以大概归纳出其性质，然后把它们删掉即可。

对于删掉后的数据我还是搞了很长时间：显然我把每一条操作重新编号了。

因为在跳转的时候，编号还是会按照原先数据的编号，所以要搞一个比较麻烦的映射。

此外我记得还有很多细节，比如在块之间跳跃的时候，好像还可以往后跳好几块啥的，总之特别坑。

#include<bits/stdc++.h>
#include<stdio.h>
#include<algorithm>
#include<cstring>
#include<vector>
#include "Windows.h"
#define N 35005
#define M 1005
#define x first
#define y second
#define mk make_pair
using namespace std;
typedef pair<bool,int> Pair;
int ret[205][21],best[205],S[1005];
int P[N],Q[N],index[N],pos[N],sign[N],ch[21],now[66];
Pair A[N],B[N];char str[N][3];
int F[N][M],prei[N][M],prek[N][M],walk[N][M],extra[N][M];
int n,m,ans,st,i,k,newk,newi,tmpi,tmpk,tot,j;
Pair read(){
  char tmp[10];int d;
  scanf("%s%d",tmp,&d);
  if (tmp[0]=='c') return mk(0,d);
  return mk(1,d);
}
int Read(){
  char tmp[10];scanf("%s",tmp);
  return tmp[0]=='+'?1:-1;
}
int bug=0;
void DFS(int x){
  if (x>10){
    if (bug) 
			assert(str[st+12*10][0]=='i'&&A[st+12*10].y==3);
    int get=0,b=st+12*10;
    for (int i=b;i<st+174;i++){
      //fprintf(stderr,"%d\n",i);
      if (str[i][0]=='i'){
        int t1=A[i].x?now[A[i].y]:A[i].y;
        int t2=B[i].x?now[B[i].y]:B[i].y;
        if (t1<t2) i=P[i]-1;else i=Q[i]-1;
      }else if (A[i].y==1)
        get+=sign[i]*(B[i].x?now[B[i].y]:B[i].y);
    }//if (bug) fprintf(stderr,"%d\n",get);
    if (get>best[tot]) 
      best[tot]=get,memcpy(ret[tot],ch,sizeof(ch));
    return;
  }
  ch[x]=2;DFS(x+1);
  int b=st+(x-1)*12;
  for (int i=1;i<=10;i++)
    now[i+2]+=B[b+i].y;
  ch[x]=1;DFS(x+1);
  for (int i=1;i<=10;i++)
    now[i+2]-=B[b+i].y;
}
void BACK(int i,int k){
  if (i<=1) return;
  //fprintf(stderr,"%d %d %d %d %d\n",i,k,F[i][k],walk[i][k],extra[i][k]);
  BACK(prei[i][k],prek[i][k]);
  //fprintf(stderr,"%d\n",i);
  if (walk[i][k]!=-1) 
    printf("%d ",walk[i][k]),assert(walk[i][k]>0);
  if (extra[i][k])
    for (int c=1;c<=10;c++)
      printf("%d ",ret[extra[i][k]][c]);
}
int calc(int x){
	for (int i=1;i<=*S;i++)
		if (S[i]==x){
			int j=i;
			for (;j<*S&&S[j+1]==S[j]+1;++j);
			x=S[j]+1;break;
	  }
	x-=lower_bound(S+1,S+*S+1,x)-(S+1);
	return x;
}
int main(){
  freopen("train10.in","r",stdin);
  scanf("%d%d",&n,&m);n-=8;int last=0;
  for (i=1,j=1;i<=n;i++,j++){
    scanf("%s",str[i]);int t;index[i]=j;
    if (str[i][0]=='v') scanf("%d",&t),A[i]=mk(1,t),sign[i]=Read(),B[i]=read();
    if (str[i][0]=='i') A[i]=read(),B[i]=read(),scanf("%d%d",&P[i],&Q[i]);
    if (str[i][0]=='s') scanf("%d%d",&P[i],&Q[i]);
    if (i%174==2&&i>10) 
      if (!A[i].x) 
        assert(str[i][0]!='s'),i--,n--,S[++*S]=j;
  }printf("%d ",n);
  for (i=1;i<=n;i++)
  	P[i]=calc(P[i]),Q[i]=calc(Q[i]);
  for (st=6;st<=n;st+=174){
    best[++tot]=-1e9;
    assert(str[st][0]=='s');
    for (i=3;i<=12;i++) now[i]=0;
    DFS(1);
    //fprintf(stderr,"%d %d\n",st,best[tot]);
    for (k=1;k<=10;k++)
      assert(ret[tot][k]>0);//fprintf(stderr,"%d ",ret[tot][k]);
  }assert(tot==200);
  bug=0;tot=0;
  for (st=2;st<=n;st+=174) pos[st]=++tot;
  for (i=0;i<=tot+1;i++)
    for (k=0;k<M;k++) F[i][k]=-1e9;
  F[1][1000]=0;
  for (i=1;i<=tot;i++)
    for (k=0;k<M;k++)
      if (F[i][k]>-1e9){
        //fprintf(stderr,"%d %d %d\n",i,k,F[i][k]);
        st=1+(i-1)*174+1;
        assert(str[st][0]=='i'&&A[st].y==2);
        if (k<B[st].y){
        	if (P[st+1]>=1&&P[st+1]<=n){
            //printf("%d %d %d\n",st+1,index[P[st+1]],index[Q[st+1]]);
            newi=pos[P[st+1]];assert(newi);
            if (F[i][k]>F[newi][k])
              F[newi][k]=F[i][k],prei[newi][k]=i,prek[newi][k]=k,
              walk[newi][k]=-1,extra[newi][k]=0;
          }else 
            if (F[i][k]>F[tot+1][k])
              F[tot+1][k]=F[i][k],prei[tot+1][k]=i,prek[tot+1][k]=k,
              walk[tot+1][k]=-1,extra[tot+1][k]=0;
          continue;
        }st+=2;assert(str[st][0]=='s');
        if (Q[st]<1||Q[st]>n){
          if (F[i][k]>F[tot+1][k])
            F[tot+1][k]=F[i][k],prei[tot+1][k]=i,prek[tot+1][k]=k,
            walk[tot+1][k]=2,extra[tot+1][k]=0;
        }else{
          assert(pos[Q[st]]);
          newi=pos[Q[st]];
          if (F[i][k]>F[newi][k])
            F[newi][k]=F[i][k],prei[newi][k]=i,prek[newi][k]=k,
            walk[newi][k]=2,extra[newi][k]=0;
        }
        ++st;assert(A[st].y==2&&B[st].x==0);
        //fprintf(stderr,"%d %d\n",sign[st],B[st].y);
        newk=k+sign[st]*B[st].y;
        assert(newk<=k);
        //fprintf(stderr,"%d\n",F[i][k]+best[i]);
        if (F[i][k]+best[i]>F[i+1][newk])
          F[i+1][newk]=F[i][k]+best[i],prei[i+1][newk]=i,prek[i+1][newk]=k,
          walk[i+1][newk]=1,extra[i+1][newk]=i;
      }
  //fprintf(stderr,"%d %d\n",F[tot][500],F[tot+1][500]);
  for (k=0;k<M;k++)
    if (F[tot+1][k]>ans)
      ans=F[tot+1][k],tmpi=tot+1,tmpk=k;
  fprintf(stderr,"%d\n",ans);
  freopen("train10.out","w",stdout);
  BACK(tmpi,tmpk);
  return 0;
}

阿蒋
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
NOI测试数据
04-03
NOI2013Day2测试数据
P1335 [NOI2013] 小Q的修炼 题解
ApocalypseTq的博客
08-20 1303
感觉这种题答都没有题解，而我又想在这里保存一下代码，就写一份题解咯。 【题意】 一共有M个变量。 有一系列的操作，按顺序标为1~N。操作分为三种： ①普通操作：将一个变量加上一个量。 ②条件跳转：给出两个量A、B和两个编号P、Q。 如果A<B那么跳到编号为P的操作，否则跳到编号为Q的操作。 ③选择跳转：给出两个编号P、Q。在P和Q中任选一个跳过去。 注意以上的“量”可以是常量，也可以是目前某一个变量的值。 如果什么时候跳转到的编号不在1~N之间，则视为退出游戏。 你要给出选择跳转的
UOJ#123. 【NOI2013】小Q的修炼
L_0_Forever_LF的专栏
06-23 1669
第一次完整做完一道题答…. 这道题答似乎算是十分友好的 前面几个点的代码没存，只有最后几个点的代码（不过后来看了一下感觉这个代码是能跑所有点的） case1,2 写个暴力遍历所有情况，case2要跑一会 case3 我们看一下这个train3.in 发现他分成了很多块，每个块的大小是170，在每个块内他会对变量２～１２修改，在块的末尾，他会让１加上这些变量，然后把除了２的变量清空（变...
uoj123 【NOI2013】小Q的修炼
aida9573的博客
05-02 608
搞了一下午+半晚上。其实不是很难。 提答题重要的是要发现数据的特殊性质，然后根据不同数据写出不同的算法获得其对应的分数。 首先前两个测试点我们发现可以直接暴搜通过，事实上对于每个数据都暴搜加上一定的次数限制，都可以获得两分的好成绩。 1 #include <cstdio> 2 #include <cstring> 3 #include &l...
「NOI2013」小 Q 的修炼 解题报告
weixin_30636089的博客
04-12 559
「NOI2013」小 Q 的修炼 第一次完整的做出一个提答，花了半个晚上+一个上午+半个下午 总体来说太慢了 对于此题，我认为的难点是观察数据并猜测性质和读入操作 我隔一会就思考这个sb字符串读起来怎么这么麻烦啊 首先可以发现，这个所有的选择都之后往后走，就是个topo图 task1,2,3 观察到数据有形如 s x x+11 v 3 + c y v 4 + c y v 5 + c y v 6...
BZOJ 3240 [Noi2013] 矩阵游戏 题解
阿蒋的专栏
04-27 3928
【原题】
NOI2013数据
03-02
【标题】"NOI2013数据"指的是2013年中国信息学奥林匹克竞赛（National Olympiad in Informatics, NOI）的比赛数据。这个标题暗示了我们即将探讨的是与编程竞赛、算法设计和问题解决相关的知识领域。 【描述】"NOI...
NOI2013笔试
04-03
考试资源NOI2013笔试
P4252 NOI2006 聪明的导游 题解
最新发布
09-14
【P4252 NOI2006 聪明的导游 题解】是针对全国信息学奥林匹克竞赛（NOI）2006年的一道编程题目进行的解答分析，主要涉及到C++编程语言的应用。这道题目可能是关于算法设计和数据结构的运用，因为NOI比赛通常涵盖这些...
noi2016 旷野大计算 题解1
08-03
【旷野大计算】是NOI（全国青少年信息学奥林匹克竞赛）在2016年推出的一道竞赛题目，由清华大学的吕凯风、王逸松、于纪平和张瑞喆共同设计和验证。这道题目的核心是构建计算网络来解决一系列计算任务，考验参赛者的...
NOI2018day2后面两个题的题解pdf
07-22
《NOI2018day2后面两个题的题解pdf》是一份针对全国青少年信息学奥林匹克竞赛（NOI）2018年第二天比赛的深度解析文档，由出题人亲自讲解，旨在帮助参赛者理解和掌握比赛中的关键知识点。这份资源包含两个部分：...
[NOI2013]向量内积
七代目鸽影
08-08 295
随机化是真的很牛皮，也很离谱。
洛谷 P1687 机器人小Q 题解
Lotuses的博客
08-16 373
我看这题似乎没有将状态转移方程讲清楚的题解啊，所以我来了 入题。 看到这题，我立马想到贪心。 对题意，我的错误的理解为：对于任意一个能量菜单上的能量值都可以在任意时间充电。这样，就可以直接排序选前kkk个最小值进行充电。 然后，我看到了此题的颜色：普及+/提高 这题不简单！ 于是，我就看到了讨论中的： 贪心60分求助 算法疑问 是题目问题还是我的问题 哦原来是 按一定顺序 给出了 NNN 个单位的能量值，使用也得 按一定顺序 。也就是说，用了第 iii 个后，第 iii 个之前的就不能再用了。 好了，排序
[NOI2013] 矩阵游戏 题解
莫莫 dicol 的博客
09-25 249
[NOI2013] 矩阵游戏 [NOI2013] 矩阵游戏 各位我是弱智石锤了。 题目可能不是很难但是有点细节要注意。 首先考虑行和列我们分别来看： 对于列的情况我们只需要前一项即可递推。 对于行的情况我们只需要上一项也可递推。 那么本质上题目就提示我们可以只保留一项进行矩阵快速幂。 不妨设答案矩阵是 [1fm] \left[ \begin{matrix} 1 & f_m \end{matrix} \right] [1​fm​​] 我们考虑首先递推同一行之后再递推列，最后一行单独拿出来处
NOI2013 树的计数
ylsoi的博客
06-18 479
NOI2013 树的计数 给定一个dfs序和bfs序，求解符合这两个条件的所有树的平均树高。 思路 如果我们能够给bfs序中每一段区间分层，然后再去对应dfs序，不难发现可以唯一确定一棵树，即在dfs的过程中，前后两个节点的关系可以按照层数来判断，分为儿子或者是某一层祖先的另外一个儿子。 而给bfs序分层的时候我们需要满足一些限制： bfs序中同一层在dfs中访问顺序必须严格按照bfs的访问顺序...
2022.1.29 训练日记 5 AcWing 2005. 马蹄铁
小Q的博客
01-29 105
题目链接：马蹄铁 题目分析： 0.dfs暴力搜索题。 1.s[N][N] 存储图,如果s[1][1]==’)’提前结束，因为题目要求路径为(((…)))这种格式 st[N][N]记录走过的路径 一般来说，捡马蹄的方式为先捡 ( ,如果捡了 ) 那么之后就只能捡 ) ,直到 ( 的数目和 ) 的 数目一样多。 dfs(x,y,l,r) ==> x,y为当前位置 , L 为已经捡了L个’（‘型马蹄铁，R为已经捡了R个’）‘型马蹄铁 code: #include <iostream&gt
bzoj AC倒序
热门推荐
weixin_30819085的博客
08-23 2万+
Search GO 说明：输入题号直接进入相应题目，如需搜索含数字的题目，请在关键词前加单引号 Problem ID Title Source AC Submit Y 1000 A+B Problem 10983 18765 Y 1036 [ZJOI2008]树的统计Count 5293 13132 Y 1588 [HNOI2002]营业额统计 5056 13607 100...
小Q系列故事——电梯里的爱情
chengmaoning的专栏
03-24 1197
Problem Description 　　细心的同事发现，小Ｑ最近喜欢乘电梯上上下下，究其原因，也许只有小Ｑ自己知道：在电梯里经常可以遇到他心中的女神HR。 　　电梯其实是个很暧昧的地方，只有在电梯里，小Q才有勇气如此近距离接近女神，虽然觉得有点不自在，但次数多了，女神也习惯了小Ｑ的存在，甚至熟悉到仿佛不说上句话自己也都觉得不合适了。可是，他们的谈话也仅仅限于今天天气不错啊或是你吃了吗之类的
P1398 [NOI2013]书法家
weixin_30667301的博客
09-18 197
传送门 就是个普及组 $dp$ 合集，把 $NOI$ 从左到右拆成 $9$ 个部分，每个部分都可以分别 $dp$ 除了 $N$ 的中间部分比较恶心以外其他都还好，自己推一下然后就知道转移，就 $N$ 的中间优化转移比较不好写 随便吧，反正 $9$ 个 $dp$ 都挺简单的，量变导致质变，我在想那一年的选手是不是都被恶心到了...反正我是被恶心死了 $luogu$ 上这一题空间限制...
[NOI1995] 石子合并 题解
08-28
对于这个问题，可以使用动态规划来解决。我们可以定义一个二维数组dp，其中dp[i][j]表示将区间[i, j]的石子合并成一堆所需要的最小代价。 首先，我们可以考虑合并长度为2的石子堆，即dp[i][j] = dp[i][i+1] + dp[i+2][j] + sum(i, j)，其中sum(i, j)表示区间[i, j]的石子堆的总和。然后，我们可以逐步增加合并的长度，直到合并整个区间。 具体的动态规划转移方程如下： dp[i][j] = min(dp[i][k] + dp[k+1][j] + sum(i, j))，其中i ≤ k < j 最后，所求的答案即为dp[n]，其中n为石子堆的数量。 以下是C++的代码实现： ```cpp const int MAXN = 105; int dp[MAXN][MAXN]; int sum[MAXN]; int main() { int n; cin >> n; for (int i = 1; i <= n; i++) { cin >> sum[i]; sum[i] += sum[i-1]; // 计算前缀和 } for (int len = 2; len <= n; len++) { for (int i = 1; i + len - 1 <= n; i++) { int j = i + len - 1; dp[i][j] = INT_MAX; for (int k = i; k < j; k++) { dp[i][j] = min(dp[i][j], dp[i][k] + dp[k+1][j] + sum[j] - sum[i-1]); } } } cout << dp[1][n] << endl; return 0; } ``` 希望这个解法能够帮助你解决问题！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值