NOIP难题汇总

一下是本蒟蒻认为近几年来NOIP提高组比较难的题目,神犇觉得太水请手动关闭:-)

 

TOP10 NOIP 2010 关押罪犯
主要考点:并查集

 开两倍并查集，f[i],f[j+n]表示ｉ和ｊ在不同的监狱。利
用a与b不在一个监狱，b与c不在一个监狱，则a与c必定
在一个监狱这一性质合并集合。

#include<set>
#include<map>
#include<queue>
#include<stack>
#include<ctime>
#include<cmath>
#include<string>
#include<vector>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
struct data{
  int a,b,w;
}e[100010];
int k[40010];
int cmp(const data &A,const data &B)
{
  return A.w>B.w;
}
int find(int x)
{
  if(k[x]==x) return x;
  else {k[x]=find(k[x]);return k[x];}
}
int main()
{
  int n,m;
  scanf("%d%d",&n,&m);
  for(int i=1;i<=m;i++)
    scanf("%d%d%d",&e[i].a,&e[i].b,&e[i].w);
  for(int i=1;i<=2*n;i++)
    k[i]=i;
  sort(e+1,e+m+1,cmp);
  for(int i=1;i<=m;i++)
    {
      int p=find(e[i].a),q=find(e[i].b);
      if(p==q) {printf("%d",e[i].w);return 0;}
      k[p]=find(e[i].b+n),k[q]=find(e[i].a+n);
    }
  printf("0");
  return 0;
}

 

TOP9 NOIP 2015 运输计划

主要考点:二分,树上差分,lca.
二分一个答案now.
那些距离小于now的点对就不用管了.
先统计那些距离大于now的点的个数和最大的距离.
然后现在要将一条边的边权赋为0,那么就肯定要找到一条所有未排除点对都经过的边,且这条边的边权最大.
假设已经找到了这条边,那么就只用判断减去这条边的边权之后最大的点对距离是否<=now
现在问题是怎么找这条边.
直接用线段树区间加法应该是会TLE的,考虑只用最后一次询问操作,可以使用树上差分.
注意递归版的树上差分常数较大,可以记一个BFS序写成非递归版.

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<algorithm>
#include<map>
#include<complex>
#include<queue>
#include<stack>
#include<cmath>
#include<set>
#include<vector>
#define maxn 300010
#define RG register
using namespace std;
struct data{
  int nex,to,w;
}e[maxn*2];
struct note{
  int x,y,lca,dis;
}q[maxn];
int head[maxn],edge=0,n,m;
int que[maxn],rk[maxn],size[maxn],top[maxn],dad[maxn],son[maxn],deep[maxn],tmp[maxn],dis[maxn],up[maxn];
bool vis[maxn];
inline void add(int from,int to,int w){
  e[++edge].nex=head[from];
  e[edge].to=to;
  e[edge].w=w;
  head[from]=edge;
}
void dfs1(int x,int fa){
  size[x]=1;
  for(int i=head[x];i;i=e[i].nex){
    RG int v=e[i].to;
    if(v==fa) continue;
    dad[v]=x;deep[v]=deep[x]+1;
    dis[v]=dis[x]+e[i].w;
    up[v]=e[i].w;
    dfs1(v,x);
    size[x]+=size[v];
    if(size[v]>size[son[x]])son[x]=v;
  }
}
void dfs2(int x,int fa){
  if(son[x]) top[son[x]]=top[x],dfs2(son[x],x);
  for(RG int i=head[x];i;i=e[i].nex){
    RG int v=e[i].to;
    if(v==fa || v==son[x]) continue;
    top[v]=v;
    dfs2(v,x);
  }
}
inline int lca(int x,int y){
  while(top[x]!=top[y]){
    if(deep[top[x]]>deep[top[y]]) x=dad[top[x]];
    else y=dad[top[y]];
  }
  return deep[x]<deep[y]?x:y;
}
inline void bfs(){
  RG int h=1,t=1,tot=1;
  que[h]=1,rk[tot]=1;
  while(h<=t){
    RG int u=que[h++];vis[u]=1;
    for(RG int i=head[u];i;i=e[i].nex){
      RG int v=e[i].to;
      if(!vis[v])rk[++tot]=v,que[++t]=v;
    }
  }
}
inline bool check(int now){
  RG int tot=0,zd=0,zd1=0,sp=0;
  for(RG int i=1;i<=m;i++)
    if(q[i].dis>now) tmp[q[i].x]++,tmp[q[i].y]++,tmp[q[i].lca]-=2,tot++,zd=max(zd,q[i].dis-now);
  if(tot==0) return 1;
  for(RG int i=n;i>1;i--){
    tmp[dad[rk[i]]]+=tmp[rk[i]];
    if(tmp[rk[i]]>zd1) zd1=tmp[rk[i]],sp=rk[i];
    else if(tmp[rk[i]]==zd1 && up[rk[i]]>up[sp]) sp=rk[i];
    tmp[rk[i]]=0;
  }
  if(zd1<tot || zd-up[sp]>0)return 0;
  return 1;
}
int main(){
  RG int l=0,r=0,x,y,z;
  scanf("%d%d",&n,&m);
  for(RG int i=1;i<n;i++)
    scanf("%d%d%d",&x,&y,&z),add(x,y,z),add(y,x,z);
  top[1]=deep[1]=dad[1]=1;
  dfs1(1,0),dfs2(1,0),bfs();
  for(RG int i=1;i<=m;i++){
    scanf("%d%d",&q[i].x,&q[i].y);
    q[i].lca=lca(q[i].x,q[i].y);
    q[i].dis=dis[q[i].x]+dis[q[i].y]-2*dis[q[i].lca];
    r=max(r,q[i].dis);
  }
  while(l<=r){
    RG int mid=(l+r)>>1;
    check(mid)?r=mid-1:l=mid+1;
  }
  printf("%d",l);
  return 0;
}

