NOIP复赛试题.docx

NOIP复赛试题.docx

《NOIP复赛试题.docx》由会员分享，可在线阅读，更多相关《NOIP复赛试题.docx（21页珍藏版）》请在冰豆网上搜索。

NOIP复赛试题

NOIP2011复赛试题

 （2012-10-1807:

44:

21）

转载▼

标签：

教育

分类：

 教育教学

Day1

铺地毯

【问题描述】

为了准备一个独特的颁奖典礼，组织者在会场的一片矩形区域（可看做是平面直角坐标系的第一象限）铺上一些矩形地毯。

一共有n张地毯，编号从1到n。

现在将这些地毯按照编号从小到大的顺序平行于坐标轴先后铺设，后铺的地毯覆盖在前面已经铺好的地毯之上。

地毯铺设完成后，组织者想知道覆盖地面某个点的最上面的那张地毯的编号。

注意：

在矩形地毯边界和四个顶点上的点也算被地毯覆盖。

【输入】

输入文件名为carpet.in。

输入共n+2行。

第一行，一个整数n，表示总共有n张地毯。

接下来的n行中，第i+1行表示编号i的地毯的信息，包含四个正整数a，b，g，k，每两个整数之间用一个空格隔开，分别表示铺设地毯的左下角的坐标（a，b）以及地毯在x轴和y轴方向的长度。

第n+2行包含两个正整数x和y，表示所求的地面的点的坐标（x，y）。

【输出】

输出文件名为carpet.out。

输出共1行，一个整数，表示所求的地毯的编号；若此处没有被地毯覆盖则输出-1。

【输入输出样例1】

carpet.in

carpet.out

3

1023

0233

2133

22

3

【输入输出样例说明】

如下图，1号地毯用实线表示，2号地毯用虚线表示，3号用双实线表示，覆盖点（2，2）的最上面一张地毯是3号地毯。

【输入输出样例2】

carpet.in

carpet.out

3

1023

0233

2133

45

-1

【输入输出样例说明】

如上图，1号地毯用实线表示，2号地毯用虚线表示，3号用双实线表示，点（4，5）没有被地毯覆盖，所以输出-1。

【数据范围】

对于30%的数据，有n≤2；

对于50%的数据，0≤a,b,g,k≤100；

对于100%的数据，有0≤n≤10,000，0≤a,b,g,k≤100,000。

【一句话题意】

给定n个按顺序覆盖的矩形，求某个点最上方的矩形编号。

【考察知识点】

枚举

选择客栈

【问题描述】

丽江河边有n家很有特色的客栈，客栈按照其位置顺序从1到n编号。

每家客栈都按照某一种色调进行装饰（总共k种，用整数0~k-1表示），且每家客栈都设有一家咖啡店，每家咖啡店均有各自的最低消费。

两位游客一起去丽江旅游，他们喜欢相同的色调，又想尝试两个不同的客栈，因此决定分别住在色调相同的两家客栈中。

晚上，他们打算选择一家咖啡店喝咖啡，要求咖啡店位于两人住的两家客栈之间（包括他们住的客栈），且咖啡店的最低消费不超过p。

他们想知道总共有多少种选择住宿的方案，保证晚上可以找到一家最低消费不超过p元的咖啡店小聚。

【输入】

输入文件hotel.in，共n+1行。

第一行三个整数n，k，p，每两个整数之间用一个空格隔开，分别表示客栈的个数，色调的数目和能接受的最低消费的最高值；接下来的n行，第i+1行两个整数，之间用一个空格隔开，分别表示i号客栈的装饰色调和i号客栈的咖啡店的最低消费。

【输出】

输出文件名为hotel.out。

输出只有一行，一个整数，表示可选的住宿方案的总数。

【输入输出样例1】

hotel.in

hotel.out

523

05

13

02

14

15

3

【输入输出样例说明】

客栈编号

①

②

③

④

⑤

色调

0

1

0

1

1

最低消费

5

3

2

4

5

