当前位置:首页 >> IT/计算机 >>

NOIP初赛资料——队列


队列
Jsoi2009

队列的基本操作
?举例1:到医院看病,首先需要到挂 号处挂号,然后,按号码顺序救诊。 ?举例2:乘坐公共汽车,应该在车站 排队,车来后,按顺序上车。

出队

A1 A2 A3 A4……AN-1 AN F(队头)

进队

R(队尾)

一、队列的定义 队列就是允许在一端进行插入,在另一 端进行删除的线性表。允许插入的一端 称为队尾,通常用一个队尾指针r指向

队尾元素,即r总是指向最后被插入的
元素;允许删除的一端称为队首,通常

也用一个队首指针f指向排头元素的前
面。初始时f=r=0。

? 结论:在队列这种数据结构中,最先

插入在元素将是最先被删除;反之最
后插入的元素将最后被删除,因此队

列又称为“先进先出”(FIFO—first
in first out)的线性表。

? 队列的基本操作:

(1)初始化队列 Qini (Q)

(2)入队 QADD(Q,X)
(3)出队 QDel(Q,X) (4)判断队列是否为空 qempty(Q) (5)判断队列是否为满qfull(Q)

二、队列的存储结构 1、顺序存储 Const Const m=队列元素的上限; m=队列元素的上限; Type Type queue=record {队列的类型定义} queue=record {队列的类型定义} data array[1..m] of elemtype data : : array[1..m]of elemtype f,end; r: integer ; {队尾指针和队首指针} Var end; q:queue; {队列} Var r:q:queue; {队列} f, integer ; {队尾指针和队首指针}

二、队列的存储结构

2、链式存储
F
A1 A2 AN

R

type link= ^celltype ; celltype=record data:elemtype; next:link; end; var f,r:link;

三、队列的基本运算 1、初始化:设定Q为一空队列: procedure Qini (var Q:queue); begin

Q.f:=0;
Q.r:=0;

end;

2、判队列空:若队列Q为空,则返回值 true,否则返回值false。 function qempty(Q:queue):Boolean; begin qempty:=(Q.r=Q.f) end;

3、判队满:若队列满,则返回值true, 否则返回值false。 function qfull(Q:queue):Boolean; begin Qfull:=(Q.r=m); end;

4、元素进队:若队列Q不满时,把元 素X插入到队列Q的队尾,否则返回信 息“Overflow”:
procedure QADD(var q:queue;x:elemtype); begin if qfull(Q) then writeln (‘overflow’) {上溢} else begin {后移队尾指针并插入元素x} Q.R:=Q.r+1; Q.data[Q.r]:=x; end;{else} end;{ADD}

5、元素出队:若队列Q不空,则把队头 元素删除并返回值给X,否则输出信息 “Underflow”: procedure Qdel(var Q:queue;var X:elemtype); begin if qempty(Q) then writeln(‘Underflow’) {下溢} else begin {后移队首指针并取出队首元素} Q.f←Q.f+1; X←Q.data[Q.f] ; end;{else} end;

应用举例 例1假设在周末舞会上,男士们和女士们 进入舞厅时,各自排成一队。跳舞开始 时,依次从男队和女队的队头上各出一 人配成舞伴。规定每个舞曲能有一对跳 舞者。若两队初始人数不相同,则较长 的那一队中未配对者等待下一轮舞曲。 现要求写一个程序,模拟上述舞伴配对 问题。 输入:第一行两队的人数 第二行舞曲的数目

分析:设计两个队列分别存放男士和女士。 每对跳舞的人一旦跳完后就回到队尾等待 下次被选。如m=4 n=3 k=6 F1 R1 A 1 2 3 1 2 3 F2 R2 ………… …………

B 1 2 1 2 1 2

const max=10000; var a,b:array[1..max] of integer; m,n,k1,k,i,f1,r1,f2,r2:integer; begin readln(m,n); for i:=1 to m do a[i]:=i; for i:=1 to n do b[i]:=i; readln(k); k1:=1; f1:=1;r1:=m;f2:=1;r2:=n;

