给一些程序填空题,PASCAL的

pascal的程序填空（希望有讲解）~

一、预备知识
首先我们要先看清楚，题目的分数类型是“假分数”中的“带分数”，带分数的例子：、。



附带分数的加减法方法（摘自百度百科）：异分母分数相加减，
先通分，即运用分数的基本性质将异分母分数转化为同分母分数，改变其分数单位而大小不变，
再按同分母分数相加减法去计算，最后要约分。

然后，我们来手动模拟一下分数运算，
+ =( 整数1+4) + ( 分子 5*9+7*7 )/ ( 分母 7*9 )= (整数 5) + ( 分子 94) / ( 分母 63)
= (整数 5 + 94 div 63 ) + ( 分子 94 mod 63) / ( 分母 63) = (整数 6) + ( 分子 31) / ( 分母 63)。
这个例子刚好两个分数相加后分子分母没有最大公约数，如果相加后分子分母有最大公约数，还要再约分一下

然后来看看这个程序吧。

二、
没有题号看得有点费劲哦。function gcd...1、if r=0 then break//有点多此一举的语句，但感觉只能填这个了{下面是oier经常用的gcd代码形式的伪代码，不知道会不会给你点启示}func gcd(a,b) if a mod b=0 then exit(b) else exit(gcd(b, a mod b))function lcm...2、*b div gcd(a,b)//a和b的最小公倍数当然等于 a*b/a和b的最大公约数主程序{下面几个空请自己模拟一下上面“预备知识”中例子就可以理解。3和4是进行分数中分子通分的处理5 还有它下面的那行语句 是 把假分数化为真分数（分子比分母小的分数）}3、(l div u)4、(l div c[i])5、l
三、声明
上面的所有内容除了注明了的之外都是本人（天蝎的猪）亲手打出来的，鉴于各种原因，不排除会有非智力的错误出现，欢迎指正~

请问 w=y2k 是y^2 * k 还是 y* 2^k 或是 2*y*k

真想要？要有耐心看下去的。。。。
自己挑些题做吧。
2006：
1．（选排列）下面程序的功能是利用递归方法生成从 1 到 n(n<10)的 n 个数中取 k(1<=k<=n)个数的 全部可能的排列（不一定按升序输出）。例如，当 n=3，k=2 时，应该输出（每行输出 5 个排列）：

12 13 21 23 32

31
程序：
Program ex501; Var i,n,k:integer;
a:array[1..10] of integer;

count:longint;

Procedure perm2(j:integer);

var i,p,t:integer;

begin

if ① then

begin

for i:=k to n do begin inc(count);
t:=a[k]; a[k]:=a[i]; a[i]:=t;

for ② do write(a[p]:1);

write(' ');

t:=a[k];a[k]:=a[i];a[i]:=t;

if (count mod 5=0) then writeln;

end; exit; end;
for i:=j to n do begin
t:=a[j];a[j]:=a[i];a[i]:=t;由OIFans.cn收集

③ ;

t:=a[j]; ④ ;

end end; begin
writeln('Entry n,k (k<=n):'); read(n,k);

count:=0;

for i:=1 to n do a[i]:=i;
⑤ ;

end.

2．（TSP 问题的交叉算子）TSP 问题(Traveling Salesman Problem)描述如下：给定 n 个城 市，构成一个完全图，任何两城市之间都有一个代价（例如路程、旅费等），现要构造遍历所有城市的环 路，每个城市恰好经过一次，求使总代价达到最小的一条环路。

遗传算法是求解该问题的一个很有效的近似算法。在该算法中，一个个体为一条环路，其编码方法 之一是 1 到 n 这 n 个数字的一个排列，每个数字为一个城市的编号。例如当 n=5 时，“3 4 2 1 5” 表示该方案实施的路线为 3->4->2->1->5->3。遗传算法的核心是通过两个个体的交叉操作，产生两 个新的个体。下面的程序给出了最简单的一种交叉算法。具体过程如下：
(1)选定中间一段作为互换段，该段的起止下标为 t1，t2，随机生成 t1，t2 后，互换两段。
(2)互换后，在每个新的排列中可能有重复数字，因而不能作为新个体的编码，一般再做两步处理：
(2.1) 将两个互换段中，共同的数字标记为 0，表示已处理完。
(2.2) 将两个互换段中其余数字标记为 1，按顺序将互换段外重复的数字进行替换。 例如：n=12，两个个体分别是：