2人要住同样色调的客栈，所有可选的住宿方案包括：

住客栈①③，②④，②⑤，④⑤，但是若选择住4、5号客栈的话，4、5号客栈之间的咖啡店的最低消费是4，而两人能承受的最低消费是3元，所以不满足要求。

因此只有前3种方案可选。

【数据范围】

对于30%的数据，有n≤100；

对于50%的数据，有n≤1,000；

对于100%的数据，有2≤n≤200,000，0

【一句话题意】

合法区间[l,r]定义：

l,r的色调相同，且[l,r]之间存在一个最低消费不超过p。

求合法区间总数。

【考察知识点】

二分查找/枚举

mayan 游戏

【问题描述】

Mayanpuzzle是最近流行起来的一个游戏。

游戏界面是一个7行5列的棋盘，上面堆放着一些方块，方块不能悬空堆放，即方块必须放在最下面一行，或者放在其他方块之上。

游戏通关是指在规定的步数内消除所有的方块，消除方块的规则如下：

1、每步移动可以且仅可以沿横向（即向左或向右）拖动某一方块一格：

当拖动这一方块时，如果拖动后到达的位置（以下称目标位置）也有方块，那么这两个方块将交换位置（参见输入输出样例说明中的图6到图7）；如果目标位置上没有方块，那么被拖动的方块将从原来的竖列中抽出，并从目标位置上掉落（直到不悬空，参见下面图1和图2）；

2、任一时刻，如果在一横行或者竖列上有连续三个或者三个以上相同颜色的方块，则它们将立即被消除（参见图1到图3）。

注意：

a）如果同时有多组方块满足消除条件，几组方块会同时被消除（例如下面图4，三个颜色为1的方块和三个颜色为2的方块会同时被消除，最后剩下一个颜色为2的方块）。

b）当出现行和列都满足消除条件且行列共享某个方块时，行和列上满足消除条件的所有方块会被同时消除（例如下面图5所示的情形，5个方块会同时被消除）。

3、方块消除之后，消除位置之上的方块将掉落，掉落后可能会引起新的方块消除。

注意：

掉落的过程中将不会有方块的消除。

上面图1到图3给出了在棋盘上移动一块方块之后棋盘的变化。

棋盘的左下角方块的坐标为（0,0），将位于（3,3）的方块向左移动之后，游戏界面从图1变成图2所示的状态，此时在一竖列上有连续三块颜色为4的方块，满足消除条件，消除连续3块颜色为4的方块后，上方的颜色为3的方块掉落，形成图3所示的局面。

【输入】

输入文件mayan.in，共6行。

第一行为一个正整数n，表示要求游戏通关的步数。

接下来的5行，描述7*5的游戏界面。

每行若干个整数，每两个整数之间用一个空格隔开，每行以一个0结束，自下向上表示每竖列方块的颜色编号（颜色不多于10种，从1开始顺序编号，相同数字表示相同颜色）。

输入数据保证初始棋盘中没有可以消除的方块。

【输出】

输出文件名为mayan.out。

如果有解决方案，输出n行，每行包含3个整数x，y，g，表示一次移动，每两个整数之间用一个空格隔开，其中（x，y）表示要移动的方块的坐标，g表示移动的方向，1表示向右移动，-1表示向左移动。

注意：

多组解时，按照x为第一关健字，y为第二关健字，1优先于-1，给出一组字典序最小的解。

游戏界面左下角的坐标为（0，0）。

如果没有解决方案，输出一行，包含一个整数-1。

【输入输出样例1】

mayan.in

mayan.out

3

10

210

2340

310

24340

211

311

301

【输入输出样例说明】

按箭头方向的顺序分别为图6到图11

样例输入的游戏局面如上面第一个图片所示，依次移动的三步是：

（2，1）处的方格向右移动，（3，1）处的方格向右移动，（3，0）处的方格向右移动，最后可以将棋盘上所有方块消除。

【数据范围】

