pascal-基本算法模块

基本算法模块

For NOIP2007

Billy.Linux

模块目录

一、排序

1．选择排序

2．插入排序

3．冒泡排序

4．快速排序

5．堆排序

6．归并排序

7．线性时间排序二、高精度

1．高精度比较

2．高精度加法

3．高精度减法

4．单精度乘法

5．高精度乘法

6．单精度除法

7．高精度除法

8．进制转换

三、数论

1．欧几里德算法

2．扩展欧几里德

3．求最小公倍数

4．求解线形同余方程

5．素数的判断

6．素数的生成

四、排列组合

1．排列生成算法

2．组合生成算法

3．排列按序生成法

4．排列字典序生成法五、图论

1．图的读入

2．深度优先搜索

3．广度优先搜索

4．强连同分量

5．拓扑排序

6．最小生成树

7．最短路径

六、背包问题

1．装满背包

2．一维价值最大背包

3．二位价值最大背包

一、排序算法

var

a:array[1..maxn]of longint;——排序对象

1．选择排序——Select_sort procedure select_sort;

begin

for i:=1 to n-1 do

for j:=i+1 to n do

if a[i]>a[j] then

begin temp:=a[i];a[i]:=a[j];a[j]:=temp;end; end;

2．插入排序——Insert_sort

procedure insert_sort;

begin

for i:=2 to n do

begin

key:=a[i];j:=i-1;

while (key0) do begin a[j+1]:=a[j];dec(j);end; a[j+1]:=key;

end;

end;

3．冒泡排序——Bubble_sort

procedure bubble_sort;

begin

for i:=1 to n-1 do

for j:=n downto i+1 do

if a[j]

begin temp:=a[j];a[j]:=a[j-1];a[j-1]:=temp;end;

end;

4．快速排序——Quick_sort

procedure qsort(s,t:longint);

var

i,j,x:longint;

begin

i:=s;j:=t;x:=a[(i+j)div 2];

repeat

while a[i]

while a[j]>x do dec(j);{找右边比他小的}

if i<=j then{交换}

begin

temp:=a[i];a[i]:=a[j];a[j]:=temp;

inc(i);dec(j);

end;

until i>j;

if s

if i

end;

5．堆排序——Heap_sort

procedure heap(i,n:longint);{将第i个元素向下筛} var

j,x:longint;

begin

j:=i*2;x:=a[i];

while j<=n do

begin

