Tải bản đầy đủ - 0 (trang)
§3. MỘT SỐ BÀI TOÁN QUY HOẠCH ĐỘNG

§3. MỘT SỐ BÀI TOÁN QUY HOẠCH ĐỘNG

Tải bản đầy đủ - 0trang

154



Chuyên đề



chỉ số j trong khoảng từ i + 1 đến n + 1 mà a[j] > a[i], chọn ra chỉ số jmax có L[jmax] lớn

nhất. Đặt L[i] := L[jmax] + 1:

L [i ] = max L [ j] + 1

i < j≤ n −1

a [i ]< a [ j]



3.1.3. Truy vết

Tại bước xây dựng dãy L, mỗi khi gán L[i] := L[jmax] + 1, ta đặt T[i] = jmax. Để lưu lại rằng:

Dãy con dài nhất bắt đầu tại a[i] sẽ có phần tử thứ hai kế tiếp là a[jmax].

Sau khi tính xong hay dãy L và T, ta bắt đầu từ T[0].

T[0] chính là phần tử đầu tiên được chọn,

T[T[0]] là phần tử thứ hai được chọn,

T[T[T[0]]] là phần tử thứ ba được chọn …

Quá trình truy vết có thể diễn tả như sau:

i := T[0];

while i <> n + 1 do {Chừng nào chưa duyệt đến số a[n+1]=+∞ ở cuối}

begin



i := T[i];

end;



Ví dụ: với A = (5, 2, 3, 4, 9, 10, 5, 6, 7, 8). Hai dãy L và T sau khi tính sẽ là:

Calculating



i

0

ai − ∞

L[i] 9



1

5

5



2

2

8



3

3

7



4

4

6



5

9

3



6

10

2



7

5

5



8

6

4



9

7

3



10

8

2



T[i]



8



3



4



7



6



11



8



9



10



11



2



11

+∞

1



Tracing



Hình 50: Tính tốn và truy vết

P_3_03_1.PAS * Tìm dãy con đơn điệu tăng dài nhất

{$MODE DELPHI} (*This program uses 32-bit Integer [-231..231 - 1]*)

program LongestSubSequence;

const

InputFile = 'INCSEQ.INP';

OutputFile = 'INCSEQ.OUT';

max = 1000000;

var

a, L, T: array[0..max + 1] of Integer;

n: Integer;

procedure Enter;

var

i: Integer;

f: Text;

begin

Assign(f, InputFile); Reset(f);

ReadLn(f, n);

ĐHSPHN 1999-2004



Quy hoạch động



155



for i := 1 to n do Read(f, a[i]);

Close(f);

end;

procedure Optimize; {Quy hoạch động}

var

i, j, jmax: Integer;

begin

a[0] := Low(Integer); a[n + 1] := High(Integer); {Thêm hai phần tử canh hai đầu dãy a}

L[n + 1] := 1; {Điền cơ sở quy hoach động vào bảng phương án}

for i := n downto 0 do {Tính bảng phương án}

begin

{Chọn trong các chỉ số j đứng sau i thoả mãn a[j] > a[i] ra chỉ số jmax có L[jmax] lớn nhất}

jmax := n + 1;

for j := i + 1 to n + 1 do

if (a[j] > a[i]) and (L[j] > L[jmax]) then jmax := j;

L[i] := L[jmax] + 1; {Lưu độ dài dãy con tăng dài nhất bắt đầu tại a[i]}

T[i] := jmax; {Lưu vết: phần tử đứng liền sau a[i] trong dãy con tăng dài nhất đó là a[jmax]}

end;

end;

procedure Result;

var

f: Text;

i: Integer;

begin

Assign(f, OutputFile); Rewrite(f);

WriteLn(f, L[0] - 2); {Chiều dài dãy con tăng dài nhất}

i := T[0]; {Bắt đầu truy vết tìm nghiệm}

while i <> n + 1 do

begin

WriteLn(f, 'a[', i, '] = ', a[i]);

i := T[i];