a1: 1 3 5 4 * 2 6 7 9 * 10 12 8 11

a2: 3 2 1 12 * 6 7 10 11 * 8 5 4 9
t1=5，t2=8。上述每一行中，两个星号间的部分为互换段。假定数组的下标从 1 开始，互换后有：

a1: 1 3 5 4 * 6 7 10 11 * 10 12 8 11

a2: 3 2 1 12 * 2 6 7 9 * 8 5 4 9
然后，将数字 6,7 对应的项标记为 0，星号内数字 2,9,10,11 对应的项标记为 1，并且按顺序对 应关系为:10<->2，11<->9。于是，将 a1[9]=10 替换为 a1[9]=2，将 a2[2]=2 替换为 a2[2]=10， 类似再做第 2 组替换。这样处理后，就得到了两个新个体：

a1: 1 3 5 4 6 7 10 11 2 12 8 9

a2: 3 10 1 12 2 6 7 9 8 5 4 11
（3）输出两个新个体的编码。 程序：

program ex502;

type arr1=array[1..20] of integer;

var a1,a2,kz1,kz2:arr1; n,k,t1,t2:integer;
function rand1(k:integer):integer;

var t:integer;

begin t:=0;
while (t<2) or(t>k) do t:=random(k+1)-2; rand1:=t;
end;

procedure read1(var a:arr1;m:integer);
{读入数组元素 a[1]至 a[m]，a[0]=0，略。}

procedure wrt1(var a:arr1;m:integer);
{输出数组元素 a[1]至 a[m]，略。}
procedure cross(var a1,a2:arr1;t1, t2,n:integer);由OIFans.cn收集

var i,j,t,kj:integer; begin
for i:=t1 to t2 do begin
t:=a1[i]; ① ;

end;

for i:=1 to n do

if (i<t1)or(i>t2) then begin
kz1[i]:=-1;kz2[i]:=-1;

end else
begin ② ; end;

for i:=t1 to t2 do for j:=t1 to t2 do
if(a1[i]=a2[j]) then
begin ③ ; break; end;

for i:=t1 to t2 do if(kz1[i]=1) then begin
for j:=t1 to t2 do if(kz2[j]=1) then
begin kj:=j; break; end;

for j:=1 to n do if ④ then

begin a1[j]:=a2[kj];break; end;

for j:=1 to n do if ⑤ then

begin a2[j]:=a1[i]; break; end;

kz1[i]:=0;kz2[kj]:=0;

end; end; begin
writeln('input (n>5):');

readln(n);

writeln('input array 1:'); read1(a1,n);
writeln('input array 2:'); read1(a2,n);

t1:=rand1(n-1);

repeat

t2:=rand1(n-1); until(t1<>t2); if(t1>t2) then
begin k:=t1; t1:=t2; t2:=k; end;

⑥ ;

wrt1(a1,n); wrt1(a2,n);

end.

