NOIP2017题解

最新推荐文章于 2021-01-22 11:13:49 发布
最新推荐文章于 2021-01-22 11:13:49 发布
阅读量7.3k 收藏 7
点赞数 2
分类专栏： 杂文
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KsCla/article/details/78554935
版权

前言

趁着现在还没有出成绩，我还可以在机房浪一波……
以下6题的代码都只是通过了洛谷的民间数据，如果官方数据出了，没有AC也是很正常的。

Day1T1：小凯的疑惑

题目分析：考试的时候花了10min推出来，后来得知出题人也是这么推的。

我们考虑答案模a等于几，很明显不可能等于0。那么假设答案模a等于1，必然存在一个最小的正整数y使得yb%a=1，很明显y与a互质。于是所有%a=1的数中，最大的不能被表示的数就是yb-a。而所有%a=2的数中，最大的不能被表示数是(2y%a)b-a；所有%a=3的数中，最大的不能被表示数是(3y%a)b-a……以此类推。由小学奥数可知（其实是某XJB定理），当正整数y小于a且与a互质时，y，2y%a，3y%a……(a-1)y%a的最大值为a-1。于是答案为(a-1)b-a。

CODE：

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<stdio.h>
#include<algorithm>
using namespace std;

typedef long long LL;

int a,b;
LL ans;

int main()
{
    freopen("math.in","r",stdin);
    freopen("math.out","w",stdout);

    scanf("%d%d",&a,&b);
    ans=(long long)a*(long long)b-(long long)a-(long long)b;
    printf("%lld\n",ans);

    return 0;
}

Day1T2：时间复杂度

题目分析：硬模拟即可，感觉就是pjT2的难度。

CODE：

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<stdio.h>
#include<algorithm>
using namespace std;

const int maxn=110;

struct data
{
    int id,lo,hi,ed;
} work[maxn];

bool vis[30];
int sak[maxn];
int tail=0;

char s[maxn];
int Max,now;
int t,l,w;

int Read(int y)
{
    int x=0;
    while ( '0'<=s[y] && s[y]<='9' ) x=x*10+(s[y]-'0'),y++;
    return x;
}

int main()
{
    freopen("complexity.in","r",stdin);
    freopen("complexity.out","w",stdout);

    scanf("%d",&t);
    while (t--)
    {
        scanf("%d",&l);
        getchar();
        scanf("%s",&s);
        if (s[2]=='1') w=0;
        else w=Read(4);

        for (int i=1; i<=l; i++)
        {
            scanf("%s",&s);
            while ( s[0]!='E' && s[0]!='F' ) scanf("%s",&s);
            if (s[0]=='E') work[i].id=-1;
            else
            {
                scanf("%s",&s);
                work[i].id=s[0]-'a';
                scanf("%s",&s);
                if (s[0]=='n') work[i].lo=102;
                else work[i].lo=Read(0);
                scanf("%s",&s);
                if (s[0]=='n') work[i].hi=102;
                else work[i].hi=Read(0);
            }
        }

        //printf("%d\n",w);
        //for (int i=1; i<=l; i++) printf("%d %d %d\n",work[i].id,work[i].lo,work[i].hi);
        //printf("\n");

        memset(vis,false,sizeof(vis));
        bool sol=true;
        tail=0;
        for (int i=1; i<=l; i++)
        {
            if (work[i].id==-1)
                if (!tail)
                {
                    sol=false;
                    break;
                }
                else
                {
                    int x=sak[tail];
                    tail--;
                    vis[ work[x].id ]=false;
                    work[x].ed=i;
                }
            else
            {
                tail++;
                sak[tail]=i;
                if (!vis[ work[i].id ]) vis[ work[i].id ]=true;
                else
                {
                    sol=false;
                    break;
                }
            }
        }
        if (tail) sol=false;

        if (!sol)
        {
            printf("ERR\n");
            continue;
        }

        //printf("\n");

        now=0,Max=0;
        int Time=0;
        while (Time<l)
        {
            Time++;
            if (work[Time].id==-1)
            {
                int x=sak[tail];
                tail--;
                if ( work[x].lo<work[x].hi && work[x].hi==102 ) now--;
            }
            else
                if (work[Time].lo>work[Time].hi) Time=work[Time].ed;
                else
                {
                    sak[++tail]=Time;
                    if ( work[Time].lo<work[Time].hi && work[Time].hi==102 )
                        now++,Max=max(Max,now);
                }
        }

        if (Max==w) printf("Yes\n");
        else printf("No\n");
    }

    return 0;
}