end;

Close(f);

end;

begin

Enter;

Optimize;

Result;

end.



Nhận xét:

Nhắc lại công thức truy hồi tính các L[.] là:

⎧L [ n + 1] = 0



⎨L [i ] = max L [ j] + 1; (∀i=0,n)

i < j≤ n +1



a [i ]< a [ j]





và để tính hết các L[.], ta phải mất một đoạn chương trình với độ phức tạp tính tốn là O(n2).

Ta có thể cải tiến cách cài đặt để được một đoạn chương trình với độ phức tạp tính tốn là

O(nlogn) bằng kỹ thuật sau:

Với mỗi số k, ta gọi StartOf[k] là chỉ số x của phần tử a[x] thoả mãn: dãy đơn điệu tăng dài

nhất bắt đầu từ a[x] có độ dài k. Nếu có nhiều phần tử a[.] cùng thoả mãn điều kiện này thì ta

chọn phần tử a[x] là phần tử lớn nhất trong số những phần tử đó. Việc tính các giá trị StartOf[.]

được thực hiện đồng thời với việc tính các giá trị L[.] bằng phương pháp sau:

Lê Minh Hoàng



156



Chuyên đề



L[n + 1] := 1;

StartOf[1] := n + 1;

m := 1; {m là độ dài dãy con đơn điệu tăng dài nhất của dãy a[i..n+1] (ở bước khởi tạo này i = n + 1)}

for i := n downto 0 do

begin

〈Tính L[i]; đặt k := L[i]〉;

if k > m then {Nếu dãy con tăng dài nhất bắt đầu tại a[i] có độ dài > m}

begin

m := k; {Cập nhật lại m}

StartOf[k] := i; {Gán giá trị cho StartOf[m]}

end

else

if a[i] > a[StartOf[k]] then {Nếu có nhiều dãy đơn điệu tăng dài nhất độ dài k thì}

StartOf[k] := i; {chỉ ghi nhận lại dãy có phần tử bắt đầu lớn nhất}

end;



3.1.4. Cải tiến

Khi bắt đầu vào một lần lặp với một giá trị i, ta đã biết được:

m: Độ dài dãy con đơn điệu tăng dài nhất của dãy a[i+1..n+1]

StartOf[k] (1 ≤ k ≤ m): Phần tử a[StartOf[k]] là phần tử lớn nhất trong số các phần tử trong

đoạn a[i+1..n+1] thoả mãn: Dãy con đơn điệu tăng dài nhất bắt đầu từ a[StartOf[k]] có độ

dài k. Do thứ tự tính tốn được áp đặt như trong sơ đồ trên, ta dễ dàng nhận thấy rằng:

a[StartOf[k]] < a[StartOf[k - 1]] <…
Điều kiện để có dãy con đơn điệu tăng độ dài p+1 bắt đầu tại a[i] chính là a[StartOf[p]] > a[i]

(vì theo thứ tự tính tốn thì khi bắt đầu một lần lặp với giá trị i, a[StartOf[p]] luôn đứng sau

a[i]). Mặt khác nếu đem a[i] ghép vào đầu dãy con đơn điệu tăng dài nhất bắt đầu tại

a[StartOf[p]] mà thu được dãy tăng thì đem a[i] ghép vào đầu dãy con đơn điệu tăng dài nhất

bắt đầu tại a[StartOf[p - 1]] ta cũng thu được dãy tăng. Vậy để tính L[i], ta có thể tìm số p lớn

nhất thoả mãn a[StartOf[p]] > a[i] bằng thuật tốn tìm kiếm nhị phân rồi đặt L[i] := p + 1

(và sau đó T[i] := StartOf[p], tất nhiên)

P_3_03_2.PAS * Cải tiến thuật tốn tìm dãy con đơn điệu tăng dài nhất

{$MODE DELPHI} (*This program uses 32-bit Integer [-231..231 - 1]*)

program LongestSubSequence;

const

InputFile = 'INCSEQ.INP';

