模擬退火算法及其Matlab實現

1基本原理：

         模擬退火算法源於固體的退火過程，當把一個固體的加熱使其升溫，其內部分子出現無序狀態，內能增大

而降溫時，所有粒子趨於有序，冷卻到最低溫度時內能達到最少。當某一狀態下系統內能減少，則完全

接受這一新的狀態，否則對於這一狀態采樣概率接受，溫度越高，接受的概率越大。當溫度由初始值逐漸

降到最低溫度時，即可得到最低的內能，也就是算法的最優解。

2算法步驟：

  （1）設置算法的參數：初始溫度，結束溫度，溫度衰減系數，每個溫度下的擾動次數，初始狀態，初始解

   （2）對狀態產生擾動，計算新狀態下的解，比較兩個解的大小，判斷是否接受新的狀態

   （3）在此溫度下，對步驟（2）按設置的擾動次數重復進行擾動

   （4）對溫度進行衰減，並在新的溫度下重復（2）（3），直到結束溫度

   （5）輸出記錄最優狀態和最優解，算法結束

3實例計算：

  采用TSP問題中的eil51數據，官方的最優解為426，編寫Matlab程序，進行計算

4Matlab代碼：

clc,clear            %清空環境中的變量
tic
iter = 1;                                                                                   % 迭代次數初值
a=0.99;                                                                                    %溫度衰減系數
t0=120;                                                                                    %初始溫度
tf=1;                                                                                          %最后溫度
t=t0;
Markov=10000;                                                                     %Markov鏈長度
load data1.txt                                                                           %讀入城市的坐標
city=data1;
n = size(city,1);                                                                      %城市距離初始化
D = zeros(n,n);                                                    
for i = 1:n
    for j = 1:n
            D(i,j) = sqrt(sum((city(i,:) - city(j,:)).^2));
    end    
end                                                                                
route=1:n;   
route_new=route;
best_length=Inf;
Length=Inf;
best_route=route;
%%
while t>=tf
            for j=1:Markov
                    %進行擾動,長生新的序列route_new;
                    if (rand<0.7)
                        %交換兩個數的順序
                           ind1=0;ind2=0;
                           while(ind1==ind2&&ind1>=ind2)
                                    ind1=ceil(rand*n);
                                    ind2=ceil(rand*n);
                           end                      
                                      temp=route_new(ind1);
                                      route_new(ind1)=route_new(ind2);
                                      route_new(ind2)=temp;
                    else
                          ind=zeros(3,1);
                          L_ind=length(unique(ind));
                          while (L_ind<3)
                                    ind=ceil([rand*n rand*n rand*n]);
                                    L_ind=length(unique(ind));
                          end
                          ind0=sort(ind);
                          a1=ind0(1);b1=ind0(2);c1=ind0(3);
                         route0=route_new;
                         route0(a1:a1+c1-b1-1)=route_new(b1+1:c1);
                         route0(a1+c1-b1:c1)=route_new(a1:b1);
                         route_new=route0;    
                    end 
                     %計算路徑的距離,Length_new 
                          length_new = 0;
                        Route=[route_new route_new(1)];
                              for j = 1:n
                                  length_new = length_new+ D(Route(j),Route(j + 1));
                              end
                     if length_new<Length      
                              Length=length_new;
                              route=route_new;
                           %對最優路線和距離更新
                           if       length_new<best_length
                                    iter = iter + 1;    
                                     best_length=length_new;
                                     best_route=route_new;
                           end
                     else
                             if rand<exp(-(length_new-Length)/t)
                                  route=route_new;
                                  Length=length_new;
                              end
                     end
                       route_new=route; 
                end              
                        t=t*a;
end

%--------------------------------------------------------------------------
%% 結果顯示 
toc
Route=[best_route best_route(1)];
plot([city(Route ,1)], [city(Route ,2)],'o-');
    disp('最優解為：')
    disp(best_route)
    disp('最短距離：')
    disp(best_length)
    disp('最優解迭代次數：')
    disp(iter)
for i = 1:n
    %對每個城市進行標號
    text(city(i,1),city(i,2),['   ' num2str(i)]);
end
xlabel('城市位置橫坐標')
ylabel('城市位置縱坐標')
title(['模擬退火算法(最短距離）:' num2str(best_length) ''])

5運行結果：

最短距離：436.7146，其和最優解426接近

TSP圖：