Day1T3：逛公园

题目分析：我们可以先算出从1到每个点的最短路f，以及每个点到n的最短路g。然后记cnt[i][j]表示到了点i，已走长度为f[i]+j的方案数，很明显j不应超过题目给定的K。由于f[u]+cost(u,v)>=f[v]，所以cnt数组是可以宽搜算出来的。0环的话一开始Dfs一遍就可以找出来了。有一个很坑的地方是：如果出现了0环，还要判断0环是否能真的走到n号点，所以Dfs的时候，遇到一个不能走到n的状态要退出。时间复杂度 O((最短路时间+mK)∗T) 。

CODE：

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
using namespace std;

const int maxn=100100;
const int maxm=200100;
const int maxk=55;
const int oo=1000000000;

struct edge
{
    int obj,len;
    edge *Next;
} e[maxm<<1];
edge *head1[maxn];
edge *head2[maxn];
int cur=-1;

int Heap[maxn];
int id[maxn];
int tail;

int f[maxn];
int g[maxn];

int cnt[maxn][maxk];
int vis[maxn][maxk];
int num[maxn][maxk];

int qx[maxn*maxk];
int qy[maxn*maxk];
int he,ta;

int t,n,m,k,p;

void Add(edge **head,int x,int y,int z)
{
    cur++;
    e[cur].obj=y;
    e[cur].len=z;
    e[cur].Next=head[x];
    head[x]=e+cur;
}

int Delete(int *dis)
{
    int temp=Heap[1];
    Heap[1]=Heap[tail];
    id[ Heap[1] ]=1;
    tail--;

    int x=1;
    while (1)
    {
        int y=x,Left=x<<1,Right=Left|1;
        if ( Left<=tail && dis[ Heap[Left] ]<dis[ Heap[y] ] ) y=Left;
        if ( Right<=tail && dis[ Heap[Right] ]<dis[ Heap[y] ] ) y=Right;
        if (y==x) break;
        swap(Heap[x],Heap[y]);
        swap(id[ Heap[x] ],id[ Heap[y] ]);
        x=y;
    }

    return temp;
}

void Update(int *dis,int x)
{
    while (x>1)
    {
        int y=x>>1;
        if (dis[ Heap[y] ]<dis[ Heap[x] ]) break;
        swap(Heap[x],Heap[y]);
        swap(id[ Heap[x] ],id[ Heap[y] ]);
        x=y;
    }
}

void Dijkstra(int s,edge **head,int *dis)
{
    for (int i=1; i<=n; i++) dis[i]=oo;
    dis[s]=0;

    tail=1;
    Heap[1]=s;
    id[s]=1;
    for (int i=1; i<=n; i++) if (i!=s)
        Heap[++tail]=i,id[i]=tail;

    for (int i=1; i<n; i++)
    {
        int node=Delete(dis);
        for (edge *p=head[node]; p; p=p->Next)
        {
            int to=p->obj;
            if (dis[to]>dis[node]+p->len)
                dis[to]=dis[node]+p->len,Update(dis,id[to]);
        }
    }
}

bool Find(int node,int i)
{
    if (f[node]+i+g[node]>f[n]+k) return true;
    if (vis[node][i]==2) return true;
    if (vis[node][i]==1) return false;

    vis[node][i]=1;
    for (edge *p=head1[node]; p; p=p->Next)
    {
        int to=p->obj;
        int j=f[node]+i+p->len-f[to];
        if (j>k) continue;
        if ( !Find(to,j) ) return false;
    }
    vis[node][i]=2;
    return true;
}

