程序设计艺术与方法Word文件下载.docx
《程序设计艺术与方法Word文件下载.docx》由会员分享，可在线阅读，更多相关《程序设计艺术与方法Word文件下载.docx（17页珍藏版）》请在冰豆网上搜索。
srand（time（NULL））;
for（inti=0;
i<
10;
i++）
myV.push_back（rand（））;
sort（myV.begin（）,myV.end（）,sortup）;
vector<
:
iteratorit1;
for（it1=myV.begin（）;
it1!
=myV.end（）;
it1++）
{
cout<
<
（*it1）<
setw（6）;
}
endl;
intmin=myV[0];
for（it1=myV.begin（）+1;
if（（*it1）<
min）min=（*it1）;
"
最小元素为"
<
min<
intmax=myV[0];
if（（*it1）>
max）max=（*it1）;
最大元素为"
max<
intvalue=rand（）;
it1=find（myV.begin（）,myV.end（）,value）;
if（（*it1）==value）
找到了这个随机数"
endl;
else
没有找到这个随机数"
myV.insert（myV.end（）,value）;
插入尾部的随机数为"
value<
\n"
intt=rand（）;
myV.insert（myV.begin（）,t）;
插入头部的随机数为"
t<
myV.pop_back（）;
myV.clear（）;
if（myV.empty（））
cout<
"
It'
sempty!
endl;
system（"
PAUSE"
）;
return0;
}
运行截图：
2练习泛型算法的使用：
list>
//#inclued<
typedeflist<
lin;
intvalue[]={1,2,3,4,5};
voidprint（lin&
l）
inti;
lin:
iteratorlit;
for（lit=l.begin（）;
lit!
=l.end（）;
lit++）
cout<
（*lit）<
;
boolsortsp（intv1,intv2）
returnv1>
intmain（）{
linlin2;
lin2.push_front（3）;
lin2.push_front（4）;
lin2.insert（lin2.begin（）,value,value+5）;
lin2内的元素为：
print（lin2）;
lin2.sort（）;
排序后的lin2:
lin2.push_front（10）;
在list头部插入10之后的结果：
lin2.remove（6）;
删除一个数后的lin1:
system（"
return0;
实验二搜索算法的实现
1.实验目的
（1）掌握宽度优先搜索算法。
（2）掌握深度优先搜索算法。
2.试验设备硬件环境：
3.试验内容
（1）将书上的走迷宫代码上机运行并检验结果，并注意体会搜索的思想。
（2）八皇后问题：
在一个国际象棋棋盘上放八个皇后，使得任何两个皇后之间不相互攻击，求出所有的布棋方法。
上机运行并检验结果。
思考：
将此题推广到N皇后的情况，检验在N比较大的情况下，比方说N=16的时候，你的程序能否快速的求出结果，如果不能，思考有什么方法能够优化算法。
（3）骑士游历问题：
在国际棋盘上使一个骑士遍历所有的格子一遍且仅一遍，对于任意给定的顶点，输出一条符合上述要求的路径。
（4）倒水问题：
给定2个没有刻度容器，对于任意给定的容积，求出如何只用两个瓶装出L升的水，如果可以，输出步骤，如果不可以，请输出NoSolution。
（2）八皇后问题
math.h>
intsum=0;
intupperlimit=1;
voidcompare（introw,intld,intrd）
if（row!
=upperlimit）
intpos=upperlimit&
~（row|ld|rd）;
while（pos!
=0）
intp=pos&
-pos;
pos-=p;
compare（row+p,（ld+p）<
1,（rd+p）>
>
1）;
else{sum++;
intmain（）
intn;
请输入皇后的个数:
cin>
n;
upperlimit=（upperlimit<
n）-1;
compare（0,0,0）;
问题的解如下:
sum<
（4）倒水问题
4.倒水问题：
#include"
stdio.h"
intca,cb,cc,x,y;
while（scanf（"
%d%d%d"
&
ca,&
cb,&
cc）!
=EOF）
if（cb==cc）
{printf（"
fillB\n"
elseif（ca==cc）
printf（"
fillA\n"
pourAB\n"
else
x=y=0;
if（ca<
cc）
while
（1）
{if（y==0）
y=cb;
if（y>
ca-x）//如果b中的水大于a中的剩余容积，就把a灌满//
y-=ca-x;
x=ca;
pourBA\n"
else//如果b中的水小于a中的剩余容积，那么把b中的水全加入a//
x+=y;
y=0;
if（y==cc）//如果b中的水已经和cc相等，那就结束//
break;
}
if（ca==x）//如果a中的水满了，就把a倒空//
x=0;
emptyA\n"
if（x==0）
if（x>
cb-y）//如果a中的水大于b中的剩余容积，就把b灌满//
x-=cb-y;
else//如果a中的水小于b中的剩余容积，那么把a中的水全加入b//
y+=x;
if（y==cb）//如果b中的水满了，就把b倒空//
emptyB\n"
success\n"
运行截图:
实验三计算几何算法的实现
1.实验目的
（1）理解线段的性质、叉积和有向面积。
（2）掌握寻找凸包的算法。
（3）综合运用计算几何和搜索中的知识求解有关问题。
2.试验设备硬件环境：
PC计算机软件环
操作系统：
Devcpp/gnuc++3.试验内容
（1）将讲义第三章第三节中的凸包代码上机运行并检验结果。
（2）完成讲义第三章的课后习题，上机运行并检验结果。
（3）思考：
判线段相交时，如果有个线段的端点在另一条线段上，注意可能与另一条线段上的端点重合，思考这样的情况怎么办。
（4）房间短路问题：
给顶一个内含阻碍墙的房间，求解出一条从起点到终点的短路径。
房间的边界固定在x=0,x=10,y=0和y=10。
起点和重点固定在（0,5）和（10,5）。
房间里还有0到18个墙，每个墙有两个门。
输入给定的墙的个数，每个墙的x位置和两个门的y坐标区间，输出最短路的长度。
（4）房间短路问题
#include<
utility>
usingnamespacestd;
typedefpair<
double,double>
POINT;
//线段
doubledirection（POINTp,POINTp1,POINTp2）{
POINTv1,v2;
v1.first=p2.first-p1.first;
v1.second=p2.second-p1.first;
v2.first=p1.first-p.first;
v2.second=p1.second-p.second;
returnv1.first*v2.second-v1.second*v2.second;
boolon_segment（POINTp,POINTp1,POINTp2）{
doublemin_x=p1.first<
p2.first?
p1.first:
p2.first;
doublemax_x=p1.first>
doublemin_y=p1.second<
p2.second?
p1.second:
p2.second;
doublemax_y=p1.second>
if（p.first>
=min_x&
&
p.first<
max_x&
p.second>
=
min_y&
p.second<
=max_y）
returntrue;
returnfalse;
POINTstartPoint;
boolsortByPolorAngle（constPOINT&
p1,constPOINT&
p2）
doubled=direction（startPoint,p1,p2）;
if（d<
0）returntrue;
if（d>
0）returnfalse;
if（d==0&
on_segment（startPoint,p1,p2））returntrue;
on_segment（p2,startPoint,p1））returntrue;
voidfind_convex_hull（vector<
POINT>
point）
{
POINTp0=point[0];
intk=0;
for（inti=0;
point.size（）;
if（point[i].second<
p0.second||
point[i].second==p0.second&
point[i].first<
p0.first）{
p0=point[i];
k=i;
point.erase（point.begin（）+k）;
point.insert（point.begin（）,p0）;
convex_hull;
do{
convex_hull.push_back（point[0]）;
startPoint=point[0];
point.erase（point.begin（））;
sort（point.begin（）,point.end（）,sortByPolorAngle）;
if（point[0]==convex_hull[0]）break;
point.push_back（convex_hull[convex_hull.size（）-1]）;
}while
（1）;
for（intj=0;
j<
convex_hull.size（）;
j++）{
convex_hull[j].first<
'
'
convex_hull[j].second<
}}
intmain（）{
pv;
doublex,y;
inti;
请输入10个点<
x,y>
：
for（i=1;
=10;
i++）{
No."
x>
y;
pv.push_back（make_pair（x,y））;
find_convex_hull（pv）;
Pause"
}运行截图：
实验四动态规划算法的实现
1.实验目的
（1）理解动态规划的基本思想、动态规划算法的基本步骤。
（2）掌握动态规划算法实际步骤。
3.试验内容
（1）求两个字符串的最长公共子序列。
X的一个子序列是相应于X下标序列{1,2,…,m}的一个子序列，求解两个序列的所有子序列中长度大的，例如输入：
pear,peach输出：
pea。
（2）给定两个字符串a和b，现将串a通过变换变为串b，可用的操作为，删除串a中的一个字符；
在串a的某个位置插入一个元素；
将串a中的某个字母换为另一个字母。
对于任意的串a和串b，输出少多少次能够将串变为串b。
输出变换的步骤。
（3）输入一个矩阵，计算所有的子矩阵中和的大值。
例如，输入0-2-7092-62-41-41-180-2输出为：
15思考：
当矩阵很大时，比如100*100的矩阵，你的程序还能够很快的得出结果吗，如果不能，请思考如何用动态规划的思想解决
（1）求两个字符串的最长公共子序列
cstring>
#defineN100
//str1存储字符串x，str2存储字符串y
charstr1[N],str2[N];
//lcs存储最长公共子序列
charlcs[N];
//c[i][j]存储str1[1...i]与str2[1...j]的最长公共子序列的长度
intc[N][N];
//flag[i][j]==0为str1[i]==str2[j]
//flag[i][j]==1为c[i-1][j]>
=s[i][j-1]
//flag[i][j]==-1为c[i-1][j]<
s[i][j-1]
intflag[N][N];
//求长度
intLCSLength（char*x,char*y）
inti,j;
//分别取得x,y的长度
intm=strlen（x）;
intn=strlen（y）;
=m;
c[i][0]=0;
for（i=0;
=n;
c[0][i]=0;
for（j=1;
j++）
if（x[i-1]==y[j-1]）
c[i][j]=c[i-1][j-1]+1;
flag[i][j]=0;
elseif（c[i-1][j]>
=c[i][j-1]）
c[i][j]=c[i-1][j];
flag[i][j]=1;
c[i][j]=c[i][j-1];
flag[i][j]=-1;
returnc[m][n];
//求出最长公共子序列
char*getLCS（char*x,char*y,intlen,char*lcs）
inti=strlen（x）;
intj=strlen（y）;
while（i&
j）
if（flag[i][j]==0）
lcs[--len]=x[i-1];
i--;
j--;
elseif（flag[i][j]==1）
returnlcs;
请输入字符串x：
str1;
请输入字符串y：
str2;
intlcsLen=LCSLength（str1,str2）;
最长公共子序列长度：
lcsLen<
char*p=getLCS（str1,str2,lcsLen,lcs）;
最长公共子序列为：
lcsLen;
lcs[i]<
升级会员 