Ahne algoritmi esimerkeillä: Ahne menetelmä & Lähestyä

Sisällysluettelo:

Anonim

Mikä on ahne algoritmi?

Vuonna ahne algoritmi joukko resursseja rekursiivisesti perusteella jaetaan suurimman, välitön saatavuus että resurssien kussakin vaiheessa suorittamisen.

Ahneeseen lähestymistapaan perustuvan ongelman ratkaisemiseksi on kaksi vaihetta

  1. Skannataan luettelo
  2. Optimointi

Nämä vaiheet käsitellään rinnakkain tässä ahneiden algoritmien opetusohjelmassa matriisin jakamisen aikana.

Ahneiden lähestymistapojen ymmärtämiseksi sinulla on oltava toimiva tieto rekursiosta ja kontekstin vaihtamisesta. Tämä auttaa sinua ymmärtämään, kuinka koodi voidaan jäljittää. Voit määritellä ahne paradigma omien tarpeellisten ja riittävien lausuntojen avulla.

Kaksi ehtoa määrittelee ahneuden paradigman.

  • Jokaisen vaiheittaisen ratkaisun on rakennettava ongelma kohti parhaiten hyväksyttyä ratkaisua.
  • Riittää, jos ongelman jäsentäminen voi pysähtyä lopullisessa määrässä ahneita vaiheita.

Kun teoriointia jatketaan, kuvailkaamme ahneeseen lähestymistapaan liittyvää historiaa.

Tässä ahneiden algoritmien opetusohjelmassa opit:

  • Ahneiden algoritmien historia
  • Ahne strategiat ja päätökset
  • Ahneuden lähestymistavan ominaisuudet
  • Miksi käyttää ahne lähestymistapaa?
  • Kuinka ratkaista toiminnan valintaongelma
  • Ahne-lähestymistavan arkkitehtuuri
  • Ahneiden algoritmien haitat

Ahneiden algoritmien historia

Tässä on tärkeä ahneiden algoritmien maamerkki:

  • Ahneita algoritmeja käsiteltiin monille kaavioalgoritmeille 1950-luvulla.
  • Esdger Djikstra käsitteli algoritmin tuottamaan minimaalisesti kattavia puita. Hän pyrki lyhentämään Hollannin pääkaupungin Amsterdamin reittien pituutta.
  • Samalla vuosikymmenellä Prim ja Kruskal saavuttivat optimointistrategiat, jotka perustuivat reittikustannusten minimoimiseen punnitun reitin varrella.
  • 70-luvulla amerikkalaiset tutkijat Cormen, Rivest ja Stein ehdottivat ahneiden ratkaisujen rekursiivista uudelleenjärjestelyä klassisessa johdannossaan algoritmikirjaan.
  • Ahne haku paradigma rekisteröitiin erityyppisenä optimointistrategiana NIST-tietueissa vuonna 2005.
  • Kunnes päiväys, verkkoa käyttävät protokollat, kuten avoin-lyhin polku ensin (OSPF) ja monet muut verkkopakettikytkentäprotokollat, käyttävät ahneita strategioita verkkoon kuluvan ajan minimoimiseksi.

Ahne strategiat ja päätökset

Logiikka sen yksinkertaisimmassa muodossa keitettiin "ahneeksi" tai "ei ahneeksi". Nämä lauseet määriteltiin lähestymistavalla, jota käytettiin edistymään kussakin algoritmivaiheessa.

Esimerkiksi Djikstran algoritmi hyödynsi asteittain ahne strategia tunnistaa isännät Internetissä laskemalla kustannusfunktio. Kustannusfunktion palauttama arvo määrittää, onko seuraava polku "ahne" vai "ei ahne".

Lyhyesti sanottuna algoritmi lakkaa olemasta ahne, jos se missä tahansa vaiheessa ottaa askeleen, joka ei ole paikallisesti ahne. Ahneet ongelmat pysähtyvät ilman ahneuden laajuutta.

Ahneuden lähestymistavan ominaisuudet

Ahneiden menetelmien algoritmin tärkeitä ominaisuuksia ovat:

  • Resursseista on järjestetty luettelo, johon sisältyy kustannuksia tai arvonmäärityksiä. Nämä kvantifioivat järjestelmän rajoituksia.
  • Otat resurssien enimmäismäärän siihen aikaan, kun rajoitusta sovelletaan.
  • Esimerkiksi toiminnan ajoitusongelmassa resurssikustannukset ovat tunteina, ja toiminnot on suoritettava sarjajärjestyksessä.

Miksi käyttää ahne lähestymistapaa?

Tässä on syitä ahneuden käyttämiseen:

  • Ahne lähestymistapa on muutama kompromissi, mikä voi tehdä siitä sopivan optimointiin.
  • Yksi merkittävä syy on saavuttaa mahdollisimman toteutettavissa oleva ratkaisu välittömästi. Jos aktiviteetin valintaongelmassa (selitetty alla), jos enemmän toimintoja voidaan tehdä ennen nykyisen toiminnan päättämistä, nämä toiminnot voidaan suorittaa samassa ajassa.
  • Toinen syy on jakaa ongelma rekursiivisesti ehdon perusteella ilman tarvetta yhdistää kaikkia ratkaisuja.
  • Aktiviteetin valintaongelmassa "rekursiivinen jako" -vaihe saavutetaan skannaamalla luettelo kohteista vain kerran ja huomioiden tietyt toiminnot.

