----------------------------------------------------- Page 1 -----------------------------------------------------
1.1 第 1 章 ─ 概 论
1.1.1 练 习 题
1. 下 列 关 于 算 法 的 说 法 中 正 确 的 有 （ ） 。
Ⅰ . 求 解 某 一 类 问 题 的 算 法 是 唯 一 的
Ⅱ . 算 法 必 须 在 有 限 步 操 作 之 后 停 止
Ⅲ . 算 法 的 每 一 步 操 作 必 须 是 明 确 的 ， 不 能 有 歧 义 或 含 义 模 糊
Ⅳ . 算 法 执 行 后 一 定 产 生 确 定 的 结 果
A. 1 个 B.2 个 C.3 个 D.4 个
2. T ( n ) 表 示 当 输 入 规 模 为 n 时 的 算 法 效 率 ， 以 下 算 法 效 率 最 优 的 是 （ ） 。
A. T ( n )= T ( n - 1)+1 ， T (1)=1 C. T ( n )= T ( n /2)+1 ， T (1)=1
B. T ( n )= 2 n
D. T ( n )=3 n log 2 n
3. 什 么 是 算 法 ？ 算 法 有 哪 些 特 征 ？
4. 判 断 一 个 大 于 2 的 正 整 数 n 是 否 为 素 数 的 方 法 有 多 种 ， 给 出 两 种 算 法 ， 说 明 其 中 一 种 算 法 更 好 的 理 由 。
5. 证 明 以 下 关 系 成 立 ：
（ 1 ） 10 n - 2 n = ( n )
（ 2 ） 2 = (2 )
6. 证 明 O( f ( n ))+O( g ( n ))=O(max{ f ( n ) ， g ( n )}) 。
7. 有 一 个 含 n （ n >2 ） 个 整 数 的 数 组 a ， 判 断 其 中 是 否 存 在 出 现 次 数 超 过 所 有 元 素 一 半 的 元 素 。
8. 一 个 字 符 串 采 用 string 对 象 存 储 ， 设 计 一 个 算 法 判 断 该 字 符 串 是 否 为 回 文 。
9. 有 一 个 整 数 序 列 ， 设 计 一 个 算 法 判 断 其 中 是 否 存 在 两 个 元 素 和 恰 好 等 于 给 定 的 整 数 k 。
10. 有 两 个 整 数 序 列 ， 每 个 整 数 序 列 中 所 有 元 素 均 不 相 同 。 设 计 一 个 算 法 求 它 们 的 公 共 元 素 ， 要 求 不 使 用 STL 的 集 合 算 法 。
11. 正 整 数 n （ n >1 ） 可 以 写 成 质 数 的 乘 积 形 式 ， 称 为 整 数 的 质 因 数 分 解 。 例 如 ， 12=2*2*3 ， 18=2*3*3 ， 11=11 。 设 计 一 个 算 法 求 n 这 样 分 解 后 各 个 质 因 数 出 现 的 次 数 ， 采 用 vector 向 量 存 放 结 果 。
12. 有 一 个 整 数 序 列 ， 所 有 元 素 均 不 相 同 ， 设 计 一 个 算 法 求 相 差 最 小 的 元 素 对 的 个 数 。 如 序 列 4 、 1 、 2 、 3 的 相 差 最 小 的 元 素 对 的 个 数 是 3 ， 其 元 素 对 是 （ 1 ， 2 ） ， （ 2 ， 3 ） ， （ 3 ， 4 ） 。
13. 有 一 个 map 容 器 ， 其 中 已 经 存 放 了 较 多 元 素 。 设 计 一 个 算 法 求 出 其 中 重 复 的 value 并 且 返 回 重 复 value 的 个 数 。
14. 重 新 做 第 10 题 ， 采 用 map 容 器 存 放 最 终 结 果 。
15. 假 设 有 一 个 含 n （ n >1 ） 个 元 素 的 stack 栈 容 器 st ， 设 计 一 个 算 法 出 栈 从 栈 顶 到 栈 底 的 第 k （ 1 ≤ k ≤ n ） 个 元 素 ， 其 他 栈 元 素 不 变 。
2
2
2
n +1 n
----------------------------------------------------- Page 2 -----------------------------------------------------
算 法 设 计
1.1.2 练 习 题 参 考 答 案
1. 答 ： 由 于 算 法 具 有 有 穷 性 、 确 定 性 和 输 出 性 ， 因 而 Ⅱ 、 Ⅲ 、 Ⅳ 正 确 ， 而 解 决 某 一 类 问 题 的 算 法 不 一 定 是 唯 一 的 。 答 案 为 C 。
2. 答 ： 选 项 A 的 时 间 复 杂 度 为 O( n ) 。 选 项 B 的 时 间 复 杂 度 为 O( n ) 。 选 项 C 的 时 间 复 杂 度 为 O(log 2 n ) 。 选 项 D 的 时 间 复 杂 度 为 O( n log 2 n ) 。 答 案 为 C 。
3. 答 ： 算 法 是 求 解 问 题 的 一 系 列 计 算 步 骤 。 算 法 具 有 有 限 性 、 确 定 性 、 可 行 性 、 输 入 性 和 输 出 性 5 个 重 要 特 征 。
4. 答 ： 两 种 算 法 如 下 ：
#include
#include
bool isPrime1(int n) // 方 法 1
{ for (int i=2;iif (n%i==0)
return false;
return true;
}
bool isPrime2(int n) // 方 法 2
{ for (int i=2;i<=(int)sqrt(n);i++)
if (n%i==0)
return false;
return true;
}
void main()
{ int n=5;
printf("%d,%d\n",isPrime1(n),isPrime2(n));
}
方 法 1 的 时 间 复 杂 度 为 O( n ) ， 方 法 2 的 时 间 复 杂 度 为 n ， 所 以 方 法 2 更 好 。 5. 答 ： （ 1 ） 当 n 足 够 大 时 ， (10 n - 2 n )/( n )=10 ， 所 以 10 n - 2 n = ( n ) 。
（ 2 ） 2 =2*2 = (2 ) 。
6. 证 明 ： 对 于 任 意 f 1 (n) ∈ O( f ( n )) ， 存 在 正 常 数 c 1 和 正 常 数 n 1 ， 使 得 对 所 有 n ≥ n 1 ， 有 f 1 ( n ) ≤ c 1 f ( n ) 。
类 似 地 ， 对 于 任 意 g 1 ( n ) ∈ O( g ( n )) ， 存 在 正 常 数 c 2 和 自 然 数 n 2 ， 使 得 对 所 有 n ≥ n 2 ， 有 g 1 ( n ) ≤ c 2 g ( n ) 。
令 c 3 =max{ c 1 ， c 2 } ， n 3 =max{ n 1 ， n 2 } ， h ( n )= max{ f ( n ) ， g ( n )} 。
则 对 所 有 的 n ≥ n 3 ， 有 ：
f 1 ( n ) + g 1 ( n ) ≤ c 1 f ( n ) + c 2 g ( n ) ≤ c 3 f ( n )+ c 3 g ( n )= c 3 ( f ( n )+ g ( n ))
≤ c 3 2max{ f ( n ) ， g ( n )}=2 c 3 h ( n )=O(max{ f ( n ) ， g ( n )}) 。
7. 解 ： 先 将 a 中 元 素 递 增 排 序 ， 再 求 出 现 次 数 最 多 的 次 数 maxnum ， 最 后 判 断 是 否 满 足 条 件 。 对 应 的 程 序 如 下 ：
#include
#include
using namespace std;
2
2
2
2
2
2
n +1 n n
----------------------------------------------------- Page 3 -----------------------------------------------------
第 1 章
概 论
bool solve(int a[],int n,int &x)
{ sort(a,a+n);
int maxnum=0;
int num=1;
int e=a[0];
for (int i=1;i{ if (a[i]==e)
{ num++;
// 递 增 排 序
// 出 现 次 数 最 多 的 次 数
if (num>maxnum)
{ maxnum=num;
x=e;
}
}
else
{ e=a[i];
num=1;
}
}
if (maxnum>n/2)
return true;
else
return false;
}
void main()
{ int a[]={2,2,2,4,5,6,2};
int n=sizeof(a)/sizeof(a[0]);
int x;
if (solve(a,n,x))
printf(" 出 现 次 数 超 过 所 有 元 素 一 半 的 元 素 为 % d\n",x); else
printf(" 不 存 在 出 现 次 数 超 过 所 有 元 素 一 半 的 元 素 \ n");
}
上 述 程 序 的 执 行 结 果 如 图 1.1 所 示 。
图 1.1
程 序 执 行 结 果
8. 解 ： 采 用 前 后 字 符 判 断 方 法 ， 对 应 的 程 序 如 下 ： #include
#include
using namespace std;
bool solve(string str) // 判 断 字 符 串 str 是 否 为 回 文 { int i=0,j=str.length()-1;
while (i{ if (str[i]!=str[j])
return false;
3
----------------------------------------------------- Page 4 -----------------------------------------------------
算 法 设 计
i++; j--;
}
return true;
}
void main()
{ cout << " 求 解 结 果 " << endl;
string str="abcd";
cout << " " << str << (solve(str)?" 是 回 文 " :" 不 是 回 文 " ) << endl; string str1="abba";
cout << " " << str1 << (solve(str1)?" 是 回 文 " :" 不 是 回 文 " ) << endl; }
上 述 程 序 的 执 行 结 果 如 图 1.2 所 示 。
图 1.2
程 序 执 行 结 果
9. 解 ： 先 将 a 中 元 素 递 增 排 序 ， 然 后 从 两 端 开 始 进 行 判 断 。 对 应 的 程 序 如 下 ： #include
#include
using namespace std;
bool solve(int a[],int n,int k)
{ sort(a,a+n);
int i=0, j=n-1;
while (i{ if (a[i]+a[j]==k)
return true;
// 递 增 排 序
// 区 间 中 存 在 两 个 或 者 以 上 元 素
else if (a[i]+a[j]i++;
else
j--;
}
return false;
}
void main()
{ int a[]={1,2,4,5,3};
int n=sizeof(a)/sizeof(a[0]);
printf(" 求 解 结 果 \ n");
int k=9,i,j;
if (solve(a,n,k,i,j))
printf(" 存 在 : %d+%d=%d\n",a[i],a[j],k); else
printf(" 不 存 在 两 个 元 素 和 为 % d\n",k);
int k1=10;
if (solve(a,n,k1,i,j))
printf(" 存 在 : %d+%d=%d\n",a[i],a[j],k1);
4
----------------------------------------------------- Page 5 -----------------------------------------------------
第 1 章
概 论
else
printf("
不 存 在 两 个 元 素 和 为 % d\n",k1);
}
上 述 程 序 的 执 行 结 果 如 图 1.3 所 示 。
图 1.3
程 序 执 行 结 果
10. 解 ： 采 用 集 合 set 存 储 整 数 序 列 ， 集 合 中 元 素 默 认 是 递 增 排 序 的 ， 再 采 用 二 路 归 并 算 法 求 它 们 的 交 集 。 对 应 的 程 序 如 下 ：
#include
#include
using namespace std;
void solve(set s1,set s2,set &s3) { set::iterator it1,it2;
it1=s1.begin(); it2=s2.begin();
while (it1!=s1.end() && it2!=s2.end())
{ if (*it1==*it2)
{ s3.insert(*it1);
++it1; ++it2;
}
else if (*it1<*it2)
++it1;
else
++it2;
}
}
// 求 交 集 s3
void dispset(set s)
{ set::iterator it;
// 输 出 集 合 的 元 素
for (it=s.begin();it!=s.end();++it)
printf("%d ",*it);
printf("\n");
}
void main()
{ int a[]={3,2,4,8};
int n=sizeof(a)/sizeof(a[0]);
set s1(a,a+n);
int b[]={1,2,4,5,3};
int m=sizeof(b)/sizeof(b[0]);
set s2(b,b+m);
set s3;
solve(s1,s2,s3);
printf(" 求 解 结 果 \ n");
printf(" s1: "); dispset(s1);
5
----------------------------------------------------- Page 6 -----------------------------------------------------
算 法 设 计
printf("
printf("
s2: "); dispset(s2);
s3: "); dispset(s3);
}
上 述 程 序 的 执 行 结 果 如 图 1.4 所 示 。
图 1.4
程 序 执 行 结 果
11. 解 ： 对 于 正 整 数 n ， 从 i =2 开 始 查 找 其 质 因 数 ， ic 记 录 质 因 数 i 出 现 的 次 数 ， 当 找 到 这 样 质 因 数 后 ， 将 （ i ， ic ） 作 为 一 个 元 素 插 入 到 vector 容 器 v 中 。 最 后 输 出 v 。 对 应 的 算 法 如 下 ：
#include
#include
using namespace std;
struct NodeType
{ int p;
int pc;
//vector 向 量 元 素 类 型 // 质 因 数
// 质 因 数 出 现 次 数
};
void solve(int n,vector &v) // 求 n 的 质 因 数 分 解 { int i=2;
int ic=0;
NodeType e;
do
{ if (n%i==0)
{ ic++;
n=n/i;
}
else
{ if (ic>0)
{ e.p=i;
e.pc=ic;
v.push_back(e);
}
ic=0;
i++;
}
} while (n>1 || ic!=0);
}
void disp(vector &v) // 输 出 v
{ vector::iterator it;
for (it=v.begin();it!=v.end();++it)
printf(" 质 因 数 % d 出 现 % d 次 \ n",it->p,it->pc);
}
6
----------------------------------------------------- Page 7 -----------------------------------------------------
第 1 章
概 论
void main()
{ vector v;
int n=100;
printf("n=%d\n",n);
solve(n,v);
disp(v);
}
上 述 程 序 的 执 行 结 果 如 图 1.5 所 示 。
图 1.5
程 序 执 行 结 果
12. 解 ： 先 递 增 排 序 ， 再 求 相 邻 元 素 差 ， 比 较 求 最 小 元 素 差 ， 累 计 最 小 元 素 差 的 个 数 。 对 应 的 程 序 如 下 ：
#include
#include
#include
using namespace std;
int solve(vector &myv)
// 求 myv 中 相 差 最 小 的 元 素 对 的 个 数
{ sort(myv.begin(),myv.end()); // 递 增 排 序
int ans=1;
int mindif=myv[1]-myv[0];
for (int i=2;i{ if (myv[i]-myv[i-1]{ ans=1;
mindif=myv[i]-myv[i-1];
}
else if (myv[i]-myv[i-1]==mindif)
ans++;
}
return ans;
}
void main()
{ int a[]={4,1,2,3};
int n=sizeof(a)/sizeof(a[0]);
vector myv(a,a+n);
cout << " 相 差 最 小 的 元 素 对 的 个 数 : " << solve(myv) << endl; }
上 述 程 序 的 执 行 结 果 如 图 1.6 所 示 。
7
----------------------------------------------------- Page 8 -----------------------------------------------------
图 1.6
算 法 设 计
程 序 执 行 结 果
13. 解 ： 对 于 map 容 器 mymap ， 设 计 另 外 一 个 map 容 器 tmap ， 将 前 者 的 value 作 为 后 者 的 关 键 字 。 遍 历 mymap ， 累 计 tmap 中 相 同 关 键 字 的 次 数 。 一 个 参 考 程 序 及 其 输 出 结 果 如 下 ：
#include
#include
2
----------------------------------------------------- Page 55 -----------------------------------------------------
第 1 章
概 论
6 18 2 7 4
5 9 3 9 9 5
8 4 1 326
37 2 8 64
输 出 结 果 ：
1 2 3 4 4 5
16
1.7.2 练 习 题 参 考 答 案
1. 答 ： C 。
2. 答 ： n 皇 后 问 题 的 解 不 满 足 贪 心 选 择 性 质 。 答 案 为 B 。
3. 答 ： D 。
4. 答 ： 由 于 背 包 问 题 可 以 取 物 品 的 一 部 分 ， 所 以 总 价 值 一 定 大 于 等 于 做 0/1 背 包 问 题 。 答 案 为 D 。
5. 答 ： 这 里 n =215 ， 哈 夫 曼 树 中 n 1 =0 ， 而 n 0 = n 2 +1 ， n = n 0 + n 1 + n 2 =2n 0 - 1 ， n 0 =( n +1)/2=108 。 答 案 为 B 。
6. 答 ： 在 构 造 哈 夫 曼 树 时 每 次 都 是 将 两 棵 根 结 点 最 小 的 树 合 并 ， 从 而 体 现 贪 心 的 思 路 。
7. 证 明 ： 例 如 ， n =3 ， w ={3 ， 2 ， 2} ， v ={7 ， 4 ， 4} ， W =4 时 ， 由 于 7/3 最 大 ， 若 按 题 目 要 求 的 方 法 ， 只 能 取 第 一 个 ， 收 益 是 7 。 而 此 实 例 的 最 大 的 收 益 应 该 是 8 ， 取 第 2 、 3 个 物 品 。
8. 解 ： 用 结 构 体 数 组 A 存 放 硬 币 数 据 ， A [ i ]. v 存 放 硬 币 i 的 面 额 ， A [ i ]. c 存 放 硬 币 i 的 枚 数 。 采 用 贪 心 思 路 ， 首 先 将 数 组 A 按 面 额 递 减 排 序 ， 再 兑 换 硬 币 ， 每 次 尽 可 能 兑 换 面 额 大 的 硬 币 。 对 应 的 完 整 程 序 如 下 ：
#include
#include
using namespace std;
#define min(x,y) ((x)<(y)?(x):(y))
#define MAX 21
// 问 题 表 示
int n=7;
struct NodeType
{ int v;
int c;
// 面 额
// 枚 数
bool operator<(const NodeType &s)
{
// 用 于 按 面 额 递 减 排 序
return s.v}
};
NodeType A[]={{1,12},{2,8},{5,6},{50,10},{10,8},{200,1},{100,4}};
int W;
// 求 解 结 果 表 示
int ans=0;
void solve()
// 兑 换 的 硬 币 枚 数 // 兑 换 硬 币
55
----------------------------------------------------- Page 56 -----------------------------------------------------
{ sort(A,A+n);
算 法 设 计
// 按 面 额 递 减 排 序
for (int i=0;i{ int t=min(W/A[i].v,A[i].c); // 使 用 硬 币 i 的 枚 数 if (t!=0)
printf(" 支 付 %3d 面 额 : %3d 枚 \ n",A[i].v,t);
W-=t*A[i].v;
ans+=t;
if (W==0) break;
}
}
void main()
{ W=325;
// 剩 余 的 金 额
// 支 付 的 金 额
printf(" 支 付 % d 分 : \n",W);
solve();
printf(" 最 少 硬 币 的 个 数 : %d 枚 \ n",ans); }
上 述 程 序 的 执 行 结 果 如 图 1.43 所 示 。
图 1.43
程 序 执 行 结 果
9. 解 ： 采 用 贪 心 方 法 求 解 。 用 a [0.. k ] 存 放 n 的 分 解 结 果 ：
（ 1 ） n ≤ 4 时 可 以 验 证 其 分 解 成 几 个 正 整 数 的 和 的 乘 积 均 小 于 n ， 没 有 解 。
（ 2 ） n >4 时 ， 把 n 分 拆 成 若 干 个 互 不 相 等 的 自 然 数 的 和 ， 分 解 数 的 个 数 越 多 乘 积 越 大 。 为 此 让 n 的 分 解 数 个 数 尽 可 能 多 （ 体 现 贪 心 的 思 路 ） ， 把 n 分 解 成 从 2 开 始 的 连 续 的 自 然 数 之 和 。 例 如 ， 分 解 n 为 a [0]=2 ， a [1]=3 ， a [2]=4 ， … ， a [ k ]= k +2 （ 共 有 k +1 个 分 解 数 ） ， 用 m 表 示 剩 下 数 ， 这 样 的 分 解 直 到 m ≤ a [ k ] 为 止 ， 即 m ≤ k +2 。 对 剩 下 数 m 的 处 理 分 为 如 下 两 种 情 况 ：
① m < k +2 ： 将 m 平 均 分 解 到 a [ k .. i ] （ 对 应 的 分 解 数 个 数 为 m ） 中 ， 即 从 a [ k ] 开 始 往 前 的 分 解 数 增 加 1 （ 也 是 贪 心 的 思 路 ， 分 解 数 越 大 加 1 和 乘 积 也 越 大 ） 。
② m = k +2 ： 将 a [0.. k - 1] （ 对 应 的 分 解 数 个 数 为 k ） 的 每 个 分 解 数 增 加 1 ， 剩 下 的 2 增 加 到 a [ k ] 中 ， 即 a [ k ] 增 加 2 。
对 应 的 完 整 程 序 如 下 ：
#include
#include
#define MAX 20
// 问 题 表 示
int n;
// 求 解 结 果 表 示
56
----------------------------------------------------- Page 57 -----------------------------------------------------
第 1 章
概 论
int a[MAX];
int k=0;
void solve()
{ int i;
int sum=1;
if (n<4)
return;
else
{ int m=n;
a[0]=2;
m-=a[0];
k=0;
while (m>a[k])
{ k++;
// 存 放 被 分 解 的 数
//a[0..k] 存 放 被 分 解 的 数
// 求 解 n 的 最 大 乘 积 分 解 问 题
// 不 存 在 最 优 方 案 , 直 接 返 回
//m 表 示 剩 下 数
// 第 一 个 数 从 2 开 始
// 减 去 已 经 分 解 的 数
// 若 剩 下 数 大 于 最 后 一 个 分 解 数 , 则 继 续 分 解 //a 数 组 下 标 + 1
a[k]=a[k-1]+1; // 按 2 、 3 、 4 递 增 顺 序 分 解
m-=a[k];
}
if (m// 减 去 最 新 分 解 的 数
// 若 剩 下 数 小 于 a [k], 从 a [k] 开 始 往 前 的 数 + 1
{ for (i=0; ia[k-i]+=1;
}
if (m==a[k])
{ a[k]+=2;
// 若 剩 下 数 等 于 a [k], 则 a [k] 的 值 + 2, 之 前 的 数 + 1
for (i=0; ia[i]+=1;
}
}
}
void main()
{ n=23;
memset(a,0,sizeof(a));
solve();
printf("%d 的 最 优 分 解 方 案 \ n",n); int mul=1;
printf(" 分 解 的 数 : ");
for (int i=0;i<=k;i++)
if (a[i]!=0)
{ printf("%d ",a[i]);
mul*=a[i];
}
printf("\n 乘 积 最 大 值 : %d\n",mul); }
上 述 程 序 的 执 行 结 果 如 图 1.44 所 示 。
57
----------------------------------------------------- Page 58 -----------------------------------------------------
图 1.44
算 法 设 计
程 序 执 行 结 果
10. 解 ： 采 用 贪 心 思 路 ， 首 先 按 体 重 递 增 排 序 ； 再 考 虑 前 后 的 两 个 人 （ 最 轻 者 和 最 重 者 ） ， 分 别 用 i 、 j 指 向 ： 若 w [ i ]+ w [ j ] ≤ C ， 说 明 这 两 个 人 可 以 同 乘 （ 执 行 i ++ ， j -- ） ， 否 则 w [ j ] 单 乘 （ 执 行 j -- ） ， 若 最 后 只 剩 余 一 个 人 ， 该 人 只 能 单 乘 。
对 应 的 完 整 程 序 如 下 ：
#include
#include
using namespace std;
#define MAXN 101
// 问 题 表 示
int n=7;
int w[]={50,65,58,72,78,53,82};
int C=150;
// 求 解 结 果 表 示
int bests=0;
void Boat()
{ sort(w,w+n);
int i=0;
int j=n - 1;
while (i<=j)
{ if(i==j)
// 求 解 乘 船 问 题 // 递 增 排 序
// 剩 下 最 后 一 个 人
{ printf(" 一 艘 船 : %d\n",w[i]); bests++;
break;
}
if (w[i]+w[j]<=C) // 前 后 两 个 人 同 乘
{ printf(" 一 艘 船 : %d %d\n",w[i],w[j]); bests++;
i++;
j--;
}
else
//w[j] 单 乘
{ printf(" 一 艘 船 : %d\n",w[j]); bests++;
j--;
}
}
}
void main()
{ printf(" 求 解 结 果 : \n");
Boat();
printf(" 最 少 的 船 数 = %d\n",bests);
}
上 述 程 序 的 执 行 结 果 如 图 1.45 所 示 。
58
----------------------------------------------------- Page 59 -----------------------------------------------------
第 1 章
概 论
图 1.45
程 序 执 行 结 果
11. 解 ： 采 用 贪 心 思 路 。 每 次 都 在 还 未 安 排 的 容 量 最 大 的 会 议 室 安 排 尽 可 能 多 的 参 会 人 数 ， 即 对 于 每 个 会 议 室 ， 都 安 排 当 前 还 未 安 排 的 会 议 中 ， 参 会 人 数 最 多 的 会 议 。 若 能 容 纳 下 ， 则 选 择 该 会 议 ， 否 则 找 参 会 人 数 次 多 的 会 议 来 安 排 ， 直 到 找 到 能 容 纳 下 的 会 议 。
对 应 的 完 整 程 序 如 下 ：
#include
#include
using namespace std;
// 问 题 表 示
int n=4;
int m=4;
int A[]={3,4,3,1};
int B[]={1,2,2,6}; // 求 解 结 果 表 示 int ans=0;
void solve()
{ sort(A,A+n);
sort(B,B+m);
// 会 议 个 数 // 会 议 室 个 数
// 求 解 算 法 // 递 增 排 序 // 递 增 排 序
int i=n-1,j=m-1; // 从 最 多 人 数 会 议 和 最 多 容 纳 人 数 会 议 室 开 始
for(i;i>=0;i--)
{ if(A[i]<=B[j] && j>=0)
{ ans++; // 不 满 足 条 件 ， 增 加 一 个 会 议 室
j--;
}
}
}
void main()
{ solve();
printf("%d\n",ans); // 输 出 2
}
12. 解 ： 与 《 教 程 》 例 7.2 类 似 ， 会 场 对 应 蓄 栏 ， 只 是 这 里 仅 仅 求 会 场 个 数 ， 即 最 大 兼 容 活 动 子 集 的 个 数 。 对 应 的 完 整 程 序 如 下 ：
#include
#include
#include
using namespace std;
#define MAX 51
// 问 题 表 示
struct Action
// 活 动 的 类 型 声 明 59
----------------------------------------------------- Page 60 -----------------------------------------------------
{ int b;
int e;
算 法 设 计
// 活 动 起 始 时 间 // 活 动 结 束 时 间
bool operator<(const Action &s) const // 重 载 < 关 系 函 数
{ if (e==s.e)
return b<=s.b;
else
return e<=s.e;
}
// 结 束 时 间 相 同 按 开 始 时 间 递 增 排 序 // 否 则 按 结 束 时 间 递 增 排 序
};
int n=5;
Action A[]={{0},{1,10},{2,4},{3,6},{5,8},{4,7}}; // 下 标 0 不 用 // 求 解 结 果 表 示
int ans;
void solve()
{ bool flag[MAX];
memset(flag,0,sizeof(flag));
sort(A+1,A+n+1);
ans=0;
for (int j=1;j<=n;j++)
{ if (!flag[j])
{ flag[j]=true;
int preend=j;
// 最 少 会 场 个 数
// 求 解 最 大 兼 容 活 动 子 集 // 活 动 标 志
//A[1..n] 按 指 定 方 式 排 序 // 会 场 个 数
// 前 一 个 兼 容 活 动 的 下 标
for (int i=preend+1;i<=n;i++)
{ if (A[i].b>=A[preend].e && !flag[i]) { preend=i;
flag[i]=true;
}
}
ans++;
// 增 加 一 个 最 大 兼 容 活 动 子 集
}
}
}
void main()
{ solve();
printf(" 求 解 结 果 \ n");
printf(" 最 少 会 场 个 数 : %d\n",ans); // 输 出 4
}
13. 解 ： 采 用 贪 心 思 路 。 从 第 1 列 开 始 每 次 查 找 a [ i ][ j ] 元 素 上 、 中 、 下 3 个 对 应 数 中 的 最 小 数 。 对 应 的 程 序 如 下 ：
#include
#define M 12
#define N 110
int m=5, n=6;
int a[M][N]={{3,4,1,2,8,6},{6,1,8,2,7,4},{5,9,3,9,9,5},{8,4,1,3,2,6},{3,7,2,8,6,4}};
int minRow,minCol;
int minValue(int i, int j)
// 求 a [i][j] 有 方 上 、 中 、 下 3 个 数 的 最 小 数 , 同 时 要 把 行 标 记 录 下 来
{
int s = (i == 0) ? m - 1 : i - 1; int x = (i == m - 1) ? 0 : i + 1;
60
----------------------------------------------------- Page 61 -----------------------------------------------------
第 1 章
概 论
minRow = s;
minRow = a[i][j+1] < a[minRow][j+1] ? i : minRow;
minRow = a[x][j+1] < a[minRow][j+1] ? x : minRow;
minRow = a[minRow][j+1] == a[s][j+1] && minRow > s ? s : minRow; minRow = a[minRow][j+1] == a[i][j+1] && minRow > i ? i : minRow; minRow = a[minRow][j+1] == a[x][j+1] && minRow > x ? x : minRow; return a[minRow][j+1];
}
void solve()
{ int i,j,min;
for (j=n-2; j>=0; j--)
for (i=0; ia[i][j]+= minValue(i,j);
min=a[0][0];
minRow=0;
for (i=1; iif (a[i][0]{ min=a[i][0];
minRow=i;
}
for (j=0; j{ printf("%d",minRow+1);
if (jminValue(minRow, j);
}
printf("\n%d\n",min);
}
void main()
{
solve();
}
// 在 第 一 列 查 找 最 小 代 价 的 行
1.8 第 8 章 ─ 动 态 规 划
1.8.1 练 习 题
1. 下 列 算 法 中 通 常 以 自 底 向 上 的 方 式 求 解 最 优 解 的 是 （ ） 。
A. 备 忘 录 法 B. 动 态 规 划 法 C. 贪 心 法 D. 回 溯 法 2. 备 忘 录 方 法 是 （ ） 算 法 的 变 形 。
A. 分 治 法
B. 回 溯 法
C. 贪 心 法 D. 动 态 规 划 法
3. 下 列 是 动 态 规 划 算 法 基 本 要 素 的 是 （ ） 。
A. 定 义 最 优 解 B. 构 造 最 优 解 C. 算 出 最 优 解 D. 子 问 题 重 叠 性 质 4. 一 个 问 题 可 用 动 态 规 划 算 法 或 贪 心 算 法 求 解 的 关 键 特 征 是 问 题 的 （ ） 。
A. 贪 心 选 择 性 质 B. 重 叠 子 问 题 C. 最 优 子 结 构 性 质 D. 定 义 最 优 解 5. 简 述 动 态 规 划 法 的 基 本 思 路 。
6. 简 述 动 态 规 划 法 与 贪 心 法 的 异 同 。
61
----------------------------------------------------- Page 62 -----------------------------------------------------
算 法 设 计
7. 简 述 动 态 规 划 法 与 分 治 法 的 异 同 。
8. 下 列 算 法 中 哪 些 属 于 动 态 规 划 算 法 ？
（ 1 ） 顺 序 查 找 算 法
（ 2 ） 直 接 插 入 排 序 算 法
（ 3 ） 简 单 选 择 排 序 算 法
（ 4 ） 二 路 归 并 排 序 算 法
9. 某 个 问 题 对 应 的 递 归 模 型 如 下 ：
f (1)=1
f (2)=2
f ( n )= f ( n - 1)+ f ( n - 2)+ … + f (1)+1
可 以 采 用 如 下 递 归 算 法 求 解 ： long f(int n)
{ if (n==1) return 1;
if (n==2) return 2;
long sum=1;
for (int i=1;i<=n-1;i++)
sum+=f(i);
return sum;
当 n >2 时
}
但 其 中 存 在 大 量 的 重 复 计 算 ， 请 采 用 备 忘 录 方 法 求 解 。
10. 第 3 章 中 的 实 验 4 采 用 分 治 法 求 解 半 数 集 问 题 ， 如 果 直 接 递 归 求 解 会 存 在 大 量 重 复 计 算 ， 请 改 进 该 算 法 。
11. 设 计 一 个 时 间 复 杂 度 为 O( n ) 的 算 法 来 计 算 二 项 式 系 数 C n （ k ≤ n ） 。 二 项 式 系 数 C n 的 求 值 过 程 如 下 ：
? = 1
? = 1
? ? ‒ 1 ?
? ? ‒ 1 ? ‒ 1
当 i ≥ j
12. 一 个 机 器 人 只 能 向 下 和 向 右 移 动 ， 每 次 只 能 移 动 一 步 ， 设 计 一 个 算 法 求 它 从 （ 0 ， 0 ） 移 动 到 （ m ， n ） 有 多 少 条 路 径 。
13. 两 种 水 果 杂 交 出 一 种 新 水 果 ， 现 在 给 新 水 果 取 名 ， 要 求 这 个 名 字 中 包 含 了 以 前 两 种 水 果 名 字 的 字 母 ， 并 且 这 个 名 字 要 尽 量 短 。 也 就 是 说 以 前 的 一 种 水 果 名 字 arr1 是 新 水 果 名 字 arr 的 子 序 列 ， 另 一 种 水 果 名 字 arr2 也 是 新 水 果 名 字 arr 的 子 序 列 。 设 计 一 个 算 法 求 arr 。
例 如 ： 输 入 以 下 3 组 水 果 名 称 ：
apple peach
ananas banana
pear peach
输 出 的 新 水 果 名 称 如 下 ：
62
2
k
n
k
0
?
?
?
? = ?
+ ?
----------------------------------------------------- Page 63 -----------------------------------------------------
第 1 章
概 论
appleach
bananas
pearch
1.8.2 练 习 题 参 考 答 案
1. 答 ： B 。
2. 答 ： D 。
3. 答 ： D 。
4. 答 ： C 。
5. 答 ： 动 态 规 划 法 的 基 本 思 路 是 将 待 求 解 问 题 分 解 成 若 干 个 子 问 题 ， 先 求 子 问 题 的 解 ， 然 后 从 这 些 子 问 题 的 解 得 到 原 问 题 的 解 。
6. 答 ： 动 态 规 划 法 的 3 个 基 本 要 素 是 最 优 子 结 构 性 质 、 无 后 效 性 和 重 叠 子 问 题 性 质 ， 而 贪 心 法 的 两 个 基 本 要 素 是 贪 心 选 择 性 质 和 最 优 子 结 构 性 质 。 所 以 两 者 的 共 同 点 是 都 要 求 问 题 具 有 最 优 子 结 构 性 质 。
两 者 的 不 同 点 如 下 ：
（ 1 ） 求 解 方 式 不 同 ， 动 态 规 划 法 是 自 底 向 上 的 ， 有 些 具 有 最 优 子 结 构 性 质 的 问 题 只 能 用 动 态 规 划 法 ， 有 些 可 用 贪 心 法 。 而 贪 心 法 是 自 顶 向 下 的 。
（ 2 ） 对 子 问 题 的 依 赖 不 同 ， 动 态 规 划 法 依 赖 于 各 子 问 题 的 解 ， 所 以 应 使 各 子 问 题 最 优 ， 才 能 保 证 整 体 最 优 ； 而 贪 心 法 依 赖 于 过 去 所 作 过 的 选 择 ， 但 决 不 依 赖 于 将 来 的 选 择 ， 也 不 依 赖 于 子 问 题 的 解 。
7. 答 ： 两 者 的 共 同 点 是 将 待 求 解 的 问 题 分 解 成 若 干 子 问 题 ， 先 求 解 子 问 题 ， 然 后 再 从 这 些 子 问 题 的 解 得 到 原 问 题 的 解 。
两 者 的 不 同 点 是 ： 适 合 于 用 动 态 规 划 法 求 解 的 问 题 ， 分 解 得 到 的 各 子 问 题 往 往 不 是 相 互 独 立 的 （ 重 叠 子 问 题 性 质 ） ， 而 分 治 法 中 子 问 题 相 互 独 立 ； 另 外 动 态 规 划 法 用 表 保 存 已 求 解 过 的 子 问 题 的 解 ， 再 次 碰 到 同 样 的 子 问 题 时 不 必 重 新 求 解 ， 而 只 需 查 询 答 案 ， 故 可 获 得 多 项 式 级 时 间 复 杂 度 ， 效 率 较 高 ， 而 分 治 法 中 对 于 每 次 出 现 的 子 问 题 均 求 解 ， 导 致 同 样 的 子 问 题 被 反 复 求 解 ， 故 产 生 指 数 增 长 的 时 间 复 杂 度 ， 效 率 较 低 。
8. 答 ： 判 断 算 法 是 否 具 有 最 优 子 结 构 性 质 、 无 后 效 性 和 重 叠 子 问 题 性 质 。 （ 2 ） 、 （ 3 ） 和 （ 4 ） 均 属 于 动 态 规 划 算 法 。
9. 解 ： 设 计 一 个 dp 数 组 ， dp[ i ] 对 应 f ( i ) 的 值 ， 首 先 dp 的 所 有 元 素 初 始 化 为 0 ， 在 计 算 f ( i ) 时 ， 若 dp[0]>0 表 示 f ( i ) 已 经 求 出 ， 直 接 返 回 dp[ i ] 即 可 ， 这 样 避 免 了 重 复 计 算 。 对 应 的 算 法 如 下 ：
long dp[MAX]; //dp[n] 保 存 f (n) 的 计 算 结 果
long f1(int n)
{ if (n==1)
{ dp[n]=1;
return dp[n];
}
if (n==2)
{ dp[n]=2;
return dp[n];
63
----------------------------------------------------- Page 64 -----------------------------------------------------
算 法 设 计
}
if (dp[n]>0) return dp[n];
long sum=1;
for (int i=1;i<=n-1;i++)
sum+=f1(i);
dp[n]=sum;
return dp[n];
}
10. 解 ： 设 计 一 个 数 组 a ， 其 中 a [ i ]= f ( i ) ， 首 先 将 a 的 所 有 元 素 初 始 化 为 0 ， 当 a [ i ]>0 时 表 示 对 应 的 f ( i ) 已 经 求 出 ， 直 接 返 回 就 可 以 了 。 对 应 的 完 整 程 序 如 下 ：
#include
#include
#define MAXN 201
// 问 题 表 示
int n;
int a[MAXN];
int fa(int i)
{ int ans=1;
if (a[i]>0)
return a[i];
for(int j=1;j<=i/2;j++)
ans+=fa(j);
a[i]=ans;
return ans;
}
int solve(int n)
{ memset(a,0,sizeof(a));
a[1]=1;
return fa(n);
}
void main()
{ n=6;
// 求 a [i]
// 求 s et(n) 的 元 素 个 数
printf(" 求 解 结 果 \ n");
printf(" n=%d 时 半 数 集 元 素 个 数 = %d\n",n,solve(n));
}
11. 解 ： 定 义 C ( i ， j )= C i
， i ≥ j 。 则 有 如 下 递 推 计 算 公 式 ： C ( i ， n j )= C ( i - 1 ， j - 1)+C( i -
1 ， j ) ， 初 始 条 件 为 C ( i ， 0)=1 ， C ( i ， i )=1 。 可 以 根 据 初 始 条 件 由 此 递 推 关 系 计 算 C ( n ， k ) ，
n
即 C n 。 对 应 的 程 序 如 下 ：
#include
#define MAXN 51
#define MAXK 31
// 问 题 表 示
int n,k;
// 求 解 结 果 表 示
int C[MAXN][MAXK];
void solve()
{ int i,j;
64
j
k
----------------------------------------------------- Page 65 -----------------------------------------------------
第 1 章
概 论
for (i=0;i<=n;i++)
{ C[i][i]=1;
C[i][0]=1;
}
for (i=1;i<=n;i++)
for (j=1;j<=k;j++)
C[i][j]=C[i-1][j-1]+C[i-1][j];
}
void main()
{ n=5,k=3;
solve();
printf("%d\n",C[n][k]); // 输 出 1 0
}
显 然 ， solve() 算 法 的 时 间 复 杂 度 为 O( n ) 。
12. 解 ： 设 从 （ 0 ， 0 ） 移 动 到 （ i ， j ） 的 路 径 条 数 为 dp[ i ][ j ] ， 由 于 机 器 人 只 能 向 下 和 向 右 移 动 ， 不 同 于 迷 宫 问 题 （ 迷 宫 问 题 由 于 存 在 后 退 ， 不 满 足 无 后 效 性 ， 不 适 合 用 动 态 规 划 法 求 解 ） 。 对 应 的 状 态 转 移 方 程 如 下 ：
dp[0][ j ]=1
dp[ i ][0]=1
dp[ i ][ j ]=dp[ i ][ j - 1]+dp[ i - 1][ j ]
i 、 j >0
最 后 结 果 是 dp[ m ][ n ] 。 对 应 的 程 序 如 下 ：
#include
#include
#define MAXX 51
#define MAXY 51
// 问 题 表 示
int m,n;
// 求 解 结 果 表 示
int dp[MAXX][MAXY];
void solve()
{ int i,j;
dp[0][0]=0;
memset(dp,0,sizeof(dp));
for (i=1;i<=m;i++)
dp[i][0]=1;
for (j=1;j<=n;j++)
dp[0][j]=1;
for (i=1;i<=m;i++)
for (j=1;j<=n;j++)
dp[i][j]=dp[i][j-1]+dp[i-1][j];
}
void main()
{ m=5,n=3;
solve();
printf("%d\n",dp[m][n]);
}
13. 解 ： 本 题 目 的 思 路 是 求 arr1 和 arr2 字 符 串 的 最 长 公 共 子 序 列 ， 基 本 过 程 参 见 《 教
65
2
----------------------------------------------------- Page 66 -----------------------------------------------------
程 》 第 8 章 8.5 节 。 对 应 的 完 整 程 序 如 下 ： #include
#include
#include
#include
using namespace std;
#define max(x,y) ((x)>(y)?(x):(y))
#define MAX 51
// 问 题 表 示
int m,n;
string arr1,arr2;
// 求 解 结 果 表 示
int dp[MAX][MAX];
vector subs;
void LCSlength()
{ int i,j;
for (i=0;i<=m;i++)
dp[i][0]=0;
for (j=0;j<=n;j++)
dp[0][j]=0;
for (i=1;i<=m;i++)
for (j=1;j<=n;j++)
算 法 设 计
// 序 列 中 最 多 的 字 符 个 数
// 动 态 规 划 数 组
// 存 放 L CS
// 求 d p
// 将 d p[i][0] 置 为 0 , 边 界 条 件
// 将 d p[0][j] 置 为 0 , 边 界 条 件
// 两 重 f or 循 环 处 理 arr1 、 arr2 的 所 有 字 符
{ if (arr1[i-1]==arr2[j-1]) // 比 较 的 字 符 相 同
dp[i][j]=dp[i-1][j-1]+1;
else
// 比 较 的 字 符 不 同
dp[i][j]=max(dp[i][j-1],dp[i-1][j]);
}
}
void Buildsubs()
{ int k=dp[m][n];
int i=m;
int j=n;
while (k>0)
// 由 d p 构 造 从 s ubs
//k 为 a rr1 和 a rr2 的 最 长 公 共 子 序 列 长 度
// 在 s ubs 中 放 入 最 长 公 共 子 序 列 ( 反 向 )
if (dp[i][j]==dp[i-1][j]) i--;
else if (dp[i][j]==dp[i][j-1]) j--;
else
{ subs.push_back(arr1[i-1]); //subs 中 添 加 a rr1[i-1] i--; j--; k--;
}
}
void main()
{ cin >> arr1 >> arr2; m=arr1.length();
n=arr2.length();
LCSlength();
Buildsubs();
cout << " 求 解 结 果 " << endl;
cout << " arr: "; vector::reverse_iterator rit;
// 输 入 a rr1 和 a rr2 //m 为 a rr1 的 长 度 //n 为 a rr2 的 长 度 // 求 出 d p
// 求 出 L CS
66
----------------------------------------------------- Page 67 -----------------------------------------------------
第 1 章
for (rit=subs.rbegin();rit!=subs.rend();++rit)
cout << *rit;
cout << endl;
cout << " 长 度 : " << dp[m][n] << endl;
概 论
}
改 为 如 下 ：
13. 解 ： 本 题 目 的 思 路 是 先 求 arr1 和 arr2 字 符 串 的 最 长 公 共 子 序 列 ， 基 本 过 程 参 见 《 教 程 》 第 8 章 8.5 节 ， 再 利 用 递 归 输 出 新 水 果 取 名 。
算 法 中 设 置 二 维 动 态 规 划 数 组 dp ， dp[i][j] 表 示 arr1[0..i-1] （ i 个 字 母 ） 和 arr2[0..j-1] （ j 个 字 母 ） 中 最 长 公 共 子 序 列 的 长 度 。 另 外 设 置 二 维 数 组 b ， b[i][j] 表 示 arr1 和 arr2 比 较 的 3 种 情 况 ： b[i][j]=0 表 示 arr1[i-1]=arr2[j-1] ， b[i][j]=1 表 示 arr1[i-1] ≠ arr2[j-1] 并 且 dp[i- 1][j]>dp[i][j-1] ， b[i][j]=2 表 示 arr1[i-1] ≠ arr2[j-1] 并 且 dp[i-1][j] ≤ dp[i][j-1] 。
对 应 的 完 整 程 序 如 下 ：
#include
#include
#define MAX 51
// 问 题 表 示
int m,n;
char arr1[MAX],arr2[MAX];
// 求 解 结 果 表 示
int dp[MAX][MAX];
int b[MAX][MAX];
void Output(int i,int j)
{ if (i==0 && j==0)
return;
if(i==0)
{ Output(i,j-1);
printf("%c",arr2[j-1]);
return;
}
else if(j==0)
{ Output(i-1,j);
printf("%c",arr1[i-1]);
return;
}
if (b[i][j]==0)
{ Output(i-1,j-1);
printf("%c",arr1[i-1]);
return;
}
else if(b[i][j]==1)
{ Output(i-1,j);
printf("%c",arr1[i-1]);
return;
}
else
{ Output(i,j-1);
// 序 列 中 最 多 的 字 符 个 数
// 动 态 规 划 数 组
// 存 放 a rr1 与 a rr2 比 较 的 3 种 情 况 // 利 用 递 归 输 出 新 水 果 取 名
// 输 出 完 毕
//arr1 完 毕 ， 输 出 arr2 的 剩 余 部 分
//arr2 完 毕 ， 输 出 a rr1 的 剩 余 部 分
//arr1[i-1]=arr2[j-1] 的 情 况
67
----------------------------------------------------- Page 68 -----------------------------------------------------
算 法 设 计
printf("%c",arr2[j-1]);
return;
}
}
void LCSlength()
{ int i,j;
for (i=0;i<=m;i++)
dp[i][0]=0;
for (j=0;j<=n;j++)
dp[0][j]=0;
for (i=1;i<=m;i++)
for (j=1;j<=n;j++)
{ if (arr1[i-1]==arr2[j-1])
{ dp[i][j]=dp[i-1][j-1]+1;
b[i][j]=0;
}
else if (dp[i-1][j]>dp[i][j-1])
{ dp[i][j]=dp[i-1][j];
b[i][j]=1;
}
else
{ dp[i][j]=dp[i][j-1];
b[i][j]=2;
}
}
}
void main()
{ int t;
printf(" 测 试 用 例 个 数 : "); scanf("%d",&t);
while(t--)
{ scanf("%s",arr1);
scanf("%s",arr2);
memset(b,-1,sizeof(b));
m=strlen(arr1);
n=strlen(arr2);
LCSlength();
printf(" 结 果 : "); Output(m,n); printf("\n");
}
}
上 述 程 序 的 一 次 执 行 结 果 如 图 1.46 所 示 。
// 求 d p
// 将 d p[i][0] 置 为 0 , 边 界 条 件
// 将 d p[0][j] 置 为 0 , 边 界 条 件
// 两 重 f or 循 环 处 理 a rr1 、 arr2 的 所 有 字 符 // 比 较 的 字 符 相 同 ： 情 况 0
// 情 况 1
//dp[i-1][j]<=dp[i][j-1]: 情 况 2
// 输 入 测 试 用 例 个 数
//m 为 a rr1 的 长 度
//n 为 a rr2 的 长 度
// 求 出 d p
// 输 出 新 水 果 取 名
68
----------------------------------------------------- Page 69 -----------------------------------------------------
第 1 章
概 论
图 1.46
程 序 的 一 次 执 行 结 果
13. 解 ： 本 题 目 的 思 路 是 求 arr1 和 arr2 字 符 串 的 最 长 公 共 子 序 列 ， 基 本 过 程 参 见 《 教 程 》 第 8 章 8.5 节 。 对 应 的 完 整 程 序 如 下 ：
然 后 再 用 递 归 思 想 ， 逐 一 输 出 ， 得 到 的 就 是 最 后 答 案 。
#include
#include
#include
#include
using namespace std;
#define max(x,y) ((x)>(y)?(x):(y))
#define MAX 51
// 问 题 表 示
int m,n;
string arr1,arr2;
// 求 解 结 果 表 示
int dp[MAX][MAX];
vector subs;
void LCSlength()
{ int i,j;
for (i=0;i<=m;i++)
dp[i][0]=0;
for (j=0;j<=n;j++)
dp[0][j]=0;
for (i=1;i<=m;i++)
for (j=1;j<=n;j++)
// 序 列 中 最 多 的 字 符 个 数
// 动 态 规 划 数 组
// 存 放 L CS
// 求 d p
// 将 d p[i][0] 置 为 0 , 边 界 条 件
// 将 d p[0][j] 置 为 0 , 边 界 条 件
// 两 重 f or 循 环 处 理 a rr1 、 arr2 的 所 有 字 符
{ if (arr1[i-1]==arr2[j-1]) // 比 较 的 字 符 相 同
dp[i][j]=dp[i-1][j-1]+1;
else
// 比 较 的 字 符 不 同
dp[i][j]=max(dp[i][j-1],dp[i-1][j]);
}
}
void Buildsubs()
{ int k=dp[m][n];
int i=m;
int j=n;
while (k>0)
// 由 d p 构 造 从 s ubs
//k 为 a rr1 和 a rr2 的 最 长 公 共 子 序 列 长 度
// 在 s ubs 中 放 入 最 长 公 共 子 序 列 ( 反 向 )
if (dp[i][j]==dp[i-1][j]) i--;
else if (dp[i][j]==dp[i][j-1]) j--;
69
----------------------------------------------------- Page 70 -----------------------------------------------------
算 法 设 计
else
{ subs.push_back(arr1[i-1]); //subs 中 添 加 a rr1[i-1] i--; j--; k--;
}
}
void main()
{ cin >> arr1 >> arr2; m=arr1.length();
n=arr2.length();
LCSlength();
Buildsubs();
// 输 入 a rr1 和 arr2 //m 为 a rr1 的 长 度 //n 为 a rr2 的 长 度 // 求 出 d p
// 求 出 L CS
cout << " 求 解 结 果 " << endl;
cout << " arr: ";
vector::reverse_iterator rit;
for (rit=subs.rbegin();rit!=subs.rend();++rit)
cout << *rit;
cout << endl;
cout << " 长 度 : " << dp[m][n] << endl;
}
上 述 程 序 的 一 次 执 行 结 果 如 图 1.46 所 示 。
图 1.46
程 序 的 一 次 执 行 结 果
1.9 第 9 章 ─ 图 算 法 设 计
1.9.1 练 习 题
1. 以 下 不 属 于 贪 心 算 法 的 是 （ ） 。
A.Prim 算 法 B.Kruskal 算 法 C.Dijkstra 算 法 D. 深 度 优 先 遍 历 2. 一 个 有 n 个 顶 点 的 连 通 图 的 生 成 树 是 原 图 的 最 小 连 通 子 图 ， 且 包 含 原 图 中 所 有 n
个 顶 点 ， 并 且 有 保 持 图 联 通 的 最 少 的 边 。 最 大 生 成 树 就 是 权 和 最 大 生 成 树 ， 现 在 给 出 一 个 无 向 带 权 图 的 邻 接 矩 阵 为 { {0 ， 4 ， 5 ， 0 ， 3} ， {4 ， 0 ， 4 ， 2 ， 3} ， {5 ， 4 ， 0 ， 2 ， 0} ， {0 ， 2 ， 2 ， 0 ， 1} ， {3 ， 3 ， 0 ， 1 ， 0}} ， 其 中 权 为 0 表 示 没 有 边 。 一 个 图 为 求 这 个 图 的 最 大 生 成 树 的 权 和 是 （ ） 。
A.11
B.12
C.13
D.14
E.15
3. 某 个 带 权 连 通 图 有 4 个 以 上 的 顶 点 ， 其 中 恰 好 有 2 条 权 值 最 小 的 边 ， 尽 管 该 图 的 最 小 生 成 树 可 能 有 多 个 ， 而 这 2 条 权 值 最 小 的 边 一 定 包 含 在 所 有 的 最 小 生 成 树 中 吗 ？ 如 果 有 3 条 权 值 最 小 的 边 呢 ？
70
----------------------------------------------------- Page 71 -----------------------------------------------------
第 1 章
概 论
4. 为 什 么 TSP 问 题 采 用 贪 心 算 法 求 解 不 一 定 得 到 最 优 解 ？
5. 求 最 短 路 径 的 4 种 算 法 适 合 带 权 无 向 图 吗 ？
6. 求 单 源 最 短 路 径 的 算 法 有 Dijkstra 算 法 、 Bellman - Ford 算 法 和 SPFA 算 法 ， 比 较 这 些 算 法 的 不 同 点 。
7. 有 人 这 样 修 改 Dijkstra 算 法 以 便 求 一 个 带 权 连 通 图 的 单 源 最 长 路 径 ， 将 每 次 选 择 dist 最 小 的 顶 点 u 改 为 选 择 最 大 的 顶 点 u ， 将 按 路 径 长 度 小 进 行 调 整 改 为 按 路 径 长 度 大 调 整 。 这 样 可 以 求 单 源 最 长 路 径 吗 ？
8. 给 出 一 种 方 法 求 无 环 带 权 连 通 图 （ 所 有 权 值 非 负 ） 中 从 顶 点 s 到 顶 点 t 的 一 条 最 长 简 单 路 径 。
9. 一 个 运 输 网 络 如 图 1.47 所 示 ， 边 上 数 字 为 （ c ( i ， j ) ， b ( i ， j ) ） ， 其 中 c ( i ， j ) 表 示 容 量 ， b ( i ， j ) 表 示 单 位 运 输 费 用 。 给 出 从 1 、 2 、 3 位 置 运 输 货 物 到 位 置 6 的 最 小 费 用 最 大 流 的 过 程 。
10. 本 教 程 中 的 Dijkstra 算 法 采 用 邻 接 矩 阵 存 储 图 ， 算 法 时 间 复 杂 度 为 O( n ) 。 请 你 从 各 个 方 面 考 虑 优 化 该 算 法 ， 用 于 求 源 点 v 到 其 他 顶 点 的 最 短 路 径 长 度 。
11. 有 一 个 带 权 有 向 图 G （ 所 有 权 为 正 整 数 ） ， 采 用 邻 接 矩 阵 存 储 。 设 计 一 个 算 法 求 其 中 的 一 个 最 小 环 。
1
(4,2)
(6,4)
4
(12,3)
2
(3,5)
6
(3,4)
(1,6)
5
(9,12)
3
(2,3)
图 1.47
一 个 运 输 网 络
1.9.2 练 习 题 参 考 答 案
1. 答 ： D 。
2. 答 ： 采 用 类 似 Kurskal 算 法 来 求 最 大 生 成 树 ， 第 1 步 取 最 大 边 （ 0 ， 2 ） ， 第 2 步 取 边 （ 0 ， 1 ） ， 第 3 步 取 边 （ 0 ， 4 ） ， 第 4 步 取 最 大 边 （ 1 ， 3 ） ， 得 到 的 权 和 为 14 。 答 案 为 D 。
3. 答 ： 这 2 条 权 值 最 小 的 边 一 定 包 含 在 所 有 的 最 小 生 成 树 中 ， 因 为 按 Kurskal 算 法 一 定 首 先 选 中 这 2 条 权 值 最 小 的 边 。 如 果 有 3 条 权 值 最 小 的 边 ， 就 不 一 定 了 ， 因 为 首 先 选 中 这 3 条 权 值 最 小 的 边 有 可 能 出 现 回 路 。
4. 答 ： TSP 问 题 不 满 足 最 优 子 结 构 性 质 ， 如 （ 0 ， 1 ， 2 ， 3 ， 0 ） 是 整 个 问 题 的 最 优 解 ， 但 （ 0 ， 1 ， 2 ， 0 ） 不 一 定 是 子 问 题 的 最 优 解 。
5. 答 ： 都 适 合 带 权 无 向 图 求 最 短 路 径 。
6. 答 ： Dijkstra 算 法 不 适 合 存 在 负 权 边 的 图 求 单 源 最 短 路 径 ， 其 时 间 复 杂 度 为 O( n ) 。 Bellman - Ford 算 法 和 SPFA 算 法 适 合 存 在 负 权 边 的 图 求 单 源 最 短 路 径 ， 但 图 中 不 能
71
2
2
----------------------------------------------------- Page 72 -----------------------------------------------------
算 法 设 计
存 在 权 值 和 为 负 的 环 。 Bellman - Ford 算 法 的 时 间 复 杂 度 为 O( ne ) ， 而 SPFA 算 法 的 时 间 复 杂 度 为 O( e ) ， 所 以 SPFA 算 法 更 优 。
7. 答 ： 不 能 。 Dijkstra 算 法 本 质 上 是 一 种 贪 心 算 法 ， 而 求 单 源 最 长 路 径 不 满 足 贪 心 选 择 性 质 。
8. 答 ： Bellman - Ford 算 法 和 SPFA 算 法 适 合 存 在 负 权 边 的 图 求 单 源 最 短 路 径 。 可 以 将 图 中 所 有 边 权 值 改 为 负 权 值 ， 求 出 从 顶 点 s 到 顶 点 t 的 一 条 最 短 简 单 路 径 ， 它 就 是 原 来 图 中 从 顶 点 s 到 顶 点 t 的 一 条 最 长 简 单 路 径 。
9. 答 ： 为 该 运 输 网 络 添 加 一 个 虚 拟 起 点 0 ， 它 到 1 、 2 、 3 位 置 运 输 费 用 为 0 ， 容 量 分 别 为 到 1 、 2 、 3 位 置 运 输 容 量 和 ， 如 图 1.48 所 示 ， 起 点 s =0 ， 终 点 t =6 。
1
(4,2)
(10,0)
(6,4)
4
(12,3)
0
(6,0)
2
(3,5)
6
(3,0)
(3,4)
(1,6)
5
(9,12)
3
(2,3)
图 1.48
添 加 一 个 虚 拟 起 点 的 运 输 网 络
首 先 初 始 化 f 为 零 流 ， 最 大 流 量 maxf=0 ， 最 小 费 用 mincost=0 ， 采 用 最 小 费 用 最 大 流 算 法 求 解 过 程 如 下 ：
（ 1 ） k =0 ， 求 出 w 如 下 ：
求 出 从 起 点 0 到 终 点 6 的 最 短 路 径 为 0→1 →4 →6 ， 求 出 最 小 调 整 量 =4 ， f [4][6] 调 整 为 4 ， f [1][4] 调 整 为 4 ， f [0][1] 调 整 为 4 ， mincost=20 ， maxf=4 。
（ 2 ） k =1 ， 求 出 w 如 下 ：
求 出 从 起 点 0 到 终 点 6 的 最 短 路 径 为 0 →2 →4 →6 ， 求 出 最 小 调 整 量 =3 ， f [4][6] 调 整
72
----------------------------------------------------- Page 73 -----------------------------------------------------
第 1 章
概 论
为 7 ， f [2][4] 调 整 为 3 ， f [0][2] 调 整 为 3 ， mincost=44 ， maxf=4+3=7 。 （ 3 ） k =2 ， 求 出 w 如 下 ：
求 出 从 起 点 0 到 终 点 6 的 最 短 路 径 为 0 →3 →4 →6 ， 求 出 最 小 调 整 量 =1 ， f [4][6] 调 整 为 8 ， f [3][4] 调 整 为 1 ， f [0][3] 调 整 为 1 ， mincost=53 ， maxf=7+1=8 。
（ 4 ） k =3 ， 求 出 w 如 下 ：
求 出 从 起 点 0 到 终 点 6 的 最 短 路 径 为 0 →3 →5 →6 ， 求 出 最 小 调 整 量 =2 ， f [5][6] 调 整 为 2 ， f [3][5] 调 整 为 2 ， f [0][3] 调 整 为 3 ， mincost=83 ， maxf=8+2=10 。
（ 5 ） k =4 ， 求 出 w 如 下 ：
求 出 从 起 点 0 到 终 点 6 的 最 短 路 径 为 0 →1→5 →6 ， 求 出 最 小 调 整 量 =6 ， f [5][6] 调 整 为 8 ， f [1][5] 调 整 为 6 ， f [0][1] 调 整 为 10 ， mincost=179 ， maxf=10+6=16 。
（ 6 ） k =5 ， 求 出 w 如 下 ：
求 出 从 起 点 0 到 终 点 6 的 最 短 路 径 为 0 →1 →5→6 ， 求 出 最 小 调 整 量 =1 ， f [5][6] 调 整
73
----------------------------------------------------- Page 74 -----------------------------------------------------
算 法 设 计
为 9 ， f [2][5] 调 整 为 1 ， f [0][2] 调 整 为 4 ， mincost=195 ， maxf=16+1=17 。 （ 7 ） k =6 ， 求 出 的 w 中 没 有 增 广 路 径 ， 调 整 结 束 。 对 应 的 最 大 流 如 下 ：
最 终 结 果 ， maxf=17 ， mincost=195 。 即 运 输 的 最 大 货 物 量 为 17 ， 对 应 的 最 小 总 运 输 费 用 为 195 。
10. 解 ： 从 两 个 方 面 考 虑 优 化 ：
（ 1 ） 在 Dijkstra 算 法 中 ， 当 求 出 源 点 v 到 顶 点 u 的 最 短 路 径 长 度 后 ， 仅 仅 调 整 从 顶 点 u 出 发 的 邻 接 点 的 最 短 路 径 长 度 ， 而 教 程 中 的 Dijkstra 算 法 由 于 采 用 邻 接 矩 阵 存 储 图 ， 需 要 花 费 O( n ) 的 时 间 来 调 整 顶 点 u 出 发 的 邻 接 点 的 最 短 路 径 长 度 ， 如 果 采 用 邻 接 表 存 储 图 ， 可 以 很 快 查 找 到 顶 点 u 的 所 有 邻 接 点 并 进 行 调 整 ， 时 间 为 O(MAX( 图 中 顶 点 的 出 度 ) ) 。
（ 2 ） 求 目 前 一 个 最 短 路 径 长 度 的 顶 点 u 时 ， 教 科 书 上 的 Dijkstra 算 法 采 用 简 单 比 较 方 法 ， 可 以 改 为 采 用 优 先 队 列 （ 小 根 堆 ） 求 解 。 由 于 最 多 e 条 边 对 应 的 顶 点 进 队 ， 对 应 的 时 间 为 O(log 2 e ) 。
对 应 的 完 整 程 序 和 测 试 数 据 算 法 如 下 ：
#include "Graph.cpp"
#include
#include
using namespace std;
ALGraph *G;
struct Node
{ int i;
int v;
// 包 含 图 的 基 本 运 算 算 法
// 图 的 邻 接 表 存 储 结 构 ， 作 为 全 局 变 量 // 声 明 堆 中 结 点 类 型
// 顶 点 编 号
//dist[i] 值
friend bool operator<(const Node &a ， const Node &b) // 定 义 比 较 运 算 符 { return a.v > b.v; }
};
void Dijkstra(int v ， int dist[]) // 改 进 的 D ijkstra 算 法
{ ArcNode *p;
priority_queue qu;
Node e;
int S[MAXV];
// 创 建 小 根 堆
//S[i]=1 表 示 顶 点 i 在 S 中 ， S[i]=0 表 示 顶 点 i 在 U 中
int i ， j ， u ， w;
memset(S ， 0 ， sizeof(S));
p=G->adjlist[v].firstarc;
for (i=0;in;i++) dist[i]=INF;
while (p!=NULL)
{ w=p->adjvex;
74
----------------------------------------------------- Page 75 -----------------------------------------------------
第 1 章
概 论
dist[w]=p->weight;
e.i=w; e.v=dist[w];
qu.push(e);
p=p->nextarc;
}
S[v]=1;
for (i=0;in-1;i++)
// 距 离 初 始 化
// 将 v 的 出 边 顶 点 进 队 q u
// 源 点 编 号 v 放 入 S 中
// 循 环 直 到 所 有 顶 点 的 最 短 路 径 都 求 出
{ e=qu.top(); qu.pop(); // 出 队 e
u=e.i;
S[u]=1;
p=G->adjlist[u].firstarc;
while (p!=NULL)
{ w=p->adjvex;
if (S[w]==0)
// 选 取 具 有 最 小 最 短 路 径 长 度 的 顶 点 u
// 顶 点 u 加 入 S 中
// 考 察 从 顶 点 u 出 发 的 所 有 相 邻 点
// 考 虑 修 改 不 在 S 中 的 顶 点 w 的 最 短 路 径 长 度
if (dist[u]+p->weight{ dist[w]=dist[u]+p->weight; // 修 改 最 短 路 径 长 度 e.i=w; e.v=dist[w];
qu.push(e); // 修 改 最 短 路 径 长 度 的 顶 点 进 队
}
p=p->nextarc;
}
}
}
void Disppathlength(int v ， int dist[]) // 输 出 最 短 路 径 长 度
{ printf(" 从 % d 顶 点 出 发 的 最 短 路 径 长 度 如 下 : \n" ， v);
for (int i=0;in;++i)
if (i!=v)
printf(" 到 顶 点 % d: %d\n" ， i ， dist[i]);
}
void main()
{ int A[MAXV][MAXV]={
{0 ， 4 ， 6 ， 6 ， INF ， INF ， INF} ，
{INF ， 0 ， 1 ， INF ， 7 ， INF ， INF} ，
{INF ， INF ， 0 ， INF ， 6 ， 4 ， INF} ，
{INF ， INF ， 2 ， 0 ， INF ， 5 ， INF} ，
{INF ， INF ， INF ， INF ， 0 ， INF ， 6} ，
{INF ， INF ， INF ， INF ， 1 ， 0 ， 8} ，
{INF ， INF ， INF ， INF ， INF ， INF ， 0}};
int n=7 ， e=12;
CreateAdj(G ， A ， n ， e); printf(" 图 G 的 邻 接 表 : \n"); DispAdj(G);
int v=0;
int dist[MAXV];
Dijkstra(v ， dist);
Disppathlength(v ， dist);
DestroyAdj(G);
// 建 立 图 的 邻 接 表 // 输 出 邻 接 表
// 调 用 Dijkstra 算 法 // 输 出 结 果
// 销 毁 图 的 邻 接 表
}
上 述 程 序 的 执 行 结 果 如 图 1.49 所 示 。
75
----------------------------------------------------- Page 76 -----------------------------------------------------
算 法 设 计
图 1.49 程 序 执 行 结 果
其 中 Dijkstra 算 法 的 时 间 复 杂 度 为 O( n (log 2 e +MAX( 顶 点 的 出 度 ) ) ， 一 般 图 中 最 大 顶 点 出 度 远 小 于 e ， 所 以 进 一 步 简 化 时 间 复 杂 度 为 O( n log 2 e ) 。
11. 有 一 个 带 权 有 向 图 G （ 所 有 权 为 正 整 数 ） ， 采 用 邻 接 矩 阵 存 储 。 设 计 一 个 算 法 求 其 中 的 一 个 最 小 环 。
解 ： 利 用 Floyd 算 法 求 出 所 有 顶 点 对 之 间 的 最 短 路 径 ， 若 顶 点 i 到 j 有 最 短 路 径 ， 而 图 中 又 存 在 顶 点 j 到 i 的 边 ， 则 构 成 一 个 环 ， 在 所 有 环 中 比 较 找 到 一 个 最 小 环 并 输 出 。 对 应 的 程 序 如 下 ：
#include "Graph.cpp"
// 包 含 图 的 基 本 运 算 算 法
#include
using namespace std;
void Dispapath(int path[][MAXV],int i,int j) // 输 出 顶 点 i 到 j 的 一 条 最 短 路 径
{ vector apath;
int k=path[i][j];
apath.push_back(j);
while (k!=-1 && k!=i)
{ apath.push_back(k);
k=path[i][k];
}
apath.push_back(i);
// 存 放 一 条 最 短 路 径 中 间 顶 点 ( 反 向 ) // 路 径 上 添 加 终 点
// 路 径 上 添 加 中 间 点
// 路 径 上 添 加 起 点
for (int s=apath.size()-1;s>=0;s--) // 输 出 路 径 上 的 中 间 顶 点 printf("%d → ",apath[s]);
}
int Mincycle(MGraph g,int A[MAXV][MAXV],int &mini,int &minj) // 在 图 g 和 A 中 的 查 找 一 个 最 小 环
{ int i,j,min=INF;
for (i=0;ifor (j=0;jif (i!=j && g.edges[j][i]{ if (A[i][j]+g.edges[j][i]{ min=A[i][j]+g.edges[j][i];
mini=i; minj=j;
76
----------------------------------------------------- Page 77 -----------------------------------------------------
第 1 章
概 论
}
}
return min;
}
void Floyd(MGraph g)
{ int A[MAXV][MAXV],path[MAXV][MAXV];
int i,j,k,min,mini,minj;
for (i=0;ifor (j=0;j{ A[i][j]=g.edges[i][j];
//Floyd 算 法 求 图 g 中 的 一 个 最 小 环
if (i!=j && g.edges[i][j]path[i][j]=i;
else
path[i][j]=-1;
}
for (k=0;k{ for (i=0;ifor (j=0;j// 顶 点 i 到 j 有 边 时
// 顶 点 i 到 j 没 有 边 时
// 依 次 考 察 所 有 顶 点
if (A[i][j]>A[i][k]+A[k][j])
{ A[i][j]=A[i][k]+A[k][j]; // 修 改 最 短 路 径 长 度 path[i][j]=path[k][j]; // 修 改 最 短 路 径
}
}
min=Mincycle(g,A,mini,minj);
if (min!=INF)
{ printf(" 图 中 最 小 环 ： ");
Dispapath(path,mini,minj); printf("%d, 长 度 ： %d\n",mini,min);
}
else printf(" 图 中 没 有 任 何 环 \ n");
}
void main()
{ MGraph g;
// 输 出 一 条 最 短 路 径
int A[MAXV][MAXV]={ {0,5,INF,INF},{INF,0,1,INF},
{3,INF,0,2}, {INF,4,INF,0}};
int n=4, e=5;
CreateMat(g,A,n,e); printf(" 图 G 的 邻 接 矩 阵 : \n"); DispMat(g);
Floyd(g);
// 建 立 图 的 邻 接 矩 阵 // 输 出 邻 接 矩 阵
}
上 述 程 序 的 执 行 结 果 如 图 1.50 所 示 。
77
----------------------------------------------------- Page 78 -----------------------------------------------------
算 法 设 计
图 1.50 程 序 执 行 结 果
1.10 第 10 章 ─ 计 算 几 何
1.10.1 练 习 题
1. 对 如 图 1.51 所 示 的 点 集 A ， 给 出 采 用 Graham 扫 描 算 法 求 凸 包 的 过 程 及 结 果 。
10
9
8
7
6
5
4
3
2
1
a 8
a 11
a 9
a 0
a 6
a 7
a 5
a 3
a 10
a 4
a 1
a 2
1 2 3 4 5
6 7 8 9 10
图 1.51 一 个 点 集 A
2. 对 如 图 1.51 所 示 的 点 集 A ， 给 出 采 用 分 治 法 求 最 近 点 对 的 过 程 及 结 果 。
3. 对 如 图 1.51 所 示 的 点 集 A ， 给 出 采 用 旋 转 卡 壳 法 求 最 远 点 对 的 结 果 。
4. 对 应 3 个 点 向 量 p 1 、 p 2 、 p 3 ， 采 用 S (p 1 ， p 2 ， p 3 )=(p 2 - p 1 ) (p 3 - p 1 )/2 求 它 们 构 成 的 三 角 形 面 积 ， 请 问 什 么 情 况 下 计 算 结 果 为 正 ？ 什 么 情 况 下 计 算 结 果 为 负 ？
5. 已 知 坐 标 为 整 数 ， 给 出 判 断 平 面 上 一 点 p 是 否 在 一 个 逆 时 针 三 角 形 p 1 -p 2 -p 3 的 算 法 。
1.10.2 练 习 题 参 考 答 案
内 部
1. 答 ： 采 用 Graham 扫 描 算 法 求 凸 包 的 过 程 及 结 果 如 下 ：
求 出 起 点 a 0 (1 ， 1) 。
排 序 后 ： a 0 (1 ， 1) a 1 (8 ， 1) a 2 (9 ， 4) a 3 (5 ， 4) a 4 (8 ， 7) a 5 (5 ， 6) a 10 (7 ， 10) a 9 (3 ， 5) a 6 (3 ， 7) a 7 (4 ， 10) a 8 (1 ， 6) a 11 (0 ， 3) 。
先 将 a 0 (1 ， 1) 进 栈 ， a 1 (8 ， 1) 进 栈 ， a 2 (9 ， 4) 进 栈 。
处 理 点 a 3 (5 ， 4) ： a 3 (5 ， 4) 进 栈 。
处 理 点 a 4 (8 ， 7) ： a 3 (5 ， 4) 存 在 右 拐 关 系 ， 退 栈 ， a 4 (8 ， 7) 进 栈 。
78
----------------------------------------------------- Page 79 -----------------------------------------------------
第 1 章
概 论
处 理 点 a 5 (5 ， 6) ： a 5 (5 ， 6) 进 栈 。
处 理 点 a 10 (7 ， 10) ： a 5 (5 ， 6) 存 在 右 拐 关 系 ， 退 栈 ， a 10 (7 ， 10) 进 栈 。
处 理 点 a 9 (3 ， 5) ： a 9 (3 ， 5) 进 栈 。
处 理 点 a 6 (3 ， 7) ： a 9 (3 ， 5) 存 在 右 拐 关 系 ， 退 栈 ， a 6 (3 ， 7) 进 栈 。
处 理 点 a 7 (4 ， 10) ： a 6 (3 ， 7) 存 在 右 拐 关 系 ， 退 栈 ， a 7 (4 ， 10) 进 栈 。
处 理 点 a 8 (1 ， 6) ： a 8 (1 ， 6) 进 栈 。
处 理 点 a 11 (0 ， 3) ： a 11 (0 ， 3) 进 栈 。
结 果 ： n =8 ， 凸 包 的 顶 点 ： a 0 (1 ， 1) a 1 (8 ， 1) a 2 (9 ， 4) a 4 (8 ， 7) a 10 (7 ， 10) a 7 (4 ， 10) a 8 (1 ， 6) a 11 (0 ， 3) 。
2. 答 ： 求 解 过 程 如 下 ：
排 序 前 ： (1 ， 1) (8 ， 1) (9 ， 4) (5 ， 4) (8 ， 7) (5 ， 6) (3 ， 7) (4 ， 10) (1 ， 6) (3 ， 5) (7 ， 10) (0 ， 3) 。 按 x 坐 标 排 序 后 ： (0 ， 3) (1 ， 1) (1 ， 6) (3 ， 7) (3 ， 5) (4 ， 10) (5 ， 4) (5 ， 6) (7 ， 10) (8 ， 1) (8 ， 7) (9 ， 4) 。 按 y 坐 标 排 序 后 ： (1 ， 1) (8 ， 1) (0 ， 3) (5 ， 4) (9 ， 4) (3 ， 5) (1 ， 6) (5 ， 6) (3 ， 7) (8 ， 7) (4 ， 10) (7 ， 10) 。
（ 1 ） 中 间 位 置 midindex=5 ， 左 部 分 ： (0 ， 3) (1 ， 1) (1 ， 6) (3 ， 7) (3 ， 5) (4 ， 10) ； 右 部 分 ： (5 ， 4) (5 ， 6) (7 ， 10) (8 ， 1) (8 ， 7) (9 ， 4) ； 中 间 部 分 点 集 为 (0 ， 3) (3 ， 7) (4 ， 10) (5 ， 4) (5 ， 6) (7 ， 10) (8 ， 7) 。
（ 2 ） 求 解 左 部 分 ： (0 ， 3) (1 ， 1) (1 ， 6) (3 ， 7) (3 ， 5) (4 ， 10) 。
中 间 位 置 = 2 ， 划 分 为 左 部 分 1 ： (0 ， 3) (1 ， 1) (1 ， 6) ， 右 部 分 1 ： (3 ， 7) (3 ， 5) (4 ， 10) 处 理 左 部 分 1 ： 点 数 少 于 4 ： 求 出 最 近 距 离 = 2.23607 ， 即 ( 0 ， 3) 和 ( 1 ， 1) 之 间 的 距 离 。 处 理 右 部 分 1 ： 点 数 少 于 4 ： 求 出 最 近 距 离 =2 ， 即 ( 3 ， 7) 和 ( 3 ， 5) 之 间 的 距 离 。 再 考 虑 中 间 部 分 （ 中 间 部 分 最 近 距 离 = 2.23 ） 求 出 左 部 分 d1=2 。
（ 3 ） 求 解 右 部 分 ： (5 ， 4) (5 ， 6) (7 ， 10) (8 ， 1) (8 ， 7) (9 ， 4) 。
中 间 位 置 = 8 ， 划 分 为 左 部 分 2 ： (5 ， 4) (5 ， 6) (7 ， 10) ， 右 部 分 2 ： (8 ， 1) (8 ， 7) (9 ， 4) 。
处 理 左 部 分 2 ： 点 数 少 于 4 ， 求 出 最 近 距 离 = 2 ， 即 (5 ， 4) 和 ( 5 ， 6) 之 间 的 距 离 。 处 理 右 部 分 2 ： 点 数 少 于 4 ， 求 出 最 近 距 离 = 3.16228 ， 即 ( 8 ， 1) 和 ( 9 ， 4) 之 间 的 距 离 。 再 考 虑 中 间 部 分 （ 中 间 部 分 为 空 ） 求 出 右 部 分 d2=2 。
（ 4 ） 求 解 中 间 部 分 点 集 ： (0 ， 3) (3 ， 7) (4 ， 10) (5 ， 4) (5 ， 6) (7 ， 10) (8 ， 7) 。 求 出 最 近 距 离 d3=5 。
最 终 结 果 为 ： d=MIN{d1 ， d2 ， d3)=2 。
3. 答 ： 采 用 旋 转 卡 壳 法 求 出 两 个 最 远 点 对 是 （ 1 ， 1 ） 和 （ 7 ， 10 ） ， 最 远 距 离 为 10.82 。
4. 答 ： 当 三 角 形 p 1 - p 2 - p 3
逆 时 针 方 向 时 ， 如 图 1.52 所 示 ， p 2 - p 1
在 p 3 - p 1
的 顺 时 针 方
向 上 ， (p 2 - p 1 ) (p 3 - p 1 )>0 ， 对 应 的 面 积 ( p 2 - p 1 ) (p 3 - p 1 )/2 为 正 。
当 三 角 形 p 1 - p 2 - p 3
顺 时 针 方 向 时 ， 如 图 1.53 所 示 ， p 2 - p 1
在 p 3 - p 1
的 逆 时 针 方 向 上 ，
(p 2 - p 1 ) (p 3 - p 1 )<0 ， 对 应 的 面 积 ( p 2 - p 1 ) (p 3 - p 1 )/2 为 负 。
79
----------------------------------------------------- Page 80 -----------------------------------------------------
算 法 设 计
p 1
p 3 - p 1
p 2 - p 1
p 1
p 2 - p 1
p 3 - p 1
图 1.52
p 1 - p 2 - p 3
逆 时 针 方 向 图
图 1.53 p 1 - p 2 - p 3
逆 时 针 方 向
5. 答 ： 用 S (p 1 ， p 2 ， p 3 )=(p 2 - p 1 ) (p 3 - p 1 )/2 求 三 角 形 p 1 、 p 2 、 p 3 带 符 号 的 的 面 积 。 如 图 1.54 所 示 ， 若 S (p ， p 2 ， p 3 ) 和 S (p ， p 3 ， p 1 ) 和 S (p ， p 1 ， p 2 ) （ 3 个 三 角 形 的 方 向 均 为 逆 时 针 方 向 ） 均 大 于 0 ， 表 示 p 在 该 三 角 形 内 部 。
p 3
p 1
p
p 2
图 1.54
一 个 点 p 和 一 个 三 角 形
对 应 的 程 序 如 下 ：
#include "Fundament.cpp"
// 包 含 向 量 基 本 运 算 算 法
double getArea(Point p1,Point p2,Point p3) // 求 带 符 号 的 面 积
{
return Det(p2-p1,p3-p1);
}
bool Intrig(Point p,Point p1,Point p2,Point p3) // 判 断 p 是 否 在 三 角 形 p1p2p3 的 内 部 { double area1=getArea(p,p2,p3);
double area2=getArea(p,p3,p1);
double area3=getArea(p,p1,p2);
if (area1>0 && area2>0 && area3>0)
return true;
else
return false;
}
void main()
{ printf(" 求 解 结 果 \ n");
Point p1(0,0);
Point p2(5,-4);
Point p3(4,3);
Point p4(3,1);
Point p5(-1,1);
printf(" p1:"); p1.disp(); printf("\n");
printf(" p2:"); p2.disp(); printf("\n");
printf(" p3:"); p3.disp(); printf("\n");
printf(" p4:"); p4.disp(); printf("\n");
80
----------------------------------------------------- Page 81 -----------------------------------------------------
第 1 章
概 论
printf("
printf("
printf("
printf("
p5:"); p5.disp(); printf("\n");
p1p2p3 三 角 形 面 积 : %g\n",getArea(p1,p2,p3));
p4 在 p 1p2p3 三 角 形 内 部 : %s\n",Intrig(p4,p1,p2,p3)?" 是 " :" 不 是 " ); p5 在 p 1p2p3 三 角 形 内 部 : %s\n",Intrig(p5,p1,p2,p3)?" 是 " :" 不 是 " );
}
上 述 程 序 的 执 行 结 果 如 图 1.55 所 示 。
图 1.55 程 序 执 行 结 果
1.11 第 11 章 ─ 计 算 复 杂 性 理 论
1.11.1 练 习 题
1. 旅 行 商 问 题 是 NP 问 题 吗 ？
A. 否
B. 是
C. 至 今 尚 无 定 论
2. 下 面 有 关 P 问 题 ， NP 问 题 和 NPC 问 题 ， 说 法 错 误 的 是 （ ） 。
A. 如 果 一 个 问 题 可 以 找 到 一 个 能 在 多 项 式 的 时 间 里 解 决 它 的 算 法 ， 那 么 这 个 问 题 就 属 于 P 问 题
B.NP 问 题 是 指 可 以 在 多 项 式 的 时 间 里 验 证 一 个 解 的 问 题
C. 所 有 的 P 类 问 题 都 是 NP 问 题
D.NPC 问 题 不 一 定 是 个 NP 问 题 ， 只 要 保 证 所 有 的 NP 问 题 都 可 以 约 化 到 它 即 可
3. 对 于 《 教 程 》 例 11.2 设 计 的 图 灵 机 ， 分 别 给 出 执 行 f (3 ， 2) 和 f (2 ， 3) 的 瞬 像 演 变 过 程 。
4. 什 么 是 P 类 问 题 ？ 什 么 是 NP 类 问 题 ？
5. 证 明 求 两 个 m 行 n 列 的 二 维 矩 阵 相 加 的 问 题 属 于 P 类 问 题 。
6. 证 明 求 含 有 n 个 元 素 的 数 据 序 列 中 求 最 大 元 素 的 问 题 属 于 P 类 问 题 。
7. 设 计 一 个 确 定 性 图 灵 机 M ， 用 于 计 算 后 继 函 数 S ( n )= n +1 （ n 为 一 个 二 进 制 数 ） ， 并 给 出 求 1010001 的 后 继 函 数 值 的 瞬 像 演 变 过 程 。
1.11.2 练 习 题 参 考 答 案
1. 答 ： B 。
2. 答 ： D 。
3. 答 ： （ 1 ） 执 行 f (3 ， 2) 时 ， 输 入 带 上 的 初 始 信 息 为 000100B ， 其 瞬 像 演 变 过 程 如
81
----------------------------------------------------- Page 82 -----------------------------------------------------
算 法 设 计
下 ：
q 0 000100B B0 q 3 0110B BB01 q 2 10B
B q 1 00100B B q 3 00110B BB011 q 2 0B
B0 q 1 0100B q 3 B00110B BB01 q 3 11B
B00 q 1 100B
B001 q 2 00B
B00 q 3 110B
B q 0 00110B
BB q 1 0110B
BB0 q 1 110B
BB0 q 3 111B
BB q 3 0111B
BB q 0 0111B
BBB1 q 2 11B
BBB11 q 2 1B
BBB111 q 2 B
BBB11 q 4 1B
BBB1 q 4 1BB
BBB q 4 1BBB
BBB q 4 BBBB
BBB0 q 6 BBB
最 终 带 上 有 一 个 0 ， 计 算 结 果 为 1 。
（ 2 ） 执 行 f (2 ， 3) 时 ， 输 入 带 上 的 初 始 信 息 为 001000B ， 其 瞬 像 演 变 过 程 如 下 ：
q 0 001000B
B q 0 01000B
B0 q 1 1000B
B01 q 2 000B
B0 q 3 1100B
B q 3 01100B
q 3 B01100B BB q 3 1100B
B q 0 01100B B q 3 B1100B
BB q 1 1100B BB q 0 1100B
BB1 q 2 100B BBB q 5 100B
BB11 q 2 00B BBBB q 5 00B
BB1 q 3 100B
BBBBB q 5 0B
BBBBBB q 5 B
BBBBBBB q 6
最 终 带 上 有 零 个 0 ， 计 算 结 果 为 0 。
4. 答 ： 用 确 定 性 图 灵 机 以 多 项 式 时 间 界 可 解 的 问 题 称 为 P 类 问 题 。 用 非 确 定 性 图 灵 机 以 多 项 式 时 间 界 可 解 的 问 题 称 为 NP 类 问 题 。
5. 答 ： 求 两 个 m 行 n 列 的 二 维 矩 阵 相 加 的 问 题 对 应 的 算 法 时 间 复 杂 度 为 O( mn ) ， 所 以 属 于 P 类 问 题 。
6. 答 ： 求 含 有 n 个 元 素 的 数 据 序 列 中 最 大 元 素 的 问 题 的 算 法 时 间 复 杂 度 为 O( n ) ， 所 以 属 于 P 类 问 题 。
7. 解 ： q 0 为 初 始 状 态 ， q 3 为 终 止 状 态 ， 读 写 头 初 始 时 注 视 最 右 边 的 格 。 δ 动 作 函 数 如 下 ：
δ ( q 0 ， 0) → ( q 1 ， 1 ， L )
δ ( q 0 ， 1) → ( q 2 ， 0 ， L )
δ ( q 0 ， B ) → ( q 3 ， B ， R )
δ ( q 1 ， 0) → ( q 1 ， 0 ， L )
δ ( q 1 ， 1) → ( q 1 ， 1 ， L )
δ ( q 1 ， B ) → ( q 3 ， B ， L )
δ ( q 2 ， 0) → ( q 1 ， 1 ， L )
δ ( q 2 ， 1) → ( q 2 ， 0 ， L )
δ ( q 2 ， B ) → ( q 3 ， B ， L )
求 10100010 的 后 继 函 数 值 的 瞬 像 演 变 过 程 如 下 ：
B 1010001 q 0 0 B
B 101000 q 1 11 B
B 10100 q 1 011 B
B 1010 q 1 0011 B
B 101 q 1 00011 B
B 10 q 1 100011 B
B 1 q 1 0100011 B
Bq 1 10100011 B
q 1 B10100011 B
q 3 BB 10100011 B
其 结 果 为 10100011 。
82
----------------------------------------------------- Page 83 -----------------------------------------------------
第 1 章
概 论
1.12 第 12 章 ─ 概 率 算 法 和 近 似 算 法
1.12.1 练 习 题
1. 蒙 特 卡 罗 算 法 是 （ ） 的 一 种 。
A. 分 枝 限 界 算 法 B. 贪 心 算 法 C. 概 率 算 法 D. 回 溯 算 法
2. 在 下 列 算 法 中 有 时 找 不 到 问 题 解 的 是 （ ） 。
A. 蒙 特 卡 罗 算 法 B. 拉 斯 维 加 斯 算 法 C. 舍 伍 德 算 法 D. 数 值 概 率 算 法 3. 在 下 列 算 法 中 得 到 的 解 未 必 正 确 的 是 （ ） 。
A. 蒙 特 卡 罗 算 法 B. 拉 斯 维 加 斯 算 法 C. 舍 伍 德 算 法 D. 数 值 概 率 算 法 4. 总 能 求 得 非 数 值 问 题 的 一 个 解 ， 且 所 求 得 的 解 总 是 正 确 的 是 （ ） 。
A. 蒙 特 卡 罗 算 法 B. 拉 斯 维 加 斯 算 法 C. 数 值 概 率 算 法 D. 舍 伍 德 算 法 5. 目 前 可 以 采 用 （ ） 在 多 项 式 级 时 间 内 求 出 旅 行 商 问 题 的 一 个 近 似 最 优 解 。
A. 回 溯 法
B. 蛮 力 法
C. 近 似 算 法 D. 都 不 可 能
6. 下 列 叙 述 错 误 的 是 （ ） 。
A. 概 率 算 法 的 期 望 执 行 时 间 是 指 反 复 解 同 一 个 输 入 实 例 所 花 的 平 均 执 行 时 间
B. 概 率 算 法 的 平 均 期 望 时 间 是 指 所 有 输 入 实 例 上 的 平 均 期 望 执 行 时 间
C. 概 率 算 法 的 最 坏 期 望 事 件 是 指 最 坏 输 入 实 例 上 的 期 望 执 行 时 间
D. 概 率 算 法 的 期 望 执 行 时 间 是 指 所 有 输 入 实 例 上 的 所 花 的 平 均 执 行 时 间
7. 下 列 叙 述 错 误 的 是 （ ） 。
A. 数 值 概 率 算 法 一 般 是 求 数 值 计 算 问 题 的 近 似 解
B.Monte Carlo 总 能 求 得 问 题 的 一 个 解 ， 但 该 解 未 必 正 确
C.Las Vegas 算 法 的 一 定 能 求 出 问 题 的 正 确 解
D.Sherwood 算 法 的 主 要 作 用 是 减 少 或 是 消 除 好 的 和 坏 的 实 例 之 间 的 差 别
8. 近 似 算 法 和 贪 心 法 有 什 么 不 同 ？
9. 给 定 能 随 机 生 成 整 数 1 到 5 的 函 数 rand5() ， 写 出 能 随 机 生 成 整 数 1 到 7 的 函 数 rand7() 。
1.12.2 练 习 题 参 考 答 案
1. 答 ： C 。
2. 答 ： B 。
3. 答 ： A 。
4. 答 ： D 。
5. 答 ： C 。
6. 答 ： 对 概 率 算 法 通 常 讨 论 平 均 的 期 望 时 间 和 最 坏 的 期 望 时 间 ， 前 者 指 所 有 输 入 实 例 上 平 均 的 期 望 执 行 时 间 ， 后 者 指 最 坏 的 输 入 实 例 上 的 期 望 执 行 时 间 。 答 案 为 D 。
7. 答 ： 一 旦 用 拉 斯 维 加 斯 算 法 找 到 一 个 解 ， 那 么 这 个 解 肯 定 是 正 确 的 ， 但 有 时 用 拉 斯 维 加 斯 算 法 可 能 找 不 到 解 。 答 案 为 C 。
8. 答 ： 近 似 算 法 不 能 保 证 得 到 最 优 解 。 贪 心 算 法 不 一 定 是 近 似 算 法 ， 如 果 可 以 证 明
83
----------------------------------------------------- Page 84 -----------------------------------------------------
算 法 设 计
决 策 既 不 受 之 前 决 策 的 影 响 ， 也 不 影 响 后 续 决 策 ， 则 贪 心 算 法 就 是 确 定 的 最 优 解 算 法 。 9. 解 ： 通 过 rand5()*5+rand5() 产 生 6 ， 7 ， 8 ， 9 ， … ， 26 ， 27 ， 28 ， 29 ， 30 这 25 个 整
数 ， 每 个 整 数 x 出 现 的 概 率 相 等 ， 取 前 面 3*7=21 个 整 数 ， 舍 弃 后 面 的 4 个 整 数 ， 将 { 6 ， 7 ， 8} 转 化 成 1 ， {9 ， 10 ， 11} 转 化 成 2 ， 以 此 类 推 ， 即 由 y = ( x - 3)/3 为 最 终 结 果 。 对 应 的 程 序 如 下 ：
#include
#include
#include
int rand5()
{ int a=1,b=5;
return rand()%(b-a+1)+a;
}
int rand7()
{ int x;
do
{
x=rand5()*5+rand5();
} while (x>26);
int y=(x-3)/3;
return y;
}
void main()
{ srand((unsigned)time(NULL));
for (int i=1;i<=20;i++)
printf("%d ",rand7());
printf("\n");
// 包 含 产 生 随 机 数 的 库 函 数
// 产 生 一 个 [ 1,5] 的 随 机 数
// 产 生 一 个 [ 1,7] 的 随 机 数 // 随 机 种 子
// 输 出 20 个 [ 1,7] 的 随 机 数
}
上 述 程 序 的 一 次 执 行 结 果 如 图 1.56 所 示 。
图 1.56
程 序 执 行 结 果
84