OutputFile = 'INCSEQ.OUT';

const

max = 1000000;

var

a, L, T, StartOf: array[0..max + 1] of Integer;

n, m: Integer;

procedure Enter;

var

i: Integer;

f: Text;

begin

Assign(f, InputFile); Reset(f);

ReadLn(f, n);

for i := 1 to n do Read(f, a[i]);

Close(f);

end;

procedure Init;

ĐHSPHN 1999-2004



Quy hoạch động



157



begin

a[0] := Low(Integer);

a[n + 1] := High(Integer);

m := 1;

L[n + 1] := 1;

StartOf[1] := n + 1;

end;

{Hàm Find, tìm vị trí j mà nếu đem ai ghép vào đầu dãy con đơn điệu tăng dài nhất bắt đầu từ aj sẽ được dãy đơn

điệu tăng dài nhất bắt đầu tại ai}

function Find(i: Integer): Integer;

var

inf, sup, median, j: Integer;

begin

inf := 1; sup := m + 1;

repeat {Thuật toán tìm kiếm nhị phân}

median := (inf + sup) div 2;

j := StartOf[median];

if a[j] > a[i] then inf := median {Luôn để aStartOf[inf] > ai ≥ aStartOf[sup]}

else sup := median;

until inf + 1 = sup;

Find := StartOf[inf];

end;

procedure Optimize;

var

i, j, k: Integer;

begin

for i := n downto 0 do

begin

j := Find(i);

k := L[j] + 1;

if k > m then

begin

m := k;

StartOf[k] := i;

end

else

if a[StartOf[k]] < a[i] then

StartOf[k] := i;

L[i] := k;

T[i] := j;

end;

end;

procedure Result;

var

f: Text;

i: Integer;

begin

Assign(f, OutputFile); Rewrite(f);

WriteLn(f, m - 2);

i := T[0];

while i <> n + 1 do

begin

WriteLn(f, 'a[', i, '] = ', a[i]);

i := T[i];

end;

Close(f);

end;

begin

Enter;

Lê Minh Hồng



158



Chun đề



Init;

Optimize;

Result;

end.



Dễ thấy chi phí thời gian thực hiện giải thuật này cấp O(nlogn), đây là một ví dụ điển hình

cho thấy rằng một cơng thức truy hồi có thể có nhiều phương pháp tính.



3.2. BÀI TỐN CÁI TÚI

Trong siêu thị có n gói hàng (n ≤ 100), gói hàng thứ i có trọng lượng là W[i] ≤ 100 và trị giá

V[i] ≤ 100. Một tên trộm đột nhập vào siêu thị, tên trộm mang theo một cái túi có thể mang

được tối đa trọng lượng M ( M ≤ 100). Hỏi tên trộm sẽ lấy đi những gói hàng nào để được

tổng giá trị lớn nhất.

Input: file văn bản BAG.INP

Dòng 1: Chứa hai số n, M cách nhau ít nhất một dấu cách

n dòng tiếp theo, dòng thứ i chứa hai số nguyên dương W[i], V[i] cách nhau ít nhất một

dấu cách

Output: file văn bản BAG.OUT

Dòng 1: Ghi giá trị lớn nhất tên trộm có thể lấy

Dòng 2: Ghi chỉ số những gói bị lấy

BAG.INP

5 11

33

44

54

9 10

44



BAG.OUT

11

521



Cách giải:

Nếu gọi F[i, j] là giá trị lớn nhất có thể có bằng cách chọn trong các gói {1, 2, …, i} với giới

hạn trọng lượng j. Thì giá trị lớn nhất khi được chọn trong số n gói với giới hạn trọng lượng

M chính là F[n, M].



3.2.1. Cơng thức truy hồi tính F[i, j].

Với giới hạn trọng lượng j, việc chọn tối ưu trong số các gói {1, 2, …, i - 1, i} để có giá trị lớn

nhất sẽ có hai khả năng:

Nếu khơng chọn gói thứ i thì F[i, j] là giá trị lớn nhất có thể bằng cách chọn trong số các