repeat writeln(a[f1]:3,' ',b[f1]:3); r1:=r1+1;a[r1]:=a[f1]; f1:=f1+1 ; r2:=r2+1;b[r2]:=b[f2]; f2:=f2+1; k1:=k1+1;

until k1>k
end.

例2.集合的前N个元素:编一个程序,按递 增次序生成集合M的最小的N个数,M的定义 如下: (1)数1属于M; (2)如果X属于M,则Y=2*X+1和Z=3*x+1 也属于M; (3)此外再没有别的数属于M。

分析:可以用两个队列a和b来存放新产生 的数,然后通过比较大小决定是否输出, 具体方法如下: (1)令fa和fb分别为队列a和队列b的头指 针,它们的尾指针分别为ra和rb。初始时, X=1,fa=fb=ra=rb=1; (2)将2*x+1和3*x+1分别放入队列a和队 列b的队尾,尾指针加1。即: a[r]←2*x+1,b[r]←3*x+1,r←r+1;

(3)将队列a和队列b的头结点进行比较, 可能有三种情况: (A)a[ha]>b[hb] (B)a[ha]=b[hb] (C)a[ha]<b[hb]
将比较的小者取出送入X,取出数的队 列的头指针相应加1。 (4)重复(2),(3)直至取出第N项为止。

var a,b:array[1..1000] of integer;

x,fa,fb,ra,rb,total,n,i:integer;
flag,flag1:boolean; begin write('N=');readln(n); x:=1;

fa:=1;fb:=1;ra:=0;rb:=0;total:=1;

while total<=n do begin write(x:5); inc(ra);inc(rb); flag:=true; for i:=fb to rb do {判重} if 2*x+1=b[i] then flag:=false; if flag then a[ra]:=2*x+1 else ra:=ra-1; b[rb]:=3*x+1;

if a[fa]>b[fb] then begin x:=b[fb];inc(fb); end else begin x:=a[fa];inc(fa); {a[fa]<=b[fa]} if a[fa]=b[fb] then inc(fb); end;(应改为a[fa-1]=b[fb]) inc(total); end; end.

算法二: var a:array[1..30000] of 0..1; f,t,n,m,i:integer; begin readln(n); for i:=1 to 30000 do a[i]:=0; a[1]:=1;f:=1;k:=1; while t<=n do begin a[f*2+1]:=1;a[f*3+1]:=1; f:=f+1; while a[f]=0 do f:=f+1; t:=t+1; end;

m:=1;i:=1; while m<=n do begin if a[i]<>0 then begin write(i,' '); m:=m+1; end; i:=i+1; end; end.

例3下图表示的是从城市A到城市H的交通图。 从图中可以看出,从城市A到城市H要经过若 干个城市。现要找出一条经过城市最少的一条 路线。

看到这图很容易想到用邻接距阵来表示,0 表示能走,1表示不能走。

首先想到的是用队的思想。我们可以a记录搜索 过程,a.city记录经过的城市,a.pre记录前趋元素, 这样就可以倒推出最短线路。 具体过程如下: (1) 将城市A入队,队首、队尾都为1。 (2) 将队首所指的城市所有可直通的城市入队 (如果这个城市在队中出现过就不入队,可用 一个集合来判断),将入队城市的pre指向队首 的位置。然后将队首加1,得到新的队首城市。 重复以上步骤,直到城市H入队为止。当搜到城 市H时,搜索结束。利用pre可倒推出最少城市 线路。

const ju:array[1..8,1..8] of 0..1= ((1,0,0,0,1,0,1,1), (0,1,1,1,1,0,1,1), (0,1,1,0,0,1,1,1), (0,1,0,1,1,1,0,1), (1,1,0,1,1,1,0,0), (0,0,1,1,1,1,1,0), (1,1,1,0,0,1,1,0), (1,1,1,1,0,0,0,1)); type r=record {记录定义} city:array[1..100] of char; pre:array[1..100] of integer; end; var h,d,i:integer; a:r; s:set of 'A'..'H';

