Ancak öyle bir node’a geliyoruz ki gidilecek yer kalmıyor. Çünkü direkt bağlantımızın olduğu bütün node’lar daha önceden gezilmiş. Böyle bir durumda ise bu node’dan önce en son gezdiğimiz node’a geri dönüyoruz ve başka tercihler var mı diye bakıyoruz. Algoritma rekürsif olarak çalıştığı için her takıldığımız noktada bir üste çıkmamıza olanak sağlıyor. Algoritmamız başladığımız yere geldiğimizde ve hali hazırda bütün çocuklarımızı gezdiğimizde bitiyor.

Sözde Kod

DFS(G)
   for each u ∈ V do
      color[u] <- white 
      pred[u] <- NIL
   time <- 0
   for each u ∈ V do
      if color[u] = white                      
   then
         DFS-VISIT(G, u)

DFS-VISIT(G, u)
   color[u]<- gray 
   d[u]<- time <- time + 1
   for each v∈ Adj[u] do
      if color[v] = white    then 
         pred[v] <- u
   	 DFS-VISIT(G, v) 	
   color[u] <- black 
   f[u]<- time <- time + 1

Derin Öncelikli Arama İşlem Adımları:

• Önce bir başlangıç node’u seçilir ve ziyaret edilir.
• Seçilen node’un bir komşusu seçilir ve ziyaret edilir.
• 2.adım ziyaret edecek komşu kalmayıncaya kadar tekrar edilir.
• Komşu kalmadığında tekrar geri dönülür ve önceki ziyaret edilmiş node’lar için adım 2 ve 3 tekrar edilir.

Aşağıdaki somut örnek üzerinde söylediklerimizi inceleyelim.

Derin Öncelikli Arama Örneği

Aşama 1:

Her bir node’lar üzerinde gideceği komşuları belirlenir.

Aşama 2:

Öncelikle bir root (başlangıç node) seçmemiz gerekir. Root olarak A node’nu seçiyoruz. A’nın komşuları F ve G node’ları var.

Stack’de A eklenmiş olur. A’nın gidebileceği F ve G node’ları vardır. Herhangi bir çocuğundan başlamamız lazım.

Aşama 3:

F seçelim. F’den direkt yol olan E node vardır. Böylelikle stacke F node da eklenmiş olur. F node’nun gidebileceği tek bir yer var. E node’na gitmiş oluyoruz.

Aşama 4:

Stacke E node da eklenmiş olur. E’nin gidebileceği komşuları C, D ve G nodelarıdır. Örnekte C node’nu tercih ediyoruz.

Aşama 5:

Stacke C node da eklenmiş olur. C node’dan A ve D nodelarına gidebiliriz. A node’ya gidiyoruz. A node’na daha önce uğradığımızı fark ederiz.

Aşama 6:

C node’dan A ya daha önce uğramış olduğumuz için C node’ndan D node’na gideriz.

Aşama 7:

Daha önce D node’na uğramadığımız için D node’nu stacke ekleriz. D node’ndan gidebileceği komşular C ve F nodelarıdır. İlk tercihimiz. C node olur. Daha önce buraya uğradığımızı fark ederiz.

Aşama 8:

D node’ndan gidebileceği bir diğer node F node, orayada daha önce uğradığımızı biliyoruz.

Aşama 9:

D node’nun gidebileceği başka hiçbir yer kalmadı.

Aşama 10:

D node’nun gidebilecek yeri kalmadığı için stackten onu siliyoruz. Stackten sildiğimiz node peşine hangi node var ise oradan devam edilir.(C node)

C node’nun komşuları A ve D nodeları idi. A ve D nodelarını daha önce gitmiştik. Başka gidebileceğimiz yer kalmadığı için C node’nu stackten çıkarıyoruz.

Aşama 11:

Stackten sildiğimiz node peşine hangi node var ise oradan devam edilir.(E node) E node ile daha önce C node’na gitmiştik. E node’ndan gidebileceğimiz komşular D ve G kaldı. D node’na gittiğimizde, D node’na daha önceden uğradığımızı görüyoruz.

Aşama 12:

E node’ndan gidebileceğimiz G node kaldı. G node’na daha önceden uğramamışız.

Aşama 13:

G node’nu stacke eklenir. G node’ndan gidebileceğimiz komşu node’lar yoktur. G node’nu da stackten silebiliriz.

Aşama 14:

Stackten sildiğimiz node peşine hangi node var ise oradan devam edilir.(E node) E node’nun komşuları C, D ve G hepsine uğramış olduk. E node’nun gidebileceği başka bir yer kalmadığı için E node da stackten sileriz.

Aşama 15:

Stackten sildiğimiz node peşine hangi node var ise oradan devam edilir.(F node) F node’nun gidebileceği E node var. E node’na da daha önce uğradığı için gidecek başka bir yer kalmadı. F node stackten silinir.

Aşama 16:

Stack’te sadece A node kalır. A’nın komşuları F ve G node’larıdır. F’ye daha önce uğradığı için G node’na giden yolu kullanır.