2005：
1．木材加工
题目描述:
木材厂有一些原木，现在想把这些木头切割成一些长度相同的小段木头（木头有可能有
剩余），需要得到的小段的数目是给定的。当然，我们希望得到的小段越长越好，你的任务
是计算能够得到的小段木头的最大长度。
木头长度的单位是cm。原木的长度都是正整数，我们要求切割得到的小段木头的长度
也是正整数。
输入:
第一行是两个正整数N和K(1 ≤ N ≤ 10000，1 ≤ K ≤ 10000)，N是原木的数目，
K是需要得到的小段的数目。
接下来的N行，每行有一个1到10000之间的正整数，表示一根原木的长度。
输出:
输出能够切割得到的小段的最大长度。如果连1cm长的小段都切不出来，输出”0”。
输入样例:
3 7
232
124
456
输出样例:
114
程序：
var
n, k : integer;
len : array [1..10000] of integer;
i, left, right, mid : integer;
function isok(t : integer) : boolean;
var
num, i : integer;
begin
num := 0;
for i := 1 to n do begin
if num >= k then break;
num := ① ;
end;
if ② then isok := true
else isok := false;
end;
begin
readln(n, k);
right := 0;
for i := 1 to n do begin
readln(len[i]);
if right < len[i] then right := len[i];
end;
inc(right);
③ ;
while ④ < right do begin
mid := (left + right) div 2;
if ⑤ then right := mid
else left := mid;
end;
writeln(left);
end.
2．N叉树
题目描述:
我们都了解二叉树的先根遍历，中根遍历和后根遍历。当知道先根遍历的结果和中根遍
历结果的时候，我们可以唯一的确定二叉树；同样的，如果知道了后根遍历的结果和中根遍
历结果，二叉树也是唯一确定的。但是如果只知道先根遍历和后根遍历的结果，二叉树就不
是唯一的了。但是我们可以计算满足条件的不同二叉树一共有多少个。这不是一个很困难的
问题，稍微复杂一点，我们把这个问题推广到N叉树。
我们用小写英文字母来表示N 叉树的结点，不同的结点用不同的字母表示。比如，对
于4叉树，如果先根遍历的结果是abdefgc，后根遍历的结果是defgbca，那么我们可以
得到6个不同的4叉树（如下图）。
输入:
输入数据包括3行。
第一行是一个正整数N(2 ≤ N ≤ 20)，表示我们要考虑N叉树。
第二行和第三行分别是两个字符串序列，分别表示先根遍历和后根遍历的结果。
输出:
输出不同的N叉树的数目。题目中给的数据保证得到的结果小于2
31
。
输入样例:
4
abdefgc
defgbca
输出样例:
6
程序：
var
str1, str2 : string;
N, len : integer;
com : array[0..100, 0..100] of longint;
function getcom(x, y : integer) : longint;
begin
if (y = 0) or (x = y) then ①
else if com[x][y] <> 0 then getcom := com[x][y]
else begin
com[x][y] := getcom(x - 1, y)+ ② ;
getcom := com[x][y];
end;
end;
function count(a, b, c : integer) : longint;
var
sum : longint;
k, s, t, p : integer;
begin
sum := 1; k := 0; s := a + 1; t := c;
if a = b then count := 1
else begin
while s <= b do begin
p := t;
while str1[s] <> str2[t] do inc(t);
sum := sum * count(s, s + t - p, p);
s := ③ ;
④ ; inc(k);
end;
count := ⑤ * getcom(N, k);
end;
end;
begin
readln(N); readln(str1); readln(str2);
len := length(str1);
writeln(count( ⑥ ));
end.

2004：
1．Joseph
题目描述:
原始的Joseph问题的描述如下：有n个人围坐在一个圆桌周围，把这n个人依次编号为1，…，n。从编号是1的人开始报数，数到第m个人出列，然后从出列的下一个人重新开始报数，数到第m个人又出列，…，如此反复直到所有的人全部出列为止。比如当n=6，m=5的时候，出列的顺序依次是5，4，6，2，3，1。
现在的问题是：假设有k个好人和k个坏人。好人的编号的1到k，坏人的编号是k+1到2k。我们希望求出m的最小值，使得最先出列的k个人都是坏人。
输入:
仅有的一个数字是k（0 < k <14）。
输出:
使得最先出列的k个人都是坏人的m的最小值。
输入样例:
4
输出样例:
30
程序：
program program1;
var
i, k, m, start: longint;
find: boolean;
function check(remain: integer): boolean;
var result: integer;
begin
result:=( ① ) mod remain;
if( ② )then begin
start := result; check := true;
end
else check := false;
end;
begin
find := false;
read(k);
m := k;
while ( ③ ) do begin
find := true; start := 0;
for i := 0 to k-1 do
if( not check( ④ )) then begin
find := false; break;
end;
inc(m);
end;
writeln( ⑤ );
end.

2．逻辑游戏
题目描述:
一个同学给了我一个逻辑游戏。他给了我图1，在这个图上，每一段边界都已经进行了编号。我的任务是在图中画一条连续的曲线，使得这条曲线穿过每一个边界一次且仅穿过一次，而且曲线的起点和终点都在这整个区域的外面。这条曲线是容许自交的。
对于图1，我的同学告诉我画出这样的一条曲线（图2）是不可能的，但是对于有的图形（比如图3），画出这样一条曲线是可行的。对于给定的一个图，我想知道是否可以画出满足要求的曲线。