gói {1, 2, …, i - 1} với giới hạn trọng lượng là j. Tức là

F[i, j] = F[i - 1, j]

Nếu có chọn gói thứ i (tất nhiên chỉ xét tới trường hợp này khi mà W[i] ≤ j) thì F[i, j] bằng

giá trị gói thứ i là V[i] cộng với giá trị lớn nhất có thể có được bằng cách chọn trong số các

gói {1, 2, …, i - 1} với giới hạn trọng lượng j - W[i]. Tức là về mặt giá trị thu được:

F[i, j] = V[i] + F[i - 1, j - W[i]]



ĐHSPHN 1999-2004



Quy hoạch động



159



Vì theo cách xây dựng F[i, j] là giá trị lớn nhất có thể, nên F[i, j] sẽ là max trong 2 giá trị thu

được ở trên.



3.2.2. Cơ sở quy hoạch động:

Dễ thấy F[0, j] = giá trị lớn nhất có thể bằng cách chọn trong số 0 gói = 0.



3.2.3. Tính bảng phương án:

Bảng phương án F gồm n + 1 dòng, M + 1 cột, trước tiên được điền cơ sở quy hoạch động:

Dòng 0 gồm tồn số 0. Sử dụng cơng thức truy hồi, dùng dòng 0 tính dòng 1, dùng dòng 1

tính dòng 2, v.v… đến khi tính hết dòng n.



F

0

1

2

...

n



0

0



1

0



2

0



......

...0...



M

0



...



...



...



...



...



3.2.4. Truy vết:

Tính xong bảng phương án thì ta quan tâm đến F[n, M] đó chính là giá trị lớn nhất thu được

khi chọn trong cả n gói với giới hạn trọng lượng M. Nếu F[n, M] = F[n - 1, M] thì tức là

khơng chọn gói thứ n, ta truy tiếp F[n - 1, M]. Còn nếu F[n, M] ≠ F[n - 1, M] thì ta thơng báo

rằng phép chọn tối ưu có chọn gói thứ n và truy tiếp F[n - 1, M - W[n]]. Cứ tiếp tục cho tới

khi truy lên tới hàng 0 của bảng phương án.

P_3_03_3.PAS * Bài toán cái túi

{$MODE DELPHI} (*This program uses 32-bit Integer [-231..231 - 1]*)

program The_Bag;

const

InputFile = 'BAG.INP';

OutputFile = 'BAG.OUT';

max = 100;

var

W, V: Array[1..max] of Integer;

F: array[0..max, 0..max] of Integer;

n, M: Integer;

procedure Enter;

var

i: Integer;

fi: Text;

begin

Assign(fi, InputFile); Reset(fi);

ReadLn(fi, n, M);

for i := 1 to n do ReadLn(fi, W[i], V[i]);

Close(fi);

end;

procedure Optimize; {Tính bảng phương án bằng cơng thức truy hồi}

var

i, j: Integer;

begin

Lê Minh Hoàng



160



Chuyên đề



FillChar(F[0], SizeOf(F[0]), 0); {Điền cơ sở quy hoạch động}

for i := 1 to n do

for j := 0 to M do

begin {Tính F[i, j]}

F[i, j] := F[i - 1, j]; {Giả sử khơng chọn gói thứ i thì F[i, j] = F[i - 1, j]}

{Sau đó đánh giá: nếu chọn gói thứ i sẽ được lợi hơn thì đặt lại F[i, j]}

if (j >= W[i]) and (F[i, j] < F[i - 1, j - W[i]] + V[i]) then

F[i, j] := F[i - 1, j - W[i]] + V[i];

end;

end;

procedure Trace; {Truy vết tìm nghiệm tối ưu}

var

fo: Text;

begin

Assign(fo, OutputFile); Rewrite(fo);

WriteLn(fo, F[n, M]); {In ra giá trị lớn nhất có thể kiếm được}

while n <> 0 do {Truy vết trên bảng phương án từ hàng n lên hàng 0}

