写在开头:
算法真的学的头大,一眼望不到算法的尽头。yls的算法作业也真是暴多,这一学期光算法就写了50+篇报告,期中的时候看别人统计出来的时候真的破防了。但是这么多作业也不算白写,给我打的平时分我还是很满意滴。
声明:本人算法入门水平,佬们没必要浪费时间看这坨代码。
如果有任何违规的地方,请第一时间联系我,我会立即删除本文。
实验一:递归与分治
实验1.3 快速排序及第k小数
1.算法描述:
对于一个已经给出的数组,通过输入一个合法区间[l,r],以及一个数k,先找出[l,r]中第k小的数并输出,再使用快速排序对[l,r]这个区间进行排序,最后输出已经排序好的数值序列。
2.算法思路:
快速排序实际上就是通过一次次地选出一个个参考值,并根据这个参考值,将比他小的排在他左边,比他大的排在他右边,这样进行调整。我们可以先实现调整函数int arrange(int l,int r)以a[l]作为临时参照物,把在[l,r]中比a[l]小的放到它左边,比它大的放在他右边,并最终确定a[l]所在的位置。那么快速排序void quick_sort(int l,int r)就可以通过每一次得知a[l]的位置,将原序列分为三段,除了a[l]这个数不用处理以外,剩下的两段,一个都比他小,另一个都比他大,都要继续调整,即递归调用自己,直到全部因为l>=r而结束后,原序列变为有序序列。而通过arrange 返回的参数到左边界l的距离实际上就是参考数在序列中的序号,通过将这个序号与k进行对比,我们可以得出接下来我们要查找哪边。
3.代码实现:
#include <iostream>
using namespace std;
int a[105]={0,9,2,7,4,5,6,3,8,1};
void swap(int i,int j)
{
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
int arrange(int l,int r)
{
int temp = a[l];
while(l<r)
{
while(a[r]>=temp&&l<r)
r--;
if(l<r)
swap(l,r);
while(a[l]<=temp&&l<r)
l++;
if(l<r)
swap(l,r);
}
return l;//返回参考点的下标
}
void quick_sort(int l,int r)
{
if(l >= r)
return;
else
{
int mid = arrange(l, r);
quick_sort(l,mid-1);
quick_sort(mid+1,r);
}
}
int quick_sort_mink(int l,int r,int k)
{
int mid = arrange(l, r);
if((mid-l+1) == k)
{
return a[mid];
//若为第k小的,则返回
}
else if ((mid-l+1) > k)
{
return quick_sort_mink(l, mid-1, k);
//若超过第k个,则查找l到mid-1,裁剪[mid,r],因为裁剪的是大的值,所以不改变k
}
else
{
return quick_sort_mink(mid+1, r, k-(mid-l+1));
//若小于k,则将[l,mid]共(mid-l+1)个数全部裁剪,因而从查找原序列的第k个,变为查找新序列的第k-(mid-l+1)个。
}
}
int main()
{
int k,l,r;
cout<<"请输入左边界l的值:";
cin>>l;
cout<<"请输入左边界r的值:";
cin>>r;
if(l>r)
{
cout<<"l不能比r大!!!"<<endl;
return -1;
}
cout<<"请输入k的值:";
cin>>k;
if(r-l+1<k)
{
cout<<"总共就"<<r-l+1<<"个数,你让我找第"<<k<<"小的数?"<<endl;
return -1;
}
cout<<"第"<<k<<"小的数是:"<<quick_sort_mink(l, r, k)<<endl;
quick_sort(l, r);
cout<<"排序后的结果为:";
for(int i=l;i<=r;i++)
cout<<a[i]<<" ";
cout<<endl;
return 0;
}
4.算法优化:
快速排序的最坏时间复杂度为O(),比如对于{1,2,3,4}这样的序列进行快速排序,就会出现这样的最坏时间复杂度。对于最坏的情况,T(n) = T(n-1)+T(1)+n,最坏时间复杂度就是由这样的不对等分配导致的。而对于最好的情况,T(n) = 2T(n/2)+n,这样最好时间复杂度就是O(
).所以如何选取一个合理的参照数字,选到的数字越靠近中间数越好,就是优化快排的关键。
1.从数组的头部,尾部和中间,这三个数里面选择既不是最大的也不是最小的数作为参照数。
2.使用随机数产生参照数的下标,随机数还是很能打的。
实验 1.5 棋盘覆盖问题
1.题干:
在一个
×
个方格组成的棋盘中,恰有一个方格与其它方格不同,称该方格为一特殊方格,且称该棋盘为一特殊棋盘。在棋盘覆盖问题中,要用图示的
4种不同形态的L型骨牌覆盖给定的特殊棋盘上除特殊方格以外的所有方格,且任何2个L型骨牌不得重叠覆盖。
2.算法描述:
对于一组给出的k,x,y。输出一个除了(x,y)以外,其他方块都不重叠地被骨牌给覆盖了的边长为的正方形棋盘情况图。
3.算法思路:
对于正方形棋盘,我们将其均分成四块,其中1块有特殊方块,另外3块没有特殊方块,为了能使递归进行下去,我们必须在另外3块中创造出特殊方块(或者说已经被占领的方块)。
创造情况如下图:
1.特殊点在左上角:
红色为新的特殊点;
2.特殊点在右上角:
蓝色为新的特殊点;
3.特殊点在左下角:
橙黄色的为新的特殊点。
4.特殊点在右下角,则左上角区块的最右下角的方块,右上角区块的最左下角的方块,左下角区块的最右上角的方块,作为新的特殊点。
最后,若区块的尺寸缩小到单位长度1时,结束递归。
4.代码实现:
#include <iostream>
using namespace std;
int map[105][105]={0};
void draw(int x,int y,int lx,int ly,int l)//(x,y)为特殊点的坐标,(lx,ly)为正方形棋盘的左上角的坐标,l为棋盘的边长
{
if(l == 1)
return ;
int halfx = lx+l/2-1,halfy = ly+l/2-1;
if(x<=halfx)
{
if(y<=halfy)//若特殊点在左上角,则在最中间的2x2个方格中放入一个d类骨牌,并将放入的骨牌当作新的特殊点
{
map[halfx][halfy+1] = 4;//4代表此方块被d类骨牌占领
map[halfx+1][halfy] = 4;
map[halfx+1][halfy+1] = 4;
draw(x, y, lx, ly, l/2);
draw(halfx,halfy+1,lx,halfy+1,l/2);
draw(halfx+1,halfy,halfx+1,ly,l/2);
draw(halfx+1,halfy+1,halfx+1,halfy+1,l/2);
}
else//若特殊点在右上角,则在最中间的2x2个方格中放入一个c类骨牌,并将放入的骨牌当作新的特殊点
{
map[halfx][halfy] = 3;//3代表此方块被c类骨牌占领
map[halfx+1][halfy] = 3;
map[halfx+1][halfy+1] = 3;
draw(halfx, halfy, lx, ly, l/2);
draw(x,y,lx,halfy+1,l/2);
draw(halfx+1,halfy,halfx+1,ly,l/2);
draw(halfx+1,halfy+1,halfx+1,halfy+1,l/2);
}
}
else
{
if(y<=halfy)//若特殊点在左下角,则在最中间的2x2个方格中放入一个b类骨牌,并将放入的骨牌当作新的特殊点
{
map[halfx][halfy] = 2;//2代表此方块被b类骨牌占领
map[halfx][halfy+1] = 2;
map[halfx+1][halfy+1] = 2;
draw(halfx, halfy, lx, ly, l/2);
draw(halfx,halfy+1,lx,halfy+1,l/2);
draw(x,y,halfx+1,ly,l/2);
draw(halfx+1,halfy+1,halfx+1,halfy+1,l/2);
}
else//若特殊点在右下角,则在最中间的2x2个方格中放入一个a类骨牌,并将放入的骨牌当作新的特殊点
{
map[halfx][halfy] = 1;//1代表此方块被a类骨牌占领
map[halfx][halfy+1] = 1;
map[halfx+1][halfy] = 1;
draw(halfx, halfy, lx, ly, l/2);
draw(halfx,halfy+1,lx,halfy+1,l/2);
draw(halfx+1,halfy,halfx+1,ly,l/2);
draw(x,y,halfx+1,halfy+1,l/2);
}
}
}
int quickPower(int a, int b)//是求a的b次方
{
int ans = 1, base = a;//ans为答案,base为a^(2^n)
while(b > 0)//b是一个变化的二进制数,如果还没有用完
{
if(b & 1)//&是位运算,b&1表示b在二进制下最后一位是不是1,如果是:
ans *= base;//把ans乘上对应的a^(2^n)
base *= base;//base自乘,由a^(2^n)变成a^(2^(n+1))
b >>= 1;//位运算,b右移一位,如101变成10(把最右边的1移掉了),10010变成1001。现在b在二进制下最后一位是刚刚的倒数第二位。结合上面b & 1食用更佳
}
return ans;
}
int main()
{
int k,x,y,l;
cout<<"请输入k的值(1~6):";
cin>>k;
if(k<1||k>6)
{
cout<<"k的取值非法,请遵守提示!!!"<<endl;
return -1;
}
cout<<"请输入特殊方格的x坐标(1<=x<=2^k):";
cin>>x;
cout<<"请输入特殊方格的y坐标(1<=y<=2^k):";
cin>>y;
if(x<1||y<1)
{
cout<<"横、纵坐标必须大于0哦。"<<endl;
return -1;
}
l = quickPower(2, k);
if(x>l||y>l)
{
cout<<"边长才为"<<l<<",你叫我上哪里去找("<<x<<","<<y<<")?"<<endl;
return -1;
}
draw(x, y, 1, 1, l);
for(int i=1;i<=l;i++)
{
for(int j=1;j<=l;j++)
{
cout<<map[i][j]<<" ";
}
cout<<endl;
}
return 0;
}
5.算法优化:
我没想到有哪里可以优化的。。。
实验四:动态规划
实验4.2 计算矩阵连乘积
1.题干:
在科学计算中经常要计算矩阵的乘积。矩阵A和B可乘的条件是矩阵A的列数等于矩阵B的行数。若A是一个p×q的矩阵,B是一个q×r的矩阵,则其乘积C=AB是一个p×r的矩阵。由该公式知计算C=AB总共需要pqr次的数乘。其标准计算公式为:
现在的问题是,给定n个矩阵{A1,A2,…,An}。其中Ai与Ai+1是可乘的,i=1,2,…,n-1。要求计算出这n个矩阵的连乘积A1A2…An的最少数乘次数。
2.算法描述:
对于输入的矩阵个数n,以及各个矩阵的行数,列数。得到一个最小的乘积次数以及对应的方案。
3.算法思路:
采用动态规划,写出状态转移方程:
m[i][j]表示从第i个矩阵乘到第j个矩阵所需的最少乘法次数。
随后进行动态规划,注意因为m[i][j]的计算需要m[i][k]和m[k+1][j]所以必须先将i,j相差小的给计算出来,才能继续算i,j相差大的。
4.代码实现:
#include <iostream>
using namespace std;
int s[105][105];
void showhow(int l,int r)//展示分割矩阵
{
if(l>=r)
return;
else
{
cout<<l<<"号矩阵到"<<r<<"号矩阵的分割矩阵为:"<<s[l][r]<<endl;
showhow(l,s[l][r]);
showhow(s[l][r]+1,r);
}
}
int main()
{
int n,p[105],i,j,r,k,cnt[105][105],tempcnt;
cout<<"请输入矩阵的个数(1<n<101):";
cin>>n;
if(n<2||n>100)
{
cout<<"矩阵个数非法!!!"<<endl;
return -1;
}
cout<<"请输入第1个矩阵的行数:";
cin>>p[0];
if(p[0]<1)
{
cout<<"行数非法!!!"<<endl;
return -1;
}
for(i = 1;i<n;i++)
{
cout<<"请输入第"<<i<<"个矩阵的列数(同时也是第"<<i+1<<"个矩阵的行数):";
cin>>p[i];
if(p[i]<1)
{
cout<<"列数非法!!!"<<endl;
return -1;
}
}
cout<<"请输入第"<<i<<"个矩阵的列数:";
cin>>p[n];
if(p[n]<1)
{
cout<<"列数非法!!!"<<endl;
return -1;
}
for(i = 1;i<=n;i++)
{
cnt[i][i]=0;
s[i][i]=0;
}
i = 1;
for(r=1;i+r<=n;r++)//i与j相差多少,并保证j不超过n
{
for(;i<n;i++)
{
j = i+r;
cnt[i][j] = cnt[i+1][j]+p[i-1]*p[i]*p[j];//初始化分法
s[i][j] = i;
for(k=i+1;k<j;k++)
{
tempcnt = cnt[i][k]+cnt[k+1][j]+p[i-1]*p[k]*p[j];//查找是否有更好的分法
if(tempcnt<cnt[i][j])
{
cnt[i][j] = tempcnt;
s[i][j] = k;
}
}
}
i=1;
}
cout<<"最少乘积次数为:"<<cnt[1][n]<<endl;
showhow(1, n);
return 0;
}
5.算法优化:
没什么想法。。。
实验4.4 防卫导弹
1.题干:
一种新型的防卫导弹可截击多个攻击导弹。它可以向前飞行,也可以用很快的速度向下飞行,可以毫无损伤地截击进攻导弹,但不可以向后或向上飞行。但有一个缺点,尽管它发射时可以达到任意高度,但它只能截击比它上次截击导弹时所处高度低或者高度相同的导弹。现对这种新型防卫导弹进行测试,在每一次测试中,发射一系列的测试导弹(这些导弹发射的间隔时间固定,飞行速度相同),该防卫导弹所能获得的信息包括各进攻导弹的高度,以及它们发射次序。现要求编一程序,求在每次测试中,该防卫导弹最多能截击的进攻导弹数量,一个导弹能被截击应满足下列两个条件之一:
a)它是该次测试中第一个被防卫导弹截击的导弹;
b)它是在上一次被截击导弹的发射后发射,且高度不大于上一次被截击导弹的高度的导弹。
2.算法描述:
对于输入的导弹个数n,以及一系列导弹的高度h[n],输出能拦截的最大导弹个数。
3.算法思路:
本题为动态规划题,初始化dp[i-1] = 1。写出动态方程:若有比i-1号导弹更低的导弹,则dp[i-1] = max(dp[i-1],dp[j]+1)。
dp[i]表示在拦截i号导弹的前提下,所能拦截的最大导弹个数,最终在所有情况中找出拦截导弹个数最多的情况。
4.代码实现:
#include <iostream>
using namespace std;
int maxcnt(int a[],int l,int r)
{
if(l==r)
{
return a[l];
}
else
{
int mid = (l+r)/2;
return max(maxcnt(a,l,mid),maxcnt(a,mid+1,r));
}
}
int max(int a,int b)
{
return a>=b?a:b;
}
int main()
{
int n,h[105],dp[105],i,j;
cout<<"请输入导弹的个数(小于101个):";
cin>>n;
if(n<1||n>100)
{
cout<<"非法导弹个数!!!"<<endl;
return -1;
}
for(i=1;i<=n;i++)
{
cout<<"请输入第"<<i<<"个导弹的高度:";
cin>>h[i];
dp[i] = 1;
if(h[i]<1)
{
cout<<"非法导弹高度!!!"<<endl;
return -1;
}
}
for(i= n;i>1;i--)
{
for(j=i;j<=n;j++)
{
if(h[i-1]>=h[j])//若第i-1个导弹的高度大于等于第j个的导弹的高度,则取两者能拦截的大者
{
dp[i-1] = max(dp[i-1],dp[j]+1);
}
}
}
cout<<"最多能拦截"<<maxcnt(dp, 1, n)<<"个导弹"<<endl;
return 0;
}
5.算法优化:
没啥想法。。。
实验4.9 皇宫看守
1.题干:
太平王世子事件后,陆小凤成了皇上特聘的御前一品侍卫。皇宫以午门为起点,直到后宫嫔妃们的寝宫,呈一棵树的形状;某些宫殿间可以互相望见。大内保卫森严,三步一岗,五步一哨,每个宫殿都要有人全天候看守,在不同的宫殿安排看守所需的费用不同。可是陆小凤手上的经费不足,无论如何也没法在每个宫殿都安置留守侍卫。
请你编程计算帮助陆小凤布置侍卫,在看守全部宫殿的前提下,使得花费的经费最少。
2.算法描述:
对于输入的节点个数n,以及各个结点的相关信息:此节点要花费的经费,子节点的个数,以及各个子节点的序号(保存在trees数组中),输出一个最小费用。
3.算法思路:
本实验依旧采用动态规划的方法。用dp[i]表示看守以i为根的皇宫所需要的最小经费。
对于这种只有根结点的树,他的dp = cost。
对于其他的树,则需要比较:1.根节点的花费+子代的子代的dp花费;2.子代的dp花费。最后取二者小的那一方dp[i] = min(trees[i].cost+sum,childcost(trees, i))
4.代码实现:
#include <iostream>
using namespace std;
class tree
{
public:
int cost;
int childnum;
int childid[105];
tree(int c,int cn)
{
this->cost = c;
this->childnum = cn;
for(int i=1;i<=cn;i++)
{
cin>>childid[i];
}
}
tree(){}
};
int childcost(tree a[],int id)//求出编号为id的所有孩子的最小经费之和
{
int i,sum=0;
for(i=1;i<=a[id].childnum;i++)
{
sum+=a[a[id].childid[i]].cost;
}
return sum;
}
int max(int a,int b)
{
return a>b?a:b;
}
int maxone(int a[],int l,int r)//二分法求数组最大值
{
if(l == r)
return a[l];
else
{
int mid = (l+r)/2;
return max(maxone(a,l,mid),maxone(a, mid+1, r));
}
}
int min(int a,int b)
{
return a<=b?a:b;
}
int main()
{
int n,i,tempc,tempcn,num,dp[105];//dp[i]表示看守以i为根的树所需要的最小经费
tree trees[105];
cout<<"请输入结点的个数(小于101):";
cin>>n;
for(i=1;i<=n;i++)
{
cout<<"请输入"<<i<<"号结点的相关信息:";
cin>>tempc>>tempcn;
trees[i] = tree(tempc,tempcn);
}
for(num=0;num<n-1;num++)
{
for(i = 1;i<=n;i++)
{
if(trees[i].childnum == num)
{
if(num == 0)
{
dp[i] = trees[i].cost;
}
else
{
int sum = 0;
for(int j = 1;j<=trees[i].childnum;j++)
{
sum+= childcost(trees, trees[i].childid[j]);
}
dp[i] = min(trees[i].cost+sum,childcost(trees, i));//要么自己的耗费+孩子的孩子的耗费之和,要么孩子的耗费之和,二者取小
}
}
}
}
cout<<maxone(dp,1,n)<<endl;//在dp数组中开销最大的肯定是根结点。
return 0;
}
5.算法优化:
我不到怎么优化啊。。。
实验五:贪心算法和随机算法
实验5.1 背包问题
1.题干:
有一个背包,背包容量是M=150。有7个物品,物品可以分割成任意大小。
要求尽可能让装入背包中的物品总价值最大,但不能超过总容量。
物品
A
B
C
D
E
F
G
重量
35
30
60
50
40
10
25
价值
10
40
30
50
35
40
30
2.算法描述:
对于给出的背包容量m,物品个数n,以及各个物品的重量w和总价值v,输出背包能承载的最大总价值,以及放入物品的种类和多少。
3.算法思路:
采用贪心算法,对所有物品按照单位重量的价值进行排序,优先选单位重量的价值高者的全部,最后再取剩下的单位重量的价值高者的部分。
4.代码实现:
#include <iostream>
using namespace std;
void swap(int a[],int i1,int i2)
{
int temp = a[i1];
a[i1] = a[i2];
a[i2] = temp;
return;
}
void swap(double a[],int i1,int i2)
{
double temp = a[i1];
a[i1] = a[i2];
a[i2] = temp;
return;
}
int main()
{
int n,index[105],w[105],v[105],m,i,j;
double sum = 0,v_per_w[105];
cout<<"请输入背包的容量:";
cin>>m;
cout<<"请输入物品的个数:";
cin>>n;
for(i = 1;i<=n;i++)
{
index[i] = i;
cout<<"请输入"<<i<<"号物品的重量:";
cin>>w[i];
cout<<"请输入"<<i<<"号物品的总价值:";
cin>>v[i];
v_per_w[i] = (1.0*v[i])/w[i];
}
for(i=1;i<n;i++)
{
int max = i;
for(j=i+1;j<=n;j++)
{
if(v_per_w[j]>v_per_w[max])
max = j;
}
if(max != i)
{
swap(index,i,max);
swap(w,i,max);
swap(v,i,max);
swap(v_per_w,i,max);
}
cout<<v_per_w[i]<<endl;
}
i=1;
while(m>w[i])
{
sum+=v[i];
m-=w[i];
i++;
}
sum+= (v_per_w[i]*m);
double percent = (m*1.0)/w[i];
cout<<"总价值最大为:"<<sum<<endl;
cout<<"方案为:"<<endl;
for(int j=1;j<i;j++)
{
cout<<index[j]<<"号物品取全部"<<endl;
}
cout<<index[i]<<"号物品取"<<percent<<endl;
return 0;
}
5.算法优化:
这玩意真没有优化的必要了吧。。。
实验5.2 照亮的山景
1.题干:
在一片山的上空,高度为T处有N个处于不同位置的灯泡,如图。如果山的边界上某一点于某灯i的连线不经过山的其它点,我们称灯i可以照亮该点。开尽量少的灯,使得整个山景都被照亮。山被表示成有m个转折点的折线。
提示:照亮整个山景相当于照亮每一个转折点。
2.算法描述:
对于输入的灯泡高度t,灯泡个数n,每个灯泡的横坐标l_x,折点个数m,每个折点的坐标(xi,yi),输出最少的开灯组合。
3.算法思路:
通过计算灯泡到折点的斜率来确定哪些点能被这个灯泡照到:对于x大于灯泡的横坐标l_x的点,后面能照到的折点和灯泡构成的直线的斜率为非减序列;而对于x小于灯泡横坐标l_x的点,前面能照到的折点和灯泡构成的直线的斜率为非递增序列。
1.
2.
3.
4.
5.
6.
7.
确定好每个灯能照到哪些点后,这个问题就变成了,如何取子集,使这些子集的交集为全集,且子集个数最少。这好像是一个NPC问题,目前没有多项式复杂度的解法,所以我采用模拟退火算法这种启发式算法来求解。效果也还可以。
4.代码实现:
#include <iostream>
using namespace std;
int cnt[105],details[105][105],a[105]={0};//cnt[k]表示k号灯泡能照到的折点的个数,details[k][]是具体哪个折点能被k号灯泡照到
double check(int get[],int n,int m)//对于一种亮灯泡的方案get[],计算这种方案能照亮的折点的百分比
{
int i,j,count=0;
for(i=1;i<=m;i++)
{
a[i] = 0;
}
for(i=1;i<=n;i++)
{
if(get[i] == 1)
{
for(j=1;j<=cnt[i];j++)
{
a[details[i][j]] = 1;
}
}
}
for(i=1;i<=m;i++)
{
if(a[i] == 1)
{
count++;
}
}
double percent = (double)((1.0*count)/m);
return percent;
}
int main()
{
int t,n,m,l_x[105],x[105],y[105],l,r,i;
cout<<"请输入灯泡的高度T以及灯泡的个数N:"<<endl;
cin>>t>>n;
cout<<"请输入"<<n<<"个灯泡的横坐标:"<<endl;
for(i=1;i<=n;i++)
{
cin>>l_x[i];
}
cout<<"请输入折点的个数:"<<endl;
cin>>m;
cout<<"请输入"<<m<<"个折点的坐标(请按横坐标依次增大的顺序输入):"<<endl;
for(i=1;i<=m;i++)
{
cin>>x[i]>>y[i];
}
for(int k=1;k<=n;k++)
{
r=1;
while(l_x[k]>x[r])//找到第一个横坐标大于等于这个灯泡的点
r++;
if(l_x[k] == x[r])//如果这个点正好在灯泡下方,此时斜率为∞,分母为0会报错,所以要特殊处理
{
cnt[k]++;
details[k][cnt[k]] = r;//记录这个点
l = r-1;//设置左边的起点
r = r+1;//设置右边的起点
}
else//这个点不在灯泡正下方
{
l = r-1;//设置左边的起点
r = r;//设置右边的起点
}
if(r<=m)//如果右边还有点
{
double k_board = (1.0*(t-y[r]))/(l_x[k]-x[r]);//计算标记点和灯泡组成的直线的斜率
cnt[k]++;
details[k][cnt[k]] = r;
for(i=r+1;i<=m;i++)
{
double temp_k = (1.0*(t-y[i]))/(l_x[k]-x[i]);
if(temp_k>=k_board)//若后面的斜率变大了,那么就更新屏障的斜率
{
cnt[k]++;
details[k][cnt[k]] = i;
k_board = temp_k;
}
}
}
if(l>0)//如果左边还有点
{
double k_board = (1.0*(t-y[l]))/(l_x[k]-x[l]);
cnt[k]++;
details[k][cnt[k]] = l;
for(i=l-1;i>0;i--)
{
double temp_k = (1.0*(t-y[i]))/(l_x[k]-x[i]);
if(temp_k<=k_board)//若前面的斜率变小了,那么就更新屏障的斜率
{
cnt[k]++;
details[k][cnt[k]] = i;
k_board = temp_k;
}
}
}
}
//模拟退火部分
int bestget[105]={0},tempget[105]={0},nowget[105]={0},bestsize=0,tempsize=0,nowsize=0;
//best/temp/nowget分别为最佳,暂时,目前的亮灯方案。best/temp/nowsize分别为最佳,暂时,目前的亮灯个数
double temperature = 200,a = 0.99,bestmax=0,tempmax=0,nowmax=0;//best/temp/nowget分别为最佳,暂时,目前的照到的折点的百分比。
while(temperature > 0.1)
{
for(i=1;i<=100;i++)
{
int random_index = (int)(rand()%n)+1;
nowget[random_index] = (nowget[random_index]+1)%2;
nowmax = check(nowget, n, m);
nowsize = 0;
for(int j=1;j<=m;j++)
{
if(nowget[j])
nowsize++;
}
if(nowmax>=tempmax||(tempmax - nowmax)/temperature>(1.0*rand())/RAND_MAX)
{
if((nowmax == tempmax) && (nowsize > tempsize))
continue;
tempmax = nowmax;
tempsize = nowsize;
for(int j=1;j<=n;j++)
{
tempget[j] = nowget[j];
}
}
}
if(tempmax>=bestmax)
{
if((tempmax == bestmax) && (tempsize > bestsize))
continue;
bestmax = tempmax;
bestsize = tempsize;
for(int j=1;j<=n;j++)
{
bestget[j] = tempget[j];
}
}
temperature*=a;
}
for(i=1;i<=n;i++)
{
cout<<bestget[i]<<" ";
}
cout<<endl;
return 0;
}
5.算法优化:
模拟退火部分的参数应该可以调整优化,但是我不是很懂参数设置。
实验5.3 搬桌子问题
1.题干:
某教学大楼一层有n个教室,从左到右依次编号为1、2、…、n。现在要把一些课桌从某些教室搬到另外一些教室,每张桌子都是从编号较小的教室搬到编号较大的教室,每一趟,都是从左到右走,搬完一张课桌后,可以继续从当前位置或往右走搬另一张桌子。输入数据:先输入n、m,然后紧接着m行输入这m张要搬课桌的起始教室和目标教室。输出数据:最少需要跑几趟。
2.算法描述:
对于输入的教室个数n,桌子个数m,以及各个桌子的起始教室start和目标教室end,给出全部搬完的最少的趟数。
3.算法思路:
采用贪心算法,优先搬移起始教室最近的桌子(或者目标教室最近的教室好像也可以?)即可。
4.代码实现:
#include <iostream>
using namespace std;
void swap(int a[],int i1,int i2)
{
int temp = a[i1];
a[i1] = a[i2];
a[i2] = temp;
return ;
}
int main()
{
int n,m,start[105],end[105],used[105]={0},i,j,cnt=0,num=0,temp;
cout<<"请输入教室的个数n和桌子的个数m:";
cin>>n>>m;
for(i=1;i<=m;i++)
{
cout<<"请输入第"<<i<<"个桌子的起始教室和目标教室:";
cin>>start[i]>>end[i];
}
for(i=1;i<m;i++)
{
int min = i;
for(j=i+1;j<=m;j++)
{
if(start[j]<start[min])
min = j;
}
if(min != j)
{
swap(start,i,min);
swap(end,i,min);
}
}
while(num<m)
{
temp = 0;
for(i=1;i<=n;i++)
{
if(used[i] == 0&&start[i]>=temp)
{
temp = end[i];
used[i] = 1;
num++;
}
}
cnt++;
}
cout<<cnt<<endl;
return 0;
}
5.算法优化:
贪心好像也没什么好优化的。。。