TOP8 NOIP 2008 双栈排序

主要考点:二分图模型.
考虑把不能放在一个栈里面的两个点连边.
那么能否进行双栈排序,取决于这是否是一个二分图.
考虑满足什么条件的两个点不能在一个栈里面.
设i<j
若a[i]>a[j],这两个点肯定是可以在一个栈里面的.
若a[i]<a[j],且存在k>j,a[k]<a[i],这两个点不能在一个栈里面.
因为一个栈中的最小值只能是栈顶,又因为k还没有入栈,所以i还不能出栈,所以j还不能入栈.
二分图染色之后就判断了每个点是在哪个栈里面.
然后开一个now标记表示下一个出栈的是什么.
模拟即可.

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<algorithm>
#include<map>
#include<complex>
#include<queue>
#include<stack>
#include<cmath>
#include<set>
#include<vector>
#define maxn 1010
using namespace std;
int a[maxn],co[maxn],w[maxn][maxn],f[maxn],s1[maxn],s2[maxn],top1=0,top2=0,n;
void dfs(int x){
  for(int i=1;i<=n;i++)
    if(w[x][i]){
      if(co[i]==-1) co[i]=co[x]^1,dfs(i);
      else if(co[i]==co[x]) printf("0"),exit(0);
    }
}
int main(){
  scanf("%d",&n);
  for(int i=1;i<=n;i++)
    scanf("%d",&a[i]);
  f[n+1]=2000000000;
  for(int i=n;i>=1;i--)
    f[i]=min(f[i+1],a[i]);
  for(int i=1;i<n;i++)
    for(int j=i+1;j<=n;j++)
      if(a[i]<a[j] && f[j+1]<a[i]) w[i][j]=1,w[j][i]=1;
  memset(co,-1,sizeof(co));
  for(int i=1;i<=n;i++)
    if(co[i]==-1) co[i]=0,dfs(i);
  s1[0]=s2[0]=10000;
  int now=1;
  for(int i=1;i<=n;i++){
    if(co[i]==0) printf("a "),s1[++top1]=a[i];
    else printf("c "),s2[++top2]=a[i];
    while(s1[top1]==now || s2[top2]==now){
      if(s1[top1]==now) printf("b "),top1--;
      else printf("d "),top2--;
      now++;
    }
  }
  while(top1>0 || top2>0 ){
    if(s1[top1]<s2[top2]) printf("b "),top1--;
    else printf("d "),top2--;
  }
  return 0;
}

 

TOP7 NOIP 2015 斗地主(增强版)