int Mod(int x)
{
    if (x>=p) x-=p;
    return x;
}

void Bfs()
{
    for (int i=1; i<=n; i++)
        for (int j=0; j<=k; j++) cnt[i][j]=0;
    cnt[1][0]=1%p;

    for (int i=1; i<=n; i++)
        for (int j=0; j<=k; j++)
            if (vis[i][j])
                for (edge *p=head1[i]; p; p=p->Next)
                {
                    int to=p->obj;
                    int x=f[i]+j+p->len-f[to];
                    if ( x<=k && vis[to][x] ) num[to][x]++;
                }

    he=0,ta=1;
    qx[1]=1;
    qy[1]=0;
    while (he<ta)
    {
        he++;
        int node=qx[he];
        int i=qy[he];

        for (edge *p=head1[node]; p; p=p->Next)
        {
            int to=p->obj;
            int j=f[node]+i+p->len-f[to];
            if ( j>k || !vis[to][j] ) continue;

            cnt[to][j]=Mod(cnt[to][j]+cnt[node][i]);
            num[to][j]--;
            if (!num[to][j])
            {
                ta++;
                qx[ta]=to;
                qy[ta]=j;
            }
        }
    }
}

int main()
{
    freopen("3953.in","r",stdin);
    freopen("3953.out","w",stdout);

    scanf("%d",&t);
    while (t--)
    {
        scanf("%d%d%d%d",&n,&m,&k,&p);
        cur=-1;
        for (int i=1; i<=n; i++) head1[i]=head2[i]=NULL;
        for (int i=1; i<=m; i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            Add(head1,a,b,c);
            Add(head2,b,a,c);
        }

        Dijkstra(1,head1,f);
        Dijkstra(n,head2,g);

        for (int i=1; i<=n; i++)
            for (int j=0; j<=k; j++)
                vis[i][j]=num[i][j];
        bool sol=Find(1,0);

        if (!sol) printf("-1\n");
        else
        {
            Bfs();
            int ans=0;
            for (int i=0; i<=k; i++) ans=Mod(ans+cnt[n][i]);
            printf("%d\n",ans);
        }
    }

    return 0;
}

Day2T1：奶酪

题目分析： n2 连边，然后宽搜即可。按理来说两个圆心的 (δx)2+(δy)2+(δz)2 会爆long long，要用unsigned long long，但听说出题人没有卡。

CODE：

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<stdio.h>
#include<algorithm>
using namespace std;

const int maxn=1010;
typedef long long LL;

struct edge
{
    int obj;
    edge *Next;
} e[maxn*maxn];
edge *head[maxn];
int cur;

int level[maxn];
int que[maxn];
int he,ta;

int X[maxn];
int Y[maxn];
int Z[maxn];

int t,n,h,r;
LL temp;

bool Judge(LL x,LL y,LL z)
{
    x*=x;
    y*=y;
    z*=z;
    LL dis=x+y+z;
    return (dis<=temp);
}

void Add(int x,int y)
{
    cur++;
    e[cur].obj=y;
    e[cur].Next=head[x];
    head[x]=e+cur;
}

bool Bfs()
{
    level[0]=1;
    for (int i=1; i<=n+1; i++) level[i]=0;
    he=0,ta=1;
    que[1]=0;
    while (he<ta)
    {
        int node=que[++he];
        for (edge *p=head[node]; p; p=p->Next)
        {
            int to=p->obj;
            if (!level[to]) level[to]=level[node]+1,que[++ta]=to;
        }
    }
    return level[n+1];
}