begin

if F[n, M] <> F[n - 1, M] then {Nếu có chọn gói thứ n}

begin

Write(fo, n, ' ');

M := M - W[n]; {Đã chọn gói thứ n rồi thì chỉ có thể mang thêm được trọng lượng M - W[n] nữa thôi}

end;

Dec(n);

end;

Close(fo);

end;

begin

Enter;

Optimize;

Trace;

end.



3.3. BIẾN ĐỔI XÂU

Cho xâu ký tự X, xét 3 phép biến đổi:

a) Insert(i, C): i là số, C là ký tự: Phép Insert chèn ký tự C vào sau vị trí i của xâu X.

b) Replace(i, C): i là số, C là ký tự: Phép Replace thay ký tự tại vị trí i của xâu X bởi ký tự C.

c) Delete(i): i là số, Phép Delete xoá ký tự tại vị trí i của xâu X.

Yêu cầu: Cho trước xâu Y, hãy tìm một số ít nhất các phép biến đổi trên để biến xâu X thành

xâu Y.

Input: file văn bản STR.INP

Dòng 1: Chứa xâu X (độ dài ≤ 100)

Dòng 2: Chứa xâu Y (độ dài ≤ 100)

Output: file văn bản STR.OUT ghi các phép biến đổi cần thực hiện và xâu X tại mỗi phép

biến đổi.



ĐHSPHN 1999-2004



Quy hoạch động



161

STR.INP

PBBCEFATZ

QABCDABEFA



STR.OUT

7

PBBCEFATZ -> Delete(9) -> PBBCEFAT

PBBCEFAT -> Delete(8) -> PBBCEFA

PBBCEFA -> Insert(4, B) -> PBBCBEFA

PBBCBEFA -> Insert(4, A) -> PBBCABEFA

PBBCABEFA -> Insert(4, D) -> PBBCDABEFA

PBBCDABEFA -> Replace(2, A) -> PABCDABEFA

PABCDABEFA -> Replace(1, Q) -> QABCDABEFA



Cách giải:

Đối với xâu ký tự thì việc xố, chèn sẽ làm cho các phần tử phía sau vị trí biến đổi bị đánh chỉ

số lại, gây khó khăn cho việc quản lý vị trí. Để khắc phục điều này, ta sẽ tìm một thứ tự biến

đổi thoả mãn: Phép biến đổi tại vị trí i bắt buộc phải thực hiện sau các phép biến đổi tại vị trí i

+ 1, i + 2, …

Ví dụ: X = 'ABCD';

Insert(0, E) sau đó Delete(4) cho ra X = 'EABD'. Cách này khơng tn thủ ngun tắc

Delete(3) sau đó Insert(0, E) cho ra X = 'EABD'. Cách này tuân thủ ngun tắc đề ra.

Nói tóm lại ta sẽ tìm một dãy biến đổi có vị trí thực hiện giảm dần.



3.3.1. Công thức truy hồi

Giả sử m là độ dài xâu X và n là độ dài xâu Y. Gọi F[i, j] là số phép biến đổi tối thiểu để biến

xâu gồm i ký tự đầu của xâu X: X[1..i] thành xâu gồm j ký tự đầu của xâu Y: Y[1..j].

Quan sát hai dãy X và Y

X1



X2



Y1



Y2



……



Xm-1



……



Yn-1



Xm

Yn



Ta nhận thấy:

Nếu X[m] = Y[n] thì ta chỉ cần biến đoạn X[1..m-1] thành Y[1..n-1]. Tức là trong trường

hợp này: F[m, n] = F[m - 1, n - 1]

X1



X2



Y1



Y2



……



Xm-1



……



Yn-1



Xm=Yn

Yn=Xm



Nếu X[m] ≠ Y[n] thì tại vị trí X[m] ta có thể sử dụng một trong 3 phép biến đổi:

Hoặc chèn vào sau vị trí m của X, một ký tự đúng bằng Yn:

X1



X2



