当前位置：文档之家› 第四章算法作业

第四章算法作业

骆吉洲作业：

1. 设有n种不同面值的硬币，个个硬币的面值存于数组T[1:n]中。现在用这些硬币来找钱。各种硬币使用的各数不限。

（1）当只用面值为T[1]、T[2],…,T[i]来找出钱j时，所用的硬币的最小个数记为C(i,j),写出C(i,j)的递推式。

（2）设计一个动态规划算法以计算C(n,j)，1≤j≤L，并且只使用一个规模为L的数组，并分析该算法的复杂度。

（3）设C(n,j)，1≤j≤L已经计算出来，对任意钱数m（小于等于L），确定用最少硬币数找出钱m的策略。证明该问题有贪心选择性，设计解该问题的贪心算法，并分析其复杂度。

答：

（1）递推式：

C(i,j)={

0 j=0 j/T[1] j>0且i=1 min

1≤k≤j/T[i]

{k+C(i?1,j?k×T[i])} j>0且i≠1

（2）算法设计：根据（1）中的递推公式，计算C(i,j)时只可能会用到C(i-1,x)，其中x的取值区间为[1,j-1]。不会使用x>j的元素数值。假设一个n×L阶矩阵，只需要从左往右计算，每列从上往下计算C(i,j)，并使用一个规模为L的数组即可。

算法伪代码：

Input：硬币面值数组T[1:n]，待找钱数L

Output：使用硬币的最小个数x的数组

GET-CHANGE(T,L)

1 n←length(T)

2 create array x[1:L]

3 for j←1 to L

4 d o x[j]←j/T[1]

5 for i←2 to n

6 do for j←L to 1

7 do for k←1 to j/T[i]

8 do if x[j-k*x]+k

9 then x[j]←x[j-k*x]+k

10 return x

时间复杂度分析：算法1~2行时间复杂度为O(1)，3~4行时间复杂度为O(L)，5~9行时间复杂度为O(nL2)，10行时间复杂度为O(1)。故算法总的时间复杂度为O(nL2)。

（3）设y[1:n]存储当找钱数为j的最优解时T[1:n]硬币分别找的个数。选择面值最大的T[i]，1≤i≤n，使C[n,j]=C[n,j-T[i]]+1，则子问题找钱数为j-T[i]的最优解y’[1:n]中，y’[i]+1后即为原问题的最优解y[1:n]。故问题的最优解可以通过子问题的最优解来达到，该问题具有贪心选择性。（假设T[1:n]的面值是递增的，并且C[n,L]是与排序后的T对应的结果）

Input：T[1:n], C[1:L], m

Output：每个硬币对应的数目y[1:n]

GET-CHANGE-NUMBER(T,C,m)

1 n←length(T),w←m

2 create array y[1:n]

3 for i←1 to n

4 do y[i]←0

5 while w>0

6 do for i←n to 1

7 do if C[w]=C[w-T[i]]+1

8 then y[i]←y[i]+1

9 w←w-T[i]

10 break

11 return y

时间复杂性分析：算法1~2行时间复杂度为O(1)，2~3行时间复杂度为O(n)，5~10行时间复杂度为O(m×n)，11行时间复杂度为O(1)。故算法总的时间复杂度为O(m×n)。

2.设计一个动态规划算法从n个数构成的数列中找出最长单调递增子序列。

答：

（1）问题转化：设X[1:n]为n个数构成的序列，Y[1:n]为将X[1:n]中的数进行递增排序的结果。那么，原问题可以转化为求X和Y的最长公共子序列。设X中的最长单调递增子序列为x i, x j, …, x k, x m，那么在排序后的Y中，该子序列仍以这一顺序存在于Y中，显然该序列为X和Y的公共子序列。假设其不是X和Y的最长公共子序列，

设其最长公共子序列为x i, x j, …, x p, …, x k, x m。由于Y为递增序列，因此有x i

（2）优化子结构

X和Y的LCS=(z1,z2,…,z k)的优化解结构为

LCS XY=LCS X

+ if x m=y n

m?1Y n?1

if x m≠y n，z k≠x m

LCS XY=LCS X

m?1Y

if x m≠y n，z k≠y m

LCS XY=LCS XY

n?1

（3）递推方程

C[i,j]=X i和Y j的LCS的长度

C[i,j]=0 if i=0或j=0

C[i,j]=C[i?1,j?1]+1 if i,j>0且x i=y j

C[i,j]=max (C[i,j?1],C[i?1,j]) if i,j>0且x i=y j （4）算法伪代码

Input:数列X[1:n]

Output：X的最长单调递增子序列

LIS(X)

1 n←length(X)

2 create array Y[1:n] ,C[n,n] and B[n,n]

3 Y←sort(X)

4 for i←1 to n

5 do C[i,0]←0，C[0,j]←0

6 for i←1 to n

7 do for j←1 to n

8 if X[i]=Y[j]

9 then C[i,j]←C[i-1,j-1]+1;B[i,j]←“↖”

10 else if C[i-1,j]≥C[i,j-1]

11 then C[i,j]←C[i-1,j]; B[i,j]←“↑”

12 else C[i,j]←C[i,j-1]; B[i,j]←“←”

13 return B and C

PRINT-LIS(B,X,i,j)

1 if i←0 or j←0

2 then return

3 if B[i,j]= “↖”

4 then PRINT-LIS(B,X,i-1,j-1);print X[i]

5 else if B[i,j]= “↑”

6 then PRINT-LIS(B,X,i-1,j);

7 else PRINT-LIS(B,X,i,j-1);

时间复杂度分析：

计算代价算法LIS(X)中，1~2行时间复杂度为O(1)，3行为排序算法，时间复杂度最低为O(nlogn)，4~5行时间复杂度为O(n)，6~12行时间复杂度为O(n2)，13行时间复杂度为O(1)；

构造算法PRINT-LIS(B,X,i,j)中，时间复杂度为O(2n)。

故算法总的时间复杂度为O(n 2)。

3.给定一个n×n 的矩阵A ，矩阵中的元素只取0或者1。设计一个动态规划算法，求解得到A 中元素全是1的子方阵使其阶数达到最大值。

答：

（1）优化子结构：设n 阶矩阵表示为A[1:n,1:n]，B[i,j]为A 中前i 行，前j 列中1的个数。则

???==++=1

A[i][j] if 10A[i][j] if 0B -B B B 1-j 1,-i 1-j i,j 1,-i j i, 如果B i,j -B i-k,j - B i,j-k +B i-k,j-k =k 2，那么在该位置存在一个k 阶矩阵。

（2）递推方程：

设C[i,j]表示A 中前i 行前j 列中元素全为1的子方阵的最大阶数。则递推方程为：

C [i,j ]=max {C [i ?1,j ],C [i,j ?1],

max k

{k ≥max (C [i ?1,j ],C [i,j ?1])| B [i,j ]?B [i ?k,j ]?B [i,j ?k ]+B [i ?k ][j ?k ]=k ×k}}

（3）算法伪代码

只要知道了C n,n 的值，就知道了最优解的阶数，为了知道这个最优解的具体信息，我们还需一个结构S ，S i,j 是C i,j 对应的方阵的右下角元素在A 中对应的位置。因此，S n,n 就是最优解方阵右下角元素的位置，C n,n 是最优解的阶数。

GET-MAX-MATRIX(A,n)

1 create arrays B[0:n][0:n],C[0:n][0:n],S[1:n][1:n]

2 for i←0 to n

3 do B[i][0]←0; B[0][i]←0;C[i][0]← 0; C[0][i]←0;

4 for i←0 to n

5 do for j←0 to n

6 do if A[i][j]=1

7 then B[i][j]←1

8 else B[i][j]←0

9 B[i][j]←B[i][j]+B[i-1][j]+B[i][j-1]+B[i-1][j-1]

10if C[i-1][j]>C[i][j-1]

11 then C[i][j]←C[i-1][j]

12 S[i][j]←C[i-1][j]

13 else C[i][j]←C[i][j-1]

14 S[i][j]←C[i][j-1]

15 for k←C[i][j]+1 to i

16 do if i-k+1<1 or j-k+1<0

17 then break

18 if B[i][j]-B[i-k+1][j]-B[i][j-k]+B[i-k][j-k]=k×k

19 then C[i][j]←k

20 S[i][j] (i,j)

21 else break

22 return S and C

算法结束后，S[n][n]中有序实数对(i,j)为A 中最大全1矩阵右下角元素的坐标。该矩阵为A[i-C[n][n]:i][j-C[n][n]:j]。

时间复杂度分析：算法第1行时间复杂度为O(1)，2~3行时间复杂度为O(n)，4~22行时间复杂度为O(n 3)，23行时间复杂度为O(1)。故算法总的时间复杂度为O(n 3)。

4.集合划分问题描述如下：

输入：正整数集合 S={a 1,a 2,a 3,…, a n };

输出：是否存在A ? S 使得∑a i =∑a i a i ∈S?A a i ∈A 。试设计一个动态规划算法，求解集合划分问题。

答：

（1）问题转化：若集合划分A 使得∑a i =∑a i a i ∈S?A a i ∈A ，则有∑a i =∑a i =12∑a i a i ∈S a i ∈S?A a i ∈A 。那么，该问题可转化为一个0-1背包问题。对于输入的正整数集合S={a 1,a 2,a 3,…, a n }。设X=(x 1, x 2, …, x n ),

x i ∈{0, 1}, 满足∑x i a i n i=1≤12∑a i a i ∈S ,且∑x i a i n i=1最大。若此时∑x i a i n i=1=12∑a i a i ∈S , 则存在这样的集合划分A ，输出划分结果；否则不存在这样的集合A 。

（2）优化子结构：如果(y 1, y 2,…, y n )是0-1背包问题的有化解，则(y 2, y 3,…, y n )是如下子问题的优化解：∑x i a i n i=2≤12∑a i a i ∈S ?a 1y 1；x i ∈{0, 1}，2≤i ≤n 。

（3）递推方程：设背包容量为j ，m(i,j)表示背包容量为j ，可选物品为a i ,a i+1,…, a n 时，问题的最优解的代价。因此递归方程为：

m(i,j)=m(i+1,j) 0≤j

m(i,j)=max(m(i+1,j),m(i+1,j?a i)+a i) j≥a i

m(n,j)=0 0≤j

m(n,j)=a n j≥a n

（4）算法伪代码：

Input：正整数集合S={a1,a2,a3,…, a n}

Output：若存在A ?S使得∑a i=∑a i

a i∈A, 则输出X; 否则输

a i∈S?A