Distances = new int[W*H];
Previous = new int[W*H];
for (int i = 0; i < W*H; i++)
{
  Distances[i] = INF;
  Previous[i] = -1;
}
Distances[0] = 0;

Algoritmadaki her adımda kaynak bir nokta seçip, bu noktadan komşu noktalara gitmenin bize maliyetini hesaplayacağız ve bu nokta için bir daha hesap yapmayacağız. Bu yüzden hangi noktalar üzerinde çalıştığımızı da bir şekilde tutmamız gerekiyor. Bunun için bir liste kullanabilirsiniz. Gidilen noktaları listeden çıkarıp geriye kalanlar içinde hedefe en yakın olanı seçerek devam edebilirsiniz. Liste boşalana kadar bu işleme devam edip tüm noktalar için hesaplamalarımızı yapmış oluruz:

var list = new List<int>();
for (int i = 0; i < W * H; i++) list.Add(i);
while(list.Count > 0)
{
  //hesaplamalar
}

Çapraz hareketler yapamayacağımız için her kare üzerinde gidilebilecek 4 yön var: sağa, sol, yukarı ve aşağı.

private static readonly int[] dx = { 1, 0, -1, 0 };
private static readonly int[] dy = { 0, 1, 0, -1 };

Tüm bu yönlere hareket etmenin bizim için maliyeti nedir hesaplayalım ve Distance dizisinde bu noktaya karşılık gelen indekse bu değeri yazalım.

while (list.Count > 0)
{
  // hedefe en yakın noktanın indeksini al
  int bi = GetClosestIndex(list);
  int cx = bi % W, cy = bi / W; 

  for (int i = 0; i < dx.Length; i++ )
  {
    int nx = cx + dx[i];
    int ny = cy + dy[i];
    // dışarıda kalıyorsa çık
    if (0 > nx || nx >= W || 0 > ny || ny >= H) continue;
    int ci = ny * W + nx;
    // bi'den ci'ye gidersek maliyeti nedir
    int cost = CostOfGoing(bi,ci);
    int alt = Distances[bi] + cost;
    //daha kazançlıysa burdan gidelim
    if (Distances[ci] > alt)
    {
      Distances[ci] = alt;
      Previous[ci] = bi;
    }
  }
}

Bu işlem tüm noktalar için yapıldığında hedef noktanın kaynak noktaya olan mesafesi Distance[Hedef] olacaktır. Gidilecek yol ise şöyle çıkarılabilir:

int target = 99;
List path = new List<int>();
while(Previous[target]!=-1)
{
    path.Add(target);
    target = Previous[target];
}
path.Reverse();

Dijkstra Algoritmasının en güçlü taraflarından birisi, çalışma süresinin kısa olmasıdır. Örnekte, kaynaktan başlayarak diğer tüm noktalara olan mesafeyi hesaplıyoruz sonra hedefimize giden yolu çıkarıyoruz. Bunu tüm noktalar için yapmak zorunda değiliz; eğer isterseniz algoritma içinde bi = target olduğu zaman algoritmayı sonlandırarak çalışma süresini de kısaltmış olabiliriz. İkinci olarak ise; bir noktanın diğer noktaya olan mesafesini bir maliyet fonksiyonu ile hesaplıyorruz. Sadece bu fonksiyonu değiştirerek farklı sonuçlar elde edebiliriz. Örneğin; tahtanın üzerindeki her kareyi bir tepe olarak düşünelim ve üzerindeki sayı ise o tepenin yüksekliği olsun. Bir tepeden diğerine geçerken; tırmanmamız yükseklik farkı kadar, aşağı inmemiz ise yükseklik farkının yarısı kadar zaman alsın. Bu durumda maliyet fonksiyonumuzu aşağıdaki gibi değiştirmek bize istediğimiz sonucu verecektir:

private int GetCostOfGoing(int bi, int ci)
{
    int diff = Height[bi] - Height[ci];
    if (diff < 0) return -diff / 2;
    return diff;
}

Tüm bu işlemi görsel olarak takip etmeniz için bir WPF projesi hazırladım. Buradan indirip inceleyebilirsiniz.

DipNot: Bu yazıyı, yazarken kaybettiğim o tuşuma armağan ediyorum.

int[,] table = new int[5,5];

Algoritmanın temelinde min fonksiyonu kullanıldığı için bu tablonun girdilerinin ilk değerleri maksimum olarak atıyoruz. Her bir noktanın kendine olan mesafesini 0, diğer noktalara olan mesafesini ise sonsuz kabul ederek başlayacağız.

int INFINITY = 9999999;
int N = 5;
for (int i = 0; i < N; i++)
  for(int j = 0; j < N; j++)
    table[i,j] = i == j ? 0 : INFINITY;