procedure out; {输出过程} begin write(a.city[d]); repeat d:=a.pre[d]; write('--',a.city[d]); until a.pre[d]=0; writeln; halt; end;

procedure doit; begin begin inc(d); {队尾加一,入队} h:=0; d:=1; a.city[d]:=chr(64+i); a.city[1]:=‘A’; a.pre[d]:=h; a.pre[1]:=0; s:=s+[a.city[d]]; s:=[‘A’]; a.city[d]='H' then out; if repeat {步骤2} end; inc(h); {队首加一,出队} until h=d; for i:=1 to 8 do {搜索可直通的城市} end; if (ju[ord(a.city[h])-64,i]=0) begin {主程序} and (not(chr(i+64) in s))then {判断城市是否走过} doit; end.

例4迷宫问题
编一个程序,找出一条通过迷宫的路径。在 任何一个格子中,可以向8个方向前进,这里有 兰色方块的单元表示走不通,将从入口处经过 迷宫到出口处的最短的一条通路打印出来。 入口

出口

分析(1)怎样来存储迷宫?将它变成0,1 二维数组。这样上述迷宫可转化为:
0 1 0 0 1 0 1 1 1 1 0 1 1 0 0 1 0 1 1 0 1 0 1 0 1 1 1 1 1 0 1 1

1
0

0
1

0
1

1
0

1
0

0
1

0
1

0
0

(2)在迷宫中怎样探索路径?有几个方 向可以探索呢? *只有三个探索方向的位置。如mg[1,1]
*有五个探索方向的位置。如mg[3,1] *有八个探索方向的位置。如mg[3,2]

思考:能否都转化为八个方向的探索呢?

这样存储的迷宫数组就转化成:
1 1 1 0 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1

1
1 1 1 1 1

1
0 0 1 0 1

0
1 1 0 1 1

1
0 1 0 1 1

0
0 1 1 0 1

1
1 0 1 0 1

0
1 0 0 1 1

1
1 1 0 1 1

0
1 1 0 0 1

1
1 1 1 1 1

(x-1,y-1) (x-1,y)(x-1,y+1) (x,y-1) (x,y)(x,y+1)

因此,数组定义为: Mg:array[0..m+1,0..n+1] of integer; 而探索方向则变成了统一的情况,都探 Dx Dy 索8个方向:
0 1 1 1 0 -1 -1 -1 1 1 0 -1 -1 -1 0 1

(x+1,y+1) (x+1,y-1) (x+1,y) 这样可以定义一个二维数组记 录探索方向。

(3)如何才能记录踪迹,并把探索的踪 迹记忆下来呢? 踪迹一般应包括来处和当前位置,可以需 要用记录类型 Node=record X,y:integer; Pre:0..r; End; 用一个对队列记忆探索的踪迹: Sqtype=array[1..r] of node;

例如:从(1,1)入口到达(6,8),往下 探索时队列的情况
1 1 1 1 1 1 1 1 1 0 1 0 0 1 0 1 1 1 0 1 1 0 1 1 1 1 1 0 1 0 1 1 1 1 0 0 1 1 0 1 1 0 1 1 0 1 0 1 1 1 0 1 0 0 1 1 1 1 1 1 1 0 1 1 1 1 0 1 1 0 0 1 1 1 1 1 1 1 1 1

(4)如何防止重复探索:将迷宫中的0替换 为-1

procedure Qini(var sQ:sqtype); begin sQ[1].x:=1;sq[1].y:=1; Sq[1].pre:=0 F:=1;r:=1;mg[1,1]:=-1; end;