题目和斗地主一样,加了hack数据.
然后发现原来的那个贪心算法完全就是个错的.
所以这道题的正解本来不是这个,然后因为数据水被认为这道题的正解是搜索+贪心...
贪心策略出错的原因:贪心是爆搜顺子之后,把其他的牌每次尽可能大的打出.
但是平常打牌的时候并不是这样.
有可能你把一个炸弹拆掉去打会更优.
那怎么搞?
还是先爆搜顺子.然后求剩余的牌最少要打几次.
题目里说每组数据的n都相等,这提示我们用动态规划.
设dp[i][j][k][l]表示还有i种4张的牌,j种3张的牌,k种2张的牌,l种单牌.
转移有很多,除了题面上的那几种外,还要考虑把某种牌拆开.
写的时候一定要细心.
边界要注意判,上边界没有判会导致很多状态的值为0.
若数据不水的话,这应该算是是一道比较难的题了吧.

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<algorithm>
#include<map>
#include<complex>
#include<queue>
#include<stack>
#include<cmath>
#include<set>
#include<vector>
using namespace std;
int a[20],ans=1000000000,n,dp[25][50][75][100];
void updata(int &x,int y){x=x>y?y:x;}
inline int win(){
  int w[5]={0,0,0,0,0};
  for(int i=1;i<=15;i++)
    if(a[i]) w[a[i]]++;
  if(a[14] && a[15]) return min(dp[w[4]][w[3]][w[2]][w[1]-2]+1,dp[w[4]][w[3]][w[2]][w[1]]);
  else return dp[w[4]][w[3]][w[2]][w[1]];
}
void dfs(int w,int las){
  if(las==0) return;
  if(w>ans) return;
  ans=min(ans,w+win());
  for(int i=1;i<=11;i++)
    if(a[i]>=3){//三顺子.
      a[i]-=3;int j=i+1;
      while(j<=12 && a[j]>=3) a[j]-=3,dfs(w+1,las-(j-i+1)*3),j++;
      j--;
      for(int k=i;k<=j;k++) a[k]+=3;
    }
  for(int i=1;i<=10;i++)
    if(a[i]>=2 && a[i+1]>=2){//双顺子.
      a[i]-=2;a[i+1]-=2;int j=i+2;
      while(j<=12 && a[j]>=2) a[j]-=2,dfs(w+1,las-(j-i+1)*2),j++;
      j--;
      for(int k=i;k<=j;k++) a[k]+=2;
    }
  for(int i=1;i<=8;i++)
    if(a[i] && a[i+1] && a[i+2] && a[i+3]){//单顺子.
      a[i]--;a[i+1]--;a[i+2]--;a[i+3]--;int j=i+4;
      while(j<=12 && a[j]>=1) a[j]--,dfs(w+1,las-(j-i+1)),j++;
      j--;
      for(int k=i;k<=j;k++) a[k]++;
    }
}
inline void prepare(){
  memset(dp,127/3,sizeof(dp));
  dp[0][0][0][0]=0;
  for(int i=0;i<=n;i++)
    for(int j=0;j<=n*2;j++)
      for(int k=0;k<=n*3;k++)
    for(int l=0;l<=n*4;l++)if(i*4+j*3+k*2+l<=n){
      if(i){
        updata(dp[i][j][k][l],dp[i-1][j][k][l]+1);//直接炸
        if(k>=2) updata(dp[i][j][k][l],dp[i-1][j][k-2][l]+1);//4带两对
        if(l>=2) updata(dp[i][j][k][l],dp[i-1][j][k][l-2]+1);//4带两张
        if(k>=1) updata(dp[i][j][k][l],dp[i-1][j][k-1][l]+1);//4带一对
        updata(dp[i][j][k][l],dp[i-1][j+1][k][l+1]);//4拆成3和1
        updata(dp[i][j][k][l],dp[i-1][j][k+2][l]);//4拆成2和2
        updata(dp[i][j][k][l],dp[i-1][j][k][l+4]);//4拆成1,1,1,1
      }
      if(j){
        updata(dp[i][j][k][l],dp[i][j-1][k][l]+1);//直接打
        if(k>=1) updata(dp[i][j][k][l],dp[i][j-1][k-1][l]+1);//3带一对
        if(l>=1) updata(dp[i][j][k][l],dp[i][j-1][k][l-1]+1);//3带1
        updata(dp[i][j][k][l],dp[i][j-1][k+1][l+1]);//拆成1和2
        updata(dp[i][j][k][l],dp[i][j-1][k][l+3]);//拆成1,1,1
      }
      if(k){
        updata(dp[i][j][k][l],dp[i][j][k-1][l]+1);
        updata(dp[i][j][k][l],dp[i][j][k-1][l+2]);
      }
      if(l) updata(dp[i][j][k][l],dp[i][j][k][l-1]+1);
    }
}
int main(){
  int T,x,y;
  scanf("%d%d",&T,&n);
  prepare();
  while(T){
    T--;ans=1000000000;
    memset(a,0,sizeof(a));
    for(int i=1;i<=n;i++){
      scanf("%d%d",&x,&y);
      if(x==0 && y==1) a[14]++;
      if(x==0 && y==2) a[15]++;
      if(x==1) a[12]++;
      else if(x==2) a[13]++;
      else a[x-2]++;
    }
    dfs(0,n);
    printf("%d\n",ans);
  }
  return 0;
}

 

 

