• S: en kısa yolu kesinleşmiş düğümler (başta yalnız kaynak 0).
• w ∉ S için uzaklik[w]: 0’dan başlayıp yalnızca S’deki düğümlerden geçerek w’de biten en kısa yolun uzunluğu.
• uzaklik[u] en küçük olan u seçilir ve S’ye eklenir.
• u’nun eklenmesi, u üzerinden geçen yeni yollar açar: uzaklik[u] + maliyet(<u,w>) < uzaklik[w] ise uzaklik[w] günlenir (u–w arasında ara düğüm yok).

u’nun komşularına u üzerinden yeni yollar

#include <limits.h>
#define MAX_DUGUM 6
#define SONSUZ 1000      /* baglanti yok */
int maliyet[][MAX_DUGUM] = {
    {   0,   50,  10, 1000,   45, 1000},
    {1000,    0,  15, 1000,   10, 1000},
    {  20, 1000,   0,   15, 1000, 1000},
    {1000,   20, 1000,   0,   35, 1000},
    {1000, 1000, 1000,  30,    0, 1000},   /* eksik satir */
    {1000, 1000, 1000,   3, 1000,    0}};  /* 100 -> 1000 */
int minimumBul(int uzaklik[], int n, short gidildi[])
{
    int i, min = INT_MAX, pos = -1;
    for (i = 0; i < n; i++)
        if (uzaklik[i] < min && !gidildi[i]) {
            min = uzaklik[i];  pos = i;
        }
    return pos;
}

Ayrıntılar:

• !gidildi[w] yazılmalı; !gidildi(w) diziyi fonksiyon gibi çağırır.
• INT_MAX için <limits.h>; FALSE/TRUE tanımları.
• minimumBul −1 dönebilir (işaretsiz düğüm kalmamışsa); çağıran denetlemeli. Erişilemeyen düğüm de seçilebilir: SONSUZ (1000) < INT_MAX.

void EnKisaYolBul(int v, int maliyet[][MAX_DUGUM],
                  int uzaklik[], int onceki[],
                  int n, short gidildi[])
{
    int i, u, w;
    for (i = 0; i < n; i++) {                  /* A1 */
        gidildi[i] = FALSE;
        uzaklik[i] = maliyet[v][i];
        onceki[i] = v;             /* yol icin tutulur */
    }
    gidildi[v] = TRUE;  uzaklik[v] = 0;
    for (i = 2; i < n; i++) {        /* n-2 tur */
        u = minimumBul(uzaklik, n, gidildi);
        if (u < 0) break;            /* kalan yok */
        gidildi[u] = TRUE;
        for (w = 0; w < n; w++)
            if (!gidildi[w] &&
                uzaklik[u] + maliyet[u][w] < uzaklik[w]) {
                uzaklik[w] = uzaklik[u] + maliyet[u][w];
                onceki[w] = u;
            }
    }
}

• A1: başlangıç değerleri — uzaklıklar doğrudan kenar maliyetleri.
• A2: dış döngü n − 2 tur: son kalan düğümün uzaklığı zaten kesindir.
• A3: minimumBul O(n).
• A4: tüm w’ler için gevşetme (relaxation) O(n).
• onceki[]: yolu geri izlemek için tutulur.

Dijkstra 1’i 4 ile kesinleştirir (ondan küçük aday yok). Sonra 2 → 1 kenarı (−3) 1’e 2 maliyetle ulaşır; ama 1 artık işaretlidir. 3 de yanlış kalır.

typedef struct oge *oge_gost;
typedef struct oge {
    int dugum;
    oge_gost bag;
} oge;
typedef struct {
    int sayac;      /* <i,j> icin: basi j olan kenar sayisi */
    oge_gost bag;
} basoge;
basoge baslik[MAX_DUGUM];

• Düğümler 0..n−1 numaralı.
• sayac: düğümün öncül (giriş kenarı) sayısı; 0 ise yazılabilir.
• Kenarlar okunurken baslik[j].sayac++.

