Vet du varför det är längre i en rak linje än i en båge? Bestämma avståndet mellan två parallella linjer Vilket är det kortaste avståndet mellan två punkter

Banan längs den prickade linjen i bilden är kortare än banan längs den heldragna linjen. Och nu lite mer i detalj om exemplet med sjövägar:

Om du navigerar i en konstant kurs, då banan för fartygets rörelse längs jordens yta kommer att vara en kurva som kallas i matematik logaritmiskspiral.

I navigering kallas denna komplexa dubbla krökningslinje loxodromia, som på grekiska betyder "sned löpning".

Det kortaste avståndet mellan två punkter på jordklotet mäts dock längs en storcirkels båge.

En storcirkels båge erhålls som ett spår från skärningen av jordytan med ett plan som passerar genom jordens centrum, taget som en boll.

I navigering kallas storcirkelbågen stor cirkel, vilket betyder "rakt löpning". Den andra egenskapen hos storcirkeln är att den korsar meridianerna i olika vinklar (fig. 29).

Skillnaden i avstånd mellan två punkter på jordytan längs loxodromen och ortodromen är av praktisk betydelse endast för stora havskorsningar.

Under normala förhållanden försummas denna skillnad och navigering utförs på konstant kurs, d.v.s. av loxodrome.

För att härleda ekvationen tar vi loxodromier (fig. 30, a) två prickar OCH och PÅ, avståndet mellan dem är helt enkelt litet. Genom att rita meridianer och en parallell genom dem får vi en elementär rätvinklig sfärisk triangel ABC. I denna triangel är vinkeln som bildas av skärningspunkten mellan meridianen och parallellen rät, och vinkeln PnAB lika med skeppets kurs K. Katet AC representerar ett meridianbågsegment och kan uttryckas

var R - jordens radie tagen som en sfär;

Δφ - elementär ökning av latitud (skillnad mellan breddgrader).

ben SW representerar ett bågsegment parallellt

där r - parallellens radie;

Δλ - elementär skillnad i longituder.

Från triangel OO 1 C kan hittas det

Sedan i den slutliga formen benet SW kan uttryckas så här:

Antag en elementär sfärisk triangel ABC för lägenhet, skriv

Efter reduktion R och att ersätta elementära små steg av koordinater med infinitesimala, har vi

Vi integrerar det resulterande uttrycket i området från φ 1, λ 1 till φ 2, λ 2 betraktar värdet av tgK som ett konstant värde:

På höger sida har vi en tabellintegral. Efter att ha ersatt dess värde får vi loxodromekvationen på bollen

Analys av denna ekvation gör att vi kan dra följande slutsatser:

Vid kurser på 0 och 180 ° förvandlas loxodromen till en båge av en stor cirkel - en meridian;

Vid kurser på 90 och 270 ° sammanfaller loxodromen med parallellen;

Loxodromen korsar varje parallell bara en gång och varje meridian ett oräkneligt antal gånger. de där. spiral närmar sig stolpen, når den inte den.

Navigering i en konstant kurs, d.v.s. längs loxodromen, även om det inte är det kortaste avståndet mellan två punkter på jorden, representerar avsevärd bekvämlighet för navigatören.

Kraven för ett sjökort kan formuleras utifrån fördelen med navigering längs loxodromen och resultaten av analysen av dess ekvation enligt följande.

1. Loxodrome, som korsar meridianerna i en konstant vinkel, ska avbildas som en rät linje.

2. kartprojektion, som används för konstruktion av kartor, måste vara likvinkligt så att kurserna, bäringarna och vinklarna på den motsvarar deras värde på marken.

3. Meridianer och paralleller, som kurslinjerna 0, 90, 180° och 270°, måste vara inbördes vinkelräta räta linjer.

Det kortaste avståndet mellan två givna punkter på jordens yta, taget som en sfär, är det minsta av bågarna i en storcirkel som passerar genom dessa punkter. Förutom i fallet med ett fartyg som följer en meridian eller ekvatorn, korsar storcirkeln meridianerna i olika vinklar. Därför måste ett fartyg som följer en sådan kurva ändra sin kurs hela tiden. Det är praktiskt taget bekvämare att följa en kurs som gör en konstant vinkel med meridianerna och avbildas på kartan i Mercator-projektionen med en rak linje - loxodrome. Men på stora avstånd når skillnaden i längden på ortodromen och loxodromen ett betydande värde. Därför beräknas ortodromen i sådana fall och mellanliggande punkter markeras på den, mellan vilka de simmar längs loxodromen.