TOP6 NOIP 2016 愤怒的小鸟

主要考点:状压DP
看到猪只有18头,那么把猪状压.
设g[i][j]代表i和j这条抛物线能打掉的猪的集合是什么.
设f[i]代表打掉i这个状态的猪最少需要多少次.
那么就很容易推出一个DP方程:
f[zt]=min(f[zt],f[(zt&g[i][j])^zt]+1).
这样的复杂度是(2^n)*(n^2).
两秒可以跑过,但一秒有点困难.
考虑进一步的优化.
发现每次枚举i和j有很多重复的状态都被枚举了.
考虑有哪些状态是重复的,假设枚举了一个j1和k1,j2和k1,现在的状态是zt
1.若j1,j2,k1在一条抛物线上,那么j2和k1是不用枚举的.
2.若不在一条抛物线上,假设去掉g[j2][ki]后的状态为zt'.(ki!=k1)
那么zt'又可以通过枚举j1和k1更新.
总的来说,j是不用枚举的,每次用任意一个合法的点做j,取枚举k.
不管选的那个点做j,最终的结果都会是一样的.
然而数据足够水,最快的算法居然是爆搜+剪枝?

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<algorithm>
#include<map>
#include<complex>
#include<queue>
#include<stack>
#include<cmath>
#include<set>
#include<vector>
#define eps 1e-8
using namespace std;
struct data{double x,y;}t[20];
int g[20][20],f[262200];
int main(){
  int T,n,m;
  scanf("%d",&T);
  while(T){
    T--;memset(g,0,sizeof(g));
    scanf("%d%d",&n,&m);
    for(int i=0;i<n;i++)
      scanf("%lf%lf",&t[i].x,&t[i].y);
    for(int i=0;i<n;i++)
      for(int j=i+1;j<n;j++){
    double a=(t[i].y*t[j].x-t[j].y*t[i].x)/(t[i].x*t[j].x*(t[i].x-t[j].x));
    double b=t[i].y/t[i].x-a*t[i].x;
    if(a+eps>0) continue;
    for(int k=0;k<n;k++){
      double xx=a*t[k].x*t[k].x+b*t[k].x;
      if(xx-eps<=t[k].y && xx+eps>=t[k].y)g[i][j]|=(1<<k);
    }
      }
    memset(f,127/3,sizeof(f));f[0]=0;
    for(int zt=1;zt<(1<<n);zt++){
      int i=0;
      while(((1<<i)&zt)==0) i++;
      f[zt]=f[zt^(1<<i)]+1;
      for(int j=i+1;j<n;j++)
    f[zt]=min(f[zt],f[(zt&g[i][j])^zt]+1);
    }
    printf("%d\n",f[(1<<n)-1]);
  }
  return 0;
}

 

TOP5 NOIP 2015 子串

主要考点:序列动态规划.
设状态f[i][j][k]为a串到i,b串到j,分了k组的方案数.
那么只有a[i]==b[j]时才能转移.
若a[i-1]!=b[i-1],这时只能新建一组,f[i][j][k]+=Σf[p][j-1][k-1](p<i)
若a[i-1]==b[i-1],这时还可以和前面的接起来,f[i][j][k]+=f[i-1][j-1][k].
这个DP肯定是过不去的,还需要优化,不过这个优化很显然了.
空间上把k那一维滚动.
时间上在第一个转移的时候记一个前缀和.

这道题看大佬的博客有说20分钟切掉的..
根本想不出来..DP没入门..