Procedure mglj(var sq:sqtype); Begin Sqini; While f<=r do Begin x:=sq[f].x;y:=sq[f].y; for v:=1 to 8 do begin i:=x+zl[v,1]; j:=y+zl[v,2]; if mg[i,j]=0 then begin r:=r+1; sq[r].x:=I;sq[r].y:=j;sq[r].pre:=f; mg[i,j]:=-1; end; if (i=m) and (j=n) then [print;exit] end;

F:=f+1 End; Writeln(‘迷宫无路径’); 如何打印路径? End; Procedure print(var sq:sqtype,r:integer); Begin i:=r; repeat writeln(‘(‘,sq[i].x,’,’,sq[i].y,’)’); i:=sq[i].pre until i=0 End;

产生问题:由于顺序存储结构的存储 空间属于静态分配,所以,在添加数 据元素时,可能会出现没有剩余单元 的情况。下面我们讨论一下下图所示 的队列,称为“假溢出”现象。
0 1 2 3 4 a5 5 a6 6 a7 7 a8

fro n t

rear

解决方法:将元素加入到第一个位置, 即将存储空间的第一个位置作为队尾。 采用首尾相接的结构后,形成一个环状, 解决假溢出问题,避免数据元素的移动。 如图所示。我们将这种形式表示的队列 称之为循环队列。 R
m m-1 am Am-1 Am-1

Am Am+1
m1 2

F

3

空闲区
Am+1

3 4

F

2
R 1

循环队列的操作 1、初始化:设定Q为一空队列,队首指 针和队尾指针均指向存储空间的最后一 个位置 procedure iniqueue(var Q:equeue); begin Q.f:=m;Q.r:=m;

end;

2、判队列空:若队列Q为空,则返回值 true,否则返回值false。 function qempty(Q:equeue):Boolean;

begin
qempty:=(Q.f=Q.r) end;

3、判队满:若队列满,则返回值true, 否则返回值false。为了区分队列空和队 列满,改用“队尾指针追上队首指针” 这一特征作为队列满标志。 function qfull(Q:equeue):Boolean; begin qfull:=((Q.r mod m)+1=Q.f);

end;

4、元素进队:若队列Q不满时,把元素 X插入到队列Q的队尾,否则返回信息 “Overflow”: procedure add(var Q:equeue;X:elemtype); begin if qfull(Q) then writeln(‘Overflow’) else begin Q.r:=Q.r mod m+1; Q.data[Q.r]:=X; end end;

5、元素出队:若队列Q不空,则把队头 元素删除并返回值给X,否则输出信息 “Underflow”: procedure del(var Q:equeue;var X:elemtype); begin if qempty(Q) then writeln(‘Underflow’) else begin {后移队首指针并取出队首元素} Q.f:=Q.f mod m+1; X:=Q.data[Q.f]; end; end;

例5约瑟夫问题:编号为1,2,……n个人 按顺时针方向围坐一圈,每人持一个正整 数密码,开始给定一个正整数m,从第一 个人按顺时针方向自1开始顺序报数,报 到m者出围坐的圈子,不再参加报数,这 时将出列者的密码作为m,从出列者顺时 针方向的下一个人开始重新从1报数,如 此下去,直到所有人都出围坐的圈子为止, 输出出列者的序列。

例如有5人 M=18

序号

1 8

2 7

3 3

4 6

5 5

密码

(1)开始取m=18,从1报 1 2 4 5 8 7 6 5 数,则序号为3的人出列。 (2)开始取m=3,从4报数, 2 4 5 7 6 5 则序号为1的人出列。 (3)开始取m=8,从2报数, 2 5 7 5 则序号为4的人出列。 (4)开始取m=6,从5报数, 5 5 则序号为2的人出列。 (5)开始取m=5,从5报数, 出列顺序为:3,1,4,2,5 则序号为5的人出列。

const max=30; type people=record number,code:array[1..max] of integer end; var a:people; m,n,i,j,s,w,p:integer; begin readln(m,n); for i:=1 to n do a.number[i]:=i; for i:=1 to n do read(a.code[i]);

