Tudod, miért van távolabb egy egyenesben, mint egy ívben? Két párhuzamos egyenes távolságának meghatározása Mekkora a legrövidebb távolság két pont között

A képen látható pontozott vonal mentén az út rövidebb, mint a folytonos vonal mentén. És most egy kicsit részletesebben a tengeri útvonalak példáján:

Ha állandó irányban navigál, akkor a hajó mozgásának pályája mentén halad a Föld felszíne a matematikában nevezett görbe lesz logaritmikusspirál.

A navigációban ezt az összetett kettős görbületi vonalat ún loxodrómia, ami görögül „ferde futást” jelent.

A földgömb két pontja közötti legrövidebb távolságot azonban egy nagykör íve mentén mérjük.

A nagykör ívét a földfelszín és a föld középpontján átmenő sík metszéspontjából gömbnek vesszük.

A navigációban a nagykörívet ún nagy kör, ami "egyenes futást" jelent. A nagykör második jellemzője, hogy a meridiánokat különböző szögekben keresztezi (29. ábra).

A földfelszín két pontja közötti távolságkülönbség a loxodrom és az ortodrom mentén csak a nagy óceáni átkeléseknél bír gyakorlati jelentőséggel.

Normál körülmények között ezt a különbséget figyelmen kívül hagyják, és a navigációt állandó irányban, pl. a loxodrom által.

Az egyenlet levezetéséhez loxodrómiákat veszünk (30. ábra, a) két pont ÉSés NÁL NÉL, egyszerűen kicsi a távolság köztük. A meridiánokat és azokon keresztül párhuzamot húzva egy elemi derékszögű gömbháromszöget kapunk ABC. Ebben a háromszögben a meridián és a párhuzamos metszéspontja által alkotott szög derékszögű, és a PnAB megegyezik a K. Katet hajó irányával AC egy meridián ívszakaszt képvisel, és kifejezhető

hol R - a Föld sugara gömbnek tekintve;

Δφ - a szélesség elemi növekménye (szélességi fokok különbsége).

láb SW párhuzamos ívszakaszt ábrázol

ahol r - a párhuzamos sugár;

Δλ - a hosszúságok elemi különbsége.

Az OO 1 C háromszögből azt lehet találni

Majd a végső formában a láb SWígy fejezhető ki:

Elemi gömbháromszöget feltételezve ABC lakáshoz írj

Csökkentés után R és a koordináták elemi kis lépéseit végtelenül kicsinyekkel helyettesítjük

A kapott kifejezést integráljuk a φ 1, λ 1 és φ 2 tartományba, λ 2 a tgK értékét állandó értéknek tekintve:

A jobb oldalon van egy táblázatos integrál. Értékének behelyettesítése után megkapjuk a loxodrom egyenletet a labdán

Ennek az egyenletnek az elemzése lehetővé teszi számunkra, hogy a következő következtetéseket vonjuk le:

A 0 és 180 °-os pályáknál a loxodrom egy nagy kör ívévé válik - egy meridián;

90 és 270°-os szögben a loxodrom egybeesik a párhuzamossal;

A loxodrom minden párhuzamost csak egyszer, és minden meridiánt megszámlálhatatlan számú alkalommal keresztez. azok. spirálisan közeledik a pólushoz, nem éri el.

Az állandó irányvonalú, azaz a loxodrom mentén történő navigáció, bár nem ez a legrövidebb távolság a Föld két pontja között, jelentős kényelmet jelent a navigátor számára.

A tengeri navigációs térképekkel szemben támasztott követelmények a loxodrom mentén történő navigáció előnye és az egyenlete elemzésének eredményei alapján az alábbiak szerint fogalmazhatók meg.

1. A meridiánokat állandó szögben keresztező Loxodromot egyenes vonalként kell ábrázolni.

2. térképvetítés, amelyet térképek készítéséhez használnak, egyenlő szögűnek kell lennie, hogy a rajta lévő pályák, irányszögek és szögek megfeleljenek a talajon lévő értéküknek.

3. A meridiánoknak és párhuzamosoknak, mint például a 0, 90, 180° és 270° pályavonalaknak egymásra merőleges egyeneseknek kell lenniük.

A Föld felszínének két adott pontja között a legrövidebb távolság – gömbnek tekintve – az ezeken a pontokon áthaladó nagykör ívei közül a kisebb. A meridiánt vagy az egyenlítőt követő hajók kivételével a nagy kör különböző szögekben keresztezi a meridiánokat. Ezért egy ilyen ívet követő hajónak folyamatosan változtatnia kell az irányát. Gyakorlatilag kényelmesebb olyan pályát követni, amely állandó szöget zár be a meridiánokkal, és amelyet a térképen a Mercator-vetületben egy egyenes - loxodrom - ábrázol. Nagy távolságok esetén azonban az ortodrom és a loxodrom hosszának különbsége jelentős értéket ér el. Ezért ilyenkor kiszámítják az ortodromot, és kijelölik rajta a közbenső pontokat, amelyek között a loxodrom mentén úsznak.

A fenti követelményeknek megfelelő térképészeti vetítést Gerard Cramer (Mercator) holland térképész javasolta 1569-ben. Alkotója tiszteletére a vetítést elnevezték. Mercator.

És ki akar még többet kapni érdekes információ tudj meg többet Az eredeti cikk a honlapon található InfoGlaz.rf Link a cikkhez, amelyből ez a másolat készült -

TÁVOLSÁG, távolságok, vö. 1. Két pontot elválasztó tér, rés valami között. Az egyenes két pontja közötti legrövidebb távolság. Két kilométerre tőlünk lakik. „A parancsnok beengedte őket a legközelebbi távolságból… Szótár Ushakov