#include<bits/stdc++.h>
#define LL long long
#define mod 1000000007
using namespace std;
LL f[2][1010][210],sum[2][1010][210];
char a[1010],b[210];
int main(){
  freopen("!.in","r",stdin);
  freopen("!.out","w",stdout);
  int n,m,k;
  scanf("%d%d%d",&n,&m,&k);
  scanf("%s%s",a+1,b+1);
  int t=1,tt=0;
  for(int i=0;i<=n;i++)
  sum[0][i][0]=1;
  for(int l=1;l<=k;l++){
    memset(f[t],0,sizeof(f[t]));
    memset(sum[t],0,sizeof(sum[t]));
    for(int i=1;i<=n;i++)
      for(int j=1;j<=m;j++){
    if(a[i]==b[j]){
      f[t][i][j]+=sum[tt][i-1][j-1];
      f[t][i][j]%=mod;
      if(a[i-1]==b[j-1])
        f[t][i][j]=(f[t][i][j]+f[t][i-1][j-1])%mod;
    }
    sum[t][i][j]=sum[t][i-1][j]+f[t][i][j];
    sum[t][i][j]%=mod;
      }
    swap(t,tt);
  }
  LL ans=0;
  for(int i=1;i<=n;i++)
    ans+=f[tt][i][m],ans%=mod;
  printf("%lld",ans%mod);
  return 0;
}

TOP4 NOIP 2011 观光公交

主要考点:贪心,递推.
可以看出每个人对答案的贡献只跟公交车到他的终点的时间有关.
先可以求出不用氮气加速时的答案.递推即可.
考虑对于每一条路使用氮气加速会对哪些车站有影响.
若在i到i+1使用氮气加速,那么到i+1的时间会-1.
若在i+1处还需要等人的话,那么i+1之后的车站是不会受到影响的.
所以就要求出每个点最大影响到哪里,记为g,这个也是递推求.
若i+1处要等,那么g[i]=i+1.否则g[i]=g[i+1].
然后现在就可以贪心了,每次选择一条能加速的道路,且这条道路影响的人最多.
答案减去这个值,并更新g数组.

这道题的思维难度比较大,主要是要想到每条路会对哪些点有影响.

#include<bits/stdc++.h>
#define maxn 1010
using namespace std;
int d[maxn],t[maxn*10],a[maxn*10],b[maxn*10],sum[maxn],s[maxn],arr[maxn],g[maxn];
int main(){
  int n,m,k,ans=0;
  scanf("%d%d%d",&n,&m,&k);
  for(int i=1;i<n;i++)
    scanf("%d",&d[i]);
  for(int i=1;i<=m;i++)
    scanf("%d%d%d",&t[i],&a[i],&b[i]),s[a[i]]=max(s[a[i]],t[i]),sum[b[i]]++;
  for(int i=1;i<=n+1;i++) sum[i]+=sum[i-1];
  for(int i=1;i<=n;i++)
    arr[i+1]=max(arr[i],s[i])+d[i];
  for(int i=1;i<=m;i++)
    ans+=arr[b[i]]-t[i];
  g[n]=n+1;
  for(int i=n-1;i>=1;i--)
    g[i]=arr[i+1]>s[i+1]?g[i+1]:i+1;
  while(k){
    k--;
    int zd=0,sp=0;
    for(int i=1;i<n;i++)
      if(sum[g[i]]-sum[i]>zd && d[i]>0) zd=sum[g[i]]-sum[i],sp=i;
    ans-=zd;d[sp]--;
    for(int i=1;i<=n;i++)
      arr[i+1]=max(arr[i],s[i])+d[i];
    for(int i=n-1;i>=1;i--)
      g[i]=arr[i+1]>s[i+1]?g[i+1]:i+1;
  }
  printf("%d",ans);
  return 0;
}

TOP3 NOIP 2011 疫情控制