Y1



Y2



……

……



Xm-1

Yn-1



Xm



Yn



Yn



Thì khi đó F[m, n] sẽ bằng 1 phép chèn vừa rồi cộng với số phép biến đổi biến dãy

X[1..m] thành dãy Y[1..n-1]: F[m, n] = 1 + F[m, n - 1]

Lê Minh Hồng



162



Chun đề



Hoặc thay vị trí m của X bằng một ký tự đúng bằng Y[n]:

X1



X2



Y1



Y2



……

……



Xm-1

Yn-1



Xm:=Yn

Yn



Thì khi đó F[m, n] sẽ bằng 1 phép thay vừa rồi cộng với số phép biến đổi biến dãy

X[1..m-1] thành dãy Y[1..n-1]: F[m, n] = 1 + F[m-1, n-1]

Hoặc xố vị trí thứ m của X:

X1



X2



Y1



Y2



……

……



Xm-1

Yn-1



Xm

Yn



Thì khi đó F[m, n] sẽ bằng 1 phép xố vừa rồi cộng với số phép biến đổi biến dãy

X[1..m-1] thành dãy Y[1..n]: F[m, n] = 1 + F[m-1, n]

Vì F[m, n] phải là nhỏ nhất có thể, nên trong trường hợp X[m] ≠ Y[n] thì

F[m, n] = min(F[m, n - 1], F[m - 1, n - 1], F[m - 1, n]) + 1.

Ta xây dựng xong công thức truy hồi:

⎪⎧F [ m − 1, n − 1] , if X m = Yn

F [ m, n ] = ⎨

⎪⎩min(F [ m, n − 1] , F [ m − 1, n − 1] , F [ m − 1, n ]) + 1, if X m ≠ Yn



3.3.2. Cơ sở quy hoạch động

F[0, j] là số phép biến đổi biến xâu rỗng thành xâu gồm j ký tự đầu của F. Nó cần tối thiểu

j phép chèn: F[0, j] = j

F[i, 0] là số phép biến đổi biến xâu gồm i ký tự đầu của S thành xâu rỗng, nó cần tối thiểu i

phép xố: F[i, 0] = i

Vậy đầu tiên bảng phương án F (cỡ[0..m, 0..n]) được khởi tạo hàng 0 và cột 0 là cơ sở quy

hoạch động. Từ đó dùng cơng thức truy hồi tính ra tất cả các phần tử bảng B.

Sau khi tính xong thì F[m, n] cho ta biết số phép biến đổi tối thiểu.

Truy vết:

Nếu X[m] = Y[n] thì chỉ việc xét tiếp F[m - 1, n - 1].

Nếu không, xét 3 trường hợp:

Nếu F[m, n] = F[m, n - 1] + 1 thì phép biến đổi đầu tiên được sử dụng là: Insert(m, Y[n])

Nếu F[m, n] = F[m - 1, n - 1] + 1 thì phép biến đổi đầu tiên được sử dụng là: Replace(m,

Y[n])

Nếu F[m, n] = F[m - 1, n] + 1 thì phép biến đổi đầu tiên được sử dụng là: Delete(m)

Đưa về bài toán với m, n nhỏ hơn truy vết tiếp cho tới khi về F[0, 0]

Ví dụ: X =' ABCD'; Y = 'EABD' bảng phương án là:



ĐHSPHN 1999-2004



Quy hoạch động



163



F 0 1



2 3 4



0 0 1 2 3 4

1 1 1 1 2 3

2 2 2 2 1 2

3 3 3 3 2 2

4 4 4 4 3 2

Hình 51: Truy vết



Lưu ý: khi truy vết, để tránh truy nhập ra ngoài bảng, nên tạo viền cho bảng.

P_3_03_4.PAS * Biến đổi xâu

{$MODE DELPHI} (*This program uses 32-bit Integer [-231..231 - 1]*)

program StrOpt;

const

InputFile = 'STR.INP';

OutputFile = 'STR.OUT';

max = 100;