távolság- főnév, s., használat. gyakran Morfológia: (nem) mi? távolság minek? távolság, (lásd) mit? távolság, mint? távolság, mi? a távolságról; pl. mit? távolság, (nem) mi? távolságok, miért? távolságok, (lásd) mit? távolság, mint? távolságok... Dmitriev szótára

távolság- Én; vö. A két pontot, két tárgyat stb. elválasztó tér, valaki közötti rés, mint l. A legrövidebb folyó két pont között. R. otthonról az iskolába. Menjen vissza a közeli folyóhoz. Egy méter távolságban kinyújtott karokkal. Tudni valamit, érezni valamit. tovább… … enciklopédikus szótár

távolság- Én; vö. Lásd még távolság a) Két pontot, két objektumot stb. elválasztó tér, valaki közötti rés, mint l. A legrövidebb távolság két pont között. Távolság otthontól az iskoláig. Visszahúzódni közeli távolságba / ni... Sok kifejezés szótára

GEOMETRIA- a matematika olyan ága, amely a különféle formák (pontok, vonalak, szögek, két- és háromdimenziós objektumok tulajdonságait, méretét és egymáshoz viszonyított helyzetét) vizsgálja. A tanítás kényelme érdekében a geometriát planimetriára és szilárd geometriára osztják. NÁL NÉL… … Collier Encyclopedia

Navigáció*

Navigáció- a hajózási osztály (lásd), a hajó tengeri helyének meghatározásának módjainak bemutatása, iránytű és napló segítségével (lásd). Egy hajó tengeri helyének meghatározása azt jelenti, hogy fel kell tüntetni a térképen azt a pontot, ahol a hajó tartózkodik Ebben a pillanatban van.…… Enciklopédiai szótár F.A. Brockhaus és I.A. Efron

COGEN- (Cohen) Hermann (1842, 1918) német filozófus, a neokantianizmus marburgi iskolájának megalapítója és legkiemelkedőbb képviselője. Főbb munkái: „Kant tapasztalatelmélete” (1885), „Kant etika indoklása” (1877), „Kant esztétika indoklása” (1889), „Logika… ...

Kant Immanuel- Kant életútja és írásai Immanuel Kant a kelet-poroszországi Königsbergben (ma Kalinyingrád) született 1724-ben. Édesapja nyerges, édesanyja háziasszony volt, hat gyermekük nem élte meg a felnőttkort. Kant mindig úgy emlékezett a szüleire, hogy ...... A nyugati filozófia eredetétől napjainkig

KANT KRITIKAI FILOZÓFIÁJA: A KÉPESSÉGEK TANÁJA- (La philosophie critique de Kant: Doctrines des facultes, 1963) Deleuze. A bevezetőben a transzcendentális módszert leírva Deleuze megjegyzi, hogy Kant a filozófián a minden tudás és a lényegi célok viszonyának tudományát érti... ... Filozófiatörténet: Enciklopédia

farm elv- a geometriai optika alapelve (Lásd Geometriai optika). Az F. o. legegyszerűbb formája az az állítás, hogy egy fénysugár mindig két olyan pont között terjed a térben, amelyen az áthaladásának ideje kisebb, mint ... Nagy szovjet enciklopédia