主要考点:二分,贪心.
首先直接求应该是不可做的,二分一个答案lim.
考虑怎么check.
对于那些不能走到根的军队,就让他尽量往上走.因为越往上控制得越多.
然后现在就在根有一些军队,每个军队还能走wi.
还有一些根的子节点需要被控制.
那么就要判断是否存在一种方案使得每个没被控制的子节点都被控制.
把这两个数组从小到大排序.
然后尽量用能移动距离小的军队去控制较近的点.
这样不一定是对的,因为某个军队还可以去控制他来的那个点.
那么就要加一些特判:若某个军队走到根之后走不回他来的那个点了,那么就让他停在他来的那个点.因为他能去的点一定比这个点小,那么让别的人去那个点肯定要优一些.

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<algorithm>
#include<map>
#include<complex>
#include<queue>
#include<stack>
#include<cmath>
#include<set>
#include<vector>
#define maxn 50010
#define LL long long
using namespace std;
struct data{
  int nex,to,w;
}e[maxn*2];
struct qaq{
  LL w;int from;
  bool operator < (qaq h) const{
    return w<h.w;
  }
};
int head[maxn],edge=0,top[maxn],n,m,arm[maxn];
LL dis[maxn];
bool bj[maxn];
int f[maxn][20];
inline void add(int from,int to,int w){
  e[++edge].nex=head[from];
  e[edge].to=to;
  e[edge].w=w;
  head[from]=edge;
}
void dfs(int x,int fa){
  if(fa==1) top[x]=x;
  else top[x]=top[fa];
  for(int i=head[x];i;i=e[i].nex){
    int v=e[i].to;
    if(v==fa) continue;
    f[v][0]=x;dis[v]=dis[x]+e[i].w;
    dfs(v,x);
  }
}
inline void prepare(){
  dfs(1,0);f[1][0]=1;
  for(int j=1;j<=18;j++)
    for(int i=1;i<=n;i++)
      f[i][j]=f[f[i][j-1]][j-1];
}
void dfs1(int x,int fa){
  bool fg=1,fg1=0;
  for(int i=head[x];i;i=e[i].nex){
    int v=e[i].to;
    if(v==fa) continue;
    fg1=1;
    dfs1(v,x);
    if(!bj[v]) fg=0;
  }
  if(fg && fg1) bj[x]=1;
}
inline bool check(LL lim){
  memset(bj,0,sizeof(bj));
  vector<qaq>vec,vec1;
  for(int i=1;i<=m;i++){
    int k=arm[i];LL po=lim;
    for(int j=18;j>=0;j--)
      if(dis[k]-dis[f[k][j]]<=po) po-=(dis[k]-dis[f[k][j]]),k=f[k][j];
    if(k!=1) bj[k]=1;
    else vec.push_back((qaq){lim-dis[arm[i]],top[arm[i]]});
  }
  dfs1(1,0);
  for(int i=0;i<vec.size();i++)
    if(vec[i].w<dis[vec[i].from] && !bj[vec[i].from])bj[vec[i].from]=1,vec[i].w=0;
  if(bj[1]) return 1;
  for(int i=head[1];i;i=e[i].nex)
    if(!bj[e[i].to]) vec1.push_back((qaq){e[i].w,e[i].to});
  sort(vec.begin(),vec.end());
  sort(vec1.begin(),vec1.end());
  unsigned int i=0,j=0;
  for(;i<vec1.size() && j<vec.size();){
    if(bj[vec1[i].from]) {i++;continue;}
    //if(vec1[i].w<dis[vec[j].from] && !bj[vec[j].from]) bj[vec[j].from]=1,j++;
    else if(vec1[i].w<=vec[j].w) j++,i++;
    else j++;
  }
  if(i==vec1.size()) return 1;
  else return 0;
}
int main(){
  int x,y,z;
  scanf("%d",&n);
  for(int i=1;i<n;i++)
    scanf("%d%d%d",&x,&y,&z),add(x,y,z),add(y,x,z);
  scanf("%d",&m);
  for(int i=1;i<=m;i++)
    scanf("%d",&x),arm[i]=x;
  prepare();
  LL l=0,r=1e10;
  while(l<=r){
    LL mid=(l+r)>>1;
    if(check(mid))r=mid-1;
    else l=mid+1;
  }
  printf("%lld",l);
  return 0;
}

 

 

TOP2 NOIP 2014 华容道

主要考点:搜索,最短路

暴力:BFS． 搜索空白的格子往四周走. 队列里面记录空格的位置和目标块的位置和步数,并且标记这个状态不能重复走. 这样搞好像有80分.

正解:BFS+SPFA. 要使某个块走到特定的点,首先要使空格移到这个块的边上. 然后再不断地移这个块. 所以,先要BFS求出空白块移到这个块需要多少步. 然后空白块就在这个块边上了. 考虑到要不停的移这个块，那么空白块就要一直在这个块的边上．  

