TUGAS BESAR

IMPLEMENTASI ALGORITMA GENETIKA

PADA TRAVELING SALESMAN PROBLEM
Disusun Untuk Memenuhi Tugas Besar Mata Kuliah KecerdasanBuatan

Dosen : Nelly Indriani, W,S.Si.,M.T

Oleh :
10110241 Carsadi
10110261 Dodi Permana
Kelas IF6/VI

JURUSAN TEKNIK INFORMATIKA

FAKULTAS TEKNIK DAN ILMU KOMPUTER
UNIVERSITAS KOMPUTER INDONESIA
2013

1.LATAR BELAKANG MASALAH

Traveling Salesman Problem (TSP) merupakan sebuah permasalahan optimasi yang
dapat diterapkan pada berbagai kegiatan seperti routing. Masalah optimasi TSP terkenal
dan telah menjadi standar untuk mencoba algoritma yang komputational. Pokok
permasalahan dari TSP adalah seorang salesman harus mengunjungi sejumlah kota yang
diketahui jaraknya satu dengan yang lainnya. Semua kota yang ada harus dikunjungi
oleh salesman tersebut dan kota tersebut hanya boleh dikunjungi tepat satu kali.
Permasalahannya

adalah

bagaimana

salesman

tersebut

dapat

mengatur

rute

perjalanannya sehingga jarak yang ditempuhnya merupakan rute yang optimum yaitu
jarak minimum terbaik.
Banyak metode yang dapat dipakai untuk menyelesaikan TSP sepertiHillClimbing
Method, Ant Colony System dan Dynamic Programming. TSP ini dapat diselesaikan
dengan cepat walaupun dengan menggunakan algoritma brute force sekalipun, tetapi
hanya jika kota-kota yang akandikunjunginya sedikit. Namun, jika kota-kota yang akan
dikunjungi banyak, maka algoritma seperti Brute Force tidaklah menjadi pilihan lagi.
Sebab, Algoritma Brute Force sendiri memiliki kompleksitas O(n!).
Metode lain yang dapat dipakai untuk menyelesaikan TSP adalah algoritma
genetika. Algoritma genetika merupakan sebuah algoritma yang meniru cara kerja
proses genetika pada makhluk hidup, dimana terdapat proses seleksi, rekombinasi dan
mutasi untuk mendapatkan kromosom terbaik pada suatu generasi.
Algoritma Genetika sebagai cabang dari Algoritma Evolusi didasarkan pada proses
genetik yang ada dalam makhluk hidup; yaitu perkembangan generasi dalam sebuah
populasi yang alami, secara lambat laun mengikuti prinsip seleksi alam atau "siapa yang
kuat, dia yang bertahan (survive)". Peletak prinsip dasar sekaligus pencipta algoritma
genetika adalah John Holland.
Algoritma genetika menggunakan analogi secara langsung dari kebiasaan yang
alami yaitu seleksi alam. Algoritma ini bekerja dengan sebuah populasi yang terdiri dari
individu-individu, yang masing-masing individu mempresentasikan sebuah solusi yang
mungkin bagi persoalan yang ada. Dalam kaitan ini, individu dilambangkan dengan
sebuah nilai fitness yang akan digunakan untuk mencari solusi terbaik dari persoalan
yang ada.

Penyelesaian persoalan ini dengan pendekatan langsung adalah dengan menghitung

semua kemungkinan rute yang ada, kemudian dipilih satu rute yang terpendek. Jika ada
n kota yang harus dikunjungi maka ada n! / (2n) rute yang harus diselidiki. Dengan cara
ini, jumlah waktu komputasi yang diperlukan meningkat seiring dengan bertambahnya
ukuran dari persoalan, yaitu jumlah kota.
Proses algoritma genetika terdiri dari beberapa langkah, yaitu pengkodean
(encoding), seleksi (selection), persilangan (crossover), mutasi (mutation) dan decoding.
Pertama-tama, proses encoding adalah suatu proses kodefikasi atas solusi dari
permasalahannya. Hasil encoding adalah berbentuk string yang merupakan representasi
dari suatu kromosom. Proses selection menentukan kromosom mana yang tetap tinggal
pada generasi berikutnya. Proses crossover akan menghasilkan kromosom baru yang
merupakan pengganti dari kromosom yang hilang sehinga total kromosom pada satu
generasi berjumlah tetap. Proses mutasi memungkinkan terjadinya kromosom baru
secara unpredictable. Proses terakhir adalah decoding yaitu mengambil makna dari hasil
kromosom terbaik untuk menjawab permasalahannya.
Kelebihan algoritma genetika dibandingkan metode pencarian konvensional pada
TSP yaitu :
1. Solusi dapat diperoleh kapanpun karena solusi dihasilkan pada generasi ke
berapapun.
2. Algoritma genetika tidak harus membutuhkan waktu yang lama karena tidak semua
kemungkinan dicoba, tergantung pada kriteria berakhirnya.
3. Algoritma pencarian konvensional dilakukan apabila jumlah n kecil, tapi jika n nya
banyak maka akan memakan banyak waktu untuk penyelesaian dibandingkan
algoritma genetik.
Hal-hal yang harus dilakukan dalam menggunakan algoritma genetika adalah:
a. Mendefinisikan individu, dimana menyetakan salah satu solusi
(penyelesaian) yang mungkin dari permasalahan yang singkat.
b. Mendefinisikan nilai fitness, yang merupakan ukuran baik-tidaknya
sebuah individu atau baik-tidaknya solusi yang didapatkan.
c. Menentukan proses pembangkitan populasi awal. Hal ini biasanya
dilakukan

dengan

menggunakan

pembangkitan

random-walk.
d. Menentukan proses seleksi yang akan digunakan.

acak

seperti

e. Menentukan proses perkawinan silang (cross-over) dan mutasi gen

yang akan digunakan.

Populasi Awal

Evaluasi fitness

Seleksi Individu

Populasi Baru

ReproduksiCross-OverDan Mutasi

Gambar 1 Siklus Algoritma Genetika

Beberapa definisi penting yang perlu diperhatikan adalah sebagai
berikut :
a. Genotype (Gen), nilai yang menyatakan satuan dasar yang
membentuk suatu arti tertentu dalam satu kesatuan gen yang
dinamakan kromosom.
b.Allele, nilai dari gen.
c. Kromosom, gabungan gen-gen yang membentuk nilai tertentu.
d.Individu, menyatakan satu nilai atau keadaan yang menyatakan
salah

satu

diangkat.

solusi

yang

mungkin

dari

permasalahan

yang

e.Populasi, merupakan sekumpulan individu yang akan diproses

bersama dalam satu siklus proses evolusi.
f. Generasi, menyatakan satu siklus proses evolusi atau satu iterasi
di dalam GA.
Adapun tujuan dari Traveling Salesman Problem (TSP) ini adalah untuk mencari
rute terpendek yang optimal bagi seorang salesman dalam mengunjungi kota-kota

2. PENGENALAN SISTEM
1

Masukan Yang Dibutuhkan Sistem

Pada system ini ada 8 inputan parameter untuk mengontrol pengoperasian Algoritma
Genetika yaitu :
1. Population Size, adalah jumlah awal dari rute acak yang dibuat ketika algoritma
dimulai. Sebuah populasi yang besar membutuhkan waktu lebih lama untuk
menemukan hasilnya. Sebuah populasi yang lebih kecil meningkatkan
kemungkinan bahwa setiap rute dalam populasi akhirnya akan terlihat sama. Hal
ini meningkatkan kemungkinan bahwa solusi terbaik tidak akan ditemukan.
2. Group Size Ukuran rute yang bernilai antara 2 sampai n (jumlah individu dalam
satu populasi) yang digunakan sebagai parameter dalam seleksi mode tournament.
3. Mutasi % - Persentase bahwa setiap anak setelah crossover yang akan mengalami
mutasi, salah satu kota secara acak dipindah dari satu titik kedalam rute yang lain.
4. Nearby City - Sebagai bagian dari populasi awal, didapat dari jarak suatu kota ke
kota yang paling dekat. GA akan lebih memilih untuk menghubungkan kota-kota
yang dekat satu sama lain untuk membuat rute awal. Ketika membuat populasi
awal ini jumlah akan memilih kota yang dianggap dekat.
5. Nearby City Odds % - Persentasi probabilitas untuk menggunakan nearby city
yang di dapat dari populasi awal.
6. Maximum Generation - Berapa banyak crossover dijalankan sebelum algoritma
diakhiri.

7. Random Seed nilai yang digunakan sebagai parameter pada fungsi

pembangkitan populasi awal dengan Random Number Generator.
8. City XML File Name, memungkinkan Anda untuk mengimpor daftar kota dari file
XML. Ketika debugging masalah itu berguna untuk dapat menjalankan algoritma
dengan parameter yang sama persis.
2

Proses
A. Teknik Pengkodean
Teknik pengkodean adalah bagaimana mengkodekan gen dari kromosom,
dimana gen merupakan bagian dari kromosom.

B. Membangkitkan Populasi Awal

Membangkitkan populasi awal adalah proses membangkitkan sejumlah individu
secara acak menggunakan Random number generator.
C. Seleksi
Seleksi digunakan untuk memilih individu-individu mana saja yang akan dipilih
untuk proses kawin silang dan mutasi
D. Cross Over
Kawin silang (crossover) adalah operator dari algoritma genetika yang
melibatkan dua induk untuk membentuk kromosom baru.
E. Mutasi
Operator berikutnya pada algoritma genetika adalah mutasi gen. Operator ini
berperan untuk menggantikan gen yang hilang dari populasi akibat proses seleksi
yang memungkinkan munculnya kembali gen yang tidak muncul pada inisialisasi
populasi.
2.3.

Keluaran Dari System

Keluaran dari sistem ini adalah solusi optimum berupa rute terpendek yang bisa
dilalui oleh salesman.

3. ANALISIS
3.1. Pengkodean

Langkah pertama yang harus dilakukan dalam pembuatan programsimulasi

Traveling Salesman Problemyang menggunakan algoritma genetika adalah
membawa permasalahan TSP tersebut kedalam bentuk yang dapat dimengerti oleh
algoritma genetik, yaitudengan cara mengkodekan masalah menjadi kode-kode
tertentu. Pemodelan kromosom (pengkodean) adalah cara untuk merepresentasikan
masalah kedalam bentuk kromosom. Pengkodean ini meliputi penkodean terhadap
gen yang terdpat dalam kromosom. Ada bermacam-macam
yangdapat

dilakukan

pengkodeantersebut

dalam

antara

algoritma

lain

adalah

teknikpengkodean

genetika. Beberapateknik-teknik
pengkodean biner,

pengkodean

permutasi, danpengkodean nilai. Teknik pengkodean yangdigunakan pada TSP

adalah pengkodean permutasi.Padapengkodean permutasi, kromosom-kromosom
adalahkumpulan angka
Traveling

Salesman

yang

mewakili

posisi

dalam sebuahurutan.

Pada

Problem, gen mewakili posisi sebuah kota sedangkan

kromosom mewakili urutan kota yang dikunjungisalesman. Jadi apabila satu

kromosom berbentuksebagai berikut P1 = (X1,X2,X3,..,Xn)

berartisalesmen

bergerak dari kota bernomor X 1 ke X2dsthingga ke kota ke Xn, dengan syarat

tidak boleh mengunjungi satu kota lebih dari dua kali. Berikut adalah contoh
kromosom pada program simulasi yang dibentuk dari urutan kota-kota yang akan
dikunjungi oleh seorangsalesman:
Jika posisi suatu kota di representasikan dengan (x,y) maka kromosom yang
dapat dibentuk dari urutan kota tersebut adalah:
Tabel 1. Contoh kromosom hasil pengkodean
Kromosom

160,370; 121,132; 58,234; 41,231; 143,86; 312,176; 121,246

3.2. Membangkitkan Populasi Awal

Membangkitkan populasi awal adalah proses membangkitkan sejumlah individu
secara acak atau sesuai prosedur tertentu. Individu menyatakan salah satu solusi
yang mungkin. Individu bisa dikatakan sama dengan kromosom. Pada kasus ini,
individu dibangkitkan secara acak dengan menggunakan random number
generatorserta dipastikan bahwa satu kota tidak di kunjungi sebanyak dua kali atau
lebih.Berikut adalah contoh dari tiga individu awal yang dibangkitkan secara acak:

Tabel 2. Contoh populasi awal

Kromosom[1]
Kromosom[2]
Kromosom[3]
Kromosom[4]

3.3.

160,370; 121,132; 58,234; 41,231; 143,86; 312,176; 121,246

121,246; 160,370; 58,234; 41,231; 143,86; 312,176; 121,132
121,246; 58,234; 41,231; 143,86;121,132; 312,176; 160,370
121,246; 58,234; 41,231; 143,86;121,132; 160,370; 312,176

Seleksi
Seleksi akan menentukan individu-individu mana saja yang akan dipilih untuk

dilakukan rekombinasi dan bagaimana offspring (keturunan) terbentuk dari

individu-individu terpilih. Pada proses penseleksian digunakan suatu parameter
yang disebut kesesuaian atau fitness. Fitness digunakan untuk menentukan
seberapa baikkromosom akan bertahan hidup. Makin tinggi nilai fitness suatu
kromosom maka makin baik kromosom itu akan bertahan hidup. Nilai fitness
tertinggi merepresentasikan solusi terbaik atas persoalan itu sendiri. Penentuan
berapa besar nilai fitness suatu kromosom berdasarkan fungsi fitness yang
didefinisikan tersendiri. Untuk kasus ini fungsi fitness didefinisikan sebagai jarak
yang ditempuh oleh sebuah tour, semakin kecil jarak yang ditempuh maka semakin
besar nilai fitness yang didapat yakni f = 1/h dimana f adalah fitness dan h adalah
jarak yang ditempuh oleh sebuah tour.
Untuk mendapatkan jarak dari suatu tour, maka fungsi h didefinisikan
sebagaiberikut :
x
y

i
yi 1 )2
(
2
( ix i1) +
h=
Sehingga

nilai

kromosom-kromosom

pada

contoh

populasi

awal

yang

mempresentasikan setiap tour adalah:

Kromosom[1]

= 1 / (403,11 + 241,17 + 119,89 + 17,26 + 177,28 + 191,47 +

203,23) = 1 / 1353,41 = 0.00073

Kromosom[2]

= 1 / (274, 15 + 129,99 +170 + 17, 26 + 177,28 + 191,47 + 196)

= 1 / 1156.15 = 0.00085

Kromosom[3] = 1 / (274,45 + 64,13 + 17,26 + 177,28 + 50,99 + 196 + 246,25)

= 1 / 1026,36 = 0.00097

Kromosom[4] = 1 / (274,45 + 64,13 + 17,26 + 177,28 + 50,99 + 241,17 +

246,25) = 1 / ( 1071,53) = 0.00093
Kasus ini menggunakan seleksi metode turnamen, seleksi ini mengambil sejumlah
kromosom secara random dan menyeleksi berdasarkan nilai fitness sehingga didapatkan
dua kromosom dengan fitness tertinggi (dua tour dengan jarak terpendek) yang akan
dijadikan parent pada proses cross over. Seleksi ini juga menentukan dua kromosom
dengan nilai fitness terburuk yang nantinya akan digantikan dengan children yang
dihasilkan dari cross over. Dari nilai fitness yang sudah didapat, maka Kromosom[3]
dan Kromosom[4] akan menjadi parent. Sedangkan Kromosom[1] dan Kromosom[2]
akan digantikan oleh hasil dari proses cross over.
3.4. Cross Over
Dua masalah rumit ketika menggunakan algoritma genetika dalam kasus TSP
adalah pengkodean kromosom dan penentuan algoritmacross overyang digunakan
ketika menggabungkan dua parent tour untuk menghasilkan sebuah keturunan. Pada
algoritma genetika standar, pengkodean adalah urutan sederhana dan cross over
dilakukan dengan cara memilih secara acak satu gen pada parent dan menukar setiap
gen setelahnya dengan gen pada parent kedua. Seperti terlihat pada contoh berikut:
Tabel 3. Proses cross over algoritma genetika standar
Parent 1
Parent 2
Child 1
Child 2

FAB | E C G D
D E A| C G F B
FAB | C G B F
D E A| E C G D

Pada TSP, setiap kota hanya bisa dikunjungi satu kali dalam sebuah tour, sedangkan
pada hasil cross over di atas, child 1 mengunjungi F dab B sebanyak dua kali. Untuk
mengatasi hal tersebut proses cross over dapat diimplementasikan dengan skema order
crossover. Pada skema ini, satu bagian kromosom dipertukarkan dengan tetap menjaga
urutan kota yang bukan bagian dari kromosom tersebut.Hal tersebut dilakukan dengan
membangkitkan bilanganacak antara 1 sampai dengan panjang kromosom-1. Pada
contoh di atas bilangan acaknya adalah antara 1 sampai 6. Misal diperoleh bilangan
acak 1, maka gen yang ke-1 pada kromosom parent pertama diambil kemudian ditukar
dengan gen pada kromosom parentkedua yang belum ada pada parent pertama dengan
tetap memperhatikan urutannya.

Contoh

3.5. Mutasi
Proses mutasi sangatlah sederhana. Untuk semua gen yang ada, jika bilangan
random yang dibangkitkan kurang dari probabilitas permutasi yang ditentukan maka
ubah gen tersebut menjadi nilai kebalikannya. Program simulasi ini menggunakan
swapping mutation sehingga proses mutasinya dilakukan dengan cara melakukan
pertukaran tempat node secara acak.
4. IMPLEMENTASI

Inisialisasi variabel yang berkaitan

///<summary>
/// Starts the TSP algorithm.
/// To stop before all generations are calculated, set <see cref="Halt"/> to true.
///</summary>
///<param name="populationSize">Number of random tours to create before starting the
algorithm.</param>
///<param name="maxGenerations">Number of times to perform the crossover operation
before stopping.</param>
///<param name="groupSize">Number of tours to examine in each generation. Top 2 are
chosen as the parent tours whose children replace the worst 2 tours in the group.</param>
///<param name="mutation">Odds that a child tour will be mutated..</param>
///<param name="seed">Seed for the random number generator.</param>
///<param name="chanceToUseCloseCity">The odds (out of 100) that a city that is known
to be close will be used in any given link.</param>
///<param name="cityList">List of cities in the tour.</param>
publicvoid Begin(int populationSize, int maxGenerations, int groupSize, int mutation, int
seed, int chanceToUseCloseCity, Cities cityList)
{
rand = newRandom(seed);
this.cityList = cityList;
population = newPopulation();
population.CreateRandomPopulation(populationSize, cityList, rand,
chanceToUseCloseCity);
displayTour(population.BestTour, 0, false);
bool foundNewBestTour = false;
int generation;
for (generation = 0; generation < maxGenerations; generation++)
{

if (Halt)
{
break; // GUI has requested we exit.
}
foundNewBestTour = makeChildren(groupSize, mutation);
if (foundNewBestTour)
{
displayTour(population.BestTour, generation, false);
}
}
displayTour(population.BestTour, generation, true);
}

Skema pengkodean
<?xmlversion="1.0"encoding="utf-8" ?>
<CityList>
<CityX="160"Y="370"/>
<CityX="121"Y="132"/>
<CityX="58"Y="234"/>
<CityX="41"Y="213"/>
<CityX="143"Y="86"/>
<CityX="312"Y="176"/>
<CityX="121"Y="264"/>
<CityX="231"Y="366"/>
<CityX="380"Y="62"/>
<CityX="202"Y="260"/>
<CityX="241"Y="12"/>
<CityX="23"Y="356"/>
<CityX="43"Y="317"/>
<CityX="175"Y="134"/>
<CityX="260"Y="125"/>
<CityX="277"Y="386"/>
<CityX="312"Y="153"/>
<CityX="23"Y="256"/>
<CityX="313"Y="297"/>
<CityX="131"Y="96"/>
<CityX="87"Y="67"/>
<CityX="249"Y="283"/>
<CityX="307"Y="234"/>
<CityX="159"Y="167"/>
<CityX="285"Y="123"/>
<CityX="12"Y="34"/>
<CityX="85"Y="356"/>
<CityX="387"Y="125"/>
<CityX="135"Y="268"/>
<CityX="185"Y="345"/>
<CityX="75"Y="314"/>
<CityX="275"Y="45"/>
<CityX="313"Y="78"/>
<CityX="110"Y="67"/>
<CityX="256"Y="215"/>
<CityX="314"Y="164"/>
<CityX="342"Y="186"/>
<CityX="331"Y="214"/>
<CityX="141"Y="275"/>
<CityX="67"Y="389"/>

</CityList>
///<summary>
/// Create the initial set of random tours.
///</summary>
///<param name="populationSize">Number of tours to create.</param>
///<param name="cityList">The list of cities in this tour.</param>
///<param name="rand">Random number generator. We pass around the same random
number generator, so that results between runs are consistent.</param>
///<param name="chanceToUseCloseCity">The odds (out of 100) that a city that is known
to be close will be used in any given link.</param>
publicvoid CreateRandomPopulation(int populationSize, Cities cityList, Random rand, int
chanceToUseCloseCity)
{
int firstCity, lastCity, nextCity;
for (int tourCount = 0; tourCount < populationSize; tourCount++)
{
Tour tour = newTour(cityList.Count);
// Create a starting point for this tour
firstCity = rand.Next(cityList.Count);
lastCity = firstCity;
for (int city = 0; city < cityList.Count - 1; city++)
{
do
{
// Keep picking random cities for the next city, until we find one we haven't been to.
if ((rand.Next(100) < chanceToUseCloseCity) && ( cityList[city].CloseCities.Count > 0 ))
{
// 75% chance will will pick a city that is close to this one
nextCity =
cityList[city].CloseCities[rand.Next(cityList[city].CloseCities.Count)];
}
else
{
// Otherwise, pick a completely random city.
nextCity = rand.Next(cityList.Count);
}
// Make sure we haven't been here, and make sure it isn't where we are at now.
} while ((tour[nextCity].Connection2 != -1) || (nextCity == lastCity));
// When going from city A to B, [1] on A = B and [1] on city B = A
tour[lastCity].Connection2 = nextCity;
tour[nextCity].Connection1 = lastCity;
lastCity = nextCity;
}
// Connect the last 2 cities.
tour[lastCity].Connection2 = firstCity;
tour[firstCity].Connection1 = lastCity;
tour.DetermineFitness(cityList);
Add(tour);
if ((bestTour == null) || (tour.Fitness < bestTour.Fitness))
{
BestTour = tour;

}
}

Menghitung nilai fitness

privatedouble fitness;
///<summary>
/// The fitness (total tour length) of this tour.
///</summary>
publicdouble Fitness
{
set
{
fitness = value;
}
get
{
return fitness;
}
}
///<summary>
/// Determine the fitness (total length) of an individual tour.
///</summary>
///<param name="cities">The cities in this tour. Used to get the distance between each
city.</param>
publicvoid DetermineFitness(Cities cities)
{
Fitness = 0;
int lastCity = 0;
int nextCity = this[0].Connection1;
foreach (Link link inthis)
{
Fitness += cities[lastCity].Distances[nextCity];
// figure out if the next city in the list is [0] or [1]
if (lastCity != this[nextCity].Connection1)
{
lastCity = nextCity;
nextCity = this[nextCity].Connection1;
}
else
{
lastCity = nextCity;
nextCity = this[nextCity].Connection2;
}
}
}

Seleksi (Menggunakan metode seleksi turnamen)

privateTour bestTour = null;

///<summary>
/// The best tour found so far by the Genetic Algorithm.
///</summary>
publicTour BestTour
{
set
{
bestTour = value;
}
get
{
return bestTour;
}
}
///<summary>
/// Randomly select a group of tours from the population.
/// The top 2 are chosen as the parent tours.
/// Crossover is performed on these 2 tours.
/// The childred tours from this process replace the worst 2 tours in the group.
///</summary>
///<param name="groupSize">Number of tours in this group.</param>
///<param name="mutation">Odds that a child will be mutated.</param>
bool makeChildren(int groupSize, int mutation)
{
int[] tourGroup = newint[groupSize];
int tourCount, i, topTour, childPosition, tempTour;
// pick random tours to be in the neighborhood city group
// we allow for the same tour to be included twice
for (tourCount = 0; tourCount < groupSize; tourCount++)
{
tourGroup[tourCount] = rand.Next(population.Count);
}
// bubble sort on the neighborhood city group
for (tourCount = 0; tourCount < groupSize - 1; tourCount++)
{
topTour = tourCount;
for (i = topTour + 1; i < groupSize; i++)
{
if (population[tourGroup[i]].Fitness < population[tourGroup[topTour]].Fitness)
{
topTour = i;
}
}
if (topTour != tourCount)
{
tempTour = tourGroup[tourCount];
tourGroup[tourCount] = tourGroup[topTour];
tourGroup[topTour] = tempTour;
}
}
bool foundNewBestTour = false;
// take the best 2 tours, do crossover, and replace the worst tour with it
childPosition = tourGroup[groupSize - 1];

population[childPosition] = Tour.Crossover(population[tourGroup[0]],
population[tourGroup[1]], cityList, rand);
if (rand.Next(100) < mutation)
{
population[childPosition].Mutate(rand);
}
population[childPosition].DetermineFitness(cityList);
// now see if the first new tour has the best fitness
if (population[childPosition].Fitness < population.BestTour.Fitness)
{
population.BestTour = population[childPosition];
foundNewBestTour = true;
}
// take the best 2 tours (opposite order), do crossover, and replace the 2nd worst tour with it
childPosition = tourGroup[groupSize - 2];
population[childPosition] = Tour.Crossover(population[tourGroup[1]],
population[tourGroup[0]], cityList, rand);
if (rand.Next(100) < mutation)
{
population[childPosition].Mutate(rand);
}
population[childPosition].DetermineFitness(cityList);
// now see if the second new tour has the best fitness
if (population[childPosition].Fitness < population.BestTour.Fitness)
{
population.BestTour = population[childPosition];
foundNewBestTour = true;
}
return foundNewBestTour;
}

Cross over
publicstaticTour Crossover(Tour parent1, Tour parent2, Cities cityList, Random rand)
{
Tour child = newTour(cityList.Count);
// the new tour we are making
int[] cityUsage = newint[cityList.Count]; // how many links 0-2 that connect to this city
int city;
// for loop variable
int nextCity;
// the other city in this link
for (city = 0; city < cityList.Count; city++)
{
cityUsage[city] = 0;
}
// Take all links that both parents agree on and put them in the child
for (city = 0; city < cityList.Count; city++)
{
if (cityUsage[city] < 2)
{
if (parent1[city].Connection1 == parent2[city].Connection1)
{
nextCity = parent1[city].Connection1;
if (testConnectionValid(child, cityList, cityUsage, city, nextCity))

{
}

joinCities(child, cityUsage, city, nextCity);

}
if (parent1[city].Connection2 == parent2[city].Connection2)
{
nextCity = parent1[city].Connection2;
if (testConnectionValid(child, cityList, cityUsage, city, nextCity))
{
joinCities(child, cityUsage, city, nextCity);

if
if

if
if

}
}
(parent1[city].Connection1 == parent2[city].Connection2)
{
nextCity = parent1[city].Connection1;
(testConnectionValid(child, cityList, cityUsage, city, nextCity))
{
joinCities(child, cityUsage, city, nextCity);
}
}
(parent1[city].Connection2 == parent2[city].Connection1)
{
nextCity = parent1[city].Connection2;
(testConnectionValid(child, cityList, cityUsage, city, nextCity))
{
joinCities(child, cityUsage, city, nextCity);
}
}
}
}

// The parents don't agree on whats left, so we will alternate between using
// links from parent 1 and then parent 2.
for (city = 0; city < cityList.Count; city++)
{
if (cityUsage[city] < 2)
{
if (city % 2 == 1) // we prefer to use parent 1 on odd cities
{
nextCity = findNextCity(parent1, child, cityList, cityUsage, city);
if (nextCity == -1) // but if thats not possible we still go with parent 2
{
nextCity = findNextCity(parent2, child, cityList, cityUsage, city); ;
}
}
else// use parent 2 instead
{
nextCity = findNextCity(parent2, child, cityList, cityUsage, city);
if (nextCity == -1)
{
nextCity = findNextCity(parent1, child, cityList, cityUsage, city);
}
}
if (nextCity != -1)
{
joinCities(child, cityUsage, city, nextCity);

// not done yet. must have been 0 in above case.

if (cityUsage[city] == 1)
{
if (city % 2 != 1) // use parent 1 on even cities
{
nextCity = findNextCity(parent1, child, cityList, cityUsage, city);
if (nextCity == -1) // use parent 2 instead
{
nextCity = findNextCity(parent2, child, cityList, cityUsage, city);
}
}
else// use parent 2
{
nextCity = findNextCity(parent2, child, cityList, cityUsage, city);
if (nextCity == -1)
{
nextCity = findNextCity(parent1, child, cityList, cityUsage, city);
}
}
if (nextCity != -1)
{
}
}

joinCities(child, cityUsage, city, nextCity);

}
// Remaining links must be completely random.
// Parent's links would cause multiple disconnected loops.
for (city = 0; city < cityList.Count; city++)
{
while (cityUsage[city] < 2)
{
do
{
nextCity = rand.Next(cityList.Count); // pick a random city, until we find one
we can link to
} while (!testConnectionValid(child, cityList, cityUsage, city, nextCity));
}

joinCities(child, cityUsage, city, nextCity);

}
return child;
}

Mutasi
///<summary>
/// Randomly change one of the links in this tour.
///</summary>
///<param name="rand">Random number generator. We pass around the same random
number generator, so that results between runs are consistent.</param>
publicvoid Mutate(Random rand)
{
int cityNumber = rand.Next(this.Count);
Link link = this[cityNumber];
int tmpCityNumber;

// Find which 2 cities connect to cityNumber, and then connect them directly
if (this[link.Connection1].Connection1 == cityNumber) // Conn 1 on Conn 1 link points
back to us.
{
if (this[link.Connection2].Connection1 == cityNumber)// Conn 1 on Conn 2 link points back
to us.
{
tmpCityNumber = link.Connection2;
this[link.Connection2].Connection1 =link.Connection1;
this[link.Connection1].Connection1 = tmpCityNumber;
}
else// Conn 2 on Conn 2 link points back to us.
{
tmpCityNumber = link.Connection2;
this[link.Connection2].Connection2 = link.Connection1;
this[link.Connection1].Connection1 = tmpCityNumber;
}
}
else// Conn 2 on Conn 1 link points back to us.
{
if (this[link.Connection2].Connection1 == cityNumber)// Conn 1 on Conn 2 link points back
to us.
{
tmpCityNumber = link.Connection2;
this[link.Connection2].Connection1 = link.Connection1;
this[link.Connection1].Connection2 = tmpCityNumber;
}
else// Conn 2 on Conn 2 link points back to us.
{
tmpCityNumber = link.Connection2;
this[link.Connection2].Connection2 = link.Connection1;
this[link.Connection1].Connection2 = tmpCityNumber;
}
}
int replaceCityNumber = -1;
do
{
replaceCityNumber = rand.Next(this.Count);
}
while (replaceCityNumber == cityNumber);
Link replaceLink = this[replaceCityNumber];
// Now we have to reinsert that city back into the tour at a random location
tmpCityNumber = replaceLink.Connection2;
link.Connection2 = replaceLink.Connection2;
link.Connection1 = replaceCityNumber;
replaceLink.Connection2 = cityNumber;
if (this[tmpCityNumber].Connection1 == replaceCityNumber)
{
this[tmpCityNumber].Connection1 = cityNumber;
}
else
{
this[tmpCityNumber].Connection2 = cityNumber;
}
}

5. Kesimpulan dan Saran

Dari hasil simulasi di atas, dapat dilihat bahwa algoritma genetika dapat
dijadikan alat untuk mencari solusi pada TSP, dengan modifikasi yang diperlukan baik
pada jenis pengkodean, operasi seleksi, cross over,maupunmutasi sesuai dengan
masalah yang ditemukan pada TSP.

6. Referensi
[1] Fitrah, A., Zaky, A., & Fitrasani. (2006). PENERAPAN ALGORITMA
GENETIKA PADA PERSOALAN .
[2] Lalena, M. (n.d.). Retrieved 11 18, 2013, from http://www.lalena.com/
[3] Lukas, S., Anwar, T., & Yuliani, W. (2005). PENERAPAN ALGORITMA
GENETIKA UNTUK TRAVELING SALESMAN. 1-5.
[4] Informatika.Rerieved

11

18,2013,

www.informatika.web.id/algoritma-genetik.htm

7. Lampiran

from

Gambar 2. Screenshoot antarmuka

Gambar 3. Screenshoot Proses

Gambar 4. Screenshoot Hasil