Kuinka ratkaista toiminnan valintaongelma

Toiminnan ajoitusesimerkissä jokaiselle toiminnolle on "aloitus" ja "lopetus" aika. Jokainen aktiviteetti indeksoidaan numerona viitteeksi. Aktiivisuusluokkia on kaksi.

  1. pidetty toiminta : on toiminta, joka on viite, josta analysoidaan kyky tehdä useampi kuin yksi jäljellä oleva toiminta.
  2. jäljellä olevat toiminnot: toiminnot yhdellä tai useammalla indeksillä ennen tarkasteltavaa toimintaa.

Kokonaiskesto ilmoittaa toiminnan suorittamisen kustannukset. Toisin sanoen (maali - alku) antaa meille keston toiminnan kustannuksena.

Opit, että ahneus on jäljellä olevien toimintojen lukumäärä, jonka voit suorittaa harkitun toiminnan aikana.

Ahne-lähestymistavan arkkitehtuuri

VAIHE 1)

Skannaa luettelo aktiviteettikustannuksista alkaen indeksistä 0 pidetyksi indeksiksi.

VAIHE 2)

Kun useampia aktiviteetteja on voitu suorittaa loppuun mennessä, kyseinen toiminto päättyy, aloita yhden tai useamman jäljellä olevan toiminnan etsiminen.

VAIHE 3)

Jos jäljellä olevia toimintoja ei ole enää, nykyisestä jäljellä olevasta toiminnasta tulee seuraava harkittu toiminta. Toista vaiheet 1 ja 2 uudella harkitulla toiminnolla. Jos toimintoja ei ole jäljellä, siirry vaiheeseen 4.

VAIHE 4)

Palauta harkittujen indeksien unioni. Nämä ovat aktiivisuusindeksejä, joita käytetään maksimoimaan läpimeno.

Ahne lähestymistapa arkkitehtuuri

Koodin selitys

#include#include#include#define MAX_ACTIVITIES 12

Koodin selitys:

  1. Mukana olevat otsikkotiedostot / luokat
  2. Käyttäjän tarjoama maksimimäärä toimintoja.
using namespace std;class TIME{public:int hours;public: TIME(){hours = 0;}};

Koodin selitys:

  1. Striimaustoimintojen nimitila.
  2. TIME-luokan määritelmä
  3. Tunnin aikaleima.
  4. AIKA-oletusrakentaja
  5. Tunnit muuttuja.
class Activity{public:int index;TIME start;TIME finish;public: Activity(){start = finish = TIME();}};

Koodin selitys:

  1. Luokan määritelmä toiminnasta
  2. Aikaleimat, jotka määrittelevät keston
  3. Kaikki aikaleimat alustetaan arvoon 0 oletuskonstruktorissa
class Scheduler{public:int considered_index,init_index;Activity *current_activities = new Activity[MAX_ACTIVITIES];Activity *scheduled;

Koodin selitys:

  1. Aikataululuokan määritelmän osa 1.
  2. Pidetty indeksi on taulukon skannauksen lähtökohta.
  3. Alustusindeksiä käytetään satunnaisten aikaleimojen osoittamiseen.
  4. Joukko aktiviteettikohteita allokoidaan dynaamisesti uuden operaattorin avulla.
  5. Ajoitettu osoitin määrittää ahneuden nykyisen sijainnin.
Scheduler(){considered_index = 0;scheduled = NULL;… …

Koodin selitys:

  1. Aikataulurakentaja - aikataululuokan määritelmän osa 2.
  2. Harkittu indeksi määrittää nykyisen skannauksen nykyisen alun.
  3. Nykyinen ahne laajuus ei ole määritelty alussa.
for(init_index = 0; init_index < MAX_ACTIVITIES; init_index++){current_activities[init_index].start.hours =rand() % 12;current_activities[init_index].finish.hours =current_activities[init_index].start.hours +(rand() % 2);printf("\nSTART:%d END %d\n",current_activities[init_index].start.hours,current_activities[init_index].finish.hours);}… …

Koodin selitys:

  1. A for loop alustaa jokaisen tällä hetkellä suunnitellun toiminnan aloitus- ja lopetusajat.
  2. Aloitusajan alustus.
  3. Loppuajan alustus aina alkutunnin jälkeen tai tarkalleen siinä.
  4. Virheenkorjauslauseke tulostaa varatut kestot.
public:Activity * activity_select(int);};

Koodin selitys:

  1. Osa 4 - aikataululuokan määritelmän viimeinen osa.
  2. Aktiivisuuden valintatoiminto ottaa lähtökohdan hakemiston ja jakaa ahneen tehtävän ahneiksi alaongelmiksi.
Activity * Scheduler :: activity_select(int considered_index){this->considered_index = considered_index;int greedy_extent = this->considered_index + 1;… …

  1. Laajuusresoluutiooperaattorin (: :) avulla annetaan toiminnon määrittely.
  2. Tarkasteltava indeksi on indeksi, jota kutsutaan arvon mukaan. Greedy_extent on alustettu vain indeksi tarkastellun indeksin jälkeen.
Activity * Scheduler :: activity_select(int considered_index){while( (greedy_extent < MAX_ACTIVITIES ) &&((this->current_activities[greedy_extent]).start.hours <(this->current_activities[considered_index]).finish.hours )){printf("\nSchedule start:%d \nfinish%d\n activity:%d\n",(this->current_activities[greedy_extent]).start.hours,(this->current_activities[greedy_extent]).finish.hours,greedy_extent + 1);greedy_extent++;}… …

Koodin selitys:

  1. Ydinlogiikka - ahne laajuus on rajoitettu toimintojen määrään.
  2. Nykyisen aktiviteetin alkamisajat tarkistetaan aikatauluttaviksi ennen kuin tarkasteltavan toiminnan (annettu indeksillä) loppuisi.
  3. Niin kauan kuin mahdollista, tulostetaan valinnainen virheenkorjauslauseke.
  4. Siirry seuraavaan hakemistoon aktiivisuusryhmässä
… if ( greedy_extent <= MAX_ACTIVITIES ){return activity_select(greedy_extent);}else{return NULL;}}

Koodin selitys:

  1. Ehdolliset tarkastukset, jos kaikki toiminnot on katettu.
  2. Jos ei, voit aloittaa ahneesi uudelleen pitämällä indeksiä nykyisenä pisteenä. Tämä on rekursiivinen vaihe, joka jakaa ahneasti ongelmalausekkeen.
  3. Jos kyllä, se palaa soittajalle ilman mahdollisuutta laajentaa ahneutta.
int main(){Scheduler *activity_sched = new Scheduler();activity_sched->scheduled = activity_sched->activity_select(activity_sched->considered_index);return 0;}

Koodin selitys:

  1. Päätoiminto, jota käytetään ajastimen kutsumiseen.
  2. Uusi ajoitin on instantiated.
  3. Toiminnan valintatoiminto, joka palauttaa tyypin aktiivisuuden osoittimen, palaa soittajalle ahneen tehtävän päätyttyä.

Tuotos:

START:7 END 7START:9 END 10START:5 END 6START:10 END 10START:9 END 10Schedule start:5finish6activity:3Schedule start:9finish10activity:5

Ahneiden algoritmien haitat

Se ei sovi ahneisiin ongelmiin, joissa tarvitaan ratkaisu jokaiseen alaongelmaan, kuten lajitteluun.

Tällaisissa ahneiden algoritmien käytäntöongelmissa Greedy-menetelmä voi olla väärä; pahimmassa tapauksessa jopa johtaa ei-optimaaliseen ratkaisuun.

Siksi ahneiden algoritmien haittana on tietämättömyyden käyttäminen nykyisen ahneuden edessä.

Alla on kuvaus ahneuden menetelmän haitoista:

Tässä puuna esitetyssä ahneessa skannauksessa (korkeampi arvo suurempi ahneus) algoritmin tila arvossa 40 todennäköisesti ottaa seuraavan arvon 29. Lisäksi sen pyrkimys päättyy 12. Tämä on arvo 41.

Jos algoritmi kuitenkin meni alle optimaalisen polun tai hyväksyi valloitusstrategian. sitten 25: ää seuraisi 40, ja kokonaiskustannusten parannus olisi 65, mikä on 24 pistettä korkeampi kuin optimaalinen päätös.

Esimerkkejä ahneista algoritmeista

Useimmat verkkoalgoritmit käyttävät ahne lähestymistapa. Tässä on luettelo muutamista ahneiden algoritmien esimerkeistä:

  • Primin pienin ulottuva puu -algoritmi
  • Matkustavan myyjän ongelma
  • Kaavio - Kartan väritys
  • Kruskalin vähimmäispitoisuuspuun algoritmi
  • Dijkstran vähimmäispitoisuuspuun algoritmi
  • Kaavio - Vertex-kansi
  • Selkäreppuongelma
  • Työn ajoitusongelma

Yhteenveto:

Yhteenvetona voidaan todeta, että artikkelissa määritettiin ahne paradigma ja osoitettiin, kuinka ahne optimointi ja rekursio voivat auttaa sinua saamaan parhaan ratkaisun pisteeseen saakka. Ahne algoritmi on laajalti otettu käyttöön ongelmanratkaisusovelluksissa monilla kielillä, kuten ahne algoritmi Python, C, C #, PHP, Java jne. Greedy-algoritmien esimerkin aktiivisuuden valinta kuvattiin strategiseksi ongelmaksi, joka voisi saavuttaa maksimaalisen suorituskyvyn ahneiden avulla lähestyä. Loppujen lopuksi selvitettiin ahneuden lähestymistavan käytön puutteet.