定义mov数组,mov[i][j][k][l]代表i,j这个点,空白在k方向,要往l方向移一格的步数. 这个可以BFS求出来. 这样,把每个状态看成一个点,然后问题就转化为最短路问题,跑SPFA就可以了. 

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<algorithm>
#include<map>
#include<complex>
#include<queue>
#include<stack>
#include<cmath>
#include<set>
#include<vector>
#define inf 1000000000
using namespace std;
struct data{
  int x,y;
  bool operator == (data h) const{
    return h.x==x&&h.y==y;
  }
};
struct node{int x,y,k;};
bool bj[32][32],vis[32][32][5];
int mp[32][32],mov[32][32][5][5],dx[5]={0,1,-1,0,0},dy[5]={0,0,0,1,-1},dis[32][32],n,m,ds[32][32][5];
int bfs(data s,data t){
  if(s.x<=0||s.x>n||s.y<=0||s.y>m||t.x<=0||t.x>n||t.y<=0||t.y>m||mp[s.x][s.y]||mp[t.x][t.y]) return inf;
  if(s==t) return 0;
  queue<data>q;q.push(s);
  memset(bj,0,sizeof(bj));
  memset(dis,0,sizeof(dis));
  bj[s.x][s.y]=1;
  while(!q.empty()){
    data u=q.front();q.pop();
    for(int i=1;i<=4;i++){
      int xx=u.x+dx[i],yy=u.y+dy[i];
      if(xx<=0 || xx>n || yy<=0 || yy>m || mp[xx][yy] || bj[xx][yy]) continue;
      bj[xx][yy]=1;dis[xx][yy]=dis[u.x][u.y]+1;
      if((data){xx,yy}==t) return dis[xx][yy];
      q.push((data){xx,yy});
    }
  }
  return inf;
}
inline void prepare(){
  memset(mov,127/3,sizeof(mov));
  for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++)
      if(!mp[i][j])
    for(int k=1;k<=4;k++)
      for(int l=1;l<=4;l++){
        mp[i][j]=1;
        mov[i][j][k][l]=bfs((data){i+dx[k],j+dy[k]},(data){i+dx[l],j+dy[l]})+1;
        mp[i][j]=0;
      }
}
inline void work(){
  data e,s,t;
  scanf("%d%d%d%d%d%d",&e.x,&e.y,&s.x,&s.y,&t.x,&t.y);
  if(s==t){printf("0\n");return;}
  queue<node>q;
  memset(ds,127/3,sizeof(ds));
  memset(vis,0,sizeof(vis));
  mp[s.x][s.y]=1;
  for(int i=1;i<=4;i++){
    int step=bfs(e,(data){s.x+dx[i],s.y+dy[i]});
    if(step!=inf) ds[s.x][s.y][i]=step,vis[s.x][s.y][i]=1,q.push((node){s.x,s.y,i});
  }
  mp[s.x][s.y]=0;
  while(!q.empty()){
    node u=q.front();q.pop();vis[u.x][u.y][u.k]=0;
    for(int i=1;i<=4;i++){
      int xx=u.x+dx[i],yy=u.y+dy[i];
      if(xx<=0 || xx>n || yy<=0 || yy>m || mp[xx][yy]) continue;
      int w;
      if(i%2)w=i+1;
      else w=i-1;
      if(ds[xx][yy][w]>ds[u.x][u.y][u.k]+mov[u.x][u.y][u.k][i]){
    ds[xx][yy][w]=ds[u.x][u.y][u.k]+mov[u.x][u.y][u.k][i];
    if(!vis[xx][yy][w]) q.push((node){xx,yy,w}),vis[xx][yy][w]=1;
      }
    }
  }
  int zx=inf;
  for(int i=1;i<=4;i++)zx=min(zx,ds[t.x][t.y][i]);
  if(zx>1e8) printf("-1\n");
  else printf("%d\n",zx);
}
int main(){
  int q;
  scanf("%d%d%d",&n,&m,&q);
  for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++)
      scanf("%d",&mp[i][j]),mp[i][j]^=1;
  prepare();
  for(int i=1;i<=q;i++)
    work();
  return 0;
}

 

TOP1 NOIP 2016 天天爱跑步

主要考点:树,lca,差分.