var

X, Y: String[2 * max];

F: array[-1..max, -1..max] of Integer;

m, n: Integer;

procedure Enter;

var

fi: Text;

begin

Assign(fi, InputFile); Reset(fi);

ReadLn(fi, X); ReadLn(fi, Y);

Close(fi);

m := Length(X); n := Length(Y);

end;

function Min3(x, y, z: Integer): Integer; {Cho giá trị nhỏ nhất trong 3 giá trị x, y, z}

var

t: Integer;

begin

if x < y then t := x else t := y;

if z < t then t := z;

Min3 := t;

end;

procedure Optimize;

var

i, j: Integer;

begin

{Khởi tạo viền cho bảng phương án}

for i := 0 to m do F[i, -1] := max + 1;

for j := 0 to n do F[-1, j] := max + 1;

{Lưu cơ sở quy hoạch động}

for j := 0 to n do F[0, j] := j;

for i := 1 to m do F[i, 0] := i;

{Dùng cơng thức truy hồi tính tồn bảng phương án}

for i := 1 to m do

for j := 1 to n do

if X[i] = Y[j] then F[i, j] := F[i - 1, j - 1]

else F[i, j] := Min3(F[i, j - 1], F[i - 1, j - 1], F[i - 1, j]) + 1;

Lê Minh Hoàng



164



Chuyên đề



end;

procedure Trace; {Truy vết}

var

fo: Text;

begin

Assign(fo, OutputFile); Rewrite(fo);

WriteLn(fo, F[m, n]); {F[m, n] chính là số ít nhất các phép biến đổi cần thực hiện}

while (m <> 0) or (n <> 0) do {Vòng lặp kết thúc khi m = n = 0}

if X[m] = Y[n] then {Hai ký tự cuối của 2 xâu giống nhau}

begin

Dec(m); Dec(n); {Chỉ việc truy chéo lên trên bảng phương án}

end

else {Tại đây cần một phép biến đổi}

begin

Write(fo, X, ' -> '); {In ra xâu X trước khi biến đổi}

if F[m, n] = F[m, n - 1] + 1 then {Nếu đây là phép chèn}

begin

Write(fo, 'Insert(', m, ', ', Y[n], ')');

Insert(Y[n], X, m + 1);

Dec(n); {Truy sang phải}

end

else

if F[m, n] = F[m - 1, n - 1] + 1 then {Nếu đây là phép thay}

begin

Write(fo, 'Replace(', m, ', ', Y[n], ')');

X[m] := Y[n];

Dec(m); Dec(n); {Truy chéo lên trên}

end

else {Nếu đây là phép xoá}

begin

Write(fo, 'Delete(', m, ')');

Delete(X, m, 1);

Dec(m); {Truy lên trên}

end;

WriteLn(fo, ' -> ', X); {In ra xâu X sau phép biến đổi}

end;

Close(fo);

end;

begin

Enter;

Optimize;

Trace;

end.



Hãy tự giải thích tại sao khi giới hạn độ dài dữ liệu là 100, lại phải khai báo X và Y là

String[200] chứ không phải là String[100] ?.



3.4. DÃY CON CÓ TỔNG CHIA HẾT CHO K

Cho một dãy A gồm n (1 ≤ n ≤ 1000) số nguyên dương a[1..n] và số nguyên dương k (k ≤

1000). Hãy tìm dãy con gồm nhiều phần tử nhất của dãy đã cho sao cho tổng các phần tử của

dãy con này chia hết cho k.

Input: file văn bản SUBSEQ.INP

Dòng 1: Chứa số n

Dòng 2: Chứa n số a[1], a[2], …, a[n] cách nhau ít nhất một dấu cách

Output: file văn bản SUBSEQ.OUT

ĐHSPHN 1999-2004



Tài liệu bạn tìm kiếm đã sẵn sàng tải về

§3. MỘT SỐ BÀI TOÁN QUY HOẠCH ĐỘNG

Tải bản đầy đủ ngay(0 tr)

×