级《算法设计与分析》Word文档格式.docx
《级《算法设计与分析》Word文档格式.docx》由会员分享，可在线阅读，更多相关《级《算法设计与分析》Word文档格式.docx（12页珍藏版）》请在冰豆网上搜索。
voidmain（）{
intsum=0;
inta,c,x,i;
intb=0;
a=30;
x=2;
c=0;
for（i=0;
i<
30;
i++）{
b=a*pow（x,c）;
sum=sum+b;
a=a-1;
c=c+1;
}
printf（"
sum=%d\n"
sum）；
}（4）程序运行结果的屏幕截图；
（5）算法分析（可以从算法复杂度、优缺点或改进方法等角度来分析）。
蛮力算法的应用有通用性|、启发性、实用性、准绳性的优点，但是缺点也很明显就是蛮力算法的效率不是很高。
2.分治算法（25分）
查找问题：
输入100个整数，使用分治算法实现折半查找，统计某个整数出现的次数。
这是一种将复杂难解的问题分割为规模和结构相同或相似的子问题，通过对简单问题的求解而达到对原问题的求解的目的的算法设计方法。
分治算法能够使原本纷繁复杂的问题变得清晰明朗，而且能够通过将问题的规模变小而降低问题求解的难度。
BINARY-SEARCH（A,T）
L<
--0
R<
---n-1
Whilel<
=r
Dom<
--（l+r）/2
IfT=A[m]
Thenreturnm
Elseif<
A[m]
Thenr<
--m-1
Elsel<
--m+1
Return-1
#include<
voidmain（）
{
intlow=0,high=99,x,a[100],i,k;
intSearch（intlow,inthigh,intx,inta[100]）;
//变量赋值初始化
printf（"
输入一百个数:
\n"
）;
for（i=0;
i<
100;
i++）
scanf（"
%d"
&
a[i]）;
输入要查找的数：
x）;
k=Search（low,high,x,a）;
%d\n"
k）;
}
intSearch（intlow,inthigh,intx,inta[100]）
intmid;
intk=0,j;
while（low<
=high）
{
mid=（low+high）/2;
if（a[mid]==x）
{
k++;
for（j=0;
j<
mid;
j++）
{
if（a[j]==x）
k++;
else
continue;
}
for（j=mid+1;
=high;
returnk;
}
elseif（x<
a[mid]）//顺序查找中，左边的数小于被分开的最右边界，则所找的数//在数组的左半部分，要缩小左部的范围
high=mid-1;
else
low=mid+1;
returnk;
}
（4）程序运行结果的屏幕截图；
分治算法将问题分解为了一些更小更容易解决的问题，它具有分解性、递归性、综合性的特点。
本题用先将问题进行折半分解，大大地提高了算法运行的效率，也使降低了代码的复杂性使其更容易被人理解。
令外它很好地应用了递归的特性，使问题得到了很好的划分和求解。
3.贪心算法（25分）
活动安排问题：
根据下表各个活动的时间，用贪心算法找出一个最大兼容活动集合。
活动编号
1
2
3
4
5
6
7
8
9
10
开始时间
12
11
13
结束时间
15
17
14
从问题的某一个初始解出发逐步逼近给定的目标，以尽可能快的地求得更好的解。
当达到某算法中的某一步不能再继续前进时，算法停止。
首先定义活动的开始时间和结束时间，然后问题进行细分求解，得到局部最优解，然后将各个开始时间和结束时间进行递增排序，最后得到最终解。
intActiveManage（intstartime[],intendtime[],inta[],intn）
//变量的初始化
intj=1;
intcount=1;
inti;
a[1]=1;
for（i=2;
=n;
i++）
if（startime[i]>
=endtime[j]）{
a[i]=1;
j=i;
count++;
elsea[i]=0;
returncount;
voidsort（intstartime[],intendtime[],intn）//递增排序各个开始活动时间和结束活动时间
inta,b;
inti,j;
for（i=1;
=n+1;
for（j=i+1;
j<
j++）
if（endtime[i]>
endtime[j]）
{a=endtime[i];
endtime[i]=endtime[j];
endtime[j]=a;
b=startime[i];
startime[i]=startime[j];
startime[j]=b;
inta[10];
intstartime[]={0,3,2,5,1,7,12,8,6,11,13};
//活动开始时间
intendtime[]={0,7,4,9,6,13,15,10,8,17,14};
//活动的结束时间
sort（startime,endtime,10）;
ActiveManage（startime,endtime,a,10）;
最大的兼容集合是：
"
=10;
if（a[i]==1）
{
printf（"
开始活动时间%d"
startime[i]）;
//运算后得到的最大兼容开间
\t结束活动时间%d"
endtime[i]）;
//运算后得到的最大兼容结束间
getchar（）;
贪心算法将待求解的问题分解成若干个子问题进行分步求解，且每一步只是根据贪心策略做出看似最好的选择，以期待得到最优解。
首先对每个子问题得到棋局部最优解，再将各个局部最优解整合成问题的解，它并不为了找到问题的全部解，也不迫于找到最优解，而是着眼于快速找到问题的近最优解，甚至得到全部最优解。
它在时间效率上具有明显的优势，其时间复杂度通常是线性二次多项式，但是以牺牲解的质量为代价。
4.回溯算法（25分）
0/1背包问题：
对给定容量的背包，分别输入n（n>
=10）个物品的重量、价值，然后用回溯算法求解使得总价值最大的装包方案。
从问题的解空间中搜索得到问题的可行解或者最优解是算法。
他的主题思想是通过对部分分解进行增量的构建搜索来得到可行解，在构建过程中，采用一种“试探性”的法则，如果当前构建得到的部分解可能被继续构建为一个可行解；
否则沿着解空间树回溯至该节点的父节点，并对下一个可行解进行沟建设搜索。
kNAPSACK（）
INITIACK（v）
For（i<
--0ton）
dor[i]<
---p[i]/w[i]
SORT（r,n）
--upbound<
--w_cur<
--p_cur<
---0
While>
=0
Doforeverynodeniinthe/layer
Dov[i]<
--ni
W_cur<
--cur+w[v[l]]
P_cur<
--p_cur+p[v[l]]
Ifw_cur<
wandp_cur+r[l]*（W-w_cur）>
upbound
Thenifvisacompletesolution
ThenUPDATE_SOLUTION（v）;
Else
--l+1
--w_cur-w[v[l]]
--p_cur-p[v[l]]
--l-1
#include<
intN;
//背包容量
intM;
//物品数
intweight[150];
//物品重量
intprice[150];
//物品价值
intx[100];
intBB=0;
intBA[100];
//当前最优解
//--------------------向解量进行初始化
voidbeiBao（intn）
{
inti,k,j;
for（i=1;
i<
i++）
x[i]=0;
k=1;
while（k>
=1）
x[k]=x[k]+1;
//第k个物品放入背包
if（x[k]<
=2&
&
k==M）
{//得到一个解，输出
inttempW=0;
//当前重量
inttempV=0;
//当前价值
for（i=1;
if（x[i]==1）
tempW+=weight[i
升级会员 