Aşama 17:

G’ye daha önce uğramış olduğumuz için A stack’ine geri döner. A node’nun gidebileceği başka bir node kalmadığı için A node’nu da stackten sileriz. Böylelikle stackte hiçbir node kalmamış olur.

Aşama 18:

Derin Öncelikli Arama

Enine Arama

Kaynakça: Akifhatipoglu, Stanford, Dergipark, Geeksforgeeks, Tutorialspoint

ALGORITHMS COURSE – GRAPH THEORY TUTORIAL FROM A GOOGLE ENGINEER

The post Derin Öncelikli Arama (Depth First Search) appeared first on Halil Durmus.

Dijkstra algoritması en kısayolu belirlerken Greedy(Açgözlü) yaklaşımını kullanır. Yani bir düğümden diğer bir düğüme geçerken olası en iyi yerel çözümü göz önüne alır. Her seferinde bir sonraki düğüme ilerleme Greedy yaklaşımına göre yapılır.

Dijkstra(G,w,s)                            //Başlat
{
     for(each u ∈ V)  
     {
           d[u]= ∞;
           colur[u]=white;
     }
     d[s]=0;
     pred[s]=NIL;
     Q = (tüm köşeler kuyruk);
     
     while (Non-Empty(Q))        //Tüm köşeleri işle.
     {
           u=Extract-Min(Q);       //Yeni köşe bul.
           for (each v ∈ Adj[u] )
                 if(d[u] + w(u, v) < d[v])
                 {
                         d[v] = d[u] + w(u,v);
                         Azaltma-Anahtarı(Q, v, d[v]);
                         pred[v] = u;
                 }
           color[u] = black;
     }
}

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

Aşama 0:

Örneğimizde başlangıç düğümü (node) olarak s 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.

Aşama 1:

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üncellenir.

Adj[s]= {a,b}, a ve b üzerindeki düğümleri güncellenir.

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.

Aşama 2:

Aşama 1’den sonra, a öncelik kuyruğunda minimum değere sahiptir. Adj[a]= {b, c, d} olarak, b, c, d üzerinde çalışın ve bilgileri güncelleyin.

Aşama 3:

Aşama 2’den sonra, b öncelik kuyruğunda minimum anahtara sahiptir. Adj[b] = {a, c} olarak a, c üzerinde çalışın ve bilgileri güncelleyin.

Aşama 4:

Aşama 3’den sonra, c öncelik kuyruğunda minimum anahtara sahiptir. Adj[c] = {d} olarak, d üzerinde çalışın ve bilgileri güncelleyin.

Aşama 5:

Aşama 4’den sonra, d öncelik kuyruğunda minimum anahtara sahiptir. Adj[d] = {c} olarak, c üzerinde çalışın ve bilgileri güncelleyin.

En Kısa Yol Ağacı:

T = (V, A),

A = {(pred[v], v) | v ∈ V \ {s}}

Pred[d] dizisi ağacı inşa etmek için kullanılır.

Dijkstra Algoritmasının Zayıf Yönü

Dijkstra Algoritması’ nın 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.

Kaynakça: Zafercomert, Bilgisayarkavramlari, Codingame, CPalgorithms, Hackerearth

The post Dijkstra Algoritması appeared first on Halil Durmus.

Bir çizge aramasındaki en basit algoritmalardan biridir ve pek çok önemli çizge algoritmasının ilk örneğidir. Prim’in minumum kapsayan ağaç algoritması ve Dijkstra’nın tek kaynaklı en kısa yollar algoritması ile benzer fikirleri kullanır. Algoritma yönlü ve yönsüz çizgelerin her ikisi içinde çalışır.

Sığ öncelikli arama 1945’te Michael Burke ve Konrad Zuse tarafından çizgelerde bağlı bileşenleri tespit etmek için geliştirilmiştir. Ancak, bu algoritmanın sunulduğu doktora tezi kabul edilmemiştir ve 1972 yılında yayınlanmıştır. 1959’da E. F. Moore tarafından, bir labirentteki en kısa yolu bulmak için, 1961 yılında ondan bağımsız bir şekilde C. Y. Lee tarafından devrelerde bağlantıların belirlenmesi amacıyla tekrar icat edilmiştir.

Nasıl Çalışır?

İlerleme yolunu bulmak için algoritma her tepeyi beyaz, gri veya siyah renkle boyar. Tüm tepeler beyaz ile başlar, sonradan gri ve en son siyah olur. Arama sırasında bir tepe ile ilk defa karşılaşıldığında o tepe bulunan (discovered) olur ve o andan itibaren tepe artık beyaz renkli değildir. Gri ve siyah tepeler bulunan tepelerdir, fakat enine ilerlemek için bunlar arasından hangisinin seçileceğine karar verilir. Eğer (u,v) ∈ E ve u tepesi siyah ise, v tepesi de siyah veya gridir, böylece siyah tepelere bitişik olan tüm tepeler gezilir. Gri tepeler bazı beyaz tepelerle bitişik olabilir; bulunan ve bulunmayan tepeler arasındaki sınırı gösterirler.