s:=1; for j:=n downto 1 do begin s:=(s+m-1) mod j; if s=0 then s:=j; w:=s;p:=a.number[w];write(p,' '); m:=a.code[p]; for i:=s to j-1 do begin a.number[i]:=a.number[i+1]; a.code[i]:=a.code[i+1]; end; end; end.

综合举例例6[问题描述]求一棵树的深度与宽度。 [算法说明]树可用数组 tree:array[1..n,1..5]of integer; 如上图可表示为: (1)
1 2 3 2 5 6 3 8 0 4 9 10 5 0 0 6 0 0 7 11 12 8 0 0 9 0 0 10 0 0 11 0 0 12 13 0 4 7 0 0 0 0 0 0 0 0 0 0 0 0 (2) (3) (4) 0 0 (5) (7) (8) (9) (10) (6) 0 0 ?本题的数据结构含义, (11) (12) 0 首先要搞清楚:tree[i,j]存 0 (13) 储编号为i的结点的第j号 0 0 孩子(2<=j<=5,即最多 0 4个孩子),tree[i,j]=0表 0

13 0 0 0 0

示不存在;

在求解的过程中,用到数组 G:ARRAY[1..N,1..7] OF INTEGER;
其中:G[I,1]表示父结点, 注意:g[i,k]实质上
是一个队列,sp1为 G[I,2]表示层次, 队列头指针,sp2为队 列尾指针。 G[I,3]表示本结点号,

G[I,4]——G[I,7]

表示子女结点;

同时,设2个指针SP1(取数指针),
SP2(存数指针)

[程序清单]: program exGp3; const n=13; var i,j,k,sp1,sp2,n1,n2,jmax,p:integer; tree:array[1..n,1..5]of integer; g :array[1..n,1..7]of integer; begin tree[i,j]=0表示i结点不 for i:=1 to n do 存在 begin tree[i,1]:=i; for j:=2 to 5 do read (tree[i,j]); readln; end;

sp1:=1;sp2:=1;g[1,1]:=0;g[1,2]:=1;g[1,3]:=1; for i:=4 to 7 do g[1,i]:=tree[1,i-2]; sp1<=sp2 while__________________do 表示队列非空时做…… begin p:=g[sp1,2];n2:=g[sp1,3]; {读队顶} p:=p+1 ____________;j:=4; 变量p是用来存放层次的 g[sp1,j]<>0 while ________________do 遍历 begin n1:=g[sp1,j];j:=j+1; 本结 sp2:=sp2+1 ___________________; 移动队尾指针 点的 g[sp2,1]:=n2;g[sp2,2]:=p;g[sp2,3]:=n1; 所有 for i:=1 to 4 do g[sp2,i+3]:=tree[n1,i+1]; end; 孩子 为下一个结点的 sp1:=sp1+1 ___________________; 遍历操作作准备 end; 移动队头指针

writeln('maxd=',g[sp2,2]); 打印深度 j:=1;k:=g[1,2];jmax:=0; for i:=2 to sp2 do 同层次个数累加放 if g[i,2]=k then j:=j+1 在j中 else begin if j>jmax then jmax:=j; j与jmax打 j:=1 _______; 擂台,找 注意一层完了,j k:=g[I,2]; 出最大值 值要还原,宽度 end; 至少为1 if j>jmax then jmax:=j; writeln('max1=',jmax); end.

例7有10升油在10升的容器中,另有两个7升和3升 的空容器,现要求用这三个容器倒油,使得最后 在10升和7升的容器中各有5升油。 分析: 三个容器可以看作三个变量 C10,C7,C3, 每次倒油的可能性只有如下六种情况: ① C10 向 C7 倒油 ② C10 向 C3 倒油 ③ C7 向 C10 倒油 ④ C7 向 C3 倒油 ⑤ C3 向 C10 倒油 ⑥ C3 向 C7 倒油