int main()
{
    freopen("cheese.in","r",stdin);
    freopen("cheese.out","w",stdout);

    scanf("%d",&t);
    while (t--)
    {
        scanf("%d%d%d",&n,&h,&r);
        for (int i=1; i<=n; i++) scanf("%d%d%d",&X[i],&Y[i],&Z[i]);

        cur=-1;
        temp=4LL*(long long)r*(long long)r;
        for (int i=0; i<=n+1; i++) head[i]=NULL;
        for (register int i=1; i<n; ++i)
            for (register int j=i+1; j<=n; ++j)
                if ( Judge(X[i]-X[j],Y[i]-Y[j],Z[i]-Z[j]) )
                    Add(i,j),Add(j,i);

        for (int i=1; i<=n; i++) if (Z[i]-r<=0) Add(0,i);
        for (int i=1; i<=n; i++) if (Z[i]+r>=h) Add(i,n+1);
        bool sol=Bfs();
        if (sol) printf("Yes\n");
        else printf("No\n");
    }

    return 0;
}

Day2T2：宝藏

题目分析：主要思路是将生成树分层状压，然后子集转移。先预处理一个点到一个集合的最小费用，然后算出一个集合到一个集合的最小费用g[s][t]。记f[i][s]表示到第i层为止，已经选了s集合的最小花费，很明显f[i][s]=f[i-1][t]+g[s][t]*(i-1)。虽然实际上每一条边的花费并不一定都要乘上i-1，但可以发现最优答案一定会被计算到。时间复杂度 O(3n∗n) 。

注意将某些数组初始化为无限大时，乘起来可能会爆int。

CODE：

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<stdio.h>
#include<algorithm>
using namespace std;

const int maxn=15;
const int maxs=(1<<12)+100;
const int oo=1000000000;

int e[maxn][maxn];

int h[maxn][maxs];
int g[maxs][maxs];
int f[maxn][maxs];

int n,m;

int main()
{
    freopen("3959.in","r",stdin);
    freopen("3959.out","w",stdout);

    scanf("%d%d",&n,&m);
    for (int i=1; i<=n; i++)
        for (int j=1; j<=n; j++) e[i][j]=oo;
    for (int i=1; i<=m; i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        e[a][b]=min(e[a][b],c);
        e[b][a]=min(e[b][a],c);
    }

    int ms=1<<n;
    for (int i=1; i<=n; i++)
        for (int s=1; s<ms; s++)
        {
            h[i][s]=oo;
            if ( !(s&(1<<(i-1))) )
                for (int j=1; j<=n; j++)
                    if ( s&(1<<(j-1)) )
                        h[i][s]=min(h[i][s],e[i][j]);
        }

    for (int s=1; s<ms; s++)
    {
        int t=s&(s-1);
        while (t)
        {
            int x=s^t;
            for (int i=1; i<=n; i++)
                if ( x&(1<<(i-1)) )
                {
                    g[s][t]+=h[i][t];
                    if (g[s][t]>oo) g[s][t]=oo;
                }
            t=s&(t-1);
        }
    }

    for (int i=1; i<=n; i++)
        for (int s=0; s<ms; s++) f[i][s]=oo;
    for (int i=1; i<=n; i++) f[1][1<<(i-1)]=0;
    for (int i=2; i<=n; i++)
        for (int s=1; s<ms; s++)
        {
            int t=s&(s-1);
            while (t)
            {
                int temp;
                if (g[s][t]<oo) temp=g[s][t]*(i-1);
                else temp=oo;
                if (f[i-1][t]<oo) f[i][s]=min(f[i][s],f[i-1][t]+temp);
                t=s&(t-1);
            }
        }

    int ans=oo;
    for (int i=1; i<=n; i++) ans=min(ans,f[i][ms-1]);
    printf("%d\n",ans);

    return 0;
}

Day2T3：列队

题目分析：后来分析了一下，发现用线段树+Treap就可以做了。

在某一次操作后，矩阵一定是这个样子的：

其中红色部分表示从第m列来到左边某一行的数，蓝色代表某一行原有的数，绿色代表第m列。用一棵Treap维护绿色部分，用n棵Treap维护红色部分，再用n棵动态开节点的线duang树维护每一行蓝色部分里没有的数即可。找答案的时候根据实际情况在Treap上找数或者在线段树上二叉查找。时空复杂度均为 O(nlog(n)) 。