Enine arama başlangıçta sadece s kaynak tepesi olan kökü içererek enine ağacı oluşturur. Daha önce bulunan u tepesinin bitişiklik listesi gezinirken beyaz v tepesi bulunduğunda v tepesi ve (u,v) ayrıtı ağaca eklenir. u tepesine v‘nin öncülü(predecessor) ya da ebeveyni (parent) denir. Bir tepe en fazla bir kez bulunduğundan, en fazla bir ebeveyni olur. Enine ağaçta s köküne bağlı olarak ata (ancestor) ve torun(descendant) ilişkisi şu şekilde tanımlanır: eğer ağaçta s kökünden v tepesine olan basit yolda u tepesi varsa, bu durumda u, v nin atası v de u nun torunu olarak isimlendirilir.

Aşağıda yer alan BFS enine arama işlemi, girdi çizgeyi G = (V, E) nin bitişiklik listesi kullanılarak gösterildiğini varsayar. Çizgede her tepeye birkaç ek özellik ilave eder. Her u ∈ V tepesinin rengini u.color özelliği ile ve u nun öncülünü (predecessor) ise u.π özelliği içinde saklarız. Eğer u, öncül tepeye sahip değilse (örneğin eğer u=s veya u henüz bulunmayan bir tepeyse) bu durumda u.π = NIL olur. u.d özelliği ile algoritma tarafından hesaplanan s kaynağından u tepesine olan uzaklık tutulur. Gri teplerin kümesini kontrol etmek için algoritma ayrıca ilk-giriş, ilk-çıkış kuyruğu Q yu kullanır.

Sözde Kod

BFS (G.s)
  for her u∈ G.V - {s} tepesi
      u.color = ∈WHİTE
      u.d = ∞
      u.π= NIL
  s.color = GRAY
  s.d = NIL
  Q = Ø
  ENQUEUE(Q,s)
  while Q ≠ Ø
      u= DEQUEUE(Q)
  for her v ∈ G.Adj[u]
      if v.color == WHİTE
         v.color =GRAY
         v.d = u.d + 1
         v.π = u
         ENQUEUE(Q,v)
      u.color = BLACK

Aşağıda örnek üzerinde BFS’nin ilerleme durumunu göstermektedir.

BFS işlemi aşağıdaki gibi çalışmaktadır. s kaynak tepesi hariç, satır 1-4 her tepeyi beyaza boyar, her u tepesi için u.d yi sonsuz olarak belirler ve her tepenin ebeveynini(parent) NIL olarak belirler. Satır 5, işlemler başladığında bulunan olarak düşündüğümüz s tepesini griye boyar. Satır 6, s.d yi 0 olarak başlatır ve satır7 kaynağın öncülünü (predecessor) NIL olarak belirler. Satır 8-9 sadece s tepesini içeren Q kuyruğunu başlatır.

Satır 10-18 deki while döngüsü, bitişiklik listesi tam olarak elden geçirilmemiş bulunan tepeler yani gri tepeler kaldıkça tekrarlanır. Bu while döngüsü aşağıdaki değişmezi korur.

Satır 10 daki testte, Q kuyruğu gri tepeler kümesinden oluşur.

Örnek

İlk iterasyona (a) göre Q kuyruğundaki tek gri tepe ve tek tepe, s kaynak tepesidir. Satır 11, Q kuyruğunun en başındaki u gri tepesini ele alarak onu Q dan atar. Satır 12-17 deki for döngüsü u nun bitişiklik listesindeki her ve tepesini inceler. Eğer v beyaz ise, henüz keşfedilmemiştir ve satır 14-17 nin çalıştırılması ile işlem onu keşfeder. İşlem v tepesini griye boyar, uzaklığını v.d iken u.d+1 ye olarak belirler, u nun ebeveyni olarak v.π yi kaybeder v onu Q kuyruğunun en sonuna yerleştirir. u nun bitişiklik listesindeki tüm tepeler işlem tarafından bir kez daha incelenir incelenmez satır 18 onu siyaha boyar. Döngü değişmezi korunur çünkü bi tepe griye boyandığında (satır 14 de) o aynı zamanda sıraya alınır (satır 17 de) ve bir tepe kuruktan çıkarıldığında (satır 11 de) o aynı zamanda siyaha boyanır(satır 18 de).

Enine aramanın sonuçları verilen bir tepenin komşularının satır 12 de ziyaret edilme derecesine bağlı olabilmektedir; enine ağaç farklı olabilir, fakat algoritma ile hesaplanmış olan d uzaklıkları farklı değildir.

Kaynakça: Wikipedia, Geeksforgeeks, Hackerearth, Tutorialspoint

Bilgisayar Kavramı

U.NURİYEV, E.NASİBOĞLU, T. ÖNER. (2017). Algoritmalara Giriş Ankara: Palme Yayıncılık (589-602)

The post Enine Arama (Breadth-first Search) appeared first on Halil Durmus.