• Két pont közötti legrövidebb távolság. Tudod, miért van távolabb egy egyenesben, mint egy ívben? Két egymást metsző egyenes távolságának meghatározása

    01.02.2022

    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 legrövidebb utat a két pont között.

    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?

    - Az apám. Ő taxisofőr.

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

    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. A tengeri térképen a Jóreménység-foktól Ausztrália déli csücskébe vezető legrövidebb útvonalat 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 tengertérképen a Panama-csatornával összekötő ívelt ú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 egyes részeit papíron ábrázolni 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. A térképrajzolásnak számos módját kitalálták, de nem minden térkép mentes a hiányosságoktól: némelyiknek más, másoknak más a torzulása, 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 tudod, 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ív. De a párhuzamos kör kicsi egy kör. Egy nagy kör íve kevésbé görbült, 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. A megfeszített szál a legrövidebb út vitathatatlan mutatója, é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 egyenes vonal jelzi: ne feledje, hogy az ilyeneken párhuzamos köröket ábrázolnak. egy térkép egyenes vonalakkal, minden olyan vonal, amely nem esik egybe egy egyenessel, létezik í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, hogy a Nikolaev (ma Oktyabrskaya) vasút irányának kiválasztásakor végtelen viták voltak arról, hogy melyik utat kell lefektetni. 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 Mercator térképen csinálták volna meg, az 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, egy egyszerű számítással megbizonyosodhat arról, hogy a térképen számunkra görbének tűnő út való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 - a földgömb közepe, 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 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 DEé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ő, egyenlő a hipotenusz felével 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; ezért 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 és egy földgömbbel felvértezve 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. Világos, 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 nem mindig értékelték az időt - akkor az "idő" még nem számított "pénznek", akkor a gőzhajók megjelenésével minden további elfogyasztott szénért fizetni kell. Éppen ezért napjainkban a hajók az igazán legrövidebb úton közlekednek, gyakran nem a Mercatorban, hanem az úgynevezett „központi” vetítésben készült térképeket használva: ezeken a térképeken a nagy kö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 miért választottak kedvezőtlen utakat? Tévedés azt gondolni, hogy régen nem tudtak a tengeri térképek most jelzett sajátosságáról. A dolgot persze nem ez magyarázza, hanem az, hogy a Mercator-módszerrel rajzolt térképek a kellemetlenségekkel együtt igen értékes hasznot hoznak 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 Afrikával, Alaszkával. nagyobb, mint Ausztrália, bár Grönland 15-ször kisebb Afrikánál, Alaszka pedig 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 haladó 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ávoli 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 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ó pontja a legrövidebb úton (a "" mentén) szükséges, amint az az ábrán látható, folyamatosan módosítani kell a hajó irányát: az S 42 °, 50 " irányból induljon, és az N pályával fejezze be. 53°. 50" (ebben az esetben a legrövidebb út nem is kivitelezhető - az Antarktisz jégfalán nyugszik).

    Mindkét út - a "loxodrom" és az "ortodromia" mentén - csak akkor esik egybe, ha a nagy kör mentén haladó útvonalat a tengeri térkép 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.

    (Ábrázoló geometria)
  • CD (CXDX, C2D2) pontként jelenik meg 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ű arra a problémára redukálni, hogy meghatározzuk a két sík távolságát, 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 szeretnénk meghatározni a legrövidebb távolságot, 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 jelenik meg 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 két egyenest kell rajta húzni, párhuzamosan az adott ferde egyenesekkel, és vetítési transzformációk segítségével meg kell határozni a kívánt szöget....
    (A leíró geometria alapjai. Rövid kurzus é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. Az utolsó 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)
  • 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 vitorlázunk, akkor a hajó röppályája a föld felszínén egy görbe lesz, amit a matematika hív. logaritmikusspirál.

    A navigációban ezt az összetett kettős görbületi vonalat ún loxodromia, 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 áthaladó sík gömbnek vett metszéspontjából kapjuk meg.

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

    A földfelszín két pontja közötti távolságok különbsége 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ó pályán végzik, pl. a loxodrom által.

    Az egyenlet levezetéséhez loxodrómiákat veszünk (30. ábra, a) két pont DEé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 szög PnAB megegyezik a K. Katet hajó irányával AC egy meridián ívszakaszt képvisel, és kifejezhető

    ahol 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 loxodróm 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áltozik - 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 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. A térképek készítéséhez használt kartográfiai vetületnek konformnak kell lennie, hogy a rajta lévő pályák, irányok é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ötti legrövidebb távolság gömbnek tekintve az ezeken a pontokon áthaladó nagykör ívei közül a kisebbik. A meridiánt vagy az egyenlítőt követő hajók kivételével a nagykö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. A gyakorlatban 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 vonal - 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 aki még több érdekes információt szeretne megtudni, tudjon 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… Usakov magyarázó szótára

    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. a…… 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. Két pont közötti legrövidebb távolság. 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 ága, amely a különféle formák (pontok, vonalak, szögek, két- és háromdimenziós tárgyak) 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ó- hajózási osztály (lásd), a hajó tengeri helyének meghatározásának módjainak bemutatása befejezése iránytű és napló segítségével (lásd). A hajó tengeri helyének meghatározása azt jelenti, hogy fel kell tüntetni a térképen azt a pontot, ahol a hajó jelenleg található. 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 legjelentősebb 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ényeges 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. p. 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 ideje kisebb, mint ... Nagy szovjet enciklopédia

    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ámait a körökben, "árukat" - az út hosszát - az élek felett jelzik. Minden csúcs mellett egy piros címke van jelö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 rá, 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, azaz 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 az 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 kezdi 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: 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úcsokról szóló információk 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 (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, Edge-ek halmazából felé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); ) ) /** Élek halmazából gráfot épít * / public Graph(Élek) ( grafikon = new 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 segítségével 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 az eredeti csomóponttól */ karakternév , 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; Az elérhetetlen csomópontok soha nem fognak bekerülni a sorba --- */ void calc_all(node_t *start) ( node_t *lead; edge_t *e; set_dist(start, start, 0); while ((lead = pop_queue())) for ( e = vezető->é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 *nodes = 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("end" => $é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 - Keressen 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 állítása önmagában.vertices dist = (vertex: inf for vertex in self.vertices ) previous = (csúcs: Nincs a self.vertices-ben 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: szünet 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"]

    Hasonló cikkek