图1 图2

图3 图4
输入:
输入的图形用一个n×n的矩阵表示的。矩阵的每一个单元里有一个0到255之间（包括0和255）的整数。处于同一个区域的单元里的数相同，相邻区域的数不同（但是不相邻的区域里的数可能相同）。
输入的第一行是n（0<n<100）。以下的n行每行包括n个整数，分别给出对应的单元里的整数（这n个整数之间用空格分开）。图4给出了输入样例对应的图形。
输出:
当可以画出满足题意的曲线的时候，输出“YES”；否则，输出“NO”。
输入样例:
3
1 1 2
1 2 2
1 1 2
输出样例:
YES
程序：
program program2;
const
d: array[0..7] of integer = (1, 0, -1, 0, 0, 1, ① );
var
orig, n, i, j, ns: integer;
a: array[0..101, 0..101] of integer;
bun: boolean;
procedure plimba(x, y: integer);
var i, x1, y1: integer;
begin
a[x, y] := -a[x, y];
if (abs(a[x - 1, y]) <> orig) and (( ② <> a[x - 1, y])
or (abs(a[x, y - 1]) <> orig)) then inc(ns);
if (abs(a[x + 1, y]) <> orig) and ((a[x + 1, y - 1] <> a[x + 1,y])
or (abs(a[x, y - 1]) <> orig)) then inc(ns);
if (abs(a[x, y - 1]) <> orig) and (( ③ <> a[x, y - 1])
or (abs(a[x - 1, y]) <> orig)) then inc(ns);
if (abs(a[x, y + 1]) <> orig) and ((a[x - 1, y + 1] <> a[x,y + 1])
or (abs(a[x - 1, y]) <> orig)) then inc(ns);
for i := 0 to 3 do begin
x1 := x + d[2 * i];y1:=y+ ④ ;
if (x1 >= 1) and (x1 <= n) and (y1 >= 1) and (y1 <= n) and
( ⑤ ) then plimba(x1, y1);
end;
end;
begin
bun := true;
read(n);
for i := 0 to n+1 do
for j := 0 to n+1 do a[i, j] := 0;
a[0, 0] := -1; a[n + 1, 0] := -1;
a[0, n + 1] := -1; a[n + 1, n + 1] := -1;
for i := 1 to n do
for j := 1 to n do read(a[i, j]);
for i := 1 to n do
for j := 1 to n do
if a[i, j] > -1 then begin
ns := 0; ⑥ ;
plimba(i, j);
if ns mod 2 = 1 then bun := false;
end;
if bun then writeln('YES');
if not bun then writeln('NO');
end.

2003：