En kartografisk projektion som uppfyller ovanstående krav föreslogs av den holländska kartografen Gerard Cramer (Mercator) 1569. För att hedra sin skapare fick projektionen namnet Mercator.

Och som vill få ännu mer Intressant information lär dig mer Originalartikeln finns på hemsidan InfoGlaz.rf Länk till artikeln som denna kopia är gjord från -

AVSTÅND, avstånd, jfr. 1. Ett mellanrum som skiljer två punkter, ett mellanrum mellan något. Det kortaste avståndet mellan två punkter i en rät linje. Bor från oss på två kilometers avstånd. "Kommendanten släppte in dem på närmaste avstånd ... Lexikon Ushakov

distans- substantiv, s., bruk. ofta Morfologi: (nej) vad? avstånd till vad? avstånd, (se) vad? avstånd än? avstånd, vad? om avstånd; pl. Vad? avstånd, (nej) vad? avstånd, varför? avstånd, (se) vad? avstånd än? avstånd... Dmitrievs ordbok

distans- jag; jfr. Utrymmet som skiljer två punkter, två objekt, etc., gapet mellan någon, än l. Den kortaste floden mellan två punkter. R. från hemmet till skolan. Dra dig tillbaka till en närliggande flod. På en meters avstånd, armarna utsträckta. Vet något, känner något. på … … encyklopedisk ordbok

distans- jag; jfr. se även avstånd a) Mellanrummet som skiljer två punkter, två objekt, etc., gapet mellan någon, än l. Det kortaste avståndet mellan två punkter. Avstånd från hem till skola. Dra dig tillbaka på nära avstånd / inte ... Ordbok med många uttryck

GEOMETRI- en gren av matematiken som studerar egenskaperna hos olika former (punkter, linjer, vinklar, tvådimensionella och tredimensionella föremål), deras storlek och relativa position. För att underlätta undervisningen är geometri indelad i planimetri och solid geometri. AT … … Collier Encyclopedia

Navigering*

Navigering- Navigationsavdelningen (se), avslutar en presentation av sätt att bestämma platsen för ett fartyg till sjöss, med hjälp av en kompass och en logg (se). Att bestämma platsen för ett fartyg till sjöss innebär att sätta på kartan den punkt där fartyget befinner sig det här ögonblicket belägen.… … Encyclopedic Dictionary F.A. Brockhaus och I.A. Efron

COGEN- (Cohen) Hermann (1842 1918) tysk filosof, grundare och mest framstående representant för Marburg-skolan för nykantianism. Större verk: 'Kants teori om erfarenhet' (1885), 'Kants rättfärdigande av etiken' (1877), 'Kants rättfärdigande av estetik' (1889), 'Logik... ...

Kant Immanuel- Kants livsväg och skrifter Immanuel Kant föddes i Königsberg (numera Kaliningrad) i Ostpreussen 1724. Hans far var sadelmakare och hans mor var hemmafru, sex av deras barn levde inte till vuxen ålder. Kant mindes alltid sina föräldrar med ... ... Västerländsk filosofi från dess ursprung till våra dagar

KANTS KRITISKA FILOSOFI: Läran om förmågor- (La philosophie critique de Kant: Doctrines des facultes, 1963) av Deleuze. Deleuze beskriver den transcendentala metoden i inledningen och noterar att Kant förstår filosofi som vetenskapen om relationen mellan all kunskap och väsentliga mål... ... Filosofiens historia: Encyclopedia

gårdsprincipen- den grundläggande principen för geometrisk optik (Se Geometrisk optik). Den enklaste formen av F. p. är påståendet att en ljusstråle alltid fortplantar sig i rymden mellan två punkter längs vägen längs vilken tiden för dess passage är mindre än ... Stor sovjetisk uppslagsverk