(Ábrázoló geometria)
  • CD (CXDX, C2D2) pontként látható C5 = D5 A5B5 egyenlő...
    (Ábrázoló geometria)
  • Két párhuzamos sík távolságának meghatározása
    Két párhuzamos sík távolságának meghatározása általános helyzetben 01| x célszerű az ugyanazon két sík közötti távolság meghatározásának problémájára redukálni, a kiálló síkok helyzetébe transzformálva. Ebben az esetben a síkok közötti távolságot az egyenesek közötti merőlegesként határozzuk meg, ...
    (Ábrázoló geometria)
  • Két egymást metsző egyenes távolságának meghatározása
    Ha két egymást metsző egyenes között a legrövidebb távolságot akarjuk meghatározni, akkor kétszer meg kell változtatni a vetítési síkok rendszerét. A probléma megoldása során a közvetlen CD (CXDX, C2D2) pontként látható C5 = D5(198. ábra). Távolság ettől a ponttól a vetületig A5B5 egyenlő...
    (Ábrázoló geometria)
  • Szög két egymást metsző egyenes között
    Ez a szög két metsző egyenes között, amelyek párhuzamosak az adatokkal. Így ez a feladat hasonló az előzőhöz. Megoldásához fel kell venni egy tetszőleges pontot és rajta kell két egyenest húzni párhuzamosan az adott ferde vonalakkal, és a vetítési transzformáció segítségével meghatározni a szükséges szöget....
    (A leíró geometria alapjai. Rövid tanfolyamés feladatgyűjtemény.)
  • Két párhuzamos egyenes távolságának meghatározása
    A problémát a vetületi síkok kettős cseréjének módszere oldja meg. A végső szakaszban az egyik vetületi síknak merőlegesnek kell lennie az egyik metsző egyenesre. Ekkor a köztük lévő legrövidebb távolságot a másik ferde egyenesre merőleges szakasz értéke határozza meg (199. ábra)....
    (Ábrázoló geometria)
  • Miután krétával felvázolt két pontot a táblára, a tanár egy feladatot kínál a fiatal diáknak: rajzolja meg a két pont között a legrövidebb utat.

    A tanuló gondolkodás után szorgalmasan kanyargós vonalat húz közöttük.

    - Ez a legrövidebb út! – lepődik meg a tanár. - Ki tanított erre?

    - Édesapám. Ő taxisofőr.

    Egy naiv iskolás rajza természetesen anekdotikus, de nem mosolyogna-e, ha azt mondanák, hogy a pontozott ív az 1. ábrán. 1 a legrövidebb út a Jóreménység fokától Ausztrália déli csücskéig!

    Még feltűnőbb a következő állítás: a 2. ábrán látható. 2 oda-vissza út Japánból a Panama-csatornáig rövidebb, mint az ugyanazon a térképen közöttük húzott egyenes!

    Rizs. 1. Be tengeri térkép a Jóreménység-foktól Ausztrália déli csücskébe vezető legrövidebb utat nem egyenes vonal ("loxodrom"), hanem görbe ("ortodromia") jelzi.


    Mindez viccnek tűnik, de közben vitathatatlan igazságok állnak előtted, amelyeket jól ismernek a térképészek.




    Rizs. 2. Hihetetlennek tűnik, hogy a Yokohamát a tengeri térképen a Panama-csatornával összekötő íves út rövidebb, mint az ugyanazon pontok közé húzott egyenes vonal


    A kérdés tisztázása érdekében néhány szót kell ejteni a térképekről általában, és különösen a tengeri térképekről. A földfelszín részeit papírra rajzolni még elvileg sem egyszerű feladat, mert a Föld egy gömb, és köztudott, hogy a gömbfelület egyetlen része sem helyezhető el síkon gyűrődések és törések nélkül. Önkéntelenül is bele kell tűrni a térképek elkerülhetetlen torzulásait. Sokféle térképrajzolási módot találtak ki, de nem minden térkép mentes a hiányosságoktól: némelyiken más, másokon más jellegűek a torzulások, de nincs torzítás nélküli térkép.

    A tengerészek egy 16. századi régi holland térképész és matematikus módszere szerint készült térképeket használnak. Mercator. Ezt a módszert Mercator-projekciónak nevezik. A tengeri térképet könnyű felismerni téglalap alakú rácsáról: a meridiánok párhuzamos egyenesek sorozataként jelennek meg rajta; szélességi körök - az elsőre merőleges egyenesekben is (lásd 5. ábra).

    Képzelje el most, hogy meg akarja találni a legrövidebb utat az egyik óceáni kikötőtől a másikig ugyanazon a párhuzamoson. Az óceánon minden ösvény elérhető, és mindig a legrövidebb úton lehet eljutni oda, ha tudja, hogyan fekszik. Esetünkben természetes, hogy azon a párhuzamoson megy a legrövidebb út, amelyen mindkét kikötő fekszik: a térképen ugyanis ez egy egyenes, és mi lehet rövidebb az egyenesnél! De tévedünk: a párhuzamos út egyáltalán nem a legrövidebb.

    Valóban: egy gömb felületén két pont között a legrövidebb távolság az őket összekötő nagykör íve. De a párhuzamos kör kicsi kör. Egy nagy kör íve kevésbé ívelt, mint bármely, ugyanazon a két ponton áthúzott kis kör íve: a nagyobb sugár kisebb görbületnek felel meg. Húzza meg a fonalat a földgömbön a két pontunk között (vö. 3. ábra); gondoskodni fog arról, hogy egyáltalán ne feküdjön a párhuzamos mentén. Szűk szál – vitathatatlan mutató a legrövidebb utat, és ha nem esik egybe a földgömbön lévő párhuzamossal, akkor a tengeri térképen a legrövidebb utat nem jelöli egyenes: emlékezzünk arra, hogy a párhuzamosok köreit egy ilyen térképen egyenesek ábrázolják, minden olyan vonal nem esik egybe egyenes vonallal ív .



    Rizs. 3. Egy egyszerű módja annak, hogy megtaláljuk az igazán legrövidebb utat két pont között: egy szálat kell húzni a földgömbön e pontok között


    Az elmondottak után világossá válik, hogy a tengertérképen a legrövidebb út miért nem egyenes, hanem görbe vonalként van ábrázolva.

    Azt mondják, amikor Nikolaevskaya (most Oktyabrskaya) irányát választják vasúti végtelen viták folytak arról, hogy melyik utat fektessék le. A vitáknak I. Miklós cár beavatkozása vetett véget, aki szó szerint „egyenesen” oldotta meg a problémát: Szentpétervárt Moszkvával kötötte össze a vonal mentén. Ha ezt egy Mercator térképen csinálták volna, akkor kínos meglepetés lett volna: az egyenes vonal helyett ívnek bizonyult volna az út.

    Aki nem kerüli el a számításokat, az egy egyszerű számítással meggyőződhet arról, hogy a térképen számunkra ívesnek tűnő út valójában rövidebb, mint az, amelyet készek vagyunk egyenesnek tekinteni. Legyen két kikötőnk a 60. párhuzamoson, és 60°-os távolság választja el őket egymástól. (Az, hogy valóban létezik-e ilyen két kikötő, természetesen a számítás szempontjából lényegtelen.)



    Rizs. 4. A golyó A és B pontjai közötti távolság kiszámításához a párhuzamos ív és a nagykör íve mentén


    ábrán. 4 pont O - központ a földgömb, AB - a szélességi kör íve, amelyen kikötők fekszenek A és B; ban ben neki 60°. A szélességi kör középpontja egy pontban van TÓL TŐL Képzeld el a központból O a földgömb ugyanazon a kikötőkön keresztül egy nagy körívet húznak: a sugarát OB = OA = R; közel fog haladni a húzott ívhez AB, de nem egyezik.

    Számítsuk ki az egyes ívek hosszát. A pontok óta ÉSés NÁL NÉL 60°-os szélességi fokon fekszenek, akkor a sugarak OAés OV kavarni valakivel OS(a földgömb tengelye) 30°-os szög. Derékszögű háromszögben ASO láb AC (=r), 30°-os szöggel szemben fekvő, a hipotenúza felével egyenlő JSC;

    eszközök, r=R/2Ívhossz AB a szélességi kör hosszának egyhatoda, és mivel ez a kör fele akkora, mint a nagy kör (ami a sugár felének felel meg), akkor a kis kör ívének hossza



    Ahhoz, hogy meghatározzuk az ugyanazon pontok közé húzott nagykör ívének hosszát (vagyis a közöttük lévő legrövidebb utat), ismernünk kell a szög nagyságát. AOW. Akkord MINT, levonva az ívet 60 ° -ra (kis kör), egy szabályos hatszög oldala, amely ugyanabba a kis körbe van írva; így AB \u003d r \u003d R / 2

    Egyenes vonal rajzolása od,összekötő központ O a földgömb a közepével D akkordok AB, kap egy derékszögű háromszöget ODA, hol van a szög D- egyenes:

    DA= 1/2 AB és OA=R.

    sinAOD=AD: AO=R/4:R=0,25

    Innen (a táblázatok szerint):

    =14°28",5

    és innentől

    = 28°57".

    Most már nem nehéz megtalálni a legrövidebb út kívánt hosszát kilométerben. A számítás leegyszerűsíthető, ha emlékezünk arra, hogy a földgömb egy nagy körének egy perc hossza a

    Megtudjuk, hogy a tengeri térképen egyenes vonallal ábrázolt szélességi kör mentén 3333 km, a nagy kör mentén - a térképen látható ív mentén - 3213 km, azaz 120 km-rel rövidebb.

    Egy cérnával felfegyverkezve, kéznél lévő földgolyóval könnyedén ellenőrizheti rajzaink helyességét, és megbizonyosodhat arról, hogy a nagy körök ívei valóban a rajzokon látható módon fekszenek. ábrán látható. 1 mintha az Afrikából Ausztráliába vezető „egyenes” tengeri útvonal 6020 mérföld, a „görbe” pedig 5450 mérföld, azaz 570 mérfölddel vagy 1050 km-rel rövidebb lenne. A tengeri térképen Londonból Sanghajba tartó "közvetlen" légi útvonal a Kaszpi-tengeren vág át, míg az igazán legrövidebb útvonal Szentpétervártól északra húzódik. Egyértelmű, hogy ezek a problémák milyen szerepet játszanak az idő- és üzemanyag-megtakarításban.

    Ha a vitorlás hajózás korszakában az időt nem mindig értékelték - akkor az "időt" még nem tekintették "pénznek", akkor a gőzhajók megjelenésével minden további elfogyasztott szénért fizetni kell. Ezért manapság a hajók az igazán legrövidebb útvonalon közlekednek, gyakran nem a Mercatorban, hanem az úgynevezett "centrális" vetületben készült térképeket használva: ezeken a térképeken a nagykörök ívei egyenes vonalakként vannak ábrázolva.

    Akkor miért használtak az egykori navigátorok ilyen megtévesztő térképeket és választottak kedvezőtlen utakat? Tévedés azt gondolni, hogy régen nem tudtak a tengeri térképek most jelzett tulajdonságáról. A dolgot persze nem ez magyarázza, hanem az, hogy a Mercator-módszer szerint rajzolt térképek a kellemetlenségekkel együtt igen értékes haszonnal járnak a hajósok számára. Egy ilyen térkép először is a földfelszín különálló kis részeit ábrázolja torzítás nélkül, megőrizve a kontúr sarkait. Ennek nem mond ellent az a tény, hogy az egyenlítőtől való távolsággal minden kontúr észrevehetően megnyúlik. Magas szélességi körökön a szakasz olyan jelentős, hogy a tengeri térkép teljesen hamis elképzeléssel inspirálja azt az embert, aki nem ismeri annak jellemzőit a kontinensek valódi méretéről: Grönland olyan méretűnek tűnik, mint Afrika, Alaszka nagyobb, mint Ausztrália, bár Grönland 15-ször kisebb, mint Afrika, és Alaszka Grönlanddal együtt fele akkora, mint Ausztrália. De egy tengerészt, aki jól ismeri a térkép e jellemzőit, nem lehet velük félrevezetni. Tűri őket, különösen azért, mert kis területeken belül a tengeri térkép pontos természetszerűséget ad (5. ábra).

    Másrészt a tengeri térkép nagyban megkönnyíti a hajózási gyakorlat feladatainak megoldását. Ez az egyetlen olyan térképtípus, amelyen egy állandó pályán lévő hajó útvonala egyenes vonalként van ábrázolva. Az „állandó pályát” követni azt jelenti, hogy változatlanul egy irányt, egy határozott „lodát” tartunk, más szóval, úgy haladunk, hogy az összes meridiánt egyenlő szögben keresztezzük. De ez az út ("loxodrom") csak olyan térképen ábrázolható egyenesként, amelyen minden meridián egymással párhuzamos egyenes. És mivel a földgömbön a szélességi körök derékszögben metszik egymást a meridiánokkal, akkor egy ilyen térképen a szélességi körök a meridiánok vonalaira merőleges egyenesek legyenek. Röviden, pontosan elérkezünk ahhoz a koordináta-rácshoz, amely a tengeri térkép jellegzetes eleme.




    Rizs. 5. A földgömb tengeri vagy Mercator térképe. Az ilyen térképeken az egyenlítőtől távol eső körvonalak méretei erősen eltúlzottak. Például melyik a nagyobb: Grönland vagy Ausztrália? (válasz szövegben)


    A matrózok előszeretettel való Mercator térképei most már érthetőek. A navigátor meg akarja határozni a követendő irányt, amikor a kijelölt kikötőbe megy, és egy vonalzót alkalmaz az útvonal végpontjaira, és megméri a szöget, amelyet a meridiánokkal bezár. Ebben az irányban állandóan a nyílt tengeren tartva a navigátor pontosan a célhoz viszi a hajót. Látja, hogy a „loxodrom” bár nem a legrövidebb és nem a leggazdaságosabb, de bizonyos szempontból nagyon kényelmes módja egy tengerésznek. Ha például a Jóreménység-foktól Ausztrália déli csücskébe szeretne eljutni (lásd 1. ábra), mindig ugyanazt az irányt kell tartania S 87 °,50". utolsó pont a legrövidebb utat(az „ortodromia szerint”), amint az az ábrán látható, folyamatosan módosítani kell az edény irányát: az S 42 °, 50 "pályáról kell kezdeni, és az N 53 °, 50 pályával kell befejezni. " (ebben az esetben a legrövidebb út nem is járható - az antarktiszi jégfalba támaszkodik).

    Mindkét út - a "loxodrom" és az "ortodromia" mentén - csak akkor esik egybe, ha a nagy kör mentén haladó utat a tengeri térképen egyenes vonalként ábrázolja: az egyenlítő vagy a meridián mentén haladva. Minden más esetben ezek az utak eltérőek.

    A Dijkstra algoritmusa egy gráfalgoritmus, amelyet Edsger Dijkstra holland tudós talált fel 1959-ben. Megkeresi a legrövidebb utat a gráf egyik csúcsától a többihez. Az algoritmus működik csak negatív súlyú élek nélküli gráfokhoz.

    Tekintsük az algoritmus végrehajtását az ábrán látható gráf példáján!

    Meg kell találni a legrövidebb távolságokat az 1. csúcstól az összes többiig.

    A körök a csúcsokat, a vonalak a köztük lévő utakat (a gráf éleit) jelölik. A csúcsok számai a körökben vannak feltüntetve, "áruk" - az út hossza - az élek felett. Minden csúcs mellett egy piros címke van megjelölve - az ehhez a csúcshoz vezető legrövidebb út hossza az 1. csúcstól.

    Első lépés. Tekintsünk egy lépést Dijkstra algoritmusában a példánkban. Az 1. csúcsnak van minimális címkéje, a 2., 3. és 6. csúcs pedig szomszédja.

    Az 1. csúcs első szomszédja viszont a 2. csúcs, mivel az oda vezető út hossza minimális. A hozzá vezető út hossza az 1. csúcson át egyenlő az 1. csúcs címkéje értékének és az 1-től 2-ig tartó él hosszának összegével, azaz 0 + 7 = 7. Ez kisebb, mint a a 2. csúcs jelenlegi címkéje a végtelen, tehát a 2. csúcs új címkéje 7.

    Hasonló műveletet hajtunk végre az 1. csúcs két másik szomszédjával - a 3. és 6. -kal.

    Az 1. csomópont összes szomszédja ellenőrzésre kerül. Az 1. csúcsig mért jelenlegi minimális távolság véglegesnek minősül, és nem módosítható (azt a tényt, hogy ez valóban így van, először E. Dijkstra bizonyította). Húzd át a grafikonon, jelezve, hogy ezt a csúcsot meglátogatták.

    Második lépés. Az algoritmus lépése megismétlődik. Ismét megtaláljuk a „legközelebbi” a nem látogatott csúcsokat. Ez a 7-es jelölésű 2. csúcs.

    Ismét megpróbáljuk csökkenteni a kiválasztott csúcs szomszédjainak címkéit, megpróbálva átjutni rajtuk a 2. csúcson. A 2. csúcs szomszédai az 1., 3. és 4. csúcsok.

    A 2. csúcs első (sorrendben) szomszédja az 1. csúcs. De már meglátogatták, így az 1. csúcsponttal nem csinálunk semmit.

    A 2. csúcs következő szomszédja a 3. csúcs, mivel ezen van a látogatatlanként megjelölt csúcsok minimális címkéje. Ha 2-n keresztül megy hozzá, akkor egy ilyen út hossza 17 lesz (7 + 10 = 17). De a harmadik csúcs jelenlegi címkéje 9, ami kevesebb, mint 17, tehát a címke nem változik.

    A 2. csúcs másik szomszédja a 4. csúcs. Ha a 2. csúcson keresztül megyünk hozzá, akkor egy ilyen út hossza egyenlő lesz a 2. csúcstól mért legrövidebb távolság és a 2. és 4. csúcsok közötti távolság összegével, azaz , 22 (7 + 15 = 22) . 22 óta<, устанавливаем метку вершины 4 равной 22.

    A 2. csúcs összes szomszédja meg lett nézve, a távolságot rögzítjük és meglátogatottnak jelöljük.

    Harmadik lépés. Az algoritmus lépését megismételjük a 3. csúcs kiválasztásával. Ennek „feldolgozása” után a következő eredményeket kapjuk:

    Következő lépések. Megismételjük az algoritmus lépését a fennmaradó csúcsokra. Ezek a 6., 4. és 5. csúcsok lesznek.

    Az algoritmus végrehajtásának befejezése. Az algoritmus akkor fejeződik be, ha már nem lehet több csúcsot feldolgozni. Ebben a példában minden csúcs át van húzva, de tévedés azt feltételezni, hogy ez minden példában így lesz - egyes csúcsok áthúzva maradhatnak, ha nem érhetők el, vagyis ha a gráf szét van kapcsolva. Az algoritmus eredménye az utolsó ábrán látható: a legrövidebb út az 1-es csúcstól a 2-ig 7, a 3-ig a 9, a 4-ig 20, az 5-ig a 20, a 6-ig a 11.

    Az algoritmus megvalósítása különböző programozási nyelveken:

    C++

    #include "stdafx.h" #include névtér használata std; const int V=6; // Dijkstra algoritmusa void Dijkstra(int GR[V][V], int st) ( int távolság[V], szám, index, i, u, m=st+1; bool látogatott[V]; for (i= 0 i "< "<> "; cin>>start; Dijkstra(GR, start-1); system("pause>>void"); )

    Pascal

    program DijkstraAlgoritmus; usescrt; constV=6; inf=100000; típus vektor=egész számok tömbje; var start: integer; const GR: egész számok tömbje=((0, 1, 4, 0, 2, 0), (0, 0, 0, 9, 0, 0), (4, 0, 0, 7, 0, 0), (0, 9, 7, 0, 0, 2), (0, 0, 0, 0, 0, 8), (0, 0, 0, 0, 0, 0)); (Dijkstra algoritmusa) eljárás Dijkstra(GR: egész szám tömbje; st: egész szám); var count, index, i, u, m, min: integer; távolság: vektor; látogatott: array of boolean; beginm:=st; ha i:=1-től V-ig kezdjük a távolságot[i]:=inf; látogatott[i]:=false; vége; távolság:=0; a count:=1-től V-1-ig kezdje a min:=inf; i:=1-től V do if (nem látogatott[i]) és (távolság[i]<=min) then begin min:=distance[i]; index:=i; end; u:=index; visited[u]:=true; for i:=1 to V do if (not visited[i]) and (GR<>0) és (távolság[u]<>inf) és (távolság[u]+GR inf then writeln(m," > ", i," = ", távolság[i]) else writeln(m," > ", i," = ", "útvonal nem elérhető"); vége; (főprogram blokk) begin clrscr; write("Kezdő csomópont >> "); olvas(start); Dijkstra(GR, start); vége.

    Jáva

    import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Arrays; import java.util.StringTokenenizer; public class Megoldás ( private static int INF = Integer.MAX_VALUE / 2; private int n; //csúcsok száma digráfban private int; //ívek száma digráfban private ArrayList adj; //adjacency list private ArrayList súly; // él súlya a digráf privát logikai értékében; //tömb az átadott és át nem adott csúcsok információinak tárolására private int dist; //tömb a kezdő csúcstól való távolság tárolására //az ősök tömbje, amely a kiindulási csúcstól a legrövidebb út visszaállításához szükséges private int pred; int start; //kezdő csúcs, ahonnan az összes többi távolságot keresi privát BufferedReader cin; privát PrintWriter cout; privát StringTokenizer tokenizátor; //eljárás Dijkstra algoritmusának a kezdőcsúcsból való indításához private void dejkstra(int s) ( dist[s] = 0; //a kezdőcsúcs legrövidebb távolsága 0 for (int iter = 0; iter< n; ++iter) { int v = -1; int distV = INF; //выбираем вершину, кратчайшее расстояние до которого еще не найдено for (int i = 0; i < n; ++i) { if (used[i]) { continue; } if (distV < dist[i]) { continue; } v = i; distV = dist[i]; } //рассматриваем все дуги, исходящие из найденной вершины for (int i = 0; i < adj[v].size(); ++i) { int u = adj[v].get(i); int weightU = weight[v].get(i); //релаксация вершины if (dist[v] + weightU < dist[u]) { dist[u] = dist[v] + weightU; pred[u] = v; } } //помечаем вершину v просмотренной, до нее найдено кратчайшее расстояние used[v] = true; } } //процедура считывания входных данных с консоли private void readData() throws IOException { cin = new BufferedReader(new InputStreamReader(System.in)); cout = new PrintWriter(System.out); tokenizer = new StringTokenizer(cin.readLine()); n = Integer.parseInt(tokenizer.nextToken()); //считываем количество вершин графа m = Integer.parseInt(tokenizer.nextToken()); //считываем количество ребер графа start = Integer.parseInt(tokenizer.nextToken()) - 1; //инициализируем списка смежности графа размерности n adj = new ArrayList[n]; for (int i = 0; i < n; ++i) { adj[i] = new ArrayList(); ) //az élek súlyait tároló lista inicializálása weight = new ArrayList[n]; for (int i = 0; i< n; ++i) { weight[i] = new ArrayList(); ) //olvassa el az élek listájából adott gráfot az (int i = 0; i< m; ++i) { tokenizer = new StringTokenizer(cin.readLine()); int u = Integer.parseInt(tokenizer.nextToken()); int v = Integer.parseInt(tokenizer.nextToken()); int w = Integer.parseInt(tokenizer.nextToken()); u--; v--; adj[u].add(v); weight[u].add(w); } used = new boolean[n]; Arrays.fill(used, false); pred = new int[n]; Arrays.fill(pred, -1); dist = new int[n]; Arrays.fill(dist, INF); } //процедура восстановления кратчайшего пути по массиву предком void printWay(int v) { if (v == -1) { return; } printWay(pred[v]); cout.print((v + 1) + " "); } //процедура вывода данных в консоль private void printData() throws IOException { for (int v = 0; v < n; ++v) { if (dist[v] != INF) { cout.print(dist[v] + " "); } else { cout.print("-1 "); } } cout.println(); for (int v = 0; v < n; ++v) { cout.print((v + 1) + ": "); if (dist[v] != INF) { printWay(v); } cout.println(); } cin.close(); cout.close(); } private void run() throws IOException { readData(); dejkstra(start); printData(); cin.close(); cout.close(); } public static void main(String args) throws IOException { Solution solution = new Solution(); solution.run(); } }

    Egy másik lehetőség:

    Java.io.* importálása; import java.util.*; public class Dijkstra ( privát statikus végleges Graph.Edge GRAPH = ( new Graph.Edge("a", "b", 7), new Graph.Edge("a", "c", 9), new Graph.Edge( "a", "f", 14), new Graph.Edge("b", "c", 10), new Graph.Edge("b", "d", 15), new Graph.Edge("c" ", "d", 11), new Graph.Edge("c", "f", 2), new Graph.Edge("d", "e", 6), new Graph.Edge("e", "f", 9), ); private static final String START = "a"; private static final String END = "e"; public static void main(String args) ( Graph g = new Graph(GRAPH); g.dijkstra (START); g.printPath(END); //g.printAllPaths(); ) ) osztálygrafikon ( privát végső térkép grafikon; // csúcsnevek leképezése Vertex objektumokra, élek halmazából építve /** A gráf egyik éle (csak a Graph konstruktor használja) */ public static class Edge ( public final String v1, v2; public final int dist; public Edge(String v1, String v2, int dist) ( this.v1 = v1; this.v2 = v2; this.dist = dist; ) ) /** A gráf egyik csúcsa, kiegészítve a szomszédos csúcsok leképezéseivel */ public static class Vertex implements Comparable ( public final String name; public int dist = Integer.MAX_VALUE; // MAX_VALUE végtelennek tételezve public Csúcs előző = null; public final Map szomszédok = új HashMap<>(); public Vertex(String name) ( this.name = név; ) private void printPath() ( if (this == this.previous) ( System.out.printf("%s", this.name); ) else if ( this.previous == null) ( System.out.printf("%s(unreached)", this.name); ) else ( this.previous.printPath(); System.out.printf(" -> %s() %d)", this.name, this.dist); ) ) public int ÖsszehasonlításTo(Csúcs egyéb) ( return Integer.compare(dist, other.dist); ) ) /** Élkészletből gráfot készít * / public Graph(Élek) ( grafikon = új HashMap<>(élek.hossz); //egy lépés az (Edge e: élek) összes csúcsának megtalálásához ( if (!graph.containsKey(e.v1)) graph.put(e.v1, new Vertex(e.v1)); if (!graph. includeKey(e.v2)) graph.put(e.v2, new Vertex(e.v2)); ) //egy másik lépés az (Edge e: élek) szomszédos csúcsainak beállításához ( graph.get(e.v1). szomszédok.put(graph.get(e.v2), e.dist); //graph.get(e.v2).neighbours.put(graph.get(e.v1), e.dist); // szintén csináld ezt irányítatlan gráfnál ) ) /** A dijkstra-t egy megadott forráscsúcs használatával futtatja */ public void dijkstra(String startName) ( if (!graph.containsKey(startName)) ( System.err.printf("A grafikon nem tartalmazza a kezdőpontot \"%s\"\n", startName); return; ) végső csúcsforrás = graph.get(startName); NavigableSet q = új TreeSet<>(); // csúcsok beállítása a következőhöz: (V csúcs: graph.values()) ( v.previous = v == forrás ? forrás: null; v.dist = v == forrás v); ) dijkstra(q); ) /** A dijkstra algoritmus megvalósítása bináris kupac használatával. */ private void dijkstra(final NavigableSet q) ( Csúcs u, v; while (!q.isEmpty()) ( u = q.pollFirst(); // legrövidebb távolságú csúcs (az első iteráció a forrást adja vissza) if (u.dist == Integer.MAX_VALUE) break; // figyelmen kívül hagyhatjuk az u-t (és a többi megmaradt csúcsot), mivel nem érhetők el //nézzük meg az egyes szomszédok távolságát a (Map.Entry a: u.neighbours.entrySet()) ( v = a.getKey(); //a szomszéd ebben az iterációban final int alternateDist = u.dist + a.getValue(); if (alternateDist< v.dist) { // shorter path to neighbour found q.remove(v); v.dist = alternateDist; v.previous = u; q.add(v); } } } } /** Prints a path from the source to the specified vertex */ public void printPath(String endName) { if (!graph.containsKey(endName)) { System.err.printf("Graph doesn"t contain end vertex \"%s\"\n", endName); return; } graph.get(endName).printPath(); System.out.println(); } /** Prints the path from the source to every vertex (output order is not guaranteed) */ public void printAllPaths() { for (Vertex v: graph.values()) { v.printPath(); System.out.println(); } } }

    C

    #beleértve #beleértve #beleértve //#define BIG_EXAMPLE typedef struct node_t node_t, *heap_t; typedef struktúra él_t él_t; struct edge_t ( node_t *nd; /* ennek az élnek a célja */ edge_t *testvér;/* egyedileg linkelt listához */ int len; /* élköltség */ ); struct node_t ( él_t *él; /* az élek egyedileg összekapcsolt listája */ node_t *via; /* ahol az előző csomópont a legrövidebb úton van */ double dist; /* távolság a kiinduló csomóponttól */ karakternév; /* a, er , name */ int heap_idx /* link a kupac pozíciójához a távolság frissítéséhez */ ); /* --- élkezelés --- */ #ifdef BIG_EXAMPLE # BLOCK_SIZE meghatározása (1024 * 32 - 1) #else # BLOCK_SIZE meghatározása 15 #endif edge_t *él_gyökér = 0, *e_next = 0; /* Ne törődj a memóriakezeléssel, ezek a lényegen kívül esnek. Úgy tesz, mintha e_next = malloc(sizeof(edge_t)) */ void add_edge(node_t *a, node_t *b, double d) ( if (e_next == edge_root ) ( él_gyökér = malloc(sizeof(edge_t) * (BLOCK_SIZE + 1)); él_gyökér.testvér = e_next; e_next = él_gyökér + BLOCK_SIZE; ) --e_next; e_next->nd = b; e_next->len = ex ->testvér = a->él; a->él = e_next; ) void szabad_élek() ( for (; él_gyökér; él_gyökér = e_next) ( e_next = él_gyökér.testvér; szabad(él_gyökér); ) ) /* --- priority queue cucc --- */ heap_t *heap; int heap_len; void set_dist(node_t *nd, node_t *via, double d) ( int i, j; /* már ismertebb volt az elérési út */ if (nd->via && d >= nd->dist) return; /* megkeresi a meglévő kupacbejegyzést, vagy hozzon létre egy újat */ nd->dist = d; nd->via = via; i = nd->heap_idx; if (!i) i = ++heap_len; /* upheap */ for (; i > 1 && nd->dist< heap->dist; i = j) (halom[i] = kupac[j])->halom_idx = i; halom[i] = nd; nd->heap_idx = i; ) node_t * pop_queue() ( node_t *nd, *tmp; int i, j; if (!heap_len) visszatér 0 (i = 1; i< heap_len && (j = i * 2) <= heap_len; i = j) { if (j < heap_len && heap[j]->dist > halom->dist) j++; if (heap[j]->dist >= tmp->dist) break; (halom[i] = kupac[j])->halom_idx = i; ) halom[i] = tmp; tmp->heap_idx = i; return nd; ) /* --- Dijkstra cucc; elérhetetlen csomópontok soha nem fognak ba,-be queue --- */ void calc_all(node_t *start) ( csomópont_t *lead; él_t *e; set_dist(start, start, 0); while ((lead = pop_queue())) for (e = lead->él; e; e = e->testvér) set_dist(e->nd, lead, lead->dist + e->len); ) void show_path(node_t *nd) ( if (nd->via == nd) printf( "%s", nd->name); else if (!nd->via) printf("%s(unreached)", nd->name); else ( show_path(nd->via); printf("- > %s(%g) ", nd->name, nd->dist); ) ) int main(void) ( #ifndef BIG_EXAMPLE int i; # define N_NODES ("f" - "a" + 1) node_t * csomópontok = calloc(sizeof(node_t), N_NODES); for (i = 0; i< N_NODES; i++) sprintf(nodes[i].name, "%c", "a" + i); # define E(a, b, c) add_edge(nodes + (a - "a"), nodes + (b - "a"), c) E("a", "b", 7); E("a", "c", 9); E("a", "f", 14); E("b", "c", 10);E("b", "d", 15);E("c", "d", 11); E("c", "f", 2); E("d", "e", 6); E("e", "f", 9); # undef E #else /* BIG_EXAMPLE */ int i, j, c; # define N_NODES 4000 node_t *nodes = calloc(sizeof(node_t), N_NODES); for (i = 0; i < N_NODES; i++) sprintf(nodes[i].name, "%d", i + 1); /* given any pair of nodes, there"s about 50% chance they are not connected; if connected, the cost is randomly chosen between 0 and 49 (inclusive! see output for consequences) */ for (i = 0; i < N_NODES; i++) { for (j = 0; j < N_NODES; j++) { /* majority of runtime is actually spent here */ if (i == j) continue; c = rand() % 100; if (c < 50) continue; add_edge(nodes + i, nodes + j, c - 50); } } #endif heap = calloc(sizeof(heap_t), N_NODES + 1); heap_len = 0; calc_all(nodes); for (i = 0; i < N_NODES; i++) { show_path(nodes + i); putchar("\n"); } #if 0 /* real programmers don"t free memories (they use Fortran) */ free_edges(); free(heap); free(nodes); #endif return 0; }

    PHP

    $él, "költség" => $él); $szomszédok[$él] = array("vége" => $él, "költség" => $él); ) $csúcsok = tömb_egyedi($csúcsok); foreach ($csúcsok $csúcsként) ( $dist[$vertex] = INF; $previous[$vertex] = NULL; ) $dist[$source] = 0; $Q = $csúcsok; while (count($Q) > 0) ( // TODO - Találjon gyorsabb módot a minimum $min = INF eléréséhez; foreach ($Q mint $vertex)( if ($dist[$vertex]< $min) { $min = $dist[$vertex]; $u = $vertex; } } $Q = array_diff($Q, array($u)); if ($dist[$u] == INF or $u == $target) { break; } if (isset($neighbours[$u])) { foreach ($neighbours[$u] as $arr) { $alt = $dist[$u] + $arr["cost"]; if ($alt < $dist[$arr["end"]]) { $dist[$arr["end"]] = $alt; $previous[$arr["end"]] = $u; } } } } $path = array(); $u = $target; while (isset($previous[$u])) { array_unshift($path, $u); $u = $previous[$u]; } array_unshift($path, $u); return $path; } $graph_array = array(array("a", "b", 7), array("a", "c", 9), array("a", "f", 14), array("b", "c", 10), array("b", "d", 15), array("c", "d", 11), array("c", "f", 2), array("d", "e", 6), array("e", "f", 9)); $path = dijkstra($graph_array, "a", "e"); echo "path is: ".implode(", ", $path)."\n";


    Piton

    gyűjteményekből import namedtuple, queue from pprint import pprint as pp inf = float("inf") Edge = namedtuple("Edge", "start, end, cost") class Graph(): def __init__(self, élek): self .edges = élek2 = self.vertices = set(sum(( az élek2-ben lévő e-hez), )) def dijkstra(self, source, dest): forrás megerősítése a selfben.vertices dist = (vertex: inf for vertex in self.vertices ) previous = (csúcs: Nincs a self.verticesben lévő csúcshoz) dist = 0 q = self.vertices.copy() szomszédok = (csúcs: set() for self.vertices) for start, end, cost in self. élek: szomszédok.add((vége, költség)) #pp(szomszédok) while q: u = min(q, kulcs=lambda csúcs: dist) q.remove(u) if dist[u] == inf vagy u = = dest: törés v, költség a szomszédokban[u]: alt = dist[u] + költség, ha alt< dist[v]: # Relax (u,v,a) dist[v] = alt previous[v] = u #pp(previous) s, u = deque(), dest while previous[u]: s.pushleft(u) u = previous[u] s.pushleft(u) return s graph = Graph([("a", "b", 7), ("a", "c", 9), ("a", "f", 14), ("b", "c", 10), ("b", "d", 15), ("c", "d", 11), ("c", "f", 2), ("d", "e", 6), ("e", "f", 9)]) pp(graph.dijkstra("a", "e")) Output: ["a", "c", "d", "e"]