if (j

if x

then begin

a[i]:=a[j];i:=j;j:=i*2;

end

else j:=n+1;

end;

a[i]:=x;

end;

procedure heap_sort;

begin

for i:=n div 2 downto 1 do heap(i,n);

for i:=n downto 2 do

begin

temp:=a[i];a[i]:=a[1];a[1]:=temp;

heap(1,i-1);

end;

end;

6．归并排序——Merge_sort procedure mergesort(s,t:longint);

var

m,i,j,k:longint;

begin

if t-s=0 then exit;

m:=(s+t)div 2;

mergesort(s,m);

mergesort(m+1,t);

for i:=1 to m-s+1 do b[i]:=a[s+i-1];

for j:=m+1 to t do c[j-m]:=a[j];

i:=1;j:=1;b[m-s+2]:=max;c[t-m+1]:=max;

for k:=s to t do

if b[i]

then begin a[k]:=b[i];inc(i);end

else begin a[k]:=c[j];inc(j);end;

end;

7．线性时间排序——基数排序、计数排序、桶排序二、高精度算法——High_precision

const

maxcount=进制位

maxlen=记录高精度数组大小

type

bignum=array[0..maxlen]of longint;0为位数

1．高精度比较

function compare(a,b:bignum):longint;

begin

while a[a[0]]=0 do dec(a[0]);{检查位数是否正确}

while b[b[0]]=0 do dec(b[0]);

while a[a[0]+1]>0 do inc(a[0]);

while b[b[0]+1]>0 do inc(b[0]);

if a[0]>b[0] then exit(1);

if a[0]

for i:=a[0] downto 1 do

begin

if a[i]>b[i] then exit(1);

if a[i]

end;

exit(0);

end;

2．高精度加法

procedure add(a,b:bignum;var c:bignum);

var

i:longint;

begin

fillchar(c,sizeof(c),0);c[0]:=1;

if a[0]>b[0]

then c[0]:=a[0]

else c[0]:=b[0];

for i:=1 to a[0] do inc(c[i],a[i]);

for i:=1 to b[0] do inc(c[i],b[i]);

for i:=1 to c[0] do

begin

inc(c[i+1],c[i] div maxcount);

c[i]:=c[i] mod 10;

end;

while c[c[0]+1]>0 do

begin

inc(c[0]);

inc(c[c[0]+1],c[c[0]] div maxcount);

c[c[0]]:=c[c[0]] mod maxcount;

end;

end;

3．高精度减法

procedure minus(a,b:bignum;var c:bignum);

var

i:longint;

begin

fillchar(c,sizeof(c),0);c[0]:=a[0];

for i:=1 to c[0] do c[i]:=a[i]-b[i];

for i:=1 to c[0] do

if c[i]<0 then

begin

dec(c[i+1]);

inc(c[i],maxcount);

end;

while (c[0]>1)and(c[c[0]]=0) do dec(c[0]);

end;

4．单精度乘法

procedure mulnum(a:bignum;x:longint,var c:bignum);

var

i:longint;

begin

fillchar(c,sizeof(c),0);c[0]:=a[0];

for i:=1 to c[0] do c[i]:=a[i]*x;

for i:=1 to c[0] do

begin

inc(c[i+1],c[i] div maxcount);

c[i]:=c[i] mod 10;

end;

while c[c[0]+1]>0 do

begin

inc(c[0]);

inc(c[c[0]+1],c[c[0]] div maxcount);

c[c[0]]:=c[c[0]] mod maxcount;

end;

end;

5．高精度乘法

procedure mul(a,b:bignum;var c:bignum);

var

i,j:longint;

begin

fillchar(c,sizeof(c),0);c[0]:=a[0]+b[0]-1;

for i:=1 to a[0] do

for j:=1 to b[0] do

inc(c[i+j-1],a[i]*b[j]);

for i:=1 to c[0] do

begin

inc(c[i+1],c[i] div maxcount);

c[i]:=c[i] mod 10;

end;

while c[c[0]+1]>0 do

begin

inc(c[0]);

inc(c[c[0]+1],c[c[0]] div maxcount);

c[c[0]]:=c[c[0]] mod maxcount;

end;

end;

6．单精度除法

function divnum(a:bignum;x:longint;var c:bignum):longint;

var

i,temp:longint;

begin

fillchar(c,sizeof(c),0);c[0]:=a[0];

temp:=0;

for i:=a[0] downto 1 do

begin

temp:=temp*maxcount+a[i];

c[i]:=temp div x;

temp:=temp mod x;

end;

while (c[o]>1)and(c[c[0]]=0) do dec(c[0]);

exit(temp);

end;

7．高精度除法

procedure div(a,b:bignum;var c,d:bignum);

var

i:longint;

begin

fillchar(c,sizeof(c),0);c[0]:=a[0]-b[0]+1;

fillchar(d,sizeof(d),0);d[0]:=1;

for i:=c[0] downto 1 do

begin

c[i]:=maxcount;

repeat

dec(c[i]);mul(c,b,temp);

until compare(a,temp)>=0;

end;

while (c[o]>1)and(c[c[0]]=0) do dec(c[0]);

minus(a,temp,d);

end;

8．进制转换

10进制数用bignum记，maxcount=10

k进制数用string记

const

repchar:array[0..35]of string=(‘0’,‘1’,’2’,……,’a’,’b’,……,’z’);——数码对应的字符

repnum:array[48..122]of longint=(0,1,2……,34,35);——字符的ASCCI码对应的数码k进制转十进制：

procedure change_to_ten(s:string;k:longint):bignum;

var

i,l:longint;

temp:bignum;

begin

l:=length(s);

temp[0]:=1;temp[1]:=repnum[ord(s[l])];

for i:=1 to l-1 do

begin

inc(temp[1],repnum[ord(s[l-i])]);

mulnum(temp,k);

end;

exit(temp);

end;

十进制转k进制：

procedure change_to_k(num:bignum;k:longint):string;

var

i,temp:longint;

s:string;

begin

if (num[0]=1)and(nu m*1+=0) then exit(‘0’);

while not((num[0]=1)and(num[1]=0)) do

begin

temp:=divnum(num,k,num);

s:=repchar[temp]+s;

end;

exit(s);

end;

三、数论算法

1．求最大公约数——gcd（欧几里德算法）

递归(recursion)：

function gcd(a,b:longint):longint;

begin

if b=0 then exit(a);

exit(gcd(b,a mod b));

end;

非递归(iterative)：

function gcd(a,b:longint):longint;

var

t:longint;

begin

while b<>0 do

begin

t:=a;a:=b;b:=t mod b;

end;

exit(a);

end;

2．扩展欧几里德算法

function extended_euclid(a,b:longint;var x,y:longint):longint;

var

p,q:longint;

begin

if b=0 then

begin

x:=1;y:=0;

exit(a);

end;

p:=extended_euclid(b, a mod b,x,y);

q:=x;x:=y;y:=q-a div b *y;

exit(p);

end;

3．求最小公倍数

k:=a*b div gcd(a,b);

4．求解线性同余方程

type

ansnode=record

ansnum:longint;——解的个数

num:array[1..maxnnum]of longint;——解

end;

procedure modular_linear_equation(a,b,n:longint;var ans:ansnode);

var

d,i,x,y,temp:longint;

begin

d:=extended_euclid(a,n,x,y);

if b mod d <>0

then ans.ansnum:=0

else begin

ans.ansnum:=d;temp:=(x*(b div d))mod n;

for i:=1 to d do ans.num[i]:=(temp+i*(n div d))mod n;

end;

end;

5．素数的判断

function prime_bool(x:longint):boolean;

var

i:longint;

begin

for i:=2 to trunc(sqrt(x)) do

if x mod i=0 then exit(false);

exit(true);

end;

6．素数的生成

maxnum=生成质数的范围

maxprime=对应范围中的质数个数

var

prime:array[0..maxprime]of longint;——存储质数

bool:array[1..maxnnum]of boolean;——存储每个数是不是质数

procedure prime_make;

var

i,j:longint;

begin

fillchar(bool,sizeof(bool),0);

i:=2;

while i<=maxnnum do

begin

if not p[i] then

begin

j:=2*i;

while i<=maxnnum do

begin

p[j]:=true;

inc(j,i);

end;

inc(prime[0]);prime[prime[0]]:=i;

end;

inc(i);

end;

end;

四、排列组合算法

1．排列生成算法——m的n排列

var

a:array[0..maxn]of longint;——排列方案

b:array[0..maxm]of boolean;——每个数是否被用过递归(recursion)：

procedure make_permutation_recursion(t:longint)

var

i:longint;

begin

if t=n+1 then

begin

write(a[1]);for i:=2 to n do write(‘ ‘,a*i+);writeln;

exit;

end;

for i:=1 to m do

if not b[i] then

begin

b[i]:=true;a[t]:=i;

make(t+1);

b[i]:=false;

end;

end;

非递归(iterative)：

procedure make_permutation_iterative(m,n:longint);

var

i,j:longint;

begin

i:=1;a[1]:=0;

repeat

j:=a[i]+1;

while (j<=m)and(b[j]) do inc(j);

if j<=m

then begin

a[i]:=j;b[j]:=true;

if i=n

then begin

write(a[1]);for j:=2 to n do write(‘ ‘,a*j+);writeln;

b[a[n]]:=false;

end

else begin

inc(i);a[i]:=0;

end;

end

else begin

dec(i);b[a[i]]:=false;

end;

until i=0;

end;

2．组合生成算法——m的n组合

procedure make_combination(t:longint)

var

i:longint;

begin

if t=n+1 then

begin

write(a*1+);for i:=2 to n do write(‘ ‘,a*i+);writeln;

exit;

end;

for i:=a[t-1] to m do

if not b[i] then

begin

b[i]:=true;a[t]:=i;

make(t+1);

b[i]:=false;

end;

end;

3．排列按序生成法

const

power:array*1..maxn+of longint=(…);power*i+为i的阶乘

type

permutationnode=array[1..maxn]of longint;——排列方案求n的全排的字典序：

function get_number(n:longint;a:permutationnode):longint;

var

b:array[1..maxn]of longint;

i,j,s:longint;

begin

for i:=1 to n do b[i]:=i-1;

s:=0;

for i:=1 to n-1 do

begin

inc(s,b[a[i]]*power[n-i]);

for j:=a[i]+1 to n do dec(b[j]);

end;

exit(s+1);

end;

求字典序为m的n的全排：

function get_permutation(m,n:longint;):permutationnode;

var

use:array[1..maxn]of boolean;

a:array[0..maxn]of longint;

temp:permutationnode;

begin

dec(m);

for i:=1 to n-1 do

begin

a[i]:=m mod (i+1);

m:=m div (i+1);

end;a[0]:=0;

for i:=1 to n do

begin

j:=0;

for k:=1 to a[n-i]+1 do

begin

inc(j);

while use[j] do inc(j);

end;

temp[i]:=j;use[j]:=true;

end;

exit(temp);

end;

4．排列字典序生成法——求n的某个全排的下m个字典序排列procedure make_next(n,m:longint;a:permutationnode):permutationnode;

var

i,j,k,t,temp:longint;

begin

for t:=1 to m do

begin

i:=n;

while (i>1)and(a[i]

j:=n;

while a[j]

temp:=a[i-1];a[i-1]:=a[j];a[j]:=temp;

for k:=i to (i+n)div 2 do

begin

temp:=a[k];a[k]:=a[n+i-k];a[n+i-k]:=temp;

end;

end;

exit(a);

end;

五、图论算法

1．图的读入

以点为基础读入（没有特殊说明，一般以此方法读入）：

var

vetex:array[1..maxn,0..maxn]of longint;——邻接表，记录与那些点相连

map:array[1..maxn,1..maxn]of longint;——邻接矩阵，记录点点之间的距离

procedure initgraph;

var

i,u,v,c:longint;

begin

readln(n,e);

for i:=1 to e do

begin

readln(u,v,c);

inc(vetex[u,0]);vetex[u,vetex[u,0]]:=v;

map[u,v]:=c;

end;

end；

以边为基础读入：

type

node=record

u,v,w:longint;——u为起点，v为终点，w为权

end;

var

vetex:array[1..maxe]of node;——记录边

procedure initgraph;

var

i:longint;

begin

readln(n,e);

for i:=1 to e do

with vetex[i] do readln(u,v,w);

end;

2．深度优先搜索——DFS

var

time:longint;——时间

flag:array[1..maxn]of boolean;——是否标记

procedure DFS(t:longint);

var

i:longint;

begin

inc(time);gettime[t]:=time;flag[t]:=true;

for i:=1 to vetex[t,0] do

if not flag[vetex[t,i]] then

begin

from[vetex[t,i]]:=t;dep[vetex[t,i]]:=dep[t]+1;

DFS(vetex[t,i]);

end;

inc(time);finishtime[t]:=time;

end;

3．广度优先搜索——BFS

procedure BFS(t:longint);

var

time,open,closed,i,v:longint;

flag:array[1..maxn]of boolean;

x0:array[1..maxn]of longint;

begin

fillchar(flag,sizeof(flag),0);

open:=0;closed:=1;x0[1]:=t;dep[t]:=0;

time:=1;flag[t]:=true;flagtime[t]:=1;

repeat

inc(open);v:=x0[open];

inc(time);finishtime[v]:=time;

for i:=1 to vetex[v,0] do

if not flag[vetex[v,i]] then

begin

inc(closed);x0[closed]:=vetex[v,i];

flag[vetex[v,i]]:=true;dep[vetex[v,i]]:=dep[v]+1;

inc(time);gettime[vetex[v,i]]:=time;

end;

until open>=closed;

end;

4．强连通分量

var

connected:array[1..maxn,0..maxn]of longint;——connect[i,0]为此分量包含的节点数

total:longint;——强连同分量的个数

procedure strongly_connected;

var

i,time:longint;

flag:array[1..maxn]of boolean;

sign:array[1..maxn]of longint;

procedure sort1(t:longint);

var

i:longint;

begin

flag[t]:=true;

for i:=1 to n do

if (map[t,i]<>0)and(not flag[i]) then

sort1(i);

inc(time);sign[time]:=t;

end;

procedure sort2(t:longint);

var

i:longint;

begin

flag[t]:=true;

for i:=1 to n do

if (not flag[i])and(map[i,t]<>0) then

sort2(i);

inc(connected[total,0]);connected[total,conneted[total,0]]:=t;

end;

begin

fillchar(flag,sizeof(flag),0);

for i:=1 to n do

if not flag[i] then

sort1(i);

for i:=n downto 1 do

if not flag[sign[i]] then

begin

inc(total);

sort(sign[i]);

end;

end;

5．拓扑排序

procedure topological_sort;

var

i,open,closed:longint;

flag:array[1..maxn]of boolean;

begin

open:=0;closed:=0;

for i:=1 to n do

if inv[i]=0 then

begin

inc(closed);

flag[i]:=true;AOV[closed]:=i;

end;

if closed=0 then exit{error};

repeat

inc(open);v:=AOV[open];

for i:=1 to vetex[v,0] do

if not flag[vetex[v,i]] then

begin

dec(inv[vetex[v,i]]);

if inv[vetex[v,i]]=0 then

begin

inc(closed);

AOV[closed]:=vetex[v,i];flag[vetex[v,i]]:=true;

end;

end;

until open=closed;

if closed

end;

6．最小生成树

Prime:

procedure prime_normal;

var

i,j,min,mj:longint;

flag:array[1..maxn]of boolean;

lowcost:array[1..maxn]of longint;

begin

fillchar(lowcost,sizeof(lowcost),$5F);

lowcost[1]:=0;flag[1]:=true;

for i:=1 to v[1,0] do

lowcost[v[1,i]]:=map[1,v[1,i]];

for i:=2 to n do

begin

min:=maxlongint;

for j:=1 to n do

if (not flag[j])and(lowcost[j]

begin

min:=lowcost[j];mj:=j;

end;

flag[mj]:=true;inc(totallen,min);

for j:=1 to v[mj,0] do

if (not flag[v[mj,j]])

and(lowcost[v[mj,j]]>map[mj,v[mj,j]]) then

lowcost[v[mj,j]]:=map[mj,v[mj,j]];

end;

end;

Kruskal——以边为基础读入:

procedure kruskal;

var

set1,set2,vetex_pointer,last_set_num:longint;

function find(x:longint):longint;

begin

if father[x]=x then find:=father[x]

else begin father[x]:=find(father[x]);find:=father[x];end;

end;

begin

qsort(1,e);——对vetex以w为关键字从小到大排序

for i:=1 to n do father[i]:=i;

vetex_pointer:=1;last_set_num:=n;

while (last_set_num>1)and(vetex_pointer<=e) do

begin

set1:=find(vetex[vetex_pointer].u);

set2:=find(vetex[vetex_pointer].v);

if set1<>set2 then

begin

inc(totallen,vetex[vetex_pointer].w);

dec(last_set_num);

father[set1]:=set2;

end;

inc(vetex_pointer);

end;

writeln(totallen);

end;

7．最短路径

Dijktra:

procedure Dijkstra(s:longint);

var

i,j,min,mi:longint;

begin

fillchar(shortest,sizeof(shortest),$5F);

shortest[s]:=0;

for i:=1 to n do

begin

min:=max;

for j:=1 to n do

if (not flag[j])and(shortest[j]

begin min:=shortest[j];mi:=j;end;

flag[mi]:=true;

for j:=1 to vetex[mi,0] do

if (not flag[vetex[mi,j]])

and(shortest[vetex[mi,j]]>min+map[mi,vetex[mi,j]]) then

shortest[vetex[mi,j]]:=min+map[mi,vetex[mi,j]];

end;

end;

Floyd:

procedure Floyd;

var

i,j,k:longint;

begin

fillchar(len,sizeof(len),$5F);

for i:=1 to n do

begin

len[i,i]:=0;

for j:=1 to vetex[i,0] do

len[i,vetex[i,j]]:=map[i,vetex[i,j]];

end;

for k:=1 to n do

for i:=1 to n do

for j:=1 to n do

if len[i,k]+len[k,j]

len[i,j]:=len[i,k]+len[k,j];

end;

Bellman-ford——以边为基础读入:

procedure Bellman-ford(s:longint);

var

i,j:longint;

bool:boolean;

begin

fillchar(shortest,sizeof(shortest),$5F);shortest[s]:=0;

bool:=true;

for i:=1 to n-1 do

if bool then

begin

bool:=false;

for j:=1 to e do

if shortest[vetex[j].v]>shortest[vetex[j].u]+vetex[j].w then

begin

shortest[vetex[j].v]:=shortest[vetex[j].u]+vetex[j].w;

bool:=true;

end;

end;

for j:=1 to e do

if shortest[vetex[j].v]>shortest[vetex[j].u]+vetex[j].w then

exit(flase);

exit(true);

end;

SPFA:

procedure SPFA(s:longint);

var

u,i:longint;

x0:array[1..maxn]of longint;

begin

fillchar(shortest,sizeof(shortest),$5f);

fillchar(flag,sizeof(flag),0);

open:=0;closed:=1;x0[1]:=s;shortest[s]:=0;flag[s]:=true;

repeat

inc(open);u:=x0[open];

for i:=1 to vetex[u,0] do

if shortest[vetex[u,i]]

begin

shortest[vetex[u,i]]:=shortest[u]+map[u,vetex[u,i]];

if not flag[vetex[u,i]] then

begin

inc(closed);

x0[closed]:=vetex[u,i];

flag[vetex[u,i]]:=true;

end;

end;

flag[u]:=false;

until open>=closed;

end;

六、背包问题

1．尽量把容量为w的箱子装满

var

f:array[0..maxw]of boolean;

weight:array[1..maxn]of longint;

function p1:longint;

var

i,j:longint;

begin

fillchar(f,sizeof(f),0);f[0]:=true;

for i:=1 to n do

for j:=w downto weight[i] do

f[j]:=f[j] or f[j-weight[j]];

i:=w;while not f[i] do dec(i);

exit(i);

end;

2．在容量为w的箱子中装入物品使总价值最高var

f:array[0..maxw]of longint;

weight,value:array[1..maxn]of longint;

function p2:longint;

var

Pascal基础知识

一、初识Pascal语言 一、Pascal 语言概述 Pascal 语言是一种算法语言，它是瑞士苏黎世联邦工业大学的Niklaus Wirth教授于1968年设计完成的，1971年正式发表。1975年对Pascal 语言进行了修改，作为“标准PASCAL语言”。 Pascal 语言是一种结构化的程序设计语言，可以用来编写应用程序。它又是一种系统程序设计语言，可以用来编写顺序型的系统软件（如编译程序）。它的功能强、编译程序简单。 二、Pascal 语言的特点 Pascal语言有以下几个主要的特点： ⒈它是结构化的语言。Pascal语言提供了直接实现三种基本结构的语句以及定义“过程”和“函数”的功能。可以方便地书写出结构化程序。在编写程序时可以完全不使用GOTO语句和标号。这就易于保证程序的正确性和易读性。Pascal语言强调的是可靠性、易于验证性、概念的清晰性和实现的简化。在结构化这一点上，比其它（如 BASIC,FORTRAN77）更好一些。 ⒉有丰富的数据类型。Pascal提供了整数、实型、字符型、布尔型、枚举型、子界型、数组类型、集合类型、记录类型、和文件类型和指针类型。⒊能适用于数值运算和非数值运算领域。PASCAL的功能较强，能广泛应用于各种领域。PASCAL语言还可以用于辅助设计，实现计算机绘图功能。 ⒋ PASCAL程序的书写格式比较自由。PASCAL允许一行写多个语句，一个语句可以分写在多行上，这样就可以使PASCAL程序写得格式优美，便于阅读。 三、Pascal语言程序的基本结构 程序设计语言都有着一组自己的记号和规则。PASCAL语言必须采用其本身所规定的记号和规则来编写程序。下面我们首先来了解Pascal语言的程序基本结构。 Pascal语言的程序结构为: 程序首部 标号说明语句 常量定义语句 类型定义语句程序的说明部分 变量说明语句 函数和过程说明语句分程序 程序体程序的执行部分 先看一个简单的PASCAL程序： program exam1(input,output); var r,s,c:real; begin readln(r); c:=3.14*2*r; s:=3.14*r*r; writeln(c,s) end.

pascal 过程与函数教程

第十二课过程与函数 前面我们曾经学习了程序设计中的三种基本控制结构（顺序、分支、循环）。用它们可以组成任何程序。但在应用中，还经常用到子程序结构。 通常，在程序设计中，我们会发现一些程序段在程序的不同地方反复出现，此时可以将这些程序段作为相对独立的整体，用一个标识符给它起一个名字，凡是程序中出现该程序段的地方，只要简单地写上其标识符即可。这样的程序段，我们称之为子程序。 子程序的使用不仅缩短了程序，节省了内存空间及减少了程序的编译时间，而且有利于结构化程序设计。因为一个复杂的问题总可将其分解成若干个子问题来解决，如果子问题依然很复杂，还可以将它继续分解，直到每个子问题都是一个具有独立任务的模块。这样编制的程序结构清晰，逻辑关系明确，无论是编写、阅读、调试还是修改，都会带来极大的好处。在一个程序中可以只有主程序而没有子程序(本章以前都是如此)，但不能没有主程序，也就是说不能单独执行子程序。pascal中子程序有两种形式：函数和过程。 一、函数 在此之前，我们曾经介绍并使用了pascal提供的各种标准函数，如ABS,SUCC等等，这些函数为我们编写程序提供了很大的方便。但这些函数只是常用的基本函数，编程时经常需要自定义一些函数。 （一）函数的说明 在pascal中，函数也遵循先说明后使用的规则，在程序中，函数的说明放在调用该函数的程序（主程序或其它子程序）的说明部分。函数的结构主程序的结构很相似。 函数定义的一般格式: function <函数名> (<形式参数表>):<类型>; {函数首部} 说明: ①函数由首部与函数体两部分组成。 ②函数首部以关键字function开头。 ③函数名是用户自定义的标识符。 ④函数的类型也就是函数值的类型，所求得的函数值通过函数名传回调用它的程序。可见，函数的作用一般是为了求得一个值。 ⑤形式参数简称形参，形参即函数的自变量。自变量的初值来源于函数调用。在函数中，形参一般格式如下： 变量名表1：类型标识符1；变量名表2：类型标识符2；…;变量名表n：类型标识符n 可见形参表相当于变量说明，对函数自变量进行说明，但应特别注意：此处只能使用类型标识符，而不能直接使用类型。 ⑥当缺省形参表（当然要同时省去一对括号）时，称为无参函数。 ⑦函数体与程序体基本相似，由说明部分和执行部分组成。 ⑧函数体中的说明部分用来对本函数使用的标号、常量、类型、变量、子程序加以说明，这些量只在本函数内有效。 ⑨函数体的执行部分由begin开头，end结束，中间有若干用分号隔开的语句，只是end后应跟分号,不能像程序那样用句号"."。 ⑩在函数体的执行部分，至少应该给函数名赋一次值，以使在函数执行结束后把函数值带回调用程序。 （二）函数的调用

pascal算法题

算法应用综合测试（二） （作答时间：3小时） 说明:1、作题前先在D盘新建一个文件夹，以自已的“学校+姓名”命名 2、各程序的源文件名、输入输出文件见题目 第一题杨辉三角（yh.pas） 【问题描述】 输出杨辉三角第n行。 【输入数据】 一个整数n，表示要输出杨辉三角的第n行。 【输出数据】 一行，杨辉三角的第n行，两个数之间用空格隔开。 【数据范围】 对于30%数据，0

某一天，tenshi看了一本趣味数学书，上面提到了亲和数：定义数对 (x,y) 为亲和数对当且仅仅当x、y为不同正整数，且x、y各自的所有非自身正因子之和等于另一个数。例如 (220,284) 和 (280,224) 都是亲和数对，因为： 220的所有非自身正因子之和为：1 + 2 + 4 + 5 + 10 + 11 + 20 + 22 + 44 + 55 + 110 = 284 284的所有非自身正因子之和为：1 + 2 + 4 + 71 + 142 = 220 数对 (x,y ) 跟 (y,x) 被认为是同一数对，所以我们只考虑 x

pascal 基本算法

基本算法模块 对于NOIP，基础是相当重要的，在3个小时之内做完4道题，那么就要求我们有相当快的速度。特别是对于一些简单的、常用的算法模块，一定要要熟练掌握并灵活运用。由于NOIP是一个比较基础的比赛，因此基本算法的掌握尤为重要，所以要求能够把这些基本的模块快速、准确的移植到不同的程序中，才能在稳中取胜。 基本算法模块中最重要的是基本程序框架，也就是说，要养成适合于自己的程序风格，这样对于程序编写的速度与程序的准确度都有较大的提高。

模块目录 一、排序 1．选择排序 2．插入排序 3．冒泡排序 4．快速排序 5．堆排序 6．归并排序 7．线性时间排序二、高精度 1．高精度比较 2．高精度加法 3．高精度减法 4．单精度乘法 5．高精度乘法 6．单精度除法 7．高精度除法 8．进制转换 三、数论 1．欧几里德算法 2．扩展欧几里德 3．求最小公倍数 4．求解线形同余方程 5．素数的判断 6．素数的生成 四、排列组合 1．排列生成算法 2．组合生成算法 3．排列按序生成法 4．排列字典序生成法五、图论 1．图的读入 2．深度优先搜索 3．广度优先搜索 4．强连同分量 5．拓扑排序 6．最小生成树 7．最短路径 六、背包问题 1．装满背包 2．一维价值最大背包 3．二位价值最大背包

一、排序算法 var a:array[1..maxn]of longint;——排序对象 1．选择排序——Select_sort procedure select_sort; begin for i:=1to n-1do for j:=i+1to n do if a[i]>a[j]then begin temp:=a[i];a[i]:=a[j];a[j]:=temp;end; end; 2．插入排序——Insert_sort procedure insert_sort; begin for i:=2to n do begin key:=a[i];j:=i-1; while(key0)do begin a[j+1]:=a[j];dec(j);end; a[j+1]:=key; end; end; 3．冒泡排序——Bubble_sort procedure bubble_sort; begin for i:=1to n-1do for j:=n downto i+1do if a[j]x do dec(j);{找右边比他小的} if i<=j then{交换} begin temp:=a[i];a[i]:=a[j];a[j]:=temp;

Tarjan算法 Pascal语言描述

Tarjan算法Pascal语言描述 Tarjan算法Pascal语言描述 TonyShaw 那天做了个2-sat题，里面牵扯到求有向图的强连通分量，我这么弱，显然不会，于是从网上找求有向图的强连通分量的方法，有一个是DFS两遍，同时建原图与补图，算法名字是B？？？忘掉了，反正当时同时看见了Tarjan算法。鉴于我对于Tarjan的略微崇拜，于是想先学一下Tarjan。写这篇文章的原因在于，我在网上没有找到Pascal语言描述的程序，同时一些关于这个算法的解释不是很清楚，所以我想写一下，算是我对该算法理解的总结，也算是为其他要学习该算法的人提供点无用的参照吧。 算法思想：从一个点开始，进行深度优先遍历，同时记录到达该点的时间（dfn记录到达i 点的时间），和该点能直接或间接到达的点中的最早的时间（low记录这个值，其中low的 初始值等于dfn）。（如图。假设我们从1开始DFS，那么到达1的时间为1，到达2的时间为2，到达3的时间为3。同时，点1能直接或间接到达的点中，最小时间为1，点2能通过3间接到达点1，所以点2可到达最早的点时间为1，点3可以直接到达点1，故点3到达的最早的点的时间为1。）。对于每一个没有被遍历到的点A，如果从当前点有一条到未遍历点A的有向边，则遍历到A，同时将点A入栈，时间戳+1并用dfn[a]记录到达点A的时间，枚举从A发出的每一条边，如果该边指向的点没有被访问过，那么继续dfs，回溯后low[a]:=min(low[a],low[j])(其中j为A可以到达的点。)如果该点已经访问过并且该点仍在栈里，那么low[a]=min(low[a],dfn[j])。 解释：若点j没有被访问过，那么回溯后low[j]就是j能到达最早点，a能到达的最早点当然就是a本身能到达的最早点，或者a通过j间接到达的最早点。若点j已经被访问过，那么low[j]必然没有被回溯所更新。所以low[a]就等于a目前能到达的最小点或a直接到达点j 时点j的访问时间。注意：两个句子中的“或”其实指的是两者的最小值。那么如果我们回溯

PASCAL语法解释

我是在高一接触pascal语言，因为参加NOI的需要，顺理成章的要使用Turbo Pascal来写程序了。半年后，我开始想着如何编写Windows程序，又理所当然的找上Delphi。初见Delphi，除了begin，end 让我觉得倍感亲切外，Object Pascal里的增加的面向对象的语法却让我很是吃惊，当时的我可根本不懂什么叫面向过程，面向对象；最可恶的是，国内那些教育家们，除了会拿着清华的那本精简的不能再精简的pascal教材照本宣科外，似乎再也没有什么实质性的工作了，传说中的《Turbo Pascal大全》更是无处可寻，所以关于unit，interface这些Delphi里随处可见的关键字我也很不明白。所幸，其后不久，我得到一本名为《计算机反病毒技术》的书，里面统统都是用Turbo Pascal编写的源代码，通过它我迅速明白了早已存在于Turbo Pascal中unit，interface等关键字的含义和用法，又以Delphi中的Help文档为扶手，开始蹒跚学步了。 印象中，国内Delphi作家似乎更偏爱编写应用实例类的技术书籍，至于语法这种东西，没有几个人愿意多去涉及，即使书中必须谈及，也是寥寥数笔，匆匆带过，或者干脆与某本书类似。对Object Pascal语法讲解最好，最权威的恐怕就算《Delphi5开发人员指南》了，这本书至今也是备受推崇的。但与如今泛滥的C++书籍相比，Delphi仍然逊色许多，也难怪很多新手特别是从来没有接触过pascal语言的新手，在学习Object Pascal时会遇到不少困难。自己的感觉是：在从Turbo Pascal向Delphi过渡的过程中，由于没有正确的指引，走了很多弯路；由于没有正确的桥梁，必须要一步实现大跨越。所以，在这里，我提出自己曾经遇见的沟壑，路标性给出我自己的认识和总结，希望给入门的同学们一些帮助。我不打算详细介绍语法知识，并假设你已经有一点pascal语言和面向对象概念的基础。要想学习相关详细知识，我推荐各位一定要阅读《Delphi开发人员指南》和Delphi Help文档中的相关章节。 ●记录体和类 习惯了在一个Program模块内写完所有面向过程代码的我，有几天的时间一直未能彻底明白在非Unit模块中，非继承的自定义类的框架，语法是如何的，VCL源代码虽然经典，却过于繁杂，不能让我迅速掌握根本，我需要一个最简单又最能说明问题，完整的可运行的代码，苦于无处寻求答案，只好亲自动手，探索对应关系，终成其下两段代码。 program TP;{本代码在Turbo Pascal7.0下编译通过} type MyRecord=record {...} end; var MR:MyRecord; procedure Procedure1; begin {Procedure1Code} end; {===========main===========} begin {以这个begin为标志，主程序开始，其作用相当于C/C++中的main函数} Procedure1; end.

数据结构经典算法试题

1．假设有两个按元素值递增次序排列的线性表，均以单链表形式存储。请编写算法将这两个单链表归并为一个按元素值递减次序排列的单链表，并要求利用原来两个单链表的结点存放归并后的单链表。【北京大学1998 三、1 （5分）】 LinkedList Union(LinkedList la,lb) { pa=la->next; pb=lb->next; la->next=null; while(pa!=null && pb!=null) ∥当两链表均不为空时作 if(pa->data<=pb->data) { r=pa->next; pa->next=la->next; ∥将pa结点链于结果表中，同时逆置。 la->next=pa; pa=r; } else {r=pb->next; pb->next=la->next; ∥将pb结点链于结果表中，同时逆置。 la->next=pb; pb=r; } while(pa!=null) ∥将la表的剩余部分链入结果表，并逆置。 {r=pa->next; pa->next=la->next; la->next=pa; pa=r; } while(pb!=null) {r=pb->next; pb->next=la->next; la->next=pb; pb=r; } }

1）设有两个无头结点的单链表,头指针分别为ha,hb,链中有数据域data,链域next,两链表的数据都按递增序存放,现要求将hb表归到ha表中,且归并后ha仍递增序,归并中ha表中已有的数据若hb中也有,则hb中的数据不归并到ha中,hb的链表在算法中不允许破坏。【南京理工大学1997 四、3（15分）】 LinkedList Union(LinkedList ha, hb) ∥ha和hb是两个无头结点的数据域值递增有序的单链表，本算法将hb中并不出现在ha中的数据合并到ha中，合并中不能破坏hb链表。｛LinkedList la; la=(LinkedList)malloc(sizeof(LNode)); la->next=ha; pa=ha; pb=hb; pre=la; while(pa&&pb) if(pa->datadata) ∥处理ha中数据 {pre->next=pa;pre=pa;pa=pa->next;} else if(pa->data>pb->data) ∥处理hb中数据。 {r=(LinkedList)malloc(sizeof(LNode)); r->data=pb->data; pre->next=r; pre=r; pb=pb->next; } Else ∥处理pa- >data=pb->data; { pre->next=pa; pre=pa; pa=pa->next; ∥两结点数据相等时，只将ha的数据链入。 pb=pb->next; } if(pa!=null)pre->next=pa; ∥将两链表中剩余部分链入结果链表。 else pre->next=pb; free(la); }

算法与程序设计经典例题

第一节选择题 选择题是一种各学科均使用的常见题型，它的结构由指令性语言、题干和选择支三个部分组成。 指令性语言：通常在大题号后面，本大题所有小题的前面，用括号括起来的部分；一般有三个方面的 内容：一是本大题包含的小题数目、每小题的分值和本大题的总分；二是指明每个小题中正确答案的数量； 三是每小题的计分方法。 题干：是指每一小题中叙述考查内容的不完整（加上某个选择支就能完整）的句子。 选择支：是题干后面的备选答案。 在信息技术会考试题中均采用“四选一”型的单项选择题，即一道选择题的四个选择支中，有且只有 一个正确选项。 选择题形式多样，结构灵活，可考查知识的覆盖面广，能比较全面地考察考生的基本知识和基本操作 技能，而且选择题答案具有确定性，阅卷方便，考试信度和效度高等特点，但选择题只在限定的备选项中 选出正确选项，其考核功能有一定的局限性，对考生的创新能力的培养有不同程度的影响。 选择题的解法很多，主要可以从直接法和间接法两方面着手。 一、直接法 直接法是指运用所学知识或根据操作经验，直接从题干出发，经过回忆、计算、比较，得出结论后与 备选答案进行对照，选出正确的选项。 【例1】以下主要用于制作网页的软件是 （A）Excel（B）Linux（C）FrontPage（D）PowerPoint （浙江省2006年会考试题）分析目前每一位考生所使用的网页制作软件不多，绝大部分都在使用（C）。 【例2】下列主要用来输入音频信息的设备是 （A）键盘（B）显示器（C）话筒（D）扫描仪 （A）销售盗版软件（B）下载免费软件（C）购买正版软件（D）发布共享软件 （浙江省2002年会考试题）分析本题可以根据计算机使用道德及计算机软件保护条例等知识直接得到答案：（A）。 【例6】有如下Visual Basic程序段： If x>0 Then y=2 End If 它的控制结构属于 （A）循环结构（B）树型结构（C）分支结构（D）顺序结构 （浙江省2004年会考试题）分析作为信息技术基础的内容，要求能看懂程序的基本控制结构及简单程序的阅读理解，如果在简 单程序中有If … then …语句，则此种控制结构一定是分支结构。本题答案为（C）。 【例7】下列说法中正确的是 （A）图像通常有位图和点阵图两种表示形式 （B）用Windows系统中的“画图”程序画出来的图形就是矢量图 （C）矢量图经过移动、缩放、旋转和扭曲等变换后清晰度不会发生变化 （D）图像文件中只记录生成图的算法和图上的某些特征点，数据量较小 分析本题可以根据图像与图形、位图与矢量图等基本概念直接得到答案（C） 【例8】一位同学用数码相机拍了一些照片，他想对这些照片上的人物和背景进行重新组合，以获得 最佳效果，你可以建议他采用的软件是 （A）Flash（B）Photoshop（C）画图程序（D）Powerpoint

pascal.时间复杂度的计算

时间复杂度的计算 当我们评价一个算法的时间性能时，主要标准就是算法的渐近时间复杂度，因此，在算法分析时，往往对两者不予区分，经常是将渐近时间复杂度T(n)=O(f(n))简称为时间复杂度，其中的f(n)一般是算法中频度最大的语句频度。此外，算法中语句的频度不仅与问题规模有关，还与输入实例中各元素的取值相关。但是我们总是考虑在最坏的情况下的时间复杂度。以保证算法的运行时间不会比它更长。 常见算法时间复杂度： O(1):表示算法的运行时间为常量 O(n):表示该算法是线性算法 O(㏒2n):二分查找算法 O(n2):对数组进行排序的各种简单算法，例如直接插入排序的算法。 O(n3):做两个n阶矩阵的乘法运算 O(2n):求具有n个元素集合的所有子集的算法 O(n!):求具有N个元素的全排列的算法 优<---------------------------<劣 O(1)

pascal考试应试技巧

LongLongLive ChairmanMao NOIP 应试 技巧手册 大部分内容转载自 OIBH

最重要的是细节 1.文件输入输出 2.Close before HALT 3.注释！ 4.变量赋初值，全局变量也不例外。 5.DP初始值、边界情况 6.-0<>0 7.坐标~~~又是坐标~~~。横纵，行列， 8.人工inline。 9.记忆化没记忆等于TLE。 10.fillchar要做好 11.While/for之后的begin end 12.10^8有9位，不是8位。 13.Int64不能用Read,也不能直接赋给一个大于Longint的值。 14.非等差循环用while不用for. 15.凡是分母为变量的除法、Div、Mod都需要想一想是否要判0 16.删除屏幕输出！ 17.不要总把logn忽略掉。 18.有时候要有意采用ln,exp变*为+ 19.Gcd,Mod,Div的使用都应该注意正负。 20.实数运算永远记住用Zero! 21.聚焦边界！ 22.非明文禁止者，皆不无可能。 23.算数要准确，比如bignum的范围 24.文件名切记要使用小写！

关于算法与策略 1.看审题画在卷子上的线 2.超时的搜索/DP往往能比错误的贪心得到更多的分。 3.专用的方法胜于通用的方法。 4.好题往往不能直接经典算法 5.n,n^2n很小时差不多 6.如果一个数学问题很复杂，那么看结果找规律有可能比数学推导快。 7.即使是多项式算法，有时也可以加入很有效的剪枝。 8.矩阵的统计问题，降维策略，在外层用土方法，内层使用优化过的方法。 9.用O(N*N)枚举出Y1,Y2,然后考察之间夹的矩形是非常常用的方法。 10.涉及01串的问题，都不要忘记位运算和压缩，同时也要小心。 11.对于判重问题，关注最小表示。 12.对于想不出算法的题目，先有序化！ 13.子序列之和的问题Sb-Sa 14.对于一边明显长于另外一边的矩形问题 15.没有回溯的搜索是最成功的搜索 16.最大规模的数据非常难设计，就不要管他 17.尽量让不做已做过的事和显然没有必要的事 18.不要解决无用的子问题和对结果进行无意义的引用 19.一般情况下，根据数据规模猜算法是非常有效的 20.Qsort算法要注意应该先存储选为基点的那个数以后再比较 21.关注最内层的循环到底在干什么 22.在只涉及乘除的高精度运算中，按因数存储 23.DFS之后森林不是树，重边？ 24.优化的是针对大多数情况，不是特殊情况 25.即使是自己建的图中也有可能出现重边 26.“不超前”属性的引入可以使复杂度降低一个数量级。 27.DP的Downto应用 28.变量的取值范围与计算公式同等重要。 29.博弈问题从残局或结局出发 30.涉及单词的问题，对每个单词记录起止点，这样就充分利用了空间。 31.邻接矩阵+邻接链表 32.不如笨拙的枚举各种情况，只是注意在Copy&Paste的时候不要出错。 33.考虑坐标的定义是基于最小区间的还是基于点的。 34.双向搜索，就两边分别写过程 35.很多时候，输入的两个数据并没有说明两者的大小关系！ 36.枚举的时候不要忘记想一想是用To还是Downto更好。 37.编写DFS之前一定要先考虑最坏的情况下栈空间是否够用。 38.A mod8=A and7 39.反复调用子程序。

常用算法

常用算法 一. 基本概念： 1. 算法：就是解决问题方法的精确描述。并不是所有问题都有算法，有些问题经研究可行，则相应有算法；而有些问题不能说明可行，则表示没有相应算法。 算法具有以下性质：是一有穷动作的序列； 动作序列仅有一个初始动作； 序列中每个动作的后继动作是确定的； 序列的终止表示问题得到解答或问题没有解答 2. 算法的分类：数值的和非数值的 数值的算法是以数学方式表示的问题求数值解的方法，如：代数方程 计算、矩阵计算、线性方程组求解、函数方程求解等； 非数值的算法是求非数值解的方法，如排序查找、模式匹配、排列模 拟、表格处理、文字处理等。 3. 算法设计：主要是针对各类具体问题设计良好的算法及研究设计算 法的规律和方法。 4. 常用的算法设计方法： 数值算法：迭代法、递归法、插值法等； 非数值算法：分治法、贪婪法、回溯法等。 5. 算法分析：是对设计出的每一个具体的算法，利用数学工具，讨论 各种复杂度。算法的复杂度分时间复杂度和空间复杂度。 二. 常用数值计算算法 1. 迭代法（i teration ） 迭代法适用于方程(或方程组)求解，是使用间接方法求方程近似根的一种常用算法。(参见清华版《PASCAL 程序设计P89练习4.23》 设方程f(x)=0，该方法将方程表示为等价形式：x=g(x)，或一般地将f(x)拆成两个函数f 1、f 2，即f(x)= f 1(x)-f 2(x) =0，因而有f 1(x)=f 2(x)。其中f 1(x)是这样一个函数，对于任意数c ，容易求出f 1(x)=c 的精确度很高的实根。迭代法求解算法如下： (1). 首先选一个x 的近似根x 0，从x 0出发，代入右面函数，并解 方程f 1(x)=f 2(x 0)得到下一个近似根x 1; (2). 将上次近似根x 1代入右面函数，并解方程f 1(x)=f 2(x 1)，得到 又一个近似根x 2 (3). 重复(2)的计算，得到一系列近似根x 0,x 1,x 2,…,x i ,x i+1,…,x n ,…； 若方程有根，这数列收敛于方程的根，若满足ε 1--n n x x ，则认为x n 是方程的近似根。

pascal语言基本知识

信息学奥赛讲义 前言关于信息学奥赛 一、什么是信息学奥赛： 信息学奥赛是形式：参赛学生在规定的3个小时内，完成4个与数学（涵盖小学奥数、中学数学、大学数学）有关的问题的计算机程序设计。阅卷采取计算机自动限时测试（黑箱测试法），通常限时为1秒，超时不得分。每道题测试10个（组）不同数据，通常是由简道难，每个测试点10分，共400分，根据得分多少确定得奖等次。 IOI：国际奥林匹克信息学竞赛 1989年在保加利亚的布拉维茨开始首届举行的一年一度的中学生竞赛，每个国家可以由4人组成国家队参加比赛，共有100多个国家参赛，至今已举办了21届。中国从第一届开始参赛。 作为五项国际奥林匹克学科竞赛之一，信息学奥林匹克竞赛是由联合国教科文组织于1988年发起创建、由来自世界各地20岁以下的中学生参加的计算机科学领域的一项赛事，目的是在青少年中普及计算机科学，为来自世界各地的年轻人提供一个交流机会，并通过比赛和访问学习主办国优秀的文化，加深对主办国的了解。竞赛每年在不同国家举办。中国累计获金牌30块、银牌17块，铜牌12块，安徽省累计获得金牌2块、银牌4块，铜牌5块. NOI：全国信息学奥林匹克竞赛 由中国计算机学会主办的一项面向全国青少年的信息学竞赛，也是与联合国教科文组织提倡的国际信息学奥林匹克竞赛同步进行的一项竞赛活动。1984年开始首届比赛，每个省选拔5名（2000年前4名）学生组成省队参加比赛，最终选拔出5名学生参加IOI竞赛。 安徽省从首届开始参加比赛，至今已9次获得团体第一，且各次均名列前5名。 AHOI：安徽省信息学奥林匹克竞赛 安徽省组队参加NOI的选拔赛，铜陵市从首届开始参赛，上实际90年代曾多次获得团体总分第一，至今仍保持前5名。 NOIP：全国信息学奥林匹克联赛 由中国计算机学会主办的一项面向全国青少年的普及性信息学竞赛，参加人数较多、设奖面较大。目前，NOIP分为普及组和提高组两个级别。 提高组：主要面向高中学生，是目前高中阶段五大联赛之一。设奖面大，2008年为例：安徽省设一等奖近50名。一等奖获得者将取得高考保送生资格。初中学生也可以报名参加。 普及组：主要面对初中学生，是安徽目前初中阶段唯一奥赛。按照铜陵市中考政策，获得普及组二等奖及以上者，中考获10分加分，同时可免试进入一中理科实验班。 铜陵市从2005年起参加该项比赛活动。已先后数十人次获得提高组一等奖，已毕业学生均已保送进入名牌大学（中国科大、复旦大学、上海交大等），今年高三学生目前已有8人获得NOIP一等奖取得保送生资格。 二、信息学奥赛学什么： 1、计算机语言： 由计算机指令组成的命令集。可控制计算机自动完成某一完整的工作。目前信息学竞赛可以使用的语言有Pascal、C、C++，本期将进行Pascal语言教学。 2、数据结构： 将数学对象和事物对象表达成计算机可以接受的形式，并根据特点把它们有机地组合在一起，勾连数据之间的关系，以便高速高效地加以处理。