蚁群算法源代码1精编版Word下载.docx
《蚁群算法源代码1精编版Word下载.docx》由会员分享，可在线阅读，更多相关《蚁群算法源代码1精编版Word下载.docx（17页珍藏版）》请在冰豆网上搜索。
29.
30./*
31.//----------
（2）问题二：
Elion50
427.96;
----------------------------
32.//该程序最好的结果是428.468，可运行多次获得
33.//城市节点数目
34.#define
50
35.//城市坐标
36.double
37.
{5,64},
{5,25},
{5,6},
{7,38},
{8,52},
{10,17},
38.
{12,42},
{13,13},
{16,57},
{17,33},
{17,63},
39.
{20,26},
{21,47},
{21,10},
{25,32},
{25,55},
40.
{27,68},
{27,23},
{30,48},
{30,15},
{31,62},
41.
{31,32},
{32,22},
{32,39},
{36,16},
{37,69},
42.
{37,52},
{38,46},
{39,10},
{40,30},
{42,57},
43.
{42,41},
{43,67},
{45,35},
{46,10},
{48,28},
44.
{49,49},
{51,21},
{52,33},
{52,41},
{52,64},
45.
{56,37},
{57,58},
{58,27},
{58,48},
{59,15},
46.
{61,33},
{62,42},
{62,63},
{63,69}
47.};
48.//----------上面参数是固定的，下面的参数是可变的-----------
49.//蚂蚁数量
50.#define
51.//最大循环次数NcMax
52.int
1000;
53.//信息启发因子，期望启发式因子，全局信息素挥发参数，局部信息素挥发参数,
54.double
4,
55.//-----------问题二结束------------------------------------------------------------------------
56.*/
57.
58.//----------（3）问题三：
Elion75
542.31;
59.//该程序最好的结果是542.309，可运行多次获得
60.//城市节点数目
61.#define
75
62.//城市坐标
63.double
64.{6,25},
{7,43},
{9,56},
{10,70},
{11,28},
65.{12,17},
{12,38},
{15,5},
{15,14},
{15,56},
66.{16,19},
{17,64},
{20,30},
{21,48},
{21,45},
67.{21,36},
{22,53},
{22,22},
{26,29},
{26,13},
68.{26,59},
{27,24},
{29,39},
{30,50},
{30,20},
69.{30,60},
{31,76},
{33,34},
{33,44},
{35,51},
70.{35,16},
{35,60},
{36,6},
{36,26},
{38,33},
71.{40,37},
{40,66},
{40,60},
{40,20},
{41,46},
72.{43,26},
{44,13},
{45,42},
{47,66},
73.{48,21},
{50,30},
{50,40},
{50,50},
{50,70},
74.{50,4},
{50,15},
{51,42},
{52,26},
{54,38},
75.{54,10},
{55,34},
{55,45},
{55,50},
{55,65},
76.{55,57},
{55,20},
{57,72},
{59,5},
{60,15},
77.{62,57},
{62,48},
{62,35},
{62,24},
{64,4},
78.{65,27},
{66,14},
{66,8},
{67,41},
{70,64}
79.};
80.//----------上面参数是固定的，下面的参数是可变的-----------
81.//蚂蚁数量
82.#define
83.//最大循环次数NcMax
84.int
=1000;
85.//信息启发因子，期望启发式因子，全局信息素挥发参数，局部信息素挥发参数,
86.double
5,
0.1;
87.//-----------问题三结束------------------------------------------------------------------------
88.
89.
90.//===========================================================================================================
91.//局部更新时候使用的的常量，它是由最近邻方法得到的一个长度
92.//什么是最近邻方法?
:
）就是从源节点出发，每次选择一个距离最短的点来遍历所有的节点得到的路径
93.//每个节点都可能作为源节点来遍历
94.double
Lnn;
95.//矩阵表示两两城市之间的距离
96.double
allDistance[N][N];
97.
98.//计算两个城市之间的距离
99.double
calculateDistance（int
i,
int
j）
100.{
101.
return
sqrt（pow（（C[i][0]-C[j][0]）,2.0）
+
pow（（C[i][1]-C[j][1]）,2.0））;
102.}
103.
104.//由矩阵表示两两城市之间的距离
105.void
calculateAllDistance（）
106.{
107.
for（int
i
0;
<
N;
i++）
108.
{
109.
j
j++）
110.
111.
if
（i
!
112.
113.
allDistance[i][j]
calculateDistance（i,
j）;
114.
allDistance[j][i]
allDistance[i][j];
115.
}
116.
117.
118.}
119.
120.//获得经过n个城市的路径长度
121.double
calculateSumOfDistance（int*
tour）
122.{
123.
double
sum
124.
i<
;
125.
126.
row
*（tour
2
*
i）;
127.
col
2*
1）;
128.
+=
allDistance[row][col];
129.
130.
sum;
131.}
132.
133.class
ACSAnt;
134.
135.class
AntColonySystem
136.{
137.private:
138.
info[N][N],
visible[N][N];
//节点之间的信息素强度,节点之间的能见度
139.public:
140.
AntColonySystem（）
141.
142.
143.
//计算当前节点到下一节点转移的概率
144.
Transition（int
145.
//局部更新规则
146.
void
UpdateLocalPathRule（int
147.
//初始化
148.
InitParameter（double
value）;
149.
//全局信息素更新
150.
UpdateGlobalPathRule（int*
bestTour,
globalBestLength）;
151.};
152.
153.//计算当前节点到下一节点转移的概率
154.double
AntColonySystem:
155.{
156.
157.
158.
（pow（info[i][j],alpha）
pow（visible[i][j],
beta））;
159.
160.
else
161.
162.
0.0;
163.
164.}
165.//局部更新规则
166.void
167.{
168.
info[i][j]
（1.0
-
alpha1）
/
（N
Lnn））;
169.
info[j][i]
info[i][j];
170.}
171.//初始化
172.void
value）
173.{
174.
//初始化路径上的信息素强度tao0
175.
176.
177.
178.
179.
value;
180.
181.
182.
183.
visible[i][j]
1.0
184.
visible[j][i]
visible[i][j];
185.
186.
187.
188.}
189.
190.//全局信息素更新
191.void
globalBestLength）
192.{
193.
194.
195.
*（bestTour
196.
197.
info[row][col]
rou）
198.
info[col][row]
=info[row][col];
199.
200.}
201.
202.class
ACSAnt
203.{
204.private:
205.
AntColonySystem*
antColony;
206.protected:
207.
startCity,
cururentCity;
//初始城市编号，当前城市编号
208.
allowed[N];
//禁忌表
209.
Tour[N][2];
//当前路径
210.
currentTourIndex;
//当前路径索引，从0开始，存储蚂蚁经过城市的编号
211.public:
212.
ACSAnt（AntColonySystem*
acs,
start）
213.
214.
antColony
acs;
215.
startCity
start;
216.
217.
//开始搜索
218.
int*
Search（）;
219.
//选择下一节点
220.
Choose（）;
221.
//移动到下一节点
222.
MoveToNextCity（int
nextCity）;
223.
224.};
225.
226.//开始搜索
227.int*
ACSAnt:
Search（）
228.{
229.
cururentCity
startCity;
230.
toCity;
231.
currentTourIndex
232.
233.
234.
allowed[i]
1;
235.
236.
allowed[cururentCity]
237.
endCity;
238.
count
239.
do
240.
241.
count++;
242.
endCity
243.
toCity
244.
（toCity
>
0）
245.
246.
MoveToNextCity（toCity）;
247.
antColony->
UpdateLocalPathRule（endCity,
toCity）;
248.
249.
250.
}while（toCity
0）;
251.
MoveToNextCity（startCity）;
252.
startCity）;
253.
254.
*Tour;
255.}
256.
257.//选择下一节点
258.int
Choose（）
259.{
260.
nextCity
-1;
261.
q
rand（）/（double）RAND_MAX;
262.
//如果
q0,按先验知识，否则则按概率转移，
263.
（q
qzero）
264.
265.
probability
-1.0;
//转移到下一节点的概率
266.
267.
268.
//去掉禁忌表中已走过的节点,从剩下节点中选择最大概率的可行节点
269.
（1
==
allowed[i]）
270.
271.
prob
Transition（cururentCity,
272.
（prob
probability）
273.
274.
i;
275.
prob;
276.
277.
278.
279.
280.
281.
282.
//按概率转移
283.
p
//生成一个随机数,用来判断落在哪个区间段
284.
285.
//概率的区间点，p
落在哪个区间段，则该点是转移的方向
286.
//计算概率公式的分母的值
287.
288.
289.
290.
291.
292.
293.
294.
295.
296.
allowed[j]
&
297.
298.
j）/sum;
299
升级会员 