CODE：

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<stdio.h>
#include<algorithm>
using namespace std;

const int maxn=300100;
const int Lg=22;

const long long M1=998244353;
const long long M2=1000000007;
const long long M3=1998585857;
typedef long long LL;

struct Seg
{
    int sum;
    Seg *Lson,*Rson;
} tree[maxn*Lg];
Seg *SRoot[maxn];
int cur=-1;

struct Tnode
{
    LL val;
    int Size,fix;
    Tnode *lson,*rson;
    int Lsize() { return (lson? lson->Size:0); }
} Treap[maxn*3];
Tnode *TRoot[maxn];
int Tcur=-1;
LL seed;

int num[maxn];
int n,m,q;

Seg *New_Seg()
{
    cur++;
    tree[cur].sum=0;
    tree[cur].Lson=tree[cur].Rson=tree;
    return tree+cur;
}

int Rand()
{
    seed=(seed*M1+M2)%M3;
    return seed;
}

Tnode *New_Tnode(LL v)
{
    Tcur++;
    Treap[Tcur].val=v;
    Treap[Tcur].Size=1;
    Treap[Tcur].fix=Rand();
    Treap[Tcur].lson=Treap[Tcur].rson=NULL;
    return Treap+Tcur;
}

void Recount(Tnode *P)
{
    P->Size=P->Lsize()+(P->rson? P->rson->Size:0)+1;
}

void Left_turn(Tnode *&P)
{
    Tnode *W=P->rson;
    P->rson=W->lson;
    W->lson=P;
    P=W;
    Recount(P->lson);
    Recount(P);
}

void Insert(Tnode *&P,LL v)
{
    if (!P) P=New_Tnode(v);
    else
    {
        Insert(P->rson,v);
        if ( P->rson->fix < P->fix ) Left_turn(P);
        else Recount(P);
    }
}

void Right_turn(Tnode *&P)
{
    Tnode *W=P->lson;
    P->lson=W->rson;
    W->rson=P;
    P=W;
    Recount(P->rson);
    Recount(P);
}

LL Delete(Tnode *&P,int Rank)
{
    int Ls=P->Lsize()+1;
    LL temp;     //!!!
    if (Ls==Rank)
        if (P->lson)
            if (P->rson)
                if ( P->lson->fix < P->rson->fix )
                {
                    Right_turn(P);
                    temp=Delete(P->rson, P->rson->Lsize()+1 );
                    Recount(P);
                }
                else
                {
                    Left_turn(P);
                    temp=Delete(P->lson, P->lson->Lsize()+1 );
                    Recount(P);
                }
            else temp=P->val,P=P->lson;
        else temp=P->val,P=P->rson;
    else
    {
        if (Rank<Ls) temp=Delete(P->lson,Rank);
        else temp=Delete(P->rson,Rank-Ls);
        Recount(P);
    }
    return temp;
}

int Query(Seg *root,int L,int R,int Rank)
{
    if (L==R) return L;
    int mid=(L+R)>>1,Ls=root->Lson->sum;
    if (Rank<=mid-Ls) return Query(root->Lson,L,mid,Rank);
    else return Query(root->Rson,mid+1,R,Rank+Ls);//没考虑清楚，+号打成了-号！！！
}

void Update(Seg *&root,int L,int R,int x)
{
    if (root==tree) root=New_Seg();
    if (L==R) root->sum++;
    else
    {
        int mid=(L+R)>>1;
        if (x<=mid) Update(root->Lson,L,mid,x);
        else Update(root->Rson,mid+1,R,x);
        root->sum=root->Lson->sum+root->Rson->sum;
    }
}

/*void Print(Tnode *P)
{
    if (!P) return;
    Print(P->lson);
    printf("%d ",P->val);
    Print(P->rson);
}*/