1. 翻硬币
题目描述：
一摞硬币共有m枚，每一枚都是正面朝上。取下最上面的一枚硬币，将它翻面后放回原处。然后取下最上面的2枚硬币，将他们一起翻面后放回原处。在取3枚，取4枚……直至m枚。然后在从这摞硬币最上面的一枚开始，重复刚才的做法。这样一直做下去，直到这摞硬币中每一枚又是正面朝上为止。例如，m为1时，翻两次即可。
输 入：仅有的一个数字是这摞硬币的枚数m ，0< m <1000。
输 出：为了使这摞硬币中的每一枚都是朝正面朝上所必须翻的次数。
输入样例：30
输出样例：899
程 序：
program Program1;
var m:integer;
function solve(m: integer):integer;
var i,t,d: integer;
flag: Boolean;
begin
if (m = 1) then
solve := (1)
else begin
d := 2*m+1; t := 2; i := 1; flag := False;
repeat
if (t = 1) then
begin
solve := (2) ; flag := True;
end
else if ( (3) ) then
begin
solve := i*m-1; flag := True;
end
else
t := (4) ;
i:=i+1;
until flag;
end
end;
begin
read(m); if (( (5) ) and (m<1000)) then
writeln( (6) );
end.
2. OIM地形
题目描述：
二维离散世界有一种地形叫OIM(OI Mountain)。这种山的坡度只能上升('/')或下降('\'),而且两边的山脚都与地平线等高,山上所有地方都不低于地平线.例如：
/\ /\
/ \/\ 是一座OIM；而 / \ 不是。
\/
这个世界的地理学家们为了方便纪录，给OIM所有可能的形状用正整数编好号，而且每个正整数恰好对应一种山形。他们规定，若两座山的宽度不同，则较宽的编号较大；若宽度相同，则比较从左边开始第1个坡度不同的地方，坡度上升的编号较大。以下三座OIM的编号有小到大递增：
/\ /\ /\ /\
/ \/\ / \/\/\ / \/ \。显然/\的编号为1。但是地理学家在整理纪录是发觉，查找编号与山形的对应关系不是很方便。他们希望能快速地从编号得到山的形状。你自告奋勇答应他们写一个程序，输入编号，能马上输出山形。
输 入：一个编号（编号大小不超过600,000,000），
输 出：输入编号所对应的山形，1座山所占行数恰为它的高度，即山顶上不能有多余空行。
输入样例：15
输出样例： /\ /\
/ \/ \
程 序：
program Program2;
const
L:integer =19; SZ: integer =50;
UP: char = '/'; DN: char = '\';
Var
i,nth,x,y,h,e,f:integer;
m: array[0..1,0..38,0..19] of integer;
pic: array[0..49,0..49] of char;

procedure init;
var k,s,a,b,c: integer;
begin
for a:=0 to 1 do
for b:=0 to 2*L do
for c:=0 to L do
m[a,b,c]:=0; m[0,0,0]:=1;
for k:=0 to 2*L-1 do
begin
for s:=1 to L do
begin
m[0,k+1,s] := m[0,k,s+1] + m[1,k,s+1];
m[1,k+1,s]:= (1) ;
end;
m[0,k+1,0] :=m[0,k,1]+m[1,k,1];
end;
end;

procedure draw(k,s,nth:integer);
begin
if (k=0) then exit;
if ((nth-m[1,k,s])>=0) then
begin
nth:=nth-m[1,k,s];
if (y>h) then (2) ;
pic[y,x]:=UP; y:=y+1; x:=x+1; draw( (3) );
end
else begin
y:=y - 1; pic[y,x]:=DN; x:=x+1; draw(k-1,s-1,nth);
end;
end;

begin
init;
read(nth);
for e:=0 to SZ-1 do
for f:=0 to SZ-1 do
pic[e,f]:= ' ';
x:=0;
y:=0
h:=0;
i:=0;

while ((nth-m[0,2*i,0])>=0) do
begin
nth:= nth-m[0,2*i,0];
(4) ;
end;
draw( (5) );
for i:=h downto x-1 do
begin
for e:=0 to x-1 do
write(pic[i,e]);
writeln(' ');
end;
end.

2002：
1． 问题描述：工厂在每天的生产中，需要一定数量的零件，同时也可以知道每天生产一个零件的生产单价。在N天的生产中，当天生产的零件可以满足当天的需要，若当天用不完，可以放到下一天去使用，但要收取每个零件的保管费，不同的天收取的费用也不相同。
问题求解：求得一个N天的生产计划（即N天中每天应生产零件个数），使总的费用最少。
输入：N（天数 N<=29）
每天的需求量（N个整数）
每天生产零件的单价（N个整数）
每天保管零件的单价（N个整数）
输出：每天的生产零件个数（N个整数）
例如：当N=3时，其需要量与费用如下：
第一天 第二天 第三天
需 要 量 25 15 30
生产单价 20 30 32
保管单价 5 10 0
生产计划的安排可以有许多方案，如下面的三种：
第一天 第二天 第三天 总的费用
25 15 30 25*20+15*30+30*32=1910
40 0 30 40*20+15*5+30*32=1835
70 0 0 70*20+45*5+30*10=1925
程序说明：
b[n]：存放每天的需求量
c[n]：每天生产零件的单价
d[n]：每天保管零件的单价
e[n]：生产计划
程序：
program exp5;
var
i,j,n,yu,j0,j1,s : integer ;
b,c,d,e : array[0..30] of integer ;
begin
readln(n);
for i:=1 to n do readln(b[i],c[i],d[i]);
for i:=1 to n do e[i]:=0;
①__________:=10000; c[n+2]=0; b[n+1]:=0 j0:=1;
while (j0<=n) do
begin
yu:=c[j0]; j1:=j0; s:=b[j0];
while ②__________ do
begin
③__________ j1:=j1+1; s:=s+b[j1];
end;
④__________ j0:=j1+1;
end;
for i:=1 to n do ⑤__________
readln;
end.
二．问题描述：有n种基本物质（n≤10），分别记为P1，P2，……，Pn，用n种基本物质构造物质，这些物品使用在k个不同地区（k≤20），每个地区对物品提出自己的要求，这些要求用一个n位的数表示：a1a2……a n，其中：
ai = 1表示所需物质中必须有第i种基本物质
= -1表示所需物质中必须不能有第i种基本物质
= 0无所谓
问题求解：当k个不同要求给出之后，给出一种方案，指出哪些物质被使用，哪些物质不被使用。
程序说明：数组 b[1],b[2]……b[n] 表示某种物质
a[1..k,1..n] 记录k个地区对物品的要求，其中：
a[i,j]=1 表示第i个地区对第j种物品是需要的
a[i,j]=0 表示第i个地区对第j种物品是无所谓的
a[i,j]= -1 表示第i个地区对第j种物品是不需要的
程序：
program gxp2;
var
i,j,k,n : integer ;
p : boolean ;
b : array[0..20] of 0..1 ;
a : array[1..20,1..10] of integer ;
begin
readln(n,k);
for i:=1 to k do
begin
for j:=1 to n do read(a[i,j]);
readln;
end;
for i:=0 to n do b[i]:=0;
p:=true;
while ①__________ do
begin
j:=n;
while b[j]=1 do j:=j-1;
②__________
for i:=j+1 to n do b[i]:=0;
③__________
for i:=1 to k do
for j:=1 to n do
if (a[i,j]=1) and (b[j]=0) or ④__________
then p:=true;
end;
if ⑤__________
then writeln(‘找不到！’)
else for i:=1 to n do
if (b[i]=1) then writeln(‘物质’,i,’需要’)
else writeln(‘物质’,i,’不需要’);
end.

2001：
1.存储空间的回收算法。设在内存中已经存放了若干个作业A，B，C，D。其余的空间为可用的(如图一中(a))。

此时，可用空间可用一个二维数组dk[1..100，1..2 ]表示，(如下表一中(a))，其中：dk[i，1]对应第i个可用空间首址，dk[i，2]对应第i个可用空间长度如上图中，dk：

100 50
300 100
50 100
0 0
100 50
300 100
500 100
10000 0

表一(a) 表一(b)
现某个作业释放一个区域，其首址为d，长度为L，此时将释放区域加入到可用空间表中。要求在加入时，若可用空间相邻时，则必须进行合并。因此出现下面的4种情况(如上图一(b)所示)。
(1)下靠，即回收区域和下面可用空间相邻，例如，d=80，L=20，此时成为表二中的(a)。
(2)上靠，例如，d=600，L=50，此时表成为表二中的(b)。
(3)上、下靠，例如，d=150，L=150，此时表成为表二中的(c)。
(4)上、下不靠，例如，d=430，L=20，此时表成为表二中的(d)。

80 70
300 100
50 100
100 50
300 100
500 150

100
300

500
100
100 50
300 100
430 20
500 100

表二(a)(下靠) 表二(b)(上靠) 表二(c)(上，下靠) 表二(d)(上，下不靠)
程序说明：对数组dk预置2个标志，即头和尾标志，成为表二中(b)，这样可使算法简单，sp为dk表末地址。
程序清单：
PROGRAM GAO7_5；
VAR I，J，SP，D，L：INTEGER；
DK ：ARRAY[0..100，1..2]OF INTEGER；
BEGIN
READLN(SP)；
FOR I:=1 TO SP DO
READLN(DK[I，1]，DK[I，2])；
DK[0，1]:=0；DK[0，2]:=0； ① ；
DK[SP，1]:=10000；DK[SP，2]:=0；READLN(D，L)；I:=1；
WHILE DK[I，1]<D DO I:=I+1； ② ；
IF(DK[I，1]+DK[I，2]=D)THEN
IF(D+L=DK[I+1，1])THEN
BEGIN
DK[I，2]:= ③ ；
FOR J:=I+1 TO SP-1 DO
DK[J]:=DK[J+1]；
SP：=SP-1；
END
ELSE DK[I，2]:=DK[I，2]+L
ELSE IF(D+L=DK[I+1，1])THEN
BEGIN
DK[I+1，1]::= ④ ；DK[I+1，2]:=DK[I+1，2]+L
END
ELSE BEGIN
FOR J:=SP DOWNTO I+1 DO DK[J+1]:=DK[J]；
⑤ :=D； DK[I+1，2]:=L；SP:=SP+1；
END；
FOR I:=1 TO SP-1 DO WRITELN(DK[I，1]:4，DK[I，2]:4)；READLN；
END.

2.求关键路径
设有一个工程网络如下图表示(无环路的有向图)：
其中，顶点表示活动，①表示工程开始，⑤表示工程结束(可变，用N表示)，边上的数字表示活动延续的时间。

如上图中，活动①开始5天后活动②才能开始工作，而活动③则要等①、②完成之后才能开始，即最早也要7天后才能工作。
在工程网络中，延续时间最长的路径称为关键路径。上图中的关键路径为：①—②—③—④—⑤共18天完成。
关键路径的算法如下：
1.数据结构：
R[1..N，1..N]OF INTEGER； 表示活动的延续时间，若无连线，则用-1表示；
EET[1..N] 表示活动最早可以开始的时间
ET[1..N] 表示活动最迟应该开始的时间
关键路径通过点J，具有如下的性质：EET[J]=ET[J]
2.约定：
结点的排列已经过拓扑排序，即序号前面的结点会影响序号后面结点的活

【问题描述】
设有n种物品，每种物品有一个重量及一个价值。但每种物品的数量是无限的，同时有一个背包，最大载重量为XK，今从n种物品中选取若干件（同一种物品可以多次选取），使其重量的和小于等于XK，而价值的和为最大。
【程序清单】
Program package;
const maxxk=400;maxn=20;
type tlist=array[1…maxn] of byte;
tmake=array[0…maxn,0…maxxk] of integer;
var n,xk:integer;
w,u:tlist;
f:tmake;
procedure init;
var i:byte;
begin
fillchar(w,sizeof(w),0);
fillchar(u,sizeof(u),0);
readln(n,xk);
for i:=1 to n do
① ;
end;
procedure make;
var i,j:byte;
begin
for i:=1 to n do
begin
for j:=1 to w[i]-1 do
f[i,j]:=f[i-1,j];
for j:=w[i] to xk do
if f[i-1,j]>f[i,j-w[i]]+u[i] then ② ;
else ③ ;
end;
end;
procedure print;
var get:tlist;
i,j:byte;
begin
fillchar(get,sizeof(get),0);
i:= ④ ;j:= ⑤ ;
while i>0 do
if f[i,j]=f[i-1,j] then dec(i)
else begin
dec(j,w[i]);
⑥ ;
end;
writeln(‘n=’,n, ‘,’, ‘xk=’,xk);
writeln(‘max worth=’, ⑦ ;
for i:=1 to n do
writeln(‘no.’,i‘, weight:’,w[i]:2, ‘worth:’,u[i]:2, ‘get’,get[i]:2);
end;
begin
init;
make;
print;
end.

第2题（7分）
【问题描述】
给定一个01串，请你找出长度介于a,b之间，重复出现次数最多的01串。
输入：a,b(0<a<=b<=12)
由0，1组合的数列，由‘.’结尾。
输出：要求的串。
提示：本程序中将01序列转换为2进制数存取。
【程序清单】
program shuchuan;
var i,j,s,k,a,b,max:integer;
m:array[1…8192] of integer;
two,v:array[1…20] of integer;
c:char;
begin
for i:=1 to 13 do
① ;
readln(a,b);
read(c);
s:=1;k:=1;
while c<>‘.’do begin
s:=s shl 1+ord(c)-48;
if ② then
s:=((s-two[b+1]) mod two[b])+two[b];
inc(m[s]);
if k<b then
for i:=a to k-1 do
③ ;
inc(k);
read(c);
end;
for i:=two[b] to two[b+1] do
if m[i]>0 then
for j:=a to b-1 do
m[(i mod two[j])+two[j]]:= ④ ;
max:=0;
for i:=two[a] to two[b+1] do
if m[i]>max then ⑤ ;
for i:=two[a] to two[b+1] do
if m[i]=max then begin
j:=0;k:=I;
repeat
inc(j);v[j]:=k mod 2; ⑥ ;
until ⑦ ;
while j>0 do begin write(v[j]);dec(j) end;
writeln;
end;
end.

www.oifans.cn 上面有历届的题！

没问题啊告诉你e85d、xyz晓得的

---

雨城区18075031541： pascal语言程序填空题？
慕榕复方：new(head); head.next:=p; ? ? inc(t)2. he:=a+b; writeln(he);

雨城区18075031541： pascal程序填空 - ？
慕榕复方： 4. p[i]:=1;5.(p[j]>0) and (d[p[j],j] 6. k:=j;7.(p[j]>0) and (d[p[j],j]>d[k,j]) 源程序:const maxn=100; type tcity=record x,y:real end; var c:array[1..maxn] of tcity; d:array[1..maxn,1..maxn] of real; p:array[1..maxn] of integer; n,i,j,k:integer; a,min:real; begin ...

雨城区18075031541： 趣味填空(Pascal) - ？
慕榕复方： 不知道有多组解时你的题意该怎么输出,反正我的题解是加号从前往后输出的.program cyj; var n,i,j,k,t,sum:longint; s,s1:string; f:boolean; procedure print(t:longint); var i:longint; begin for i:=1 to t-1 do write(s1[i]); write('+'); for i:=t to length(s1) do ...

雨城区18075031541： PASCAL的一道题目,请写出程序!？
慕榕复方： var s:string; i:integer; begin readln( s ); for i:=length( s ) downto 1 do write( s[i] ); readln; end.

雨城区18075031541： 求一些pascal的题目？
慕榕复方： 1.输入矩阵a(m行n列0和矩阵b(n行h列),计算并求出c=a*b

雨城区18075031541： 几道简单的Pascal编程题 - ？
慕榕复方： 1.var a,b:integer; begin readln(a,b); writeln(a+b); end;2.var s:real; begins:=(8+12)*9/2; writeln(s:2:2) end.3.var a:integer; ge,bai,shi:integer; beginreadln(a); ge:=a mod 100; bai:=a div 100; shi:=a-ge-bai*100; weiteln(ge,bai,shi); end.4.var a:array[1.....

雨城区18075031541： 怎么做pascal程序填空？
慕榕复方： 首先要读懂程序,明白程序的意图,要完成什么功能.读程序时不要把程序断开,要把整道题的程序看一遍,联系前后语句,从而完成程序填空.

雨城区18075031541： pascal程序填空？
慕榕复方： 定义一个二维数组 a[1..4444,1..4444]of integer; 题目楼主看懂了吗?? 第一行 1+1=2,2+2=4,4+3=7,7+4=11,由于11>10 取个位数 第二行 第一个数字3=1+2 第三行 第一个 6=3+3 .......懂了吧 下面是代码,编译通过,正确输出,或许还需改进 ...

雨城区18075031541： 求下面题目的pascal程序？
慕榕复方： 第n次卖出了全部金鱼的1/n加n分之一条金鱼,每次卖的都是整数,也就是说全部金鱼的一半不是整数,需要加上0.5条金鱼才是一个整数 算法推导,另An表示n次卖出以后剩下的金鱼数 那么An-1 应该是 (An + 1/n) *n,也就是n*An + 1,这样的话就简单了,循环就搞定了 count := 11; for n := 5 downto 1 do begincount := count * n + 1; end;

雨城区18075031541： pascal程序题:对给定的10个国家名,按其字母的顺序输出. - ？
慕榕复方： 1)k:=i2)k:=j 就是每次循环找到第i个到第10个中最小的,把它与第i个交换就行了