先考虑链的情况.
若S<=T.则i点产生贡献的条件是满足存在i-S=w[i],移项
S=i-w[i].设i-w[i]=k[i],A[i]代表当前以i为起点还没有走到终点
的路径个数.那么每走到一个i,ans[i]=A[k[i]].若i这个点作为了
起点,则A[i]++,若作为终点,则A[这条路的起点]--.这个可以开
一个动态数组存下来.
S>T的情况类似.
树上的情况就差不多了,可以把每条路径看成S-LCA和T-LCA的
两条链,分别处理.deep[s]=deep[i]+w[i]才会产生贡献.那么,
对于每个点,要更新完了他的子树才能更新他.而且,所求的
A[k[i]]可能还包含其他子树的起点(因为下标是深度,有很多
深度一样的点).那么就可以在到这个点的时候记录一下A
数组,最后处理的时候减掉就可以了.
T-LCA要复杂一些,开两个动态数组分别记录要增加的位置和
要减少的位置.避免出现负数,把数组下标都加300000.
最后判断一下,若起点就是LCA,且w[s]==0,则要—(此时LCA是
有贡献的,但LCA出现了两次).

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<algorithm>
#include<map>
#include<complex>
#include<queue>
#include<stack>
#include<cmath>
#include<set>
#include<vector>
#define maxn 300010
using namespace std;
struct data{
  int nex,to;
}e[maxn*2];
int head[maxn],edge=0,mov=300000;
int A[maxn*3],ans[maxn],deep[maxn],w[maxn],val[maxn],maxdep=0;
int size[maxn],top[maxn],dad[maxn],son[maxn];
vector<int>vec1[maxn],vec2[maxn],vec3[maxn];
inline void add(int from,int to){
  e[++edge].nex=head[from];
  e[edge].to=to;
  head[from]=edge;
}
void DFS1(int x,int fa){
  maxdep=max(maxdep,deep[x]);size[x]=1;
  for(int i=head[x];i;i=e[i].nex){
    int v=e[i].to;if(v==fa) continue;
    dad[v]=x;deep[v]=deep[x]+1;
    DFS1(v,x);
    size[x]+=size[v];
    if(size[v]>size[son[x]]) son[x]=v;
  }
}
void DFS2(int x,int fa){
  if(son[x]) top[son[x]]=top[x],DFS2(son[x],x);
  for(int i=head[x];i;i=e[i].nex){
    int v=e[i].to;if(v==fa || v==son[x]) continue;
    top[v]=v;DFS2(v,x);
  }
}
inline int getlca(int x,int y){
  while(top[x]!=top[y]){
    if(deep[top[x]]>deep[top[y]]) x=dad[top[x]];
    else y=dad[top[y]];
  }
  return deep[x]>deep[y]?y:x;
}
void dfs1(int x,int fa){
  int now=deep[x]+w[x],fb;
  if(now<=maxdep) fb=A[now];
  for(int i=head[x];i;i=e[i].nex){
    int v=e[i].to;
    if(v==fa) continue;
    dfs1(v,x);
  }
  A[deep[x]]+=val[x];
  if(now<=maxdep) ans[x]+=A[now]-fb;
  for(int i=0;i<vec1[x].size();i++) A[deep[vec1[x][i]]]--;
}
void dfs2(int x,int fa){
  int now=deep[x]-w[x],fb=A[now+mov];
  for(int i=head[x];i;i=e[i].nex){
    int v=e[i].to;
    if(v==fa) continue;
    dfs2(v,x);
  }
  for(int i=0;i<vec2[x].size();i++) A[vec2[x][i]+mov]++;
  ans[x]+=A[now+mov]-fb;
  for(int i=0;i<vec3[x].size();i++) A[vec3[x][i]+mov]--;
}
int main(){
  int n,m,x,y;
  scanf("%d%d",&n,&m);
  for(int i=1;i<n;i++)
    scanf("%d%d",&x,&y),add(x,y),add(y,x);
  dad[1]=top[1]=deep[1]=1;
  DFS1(1,0),DFS2(1,0);
  for(int i=1;i<=n;i++)
    scanf("%d",&w[i]);
  for(int i=1;i<=m;i++){
    scanf("%d%d",&x,&y);val[x]++;
    int LCA=getlca(x,y),len=deep[x]+deep[y]-2*deep[LCA];
    if(deep[x]-deep[LCA]==w[LCA])ans[LCA]--;
    vec1[LCA].push_back(x);
    vec2[y].push_back(deep[y]-len);
    vec3[LCA].push_back(deep[y]-len);
  }
  dfs1(1,0);
  memset(A,0,sizeof(A));
  dfs2(1,0);
  for(int i=1;i<=n;i++)
    printf("%d ",ans[i]);
  return 0;
}

 

 

NOIP2017 ++RP