从一个容器状态(三个容器中油的容量) 看,虽然有可能经过上述六种倒油的方法产 生六种容器状态,但实际上这六种新产生的 容器状态,许多是已经出现过的状态。例如 初始状态(10,0,0)表示 C10=10,C7=0, C3=0,经过上述六种倒油方法只能产生出两 种新的容器状态(3,7,0)和(7,0,3),再 增加一个变量记录当前状态是由什么状态产 生的,这样就形成了一个不断扩张新结点的 过程,因此这个倒油的过程就可以用队列来 记录了。

队列可以理解为一个数组,数组元素是如下记录: RECORD C10,C7,C3,pre:integer; END; 数组下标为容器状态号。下面是倒油过程的队列图示: 1 C10 C7 C3 PRE
0
0 0

2
7

3

4
0

5
3

6 7
7 6

8
4

9 10 11 12 13 14 15 16 17 18 19
6 4 9 1 9 1 2 8 2 8 5

10 3

7
0 1

0
3 1

7
3 2

4
3 2

3
0 3

4
0 5

3
3 6

1
3 7

6
0 8

1
0 9

6
3

0
1

7
2

7
1

0
2

5
3

2
0

5
0

10 11 12 13 14 15 16 17

当倒油产生出第19个容器状态时已达到了题解的目的。这时只要根据pre中 的状态号17可以回溯到第17个容器状态的pre值为15,依次可再获得13,11,9, 7,5,2,1容器状态号,从而即可得到解题的倒油过程(共倒9次)。

请注意,从一个容器中向另一个容器中倒油,人操作是 很直观的,对编程来说则必须考虑: 1) 2) 有没有油可倒? 究竟倒多少?可能要全部倒入另一容器,也可

能只要倒一部分另一容器已经满了. 队列元素说明了100个,为什么? 变量fp,rp在程序中用作队列的头指针和尾指 针;flag在程序中标识是否已倒出了需要的容器状态 (C10=5,C7=5);下面是程序清单:

Type node=record c10,c7,c3:integer; pre:0..100; end; Var q:array [1..100] of node; f,r:integer; w10,w7,w3:integer; 三种容器中实际装油量 达到目标状态的标志 flag:boolean; Procedure out; {取队头结点} Begin w10:=q[f].c10;w7:=q[f].c7;w3:=q[f].c3; End;

Procedure push; {入队} Var flag1:boolean; {队中是否已有同结点的标志} Begin flag1:=true; for k:=1 to r do if (q[k].c10=w10) and (q[k].c7=w7) and (q[k].c3=w3) then flag1:=false; If flag1 then begin r:=r+1; q[r].c10:=w10; q[r].c7:=w7; q[r].c3:=w3 q[r].pre:=f end; End;

Procedure cup;{产生新结点的过程} Begin out; {c10→c7} If w10>0 then begin if w10+w7>=7 then begin w10:=w10+w7-7;w7:=7; End; else begin w7:=w10+w7; w10:=0; end; push; if (q[r].c10=5) and (q[r].c7=5) then begin flag:=true; exit; end; end;

out; {c10→c3} If w10>0 then begin if w10+w3>=3 then begin w10:=w10+w7-3;w3:=3; End; else begin w3:=w10+w3; w10:=0; end; push; if (q[r].c10=5) and (q[r].c7=5) then begin flag:=true; exit; end; end;

out; {c7→c10} If w7>0 then begin w10:=w10+w7;w7:=0; push; if (q[r].c10=5) and (q[r].c7=5) then begin flag:=true; exit; end; end; out; {c7→c3} If w7>0 then begin
if w7+w3>=3 then begin w7:=w7+w3-3;w3:=3; End; else begin w3:=w7+w3; w7:=0; end

push;
if (q[r].c10=5) and (q[r].c7=5) then begin flag:=true; exit; end; end;

