最优算法解

‘壹’ 最优解算法评价的原则

最优解算法评价的原则有：

原则1：算法能力一致。

针对多算法交叉测试的问题，必须保证待测试算法能够解决同类问题或者提供同类功能。

原则2：样本用例一致。

同一算法，不同样本测试集上的指标表现存在差异，因此无论我们的测评是横向比较多家算法，还是纵向比较一个算法的多个迭代版本，都必须保证所采用的样本测试集与测试用例完全一致，这样得到的指标数值才具有可比性。

若A算法使用a测试集，而B算法使用b测试集，那么，由于测试集不同，因此所得到的指标数值不具有可比性。

原则3：执行方式一致。

所有操作方式和测试算法的环境必须保证完全一致。

原则4：评价指标一致。

对于同系算法的测试，必须采用计算公式或统计口径完全一致的指标体系。

‘贰’ 【C语言算法】求最优解

#include<stdio.h>

voidmain()
{
	doubleV;
	printf_s("请输入V：
");
	scanf_s("%lf",&V);
	intm,n,p;
	intM,N,P;
	doubledelta=10000.0;
	for(m=0;m<=16;m++)
	{
		for(n=0;n<=256;n++)
		{
			for(p=1;p<=4096;p++)
			{
				doubled=m*n/(double)p-V;
				if(d<0)
					d=-d;
				if(d<delta)
				{
					delta=d;
					M=m;
					N=n;
					P=p;
				}
			}
		}
	}
	printf_s("最优解：M=%d,N=%d,P=%d
",M,N,P);
}

‘叁’ 最优化的解空间为离散的点，请问用什么最优化的算法解啊

问题是线性的，还是非线性的。线性的，分枝定界、分枝割平面、分枝定价、列生成等算法都可以求解；非线性的，还要分是否凸，凸的话，广义Benders分解、外部近似、分枝定界、扩展割平面算法等，非凸的话，可采用全局最优算法。

判断一下是否是凸规划，是的话，用上面的算法可以求到全局最优；否则，可能得到局部最优解。

‘肆’ Matlab神经网络原理中可以用于寻找最优解的算法有哪些

若果对你有帮助，请点赞。
神经网络的结构（例如2输入3隐节点1输出）建好后，一般就要求神经网络里的权值和阈值。现在一般求解权值和阈值，都是采用梯度下降之类的搜索算法（梯度下降法、牛顿法、列文伯格-马跨特法、狗腿法等等），这些算法会先初始化一个解，在这个解的基础上，确定一个搜索方向和一个移动步长（各种法算确定方向和步长的方法不同，也就使各种算法适用于解决不同的问题），使初始解根据这个方向和步长移动后，能使目标函数的输出（在神经网络中就是预测误差）下降。 然后将它更新为新的解，再继续寻找下一步的移动方向的步长，这样不断的迭代下去，目标函数（神经网络中的预测误差）也不断下降，最终就能找到一个解，使得目标函数（预测误差）比较小。
而在寻解过程中，步长太大，就会搜索得不仔细，可能跨过了优秀的解，而步长太小，又会使寻解过程进行得太慢。因此，步长设置适当非常重要。
学习率对原步长（在梯度下降法中就是梯度的长度）作调整，如果学习率lr = 0.1,那么梯度下降法中每次调整的步长就是0.1*梯度，
而在matlab神经网络工具箱里的lr,代表的是初始学习率。因为matlab工具箱为了在寻解不同阶段更智能的选择合适的步长，使用的是可变学习率，它会根据上一次解的调整对目标函数带来的效果来对学习率作调整，再根据学习率决定步长。
机制如下：
if newE2/E2 > maxE_inc %若果误差上升大于阈值
lr = lr * lr_dec; %则降低学习率
else
if newE2 < E2 %若果误差减少
lr = lr * lr_inc;%则增加学习率
end
详细的可以看《神经网络之家》nnetinfo里的《[重要]写自己的BP神经网络(traingd)》一文，里面是matlab神经网络工具箱梯度下降法的简化代码

‘伍’ 为什么蚁群算法第一代就能出最优解,原因

在解决问题的方法当中有很多，就像蚁群算法，用蚁群算法就能将第一代算出最优解是因为蚁群算法的算法独特，方式新颖。避免了其它算法当中的固结。

‘陆’ 求最优路径的算法

以下是C写的广度优先的最短路径穷举法,希望对你有所帮助.
#include <iostream>
#include <string>
#include <vector>
#include <map>

using namespace std;

#define SIGHTS 4 //自定义景点个数为4，以后可以扩充

class Sight //景点类信息，以后可以扩充
{
public:
Sight(string name, string sd) { sname = name; sight_detial = sd; }
string Sight_Name() { return sname; }
string Sight_detial() { return sight_detial; }
protected:
string sname; //景点名称
string sight_detial; //景点备注
};

struct SI
{
string sname; //景点名称
int index; //景点编码
};

SI SightInfo[SIGHTS];

map<int, string>results; //距离与路径的映射结构体，可以动态扩充
vector<Sight> sights; //VECTOR向量保存景点信息，目前的作用只是保存
//但是其强大的功能完全可以应付以后的功能扩充

int MinDistanct = 50000; //假定最小距离为一个很大的值
string Sight_Names = "枫林园蛟桥园青山园麦庐园 "; //目标字符串
string Best_Path; //保存最佳路径的STRING字符串

int DISTANCE[4][4] = { //查找表，用于储存接点之间距离的信息
0, 1500, 2500, 2400,
1500, 0, 800, 0,
2500, 800, 0, 200,
2400, 0, 200, 0
};

bool connect[4][4] = { //查找表，用于储存接点之间连通的信息
0, 1, 1, 1,
1, 0, 1, 0,
1, 1, 0, 1,
1, 0, 1, 0
};

void InitSights()
{ //初始化景点的各类信息
SightInfo[0].index=0;
SightInfo[0].sname = "麦庐园";
SightInfo[1].index=1;
SightInfo[1].sname = "枫林园";
SightInfo[2].index=2;
SightInfo[2].sname = "蛟桥园";
SightInfo[3].index=3;
SightInfo[3].sname = "青山园";

Sight s1("枫林园",
"枫林园以计算机系的理工科学生为主，是江西财经大学的唯一一个计算机学院");
sights.push_back(s1);
Sight s2("蛟桥园",
"蛟桥园是江西财经大学的会计、贸易等财务教学为主的教学楼群，为本部");
sights.push_back(s2);
Sight s3("青山园",
"青山园是江西财经大学的会计、贸易等财务教学为主的学生的宿舍群");
sights.push_back(s3);
Sight s4("麦庐园",
"麦庐园是江西财经大学的外语、艺术等人文科学为主的学习园地");
sights.push_back(s4);
}

void Find_Ways(string start, string end, int DIST, string path, int depth)
{ //递归调用，逐层寻找可连通的路径，并以该路径继续重复循环查找，根据分析可以
//知道，所有最优解即最短路径所经过的接点数目必定小于N，于是采用广度优先遍历，
//设置count为循环深度，当count大于SIGHTS时退出循环
int count = 1;
int i,j;
int start1 = 0,end1 = 0;
int distanct = 0, storeDist = 0;
string temp, target, pathway, storePath; //临时储存体，用于恢复递归调用后会
//改变的数据，以便之后无差别使用

count += depth;

if(count > SIGHTS)
return;

distanct += DIST; //距离累加

if(path=="") //第一次时，pathway初始化为第一个接点名称
{
pathway = start;
pathway += "=>";
}
if(path!="")
pathway = path;

storeDist = distanct; //填充临时储存值
storePath = pathway;

for(i = 0; i < SIGHTS; ++i) //通过遍历，查找景点名称对应的编号
{
if(start == SightInfo[i].sname)
start1 = SightInfo[i].index;
if(end == SightInfo[i].sname)
end1 = SightInfo[i].index;
}

for(i = 0; i < SIGHTS; i++) //算法核心步骤
{
if(connect[start1][i] != 0)
{
if(i==end1) //如果找到了一条路径，则保存之
{
distanct += DISTANCE[start1][end1];
for(j = 0; j < SIGHTS; ++j)
{
if(end1==SightInfo[j].index)
target = SightInfo[j].sname;
}
pathway += target;
results.insert(make_pair(distanct, pathway)); //保存结果路径信息

distanct = storeDist; //恢复数据供下次使用
pathway = storePath;
}
else //分支路径
{
for(j = 0; j < SIGHTS; ++j)
{
if(i==SightInfo[j].index)
temp = SightInfo[j].sname;
}
pathway += temp;
pathway += "=>";
distanct += DISTANCE[start1][i];

Find_Ways(temp, end, distanct, pathway, count); //以该连通的分支
//路径继续递归调用，查找子层路径信息。

distanct = storeDist; //恢复数据
pathway = storePath;
}
}
}
}

void Find_Best_Way()
{ //该函数建立在上述函数执行完毕之后，在map映射结构中通过对比每条路径的长度，来
//选择最优解
map<int, string>::iterator itor = results.begin();

while(itor!=results.end()) //寻找最小值
{
// cout<<"distanct = "<<itor->first<<endl;
if(itor->first < MinDistanct)
MinDistanct = itor->first;
itor++;
}

itor = results.begin();

while(itor!=results.end()) //寻找最小值所对应的整个路径字符串
{
if(itor->first == MinDistanct)
Best_Path = itor->second;
itor++;
}
}

int main(int argc, char *argv[])
{
int choice;
size_t t1=0,t2=0;
string source, termination;

InitSights();

do{
cout<<"////////////////////////////////////////////////////////\n"
<<"**** 请输入您所需要的服务号码: ********\n"
<<"**** 1.枫林园介绍 ********\n"
<<"**** 2.蛟桥园介绍 ********\n"
<<"**** 3.青山园介绍 ********\n"
<<"**** 4.麦庐园介绍 ********\n"
<<"**** 5.查询地图路径 ********\n"
<<"**** 6.退出查询系统 ********\n"
<<"////////////////////////////////////////////////////////\n"
<<endl;

cin>>choice;

switch(choice)
{
case 1:
cout<<sights[0].Sight_Name()<<endl
<<sights[0].Sight_detial()<<endl;
break;

case 2:
cout<<sights[1].Sight_Name()<<endl
<<sights[1].Sight_detial()<<endl;
break;

case 3:
cout<<sights[2].Sight_Name()<<endl
<<sights[2].Sight_detial()<<endl;
break;

case 4:
cout<<sights[3].Sight_Name()<<endl
<<sights[3].Sight_detial()<<endl;
break;

case 5:
flag1:
cout<<"请输入路径的起点"<<endl;
cin>>source;
cout<<"请输入路径的终点"<<endl;
cin>>termination;

if((t1=Sight_Names.find(source,t1))==string::npos || (t2=Sight_Names.find(termination,t2))==string::npos)
{ //检查输入的数据是否含有非法字符
cerr<<"输入的路径结点不存在，请重新输入:"<<endl;
goto flag1;
}
Find_Ways(source, termination, 0, "",0); //寻找所有可能解
Find_Best_Way(); //在所有可能解中找到最优解

cout<<"最佳路径是："<< Best_Path <<endl
<<"最小路程为(米):"<< MinDistanct<<endl;

t1 = 0; //恢复字符串下标，以支持下次查询
t2 = 0;
break;

case 6:
break;

default:
cerr<<"您的选择超出了范围，请重新输入:"<<endl;
break;
}
}while(choice!=6);

system("pause");
return 0;
}

‘柒’ 遗传算法的最优解 在论文中如何验证

适应度越大，解越优。

判断是否已得到近似全局最优解的方法就是遗传算法的终止条件。 在最大迭代次数范围内可以选择下列条件之一作为终止条件：

1. 最大适应度值和平均适应度值变化不大、趋于稳定；

2. 2. 相邻GAP代种群的距离小于可接受值，参考“蒋勇，李宏.改进NSGA—II终止判断准则[J].计算机仿真.2009. Vol.26 No.2”
   

‘捌’ C语言最优解算法

#include<stdio.h>

int result[100][6];
int data[100000][2];

int main()
{
int i,j,T,f,temp,rlen=0,dlen,swap;

scanf("%d",&T);
while(T-->0)
{
for(dlen=0;1;dlen++)
{
scanf("%d %d",&data[dlen][0],&data[dlen][1]);
if(0==data[dlen][0] && 0==data[dlen][1])
break;
}
scanf("%d",&f);
for(i=0;i<dlen-1;i++)
{
for(j=0;j<dlen-i-1;j++)
{
swap=0;
if(0==f)
{
if(data[j][0]>data[j+1][0] || (data[j][0]==data[j+1][0] && data[j][1]>data[j+1][1]))
{
swap=1;
}
}
else if(1==f)
{
if(data[j][1]>data[j+1][1] || (data[j][1]==data[j+1][1] && data[j][0]>data[j+1][0]))
{
swap=1;
}
}
if(1==swap)
{
temp=data[j][0];
data[j][0]=data[j+1][0];
data[j+1][0]=temp;
temp=data[j][1];
data[j][1]=data[j+1][1];
data[j+1][1]=temp;
}
}
}
if(dlen>=3)
{
for(i=0;i<3;i++)
{
result[rlen][2*i]=data[i][0];
result[rlen][2*i+1]=data[i][1];
}
rlen++;
}
}
for(i=0;i<rlen;i++)
{
printf("Case #%d:\n",i+1);
for(j=0;j<3;j++)
printf("%d %d\n",result[i][2*j],result[i][2*j+1]);
}
return 0;
}

‘玖’ 求最优解的算法

拉蛤螂日乘子法或线性规划和非线性规划，都可以得到最优解。