• Lyhin etäisyys kahden pisteen välillä. Tiedätkö, miksi se on pidemmällä suorassa kuin kaaressa? Kahden leikkaavan suoran välisen etäisyyden määrittäminen

    01.02.2022

    Piirrettyään kaksi pistettä taululle liidulla, opettaja tarjoaa nuorelle opiskelijalle tehtävän: piirtää lyhin polku molempien pisteiden välille.

    Opiskelija vetää ahkerasti ajateltuaan mutkaisen rajan heidän välilleen.

    - Se on lyhin tie! opettaja ihmettelee. - Kuka opetti sinulle sen?

    - Isäni. Hän on taksinkuljettaja.

    Piirustus naiivista koulupojasta on tietysti anekdootti, mutta eikö hymyilyttäisikään, jos sinulle kerrottaisiin, että kuvassa oleva pistekaari. 1 on lyhin tie Hyväntoivon niemeltä Australian eteläkärkeen!

    Vielä silmiinpistävämpi on seuraava lausunto: kuvattu kuvassa. 2 edestakaista matkaa Japanista Panaman kanavalle on lyhyempi kuin niiden väliin piirretty suora viiva samalle kartalle!

    Riisi. 1. Merikartassa lyhyintä reittiä Hyväntoivon niemeltä Australian eteläkärkeen ei ole osoitettu suoralla viivalla ("loxodrome"), vaan kaarella ("ortodromia").


    Kaikki tämä näyttää vitsiltä, ​​mutta sillä välin edessäsi ovat kiistattomat totuudet, jotka kartografit tuntevat hyvin.




    Riisi. 2. Vaikuttaa uskomattomalta, että kaareva polku, joka yhdistää merikartan Yokohaman Panaman kanavaan, on lyhyempi kuin samojen pisteiden väliin vedetty suora viiva


    Asian selventämiseksi on sanottava muutama sana kartoista yleensä ja merikartoista erityisesti. Maan pinnan osien piirtäminen paperille ei ole helppoa edes periaatteessa, koska maapallo on pallo, ja tiedetään, ettei mitään pallomaisen pinnan osaa voida levittää tasolle ilman taitoksia ja katkoja. Tahdottomasti täytyy sietää karttojen väistämättömiä vääristymiä. Karttojen piirtämiseen on keksitty monia tapoja, mutta kaikki kartat eivät ole vapaita puutteista: joissakin on yhdenlaisia ​​vääristymiä, toisissa erilaisia, mutta vääristymättömiä karttoja ei ole ollenkaan.

    Merimiehet käyttävät karttoja, jotka on piirretty vanhan 1500-luvun hollantilaisen kartografin ja matemaatikon menetelmällä. Mercator. Tätä menetelmää kutsutaan Mercator-projektioksi. Merikartan tunnistaminen on helppoa suorakaiteen muotoisesta ruudukosta: meridiaanit näkyvät siinä sarjana yhdensuuntaisia ​​suoria viivoja; leveyspiirit - myös suorina, jotka ovat kohtisuorassa ensimmäiseen nähden (katso kuva 5).

    Kuvittele nyt, että haluat löytää lyhimmän reitin yhdestä valtamerisatamasta toiseen samalla rinnalla. Merellä kaikki polut ovat käytettävissä, ja sinne on aina mahdollista matkustaa lyhintä polkua pitkin, jos tietää kuinka se sijaitsee. Meidän tapauksessamme on luonnollista ajatella, että lyhin polku kulkee sitä rinnakkaisuutta, jolla molemmat portit sijaitsevat: kartalla se on loppujen lopuksi suora, ja mikä voi olla lyhyempi kuin suora! Mutta olemme väärässä: polku yhdensuuntaisuutta pitkin ei ole ollenkaan lyhin.

    Todellakin: pallon pinnalla lyhin etäisyys kahden pisteen välillä on niitä yhdistävän suurympyrän kaari. Mutta rinnakkaisuuden ympyrä pieni ympyrä. Suuren ympyrän kaari on vähemmän kaareva kuin minkä tahansa pienen ympyrän kaari, joka on vedetty samojen kahden pisteen läpi: suurempi säde vastaa pienempää kaarevuutta. Vedä maapallon lanka kahden pisteemme väliin (ks. kuva 3); varmistat, että se ei ole lainkaan rinnakkain. Venytetty lanka on kiistaton lyhimmän reitin indikaattori, ja jos se ei ole sama kuin maapallon yhdensuuntaisuus, merikartassa lyhintä polkua ei osoita suoralla viivalla: muista, että yhdensuuntaisuuden ympyrät on kuvattu sellaisilla. kartta suorilla viivoilla, mikä tahansa viiva, joka ei ole sama kuin suora, on olemassa käyrä .



    Riisi. 3. Yksinkertainen tapa löytää todella lyhin reitti kahden pisteen välillä: sinun on vedettävä lanka maapallolla näiden pisteiden väliin


    Sanon jälkeen käy selväksi, miksi merikartan lyhin reitti ei ole kuvattu suorana, vaan kaarevana viivana.

    He sanovat, että Nikolaevin (nykyään Oktyabrskaya) rautatien suunnan valinnassa käytiin loputtomia kiistoja siitä, mihin suuntaan se asetetaan. Kiistat ratkesi tsaari Nikolai I:n väliintulolla, joka ratkaisi ongelman kirjaimellisesti "suoraan": hän yhdisti Pietarin Moskovaan. Jos tämä olisi tehty Mercator-kartalla, se olisi ollut kiusallinen yllätys: suoran sijaan tie olisi osoittautunut mutkaksi.

    Jokainen, joka ei välttele laskelmia, voi yksinkertaisella laskelmalla vakuuttua siitä, että meille kartalla kaareva polku on itse asiassa lyhyempi kuin se, jota olemme valmiita pitämään suorana. Olkoon kaksi satamaamme 60. leveydellä ja erotettu toisistaan ​​60°:n etäisyydellä. (Sillä, onko tällaisia ​​kahta satamaa todella olemassa, ei tietenkään ole merkitystä laskennan kannalta.)



    Riisi. 4. Pallon pisteiden A ja B välisten etäisyyksien laskemiseen yhdensuuntaisuuden kaarella ja suuren ympyrän kaarella


    Kuvassa 4 pistettä O - maapallon keskipiste, AB - leveyspiirin kaari, jolla satamat sijaitsevat A ja B; sisään hänen 60°. Leveyspiirin keskipiste on pisteessä FROM Kuvittele se keskustasta O maapallosta piirretään samojen satamien läpi suuri ympyräkaari: sen säde OB = OA = R; se kulkee lähellä piirrettyä kaaria AB, mutta se ei vastaa.

    Lasketaan jokaisen kaaren pituus. Pisteiden jälkeen MUTTA ja AT sijaitsevat leveysasteella 60°, sitten säteet OA ja OV sovita OS(maapallon akseli) 30° kulmassa. Suorakulmaisessa kolmiossa ASO jalka AC (=r), 30°:n kulman vastapäätä on puolet hypotenuusasta JSC;

    tarkoittaa, r = R/2 Kaaren pituus AB on kuudesosa leveyspiirin pituudesta, ja koska tällä ympyrällä on puolet suuren ympyrän pituudesta (vastaa puolta säteestä), niin pienen ympyrän kaaren pituus



    Jotta voisimme nyt määrittää samojen pisteiden väliin piirretyn suurympyrän kaaren pituuden (eli lyhimmän polun niiden välillä), meidän on tiedettävä kulman suuruus AOW. Sointu KUTEN, kun kaari vähennetään 60 °:een (pieni ympyrä), on säännöllisen kuusikulmion sivu, joka on piirretty samaan pieneen ympyrään; siksi AB \u003d r \u003d R / 2

    Suoran viivan piirtäminen od, yhdistävä keskus O maapallo keskellä D sointuja AB, hanki suorakulmainen kolmio ODA, missä on kulma D- suoraan:

    DA = 1/2 AB ja OA = R.

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

    Täältä löydämme (taulukoiden mukaan):

    =14°28",5

    ja siten

    = 28°57".

    Nyt ei ole vaikea löytää haluttua lyhimmän polun pituutta kilometreissä. Laskua voidaan yksinkertaistaa, jos muistamme, että maapallon suuren ympyrän minuutin pituus on

    Saamme tietää, että merikartassa suoralla viivalla näkyvä leveyspiirin polku on 3333 km ja polku suurella ympyrällä - kartan kaarretta pitkin - 3213 km, eli 120 km lyhyempi.

    Langalla ja maapallolla aseistettuna voit helposti tarkistaa piirustojemme oikeellisuuden ja varmistaa, että suurten ympyröiden kaaret todella ovat piirustusten osoittamalla tavalla. Näkyy kuvassa 1 ikään kuin "suora" merireitti Afrikasta Australiaan on 6020 mailia ja "käyrä" - 5450 mailia, eli 570 mailia tai 1050 km lyhyempi. Merikartan "suora" lentoreitti Lontoosta Shanghaihin halkaisee Kaspianmeren, kun taas todella lyhin reitti on Pietarista pohjoiseen. On selvää, mikä rooli näillä asioilla on ajan ja polttoaineen säästämisessä.

    Jos purjehduksen aikakaudella merenkulun aika ei aina arvostettu - silloin "aikaa" ei pidetty vielä "rahana", niin höyrylaivojen tullessa joudutaan maksamaan jokaisesta kulutetusta ylimääräisestä kivihiilestä. Siksi laivat liikkuvat nykyään todella lyhintä polkua pitkin käyttämällä usein karttoja, jotka eivät ole tehty Mercatorissa, vaan niin sanotussa "keskiprojektiossa": näissä kartoissa suurten ympyröiden kaaret on kuvattu suorina linjoina.

    Miksi entiset navigaattorit käyttivät tällaisia ​​petollisia karttoja ja valitsivat epäsuotuisia polkuja? On virhe ajatella, että vanhaan aikaan he eivät tienneet merikarttojen nyt osoitetusta ominaisuudesta. Asiaa ei tietenkään selitä tämä, vaan se, että Mercator-menetelmällä piirretyillä kartoilla on haittojen ohella erittäin arvokkaita etuja merimiehille. Tällainen kartta ensinnäkin kuvaa erillisiä pieniä osia maan pinnasta ilman vääristymiä, säilyttäen ääriviivojen kulmat. Tätä ei kiistä se tosiasia, että etäisyyden päiväntasaajasta kaikki ääriviivat venyvät huomattavasti. Korkeilla leveysasteilla venytys on niin merkittävä, että merikartta inspiroi sen piirteitä tuntemattomalle ihmiselle täysin väärän käsityksen mantereiden todellisesta koosta: Grönlanti näyttää olevan samankokoinen kuin Afrikka, Alaska on suurempi kuin Australia, vaikka Grönlanti on 15 kertaa pienempi kuin Afrikka ja Alaska yhdessä Grönlannin kanssa puolet Australian koosta. Mutta merimies, joka tuntee hyvin nämä kartan ominaisuudet, ei voi joutua harhaan. Hän sietää niitä, varsinkin kun pienillä alueilla merikartta antaa tarkan kuvan luonnosta (kuva 5).

    Toisaalta merikartta helpottaa huomattavasti merenkulun käytännön tehtävien ratkaisemista. Tämä on ainoa karttatyyppi, jossa jatkuvalla kurssilla olevan aluksen reitti on kuvattu suorana. "Vakiokurssin" noudattaminen tarkoittaa poikkeuksetta yhden suunnan, yhden selvän "rumman" säilyttämistä, toisin sanoen kulkemista siten, että kaikki pituuspiirit ylitetään samassa kulmassa. Mutta tämä polku ("loxodrome") voidaan kuvata suorana vain kartalla, jossa kaikki meridiaanit ovat suoria, yhdensuuntaisia ​​toistensa kanssa. Ja koska maapallolla leveyspiirit leikkaavat pituuspiirit suorassa kulmassa, niin tällaisella kartalla leveyspiirien tulisi olla suoria linjoja, jotka ovat kohtisuorassa meridiaanien linjoihin nähden. Lyhyesti sanottuna pääsemme juuri siihen koordinaattiverkkoon, joka muodostaa merikartan ominaispiirteen.




    Riisi. 5. Merenkulku- tai Mercator-kartta maapallosta. Tällaisissa kartoissa päiväntasaajasta kaukana olevien ääriviivojen mitat ovat suuresti liioiteltuja. Kumpi on esimerkiksi suurempi: Grönlanti vai Australia? (vastaus tekstissä)


    Merimiesten mieltymys Mercator-karttoihin on nyt ymmärrettävää. Halutessaan määrittää noudatettavan suunnan kuljetettaessa määrättyyn satamaan, navigaattori soveltaa viivainta polun päätepisteisiin ja mittaa kulman, jonka se muodostaa meridiaaneihin nähden. Pysymällä avomerellä koko ajan tähän suuntaan, navigaattori tuo aluksen tarkasti kohteeseen. Näet, että "loxodromi" on, vaikkakaan ei lyhin eikä taloudellisin, mutta tietyssä mielessä erittäin kätevä tapa purjehtijalle. Jotta päästään esimerkiksi Hyväntoivon niemeltä Australian eteläkärkeen (katso kuva 1), on aina pidettävä samaa kurssia S 87 °, 50". Sillä välin laiva saattamiseksi samalle viimeinen piste lyhimmällä tavalla (" ") pitkin, on tarpeen, kuten kuvasta voidaan nähdä, jatkuvasti muuttaa aluksen kurssia: aloita kurssista S 42 °, 50 "ja lopeta kurssilla N 53 °. 50" (tässä tapauksessa lyhin polku ei ole edes mahdollinen - se lepää Etelämantereen jääseinällä).

    Molemmat polut - "loxodromia" ja "ortodromia" pitkin - osuvat yhteen vain, kun polku suurta ympyrää pitkin on kuvattu merikartassa suorana: liikuttaessa päiväntasaajaa tai pituuspiiriä pitkin. Kaikissa muissa tapauksissa nämä polut ovat erilaisia.

    (Kuvaava geometria)
  • CD (CXDX, C2D2) näkyy pisteenä C5 = D5 A5B5 yhtä suuri...
    (Kuvaava geometria)
  • Kahden yhdensuuntaisen tason välisen etäisyyden määrittäminen
    Kahden yhdensuuntaisen tason etäisyyden määrittäminen yleisasennossa 01| X on kätevää pelkistää se ongelmaksi määrittää etäisyys samojen kahden tason välillä, muutettuna ulkonevien tason asentoon. Tässä tapauksessa tasojen välinen etäisyys määritellään kohtisuoraksi viivojen välillä, ...
    (Kuvaava geometria)
  • Kahden leikkaavan suoran välisen etäisyyden määrittäminen
    Jos haluat määrittää lyhimmän etäisyyden kahden leikkaavan suoran välillä, sinun on muutettava projektiotasojärjestelmiä kahdesti. Kun ratkaiset tämän ongelman, suora CD (CXDX, C2D2) näkyy pisteenä C5 = D5(Kuva 198). Etäisyys tästä pisteestä projektioon A5B5 yhtä suuri...
    (Kuvaava geometria)
  • Kahden leikkaavan suoran välinen kulma
    Tämä on kahden tiedon kanssa yhdensuuntaisen leikkaavan suoran välinen kulma. Tämä tehtävä on siis samanlainen kuin edellinen. Sen ratkaisemiseksi sinun on otettava mielivaltainen piste ja piirrettävä sen läpi kaksi viivaa yhdensuuntaisesti annettujen vinoviivojen kanssa ja määritettävä tarvittava kulma projektiomuunnoksen avulla.
    (Kuvausgeometrian perusteet. Lyhyt kurssi ja kokoelma tehtäviä.)
  • Kahden yhdensuuntaisen suoran välisen etäisyyden määrittäminen
    Ongelma ratkaistaan ​​projektiotasojen kaksoiskorvausmenetelmällä. Viimeisessä vaiheessa yhden projektiotasoista on oltava kohtisuorassa jollekin leikkaavasta suorasta. Sitten niiden välinen lyhin etäisyys määräytyy toiseen vinoviivaan nähden kohtisuoran segmentin arvolla (kuva 199).
    (Kuvaava geometria)
  • Polku kuvan katkoviivaa pitkin on lyhyempi kuin jatkuvaa viivaa pitkin kulkeva polku. Ja nyt hieman tarkemmin esimerkkinä merireiteistä:

    Jos purjehdit jatkuvalla kurssilla, niin laivan lentorata maan pinnalla on käyrä, jota kutsutaan matematiikassa logaritminenkierre.

    Navigoinnissa tätä monimutkaista kaksoiskaarevuusviivaa kutsutaan loksodromia, joka kreikaksi tarkoittaa "vinojuoksua".

    Kuitenkin lyhin etäisyys kahden maapallon pisteen välillä mitataan suurympyrän kaarelta.

    Suurympyrän kaari saadaan jäljenä maan pinnan leikkauspisteestä maapallon keskipisteen kautta kulkevan tason kanssa, palloksi otettuna.

    Navigoinnissa suurympyräkaarta kutsutaan mahtava ympyrä, mikä tarkoittaa "suoraa juoksua". Toinen suuren ympyrän piirre on, että se ylittää meridiaanin eri kulmissa (kuva 29).

    Maanpinnan kahden pisteen välisillä etäisyyksillä loksodromin ja ortodromin varrella on käytännön merkitystä vain suurissa valtameren ylityksissä.

    Normaaleissa olosuhteissa tämä ero jätetään huomiotta ja navigointi suoritetaan vakiokurssilla, ts. loxodromin kautta.

    Yhtälön johtamiseksi otamme loksodromioita (kuva 30, a) kaksi pistettä MUTTA ja AT, niiden välinen etäisyys on yksinkertaisesti pieni. Piirretään meridiaanit ja niiden läpi yhdensuuntaisuus, saadaan alkeellinen suorakulmainen pallomainen kolmio ABC. Tässä kolmiossa meridiaanin ja yhdensuuntaisuuden leikkauspisteen muodostama kulma on oikea, ja kulma PnAB yhtä suuri kuin aluksen K. Katet kurssi AC edustaa meridiaanikaaren segmenttiä ja voidaan ilmaista

    missä R - Maan säde pallona otettuna;

    Δφ - leveysasteen peruslisäys (leveysasteiden ero).

    jalka SW edustaa yhdensuuntaista kaarisegmenttiä

    missä r - yhdensuuntaisuuden säde;

    Δλ - alkeellinen pituusasteiden ero.

    Kolmiosta OO 1 C se löytyy

    Sitten viimeisessä muodossa jalka SW voidaan ilmaista näin:

    Olettaen pallomaisen alkeiskolmion ABC tasaiselle, kirjoita

    Vähennyksen jälkeen R ja korvaamme alkeelliset pienet koordinaattien lisäykset äärettömän pienillä

    Integroimme tuloksena olevan lausekkeen välillä φ 1, λ 1 - φ 2, λ 2 ottaen huomioon tgK:n arvon vakioarvona:

    Oikealla puolella meillä on taulukkointegraali. Sen arvon korvaamisen jälkeen saamme pallon loksodromiyhtälön

    Tämän yhtälön analyysi antaa meille mahdollisuuden tehdä seuraavat johtopäätökset:

    Kurssilla 0 ja 180 ° loksodromi muuttuu suuren ympyrän kaareksi - pituuspiiriksi;

    90 ja 270° kursseilla loksodromi osuu rinnakkain;

    Loksodromi ylittää jokaisen leveyden vain kerran ja jokainen pituuspiiri lukemattoman monta kertaa. nuo. spiraalimaisesti lähestyy napaa, se ei saavuta sitä.

    Navigointi vakiosuunnassa eli loxodromia pitkin, vaikka se ei olekaan lyhin etäisyys kahden maan pisteen välillä, on navigaattorille huomattava käyttömukavuus.

    Merenkulkukartan vaatimukset voidaan muotoilla loksodromia pitkin navigoinnin edun ja sen yhtälön analyysin tulosten perusteella seuraavasti.

    1. Loxodromi, joka ylittää pituuspiirit vakiokulmassa, on kuvattava suorana viivana.

    2. Karttojen rakentamiseen käytettävän kartografisen projektion tulee olla yhteneväinen siten, että siinä olevat suunnat, suuntimat ja kulmat vastaavat arvoaan maassa.

    3. Meridiaanin ja yhdensuuntaisuuden, kuten kurssiviivojen 0, 90, 180° ja 270°, on oltava keskenään kohtisuorassa olevia suoria viivoja.

    Lyhin etäisyys kahden tietyn maan pinnan pisteen välillä pallona otettuna on näiden pisteiden läpi kulkevan suurympyrän kaarista pienempi. Lukuun ottamatta meridiaania tai päiväntasaajaa seuraavaa laivaa, suuri ympyrä leikkaa meridiaaneja eri kulmissa. Siksi tällaista käyrää seuraavan laivan on muutettava kurssiaan koko ajan. Käytännössä kätevämpää on seurata kurssia, joka muodostaa tasaisen kulman meridiaaneihin nähden ja joka on kuvattu kartalla Mercator-projektiossa suoralla viivalla - loksodromilla. Suurilla etäisyyksillä ortodromin ja loksodromin pituuden ero saavuttaa kuitenkin merkittävän arvon. Siksi tällaisissa tapauksissa ortodromi lasketaan ja siihen merkitään välipisteet, joiden väliin ne uivat pitkin loksodromia.

    Kartografista projektiota, joka täyttää yllä mainitut vaatimukset, ehdotti hollantilainen kartografi Gerard Cramer (Mercator) vuonna 1569. Tekijän kunniaksi projektio nimettiin Mercator.

    Ja kuka haluaa oppia vielä kiinnostavampaa tietoa, se saa tietää lisää Alkuperäinen artikkeli on verkkosivustolla InfoGlaz.rf Linkki artikkeliin, josta tämä kopio on tehty -

    DISTANCE, etäisyydet, vrt. 1. Tila, joka erottaa kaksi pistettä, rako jonkin välillä. Lyhin etäisyys kahden suoran pisteen välillä. Asuu meistä kahden kilometrin etäisyydellä. "Komentaja päästi heidät sisään lähimmältä ... Ushakovin selittävä sanakirja

    etäisyys- substantiivi, s., käyttö. usein Morfologia: (ei) mitä? etäisyys mihin? etäisyys, (katso) mitä? etäisyys kuin? etäisyys, mitä? etäisyydestä; pl. mitä? etäisyys, (ei) mitä? etäisyydet, miksi? etäisyydet, (katso) mitä? etäisyys kuin? etäisyydet... Dmitrievin sanakirja

    etäisyys- minä; vrt. Tila, joka erottaa kaksi pistettä, kaksi esinettä jne., rako jonkun välillä, kuin l. Lyhin joki kahden pisteen välissä. R. kotoa kouluun. Vetäydy läheiselle joelle. Metrin etäisyydellä kädet ojennettuina. Tiedä jotain, tunne jotain. päällä…… tietosanakirja

    etäisyys- minä; vrt. Katso myös etäisyys a) Tila, joka erottaa kaksi pistettä, kaksi esinettä jne., rako jonkun välillä, kuin l. Lyhin etäisyys kahden pisteen välillä. Etäisyys kotoa kouluun. Vetäydy lähelle / ei... Monien ilmaisujen sanakirja

    GEOMETRIA- matematiikan ala, joka tutkii eri muotojen (pisteet, viivat, kulmat, kaksi- ja kolmiulotteiset esineet) ominaisuuksia, niiden kokoa ja suhteellista sijaintia. Opetuksen mukavuuden vuoksi geometria on jaettu planimetriaan ja solidigeometriaan. AT…… Collier Encyclopedia

    Navigointi*

    Navigointi- merenkulun osasto (katso), lopettaa esittelyn tavoista määrittää aluksen paikka merellä kompassin ja lokin avulla (katso). Laivan merellä olevan paikan määrittäminen tarkoittaa, että kartalle merkitään piste, jossa alus tällä hetkellä sijaitsee. ... ... Ensyklopedinen sanakirja F.A. Brockhaus ja I.A. Efron

    COGEN- (Cohen) Hermann (1842 1918) saksalainen filosofi, Marburgin uuskantialismin koulukunnan perustaja ja näkyvin edustaja. Tärkeimmät teokset: "Kantin kokemusteoria" (1885), "Kantin perustelu etiikkalle" (1877), "Kantin estetiikan perustelu" (1889), "Logiikka... ...

    Kant Immanuel- Kantin elämänpolku ja kirjoituksia Immanuel Kant syntyi Königsbergissä (nykyinen Kaliningrad) Itä-Preussissa vuonna 1724. Hänen isänsä oli satulaseppä ja äiti kotiäiti, kuusi lasta ei elänyt täysi-ikäiseksi. Kant muisti aina vanhempansa ... ... Länsimainen filosofia sen alkuperästä nykypäivään

    KANTIN KRIITTINEN FILOSOFIA: Oppi kykyistä- (La philosophie critique de Kant: Doctrines des facultes, 1963), kirjoittanut Deleuze. Kuvaamalla johdannossa transsendentaalista menetelmää Deleuze huomauttaa, että Kant ymmärtää filosofian tieteenä kaiken tiedon suhteesta olennaisiin tavoitteisiin... ... Filosofian historia: Tietosanakirja

    maatilan periaate- geometrisen optiikan perusperiaate (katso Geometrinen optiikka). F. p.:n yksinkertaisin muoto on väite, että valonsäde etenee aina avaruudessa kahden pisteen välillä pitkin polkua, jota pitkin sen kulumisaika on pienempi kuin ... Suuri Neuvostoliiton tietosanakirja

    Dijkstran algoritmi on hollantilaisen tiedemiehen Edsger Dijkstran vuonna 1959 keksimä graafialgoritmi. Löytää lyhyimmät polut graafin yhdestä kärjestä kaikkiin muihin. Algoritmi toimii vain kaavioille, joissa ei ole negatiivisen painon reunoja.

    Harkitse algoritmin suoritusta kuvassa esitetyn kaavion esimerkissä.

    Vaaditaan lyhimpien etäisyyksien löytämistä 1. kärjestä kaikkiin muihin.

    Ympyrät osoittavat kärkipisteitä, viivat osoittavat niiden välisiä polkuja (graafin reunat). Piikkien numerot on merkitty ympyröihin, niiden "hinta" - polun pituus - on merkitty reunojen yläpuolelle. Jokaisen kärjen viereen on merkitty punainen etiketti - lyhimmän polun pituus tähän kärkeen kärjestä 1.

    Ensimmäinen askel. Harkitse Dijkstran algoritmin vaihetta esimerkissämme. Vertex 1:llä on vähimmäisnimike. Vertexit 2, 3 ja 6 ovat sen naapureita.

    Huippupisteen 1 ensimmäinen naapuri on puolestaan ​​kärki 2, koska polun pituus siihen on minimaalinen. Polun pituus siihen kärjen 1 kautta on yhtä suuri kuin kärjen 1 etiketin arvon ja 1:stä 2:een menevän reunan pituuden summa, eli 0 + 7 = 7. Tämä on pienempi kuin kärjen 2 nykyinen otsikko, ääretön, joten 2. kärjen uusi otsikko on 7.

    Suoritamme samanlaisen operaation kahden muun 1. kärjen naapurin - 3. ja 6. - kanssa.

    Kaikki solmun 1 naapurit tarkistetaan. Nykyinen vähimmäisetäisyys huipulle 1 katsotaan lopulliseksi, eikä sitä voida tarkistaa (että näin todellakin on, todisti ensin E. Dijkstra). Rajaa se pois kaaviosta merkitäksesi, että tässä kärjessä on käyty.

    Toinen vaihe. Algoritmin vaihe toistetaan. Jälleen löydämme "lähimmän" vierailemattomista pisteistä. Tämä on kärki 2, joka on merkitty 7.

    Jälleen yritämme pienentää valitun kärjen naapurien nimiä, yrittäen kulkea niiden läpi 2. kärjen kautta. Vertex 2:n naapurit ovat kärjet 1, 3 ja 4.

    Huippupisteen 2 ensimmäinen (järjestyksessä) naapuri on kärki 1. Mutta siinä on jo käyty, joten 1. kärjen kanssa emme tee mitään.

    Huippupisteen 2 seuraava naapuri on kärki 3, koska siinä on vieraamattomaksi merkittyjen kärkien miniminimike. Jos siirryt siihen 2:n kautta, tällaisen polun pituus on 17 (7 + 10 = 17). Mutta kolmannen kärjen nykyinen otsikko on 9, mikä on vähemmän kuin 17, joten nimiö ei muutu.

    Toinen kärjen 2 naapuri on kärki 4. Jos mennään siihen 2.:n kautta, niin tällaisen polun pituus on yhtä suuri kuin lyhimmän etäisyyden 2. kärkeen ja pisteiden 2 ja 4 välisen etäisyyden summa, eli , 22 (7 + 15 = 22). 22 alkaen<, устанавливаем метку вершины 4 равной 22.

    Kaikki kärjen 2 naapurit on katsottu, jäädytämme etäisyyden siihen ja merkitsemme sen käydyksi.

    Kolmas vaihe. Toistamme algoritmin vaiheen valitsemalla kärkipisteen 3. Sen "käsittelyn" jälkeen saamme seuraavat tulokset:

    Seuraavat vaiheet. Toistamme algoritmin vaiheen jäljellä oleville pisteille. Nämä ovat kärjet 6, 4 ja 5, vastaavasti.

    Algoritmin suorituksen loppuun saattaminen. Algoritmi päättyy, kun pisteitä ei voida enää käsitellä. Tässä esimerkissä kaikki kärjet on yliviivattu, mutta on virhe olettaa, että näin on kaikissa esimerkeissä - jotkut pisteet voivat jäädä yliviivaamattomiksi, jos niitä ei saavuteta, eli jos graafi on irrotettu. Algoritmin tulos näkyy viimeisessä kuvassa: lyhin polku kärjestä 1:stä 2:een on 7, 3:een on 9, 4:ään on 20, 5:een on 20, 6:een on 11.

    Algoritmin toteutus eri ohjelmointikielillä:

    C++

    #include "stdafx.h" #include käyttäen nimiavaruutta std; const int V=6; // Dijkstran algoritmi void Dijkstra(int GR[V][V], int st) ( int etäisyys[V], määrä, indeksi, i, u, m=st+1; bool vierailtu[V]; for (i= 0 i "< "<> "; cin>>start; Dijkstra(GR, start-1); system("tauko>>void"); )

    Pascal

    ohjelma DijkstraAlgoritm; usescrt; constV=6; inf=100000; tyyppi vektori=kokonaislukujono; var alku: kokonaisluku; const GR: kokonaislukujono =((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)); (Dijkstran algoritmi) menettely Dijkstra(GR: kokonaislukujono; st: kokonaisluku); var count, index, i, u, m, min: kokonaisluku; etäisyys: vektori; vieraili: array of boolen; beginm:=st; jos i:=1 - V tee aloitusetäisyys[i]:=inf; vieraili[i]:=false; loppu; etäisyys:=0; count:=1 - V-1 aloita min:=inf; for i:=1 to V do if (ei käynyt[i]) ja (etäisyys[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) ja (etäisyys[u]<>inf) ja (etäisyys[u]+GR inf then writeln(m," > ", i," = ", etäisyys[i]) else writeln(m," > ", i," = ", "reitti ei ole käytettävissä"); loppu; (pääohjelmalohko) begin clrscr; write("Aloitussolmu >> "); lue(aloita); Dijkstra(GR, aloitus); loppu.

    Java

    tuonti java.io.BufferedReader; tuonti java.io.IOException; tuonti java.io.InputStreamReader; tuonti java.io.PrintWriter; tuonti java.util.ArrayList; tuonti java.util.Arrays; tuonti java.util.StringTokenenizer; julkinen luokka Ratkaisu ( yksityinen staattinen int INF = Integer.MAX_VALUE / 2; yksityinen int n; //pisteiden määrä digraafissa private int m; //kaarien määrä digraafissa private ArrayList adj; //naapuriluettelo yksityinen ArrayList paino; //digrafin reunan paino käytetty yksityistä loogista; //Matriisi tiedon tallentamiseen hyväksytyistä ja läpäisemättömistä huipuista private int dist; //taulukko tallentaaksesi etäisyyden aloituspisteestä //joukko esi-isiä, joita tarvitaan lyhimmän polun palauttamiseen aloituspisteestä private int pred; int alku; //aloituspiste, josta haetaan etäisyyttä kaikkiin muihin yksityisiin BufferedReader cin; yksityiset PrintWriter cout; yksityinen StringTokenizer tokenizer; //menettely Dijkstran algoritmin käynnistämiseksi aloituspisteestä private void dejkstra(int s) ( dist[s] = 0; //lyhin etäisyys aloituspisteeseen on 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(); ) //reunojen painot tallentavan listan alustaminen weight = new ArrayList[n]; for (int i = 0; i< n; ++i) { weight[i] = new ArrayList(); ) //lue reunusluettelon antama kuvaaja kohteelle (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(); } }

    Toinen vaihtoehto:

    Tuo java.io.*; tuonti java.util.*; public class Dijkstra ( yksityinen staattinen lopullinen Graph.Edge GRAPH = ( uusi Graph.Edge("a", "b", 7), uusi Graph.Edge("a", "c", 9), uusi Graph.Edge( "a", "f", 14), uusi Graph.Edge("b", "c", 10), uusi Graph.Edge("b", "d", 15), uusi Graph.Edge("c" ", "d", 11), uusi Graph.Edge("c", "f", 2), uusi Graph.Edge("d", "e", 6), uusi Graph.Edge("e", "f", 9), ); yksityinen staattinen lopullinen merkkijono START = "a"; yksityinen staattinen lopullinen merkkijono END = "e"; julkinen staattinen void main(String args) ( Kaavio g = uusi Graph(GRAPH); g.dijkstra (START); g.printPath(END); //g.printAllPaths(); ) ) luokkakaavio ( yksityinen lopullinen kartta kaavio; // kärkipisteiden nimien kartoitus Vertex-objekteihin, rakennettu joukosta Edges /** Graafin yksi reuna (vain Graph-konstruktorin käyttämä) */ public static class Edge ( public final String v1, v2; public final int dist; public Edge(merkkijono v1, merkkijono v2, int dist) ( this.v1 = v1; this.v2 = v2; this.dist = dist; ) ) /** Yksi graafin kärkipiste, jossa on kuvatut naapuripisteet */ julkinen staattinen luokka Vertex-työkalut Verrattavissa ( julkinen lopullinen merkkijonon nimi; public int dist = kokonaisluku.MAX_VALUE; // MAX_VALUE oletetaan äärettömäksi julkinen Vertex edellinen = null; julkinen lopullinen kartta naapurit = uusi HashMap<>(); public Vertex(String name) ( this.name = nimi; ) private void printPath() ( if (this == this.previous) ( System.out.printf("%s", this.name); ) else if ( this.previous == null) ( System.out.printf("%s(reached)", this.name); ) else ( this.previous.printPath(); System.out.printf(" -> %s() %d)", this.name, this.dist); ) ) public int vertaaTo(Vertex other) ( palauttaa Kokonaisluku.vertaa(dist, other.dist); ) ) /** Muodostaa graafin joukosta reunoja * / julkinen Graph(Reunareunat) ( kaavio = uusi HashMap<>(reunat.pituus); //yksi kierros löytääksesi kaikki pisteet kohteelle (Edge e: edges) ( 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)); ) //toinen kierros asettaaksesi naapuripisteet kohteelle (Edge e: edges) ( graph.get(e.v1). naapurit.put(graph.get(e.v2), e.dist); //graph.get(e.v2).neighbours.put(graph.get(e.v1), e.dist); // myös tee tämä ohjaamattomalle graafille ) ) /** Suorittaa dijkstran käyttämällä määritettyä lähdepistettä sisältää alkupisteen \"%s\"\n", aloitusnimi); paluu; ) lopullinen Vertexin lähde = graph.get(aloitusnimi); NavigableSet q = uusi TreeSet<>(); // määritä kärkipisteet kohteelle (Vertex v: graph.values()) ( v.previous = v == lähde ? lähde: null; v.dist = v == lähde ? 0: Integer.MAX_VALUE; q.add( v); ) dijkstra(q); ) /** Dijkstran algoritmin toteutus binäärikeon avulla. */ private void dijkstra(lopullinen NavigableSet q) ( Vertex u, v; while (!q.isEmpty()) ( u = q.pollFirst(); // kärkipiste, jolla on lyhin etäisyys (ensimmäinen iteraatio palauttaa lähteen) if (u.dist == Integer.MAX_VALUE) tauko; // voimme jättää huomiotta u:n (ja kaikki muut jäljellä olevat kärjet), koska ne ovat saavuttamattomissa //tarkastele etäisyyksiä jokaiseen naapuriin (Map.Entry a: u.neighbours.entrySet()) ( v = a.getKey(); //naapuri tässä iteraation lopullinen 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

    #sisältää #sisältää #sisältää //#define BIG_EXAMPLE typedef struct solmu_t solmu_t, *keko_t; typedef rakenne reuna_t reuna_t; struct edge_t ( solmu_t *nd; /* tämän reunan kohde */ reuna_t *sisarus;/* yksittäislinkitettyyn luetteloon */ int len; /* reunan hinta */ ); struct solmu_t ( reuna_t *reuna; /* erikseen linkitetty reunojen luettelo */ solmu_t *via; /* missä edellinen solmu on lyhimmällä polulla */ double dist; /* etäisyys alkuperäisestä solmusta */ merkin nimi; /* the, er , nimi */ int heap_idx /* linkki keon sijaintiin etäisyyden päivittämistä varten */ ); /* --- reunanhallinta --- */ #ifdef BIG_EXAMPLE # määrittele BLOCK_SIZE (1024 * 32 - 1) #else # määrittele BLOCK_SIZE 15 #endif edge_t *edge_root = 0, *e_next = 0; /* Älä välitä muistinhallintajutuista, ne ovat muutakin kuin asiaa. Pretend e_next = malloc(sizeof(edge_t)) */ void add_edge(node_t *a, node_t *b, double d) ( if (e_next == edge_root ) ( reuna_juuri = malloc(koko(reuna_t) * (BLOCK_KOKO + 1)); reuna_juuri.sisarus = e_seuraava; e_seuraava = reuna_juuri + BLOCK_KOKO; ) --e_seuraava; e_seuraava->nd = b; e_seuraava->en =ext; ->sisarus = a->reuna; a->reuna = e_seuraava; ) void free_edges() (for (; reuna_juuri; reuna_juuri = e_seuraava) ( e_seuraava = reuna_juuri.sisarus; vapaa(reuna_juuri); ) ) /* --- prioriteettijonon tavara --- */ kasa_t *keko; int kasa_len; void set_dist(node_t *nd, node_t *via, double d) ( int i, j; /* tiesi jo paremman polun */ if (nd->via && d >= nd->dist) return; /* etsi olemassa oleva keon merkintä tai luo uusi */ nd->dist = d; nd->via = kautta; i = nd->heap_idx; jos (!i) i = ++heap_len; /* upheap */ for (; i > 1 && nd->dist< heap->dist; i = j) (kasa[i] = kasa[j])->keon_idx = i; kasa[i] = nd; nd->keon_idx = i; ) solmu_t * pop_queue() ( solmu_t *nd, *tmp; int i, j; jos (!heap_len) palauttaa 0; /* poista johtava elementti, vedä tail-elementti sinne ja laske kasaan */ nd = kasa; tmp = kasa; for (i = 1; i< heap_len && (j = i * 2) <= heap_len; i = j) { if (j < heap_len && heap[j]->dist > pino->dist) j++; if (heap[j]->dist >= tmp->dist) break; (kasa[i] = kasa[j])->keon_idx = i; ) kasa[i] = tmp; tmp->keon_idx = i; paluu nd; ) /* --- Dijkstra tavaraa; tavoittamattomat solmut eivät koskaan pääse jonoon --- */ void calc_all(solmu_t *aloitus) ( solmu_t *lyijy; reuna_t *e; set_dist(aloitus, aloitus, 0); while ((lyijy = pop_queue())) for ( e = lyijy->reuna; e; e = e->sisarus) set_dist(e->nd, lead, lead->dist + e->len); ) void show_path(node_t *nd) ( if (nd-> kautta == nd) printf("%s", nd->nimi); else if (!nd->via) printf("%s(unreached)", nd->nimi); else ( näytä_polku(nd-> kautta); printf("-> %s(%g) ", nd->name, nd->dist); ) ) int main(void) ( #ifndef BIG_EXAMPLE int i; # määrittele N_SOMUt ("f" - " a" + 1) solmu_t *solmut = calloc(sizeof(node_t), N_SODES); 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

    $edge, "kustannus" => $reuna); $naapurit[$reuna] = array("loppu" => $reuna, "kustannus" => $reuna); ) $pisteet = matriisi_ainutlaatuinen($pisteet); foreach ($pisteet $vertexina) ( $dist[$vertex] = INF; $edellinen[$vertex] = NULL; ) $dist[$lähde] = 0; $Q = $vertices; while (count($Q) > 0) ( // TODO - Etsi nopeampi tapa saada vähintään $min = INF; foreach ($Q kuin $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";


    Python

    kokoelmista tuonti namedtuple, jono pprintistä tuonti pprint as pp inf = float("inf") Edge = namedtuple("Reuna", "alku, loppu, hinta") class Graph(): def __init__(self, edges): self .edges = reunat2 = self.vertices = set(sum(( e in edges2), )) def dijkstra(itse, lähde, kohde): vahvista lähde self.vertices dist = (vertex: inf for the vertex in self.vertices ) previous = (vertex: None for self.vertices) dist = 0 q = self.vertices.copy() naapurit = (vertex: set() for vertex in self.vertices) alku, loppu, hinta itsessä. reunat: naapurit.add((loppu, hinta)) #pp(naapurit) while q: u = min(q, avain=lambda-vertex: dist) q.remove(u) if dist[u] == inf tai u = = kohde: tauko v:lle, hinta naapureissa[u]: alt = dist[u] + hinta, jos 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"]

    Samanlaisia ​​artikkeleita