Bu işlemden sonra tablonun ilk değerleri aşağıdaki gibi olacaktır.

table	1	2	3	4	5
1	0	INF	INF	INF	INF
2	INF	0	INF	INF	INF
3	INF	INF	0	INF	INF
4	INF	INF	INF	0	INF
5	INF	INF	INF	INF	0

İkinci olarak noktalar arasındaki bağlantıları tutmak ve sorgulamak için bitişiklik matrisi oluşturmalıyız. Eğer bir noktadan diğerine bir kenar var ise tabloda o girdiye 1 değerini veriyoruz. Örneğin nokta 2′den nokta 3′e ve nokta 4′e birer kenar bulunuyor. Bundan dolayı tablomuzun [2,3] = [2,4] = 1 = [3,2] = [4,2]. Grafımız yönlü olmadığı için elde ettiğimiz bitişiklik matrisinin diyagonale göre simetrik olması gerekiyor. Çünkü 1′den 4′ e kenar varsa bu aynı zamanda 4′den 1′e de kenar var anlamına gelmektedir. Eğer örneğimiz yönlü bir graf olsaydı bunu söyleyemezdik. Bu işlemden sonra tablomuzun son hali aşağıdaki gibi olacak:

table	1	2	3	4	5
1	0	INF	INF	1	INF
2	INF	0	1	1	INF
3	INF	1	0	1	INF
4	1	1	1	0	1
5	INF	INF	INF	1	0

Simdi Floyd-Warshall formülünü uygulayabiliriz:

for( int k = 0; k < N; k++)
  for( int i = 0; i < N; i++)
    for( int j = 0; j < N; j++)
      table[i,j] = Math.Min(table[i,j], table[i,k] + table[k,j]);

.......AXXXXXXX
..........X...X
.....XXXXXXXXXX
.....X........X
.XXXXXXXXXXXXXX
.X.....X..X....
.X.....X..X...X
.XXXXXXXXXXBXXX

X olan noktalar gidilebilecek yolu ifade etsin. Harita üzerindeki her bir karakteri yukarıdaki graftaki bir nokta olarak kabul edebiliriz. Bu durumda elimizde genişlik * yükseklik kadar nokta olacaktır. Her bir noktanın tablodaki yerini de (satır * genişlik) + sütun olarak belirleyebiliriz. Bitişiklik matrisini oluştururken her bir noktanın sağındaki, solundaki, üstündeki ve altındaki karakterlerin X,A,B karakterlerinden biri olup olmadığını kontrol etmek yeterli olacaktır. Eğer bu karakterlerden birisi ise kenar var diyeceğiz ve tabloya 1 değerini atayacağız. Örnek kod aşağıdaki gibi:

private readonly string[] map = new string[]
     {
        ".......AXXXXXXX",
        "..........X...X",
        ".....XXXXXXXXXX",
        ".....X........X",
        ".XXXXXXXXXXXXXX",
        ".X.....X...X..X",
        ".X.....X...X..X",
        ".XXXXXXXXXXBXXX",
     };

int findShortestPath()
{
  int width = map[0].Length;
  int height = map.Length;
  int N = width*height;
  int[,] table = new int[N,N];
  int INF = 9999999;

  //tablonun ilk değerlerini atıyoruz
  for (int i = 0; i < N; i++)
    for (int j = 0; j < N; j++)
      table[i, j] = i == j ? 0 : INF;

  // bitişiklik matrisini oluşturuyoruz
  for (int i = 0; i < N; i++)
  {
    int row = i/width;
    int col = i%width;
    if (map[row][col] == '.') continue;
    // yapılabilecek tüm hareketler için olasıkları üretiyoruz
    // ve kontrol ediyoruz
    for (int dx = -1; dx <= 1; dx++)
      for (int dy = -1; dy <= 1; dy++)
      {
        // (1,1) (1,-1) gibi hareketler yapamıyoruz
        if (Math.Abs(dy) + Math.Abs(dx) == 2) continue;
        if (col + dx < width && col + dx >= 0 &&
            row + dy < height && row + dy >= 0)
        {
          char c = map[row + dy][col + dx];
          if (c == 'X' || c == 'A' || c == 'B')
          {
            int newindex = (row + dy)*width + col + dx;
            table[i, newindex] = table[newindex, i] = 1;
          }
        }
      }
    }

  for (int k = 0; k < N; k++)
    for (int i = 0; i < N; i++)
      for (int j = 0; j < N; j++)
        table[i, j] = Math.Min(table[i, j], table[i, k] + table[k, j]);

  string joined = String.Join(String.Empty, map);
  int startIndex = joined.IndexOf('A');
  int endIndex = joined.IndexOf('B');
  return table[startIndex, endIndex];

}