vis算法
① 粒子群优化算法和多模态优化算法有什么区别
摘 要：，粒子群算法据自己的速度来决定搜索过程，只有最优的粒子把信息给予其他的粒子，整个搜索更新过程是跟随当前最优解的过程，所有的粒子还可以更快的收敛于最优解。由于微粒群算法简单，容易实现，与其它求解约束优化问题的方法相比较，具有一定的优势。实验结果表明，对于无约束的非线性求解，粒子群算法表现出较好的收敛性和健壮性。
关键词：粒子群算法；函数优化；极值寻优
0 引言
非线性方程的求根问题是多年来数学家努力解决的问题之一。长期以来，人们已找出多种用于解决方程求根的方法，例如牛顿法、弦割法、抛物线法等。然而，很多传统的方法仅能运用于相应的小的问题集，推广性相对较差。对于一个现实世界中的优化问题，必须尝试很多不同的方法，甚至要发明相应的新的方法来解决，这显然是不现实的。我们需要另外的方法来克服这样的困难。
粒子群算法是一种现代启发式算法，具有推广性强、鲁棒性高等特点[1]。该算法具有群体智能、内在并行性、迭代格式简单、可快速收敛到最优解所在区域等优点[2]。本文采用粒子群算法，对函数的极值进行寻优计算，实现了对函数的极值求解。
1 粒子群算法
1.1 基本原理
粒子群算法（PSO）是一种基于群体的随机优化技术，它的思想来源于对鸟群捕食行为的研究与模拟。粒子群算法与其它基于群体的进化算法相类似，选用“群体”和“进化”的概念，按照个体的适应度值进行操作，也是一种基于迭代的寻优技术。区别在于，粒子群算法中没有交叉变异等进化算子，而是将每个个体看作搜索空间中的微粒，每个微粒没有重量和体积，但都有自己的位置向量、速度向量和适应度值。所有微粒以一定的速度飞行于搜索空间中，其中的飞行速度是由个体飞行经验和群体的飞行经验动态调整，通过追踪当前搜索到的最优值来寻找全局最优值。
1.2 参数选择
粒子群算法需要修改的参数很少，但对参数的选择却十分敏感。El-Gallad A, El-Hawary M, Sallam A, Kalas A[3]主要对算法中的种群规模、迭代次数和粒子速度的选择方法进行了详细分析，利用统计方法对约束优化问题的求解论证了这 3 个参数对算法性能的影响，并给出了具有一定通用性的3 个参数选择原则[4]。
种群规模：通常根据待优化问题的复杂程度确定。
最大速度：决定粒子在一次迭代中的最大移动距离,通常设定为不超过粒子的范围宽度。
加速常数：加速常数c1和c2通常是由经验值决定的，它代表粒子向pbest和gbest靠拢的加速项的权重。一般取值为：c1=c2=2。
中止条件：达到最大迭代次数或得到最小误差要求，通常要由具体问题确定。
惯性权重：惯性权重能够针对待优化问题调整算法的局部和全局搜索能力。当该值较大时有利于全局搜索，较小时有利于局部搜索。所以通常在算法开始时设置较大的惯性权重，以便扩大搜索范围、加快收敛。而随着迭代次数的增加逐渐减小惯性权重的值，使其进行精确搜索，避免跳过最优解。
1.3 算法步骤
PSO算法步骤如下：
Step1：初始化一个规模为 m 的粒子群，设定初始位置和速度。
初始化过程如下：
（1）设定群体规模m;
（2）对任意的i，s，在[-xmax, xmax]内均匀分布，产生初始位置xis；
（3）对任意的i，s，在[-vmax, vmax]内均匀分布，产生速度vis；
（4）对任意的i，设yi=xi，保存个体。
Step2：计算每个粒子的适应度值。
Step3：对每个粒子的适应度值和得到过的最好位置pis的适应度值进行比较，若相对较好，则将其作为当前的最好位置。
Step4：对每个粒子的适应度值和全局得到过的最好位置pgs的适应度值进行比较，若相对较好，则将其作为当前的全局最好位置。
Step5：分别对粒子的所在位置和速度进行更新。
Step6：如果满足终止条件，则输出最优解；否则，返回Step2。
1.4 粒子群算法函数极值求解
粒子群算法优化是计算机智能领域，除蚁群算法外的另一种基于群体智能的优化算法。粒子群算法是一种群体智能的烟花计算技术。与遗传算法相比，粒子群算法没有遗传算法的选择（Selection）、交叉（Crossover）、变异（Mutation）等操作，而是通过粒子在解空间追随最优的粒子进行搜索。
粒子群算法流程如图所示：
粒子群为由n个粒子组成的种群X = (X1,X2,X3,…Xn).
第i个粒子表示一个D维向量Xi = (X1,X2,X3,…XD)T.
第i个粒子的速度为Vi = (Vi1,Vi2,Vi3,…ViD)T.
个体极值为Pi = (Pi1,Pi2,Pi3,…PiD)T.
全局极值为Pg = (Pg1,Pg2,Pg3,…PgD)T.
速度更新为，式中，c1和c2为其两个学习因子的参数值；r1和r2为其两个随机值。
位置更新为.
2 粒子群算法应用举例
2.1 实验问题
这是一个无约束函数的极值寻优，对于Ackley函数，
.
其中c1=20，e=2. 71289。
2.2 实验步骤
对于Ackley函数图形，选取一个凹峰进行分析，程序运行结果如图所示。
图1 Ackley函数图形
可以看出，选取区间内的Ackley函数图形只有一个极小值点。因此，对于该段函数进行寻优，不会陷入局部最小。采用粒子群算法对该函数进行极值寻优。
首先，进行初始化粒子群，编写的MATLAB代码如下：
% 初始化种群
for i=1:sizepop
x1 = popmin1 (popmax1-popmin1)*rand;
% 产生随机个体
x2 = popmin2 (popmax2-popmin2)*rand;
pop(i,1) = x1; % 保存产生的随机个体
pop(i,2) = x2;
fitness(i) = fun([x1,x2]); % 适应度值
V(i,1) = 0; % 初始化粒子速度
V(i,2) = 0;
end
程序运行后所产生的个体值为：
表1 函数个体值
然后，根据待寻优的目标函数，计算适应度值。待寻优的目标函数为：
function y = fun(x)
y=-20*exp(-0.2*sqrt((x(1)^2x(2)^2)/2))-exp((cos(2*pi*x(1)) cos(2*pi*x(2)))/2) 20 2.71289;
根据每一组个体，通过目标函数，得到的适应度值为：
表2 函数适应度值
搜索个体最优极值，即搜索最小的适应度值，我们可利用MATLAB绘图将所有个体的适应度值绘成plot图查看相对最小值。
图3 函数适应度plot图
从图中可看出，当个体=20时，得到相对最小值，在程序中，将其保存下来。
之后进行迭代寻优，直到满足终止条件。
最后，得到的最优值为：
图4 MATLAB运行得到结果
迭代后得到的运行结果图如下：
图5 迭代曲线图
2.3 实验结果
通过图5中可看出，该函数的寻优是收敛的，最优个体和实际情况较吻合。因此，采用粒子群算法进行函数极值寻优，快速、准确且鲁棒性较好。
3 结论
本文阐述了粒子群算法求解最化问题的过程，实验结果表明了该算法对于无约束问题的可行性。与其它的进化算法相比，粒子群算法容易理解、编码简单、容易实现。但是参数的设置对于该算法的性能却有很大的影响，例如控制收敛，避免早熟等。在未来的工作中，将努力于将其它计算智能算法或其它优化技术应用于粒子群算法中，以进一步提高粒子群算法的性能。
② 数据结构(C语言版)题目，大神来
Prim算法：
intMap[10][10];
intdis[10],vis[10],F[10];
voidPrim(){
memset(vis,0,sizeof(vis));
intans=0;vis[1]=1;
for(inti=2;i<=7;i++){dis[i]=Map[i][1]!=-1?Map[i][1]:INF;F[i]=1;}
for(inti=2;i<=7;i++){
intMin=INF,p;
for(intj=1;j<=7;j++)if(!vis[j]&&dis[j]<Min)
Min=dis[p=j];
vis[p]=1;ans+=Min;
cout<<"加边:("<<p<<","<<F[p]<<")边权："<<Map[p][F[p]]<<endl;
for(intj=1;j<=7;j++)if(!vis[j]&&Map[p][j]!=-1)
if(Map[p][j]<dis[j]){
dis[j]=Map[p][j];
F[j]=p;
}
}
cout<<"总权值："<<ans<<endl;
}
intmain(){
memset(Map,-1,sizeof(Map));
while(true){
inta,b;cin>>a>>b;if(a==-1&&b==-1)break;
intc;cin>>c;Map[a][b]=Map[b][a]=c;
}
Prim();
return0;
}
输入及运行结果：
输入：
166
1220
1719
6717
659
2717
5719
2316
7315
7420
5424
3413
-1-1
结果：
加边:(6,1)边权：6
加边:(5,6)边权：9
加边:(7,6)边权：17
加边:(3,7)边权：15
加边:(4,3)边权：13
加边:(2,3)边权：16
总权值：76
Kruskal算法：
structEdge{
intu,v,w;
booloperator<(constEdge&a)const{
returnw<a.w;
}
};
Edgeedge[100];inttot=0;
intpre[100];
intFind(intx){
returnx==pre[x]?x:pre[x]=Find(pre[x]);
}
voidKruskal(){
for(inti=0;i<=7;i++)pre[i]=i;
sort(edge,edge+tot);
intcnt=1,ans=0;
for(inti=0;i<tot;i++){
if(cnt==7)break;
intu=edge[i].u,v=edge[i].v,w=edge[i].w;
intfu=Find(u),fv=Find(v);
if(fu==fv)continue;
pre[fu]=fv;cnt++;ans+=w;
cout<<"加边（"<<u<<","<<v<<"）"<<"边权："<<w<<endl;
}
cout<<"总的权值："<<ans<<endl;
}
intmain(){
while(true){
inta,b;cin>>a>>b;if(a==-1&&b==-1)break;
intc;cin>>c;edge[tot++]=(Edge){a,b,c};
}
Kruskal();
return0;
}
输入及运行结果：
输入：
166
1220
1719
6717
659
2717
5719
2316
7315
7420
5424
3413
-1-1
结果：
加边（1,6）边权：6
加边（6,5）边权：9
加边（3,4）边权：13
加边（7,3）边权：15
加边（2,3）边权：16
加边（6,7）边权：17
总的权值：76
③ 求A到B之间的最短路径，怎么获取
问题：从某顶点出发，沿图的边到达另一顶点所经过的路径中，各边上权值之和最小的一条路径——最短路径。解决最短路的问题有以下算法，Dijkstra算法，Bellman-Ford算法，Floyd算法和SPFA算法，另外还有着名的启发式搜索算法A*，不过A*准备单独出一篇，其中Floyd算法可以求解任意两点间的最短路径的长度。任意一个最短路算法都是基于这样一个事实：从任意节点A到任意节点B的最短路径不外乎2种可能，1是直接从A到B，2是从A经过若干个节点到B。
(1) 迪杰斯特拉(Dijkstra)算法按路径长度(看下面表格的最后一行，就是next点)递增次序产生最短路径。先把V分成两组：
S：已求出最短路径的顶点的集合
V-S=T：尚未确定最短路径的顶点集合
将T中顶点按最短路径递增的次序加入到S中，依据：可以证明V0到T中顶点Vk的最短路径，或是从V0到Vk的直接路径的权值或是从V0经S中顶点到Vk的路径权值之和（反证法可证，说实话，真不明白哦）。
(2) 求最短路径步骤
初使时令 S={V0},T={其余顶点}，T中顶点对应的距离值， 若存在<V0,Vi>，为<V0,Vi>弧上的权值（和SPFA初始化方式不同），若不存在<V0,Vi>，为Inf。
从T中选取一个其距离值为最小的顶点W(贪心体现在此处)，加入S(注意不是直接从S集合中选取，理解这个对于理解vis数组的作用至关重要)，对T中顶点的距离值进行修改：若加进W作中间顶点，从V0到Vi的距离值比不加W的路径要短，则修改此距离值（上面两个并列for循环，使用最小点更新）。
重复上述步骤，直到S中包含所有顶点，即S=V为止（说明最外层是除起点外的遍历）。
④ Java数组的全排列，里面布尔类型的数组vis[ ]，在递归算法里起了什么作用，递归那块理解不了，求详细解答
不要急于看代码，你心理要知道全排列的思路，不注重思路是很多程序员易犯的错误。
全排列算法：
如果我求得固定第一位后的排列，那么全部排列就可以求出，固定第一位有10种可能，可以循环求得。
如果我求得固定第二位后的排列，固定第一位后的排列就可以求出，固定第二位有9种可能，可以循环求得。
。。。
如果我求得固定第10位后的排列，固定第9位后的排列就可以求出，固定第10位有1种可能，可以循环求得。
这很明显是递归的算法。
static void dfs(int start,int end,int num){//为全部排列的集合，start为数字的位置,end为最后一位，num多余的
if(start==end){//当前的数字位置为最后一位时，说明，一个序列已经生成
for(int i=1;i<end;i++)
System.out.print(a[i]+" ");//输出序列
System.out.println();
}
else{//序列没有生成时
for(int i=1;i<end;i++){
if(vis[i])//i是否在前面使用过
continue;//如果是直接跳过
a[start]=i;//确定start位置的数字，当start为1时就是确定第一位，有10种可能
vis[i]=true;//设置i为已使用状态，避免下一位使用i
dfs(start+1,end,num);//求得确定start位后的全部序列
vis[i]=false;//设置i为未使用状态
}
}
⑤ 运动员最佳配对问题
#include <bits/stdc++.h>
using namespace std;
int n, a[22][22], b[22][22], vis[22], pre[22], ans;
void dfs(int x, int s)
{
if(x>n)
{
ans = max(ans, s);
return;
}
if(s+pre[n]-pre[x-1]<ans)
{
return;
}
for(int i = 1; i<=n; i++)
{
if(!vis[i])
{
vis[i] = 1;
dfs(x+1, s+a[x][i]*b[i][x]);
vis[i] = 0;
}
}
}
int main()
{
cin>>n;
for(int i = 1; i<=n; i++)
{
for(int j = 1; j<=n; j++)
{
cin>>a[i][j];
}
}
for(int i = 1; i<=n; i++)
{
for(int j = 1; j<=n; j++)
{
cin>>b[i][j];
}
}
for(int i = 1; i<=n; i++)
{
for(int j = 1; j<=n; j++)
{
pre[i] = max(pre[i], a[i][j] * b[j][i]);
}
pre[i] += pre[i - 1];
}
dfs(1, 0);
cout<< ans <<endl;
}
⑥ 求此程序！在线等，急！
Tarjan 算法
一.算法简介
Tarjan 算法一种由Robert Tarjan提出的求解有向图强连通分量的算法，它能做到线性时间的复杂度。
我们定义：
如果两个顶点可以相互通达，则称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。有向图的极大强连通子图，称为强连通分量(strongly connected components)。
1 void Tarjan ( int x ) { 2 dfn[ x ] = ++dfs_num ; 3 low[ x ] = dfs_num ; 4 vis [ x ] = true ;//是否在栈中 5 stack [ ++top ] = x ; 6 for ( int i=head[ x ] ; i!=0 ; i=e[i].next ){ 7 int temp = e[ i ].to ; 8 if ( !dfn[ temp ] ){ 9 Tarjan ( temp ) ;10 low[ x ] = gmin ( low[ x ] , low[ temp ] ) ;11 }12 else if ( vis[ temp ])low[ x ] = gmin ( low[ x ] , dfn[ temp ] ) ;13 }14 if ( dfn[ x ]==low[ x ] ) {//构成强连通分量15 vis[ x ] = false ;16 color[ x ] = ++col_num ;//染色17 while ( stack[ top ] != x ) {//清空18 color [stack[ top ]] = col_num ;19 vis [ stack[ top-- ] ] = false ;20 }21 top -- ;22 }23 }
⑦ 算法入门经典的黑白图问题
说实话没弄明白什么是八连块。。。
不过貌似有越界问题——dfs(x-1,y-1);
这个地方边界也不对
for(int i=0;i<=n;i++)
for(int j=0;j<=n;j++)
if((!vis[i][j])&&(mat[i][j]))
⑧ 如何通俗地解释匈牙利算法
是指二分图匹配的这个算法吧？下面是复制的，原文有图
原文地址：http://blog.csdn.net/lw277232240/article/details/72615522
二分图匹配，江湖称二分匹配，图论相关算法。
现在给出两个集合，我们拿约会来举例子。一方是男生集合，一方是女生集合，女生都比较内敛，对不认识的男孩纸并不喜欢一起约会，所以这里边就要有人际关系的问题了。
这里给男生编号n1,n2.....nn;女生编号v1v2....vn；
下面给出女生认识的男生的列表：
v1 :n1 ,n2.
v2 :n2, n3.
v3 : n1.
这里显而易见，1号男生2号男生是比较受欢迎的哈~。不用算法思想的去想这个问题我们可以这样思考：三号女生只认识1号男生，匹配上。（1组搞定）这个时候一号女生就不能选择1号男生了，她只能去选2号男生，这时候2号女生也就有了自己能选择的男生，这里我们就匹配成功了：
v1 n2
v2 n3
v3 n1
这里我们就完成了匹配的过程，这个时候我们因为所有人都有了约会对象，我们这个时候称之为最大匹配，同时也是完美匹配。
最大匹配：一个图所有匹配中，所含匹配边数最多的匹配，称为这个图的最大匹配。
完美匹配：如果一个图的某个匹配中，所有的顶点都是匹配点，那么它就是一个完美匹配。刚刚给出的例子就是完美匹配。
那么我们要如何实现算法呢？因为代码是不能直接看出来如何匹配能得到最大匹配的，所以我们这里就要有一个顺序去寻找最大匹配，这里我们以编号大小的顺序来寻找约会对象。
从v1开始找，先找到了n1.约上，然后是v2,找到了n2,约上。v3找到了n1,但是这里n1和v1已经约好了，怎么办呢？v1对v3说：我还认识n2,我去问问他有没有约会人选，要是没有的话，n1让给你。（其实我想说她是傻逼。。。。）然后v1去找n2,但是n2和v2约上了，这个时候呢v2对v1说：我还认识n3,我去看看他有没有约会的人选，要是没有的话n2，让给你（这两个傻逼。。。。）然后v2找到了n3,n3乐的屁颠屁颠的，说正好没人约我，然后他俩约上了，v2找到了n3,那么v1就能和v2约上了，然后v3也就能和n1约上了，我们这个时候就从刚刚的两组匹配，转到了3组匹配。
刚刚所述的过程，其实就是在找增广路。（这里增广路的含义自己就可以理解了吧~）那么我们如何用代码实现这个过程呢？其实并不难，我们这里需要三个数组，一个是图，一个是询问vis标记，一个是match匹配。
出自：http://blog.csdn.net/lw277232240/article/details/72615522
原文有图
⑨ 广度优先搜索C语言算法
它没有固定的写法， 但是大框都差不多， 一定要使用队列， 因为队列的存在可以维护程序按照广度优先的方式进行搜索。即层次遍历
可以给你一份我作过的一个题的代码，大体上就是这个样子
/****************************************************\
*
* Title : Rescue
* From : HDU 1242
* AC Time : 2012.01.12
* Type : 广度优先搜索求最短步数
* Method :从目标结点向回搜索，初始结点有多个
*
\****************************************************/
#include <stdio.h>
#include <string.h>
#define DATASIZE 201
#define QUEUESIZE 65536
typedef struct
{
int x,y;
}CPOINT;
int bfs(char map[][DATASIZE], int n, int m, CPOINT cpa);
int direction[][2] = {{1,0},{-1,0},{0,1},{0,-1}};
int main(void)
{
int m,n,i,j,res;
CPOINT cpa;
char map[DATASIZE][DATASIZE];
freopen("c:\\in.data","r",stdin);
while(scanf("%d%d%*c",&n,&m) != EOF) {
for(i = 0 ; i < n ; i++) {
gets(map[i]);
for(j = 0 ; j < m ; j++) {
if(map[i][j] == 'a') {
cpa.x = i;
cpa.y = j;
}
}
}
res = bfs(map, n, m, cpa);
if(res) {
printf("%d\n",res);
} else {
printf("Poor ANGEL has to stay in the prison all his life.\n");
}
}
return 0;
}
int bfs(char map[][DATASIZE], int n, int m, CPOINT cpa)
{
CPOINT q[QUEUESIZE],u,np;
int vis[DATASIZE][DATASIZE],step[DATASIZE][DATASIZE],i,front,rear,res;
memset(q, 0, sizeof(q));
memset(vis, 0, sizeof(vis));
memset(step, 0, sizeof(step));
front = rear = res = 0;
q[rear++] = cpa;
vis[cpa.x][cpa.y] = 1;
step[cpa.x][cpa.y] = 0;
while(front <= rear) {
u = q[front++];
if(map[u.x][u.y] == 'r') {
res = step[u.x][u.y];
break;
}
for(i = 0 ; i < 4; i++) {
np.x = u.x + direction[i][0];
np.y = u.y + direction[i][1];
if(np.x >= 0 && np.x < n && np.y >= 0 && np.y < m && !vis[np.x][np.y] && map[np.x][np.y] != '#' ) {
vis[np.x][np.y] = 1;
q[rear++] = np;
step[np.x][np.y] = step[u.x][u.y] + 1;
if(map[np.x][np.y] == 'x') {
++step[np.x][np.y];
}
}
}
}
return res;
}
⑩ 用图论做一个求迷宫最短路径的算法
01.#include <stdio.h>
02.#define MAXN 10
03.int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, -1, 1};
04.char name[] = {'U', 'D', 'L', 'R'};
05.int q[MAXN * MAXN]; //队列，保存当前结点编号
06.int vis[MAXN][MAXN], nMap[MAXN][MAXN];
07.int m, n; //行、列数
08.int dir[MAXN * MAXN];
09.int fa[MAXN][MAXN], dis[MAXN][MAXN], last_dir[MAXN][MAXN];
10.void funcInit();
11.void bfs(int x, int y);
12.void funcInput();
13.void print_path(int x, int y);
14.int main()
15.{
16. funcInput();
17. funcInit();
18. bfs(0, 0);
19. print_path(m - 1, n - 1);
20. return 0;
21.}
22.void funcInit()
23.{
24. int i, j;
25. for (i = 0; i != m; ++i)
26. {
27. for (j = 0; j != n; ++j)
28. {
29. vis[i][j] = 0;
30. dis[i][j] = 0;
31. }
32. }
33.}
34.void funcInput()
35.{
36. int i, j;
37. scanf("%d %d", &m, &n);
38. for (i = 0; i != m; ++i)
39. {
40. for (j = 0; j != n; ++j)
41. {
42. scanf("%d", &nMap[i][j]);
43. }
44. }
45.}
46.void bfs(int x, int y)
47.{
48. int front = 0, rear = 0;
49. int d, u; //方向标记、结点编号
50.
51. u = x * m + y;
52. vis[x][y] = 1;
53. fa[x][y] = u;
54. q[rear++] = u; //将当前结点编好放入队列
55.
56. while (front != rear)
57. {
58. u = q[front++];
59. x = u / m; y = u % m;
60. for (d = 0; d != 4; ++d)
61. {
62. int nx = x + dx[d], ny = y + dy[d];
63. if (nx >= 0 && nx < m && ny >= 0 && ny < n && !vis[nx][ny] && !nMap[nx][ny])
64. {
65. int v = nx * m + ny;
66. q[rear++] = v;
67. vis[nx][ny] = 1;
68. fa[nx][ny] = u;
69. dis[nx][ny] = dis[x][y] + 1; //记录路径长度
70. last_dir[nx][ny] = d; //记录移动方向标记
71. }
72. }
73. }
74.}
75.void print_path(int x, int y)
76.{
77. int c = 0;
78.
79. while (1)
80. {
81. int fx = fa[x][y] / m;
82. int fy = fa[x][y] % m;
83. if (fx == x && fy == y) break;
84. dir[c++] = last_dir[x][y];
85. x = fx; y = fy;
86. }
87. while (c--)
88. {
89. putchar(name[dir[c]]);
90. putchar('/n');
91. }
92. printf("最短路径长度为:%d/n", dis[m-1][n-1]);
93.}