int main()
{
    freopen("3960.in","r",stdin);
    freopen("3960.out","w",stdout);

    scanf("%d%d%d",&n,&m,&q);

    seed=q;
    for (int i=0; i<=n+1; i++) TRoot[i]=NULL;
    New_Seg();
    for (int i=1; i<=n; i++) SRoot[i]=tree,num[i]=0;

    for (int i=1; i<=n; i++) Insert(TRoot[n+1],(long long)i*(long long)m);
    m--;
    for (int i=1; i<=q; i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        if (y>m)
        {
            LL temp=Delete(TRoot[n+1],x);
            printf("%lld\n",temp);     //!!!
            Insert(TRoot[n+1],temp);
        }
        else
        {
            LL ans;
            if (y>m-num[x]) ans=Delete(TRoot[x],y+num[x]-m);
            else
            {
                ans=Query(SRoot[x],1,m,y);
                Update(SRoot[x],1,m,ans);
                ans+=( (long long)(x-1)*(long long)(m+1) );
                num[x]++;
            }
            Insert(TRoot[x], Delete(TRoot[n+1],x) );
            Insert(TRoot[n+1],ans);
            printf("%lld\n",ans);
        }
        //if (i==4) Print(TRoot[n+1]),printf("\n");
    }

    return 0;
}

//记得开long long！！！

后记：

屏幕在深夜微微发亮
思想在那虚树路径上彷徨
平面的向量交错生长
织成 忧伤的网

剪枝剪去我们的疯狂
SPFA 告诉我前途在何方
01 背包装下了忧伤
笑颜 洋溢脸庞

键盘微凉 鼠标微凉
指尖流淌 代码千行
凸包周长 直径多长
一进考场 全都忘光
你在 OJ 上提交了千百遍
却依然不能卡进那时限
双手敲尽代码也敲尽岁月
只有我一人
写的题解
凋零在 OJ 里面

Tarjan 陪伴强连通分量
生成树完成后思路才闪光
欧拉跑过的七桥古塘
让你 心驰神往

队列进出图上的方向
线段树区间修改求出总量
可持久化留下的迹象
我们 伏身欣赏

数论算法 图论算法
高斯费马 树上开花
线性规划 动态规划
时间爆炸 如何优化
我在 OI 中辗转了千百天
却不让我看 AK 最后一眼
我用空间换回超限的时间
随重新编译
测完样例
才发现漏洞满篇

原来 CE 是因选错语言
其实爆零 只因忘写文件
如果标算太难请坚定信念
不如回头再看一眼题面
以那暴力模拟向正解吊唁
蒟蒻的蜕变
神犇出现
终将与 Au 擦肩

屏幕在深夜微微发亮
我心在考场

——膜你抄 WC2017

