C语言的程序阅读题和程序天空题

1   8  10  16

#include<stdioh>

void main()

{

   int i=010,//0开头表示8进制 

   j=10,k=0x10;//0x表示16进制 

   printf("%d %d %d\n",i,j,k);

}

2  输入两个整数，输出两数之差

四

#include <stdioh>

void main()

{   

     int x,a,b,c;    

     printf("输入一个100-999之间的正整数：");                     

  scanf("%d",&x);    

  printf("\n");    

  a=x/100;    

  b=(x-a100)/10;    

  c=x%10                     ;       

  printf("%d的个位数是%d，十位数是%d，百位数是%d\n",x,c,b,a);

}

1、类型属性 *** 作符(TYPE)是返回该变量所占字节数，或标号的“远”(FAR)、“近”(NEAR)类型。常用标识符的类型值如下：

标识符种类---TYPE值

字节变量----：1

字变量------：2

双字变量----：4

近标号(NEAR):-1

远标号(FAR)--:-2

2、长度属性 *** 作符(LENGTH)是针对内存变量的 *** 作符，它返回重复 *** 作符DUP中的重复数。如果有嵌套的DUP，则只返回最外层的重复数；如果没有 *** 作符DUP，则返回1。

3、容量属性 *** 作符(SIZE)也是针对内存变量的 *** 作符。它的返回值按下列公式计算：

SIZE 变量 ＝ (LENGTH 变量) × (TYPE 变量)

MOV AX, TYPE TABLE1 ;(AX)=1

MOV BX, TYPE TABLE2 ;(BX)=2

MOV CX, LENGTH TABLE2 ;(CX)=20

MOV DX, SIZE TABLE2 ;(DX)=40

MOV SI, LENGTH TABLE3 ;(SI)=1

MOV DI, LENGTH TABLE2 ;(DI)=20

MOV AX, LENGTH TABLE4 ;(AX)=10

MOV BX, LENGTH TABLE5 ;(BX)=1

#include <stdioh>

main()

{

int i,a1,a2;

for(i=1000;i<10000;i++)

{ if(i%1000/100)

continue;

a1=i%100;

a2=i/1000;

if((a1+a2100)9==i)

printf("%d\t",i);

}

}

结果

1．一个C源程序中至少应包括一个___主函数_____。

2． 若a是int型，且a的初值为6，则计算表达式a+=a-=aa后，a的值为___-60_____。

3．若有定义：intb=7；float a=25，c=47；则表达a+(int)(b/3(int)(a+c)/2)%4的值为__45______。

4．若a为整型变量，则表达式（a=45，a2），a+6的值为___26______。

5．以下程序执行后，如果从键盘上输入1289，则输出结果为___9821________。

main()

{

int n1,n2;

scanf(“%d”,&n2);

while(n2!=0)

{

n1=n2%10;

n2=n2/10;

printf(“%d”,n1);

}

}

6．在调用C语言的库函数对字符串进行 *** 作时，应包含的头文件是____stringh__________。

真想要？要有耐心看下去的。。。。

自己挑些题做吧。

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[110] 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;由OIFanscn收集

③ ;

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)互换后，在每个新的排列中可能有重复数字，因而不能作为新个体的编码，一般再做两步处理：

(21) 将两个互换段中，共同的数字标记为 0，表示已处理完。

(22) 将两个互换段中其余数字标记为 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[120] 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);由OIFanscn收集

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 [110000] 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[0100, 0100] 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[07] of integer = (1, 0, -1, 0, 0, 1, ① );

var

orig, n, i, j, ns: integer;

a: array[0101, 0101] 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 := 2m+1; t := 2; i := 1; flag := False;

repeat

if (t = 1) then

begin

solve := (2) ; flag := True;

end

else if ( (3) ) then

begin

solve := im-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[01,038,019] of integer;

pic: array[049,049] of char;

procedure init;

var k,s,a,b,c: integer;

begin

for a:=0 to 1 do

for b:=0 to 2L do

for c:=0 to L do

m[a,b,c]:=0; m[0,0,0]:=1;

for k:=0 to 2L-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,2i,0])>=0) do

begin

nth:= nth-m[0,2i,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 2520+1530+3032=1910

40 0 30 4020+155+3032=1835

70 0 0 7020+455+3010=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[030] 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[1k,1n] 记录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[020] of 01 ;

a : array[120,110] 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[1100，12 ]表示，(如下表一中(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[0100，12]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[1N，1N]OF INTEGER； 表示活动的延续时间，若无连线，则用-1表示；

EET[1N] 表示活动最早可以开始的时间

ET[1N] 表示活动最迟应该开始的时间

关键路径通过点J，具有如下的性质：EET[J]=ET[J]

2约定：

结点的排列已经过拓扑排序，即序号前面的结点会影响序号后面结点的活

以上就是关于C语言的程序阅读题和程序天空题全部的内容，包括:C语言的程序阅读题和程序天空题、汇编程序填空题、C语言程序填空题 各位帮看看等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！