v0..v5 örneğinin sayaçlı listesi

void TopolojikSira(basoge baslik[], int n)
{
    int i, j, k, ust = -1;
    oge_gost p;
    for (i = 0; i < n; i++)      /* sayac 0: yigina */
        if (!baslik[i].sayac) {
            baslik[i].sayac = ust;  ust = i; }
    for (i = 0; i < n; i++) {
        if (ust == -1) { printf("dongu"); break; }
        j = ust;  ust = baslik[ust].sayac;
        printf("%d ", j);
        for (p = baslik[j].bag; p; p = p->bag) {
            k = p->dugum;
            if (--baslik[k].sayac == 0) {
                baslik[k].sayac = ust;  ust = k; }
        }
    }
}

• Öncülü kalmayan düğümler sayac alanları üzerinden peş peşe bağlanır: sayac artık “yığında altımdaki düğüm”. Kümelerdeki ebeveyn dizisine benzer.
• sayac--; if (!sayac) ikilisi burada --sayac == 0 olarak yazıldı (aynı anlam).

Kritik yollar: v0-v1-v4-v6-v8 ve v0-v1-v4-v7-v8 (uzunluk 18)

• Aktivite süreleri toplandığında en uzun v0 → v8 yolu: kritik yol. Birden fazla olabilir.
• Burada 6 + 1 + 9 + 2 = 18 ve 6 + 1 + 7 + 4 = 18 → proje en erken 18 günde biter.
• Bir aktivite, ön koşulları en kısa sürede biterse ne zaman başlar? Proje uzamasın diye en geç ne zaman başlamalı?
• Kritik işlerin ustalarına: “Sakın 4 günde bitirin, 5 güne sarkmasın. 3 günde biterse memnun olurum.” — yöneylem problemi.

• a_i = <k, m> ise EnErken(i) = EnErkenBas[k]: aktivite, kuyruğundaki olay gerçekleşince başlar.
• Ör. a1: k = v0 → 0; a5: k = v3 → 5 (a2); a8: k = v5 → 5 + 2 = 7.
• v4’e iki yol var: a3 en erken 6 + 1 = 7’de, a4 4 + 1 = 5’te biter. İkisi de bitmeli → en uzunu (7) beklenir.
• EnErkenBas[m] = max { EnErkenBas[k] + süre(<k,m>) }, k ∈ P(m) (yakın öncüller).
• Başta dizi 0: projenin başlangıcı 0. günü (ör. “8 Mayıs”); 10 konsaydı hepsi 10 kayardı.
• Hesap topolojik sıraya göre yapılmalıdır: öncüllerin değerleri önce bilinmeli.

/* TopolojikSira icinde sayac azaltilmadan once: */
if (EnErkenBas[k] < EnErkenBas[j] + p->sure)
    EnErkenBas[k] = EnErkenBas[j] + p->sure;

Liste öğesine sure alanı eklenir; daha uzun bir yol bulununca değer günlenir.

• Geri doğru çözümleme: tüm oklar ters çevrilir; bu çizgenin topolojik sırasında çalışılır (v8 ilk, v0 son). Yapı: komşuluk listesinin tersi, O(n + e)’de kurulur.
• Son düğüm: EnGecBas[n−1] = EnErkenBas[n−1] = 18. Başta dizi 18 ile doldurulur.
• a_i = <k, m>: EnGec(i) = EnGecBas[m] − süre. v7 en geç 18 − 4 = 14, v6 en geç 18 − 2 = 16.
• Birden çok ardıl varsa en küçüğü: EnGecBas[k] = min { EnGecBas[m] − süre }. Ör. v0: v1 için 6 − 6 = 0, v2 için 6 − 4 = 2, v3 için 8 − 5 = 3 → 0. Büyüğünü (3) alsaydık v1 gecikir, proje 21’e sarkardı.

if (EnGecBas[k] > EnGecBas[j] - p->sure)
    EnGecBas[k] = EnGecBas[j] - p->sure;