对于30%的数据，初始棋盘上的方块都在棋盘的最下面一行；

对于100%的数据，0

【一句话题意】

给定一个存在重力的矩阵，每次只能向左或右交换方块，连续3个或以上的方块群会被消除。

求操作次数为N时的操作步骤。

【考察知识点】

DFS

代码/标程

铺地毯

programcarpet;

//usessysutils;

const

    proname='carpet';

type

    juxing=record

        x1,y1,x2,y2:

longint;

    end;

var

    fin,fout:

text;

    i,j,k,l,r,m,n,x,y,s,t,ans:

longint;

    a:

array[0..11000]ofjuxing;

    t1,t2,t3,t4:

longint;

procedurepin;

var

    i,j,k:

longint;

begin

    readln（fin,n）;

    fillchar（a,sizeof（a）,0）;

    fori:

=1tondo

        begin

            readln（fin,t1,t2,t3,t4）;

            a[i].x1:

=t1;

            a[i].y1:

=t2;

            a[i].x2:

=t1+t3;

            a[i].y2:

=t2+t4;

        end;

    readln（fin,x,y）;

end;

functionok（i:

longint）:

boolean;

begin

    if（a[i].x1<=x）and（x<=a[i].x2）then

        if（a[i].y1<=y）and（y<=a[i].y2）then

            exit（true）;

    exit（false）;

end;

proceduremain;

var

    i,j,k:

longint;

begin

    ans:

=-1;

    fori:

=1tondo

        ifok（i）then

            ans:

=i;

end;

procedurepout;

var

    i,j,k:

longint;

begin

    writeln（fout,ans）;

end;

begin

    assign（fin,proname+'.in'）;

    assign（fout,proname+'.out'）;

    reset（fin）;

    rewrite（fout）;

    //time:

=now;

    pin;

    main;

    pout;

    //writeln（fout,（now-time）*24*3600*1000:

0:

0）;

    close（fin）;

    close（fout）;

end.

选择客栈

//O（nk）

programhotel;

//usessysutils;

const

    proname='hotel';

type

    kezhan=record

        color,cost:

longint;

    end;

var

    fin,fout:

text;

    i,j,k,l,r,m,n,x,y,s,t:

longint;

    a:

array[-10..200100]ofkezhan;

    sum:

array[-10..200100,-10..60]oflongint;

    colorsum,mincost:

longint;

    cafe:

array[-10..200100]oflongint;

    v:

array[-10..200100]ofboolean;

    ans:

int64;

procedurepin;

var

    i,j,k:

longint;

begin

    readln（fin,n,colorsum,mincost）;

    fillchar（a,sizeof（a）,0）;

    fori:

=1tondo

        readln（fin,a[i].color,a[i].cost）;

end;

functionfind（x:

longint）:

longint;

var

    i,j,k,mid:

longint;

begin

    l:

=1;

    r:

=s;

    find:

=-1;

    repeat

        mid:

=（l+r）shr1;

        ifx<=cafe[mid]then

            begin

                r:

=mid-1;

                find:

=cafe[mid];

            end

        else

            l:

=mid+1;

    untill>r;

end;

proceduremain;

var

    i,j,k:

longint;

begin

    fori:

=0tocolorsum-1do

        sum[0,i]:

=0;

    fori:

=1tondo

        begin

            sum[i]:

=sum[i-1];

            sum[i,a[i].color]:

=sum[i-1,a[i].color]+1;

        end;

    s:

=0;

    fillchar（cafe,sizeof（cafe）,0）;

    fillchar（v,sizeof（v）,false）;

    fori:

=1tondo

        ifa[i].cost<=mincostthen

            begin

                inc（s）;

                cafe[s]:

=i;

                v[i]:

=true;

            end;

    ans:

=0;

    fori:

=1ton-1do//meijudiyigeren

        begin

            ifv[i]then

                begin

                    ans:

=ans+（sum[n,a[i].color]-sum[i,a[i].color]）;

                end

            else

                begin

                    j:

=find（i）;

                    ifj=-1thenexit;

                    ans:

=ans+（sum[n,a[i].color]-sum[j-1,a[i].color]）;

                end;

        end;

end;

procedurepout;

var

    i,j,k:

longint;

begin

    writeln（fout,ans）;

end;

begin

    assign（fin,proname+'.in'）;

    assign（fout,proname+'.out'）;

    reset（fin）;

    rewrite（fout）;

    //time:

=now;

    pin;

    main;

    pout;

    //writeln（fout,（now-time）*24*3600*1000:

0:

0）;

    close（fin）;

    close（fout）;

end.

mayan 游戏

programmayan;

//usessysutils;

const

    proname='mayan';

type

    game=record

        data:

array[0..8,0..6]oflongint;

    end;

var

    fin,fout:

text;

    i,j,k,l,r,m,n,x,y,s,t,ans:

longint;

    first:

game;

    b:

array[0..10]ofgame;

    caozuo:

array[0..10,0..3]oflongint;

    tt:

array[0..8,0..6]oflongint;

    cut:

array[0..11]oflongint;

procedurepin;

var

    i,j,k:

longint;

begin

    readln（fin,n）;

    fillchar（first,sizeof（first）,0）;

    forj:

=1to5do

        begin

            i:

=8;

            repeat

                read（fin,k）;

                ifk=0thenbreak;

                dec（i）;

                first.data[i,j]:

=k;

            untilfalse;

            readln（fin）;

        end;

end;

procedureswap（x,x1,y1,x2,y2:

longint）;

var

    t:

longint;

begin

    t:

=b[x].data[x1,y1];

    b[x].data[x1,y1]:

=b[x].data[x2,y2];

    b[x].data[x2,y2]:

=t;

end;

functionok（x:

longint）:

boolean;

var

    i,j,k:

longint;

begin

    ok:

=true;

    fori:

=1to5do

        ifb[x].data[7,i]<>0then

            exit（false）;

end;

proceduredown（x,lie:

longint）;

var

    i,j,k:

longint;

begin

    fori:

=6downto1do

        if（b[x].data[i,lie]<>0）and（b[x].data[i+1,lie]=0）then

            begin

                fork:

=7downto1do

                    ifb[x].data[k,lie]=0then

                        break;

                swap（x,i,lie,k,lie）;

            end;

end;

functionclear（x:

longint）:

boolean;

var

    i,j,k:

longint;

    l,r:

longint;

    step:

longint;

begin

    fillchar（tt,sizeof（tt）,0）;

    l:

=0;

    r:

=0;

    step:

=x;

    clear:

=false;

    fori:

=1to7do

        begin

        forj:

=1to5do

            ifb[x].data[i,j]<>b[x].data[i,j-1]then

                begin

                    r:

=j-1;

                    if（l<>0）and（r-l+1>=3）and（b[x].data[i,l]<>0）then

                        begin

                            fork:

=ltordo

                                tt[i,k]:

=1;

                            clear:

=true;

                        end;

                    l:

=j;

                end;

        if（5-l+1>=3）and（b[x].data[i,5]<>0）then

            begin

                fork:

=lto5do

                    tt[i,k]:

=1;

                clear:

=true;

            end;

        end;

    l:

=0;

    r:

=0;

    fori:

=1to5do

        begin

        forj:

=1to7do

            ifb[x].data[j,i]<>b[x].data[j-1,i]then

                begin

                    r:

=j-1;

                    if（l<>0）and（r-l+1>=3）and（b[x].data[l,i]<>0）then

                        begin

                            fork:

=ltordo

                                tt[k,i]:

=1;

                            clear:

=true;

                        end;

                    l:

=j;

                end;

        if（7-l+1>=3）and（b[x].data[l,i]<>0）and（b[x].data[7,i]<>0）then

            begin

                fork:

=lto7do

                    tt[k,i]:

=1;

                clear:

=true;

            end;

        end;

    fori:

=1to7do

        forj:

=1to5do