(Beskrivande geometri)
  • CD (CXDX, C2D2) visas som en prick C5 = D5 A5B5 lika...
    (Beskrivande geometri)
  • Bestämma avståndet mellan två parallella plan
    Bestämning av avståndet mellan två parallella plan i allmänt läge 01| X det är bekvämt att reducera det till problemet med att bestämma avståndet mellan samma två plan, omvandlat till läget för de utskjutande. I detta fall definieras avståndet mellan planen som vinkelrät mellan linjerna, ...
    (Beskrivande geometri)
  • Bestämma avståndet mellan två korsande linjer
    Om du vill bestämma det kortaste avståndet mellan två korsande linjer måste du byta system för projektionsplan två gånger. När man löser detta problem, den direkta CD (CXDX, C2D2) visas som en prick C5 = D5(Fig. 198). Avstånd från denna punkt till projektionen A5B5 lika...
    (Beskrivande geometri)
  • Vinkel mellan två korsande räta linjer
    Detta är vinkeln mellan två skärande linjer som är parallella med data. Således liknar denna uppgift den föregående. För att lösa det måste du ta en godtycklig punkt och dra två linjer genom den parallellt med de givna snedställda linjerna och använda projektionstransformationen för att bestämma den önskade vinkeln....
    (Grundläggande för beskrivande geometri. Kort kurs och en samling uppgifter.)
  • Bestämma avståndet mellan två parallella linjer
    Problemet löses genom metoden för dubbel ersättning av projektionsplan. I slutskedet måste ett av projektionsplanen vara vinkelrät mot en av de skärande linjerna. Då bestäms det kortaste avståndet mellan dem av värdet på segmentet av vinkelrät mot den andra snedställningslinjen (Fig. 199)....
    (Beskrivande geometri)
  • Efter att ha skisserat två punkter på tavlan med krita, erbjuder läraren den unga eleven en uppgift: att rita den kortaste vägen mellan båda punkterna.

    Eleven, efter att ha tänkt, drar flitigt en slingrande linje mellan dem.

    – Det är den kortaste vägen! läraren är förvånad. - Vem lärde dig det?

    - Min pappa. Han är taxichaufför.

    Teckningen av en naiv skolpojke är förstås anekdotisk, men skulle du inte le om du fick veta att den prickade bågen i fig. 1 är den kortaste vägen från Godahoppsudden till Australiens södra spets!

    Ännu mer slående är följande uttalande: avbildat i fig. 2 tur och retur från Japan till Panamakanalen är kortare än den raka linjen som dras mellan dem på samma karta!

    Ris. 1. På sjökarta den kortaste vägen från Godahoppsudden till Australiens södra spets indikeras inte av en rak linje ("loxodrome"), utan av en kurva ("ortodromi")


    Allt detta ser ut som ett skämt, men under tiden innan du är obestridliga sanningar, välkända för kartografer.




    Ris. 2. Det verkar otroligt att den krökta vägen som förbinder Yokohama på sjökortet med Panamakanalen är kortare än en rak linje som dras mellan samma punkter


    För att klargöra frågan måste några ord sägas om sjökort i allmänhet och om sjökort i synnerhet. Att rita delar av jordens yta på papper är inte en lätt uppgift, inte ens i princip, eftersom jorden är en sfär, och det är känt att ingen del av den sfäriska ytan kan placeras ut på ett plan utan veck och brott. Ofrivilligt får man stå ut med de oundvikliga förvrängningarna på kartorna. Många sätt att rita kartor har uppfunnits, men alla kartor är inte fria från brister: vissa har förvrängningar av ett slag, andra av ett annat slag, men det finns inga kartor utan förvrängningar alls.

    Sjömän använder kartor ritade enligt metoden av en gammal holländsk kartograf och matematiker från 1500-talet. Mercator. Denna metod kallas Mercator-projektion. Det är lätt att känna igen ett sjökort på dess rektangulära rutnät: meridianerna visas på det som en serie parallella räta linjer; latitudcirklar - också i raka linjer vinkelräta mot den första (se fig. 5).

    Föreställ dig nu att du vill hitta den kortaste vägen från en havshamn till en annan på samma parallell. På havet finns alla stigar tillgängliga och det går alltid att åka dit längs den kortaste vägen om man vet hur den ligger. I vårt fall är det naturligt att tro att den kortaste vägen går längs den parallell som båda hamnarna ligger på: trots allt är det på kartan en rak linje, och vad kan vara kortare än en rak väg! Men vi har fel: vägen längs parallellen är inte alls den kortaste.

    Faktum är att på ytan av en sfär är det kortaste avståndet mellan två punkter den stora cirkelbågen som förbinder dem. Men cirkeln av parallell små en cirkel. En stor cirkels båge är mindre krökt än bågen för en liten cirkel som dras genom samma två punkter: en större radie motsvarar en mindre krökning. Dra tråden på jordklotet mellan våra två punkter (jfr fig. 3); du kommer att se till att den inte ligger längs parallellen alls. En stram tråd - en obestridd pekare den kortaste vägen, och om den inte sammanfaller med parallellen på jordklotet, så är den kortaste vägen på sjökortet inte indikerad med en rät linje: kom ihåg att cirklarna av paralleller är avbildade på en sådan karta med räta linjer, vilken linje som helst som gör det inte sammanfaller med en rak linje är kurva .



    Ris. 3. Ett enkelt sätt att hitta den riktigt kortaste vägen mellan två punkter: du måste dra en tråd på jordklotet mellan dessa punkter


    Efter det som sagts blir det tydligt varför den kortaste vägen på sjökortet inte är avbildad som en rak linje, utan som en krökt linje.

    De säger att när man väljer en riktning för Nikolaevskaya (nu Oktyabrskaya) järnväg det fanns ändlösa dispyter om hur man skulle lägga den. Tvisterna fick ett slut genom ingripande av tsar Nicholas I, som löste problemet bokstavligen "enkelt": han förband St. Petersburg med Moskva längs linjen. Om detta hade gjorts på en Mercator-karta hade det varit en pinsam överraskning: istället för en rak linje hade vägen visat sig vara en kurva.

    Den som inte undviker beräkningar kan genom en enkel beräkning övertygas om att den väg som vi ser krökt på kartan faktiskt är kortare än den som vi är redo att betrakta som rak. Låt våra två hamnar ligga på 60:e breddgraden och vara åtskilda med ett avstånd på 60°. (Om sådana två hamnar faktiskt existerar är naturligtvis oväsentligt för beräkningen.)



    Ris. 4. Till beräkningen av avstånden mellan punkterna A och B på kulan längs parallellbågen och längs storcirkelns båge


    På fig. 4 poäng O - Centrum Globen, AB - bågen av latitudcirkeln som hamnar ligger på A och B; i hennes 60°. Mitten av latitudcirkeln är vid en punkt Med Föreställ dig det från mitten O av jordklotet dras genom samma hamnar en stor cirkelbåge: dess radie OB = OA = R; den kommer att passera nära den ritade bågen AB, men det stämmer inte.

    Låt oss beräkna längden på varje båge. Eftersom poängen OCH och ligga på en latitud av 60°, sedan radierna OA och OV göra upp med OS(globens axel) en vinkel på 30°. I en rätvinklig triangel ASO ben AC (=r), att ligga mitt emot en vinkel på 30° är lika med halva hypotenusan JSC;

    innebär att, r=R/2 Båglängd ABär en sjättedel av längden på latitudcirkeln, och eftersom denna cirkel har halva längden av den stora cirkeln (motsvarande halva radien), så är längden på den lilla cirkelns båge



    För att nu bestämma längden på bågen av en storcirkel som ritas mellan samma punkter (dvs. den kortaste vägen mellan dem), måste vi veta storleken på vinkeln AOW. Ackord SOM, subtrahera bågen till 60 ° (liten cirkel), är sidan av en vanlig hexagon inskriven i samma lilla cirkel; det är därför AB \u003d r \u003d R / 2

    Rita en rak linje od, anslutande centrum O jordklotet med mitten D ackord AB, få en rätvinklig triangel ODA, var är vinkeln D- hetero:

    DA=1/2 AB och OA=R.

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

    Härifrån finner vi (enligt tabellerna):

    =14°28",5

    och följaktligen

    = 28°57".

    Nu är det inte svårt att hitta önskad längd på den kortaste vägen i kilometer. Beräkningen kan förenklas om vi kommer ihåg att längden på en minut av en storcirkel av jordklotet är

    Vi lär oss att vägen längs latitudcirkeln, visad på sjökortet med en rät linje, är 3333 km, och stigen längs den stora cirkeln - längs kurvan på kartan - 3213 km, dvs 120 km kortare.

    Beväpnad med en tråd och med en jordglob till hands kan du enkelt kontrollera riktigheten av våra ritningar och se till att de stora cirklarnas bågar verkligen ligger som visas i ritningarna. Visat i fig. 1 som om den "raka" sjövägen från Afrika till Australien är 6020 miles, och "kurvan" - 5450 miles, dvs kortare med 570 miles, eller 1050 km. Den "direkta" flygvägen på sjökortet från London till Shanghai skär genom Kaspiska havet, medan den riktigt kortaste vägen ligger norr om St. Petersburg. Det är tydligt vilken roll dessa frågor spelar för att spara tid och bränsle.

    Om sjöfartstiden inte alltid värderades under seglingstiden - då ansågs "tid" ännu inte som "pengar", då med tillkomsten av ångfartyg måste man betala för varje extra ton kol som konsumeras. Det är därför som idag fartyg navigerar den riktigt kortaste vägen, ofta med hjälp av kartor gjorda inte i Mercator, utan i den så kallade "centrala" projektionen: på dessa kartor är bågarna av stora cirklar avbildade som raka linjer.

    Varför använde då tidigare navigatörer sådana bedrägliga kartor och valde ogynnsamma vägar? Det är ett misstag att tro att man förr i tiden inte kände till den nu angivna egenskapen hos sjökort. Saken förklaras naturligtvis inte av detta, utan av att sjökort ritade enligt Mercatormetoden, tillsammans med olägenheter, har mycket värdefulla fördelar för sjömän. En sådan karta visar för det första separata små delar av jordens yta utan förvrängning, vilket bevarar konturens hörn. Detta motsägs inte av det faktum att med avstånd från ekvatorn är alla konturer märkbart sträckta. På höga breddgrader är sträckan så betydande att ett sjökort inspirerar en person som inte är bekant med dess egenskaper med en helt falsk uppfattning om kontinenternas verkliga storlek: Grönland verkar vara lika stor som Afrika, Alaska är större än Australien, även om Grönland är 15 gånger mindre än Afrika, och Alaska tillsammans med Grönland hälften så stort som Australien. Men en sjöman som är väl förtrogen med dessa egenskaper hos sjökortet kan inte vilseledas av dem. Han står ut med dem, särskilt eftersom ett sjökort inom små områden ger en exakt likhet med naturen (fig. 5).

    Å andra sidan underlättar sjökortet i hög grad lösningen av navigationsövningens uppgifter. Detta är den enda sortens sjökort där ett fartygs väg på en konstant kurs visas som en rak linje. Att följa en "konstant kurs" betyder att alltid hålla en riktning, en bestämd "rumb", med andra ord, att gå på ett sådant sätt att man korsar alla meridianerna i en lika stor vinkel. Men denna väg ("loxodrome") kan avbildas som en rak linje endast på en karta där alla meridianer är raka linjer parallella med varandra. Och eftersom latitudcirklarna på jordklotet korsar meridianerna i räta vinklar, så borde latitudcirklarna på en sådan karta vara raka linjer vinkelräta mot meridianernas linjer. Kort sagt, vi kommer precis fram till det koordinatnät som utgör ett karakteristiskt drag för sjökortet.




    Ris. 5. Nautisk eller Mercator karta över jordklotet. På sådana kartor är dimensionerna av konturer långt från ekvatorn kraftigt överdrivna. Vilket är till exempel större: Grönland eller Australien? (svar i text)


    Sjömäns förkärlek för Mercator-kartor är nu förståelig. För att bestämma kursen som ska följas när han går till den utsedda hamnen, applicerar navigatören en linjal på banans ändpunkter och mäter vinkeln den gör med meridianerna. Genom att hålla sig på öppet hav hela tiden i den här riktningen kommer navigatören att exakt föra skeppet till målet. Du ser att "loxodromen" är, om än inte den kortaste och inte den mest ekonomiska, men i ett visst avseende ett mycket bekvämt sätt för en sjöman. För att till exempel nå från Godahoppsudden till Australiens södra spets (se fig. 1) måste man alltid hålla samma kurs S 87 °.50". Under tiden för att föra fartyget till samma sista punkten den kortaste vägen(enligt "ortodromin") är det nödvändigt, som framgår av figuren, att kontinuerligt ändra fartygets kurs: börja från kursen S 42 °, 50 "och avsluta med kursen N 53 °, 50 " (i det här fallet är den kortaste vägen inte ens möjlig - den vilar in i den antarktiska isväggen).

    Båda vägarna - längs "loxodromen" och längs "ortodromin" - sammanfaller endast när vägen längs den stora cirkeln är avbildad på sjökortet som en rak linje: när man rör sig längs ekvatorn eller längs meridianen. I alla andra fall är dessa vägar olika.

    Dijkstras algoritm är en grafalgoritm som uppfanns av den holländska forskaren Edsger Dijkstra 1959. Hittar de kortaste vägarna från en av grafens hörn till alla andra. Algoritmen fungerar endast för grafer utan kanter med negativ vikt.

    Betrakta exekveringen av algoritmen i exemplet på grafen som visas i figuren.

    Låt det krävas att hitta de kortaste avstånden från 1:a vertex till alla andra.

    Cirklarna indikerar hörn, linjerna indikerar banorna mellan dem (grafens kanter). Numren på hörnen anges i cirklarna, deras "pris" - banans längd - anges ovanför kanterna. Bredvid varje vertex är en röd etikett markerad - längden på den kortaste vägen till denna vertex från vertex 1.

    Första steget. Betrakta ett steg i Dijkstras algoritm för vårt exempel. Vertex 1 har minimietiketten. Vertices 2, 3 och 6 är dess grannar.

    Den första granne till vertex 1 är i sin tur vertex 2, eftersom längden på vägen dit är minimal. Längden på vägen till den genom vertex 1 är lika med summan av värdet på etiketten för vertex 1 och längden på kanten som går från 1:a till 2:a, det vill säga 0 + 7 = 7. Detta är mindre än nuvarande etikett för vertex 2, infinity, så den nya etiketten för 2:a vertex är 7.

    Vi utför en liknande operation med två andra grannar till den 1: a vertexen - den 3: e och 6: e.

    Alla grannar till nod 1 är kontrollerade. Det nuvarande minimiavståndet till topp 1 anses vara slutgiltigt och är inte föremål för revidering (det faktum att så verkligen är fallet bevisades först av E. Dijkstra). Kryssa över det i grafen för att markera att denna vertex har besökts.

    Andra steg. Algoritmsteget upprepas. Återigen hittar vi det "närmaste" av de obesökta hörnen. Detta är vertex 2 märkt 7.

    Återigen försöker vi minska beteckningarna för grannarna till den valda vertexen, och försöker passera genom dem genom den 2: a vertexen. Vertex 2:s grannar är hörn 1, 3 och 4.

    Den första (i ordning) granne till vertex 2 är vertex 1. Men den har redan besökts, så vi gör ingenting med den 1: a vertexen.

    Nästa granne till vertex 2 är vertex 3, eftersom den har minimietiketten för de hörn som är markerade som obesökta. Om du går till den genom 2, kommer längden på en sådan väg att vara lika med 17 (7 + 10 = 17). Men den nuvarande etiketten för den tredje vertexen är 9, vilket är mindre än 17, så etiketten ändras inte.

    En annan granne till vertex 2 är vertex 4. Om du går till det genom den 2: a, så kommer längden på en sådan väg att vara lika med summan av det kortaste avståndet till 2: a vertex och avståndet mellan vertex 2 och 4, det vill säga , 22 (7 + 15 = 22). Sedan 22<, устанавливаем метку вершины 4 равной 22.

    Alla grannar till vertex 2 har setts, vi fryser avståndet till det och markerar det som besökt.

    Tredje steget. Vi upprepar steget i algoritmen genom att välja vertex 3. Efter dess "bearbetning" får vi följande resultat:

    Nästa steg. Vi upprepar steget i algoritmen för de återstående hörnen. Dessa kommer att vara hörn 6, 4 respektive 5.

    Slutförande av algoritmexekveringen. Algoritmen avslutas när inga fler hörn kan bearbetas. I det här exemplet är alla hörn överstrukna, men det är ett misstag att anta att så kommer att vara fallet i vilket exempel som helst - vissa hörn kan förbli oöverkorsade om de inte kan nås, d.v.s. om grafen kopplas bort. Resultatet av algoritmen är synligt i den sista figuren: den kortaste vägen från vertex 1 till 2 är 7, till 3 är 9, till 4 är 20, till 5 är 20, till 6 är 11.

    Implementering av algoritmen i olika programmeringsspråk:

    C++

    #inkludera "stdafx.h" #inkludera använder namnutrymme std; const int V=6; // Dijkstras algoritm void Dijkstra(int GR[V][V], int st) ( int avstånd[V], count, index, i, u, m=st+1; bool besökt[V]; för (i= 0 i "< "<> "; cin>>start; Dijkstra(GR, start-1); system("paus>>void"); )

    Pascal

    program DijkstraAlgorithm; usescrt; constV=6; inf=100000; typ vektor=array av heltal; var start: heltal; const GR: matris av heltal=((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)); (Dijkstras algoritm) procedur Dijkstra(GR: matris av heltal; st: heltal); var count, index, i, u, m, min: heltal; avstånd: vektor; besökt: rad booleska; beginm:=st; för i:=1 till V börjar avstånd[i]:=inf; besökt[i]:=falskt; slutet; avstånd:=0; för count:=1 till V-1 börjar min:=inf; för i:=1 till V gör if (ej besökt[i]) och (avstånd[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) och (avstånd[u]<>inf) och (avstånd[u]+GR inf sedan writeln(m," > ", i," = ", avstånd[i]) annars writeln(m," > ", i," = ", "rutt otillgänglig"); slutet; (huvudprogramblock) börja clrscr; write("Startnod >> "); read(start); Dijkstra(GR, start); slutet.

    Java

    importera java.io.BufferedReader; importera java.io.IOException; importera java.io.InputStreamReader; importera java.io.PrintWriter; importera java.util.ArrayList; importera java.util.Arrays; importera java.util.StringTokenizer; public class Lösning ( privat statisk int INF = Integer.MAX_VALUE / 2; privat int n; //antal hörn i digraf privat int m; //antal bågar i digraf privat ArrayList adj; //adjacency list privat ArrayList vikt; //kantens vikt i digraph privat boolean används; //array för att lagra information om godkända och ej godkända toppar privat int dist; //array för att lagra avståndet från startpunkten //en array av förfäder som behövs för att återställa den kortaste vägen från startpunkten privat int pred; int start; //startpunkt, från vilken avståndet till alla andra söks privat BufferedReader cin; privat PrintWriter cout; privat StringTokenizer tokenizer; //procedur för att starta Dijkstras algoritm från startpunkten privat void dejkstra(int s) ( dist[s] = 0; //det kortaste avståndet till startpunkten är 0 för (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(); ) //initiering av listan som lagrar vikten av kanternas vikt = new ArrayList[n]; för (int i = 0; i< n; ++i) { weight[i] = new ArrayList(); ) //läs grafen som ges av listan över kanter för (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(); } }

    Ett annat alternativ:

    Importera java.io.*; importera java.util.*; public class Dijkstra ( privat statisk slutgiltig 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), ); privat statisk slutsträng START = "a"; privat statisk slutsträng END = "e"; public static void main(String args) ( Graph g = new Graph(GRAPH); g.dijkstra (START); g.printPath(END); //g.printAllPaths(); ) ) class Graph ( privat slutlig karta Graf; // mappning av vertexnamn till vertexobjekt, byggda från en uppsättning kanter /** En kant av grafen (används endast av Graph constructor) */ 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; ) ) /** En vertex av grafen, komplett med mappningar till angränsande hörn */ offentlig statisk klass Vertex-redskap Jämförbara (public final String name; public int dist = Integer.MAX_VALUE; // MAX_VALUE antas vara oändligt offentlig Vertex föregående = null; offentlig final Map grannar = nya HashMap<>(); public Vertex(String name) ( this.name = name; ) 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 compareTo(Vertex other) ( return Integer.compare(dist, other.dist); ) ) /** Bygger en graf från en uppsättning kanter * / public Graph(Edge edges) ( graph = new HashMap<>(kanter.längd); //ett pass för att hitta alla hörn för (Edge e: edges) ( if (!graph.containsKey(e.v1)) graph.put(e.v1, new Vertex(e.v1)); if (!graph. containsKey(e.v2)) graph.put(e.v2, new Vertex(e.v2)); ) //ett pass för att ställa in angränsande hörn för (Edge e: edges) ( graph.get(e.v1). neighbours.put(graph.get(e.v2), e.dist); //graph.get(e.v2).neighbours.put(graph.get(e.v1), e.dist); // also gör detta för en oriktad graf ) ) /** Kör dijkstra med en angiven källpunkt */ public void dijkstra(String startName) ( if (!graph.containsKey(startName)) ( System.err.printf("Graph does not innehåller startpunkt \"%s\"\n", startName); return; ) final Vertex source = graph.get(startName); NavigableSet q = nytt träduppsättning<>(); // ställ in hörn för (Vertex v: graph.values()) ( v.previous = v == källa ? källa: null; v.dist = v == källa ? 0: Integer.MAX_VALUE; q.add( v);) dijkstra(q); ) /** Implementering av dijkstras algoritm med hjälp av en binär hög. */ private void dijkstra(final NavigableSet q) ( Vertex u, v; while (!q.isEmpty()) ( u = q.pollFirst(); // vertex med kortast avstånd (första iterationen returnerar källan) if (u.dist == Integer.MAX_VALUE) bryta; // vi kan ignorera u (och alla andra återstående hörn) eftersom de är oåtkomliga //se på avstånd till varje granne efter (Map.Entry a: u.neighbours.entrySet()) ( v = a.getKey(); //grannen i denna iteration 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

    #omfatta #omfatta #omfatta //#define BIG_EXAMPLE typedef struct node_t node_t, *heap_t; typedef struct edge_t edge_t; struct edge_t ( node_t *nd; /* mål för denna kant */ edge_t *syskon;/* för enkellänkad lista */ int len; /* edge cost */ ); struct node_t ( edge_t *edge; /* enkellänkad lista med kanter */ node_t *via; /* där föregående nod är i kortaste vägen */ dubbel dist; /* avstånd från ursprungsnoden */ char name; /* the, er , namn */ int heap_idx; /* länk till högposition för uppdatering av avstånd */ ); /* --- kanthantering --- */ #ifdef BIG_EXAMPLE # define BLOCK_SIZE (1024 * 32 - 1) #else # define BLOCK_SIZE 15 #endif edge_t *edge_root = 0, *e_next = 0; /* Bry dig inte om minneshanteringsgrejer, de är mer än poängen. Låtsas e_next = malloc(sizeof(edge_t)) */ void add_edge(node_t *a, node_t *b, double d) ( if (e_next == edge_root) ) ( edge_root = malloc(sizeof(edge_t) * (BLOCK_SIZE + 1)); edge_root.sibling = e_next; e_next = edge_root + BLOCK_SIZE; ) --e_next; e_next->nd = b; e_next d->lenn =_next->lenn ->syskon = a->edge; a->edge = e_next; ) void free_edges() ( för (; edge_root; edge_root = e_next) ( e_next = edge_root.sibling; free(edge_root); ) ) /* --- prioriterade kösaker --- */ heap_t *heap; int heap_len; void set_dist(node_t *nd, node_t *via, double d) ( int i, j; /* visste redan bättre väg */ if (nd->via && d >= nd->dist) return; /* hitta befintlig heap-post, eller skapa en ny */ nd->dist = d; nd->via = via; i = nd->heap_idx; if (!i) i = ++heap_len; /* upheap */ för (; i > 1 && nd->dist< heap->dist; i = j) (hög[i] = hög[j])->hög_idx = i; heap[i] = nd; nd->heap_idx = i; ) node_t * pop_queue() ( node_t *nd, *tmp; int i, j; if (!heap_len) returnera 0; /* ta bort inledande element, dra svanselementet dit och nerhög */ nd = hög; tmp = hög; för (i = 1; i< heap_len && (j = i * 2) <= heap_len; i = j) { if (j < heap_len && heap[j]->dist > heap->dist) j++; om (hög[j]->avstånd >= tmp->avstånd) bryta; (hög[i] = hög[j])->hög_idx = i; ) heap[i] = tmp; tmp->heap_idx = i; returnera nd; ) /* --- Dijkstra grejer; oåtkomliga noder kommer aldrig att göra in i kö --- */ void calc_all(node_t *start) ( node_t *lead; edge_t *e; set_dist(start, start, 0); while ((lead = pop_queue())) for (e = lead->edge; e; e = e->syskon) 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->namn, nd->dist); ) ) int main(void) ( #ifndef BIG_EXAMPLE int i; # define N_NODES ("f" - "a" + 1) node_t * noder = calloc(sizeof(nod_t), N_NODES); för (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

    $edge, "cost" => $edge); $neighbours[$edge] = array("end" => $edge, "cost" => $edge); ) $vertices = array_unique($vertices); foreach ($vertex som $vertex) ( $dist[$vertex] = INF; $previous[$vertex] = NULL; ) $dist[$source] = 0; $Q = $vertices; while (count($Q) > 0) ( // TODO - Hitta ett snabbare sätt att få minimum $min = INF; foreach ($Q som $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";


    Pytonorm

    från samlingar import namedtuple, kö från pprint importera pprint som pp inf = float("inf") Edge = namedtuple("Edge", "start, end, cost") class Graph(): def __init__(self, edges): self .edges = edges2 = self.vertices = set(sum((för e i edges2), )) def dijkstra(self, source, dest): hävda källa i self.vertices dist = (vertex: inf för vertex i self.vertices ) föregående = (vertex: Inget för vertex i self.vertices) dist = 0 q = self.vertices.copy() grannar = (vertex: set() för vertex i self.vertices) för start, slut, kostnad i self. edges: neighbors.add((end, cost)) #pp(neighbours) medan q: u = min(q, nyckel=lambda vertex: dist) q.remove(u) if dist[u] == inf eller u = = dest: paus för v, kostnad i grannar[u]: alt = dist[u] + kostnad om 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"]