KsCla
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
NOIP2017提高组DAY2题解
Hi_KER的博客
10-30 1598
T1：奶酪 考察知识：搜索，并查集，枚举 算法难度：XX 实现难度：XX 分析：这道题我当年考试用的dfs，没有处理最后20%的情况，得了80分。下面讲解用并查集解决此题。 显然我们可以用并查集合并连通的洞，只需要进行枚举就可以了 然后我们继续枚举两个不同的洞，如果一个与下边界相交，一个与上边界相交，且在同一个集合里，说明有解；如果枚举完都没有找到解，说明无解。 时间复杂度： 代码：...
[蓝桥杯 2014 国 B] Log 大侠（线段树）
最新发布
m0_60738889的博客
05-03 702
atm 参加了速算训练班，经过刻苦修炼，对以2为底的对数算得飞快，人称 Log 大侠。一天，Log 大侠的好友 drd 有一些整数序列需要变换，Log 大侠正好施展法力。变换的规则是：对其某个子序列的每个整数变为log2​x1其中 [] 表示向下取整，就是对每个数字求以2为底的对数，然后取下整。例如对序列342操作一次后，这个序列会变成232。drd 需要知道，每次这样操作后，序列的和是多少。
NOIP2017游记+题解+标程
Jacky35
11-13 3127
NOIP2017提高组 NOIP2017提高组题解 洛谷题目链接 程序
【NOIP2017提高组正式赛】宝藏 题解
linweitong2020的博客
01-22 297
【NOIP2017提高组正式赛】宝藏 题解 题目大意 这道题目题目大意就是说，有一个图G=(V,E)G=(V,E)G=(V,E)，求一个子图G′=(V,E′)G'=(V,E')G′=(V,E′)，满足E′=V−1E'=V-1E′=V−1，也就是一棵树。 然后每一次一条边建出来的花费就是长度乘以这条边起点的深度加一。 求最小花费。 解题方法 关键词：状态压缩动态规划 设fi,jf_{i,j}fi,j​表示现在这棵树的深度为iii，整棵树的状态（用0/10/10/1表示）为jjj时，的最小花费。 画一个图好看一
NOIP2017奶酪
KING_阿飞的博客
10-30 736
奶酪 题目描述 奶酪 题目描述 现有一块大奶酪，它的高度为hh，它的长度和宽度我们可以认为是无限大的，奶酪 中间有许多 半径相同 的球形空洞。我们可以在这块奶酪中建立空间坐标系，在坐标系中， 奶酪的下表面为z=0z=0，奶酪的上表面为z=hz=h。 现在，奶酪的下表面有一只小老鼠 Jerry，它知道奶酪中所有空洞的球心所在的坐 标。如果两个空洞相切或是相交，则 Jerry 可以从其中一个空洞跑到另...
NOIP2017提高组初复赛试题与题解报告
11-19
【NOIP2017提高组初复赛试题与题解报告】是针对全国青少年信息学奥林匹克联赛（NOIP）2017年提高组竞赛的一份详细解析文档。NOIP是中国计算机学会主办的一项旨在激发青少年对计算机科学兴趣、提升编程能力的比赛。...
noip2008题解
04-07
2008noip 题目+解题报告 题解很详细 但没有具体输入输出
noip2013详细题解
07-07
《NOIP2013详解：解密编程竞赛的秘密武器》 全国青少年信息学奥林匹克联赛（National Olympiad in Informatics in Provinces，简称NOIP）是中国计算机学会主办的一项旨在选拔和培养青少年计算机编程能力的竞赛。...
NOIP2017复赛普及组试题(无题解)
08-03
2017年的NOIP普及组复赛中，参赛者需要解决四道题目，分别是“成绩”、“图书管理员”、“棋盘”和“跳房子”。这些题目没有给出官方题解，旨在鼓励选手独立思考并编写自己的代码，避免抄袭。 “成绩”问题是要求...
洛谷题解：P3954-[NOIP2017 普及组] 成绩
04-16
洛谷题解：P3954-[NOIP2017 普及组] 成绩
解题报告——noip 2017提高组
11-14
解题报告——noip 2017提高组,初赛提高组，pascal及其解析
[NOIp2017 Day2 T2] 宝藏treasure (状压dp）
PhantomAgony
12-03 1150
题目 描述 参与考古挖掘的小明得到了一份藏宝图，藏宝图上标出了 n" role="presentation" style="position: relative;">nnn 个深埋在地下的宝藏屋， 也给出了这 n" role="presentation" style="position: relative;">nnn 个宝藏屋之间可供开发的 m" role="presentation" s
【NOIP2017提高组】宝藏
ETO的博客
08-27 2211
                                                  宝藏 题目背景 NOIP2017提高组 DAY2 T2 题目描述 参与考古挖掘的小明得到了一份藏宝图，藏宝图上标出了 n 个深埋在地下的宝藏屋，也给出了这 n 个宝藏屋之间可供开发的 m 条道路和它们的长度。 小明决心亲自前往挖掘所有宝藏屋中的宝藏。但是，每个宝藏屋距离地面都很远，也就是说...
2017/9/23 出题人翻车记
weixin_30455661的博客
09-23 98
嗯，好久没有写过了，来证明自己还是个活人QAQ. 话说这次考试真是有趣，第一题是送分题，基本全场AC,除了刘神和刘神经以外，第二题标称被LC卡掉了QAQ... 第三题测试点有误，刚出来的时候除了AC就是RE，显然没有AC的 UPD : 最后从今天开始复活 转载于:https://www.cnblogs.com/...
NOIP2017滚粗记
路人黑的纸巾
11-10 2470
NOIP2017 NOIP2017题解：http://blog.csdn.net/enjoy_pascal/article/details/78523496 NOIP2017提高组广东省成绩：http://blog.csdn.net/enjoy_pascal/article/details/78585598 DAY0 游记 经过去年PJ285分压线1=和上个月TG初赛64
NOIP2018退役感言+生涯总结
Amuseir的博客
12-02 1754
其实在考试之前就想过要写退役感言之类的什么东西（毕竟不打算冲省队） 最初的时候以为自己是省一保底随手就能带着开心的心情退役来着，不过很可惜，这么简单的题我居然翻车了 day1前的那一个晚上就觉得可能翻车，紧张得睡不着觉，只睡了3h左右 day1T1原题，第一次做的时候秒切，考场上犯傻，一开始以为肯定不会出原题，就使劲乱想，写了个st表+递归的版本，结果因为自己SB，写半天没有调出来，最后还发现...
NOIP2017Day1T2-时间复杂度
Mi-Queen
02-08 442
2．时间复杂度 (complexity.cpp/c/pas) 小明正在学习一种新的编程语言 A++，刚学会循环语句的他激动地写了好多程序并给出了他自己算出的时间复杂度，可他的编程老师实在不想一个一个检查小明的程序，于是你的机会来啦！下面请你编写程序来判断小明对他的每个程序给出的时间复杂度是否正确。 A++语言的循环结构如下： F i x y 循环体
[NOIP2017]宝藏
weixin_30765577的博客
09-05 82
参与考古挖掘的小明得到了一份藏宝图，藏宝图上标出了nn个深埋在地下的宝藏屋，也给出了这nn个宝藏屋之间可供开发的mm条道路和它们的长度。 小明决心亲自前往挖掘所有宝藏屋中的宝藏。但是，每个宝藏屋距离地面都很远，也就是说，从地面打通一条到某个宝藏屋的道路是很困难的，而开发宝藏屋之间的道路则相对容易很多。 小明的决心感动了考古挖掘的赞助商，赞助商决定免费赞助他打通一条从地面到某...
noip历年真题题解.pdf
09-28
《NOIP历年真题题解.pdf》是一本关于NOIP（全国青少年信息学奥林匹克竞赛）历年真题的解析书籍。这本书的目的是帮助学生更好地理解和掌握NOIP竞赛中的题目，并提供对解题思路的详细解释和讲解。 这本书一般会包含多个年份的NOIP真题，并针对每道题目提供详细的分析和解答过程。通过阅读这本书，学生可以了解到不同年份的试题在类型和难度上的变化，有助于他们对竞赛题目的理解和应对能力的提高。 《NOIP历年真题题解.pdf》通常会按照题目的类型或者年份进行组织和分类。比如，可以将编程题、算法题、数据结构题等进行分组，有助于学生对不同类型题目的习题训练和技巧掌握。 这本书的编写一般由经验丰富的NOIP竞赛选手或者教育机构的教师共同完成。他们会根据自己的经验和理解，结合真题的特点和考察点，给出详细的题目解析。解析中包括对算法思路的讲解、代码实现的示范、以及对常见错误和易错点的指导。 总之，如果你对NOIP竞赛感兴趣，想提高自己的编程和算法能力，阅读《NOIP历年真题题解.pdf》是一个不错的选择。通过学习和掌握这些真题的解析，你可以更好地应对竞赛中的各种类型题目，并提升自己的竞赛水平。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值