out; {c3→c10} If w3>0 then begin w10:=w10+w3;w3:=0; push; if (q[r].c10=5) and (q[r].c7=5) then begin flag:=true; exit; end; end; out; {c3→c7} If w3>0 then begin if w3+w7>=7then begin w3:=w3+w7-7;w3:=0;end else begin w7:=w7+w3; w3:=0; end; push; if (q[r].c10=5) and (q[r].c7=5) then begin flag:=true; exit; end; end;

Procedure print; Var s:array[1..100] of 0..100; begin write('queue:'); for i:=1 to r do write(q[i].c10:3,q[i].c7:3, q[i].c3:3, q[i].pre:3); s[1]:=r;i:=1; writeln; while s[i]<>0 do begin i:=i+1;s[i]:=q[s[i-1]].pre; end; for k:=i-1 downto 1 do writeln(q[s[k]].c10:5,q[s[k]].c7:5, q[s[k]].c3:5); end;

Begin{主程序}
f:=1;r:=1; q[1].c10:=10;q[1].c7:=0;q[1].c3:=0; q[1].pre:=0;Flag:=false; Repeat cup; f:=f+1;until flag or (f>r);

If f>r then write(‘no’)
else print;

End.

思 考
? 有没有其他办法判重,判定到达了目标

状态!

谢谢!
Jsoi 2007 南京


相关文章:
信息学奥赛NOIP初赛复习知识点
信息学奥赛NOIP初赛复习知识点_其它课程_高中教育_...队列是先进先出;例如:某个车站呈狭长形,宽度只能容...信息学奥赛辅导资料 48页 免费 信息学奥赛——算法...
noip初赛重点总汇
NOIP 初赛理论知识复习资料... 20页 免费 Noip初赛综合复习 31页 2财富值 NOIP...队列 (Queue) 一种特殊的线性表,它只允许在表的前端(front)进行删除操作,而 ...
NOIP初赛基础知识分类统计(数据结构部分)
NOIP初赛理论知识复习资料 12页 免费 NOIP初赛培训 70页 免费 NOIP基础数据结构...A)2h+l B)h C)2h-1 D)2h E)2h-l 17.已知队列(13,2,11,34,41...
NOIP初赛复习
NOIP初赛复习_IT/计算机_专业资料。初赛复习 初赛考的知识点就是计算机基本常识...星型网 设栈 S 和队列 Q 的初始状态为空,元素 e1,e2,e3,e4,e5,e6 ...
信息学奥赛NOIP初赛复习知识点(未完成稿)
noip2010 初赛集训一 20页 2财富值 NOIP初赛用复习资料 81页 1财富值 [合肥...(b<>0) C:D:E: 10、数据结构基础: A:栈的出入顺序是先进后出,队列是...
noip2000初赛试题及答案
noip2000初赛试题及答案_IT/计算机_专业资料noip2000初赛试题及答案没分了,大力...传播性、潜伏性、破坏性与易读性 8. 设循环队列中数组的下标范围是 1–n, ...
第十九届2013全国青少年信息学奥林匹克联赛初赛试题C++...
第十九届2013全国青少年信息学奥林匹克联赛初赛试题C++...如果不使用堆或其它优先队列进行优化,则其时间复杂 ...指数时间内能够解决的问题 5.CCF NOIP 复赛考试结束...
NOIP2013初赛提高组Pascal试题及答案
算法计算单源最短路时,如果不 使用堆或其它优先队列进行优化,则其时间复杂度为...NOIP初赛复习资料 60页 1下载券 NOIP提高组初赛基础知识... 2页 1下载券 第...
CCF NOIP2017 初赛普及组 C++语言试题及参考答案
CCF NOIP2017 初赛普及组 C++语言试题及参考答案_笔试_求职/职场_实用文档。第...●不得使用任何电子设备(如计算器、手机、电子词典等)或查阅任何书籍资料。 一...
NOIP初赛复习——选择题系列
noip初赛选择题专题训练 7页 免费 Noip初赛综合复习...十六进制数 100 2.下列关于队列的叙述,错误的是( ...光盘根据基制造材料和记录信息的方式不同,一般可分...
更多相关标签: