Bilgisayar bilimlerinin çeşitli alanlarında (örneğin yapay zeka, veri yapıları veya şekil kuramı (graph theory) gibi) kullanılan arama algoritmalarından birsidir.

Algoritma, derin öncelikli drama (depth first search) üzerine kurulu olduğu için, literatürde “iterative deepening depth first search (yinelemeli derinleşen, derin öncelikli arama)” olarak da geçmektedir.

Algoritma basitçe derinlik değerini bir değişkende tutmakta ve bu değeri her adımda arttırmaktadır.
Yineleme yapısı (iteration) basit bir döngü (loop) olarak düşünülebilir ve her adımda derinliğin, bir döngü değişkeni (loop variable) gibi düşünülerek derinleştiği kabul edilebilir.

Örneğin aşağıdaki şekli (graph) ele alalım:

Ağaçta görüldüğü üzere iki adet döngü (cycle) bulunmaktadır. Iterative Deepening search algoritmasını bu ağaç üzerinde çalıştıracak olursak, algoritma öncelikle derinlik değerini (bundan sonra d değişkeni (variable) ile ifade edilecektir) 0′dan başlatarak her adımda bir ilerletecektir.

d=0 için arama:
A
d=1 için arama:
A (tekrar A değerine bakar) B C (sanki ağacın en üstteki üç düğümü, şekilde gösterildiği gibi bağlanmış kabul edilebilir, daha alttaki derinliklerde bulunan DEFG düğümlerine hiç bakamaz)
d=2 için arama:
A B D E C F G (Bu aramada sanki sondaki daireler (cycle) bulunmuyormuş gibi kabul edilebilir, çünkü belirtilen derinlik bu dairelere kadar inemez)
d=3 için arama:
A B D B E C F G A
d=4 için arama:
A B D B D E B C F G A B C

Yukarıdaki arma işlemi, derinlik arttıkça devam etmektedir.

Arama algoritmalarının değerlendirildiği bazı kriterler bulunmaktadır. Buna göre IDDFS (iterative deepening depth first search) algoriması “tam” algoritma olarak kabul edilebilir.
Tamlık teriminin (completeness) anlamı aşağıdaki şekilde tanımlanabilir:

Bir arama algoritması, bütün düğümleri dolaşarak aranan düğümü bulmayı garanti ediyorsa bu algoritmaya tam arama algoritması ismi verilir.

Örneğin yine yukarıdaki şekil için klasik derin öncelikli arama (depth first search) algoritmasını ele alsaydık, bu algoritmanın tam olmadığını söyleyebilirdik. Bunun sebebi DFS algoritmasının dolaşması sırasında, aşağıdaki döngüye girmesidir:

A B D B D B D ( B D ikilisi sosuza kadar tekrar eder)

Kısacası A B D düğümleri dışındaki düğümlere asla bakmaz. Bu anlamda tam olmadığını söyleyebiliriz.

BFS (breadth first search , yayılma öncelikli veya sığ öncelikli arama) algoritması ise her zaman için tam kabul edilebilir, sebebi bir sonraki derinlik seviyesine inmeden önce, bulunduğu seviyedeki düğümleri bitirmesi ve bu sayede bütün ağaca bakmayı garanti etmesidir.

Algoritmanın karmaşıklığına değinecek olursak. Aşağıdaki şekilde bir formül ile karşılaşırız.

Bu formülde görülen terimler şekil kuramında (graph theory) sıkça kullanılan bazı değerlere atıfta bulunur.
d değerinin derinlik olduğunu daha önce belirtmiştik. b ile gösterilen değer ise dallanma katasyısıdır (branching factor).

Kısaca her düğümün kaç çocuğu olduğu (out order, kaç düğüme gidilebildiği) olarak tutulur. Örneğin tam dolu ikili arama ağacının (binary search tree) b değeri 2′dir. Genelde en kötü durum analizinde bütün çocukların dolu olması ihtimali üzerinde durulur. Ayrıca istatistiksel olarak ortalamam çocuk sayısının da alındığı olur. Örneğin şehirlerin tutulduğu bir şekilde, her şehirden gidilebilecek şehir sayısı değişmektedir. Bu durumda b değeri ortalama değer olarak hesaplanabilir.

Bu açıklama ardından yukarıdaki denkleme tekrar bakarak anlamaya çalışalım.

IDDFS algoritmasında, en altta bulunan düğümlerin 1 kere (d sabitlendiğinde en altta kalan düğümler hangileri ise) dolaşıldığını, d-1 derinliğindeki düğümlerin ise 2 kere dolaşıldığını ve böylece kök düğüme (root) kadar her düğümün, bulunduğu seviyeye göre kaç kere dolaşıldığını hesaplayabileceğimize göre yukarıdaki denklem çıkarılabilir.

Diğer bir deyişle d=0 için kök 1 kere dolaşılırken d=1 olduğunda kök 2 ve kökün çocukları 1 kere dolaşılmış olur. d=3 olduğunda kök 3 kere ve çocukları 2 ve en alttaki çocuklar ise 1 kere dolaşılmış olur. Görüldüğü üzere derinliğin her artışında kök derinlik kadar altındaki her düğüm ise birer azalarak en nihayetinde yapraklar (leaf) tek bir kere dolaşılmış olmaktadır.

Sonuç olarak Yukarıdaki formülün ilk terimi kök (d+1)1 (tek düğüm d+1 kere dolaşılmıştır) , ikinci terimi kökün çocukları (db (kökün çocukları (ki sayısı b’dir) derinlik kadar (ki d ile gösterilir) dolaşılmıştır).

Yukarıdaki bu formülü daha toplu şekilde aşağıda gösterildiği gibi yazabiliriz:

Algoritmanın dolaşma (arama) zamanı karmaşıklığı yukarıda gösterildiği gibidir. Terimler birleştirildiğinde en kötü durum analizi (worst case analysis) için O(b^d) gösterimi kullanılabilir.

Hafıza karmaşıklığı ise O(bd) olarak ifade edilebilir. Bunun sebebi d derinliğindeki bir ağacın her seviyesinde b adet çocuğu bulunması durumunda bd kadar düğüm olacağıdır. Algoritma, çalışması sırasında ilave düğümlere ihtiyaç duymaz ve şeklin kendisi üzerinde dolaşarak sonuca ulaşır.

387 views

Yazan : Şadi Evren ŞEKER

İyileştirme problemleri açısından klasik bir örnektir (optimisation problems). Problem basitçe bir kutunun içerisine en az boş alan bırakarak, eşyaların en iyi şekilde nasıl yerleştireceği olarak düşünülebilir.

Aslında problemi boyutlara göre incelersek aşağıdaki şekilde bir liste yapılabilir:

Tek boyutlu kutulama (1D bin packing) :Bu problemde amaç bir çizgi veya hat gibi görülebilecek yapının içerisine farklı boyutlardaki çizgileri yerleştirmek olarak düşünülebilir.

Örneğin zaman çizelgelemesinde, bir kişinin yapacağı işleri, zaman çizgisinin üzerine yerleştirmesi (ve her işin farklı miktarda zaman gerektirdiğini ve kişinin çalışma saatlerinin sınırlı olduğunu düşünürsek en fazla işi en az zamanda (örneğin 8 saatlik mesailer içinde) yapması ) bir problemdir. Buradaki hem kişinin yapacağı işler hem de bu işlerin yerleştirileceği zaman çizgisi tek boyutludur.

Daha basit olması açısından örneğin 100m uzunluğundaki bir ipi 7 ve 9m uzunluğundaki parçalara en az fire ile bölmek istiyoruz, en verimli bölme işleminde kaç adet 7 ve kaç adet 9 uzunluğunda ipimiz olur gibi soruları düşünebiliriz. Bu tip sorular tek boyutlu kutulama problemleridir.

İki boyutlu kutulama problemleri (2D bin packing optimization): Bu grupta bir tablodan ve iki boyuttan bahsedilebilir. Örneğin kot pantolon üreten bir tekstil firmasında farklı boyutlardaki Pantolon kalıplarının en az fire ile 5x5m büyüklüğündeki bir kare kumaştan kesilmesi isteniyor olsun. Bu problem iki boyutlu (x ve y boyutları) bir kutulama problemidir. Benzer bir problem, bir gazetedeki seri ilanların, en az fire ile sayfaya yerleştirilmesi olarak da düşünülebilir.

3 boyutlu kutulama (3D bin packing) problemin en zor şekli olarak tanımlanır ve 3 boyutlu bir kutunun içerisine konulan her şeklin farklı x,y ve z boyutlarında şekiller olması olarak düşünülebilir. Problemin genel tanımını yaptığımız için belirteyim, örneğin ev taşıma sırasında çıkan eşyaların kutulanması olarak düşünebilirsiniz. Bu durumu daha da karmaşık yapmaktadır çünkü kutular farklı boyut ve şekillerdedir (örneğin silindir bir varil veya küp veya dikdörtgenler prizması gibi kutuların içerisine yerleştirme yapılmakta) ve kutulanan şekillerde farklıdır ve hatta girintilidir (concave , non-convex) (örneğin avize, koltuk, sandalye gibi birbirinin içine girebilen nesneleri düşününüz). 2 ve 3 boyutlu paketleme, paketlenen nesnelerin girintili olup olmamasına göre ikiye ayrılmaktadır. Dış bükey nesnelerin paketlenmesi nispeten daha basit bir problemdir. Ancak nesnelerin iç bükey olması halinde problem biraz daha karmaşıklaşır.

Hatta literatürdeki kısıtlı aramalarım sonucunda ulaşabildiğim kadarıyla tam olarak iç bükey nesnelerin paketlenebildiği bir sonuç ne yazık ki bulamadım. Örneğin iki vidanın en verimlim paketlenmesi sırasında vidaların girinti çıkıntılarının üstüste gelmesi gerektiğini tecrübi olarak biliyoruz. N adet vida için bu durum birbirini tekrar eden bir hal alır. Gerçekten farklı boylarda ve adım sıklığında ve çaplarda vidalar verilse bu durumda en verimli paketlemeyi yapabilen bir algoritma henüz görmedim.

Paketlenen nesnelere göre problemin sınıflandırılması:

Paketlenen nesne çeşitlerinin sabit olması ve ön tanımlı olması halinde problem homojen olarak tanımlanır. Örneğin tek boyutlu kutulama probleminin tanımı sırasında verilen ve “100m uzunluğundaki bir ipi 7 ve 9m uzunluğundaki parçalara en az fire ile bölmek” şeklinde geçen örnek bu tip homojen (homogenous) bir yapıdadır. Buna karşılık heterojen bir problemde, paketlenecek nesnelerin tipleri ya tamamen birbirlerinden farklıdır ya da aynı tipte çok az tekrar vardır. Yine tek boyutlu problem örneğinde verilen zaman çizgisi üzerinde farklı uzunluklardaki randevuların yerleştirilmesi bu tiptendir.

Bu anlamda aşağıdaki problemler, kutulama probleminin birer özel hali olarak düşünülebilir:

• kamyon yükleme problemi (truck loading),

• konteyner yükleme problemi (Container loading problem, CLP)

• şerit paketleme problemi (Strip Packing problem, SPP)

Yukarıda, problemin tanımını yaptıktan sonra çözümlere bir göz atalım:

Homojen tek boyutlu problem çözümü

Şayet problem tek boyutlu ise ve homojen nesnelerin paketlenmesi olarak problemin çözülmesi isteniyorsa problem oldukça basit demektir ve basit matematiksel hesaplamalar ile problemi çözebiliriz.

Örneğin tek nesne ve tek paket varsa işlem basitçe paketin nesneye bölümü olarak bulunur (zaten burada zor Bir şey de yok):

Örneğin 100m uzunluğundaki bir ipten kaç tane 5m uzunluğunda ip kesilebilir:

100 / 5 = 20

biraz daha zorlaştırıp ip sayısını 2 çeşide veya 3 çeşide çıkarırsak problem np-tam (np-complete) bir hal alır. Örneğin aşağıdaki kodu inceleyelim:

Kodda görüldüğü üzere bütün ihtimaller denenmektedir. Basitçe herhangi bir k değeri için, k-a ve k-b değerlerini denemekte ve denenen duruma göre a veya b değerini bir arttırmaktadır. Aslında kodumuz basit bir ikili ağaç (binary tree) oluşturmaktadır:

Önce 9 veya 7 ile başlanması ihtimalleri:

Sonra bu ihtimallerin de 7 veya 9 azalma ihtimalleri:

Yukarıda gösterildiği gibi her düğümden yine ikişer ihtimal indirerek bir alt seviyeye geçilebilir. Neticede 0 olana kadar yapılan bir aramadır ve 0 sonucuna birden farklı yoldan ulaşılabilir.

Kodumuz çalıştırıldığında çözüm olarak aşağıdaki sonuçları üretmektedir:

cozum : 7*4 + 9*8

cozum : 7*13 + 9*1

Gerçekten de problemin iki farklı çözümü bulunmaktadır.

Yukarıdaki kod basit bir hesaplama ile, 2′nin üstlerinin toplamı kadar adım hesaplamaktadır.

Bu değer yukarıdaki ağaçtan çıkarılabilir:

ilk düğüm için tek ihtimal 2 ⁰

ikinci seviye için iki ihtimal: 2 ¹

üçüncü seviye için dört ihtimal 2 ²

şeklinde gitmektedir ve örneğin problemimiz üçüncü seviyede çözülseydi (sonuç 0 olsaydı) o zaman karmaşıklığımız bu değerlerin toplamı olacaktı ve 2 ⁰ + 2 ¹ + 2 ² şeklinde hesaplanacaktı.

Bu değer, ikili ağaçlardan bilindiği üzere 2 ⁿ-1 şeklinde hesaplanabilir.

Görüldüğü üzere yukarıdaki algoritma O(2 ⁿ) değerinde bir karmaşıklığa sahiptir ve bu değer bir çok terimli (polynom) değildir yani algoritmanın karmaşıklık sınıfı np-tam (NP-Complete) olarak belirtilebilir. Ayrıca yukarıdaki k değeri için bir çözüm bulunmuştur ancak çözüm bulunamasaydı bu değer k terim için denenecekti. Yani 100 için çözüm yoksa bir yaklaşığı olan 99 için ardından iki yaklaşığı 98 için … Bu işlem hiç çözüm bulunamaması halinde k terim için denenecekti.

Yukarıdaki problem, dinamik programlama (dynamic programming) kullanılarak iyileştirilebilir. Bunun sebebi arama işlemi sırasında bazı sonuçların tekrar etmesidir. Örneğin yukarıdaki ikili ağacı aşağıdaki şekilde çizebiliriz:

Farka dikkat ederseniz, 93 – 9 = 84 ve aynı zamanda 91-7 = 84 olduğu görülür. Bu durumda aslında 84 değeri bir önceki kodda iki farklı durum için aranmaktayken şimdi tek bir durum için aransın istiyoruz. Elbette 84 sadece bir örnektir ve buna bağlı olarak çok sayıda tekrar eden değer bulunmaktadır.

Hesaplanan bu değerleri bir dizi (array) içerisinde tutup tekrar hesaplanmasını engellemek istiyoruz:

Yukarıdaki yeni kodda, bir dizi içerisinde tek döngü ile sonucu hesaplattık. Buna göre algoritmamız iki elemanlı bir diziyi kullanmakta, dizinin 0. elemanları 7lerin sayısını ve 1. elemanları ile 9ların sayısını saymaktadır.

Kodumuz ilk başta 0 için 0 tane 7 ve 0 tane 9 gerektiği gerçeği ile çalışmaya başlıyor. 14-23. satırlar arasındaki döngü basitçe i. terim için i-a ve i-b değerlerine bakıyor. Şayet i. terim için i-a veya i-b değerinde bir çözüm varsa (nereden geldiğini önemsemeksizin) bu çözüme bulduğu koşulu ilave ederek mevcut i değeri için çözümü kaydediyor. Şayet bu iki terim de bulunmuyorsa o zaman bir sonraki i değerine geçiyor.

Ekran çıktısı aşağıdaki şekildedir:

Son 20 satır görülmekle birlikte daha önceki satılar alıntılanmamıştır. Ayrıca son 20 satırda görüldüğü üzere, tamamına ait bir çözüm bulunmaktadır. Örneğin 88 sayısı için 7*10 + 9*2 = 88 sonucuna ulaşılmıştır. En son satırda ise 100 için 7*13 + 9*1 sonucu görülmektedir.

Görüldüğü üzere birden fazla sonuç olsa bile tek bir sonucu görmekteyiz bunun sebebi veri yapısının bir sonuç üretmek üzere tasarlanmış olmasıdır. Elbette daha farklı veri yapıları kullanılarak diğer çözümleri de gösteren sonuçlar elde edilebilir.

Yukarıdaki algoritmanın karmaşıklığı ise bir öncekine göre oldukça iyi sayılabilecek O(n) olarak bulunur. Bunun sebebi dizideki her elemanın üzerinden tek bir kere geçiyor olması ve dolayısıyla tek bir döngünün (koddaki 14-21 satırlar arası) çalışıyor olmasıdır.

569 views

Yazan : Şadi Evren ŞEKER

Bilgisayar bilimlerinde, şekil kuramında (graph theory) kullanılan en kısa kesim (minimum cut) problemine yönelik bir iyileştirme (optimization) ağacıdır.

Algoritmanın amacı, bir ağaç (tree) oluşturmak ve oluşturulan ağaçta, bir şekildeki (graph) kesme ihtimallerini hesaplamaktır.

Algoritmanın çalışmasını bir örnek üzerinden anlamaya çalışalım. Öncelikle en kısa kesimi bulacağımız şeklimiz (graph) aşağıdaki şekilde verilmiş olsun:

Yukarıda, yönsüz ve ağırlıklı bir şekil görülmektedir (undirected, weighted graph). Amacımız bu şekli düz bir şekilde kestiğimizde en az maliyetli kesiği bulmaktır. Konuyu anlamak için bir kesim örneği ele alalım:

Yukarıdaki kesim sırasında, A-B, A-D, E-D, F-D bağları kesilmiştir. Bu bağların toplam maliyeti 5+7+5+7 = 24 değerindedir.

İşte bizim amacımız farklı şekillerde yapılabilecek kesme eylemlerinden en az maliyete sahip olanını bulmaktır.

Algoritmamız ilk olarak bütün düğümlerin toparlandığı bir büyük düğüm ile başlıyor.

Şekilde görüldüğü üzere, bütün düğümleri içerisine alan tek bir düğümümüz bulunuyor. Şimdi rast gele seçilen iki düğüm arasındaki en küçük kesimi buluyoruz.

Bu aşamada rast gele olarak B ve E düğümlerini aldığımızı düşünelim.

Bu iki düğüm arasındaki en düğük maliyetli kesme aşağıda verilmiştir.

Yukarıdaki şekilde, görüldüğü üzere, A-B, B-D ve D-C kenarları kesilmiş ve bunun karşılığında 12 maliyetinde bir kesim elde edilmiştir. Algoritmamız, bu kesim işlemini düğümlerin tutulduğu grup üzerinde de uygular.

Aslında bu aşamada algoritma artık anlaşılmaktadır. Algoritmamız bu şekilde rast gele düğümler seçerek her grupta tek düğüm kalana kadar şekli parçalamaya devam edecek ve sonra en kısa maliyetli kenarı alacaktır.

Bu işlemi örnek üzerinde görmeye devam edelim.

Algoritmamızın şimdiki aşamasında, gruplardan birisini ve sonrada bu gruptaki düğümlerden iki tanesini seçeceğiz.

Örneğin B ve C düğümlerini seçtiğimizi düşünelim. (Bu aşamada farklı gruplardan iki düğüm seçemiyoruz. Örneğin B ve A düğümleri seçilemezdi. Ancak diğer gruptan iki düğüm seçebilirdik. Örneğin A ve D düğümleri olabilirdi).

B ve C düğümleri arasında tek bir kesme mümkündür ve bu da aşağıdaki şekilde işaretlenmiştir:

Yukarıdaki şekilde görüldüğü üzere, B-C ve C-D kenarları kesilmiş ve maliyet olarak 9 maliyetinde bir kesim elde edilmiştir. Bu durum algoritmamızın çalışmasını tutan resmin sağ tarafında gösterilmiştir. Yani bir önceki adımda beraber duran B ve C düğümleri ayrılmış ve iki ayrı düğüm olarak gomory-hu ağacında gösterilmiştir.

Bir sonraki adımda yine iki rast gele düğüm seçiyoruz. Bu sefer düğümlerimiz E ve F olsun.

Yeni halimizde E düğümü de tek başına ağacımızda yerini almıştır (resmin sağ tarafı).

Rast gele düğüm seçimine devam ediyoruz ve bu sefer D ve F düğümlerini seçelim.

D ve F düğümleri arasında, iki farklı kesim alınabilirdi. En düğük maliyetli olan alternatif yukarıda zaten gösterilmiştir, ayrıca E-D ve F-D kesimi de alınabilirdi, ancak daha önce de belirttiğimiz üzere, en düşük maliyetli olanını alıyoruz.

Gelelim son ayrıma, A-D kesimi aşağıdaki şekilde yapılmıştır:

Bu son kesimle birlikte, ağacımızı tamamlamış oluyoruz ve algoritmamız çalışmasını bitiriyor. Buna göre yukarıdaki ağaçta iki tane minimum kesim (minimum cut) olabilir. Bunlardan birincisi B-C arasındaki 9 maliyetindeki kesim, ikincisi ise A-E arasındaki 9 maliyetindeki kesim.

279 views

Bilgisayar bilimlerinde sıkça kullanılan sonlu durum makinelerinin (finite state machine, FSM veya Finite State Automaton , FSA) gösteriminde kullanılan iki farklı yöntemdir. Genelde literatürde bir FSM’in gösteriminde en çok moore makinesi kullanılır. Bu iki yöntem (mealy ve moore makinaları) sonuçta bir gösterim farkı olduğu için bütün mealy gösterimlerinin moore ve bütün moore gösterimlerinin mealy gösterimine çevrilmesi mümkündür.

Klasik bir FSM’de bir giriş bir de çıkış bulunur (input / output). Bu değerlerin nereye yazılacağı aslında iki makine arasındaki farkı belirler.

Moore makinelerinde çıkış değerleri düğümlere (node) yazılırken, giriş değerleri kenarlar (edges) üzerinde gösterilir.

Mealy makinelerinde ise giriş ve çıkış değerleri kenarlar (edges) üzerinde aralarına bir taksim işareti (slash) konularak gösterilir. Örneğin 1/0 gösterimi, girişin 1 ve çıktının 0 olduğunu ifade eder.

Basit bir örnek olarak özel veya (exclusive or, Ä) işlemini ele alalım ve her iki makine gösterimi ile de çizmeye çalışalım.

Klasik bir XOR kapısı, yukarıdaki doğruluk çizelgesinde (truth table) gösterildiği üzere iki giriş ve bir çıkıştan oluşur. Bizim makinemiz de ilk girdiden sonra ikinci girdiyi aldığında beklenen çıktıyı vermeli. Ayrıca makine sürekli olarak çalışmaya devam edecek. Örneğin 101011 şeklinde bir veri akışı sağlanması durumunda, sonuç olarak 1Ä0Ä1Ä0Ä1Ä1 değerini hesaplamasını isteriz.

Yukarıdaki gösterim bir mealy makinesidir. Makinede görüldüğü üzere 3 farklı durum arasındaki geçişler üzerine iki adet değer yazılmıştır. Bu değerlerden ilki giriş ikincisi ise çıkış değeridir.

Makineyi beraber okumaya çalışalım.

Makinenin boşluktan bir ok ile başlayan durumu, yani örneğimizdeki S0 durumu, başlangıç durumudur. Bu durumdan başlanarak gelen değerlere göre ilgili duruma geçilir.

Örneğimizi hatırlayalım. Giriş olarak 101011 dizgisini (string) almayı planlamıştık. Bu durumda ilk bitimiz 1 olarak geliyor ve S0 durumunda 1 girişi ile S2 durumuna geçiyoruz. Burada geçiş sırasında kullanılan kenarın üzerindeki değeri okuyalım: 1/0 bunun anlamı 1 geldiğinde geçilecek kenar olması ve çıktının 0 olmasıdır. Yani şu anda çıktımız 0

Ardından gelen değer 0 (yani şimdiye kadar 01 değerleri geldi). En son makinemizdeki durum, S2 durumuydu, şimdi yeni gelen değeri bu durumdaki kollardan takip ediyor ve S1′e giden 0/1 kenarını izliyoruz. Bu kolu izleme sebebimiz, S2 durumundan gidilen tek 0 girdisi kolu olmasıdır. Bu kol üzerindeki ikinci değer olan 1 ise, çıktının 1 olduğudur. Yani buraya kadar olan girdiyi alacak olsaydık 01 için 1 çıktısı alacaktık.

İşlemlere devam edelim ve durumları yazmaya çalışalım:

Yukarıdaki tablomuzun son halinde, çıkış değeri olarak 0 okunmuştur. Yani örneğimizin neticesi 0 olacaktır.

Aynı örneği moore makinesi olarak tasarlayacak olsaydık:

Moore makinesinde, mealy makinesine benzer şekilde boşluktan gelen bir ok, başlangıç durumunu belirtir.

Makinenin, durumlarında, mealy makinesinde olmayan değerler eklenmiştir. Bu değerler, ilgili durumdaki çıktıyı gösterir. Örneğin makinemiz S1 durumundayken çıktı 0 olarak okunabilir.

Şimdi moore makinesinde, aynı örneği çalıştırıp sonucu karşılaştıralım.

Giriş olarak 101011 dizgisini (string) almayı planlamıştık. Bu durumda ilk bitimiz 1 olarak geliyor ve S0 durumunda 1 girişi ile S2 durumuna geçiyoruz. Bu geçiş sonucunda geldiğimiz S2 durumunda okunan çıktı değeri 0 yani sonuç şimdilik 0.

Ardından gelen 0 değeri ile S3 durumuna geçiyoruz ve çıktımız 1 oluyor. Çünkü S3 durumu 1 çıktısı veren durumdur. Bu şekilde durumları ve durumlar arasındaki geçişleri izlersek, aşağıdaki tabloyu çıkarabiliriz:

Görüldüğü üzere, makinemiz, örnek girdi için S2 durumunda sonlanıyor ve bu durumda çıktımız 0 olarak okunuyor.

812 views

Bu yazının amacı, eğitimimiz sırasında sürekli olarak okuduğumuz bir teori olan tertip teorisi (sıralama teorisi , order theory) konusunda bulunan kavramları (preorder, postorder gibi) açıklamaktır. Osmanlıda bu konuya nazariyatül tertip ismi verilmektedir.

Nazariyatül tertip, bilgisayar bilimleri de dahil olmak üzere pek çok matematiksel problemin çözümünde kullanılmaktadır. Örneğin sıralama algoritmaları, arama algoritmaları gibi basit algoritmalar, bu nazariye üzerinden çalışmaktadır.

Her şeye en basitten başlayalım ve ilk okulda öğrendiğimiz < veya > işaretlerinin aslında bu nazariyenin en temel işlemleri olduğunu belirtelim. Buna göre biz tam sayılar arasında bir sıralama (tertip) işlemi yaparken aslında bu teorinin bir uygulamasını yapıyoruz.

Örneğin aşağıdaki tanımı ele alalım:

Partially Ordered Sets (kısmi tertipli kümeler)

Bir kümenin aşağıdaki özellikleri taşıması durumunda verilen isimdir:

a ≤ a (yansıma (reflexive) özelliği)

a ≤ b ve b ≤ a ise a = b (ters simetri özelliği (antisymmetry))

a ≤ b ve b ≤ c ise a ≤ c (geçişlilik (transitivity)).

Örneğin yukarıdaki özelliklerin hepsi sayma sayıları kümesi için geçerlidir.

Bu kümeye İngilizcedeki partially ordered sets isminin ilk iki kelimesini birleştirerek poset ismi de verilir.

Preorder (Öntertip)

Bir değerin diğerinden önce gelmesi prensibine dayanır. Öntertip şartının sağlanması için, bir serideki değerler arasında yansıma (reflexive) ve geçişlilik (transitivity) özellikleri bulunmalıdır. Ancak ters simetri (Anti symmetry) bulunmak zorunda değildir.

Buna göre sadece a < b < c şeklindeki bir seri, öntertip olarak kabul edilebilir ve bu bağlantı özelliklerinde anti simetriden gelen eşitlik bulunmak zorunda değildir.

İşlem Tertipleri

Matematiksel olarak bütün gösterimleri bir dil olarak kabul etmek mümkündür. Bu anlamda işlemleri ifade eden matematiksel gösterimler de birer dildir ve bazı kurallara tabidir. Matematiksel işlemlerin gösteriminde kullanılan yazım şekilleri farklılık gösterebilir.

Örneğin klasik olarak kullanılan matematiksel işlemler,  herhangi bir işlem olmak ve a ve b birer fiil (predicate) olmak üzere, işlemler aşağıdaki şekillerde gösterilebilir:

1. Inorder (iç tertip infix ): a  b
2. Preorder (Ön tertip, prefix ):  a b
3. Postorder (Son tertip, postfix): a b 

Yukarıdaki yazılımlardan iç tertip gösterimi, ülkemizde ilk okullardan beri öğretilen gösterimdir. Örneğin ” 5 + 6 ” gösteriminde + işlemi iki değerin arasında yer almaktadır.

“+ 5 6″ ön tertbi veya “5 6 +” son tertibi de çeşitli matematiksel gösterimlerde kullanılmaktadır.

Örneğin programlama dillerinde de sıkça kullanılan fonksiyon çağırımı bir ön tertiptir.

F 4 5

Gösteriminde, F fonksiyonuna 4 ve 5 değerleri birer parametre olarak verilmiştir. Benzer bir kullanım komut satırında da programlara parametre verilirken geçerlidir.

cp a.txt b.txt

Yukarıdaki gösterimde a.txt dosyası, b.txt dosyası olarak kopyalanmış bu sırada, işleme (cp) parametreler prefix (öntertip) sırasıyla verilmiştir.

Ağaç Dolaşma Algoritmaları (Tree Traverse Algorithms)

Sıralama teorisinin diğer bir kullanım alanı da ağaçlardır. Herhangi bir ağacın dolaşılması sırasında yukarıda açıklanan sıralamalar kullanılabilir.

Konuyu en çok kullanılan ikili ağaçlar (binary tree) üzerinden açıklamaya çalışalım.

Yukarıdaki ağaç örneği, ikili ağaç olmanın yanında, ikili bir arama ağacı (binary search tree) olma özelliğini de taşır.

Buna göre her düğümün solundaki düğümler, kendisinden küçük ve sağındaki düğümler ise kendinden büyük değerler taşımak zorundadır.

Yukarıdaki herhangi bir düğümü aldığımızda aşağıdaki gibi bir durum ortaya çıkar.

Yukarıdaki gösterim, ikili arama ağacının bütün düğümleri için geçerlidir. Belki yaprak düğümler (leaf nodes, ağacın en altındaki düğümler) için bu durumun geçerli olmadığını düşünebilirsiniz ancak, en sondaki bu düğümlerin de sol ve sağında alt düğümler bulunmakta ancak bu düğümlerin değeri boş (null) olmaktadır. (daha detaylı bilgi için ikili arama ağacının kodlamasına bakabilirsiniz)

İkili arama ağaçlarında 6 farklı dolaşım mümkündür. Zaten bu değer 3!’dir. Bu dolaşımları yukarıda modellediğimi 3 düğümden oluşan ağaç için sıralayalım:

1. NLR
2. NRL
3. LNR
4. RNL
5. LRN
6. RLN

Yukarıdaki gösterimleri, N (ata) düğümün konumuna göre 3 sınıfta toplamak mümkündür.

1. Infix (iç tertip , inorder) : LNR ve RNL
2. Prefix ( öntertip , preorder): NLR ve NRL
3. Postfix (sontertip, postorder): RLN ve LRN

Yukarıdaki bu gösterimleri birer işlem ağacı olarak da düşünmek mümkündür. Örneğimizi aşağıda çizerek anlatmaya çalışalım:

Yukarıdaki ağaçta bulunan değerleri 6 farklı gösterim için okuyalım:

1. NLR : + 5 7
2. NRL : + 7 5
3. LNR : 5 + 7
4. RNL : 7 + 5
5. LRN : 5 7 +
6. RLN : 7 5 +

Bu gösterimlerden örneğin LNR gösterimi bizim klasik olarak ilk okuldan beri gördüğümüz toplama işlemini ifade eder.

Buna karşılık RNL gösterimi ise işlemin tersini ifade etmektedir ve toplama örneği için doğru olmakla birlikte, çıkarma (-) işleminde LNR ve RNL sırası fark etmektedir.

Şimdi örnek olarak aldığımız ilk ağaca dönelim ve 6 farklı dolaşmaya göre sayıları listeleyelim:

1. NLR : 10 7 3 9 15 13 18
2. NRL : 10 15 18 13 7 9 3
3. LNR : 3 7 9 10 13 15 18
4. RNL : 18 15 13 10 9 7 3
5. LRN : 3 9 7 13 18 15 10
6. RLN : 18 13 15 9 3 7 10

Yukarıdaki ağaç dolaşma algoritmalarından, 1. Ve 2. Sırada olanları (ikisi de öntertiptir (preorder)) literatürde, önce düğüme sonra altındaki düğümlere baktığı için sığ öncelikli dolaşma / arama (breadth first search) olarak isimlendirilir.

Buna karşılık diğer 4 dolaşma sıralaması, önce derindeki bir düğüme sonra ataya baktığı için derin öncelikli (depth first search) olarak geçer.

Yine yukarıdaki sıralamalarda dikkat edilecek bir huşu, LNR gösteriminin, ağacı küçükten büyüğe, RNL gösteriminin ise ağacı büyükten küçüğe sıraladığıdır. Bu özellik, ağaç sıralaması (tree sort) olarak geçen sıralama algoritmasının temelini oluşturur.

İşlem Tertiplerinin Dönüşümü

Örneğin elimizde içtertip (infix) bir işlem bulunsun ve biz bu tertibi örneğin son tertip (postfix) olarak çevirmek isteyelim:

(3 + 5) + (7 + 8 )

Öncelikle yukarıdaki işlemin parçalama ağacını (parse tree) oluşturuyoruz.

Yukarıdaki ağaçta, işlem önceliğine göre parçalama yapılmıştır. Örneğin 3 ve 5 sayılarını birleştiren işlem + işlemidir. Benzer şekilde 7 ve 8 sayıları diğer bir toplama işlemi ile birleştirilmiş ve neticede (kökte) her iki işlem toplanmıştır.

Şimdi bu ağacı öğrendiğimiz ön tertip yöntemine göre dolaşalım:

NLR : + + 3 5 + 7 8

Yukarıdaki gösterim, verilen işlemin son tertibe çevrilmiş halidir. Benzer durum son tertip için de geçerlidir:

LRN : 3 5 + 7 8 + +

Şayet örneğimiz aşağıdaki şekilde olsaydı:

3 + 5 + 7 + 8

Bu durumda parçalama ağacında bir belirsizlik oluşacaktı (ambiguity).

Örneğin, yukarıdaki bu yeni işlem, yukarıdaki parçalama ağacı gibi parçalanabilirken aynı zamanda aşağıdaki ağaçlardan birisi olarak da parçalabilir:

Veya

Yukarıdaki her iki gösterim de aslında matematiksel olarak işlemden çıkarılabilecek sonuçlardır.

Örneğin yukarıdaki işlemi şu 3 farklı şekilde parantezlere almak (veya 3 farklı sırada çözmek mümkündür)

(3+5)+(7+8)

3+(5+(7+8))

((3+5)+7)+8

Bu üç yaklaşımda doğrudur. Bu durumda, işlemin ön tertip çevirimi 3 farklı şekilde olabilecektir ve 3ü de doğrudur:

(3+5)+(7+8) → + + 3 5 + 7 8

3+(5+(7+8)) → + + + 7 8 5 3

((3+5)+7)+8 → + + + 3 5 7 8

Benzer durum son tertip için de geçerlidir:

(3+5)+(7+8) → 3 5 + 7 8 + +

3+(5+(7+8)) → 3 5 7 8 + + +

((3+5)+7)+8 → 8 7 3 5 + + +

Yukarıdaki bu dönüşümlerden görüleceği üzere artık belirsizlik durumu kalkmıştır. Yani dönüşümlerden herhangi birisinin tercih edilmesi halinde iç tertip durumundaki belirsizlik kaybedilir. Bu anlamda tam bir dönüşüm olduğunu söylemek mümkün olmaz.

290 views

Yazan : Şadi Evren ŞEKER

Bu algoritmanın amacı, bir şekil (graph) üzerindeki, bir kaynaktan (source) bir hedefe(target veya sink) giden en kısa yolu bulmaktır. Algoritma ağırlıklı şekiller (weighted graph) üzerinde çalışır ve bir anlamda Dijkstra algoritmasının iyileştirilmişi olarak düşünülebilir.

Algoritma aslında Dijkstra algoritmasından daha kötü bir performansa sahiptir ancak graftaki ağırlıkların eksi olması durumunda Dijkstra’nın tersine başarılı çalışır.

Algoritma Dijkstra algoritmasında olduğu gibi en küçük değere sahip olan kenardan gitmek yerine bütün graf üzerindeki kenarları test eder. Bu sayede aç gözlü yaklaşımının (greedy approach) handikabına düşmez ve her düğüme sadece bir kere bakarak en kısa yolu bulmuş olur.

Algoritmanın çalışmasını yukarıdaki gibi eksi değerlere sahip bir şekil üzerinden anlamaya çalışalım.

Öncelikle düğümlere değer ataması yapılıyor. Başlangıç düğümüne 0, doğrudan erişilen düğümlere erişim değerleri ve erişilemeyen düğümlere ¥ sonsuz değeri atanıyor. Hedef düğüm olarak da E düğümünü tanımlayalım.

Yukarıdaki örnekte A düğümünden başlayacağımız düşünelim:

Şimdi şekilde kenarları sıralayalım:

AB 2

AC 1

BE -2

BF 5

CF 2

CD -1

DF 5

DE 7

Bellman ford algoritması işte bu kenarları teker teker dolaşması itibariyle dijkstradan ayrılır. Sırayla yukarıdaki kenarları (Edges) dolaşır ve graftaki değerleri günceller.

Yukarıda, rastgele sıra ile dizilen bu kenarları sırasıyla dolaşalım ve bu dolaşma sırasında şu işlemi yapalım.

Örneğin AB kenarı , A ve B düğümleri arasında. Bu düğümlerden düşük değere sahip olan düğüm üzerine kenar değeri eklenip yüksek değere sahip olan düğüm üzerine yazılıyor.

Sırayla gidecek olursak:

AB 2, min(A,B) = 0 à 0+ 2 = 2

AC 1, min(A,C) = 0 => 0+1 = 1

BE 2, min (B,E ) 2, => 2 + 2 = 4

BF 5, min(B,F) = 2 => 2+5 = 7

CF 2, min (C,F) = 1 => 1+2 = 3, bu değer 7′den küçük olduğu için güncelliyoruz:

CD -1, min(C,D) = 1=> 1+(-1) = 0

DF 5, min (D,F) = 0 => 0+5 = 5 F’nin değerinden daha büyük o yüzden güncellemiyoruz.

DE 7, min(D,E) = 0 => 0+7 = 7, yine E’nin değerinden büyük olduğu için güncellenmiyor.

Sonuçta graf aşağıdaki şekilde bitmiştir:

Bu graftaki bütün düğümlerde, A düğümünden ne kadar maliyetle gidildiği bulunmuştur. Örnek hedef E düğümü ise, ulaşım maliyeti 4′dür.

Görüldüğü üzere eksi değere sahip düğümler olmasına rağmen herhangi bir problem yaşanmamıştır.

1,813 views

Bu algoritmanın amacı, literatürde azami akış ( maximum flow ) olarak geçen ve düğümler (nodes) arasında akış kapasiteleri belirli bir şekildeki (graph) bir başlangıçtan bir hedefe en fazla akışın sağlandığı problemleri çözmektir.

Azami akış (maximum flow) problemini örneğin şehirler arasında bağlı boru hattına veya tedarik zincirine benzetebiliriz. Örneğin aşağıdaki şekli ele alalım:

Buradaki düğümler, şehirleri ve düğümler arasındaki kenarlar (edges) ise şehirler arasındaki boru hatlarının kapasitesini belirtsin. Amacımız A düğümünden E düğüme azami miktarda akış sağlayabilmek olsun.

Ford-Fulkerson çözüm için yukarıdaki şekilde öncelikle hedef düğüme giden yolu bulur. Algoritma bu arama işlemi sırasında şayet derin öncelikli arama (depth first search ,DFS) kullanıyorsa ford fulkerson olarak isimlendirilir. Şayet aynı algoritma bu arama işlemi sırasında sığ öncelikli arama (breadth first search, BFS) kullanırsa bu durumda da edmonds karp algoritması olarak isimlendirilir.

Biz yazımızın konusu olan Edmonds Karp algoritmasını anlamak için sığ öncelikli olarak arama işlemini gerçekleştirelim:

BFS (sığ öncelikli arama) sonucunda bulunan yollarımız aşağıda listelenmiş olsun:

• A-D-E
• A-B-E
• A-C-D-E
• A-C-F-B-E
• A-C-F-D-E
• A-B-F-D-E

İlk bulacağımız yol (path) A-D-E olsun bu durumda algoritma bu yol üzerindeki en küçük kapasiteyi bulmaya çalışır:

min(A-D,D-E) = min(5,7) = 5

bu bulunan sayı aslında bu yol üzerinden akabilecek maksimum değerdir. Dolayısıyla bu yoldan 5 kapasitesinde akış yapılmasına karar verilir ve şekil üzerinde bu durum işaretlenir:

Yukarıdaki şekilde buluna kırmızı sayılar, o yoldaki anlık akış miktarlarıdır.

Ardından derin öncelikli arama işlemi devam eder ve örneğin A-B-E yolunu bulur.

min(A-B, B-E) = min(4,2) = 2

Bir sonraki yolumuz olan A-C-D-E yolunu hesaplayalım.

min(A-C,C-D,D-E) = min(1,1,2) = 1

Yukarıda dikkat edilecek bir nokta, D-E aralığının şeklin ilk halinde olan 7 olarak alınması yerine 2 olarak alınmasıdır. Bunun sebebi şeklin bu kenarındaki 5 miktarındaki kapasitenin şu anda kullanılıyor olması ve artık geriye 2 miktarında kapasite kalmasıdır.

Bu adımsan sonra BFS algoritmamız ile bulduğumuz aşağıdaki yolları atlamamız gerekecektir:

• A-C-F-B-E
• A-C-F-D-E

Bunun sebebi bu yollarda bulunan A-C aralığının artık 0 kapasitesinin kalmış olması ve bu yollardan daha fazla akış elde edilememesidir.

Son olarak BFS algoritmamızın bulduğu A-B-F-D-E yolunu hesaplayalım:

min (A-B,B-F,F-D,D-E) = min ( 2,5,5,1) = 1

Yukarıdaki şekilde bütün düğümler arasındaki akışlar gösterilmiştir. Gerçekten de graftaki E düğümüne (hedef düğüme) gidebilen yollar maksimum kapasite ile doldurulmuştur.

338 views

Bu algoritmanın amacı, literatürde azami akış ( maximum flow ) olarak geçen ve düğümler (nodes) arasında akış kapasiteleri belirli bir şekildeki (graph) bir başlangıçtan bir hedefe en fazla akışın sağlandığı problemleri çözmektir.

Azami akış (maximum flow) problemini örneğin şehirler arasında bağlı boru hattına veya tedarik zincirine benzetebiliriz. Örneğin aşağıdaki şekli ele alalım:

Buradaki düğümler, şehirleri ve düğümler arasındaki kenarlar (edges) ise şehirler arasındaki boru hatlarının kapasitesini belirtsin. Amacımız A düğümünden E düğüme azami miktarda akış sağlayabilmek olsun.

Ford-Fulkerson çözüm için yukarıdaki şekilde öncelikle hedef düğüme giden yolu bulur. Algoritma bu arama işlemi sırasında şayet derin öncelikli arama (depth first search ,DFS) kullanıyorsa ford fulkerson olarak isimlendirilir. Şayet aynı algoritma bu arama işlemi sırasında sığ öncelikli arama (breadth first search, BFS) kullanırsa bu durumda da edmonds karp algoritması olarak isimlendirilir.

Biz yazımızın konusu olan ford fulkerson algoritmasını anlamak için derin öncelikli olarak arama işlemini gerçekleştirelim:

İlk bulacağımız yol (path) A-D-E olsun bu durumda algoritma bu yol üzerindeki en küçük kapasiteyi bulmaya çalışır:

min(A-D,D-E) = min(5,7) = 5

bu bulunan sayı aslında bu yol üzerinden akabilecek maksimum değerdir. Dolayısıyla bu yoldan 5 kapasitesinde akış yapılmasına karar verilir ve şekil üzerinde bu durum işaretlenir:

Yukarıdaki şekilde buluna kırmızı sayılar, o yoldaki anlık akış miktarlarıdır.

Ardından derin öncelikli arama işlemi devam eder ve örneğin A-C-D-E yolunu bulur.

min(A-C,C-D,D-E) = min(1,1,2) = 1

Yukarıda dikkat edilecek bir nokta, D-E aralığının şeklin ilk halinde olan 7 olarak alınması yerine 2 olarak alınmasıdır. Bunun sebebi şeklin bu kenarındaki 5 miktarındaki kapasitenin şu anda kullanılıyor olması ve artık geriye 2 miktarında kapasite kalmasıdır.

Bir sonraki derin öncelikli arama yolumuz A-C-F-D-E olsun. Bu durumda yol üzerindeki kapasite hesabı aşağıdaki şekilde olacaktır:

min(A-C,C-F,F-D,D-E) = min (0,2,5,7) =0

Görüldüğü üzere bu yol artık kullanılamaz çünkü bu yoldaki kapasite 0′dır. Bunun sebebi bir önceki adımda bulunan yolun, A-C arasındaki kapasiteyi sonuna kadar kullanmış olmasıdır.

Sıradaki yolumuz A-B-F-D olsun:

min(A-B,B-F,F-D) = min( 4,5,5,1) = 1

Son olarak yolumuz A-B-E olarak verilsin :

min(A-B,B-E) = min (3,2) = 2

Yukarıdaki şekilde bütün düğümler arasındaki akışlar gösterilmiştir. Gerçekten de graftaki E düğümüne (hedef düğüme) gidebilen yollar maksimum kapasite ile doldurulmuştur.

704 views

Bu yazının amacı genel amaçlı şekillerde (graphs) sığ öncelikli aramayı (breadth first search , BFS) açıklamaktır.

Bu yazı, ağaçlardaki sığ öncelikli arama ile karıştırılmamalıdır. Ağaçlar (trees) bilindiği üzere yönlü dairesel olmayan şekillerdir (directed acyclic graph) dolayısıyla ağaçlar üzerinde bu yazıda anlatılan sıra (queue) yapısına ihtiyaç duyulmaz.

Sığ öncelikli arama bir başlangıç düğümünden başlayarak sıradaki komşuları dolaşan arama algoritmasıdır. Bu arama algoritmasında amaç önce başlangıç düğümüne yakın düğümlere bakmaktır.

Bu arama şekli suya atılan bir damlanın suda çıkardığı halkalara benzetilebilir. Başlangıç düğümüne en yakın halka sonra ikinci yakın halka ve sonra diğerleri şeklinde giden bir arama algoritmasıdır.

Bu durumu aşağıdaki örnek üzerinden anlamaya çalışalım:

Örnek olarak yukarıda bulunan şekli ele alalım. Örneğimizde başlangıç düğümü (node) olarak A düğümünü seçtiğimizi ve aranan düğümün E düğümü olduğunu düşünelim .

A düğümünün komşuluk listesini (adjacency list) çıkarıyoruz:

komşu(A) = {C,B}

Bu komşulara sırasıyla bakılıyor ve bu komşuların komşuluk listeleri çıkarılıyor:

bakılanlar: {A,B,C}

komşular = komşu (B) , komşu (C) = {D,F,E}

Arana düğüm E, bu adımda bulunmuştur.

Yukarıdaki örnekte görüldüğü üzere bir sonraki derinliğe inilmeden önce, o derinlikte olan (başlangıç düğümüne o uzaklıkta olan) bütün düğümler dolaşılıyor ve ardından bir alt seviyeye iniliyor.

Yukarıdaki örnekte bütün ağaç dolaşılmış gibi düşünülebilir. Örneğin şekil (graph) aşağıdaki gibi olsaydı:

Bu durumda Z düğümüne hiçbir zaman bakılmayacaktı çünkü aranan düğüm, Z düğümünden daha sığ bir derinlikte olacaktı.

Kısacası BFS arama algoritması ile aranan düğümün derinliğine kadar olan bütün düğümlere bakılır ancak bu derinlikten daha aşağıda olan düğümlere bakılmasına gerek yoktur.

438 views

Bilgisayar bilimlerinde kullanılan ve algoritmayı literatüre kazandıran kişinin ismini taşıyan dijkstra algoritması, verilen bir şekilde (graph) en kısa yolu (shortest path) bulmak için kullanılır.

Bu algoritmanın çalışmasını örnek bir şekil( graph ) üzerinden göstermeye çalışalım. Bu gösterimin ardından Dijkstra algoritmasının başarısını ve zafiyetlerini tartışabiliriz.

Örnek olarak yukarıda bulunan şekli ele alalım. Dijkstra algoritması herhangi bir şekildeki bir düğümden diğer bütün düğümlere giden en kısa yolu hesaplar.

Örneğimizde başlangıç düğümü (node) olarak A düğümünü seçtiğimizi düşünelim ve algoritmanın çalışmasını bu düğümden başlayarak gösterelim.

Algoritma başlangıçta bütün düğümlere henüz erişim olmadığını kabul ederek sonsuz (¥ ) değeri atar. Yani başlangıç durumunda henüz hiçbir düğüme gidemiyoruz.

Ardından başlangıç düğümünün komşusu olan bütün düğümleri dolaşarak bu düğümlere ulaşım mesafesini günceller.

Bu güncelleme işleminden sonra güncellenen düğümlerin komşularını günceller ve bütün düğümler güncellenene ve şekil üzerinde yeni bir güncelleme olmayana kadar bu işlem devam eder.

Örneğin yukarıda A düğümünün komşusu olan düğümler (B ve C) güncellendiler. Bir sonraki adımda bu düğümlerin komşuları güncellenecektir. İstediğimiz bir düğüm ile başlayalım. Örneğin önce B sonra C düğümünün komşularını güncelleyelim:

Yukarıdaki şekilde, B düğümünün komşusu olan E ve F düğümleri güncellenmiştir. Bu güncelleme işlemi sırasında B düğümünün üzerindeki mevcut maliyet ile E ve F düğümlerine gidişten doğan maliyet toplanmıştır.

Örneğin E düğümü için 2 + 5 = 7 ve F düğümü için 2 + 2 = 4 değerleri bulunmuştur.

Şimdi bir sonraki düğüm olan C düğümünden güncelleme yapalım:

Bu aşamada güncellenen düğümler, C düğümünün komşusu olan D ve F düğümleridir. Bu düğümlerden, F düğümü daha önce güncellenmişti ve değer olarak 7 taşımaktaydı, ancak yeni gelen değer, F için C üzerinden 1 + 2 = 3 olarak hesaplanmış ve bu değer daha önceden hesaplanan 7 değerinden düşük olduğu için 7′nin üzerine yazılarak 3 olmuştur.

Algoritmanın çalışmasını sonraki düğümlerin güncellenmesi ile sürdürelim. Bu sefer örneğin D düğümünün komşularını güncelleyelim ( şu anda D, F ve E düğümleri aynı derecede yeni güncellenmiştir bunlardan herhangi birisi ile başlanması Dijkstra algoritmasına uygundur. Ancak recursive (özyineli) bir kodlama yapılıyorsa koda göre elbette yakın olan komşular güncellenecektir)

D düğümünün hiçbir komşusu güncellenmemiştir bunun sebebi hesaplanan değerlerin mevcut değerlerden yüksek olması ve dolayısıyla daha iyi bir sonuç bulunamamasıdır.

F için 2 + 5 = 7 > 3

E için 2 + 7 = 9 > 4

Dolayısıyla bir sonraki düğümü seçerek devam ediyoruz

F düğümünün komşularında da bir değişiklik olmuyor ve son olarak E düğümü deneniyor:

Son halimizde de bir değişiklik olmayarak şeklimiz (graph) kararlı bir halde ( daha fazla değişiklik olmadığı için) dolaşılmış ve bitmiş oluyor.

Yukarıdaki bu grafta, düğümler üzerinde yazılı olan değerler, A düğümünden başlanarak her düğüme gidilebilen en kısa yol mesafesini vermektedir. Örneğin şekildeki F düğümüne ulaşma maliyeti 3 olarak hesaplanmıştır ve Dijkstra algoritması, A düğümünden F düğümüne daha kısa bir yol bulunamayacağını iddia eder ( eşit farklı yollar bulunabilir ama en kısa yol yine de 3 olur)

Dijkstra algoritmasının zayıf yönü

Algoritma ne yazık ki eksi (-) değer taşıyan bir kenar bulunması halinde başarılı çalışmaz. Bunun sebebi eksi (-) değerdeki kenarın sürekli olarak mevcut durumdan daha iyi bir sonuç üretmesi ve algoritmanın hiçbir zaman için kararlı hale gelememesidir.

Örneğin aşağıdaki basit şekli ele alalım:

Yukarıdaki bu şekilde B-C kenarı (edge) -2 değerinde verilmiştir. Bu durumda A düğümünden başlayarak en kısa yolları hesaplamak istersek, öncelikli olarak A düğümünden komşusu olan düğümlere güncelleme yapılacaktır:

Ardından bu düğümlerin komşuları güncellenecektir. İki düğümde birbirine -2 değerini ekleyerek daha kısa bir yol bulacak ve birbirlerini güncelleyerek daha kısa sonuçlara ulaşacaktır.

Bu işlem ne yazık ki sonsuza kadar giden bir sürecin başlangıcıdır ve hiçbir zaman daha iyi bir sonuç bulma işlemi bitmez.

Sürekli olarak mevcut durumdan daha iyi bir durum bulunacak ve daha küçük değerler güncellenecektir. Bu yüzden Dijkstra algoritması, eksi (-) değer taşıyan şekillerde (graph) başarılı çalışmaz.

4,309 views