Wikiszótár huwiktionary https://hu.wiktionary.org/wiki/Wikisz%C3%B3t%C3%A1r:Kezd%C5%91lap MediaWiki 1.44.0-wmf.6 case-sensitive Média Speciális Vita Szerkesztő Szerkesztővita Wikiszótár Wikiszótár-vita Fájl Fájlvita MediaWiki MediaWiki-vita Sablon Sablonvita Segítség Segítségvita Kategória Kategóriavita Függelék Függelékvita Index Indexvita TimedText TimedText talk Modul Modulvita 0 31999 3479423 2858532 2024-12-12T17:27:54Z Jeuwre 15076 audio 3479423 wikitext text/x-wiki {{deuff}} :{{audio|De-Erscheinung.ogg|hallgat ([ɛɐ̯ˈʃaɪ̯nʊŋ])}} #[[jelenés]] #[[jelenség]] {{deuffr}} 4ol4fussvr466i5kg7dksw6ucaejqa9 0 36134 3479413 2771811 2024-12-12T17:09:50Z LinguisticMystic 22848 3479413 wikitext text/x-wiki {{hunfn}} #{{matematika|lang=hu}} {{-der-}} * [[programozási]] {{-etim-}} {{suffix|programoz|ás|pos=fn}} {{-ford-}} {{trans-top}} *{{en}}: {{t|en|programming}} *{{fr}}: {{t|fr|programmation}} *{{de}}: {{t|de|Programmierung|f}} *{{it}}: {{t|it|programmazione|f}} *{{ru}}: {{t|ru|программирование }} *{{es}}: {{t|es|programación|f}} {{trans-bottom}} {{-rago-}} {{hu-fn-ok|programozá|s}}{{hu-birt-otok|programozás||ai}} {{hunl}} k2xk2w7gnhjsks5poetgl77vtnf3r9k 3479416 3479413 2024-12-12T17:12:50Z LinguisticMystic 22848 3479416 wikitext text/x-wiki {{hunfn}} #{{matematika|lang=hu}} A programozás a számítógépek és eszközök utasításokkal való vezérlésének művészete. Egy programozó olyan kódot ír, amely egy számítógép számára érthető, hogy adott feladatokat végezzen el. A programozás alapjainak megértése fontos lépés minden kezdő számára, aki el szeretne mélyedni ebben az izgalmas világban. ----- <span id="mi-a-programozás"></span> ==== '''1. Mi a programozás?''' ==== A programozás során a programozók algoritmusokat és logikai lépéseket írnak le egy programozási nyelv segítségével. A cél, hogy a számítógép ezeket az utasításokat végrehajtsa, és megoldjon egy adott problémát. ----- <span id="alapvető-fogalmak"></span> ==== '''2. Alapvető fogalmak''' ==== * '''Programozási nyelv''': Egy ember által írható, de gép által érthető nyelv. Példák: Python, Java, C++, JavaScript. * '''Kód''': A programozási nyelvben írt utasítások összessége. * '''Algoritmus''': Egy probléma lépésről lépésre történő megoldásának terve. * '''Debugging''': A hibák felkutatása és javítása a kódban. * '''Futtatás (Run)''': A kód végrehajtása a számítógépen. ----- <span id="az-első-lépések"></span> ==== '''3. Az első lépések''' ==== Az első lépés általában egy “Hello, World!” program írása, amely egyszerűen csak kiírja ezt a szöveget a képernyőre. Például Pythonban: <syntaxhighlight lang="python">print("Hello, World!")</syntaxhighlight> Ez a program bemutatja, hogyan működik az alapvető kódszerkezet és a kimenet kezelése. ----- <span id="változók-és-típusok"></span> ==== '''4. Változók és típusok''' ==== A változók az adatok tárolására szolgálnak a programban. Például: <syntaxhighlight lang="python">szam = 5 # Ez egy egész szám nev = "Anna" # Ez egy szöveg</syntaxhighlight> A változóknak típusai vannak, például: - '''Egész számok (int)''': pl. 1, 10, -5 - '''Valós számok (float)''': pl. 3.14, 2.5 - '''Szövegek (string)''': pl. “Hello” - '''Logikai értékek (boolean)''': pl. True, False ----- <span id="feltételes-elágazások"></span> ==== '''5. Feltételes elágazások''' ==== A programok gyakran hoznak döntéseket. Ez a feltételes elágazások segítségével történik. Példa Pythonban: <syntaxhighlight lang="python">kor = 18 if kor >= 18: print("Nagykorú vagy.") else: print("Kiskorú vagy.")</syntaxhighlight> ----- <span id="ciklusok"></span> ==== '''6. Ciklusok''' ==== A ciklusok lehetővé teszik egy művelet többszöri végrehajtását. * '''For ciklus''': <syntaxhighlight lang="python">for i in range(5): print(i) # Kiírja a 0, 1, 2, 3, 4 értékeket</syntaxhighlight> * '''While ciklus''': <syntaxhighlight lang="python">szam = 0 while szam < 5: print(szam) szam += 1</syntaxhighlight> ----- <span id="függvények"></span> ==== '''7. Függvények''' ==== A függvények újrahasználható kódrészek, amelyek adott feladatokat hajtanak végre. Példa Pythonban: <syntaxhighlight lang="python">def osszead(a, b): return a + b eredmeny = osszead(3, 5) print(eredmeny) # 8</syntaxhighlight> ----- <span id="adatszerkezetek"></span> ==== '''8. Adatszerkezetek''' ==== Az adatok rendezett tárolása kulcsfontosságú a programozásban. Az alapvető adatszerkezetek: - '''Lista (list)''': Több értéket tárolhat sorrendben. Pl. <code>[1, 2, 3]</code> - '''Tuple''': Mint a lista, de módosíthatatlan. Pl. <code>(1, 2, 3)</code> - '''Szótár (dictionary)''': Kulcs-érték párokat tárol. Pl. <code>{&quot;nev&quot;: &quot;Anna&quot;, &quot;kor&quot;: 25}</code> ----- <span id="hibakezelés"></span> ==== '''9. Hibakezelés''' ==== A hibák elkerülhetetlenek, de kezelhetők. Példa Pythonban: <syntaxhighlight lang="python">try: osztas = 10 / 0 except ZeroDivisionError: print("Nem lehet nullával osztani.")</syntaxhighlight> ----- <span id="objektumorientált-programozás-oop"></span> ==== '''10. Objektumorientált programozás (OOP)''' ==== Az OOP egy fejlettebb programozási paradigma, amely osztályok és objektumok használatán alapul. Az osztályok sablonként működnek, amelyekkel objektumokat hozhatunk létre. Példa Pythonban: <syntaxhighlight lang="python">class Auto: def __init__(self, marka, sebesseg): self.marka = marka self.sebesseg = sebesseg def gyorsul(self): self.sebesseg += 10 auto = Auto("Toyota", 100) auto.gyorsul() print(auto.sebesseg) # 110</syntaxhighlight> ----- <span id="programozási-nyelvek"></span> ==== '''11. Programozási nyelvek''' ==== Különböző nyelvek különböző célokra alkalmasak: - '''Python''': Egyszerű, kezdőknek ideális. - '''JavaScript''': Webfejlesztésre kiváló. - '''C++''': Teljesítménykritikus alkalmazásokhoz. - '''Java''': Platformfüggetlen, üzleti alkalmazásokhoz. ----- <span id="verziókezelés"></span> ==== '''12. Verziókezelés''' ==== A verziókezelés (pl. Git) segít a kódváltozások nyomon követésében és együttműködésben. ----- <span id="gyakorlás-és-tanulás"></span> ==== '''13. Gyakorlás és tanulás''' ==== A programozás elsajátítása gyakorlást igényel. Hasznos források: - Online kurzusok (pl. Codecademy, freeCodeCamp) - Gyakorló oldalak (pl. LeetCode, HackerRank) - Nyílt forráskódú projektek {{-der-}} * [[programozási]] {{-etim-}} {{suffix|programoz|ás|pos=fn}} {{-ford-}} {{trans-top}} *{{en}}: {{t|en|programming}} *{{fr}}: {{t|fr|programmation}} *{{de}}: {{t|de|Programmierung|f}} *{{it}}: {{t|it|programmazione|f}} *{{ru}}: {{t|ru|программирование }} *{{es}}: {{t|es|programación|f}} {{trans-bottom}} {{-rago-}} {{hu-fn-ok|programozá|s}}{{hu-birt-otok|programozás||ai}} {{hunl}} 6s36h5a2ggd0hlt4mvb0tfc1zray35l 0 57793 3479429 2808385 2024-12-12T17:37:14Z LinguisticMystic 22848 3479429 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika|info|comptheory|algo}} Valamely (matematikai) eljárás, folyamat vagy műveletsor szabatos leírása. {{-etim-}} A perzsa {{w|Muhammad ibn Mūsā al-Khwārizmī|al-Khwārizmī}} ({{m|ar|الخَوَارِزْمِيّ|}} névből. {{Ford}} *{{en}}: {{t|en|algorithm}} *{{da}}: {{t|da|algoritme}} *{{fo}}: {{t|fo|algoritma}} *{{de}}: {{t|de|Al­go­rith­mus|m}} *{{it}}: {{t|it|algoritmo|m}} *{{ru}}: {{t|ru|алгоритм}} *{{ro}}: {{t|ro|algoritm|}} {{Lásd}} *[[euklideszi algoritmus]] {{hunl}} 4rt4e6s045lxt8hn35yoniwmmrlpyj3 3479434 3479429 2024-12-12T17:45:15Z LinguisticMystic 22848 3479434 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika|info|comptheory|algo}} Az algoritmus egy probléma megoldására szolgáló, pontosan meghatározott lépések sorozata, amelyet egy gép (például számítógép) vagy ember követhet. Az algoritmusok az informatika és a matematika alapvető fogalmai közé tartoznak, és kulcsszerepet játszanak a programozásban, valamint a különböző problémák hatékony megoldásában. ----- <span id="algoritmusok-főbb-jellemzői"></span> ==== '''Algoritmusok főbb jellemzői''' ==== # '''Végesség''': Az algoritmus véges számú lépés után befejeződik. # '''Egyértelműség''': Az egyes lépések pontosan meghatározottak és félreérthetetlenek. # '''Bemenet''': Az algoritmus rendelkezhet bemeneti adatokkal, amelyek a probléma kezdeti állapotát reprezentálják. # '''Kimenet''': Az algoritmus legalább egy eredményt (kimenetet) ad vissza. # '''Hatékonyság''': Az algoritmusnak az adott erőforrások (idő és memória) szempontjából optimálisnak kell lennie. ----- <span id="algoritmusok-típusai"></span> === '''Algoritmusok típusai''' === <ol style="list-style-type: decimal;"> <li><p>'''Lineáris algoritmusok'''<br /> Olyan algoritmusok, amelyek egyenes vonalban, lépésről lépésre hajtják végre az utasításokat.<br /> '''Példa''': Egy számokból álló lista elemeinek összege.</p> <syntaxhighlight lang="python">def osszeg(lista): osszeg = 0 for szam in lista: osszeg += szam return osszeg</syntaxhighlight></li> <li><p>'''Elágazó algoritmusok'''<br /> Ezeknél az algoritmusoknál a végrehajtás iránya a feltételek teljesülésétől függ.<br /> '''Példa''': Egy szám pozitív, negatív vagy nulla.</p> <syntaxhighlight lang="python">def szam_tipusa(szam): if szam > 0: return "Pozitív" elif szam < 0: return "Negatív" else: return "Nulla"</syntaxhighlight></li> <li><p>'''Ismétlődő algoritmusok (Iteráció)'''<br /> Egy algoritmus bizonyos lépései ismétlődnek egy adott feltétel teljesüléséig.<br /> '''Példa''': Faktoriális számítása.</p> <syntaxhighlight lang="python">def faktorialis(n): eredmeny = 1 for i in range(1, n + 1): eredmeny *= i return eredmeny</syntaxhighlight></li> <li><p>'''Rekurzív algoritmusok'''<br /> Az algoritmus önmagát hívja meg egy kisebb részprobléma megoldására.<br /> '''Példa''': Fibonacci-számok kiszámítása.</p> <syntaxhighlight lang="python">def fibonacci(n): if n <= 1: return n return fibonacci(n - 1) + fibonacci(n - 2)</syntaxhighlight></li></ol> ----- <span id="algoritmusok-hatékonysága"></span> === '''Algoritmusok hatékonysága''' === Az algoritmusok hatékonyságát az alábbi szempontok alapján értékelhetjük: # '''Időbonyolultság (Time Complexity)''':<br /> Az algoritmus futásához szükséges idő a bemenet méretének függvényében. Az időbonyolultságot gyakran Big-O jelöléssel adjuk meg: #* (O(1)): Konstans idő. #* (O(n)): Lineáris idő. #* (O(n^2)): Négyzetes idő, például a buborékrendezés esetében. #* (O(n)): Logaritmikus idő, például bináris keresésnél. # '''Térbonyolultság (Space Complexity)''':<br /> Az algoritmus által elfoglalt memória mérete a bemenet nagyságának függvényében. ----- <span id="példák-különböző-algoritmusokra"></span> === '''Példák különböző algoritmusokra''' === <span id="rendezési-algoritmusok"></span> ==== 1. '''Rendezési algoritmusok''' ==== Ezek az algoritmusok egy lista elemeinek meghatározott sorrendbe állítására szolgálnak. * '''Buborékrendezés''' (Bubble Sort):<br /> Egyszerű, de nem túl hatékony algoritmus ((O(n^2))).<br /> <code>python def buborek_rendezes(lista): n = len(lista) for i in range(n): for j in range(0, n-i-1): if lista[j] &gt; lista[j+1]: lista[j], lista[j+1] = lista[j+1], lista[j] return lista</code> * '''Gyorsrendezés''' (Quick Sort):<br /> Hatékonyabb rendezési algoritmus ((O(n n)) átlagosan).<br /> <code>python def gyors_rendezes(lista): if len(lista) &lt;= 1: return lista pivot = lista[len(lista) // 2] kisebb = [x for x in lista if x &lt; pivot] egyenlo = [x for x in lista if x == pivot] nagyobb = [x for x in lista if x &gt; pivot] return gyors_rendezes(kisebb) + egyenlo + gyors_rendezes(nagyobb)</code> <span id="keresési-algoritmusok"></span> ==== 2. '''Keresési algoritmusok''' ==== * '''Lineáris keresés'''<br /> Egyszerű, de lassú algoritmus ((O(n))).<br /> <code>python def linearis_kereses(lista, cel): for i, elem in enumerate(lista): if elem == cel: return i return -1</code> * '''Bináris keresés'''<br /> Hatékonyabb, ha a lista rendezett ((O(n))).<br /> <code>python def binaris_kereses(lista, cel): bal, jobb = 0, len(lista) - 1 while bal &lt;= jobb: kozep = (bal + jobb) // 2 if lista[kozep] == cel: return kozep elif lista[kozep] &lt; cel: bal = kozep + 1 else: jobb = kozep - 1 return -1</code> <span id="graf-algoritmusok"></span> ==== 3. '''Graf-algoritmusok''' ==== * '''Dijkstra algoritmus'''<br /> Rövid legútdetektálás egy csúcsról a gráfban.<br /> <code>python import heapq def dijkstra(graf, kezd): tavolsag = {csucs: float('inf') for csucs in graf} tavolsag[kezd] = 0 prioritas_sor = [(0, kezd)] while prioritas_sor: akt_tav, akt_csucs = heapq.heappop(prioritas_sor) if akt_tav &gt; tavolsag[akt_csucs]: continue for szomszed, suly in graf[akt_csucs]: uj_tav = akt_tav + suly if uj_tav &lt; tavolsag[szomszed]: tavolsag[szomszed] = uj_tav heapq.heappush(prioritas_sor, (uj_tav, szomszed)) return tavolsag</code> {{-etim-}} A perzsa {{w|Muhammad ibn Mūsā al-Khwārizmī|al-Khwārizmī}} ({{m|ar|الخَوَارِزْمِيّ|}} névből. {{Ford}} *{{en}}: {{t|en|algorithm}} *{{da}}: {{t|da|algoritme}} *{{fo}}: {{t|fo|algoritma}} *{{de}}: {{t|de|Al­go­rith­mus|m}} *{{it}}: {{t|it|algoritmo|m}} *{{ru}}: {{t|ru|алгоритм}} *{{ro}}: {{t|ro|algoritm|}} {{Lásd}} *[[euklideszi algoritmus]] {{hunl}} 0mey9i07n9zvlxne6q1etc8mc5kxg2z 0 70165 3479384 2808153 2024-12-12T13:31:47Z LinguisticMystic 22848 3479384 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|gráf}} <u>Definíció</u>: Adott egy A [[halmaz]], és egy rajta értelmezett <math>\rho\subseteq A\times A </math> bináris (kétváltozós) [[reláció]]. Ekkor a <math> G=\left( A, \rho \right) </math> párt, vagyis az A halmaz feletti [[reláció]]s [[struktúra|struktúrát]] az A halmaz feletti '''gráf'''nak nevezzük. Megjegyezzük, hogy e definíció szerint a ρ reláció [[rendezett elempár|rendezett elempárokból]] áll, azaz a gráf '''[[irányított gráf|irányított]]''', viszont „többszörös” éleket nem tartalmaz, azaz '''egyszerű'''. Ezen értelmezésen belül az [[irányítatlan gráf]] fogalma úgy értelmezhető, hogy megköveteljük a ρ reláció szimmetriáját, azaz hogy érvényes legyen <math>\forall x,y \in A: (x,y)\in\rho \Leftrightarrow (y,x)\in\rho </math>, és ekkor az irányítatlan gráf az irányított gráf speciális esete. {{-ford-}} *{{en}}: {{t|en|graph}} *{{ru}}: {{t|ru|граф}} [[Kategória: Görög eredetű szavak]] {{hunl}} 2v99qc2p08vt4k731qmhm29phdch6jo 0 90179 3479400 3191182 2024-12-12T14:08:20Z 145.128.173.109 3479400 wikitext text/x-wiki {{hunmsz}} {{-ford-}} {{trans-top|iváskor, koccintáskor}} *{{sq}}: {{t-|sq|gëzuar}} *{{en}}: {{t|en|cheers|}} *{{ar}}: {{t|ar|في صحتك}} {{g|m}}/ {{g|f}} *{{eu}}: [[eskerriska]] *{{br}}: [[yec’hed mat]] *{{bg}}: {{t+|bg|наздраве|tr=nazdrave}} *{{cs}}: {{t-|cs|na zdraví}} *{{da}}: {{t+|da|skål}} *{{eo}}: [[je via sano ]], {{t-|eo|sanon}} *{{et}}: {{t|et|rõõmuhüüded}}, {{t|et|terviseks}} *{{fi}}: {{t+|fi|kippis}} *{{fr}}: {{t+|fr|santé}}, {{t+|fr|à votre santé}}, {{t|fr|tchin tchin}} *{{ka}}: {{t|ka|გაუმარჯოს|tr=gaumarjos}}, {{t|ka|გაგიმარჯოს|tr=gagimarjos}} *{{el}}: [[εις υγείαν]] (eis ygeían), [[στην υγειά…]] (stin ygeiá…), [[’ς υγεία’]] ('s ygeía'), [[γεια μας]] (geia mas) *{{he}}: [[לחיים]] (le'khaim) *{{hi}}: {{t|hi|चीयर्स|tr=chīyars}} *{{nl}}: {{t+|nl|proost}}, {{t+|nl|gezondheid}}, {{t-|nl|santé}}, {{t+|nl|schol}}, {{t-|nl|prut}}, {{t-|nl|cheers}} *{{sh}}: {{t-|sh|uzdravlje}} *{{id}}: {{t-|id|pro}}, {{t-|id|tos}} *{{ga}}: {{t-|ga|sláinte}} *{{is}}: {{t+|is|skál}} *{{ja}}: {{t-|ja|乾杯|tr=かんぱい, kanpai}} *{{ca}}: [[salut]] *{{km}}: {{t|km|សន្តិយុត្ត|tr=sɑnte' yutta'}} *{{zh}}: {{t-|cmn|乾杯}}, {{t-|cmn|干杯|tr=gānbēi}} *{{ko}}: {{t|ko|건배|tr=konbe}} ({{t+|ko|乾杯}}), [[위하여]] (wi ha yo), [[축배]] (chukbae) {{trans-mid}} *{{pl}}: {{t+|pl|na zdrowie}} *{{lv}}: [[uz veselibu]] *{{lt}}: [[į sveikatą]] *{{lb}}: [[prost]] *{{mk}}: {{t|mk|на здравје|tr=na zdrávje}} *{{mt}}: {{t-|mt|saħħa}}, {{t-|mt|evviva}} *{{mn}}: {{t|mn|таны эрүүл мэндийн тѳлѳѳ|tr=tanÿ erüül mendiyn tölöö}} *{{de}}: {{t+|de|prost}}, {{t+|de|servus}}, {{t+|de|zum Wohl}} *{{no}}: {{t+|no|skål}} *{{oc}}: [[Santat]], [[a la vòstra]] *{{it}}: {{t-|it|cin cin}}, {{t-|it|alla salute}}, {{t+|it|salute}} *{{ru}}: {{t|ru|за ваше здоровье|tr=za váše zdoróv'je}}, {{t|ru|за твоё здоровье|tr=za tvojó zdoróv'je}}, {{t|ru|будем здоровы|tr=búdem zdoróvy}}, {{t|ru|ваше здоровье|tr=váše zdoróv'je}}; {{t|ru|пей до дна|tr=pej do dná}} *{{hy}}: {{t-|hy|կենացդ|tr=kenac’d}} *{{fa}}: [[به سلامتی]] *{{pt}}: {{t+|pt|saúde}}, {{t|pt|tim tim}} *{{ro}}: [[noroc]]!, {{t|ro|sănătate|alt=sănătate!}} *{{rm}}: {{t|rm|viva}} *{{gd}}: {{t-|gd|slàinte}} *{{es}}: {{t+|es|salud}} *{{sv}}: {{t+|sv|skål}} *{{sh}}: {{t|sh|zivio ziveli}}, {{t|sh|ziveli}} *{{sk}}: {{t-|sk|na zdravie}} *{{sl}}: [[na zdravje]] *{{sw}}: [[maisha marefu]], [[afya]], [[vifijo]] *{{th}}: {{t|th|ไชโย}} *{{tr}}: {{t+|tr|şerefe}} *{{uk}}: {{t|uk|будьмо|tr=budʼmo}} *{{vi}}: [[sự cạn ly, nâng cốc chúc mừng]] *{{cy}}: {{t-|cy|iechyd da}} {{trans-bottom}} {{trans-top|tüsszentéskor}} *{{pl}}: {{t|pl|na zdrowie}} {{trans-mid}} {{trans-bottom}} {{-lásd-}} * [[egészségére]]! {{-etim-}} {{suffix|egészség|ed|re|pos=fn|nocat=y}} {{hunl}} jlmubgq7wsop907lqg06iv26gtbqcae 0 177897 3479430 2808192 2024-12-12T17:37:28Z LinguisticMystic 22848 3479430 wikitext text/x-wiki {{hunfn|fej=[[euklideszi]] [[algoritmus]]}} # {{label|hu|matematika|algo}} Módszer két különböző szám [[legnagyobb közös osztó]]jának megtalálására. ## Osszuk el maradékosan a nagyobbik számot a másik számmal. ## Ha a maradék 0, akkor a legnagyobb közös osztó éppen a kisebbik szám. ##Ha a maradék nullától különböző, akkor a keresett legnagyobb közös osztó megegyezik a maradék és a kisebb szám legnagyobb közös osztójával, ezért megismételhetjük az első lépést erre a két számra. {{-ford-}} *{{en}}: {{t|en|Euclidean algorithm}}, {{t|en|Euclid's algorithm}} *{{ru}}: {{t|ru|алгоритм Евклида}} *{{es}}: {{t|es|algoritmo de Euclides}} {{hunl}} dke5hudmhdbsw1on1cjnzwdjumgcqwg 3479433 3479430 2024-12-12T17:40:41Z LinguisticMystic 22848 3479433 wikitext text/x-wiki {{hunfn|fej=[[euklideszi]] [[algoritmus]]}} # {{label|hu|matematika|algo}} Módszer két különböző szám [[legnagyobb közös osztó]]jának megtalálására. ## Osszuk el maradékosan a nagyobbik számot a másik számmal. ## Ha a maradék 0, akkor a legnagyobb közös osztó éppen a kisebbik szám. ##Ha a maradék nullától különböző, akkor a keresett legnagyobb közös osztó megegyezik a maradék és a kisebb szám legnagyobb közös osztójával, ezért megismételhetjük az első lépést erre a két számra. ---- <span id="euklideszi-algoritmus-bemutatása"></span> === '''Euklideszi algoritmus bemutatása''' === Az '''Euklideszi algoritmus''' az egyik legrégebbi, mégis rendkívül hatékony algoritmus a legnagyobb közös osztó ('''LNKO''', angolul GCD) meghatározására két szám között. Az algoritmus az osztási maradék ismételt alkalmazásán alapul: a két szám legnagyobb közös osztója megegyezik a kisebb szám és az osztási maradék legnagyobb közös osztójával. ----- <span id="elmélet"></span> === '''Elmélet''' === Az algoritmus logikája: 1. Vegyünk két számot, (a) és (b), ahol (a b). 2. Osszuk el (a)-t (b)-vel, és határozzuk meg az osztási maradékot ((r)). 3. Az új számok: (a b), (b r). 4. Addig ismételjük, amíg (b = 0). Ekkor (a) a legnagyobb közös osztó. '''Példa működésre''': - (a = 48), (b = 18): - (48 = 2) maradék (12), - (a = 18), (b = 12), - (18 = 1) maradék (6), - (a = 12), (b = 6), - (12 = 2) maradék (0), - '''LNKO = 6'''. '''Időkomplexitás''': - Az algoritmus hatékonysága (O(((a, b)))), mivel minden iterációban a kisebbik szám legalább felére csökken. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>Euklideszi(a, b): amíg b ≠ 0: r = a % b a = b b = r visszatér a</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def gcd(a, b): while b != 0: a, b = b, a % b return a # Példa print(gcd(48, 18)) # Kimenet: 6</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> using namespace std; int gcd(int a, int b) { while (b != 0) { int r = a % b; a = b; b = r; } return a; } int main() { cout << gcd(48, 18) << endl; // Kimenet: 6 return 0; }</syntaxhighlight> ----- <span id="kiterjesztett-euklideszi-algoritmus"></span> === '''Kiterjesztett Euklideszi algoritmus''' === A kiterjesztett változat nemcsak az LNKO-t határozza meg, hanem két egész számot, (x)-et és (y)-t is, amelyek kielégítik az alábbi összefüggést: [ a x + b y = (a, b) ]. <span id="pszeudokód-a-kiterjesztett-verzióhoz"></span> ==== '''Pszeudokód a kiterjesztett verzióhoz''' ==== <pre>KiterjesztettEuklideszi(a, b): ha b = 0: visszatér (a, 1, 0) (gcd, x1, y1) = KiterjesztettEuklideszi(b, a % b) x = y1 y = x1 - (a // b) * y1 visszatér (gcd, x, y)</pre> <span id="python-implementáció-kiterjesztett-változat"></span> ==== '''Python implementáció (kiterjesztett változat)''' ==== <syntaxhighlight lang="python">def extended_gcd(a, b): if b == 0: return a, 1, 0 gcd, x1, y1 = extended_gcd(b, a % b) x = y1 y = x1 - (a // b) * y1 return gcd, x, y # Példa g, x, y = extended_gcd(48, 18) print(f"GCD: {g}, x: {x}, y: {y}") # Kimenet: GCD: 6, x: -1, y: 3</syntaxhighlight> ----- <span id="összegzés"></span> === '''Összegzés''' === Az Euklideszi algoritmus és annak kiterjesztett változata alapvető matematikai eszközök, amelyek hatékonyan számolják a legnagyobb közös osztót, illetve annak lineáris kombinációját. Pythonban és C++-ban egyszerűen implementálható, és széles körben használják a számelmélet, kriptográfia és algoritmusok területén. {{-ford-}} *{{en}}: {{t|en|Euclidean algorithm}}, {{t|en|Euclid's algorithm}} *{{ru}}: {{t|ru|алгоритм Евклида}} *{{es}}: {{t|es|algoritmo de Euclides}} {{hunl}} 8gz7xld4p1r0xapfg76o01zq63pscji 0 177997 3479399 2723268 2024-12-12T14:07:03Z LinguisticMystic 22848 3479399 wikitext text/x-wiki {{hunfn|fej=[[racionális]] [[szám]]}} # {{matematika|lang=hu}} Az <math>\dfrac{a}{b}</math> alakú számokat, ahol <math>a</math> és <math>b \in \mathbb{Z}</math> és <math>b \neq 0</math> '''racionális számoknak''' nevezzük. A racionális számok tehát olyan számok, melyek felírhatók két [[egész szám]] [[hányados|hányadosaként]]. A racionális számok halmazát <math>\mathbb{Q}</math>-val jelöljük. {{hunsyn}} * [[törtszám]] {{-ford-}} *{{en}}: {{t|en|rational number}} *{{cs}}: {{t|cs|racionální číslo|n}} *{{fi}}: {{t|fi|rationaaliluku}} *{{fr}}: {{t|fr|nombre rationnel|m}} *{{sh}}: {{t|sh|racionalni broj}} *{{de}}: {{t|de|rationale Zahl|f}} *{{ru}}: {{t|ru|рациональное число|n}} *{{ro}}: {{t|ro|număr rațional|n}} {{hunl}} 9cyr882e4nalzi2dhfztjd1a8dvto8c 0 178028 3479414 2808695 2024-12-12T17:10:10Z LinguisticMystic 22848 3479414 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika|lineáris algebra}} A '''lineáris algebra''' a [[matematika]] (konkrétan az [[algebra]]) egyik [[tudomány]]ága, mely jelentős [[geometria]]i, [[fizika]]i és [[mérnöki tudomány|mérnöki]] alkalmazásokkal rendelkezik (sőt, születtek próbálkozások még a társadalomtudományokban való alkalmazására is (pl.: a modern közgazdaságtudomány elképzelhetetlen lenne lineáris algebra nélkül). Tárgya a [[vektor]]ok, [[vektortér|vektorterek]] vagy lineáris terek, és [[lineáris leképezés]]ek (a vektorterek [[homomorfizmus]]ainak) vizsgálata. *{{en}}: {{t|en|linear algebra }} *{{fr}}: {{t|fr|algèbre linéaire}} *{{de}}: {{t|de|lineare Algebra|f}} *{{ru}}: {{t|ru|линейная алгебра}} *{{ro}}: {{t|ro|algebră liniară}} {{hunl}} 5tupmusvhy3lyreh0xjhbgt2p4xj5uv 3479418 3479414 2024-12-12T17:23:14Z LinguisticMystic 22848 3479418 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika|lineáris algebra}} A '''lineáris algebra''' a [[matematika]] (konkrétan az [[algebra]]) egyik [[tudomány]]ága, mely jelentős [[geometria]]i, [[fizika]]i és [[mérnöki tudomány|mérnöki]] alkalmazásokkal rendelkezik (sőt, születtek próbálkozások még a társadalomtudományokban való alkalmazására is (pl.: a modern közgazdaságtudomány elképzelhetetlen lenne lineáris algebra nélkül). Tárgya a [[vektor]]ok, [[vektortér|vektorterek]] vagy lineáris terek, és [[lineáris leképezés]]ek (a vektorterek [[homomorfizmus]]ainak) vizsgálata. ---- A lineáris algebra a matematika egy ága, amely vektorokkal, vektorterekkel, mátrixokkal és lineáris transzformációkkal foglalkozik. Kulcsszerepet játszik a tudomány, a mérnöki tudományok, a gazdaságtan és sok más területen. === Alapfogalmak === ==== Vektorok ==== A vektor egy olyan matematikai objektum, amelyet általában nagysággal és iránnyal jellemeznek. Algebrai szempontból a vektor egy n-dimenziós valósz vagy komplex számokkal rendelkezo rendezett halmaz: :<math>\mathbf{v} = (v_1, v_2, \dots, v_n)</math> ==== Vektorterek ==== A vektortér egy olyan halmaz, amelyben a vektorok összeadása és skalárral való szorzása van értelmezve, és ezek kielégítik az alábbi axiomákat: * Kommutativitás: <math>\mathbf{u} + \mathbf{v} = \mathbf{v} + \mathbf{u}</math> * Asszociativitás: <math>(\mathbf{u} + \mathbf{v}) + \mathbf{w} = \mathbf{u} + (\mathbf{v} + \mathbf{w})</math> * Nullvektor létezése: Létezik olyan <math>\mathbf{0}</math>, hogy <math>\mathbf{v} + \mathbf{0} = \mathbf{v}</math> * Invertálhatóság: Létezik olyan <math>-\mathbf{v}</math>, hogy <math>\mathbf{v} + (-\mathbf{v}) = \mathbf{0}</math> * Skaláris szorzás disztributivitása: <math>a(\mathbf{u} + \mathbf{v}) = a\mathbf{u} + a\mathbf{v}</math> ==== Mátrixok ==== A mátrix egy olyan téglalap alakú számelrendezés, amely sorokból és oszlopokból áll: :<math>A = \begin{bmatrix} a_{11} & a_{12} & \cdots & a_{1n} \\ a_{21} & a_{22} & \cdots & a_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{m1} & a_{m2} & \cdots & a_{mn} \end{bmatrix}</math> A mátrixokat gyakran használják lineáris egyenletrendszerek megoldására és lineáris transzformációk reprezentálására. ==== Lineáris transzformációk ==== A lineáris transzformáció egy olyan leképezés, amely kielégíti az alábbi tulajdonságokat: * Additivitás: <math>T(\mathbf{u} + \mathbf{v}) = T(\mathbf{u}) + T(\mathbf{v})</math> * Homogenitás: <math>T(a\mathbf{v}) = aT(\mathbf{v})</math> === Fontos tételek === ==== Gauss-elimináció ==== A Gauss-elimináció módszere a lineáris egyenletrendszerek megoldására szolgál. A lépései: 1. Az egyenletrendszert mátrix formába írjuk. 2. Sorműveletekkel felső háromszög alakú mátrixot kapunk. 3. Visszahelyettesítéssel meghatározzuk az ismeretleneket. ==== Determináns ==== A determináns egy négyzetes mátrixhoz rendelt szám, amelynek fontos szerepe van a mátrix invertálhatóságának eldöntésében. Egy 2x2-es mátrix esetén: :<math>\det\begin{bmatrix} a & b \\ c & d \end{bmatrix} = ad - bc</math> ==== Eigenértékek és eigenvektorok ==== Egy mátrix eigenértékei és eigenvektorai olyan <math>\lambda</math> és <math>\mathbf{v}</math>, amelyek kielégítik az alábbi egyenletet: :<math>A\mathbf{v} = \lambda\mathbf{v}</math> === Alkalmazások === * Fizika: pl. kvantummechanika (Schrödinger-egyenlet). * Gépi tanulás: adathalmazok feldolgozása, főkomponens-analízis (PCA). * Számítástechnika: 3D grafika és transzformációk. * Gazdaságtan: input-output modellek elemzése. *{{en}}: {{t|en|linear algebra }} *{{fr}}: {{t|fr|algèbre linéaire}} *{{de}}: {{t|de|lineare Algebra|f}} *{{ru}}: {{t|ru|линейная алгебра}} *{{ro}}: {{t|ro|algebră liniară}} {{hunl}} tvkbq57bvgvfir6tqokamk10rcx5hhe 0 178891 3479403 2736736 2024-12-12T14:14:23Z LinguisticMystic 22848 3479403 wikitext text/x-wiki {{hunfn}} # {{matematika|lang=hu}} Két [[halmaz]] metszete a két halmaz közös része, vagyis az olyan [[elem]]ek halmaza, amelyek mindkét halmazban benne vannak. Síkgeometria esetén például két nem párhuzamos [[egyenes]] metszete vagy egy [[pont]], vagy egy egyenes (ha a két egyenes egybeesik). {{-der-}} * {{összetételek}}: [[acélmetszet]] {{-etim-}} {{suffix|metsz|et|pos=fn}} {{-ford-}} *{{en}}: {{t|en|intersection}} *{{de}}: {{t|de|Schnitt|m}}, {{t|de|Stich|m}} *{{ru}}: {{t|ru|пересечение}} {{Lásd}} * [[halmazok metszete]] {{hunl}} o8rt58ycj266szi35r9apot9dfevug8 0 179075 3479419 3190067 2024-12-12T17:25:20Z LinguisticMystic 22848 3479419 wikitext text/x-wiki {{hunfn}} # {{matematika|lang=hu}} A [[diszkrét]] szó a matematikában a folytonos ellentéte. Olyan dolgok diszkrétek, amelyek nincsenek egymáshoz tetszőlegesen közel, hanem „hézagok” vannak közöttük. Például a valós számok folytonosan töltik ki a számegyenest, ellenben az egész számok diszkréten helyezkednek el. A diszkrét matematikához szokták sorolni a kombinatorikát és [[gráfelmélet]]et. ---- A diszkrét matematika a matematika egy olyan területe, amely az olyan struktúraival foglalkozik, amelyek nem folytonosak. Ide tartoznak a halmazelélet, gráfelmélet, kombinatorika, logika és algoritmusok. === Alapfogalmak === ==== Halmazelélet ==== A halmazelélet a matematika alapjait képezi, és halmazokkal, azok műveleteivel foglalkozik. * Halmaz: Egy objektumokból álló csoport, például <math>A = \{1, 2, 3\}</math>. * Műveletek: * Unio: <math>A \cup B</math> * Metszet: <math>A \cap B</math> * Különbség: <math>A \setminus B</math> * Komplementer: <math>A^c</math> ==== Logika ==== A logika a formális érvelés szabályaival foglalkozik. * Logikai műveletek: * És (<math>\land</math>) * Vagy (<math>\lor</math>) * Negáció (<math>\neg</math>) * Igazságtáblák: Az és és vagy műveletek kombinációinak igazságértékét mutatják. ==== Kombinatorika ==== A kombinatorika a halmazok részelemeivel és azok kombinációival foglalkozik. * Permutációk: Az elemek sorrendjének összes lehetséges variációja. <math>P(n) = n!</math> * Kombinációk: Az elemek sorrend nélküli kiválasztása. <math>C(n, k) = \frac{n!}{k!(n-k)!}</math> * Binomiális tétel: <math>(a + b)^n = \sum_{k=0}^n C(n, k) a^{n-k} b^k</math> ==== Gráfelmélet ==== A gráfelmélet a csúcsokból és élekből álló struktúrákkal foglalkozik. * Gráf: <math>G = (V, E)</math>, ahol <math>V</math> a csúcsok halmaza, <math>E</math> pedig az élek halmaza. * Gráf típusai: * Irányított gráf * Irányítatlan gráf * Súlyozott gráf * Euler-kör: Egy olyan kör, amely minden élet pontosan egyszer tartalmaz. * Hamilton-kör: Egy olyan kör, amely minden csúcspontot pontosan egyszer tartalmaz. ==== Algoritmusok ==== Az algoritmus egy lépésről lépésre történő utasításhalmaz, amely egy adott probléma megoldására szolgál. * Időbonyolultság: Egy algoritmus futási idejének mérése a bemenet méretének függvényében. * Térbonyolultság: Az algoritmus által használt memória mérése. * Híres algoritmusok: * Dijkstra algoritmus: legrövidebb út keresése * Prím algoritmus: minimális feszítő fa keresése === Fontos tételek === ==== Pigeonhole-elv ==== Ha <math>n</math> tárgyat <math>k</math> rekeszbe helyezünk és <math>n > k</math>, akkor legalább egy rekeszbe több mint egy tárgy kerül. ==== Ramsey-tétel ==== A Ramsey-tétel szerint egy elég nagy gráfban mindig találhatóak bizonyos észerű módon definiált struktúrák, például teljes algráfok. === Alkalmazások === * Számítástechnika: adatszerkezetek, titkosítási algoritmusok. * Hálózatelmélet: Internet protokollok, szociális hálózatok elemzése. * Kódelmélet: hibajavító kódok tervezése. * Kombinatorikus optimalizálás: pl. utazó ügynök probléma. {{-ford-}} *{{en}}: {{t|en|discrete mathematics}} *{{fr}}: {{t|fr|mathématiques discrètes}} *{{de}}: {{t|de|diskrete Mathematik}} *{{ru}}: {{t|ru|дискретная математика}} [[Kategória:hu:Diszkrét matematika]] {{hunl}} 5g2g6eosoknkymfw44scyya5vthkz7h 3479420 3479419 2024-12-12T17:25:49Z LinguisticMystic 22848 3479420 wikitext text/x-wiki {{hunfn}} # {{matematika|lang=hu}} A [[diszkrét]] szó a matematikában a folytonos ellentéte. Olyan dolgok diszkrétek, amelyek nincsenek egymáshoz tetszőlegesen közel, hanem „hézagok” vannak közöttük. Például a valós számok folytonosan töltik ki a számegyenest, ellenben az egész számok diszkréten helyezkednek el. A diszkrét matematikához szokták sorolni a kombinatorikát és [[gráfelmélet]]et. ---- A diszkrét matematika a matematika egy olyan területe, amely az olyan struktúraival foglalkozik, amelyek nem folytonosak. Ide tartoznak a halmazelélet, gráfelmélet, kombinatorika, logika és algoritmusok. === Alapfogalmak === ==== Halmazelélet ==== A halmazelélet a matematika alapjait képezi, és halmazokkal, azok műveleteivel foglalkozik. * Halmaz: Egy objektumokból álló csoport, például <math>A = \{1, 2, 3\}</math>. * Műveletek: ** Unio: <math>A \cup B</math> ** Metszet: <math>A \cap B</math> ** Különbség: <math>A \setminus B</math> ** Komplementer: <math>A^c</math> ==== Logika ==== A logika a formális érvelés szabályaival foglalkozik. * Logikai műveletek: ** És (<math>\land</math>) ** Vagy (<math>\lor</math>) ** Negáció (<math>\neg</math>) * Igazságtáblák: Az és és vagy műveletek kombinációinak igazságértékét mutatják. ==== Kombinatorika ==== A kombinatorika a halmazok részelemeivel és azok kombinációival foglalkozik. * Permutációk: Az elemek sorrendjének összes lehetséges variációja. <math>P(n) = n!</math> * Kombinációk: Az elemek sorrend nélküli kiválasztása. <math>C(n, k) = \frac{n!}{k!(n-k)!}</math> * Binomiális tétel: <math>(a + b)^n = \sum_{k=0}^n C(n, k) a^{n-k} b^k</math> ==== Gráfelmélet ==== A gráfelmélet a csúcsokból és élekből álló struktúrákkal foglalkozik. * Gráf: <math>G = (V, E)</math>, ahol <math>V</math> a csúcsok halmaza, <math>E</math> pedig az élek halmaza. * Gráf típusai: ** Irányított gráf ** Irányítatlan gráf ** Súlyozott gráf * Euler-kör: Egy olyan kör, amely minden élet pontosan egyszer tartalmaz. * Hamilton-kör: Egy olyan kör, amely minden csúcspontot pontosan egyszer tartalmaz. ==== Algoritmusok ==== Az algoritmus egy lépésről lépésre történő utasításhalmaz, amely egy adott probléma megoldására szolgál. * Időbonyolultság: Egy algoritmus futási idejének mérése a bemenet méretének függvényében. * Térbonyolultság: Az algoritmus által használt memória mérése. * Híres algoritmusok: ** Dijkstra algoritmus: legrövidebb út keresése ** Prím algoritmus: minimális feszítő fa keresése === Fontos tételek === ==== Pigeonhole-elv ==== Ha <math>n</math> tárgyat <math>k</math> rekeszbe helyezünk és <math>n > k</math>, akkor legalább egy rekeszbe több mint egy tárgy kerül. ==== Ramsey-tétel ==== A Ramsey-tétel szerint egy elég nagy gráfban mindig találhatóak bizonyos észerű módon definiált struktúrák, például teljes algráfok. === Alkalmazások === * Számítástechnika: adatszerkezetek, titkosítási algoritmusok. * Hálózatelmélet: Internet protokollok, szociális hálózatok elemzése. * Kódelmélet: hibajavító kódok tervezése. * Kombinatorikus optimalizálás: pl. utazó ügynök probléma. {{-ford-}} *{{en}}: {{t|en|discrete mathematics}} *{{fr}}: {{t|fr|mathématiques discrètes}} *{{de}}: {{t|de|diskrete Mathematik}} *{{ru}}: {{t|ru|дискретная математика}} [[Kategória:hu:Diszkrét matematika]] {{hunl}} 14po6c10ud1tgk8dpjwk1y9c63h6del 828 412003 3479607 3467765 2024-12-13T00:07:42Z LinguisticMystic 22848 3479607 Scribunto text/plain local aliases = {} local deprecated = {} local labels = {} aliases["ML"] = "machine learning" aliases["people"] = "mathematicians" aliases["ppl"] = "mathematicians" aliases["anal"] = "mathematical analysis" aliases["analízis"] = "mathematical analysis" aliases["stat"] = "statistics" aliases["ékszerészet"] = "jewelry" aliases["ékszer"] = "jewelry" aliases["bélyeg"] = "philately" aliases["bélyeggyűjtés"] = "philately" aliases["szerszám"] = "tools" aliases["opkut"] = "operations research" aliases["algoritmus"] = "algorithm" aliases["algo"] = "algorithm" aliases["alg"] = "algorithm" aliases["fa"] = "trees" aliases["geom"] = "geometry" aliases["kombinatorika"] = "combinatorics" aliases["komb"] = "combinatorics" aliases["LA"] = "linear algebra" aliases["linalg"] = "linear algebra" aliases["absalg"] = "abstract algebra" aliases["absztrakt algebra"] = "abstract algebra" aliases["halmaz"] = "set theory" aliases["sets"] = "set theory" aliases["számelmélet"] = "number theory" aliases["numtheory"] = "number theory" aliases["topológia"] = "topology" aliases["graph"] = "graph theory" aliases["gráf"] = "graph theory" aliases["játékelmélet"] = "game theory" aliases["hinduizmus"] = "Hinduism" aliases["buddhizmus"] = "Buddhism" aliases["dzsainizmus"] = "Jainism" aliases["nemzetiség"] = "nationality" aliases["évszak"] = "season" aliases["évszakok"] = "season" aliases["nationalities"] = "nationality" aliases["sajtónyelvi"] = "journalistic" aliases["nyelvek"] = "languages" aliases["nyelv"] = "languages" aliases["művészettörténet"] = "art history" aliases["iskola"] = "education" aliases["jogtudomány"] = "law" aliases["biblia"] = "biblical" aliases["Biblia"] = "biblical" aliases["színművészet"] = "acting" aliases["ország"] = "country" aliases["országok"] = "country" aliases["biok"] = "biochemistry" aliases["advertising"] = "advertising" aliases["aeronautika"] = "aeronautics" aliases["aerospace"] = "aerospace" aliases["mezőgazdaság"] = "agriculture" aliases["aircraft"] = "aircraft" aliases["akusztika"] = "acoustics" aliases["alkímia"] = "alchemy" aliases["alcoholic beverages"] = "alcoholic beverages" aliases["algebra"] = "algebra" aliases["algebraic geometry"] = "algebraic geometry" aliases["alternative medicine"] = "alternative medicine" aliases["amateur radio"] = "amateur radio" aliases["amino acid"] = "amino acid" aliases["analysis"] = "mathematical analysis" aliases["analytic geometry"] = "analytic geometry" aliases["analytical chemistry"] = "analytical chemistry" aliases["anarchism"] = "anarchism" aliases["anat"] = "anatomy" aliases["anatómia"] = "anatomy" aliases["angling"] = "fishing" aliases["animation"] = "animation" aliases["anime"] = "anime" aliases["antropológia"] = "anthropology" aliases["antr"] = "anthropology" aliases["arachnology"] = "arachnology" aliases["régészet"] = "archaeology" aliases["archery"] = "archery" aliases["architectural element"] = "architecture" aliases["architectural elements"] = "architecture" aliases["építészet"] = "architecture" aliases["arithmetic"] = "arithmetic" aliases["művészet"] = "art" aliases["artificial intelligence"] = "artificial intelligence" aliases["AI"] = "artificial intelligence" aliases["MI"] = "artificial intelligence" aliases["arts"] = "art" aliases["asana"] = "yoga pose" aliases["association football"] = "soccer" aliases["asterism"] = "asterism" aliases["astrology"] = "astrology" aliases["astronautics"] = "astronautics" aliases["csillagászat"] = "astronomy" aliases["astrophysics"] = "astrophysics" aliases["aszana"] = "yoga pose" aliases["athletics"] = "athletics" aliases["aut"] = "automation" aliases["automotive"] = "gépjármű" aliases["automotives"] = "gépjármű" aliases["aviation"] = "aviation" aliases["backgammon"] = "backgammon" aliases["bacteria"] = "bacteriology" aliases["bacteriology"] = "bacteriology" aliases["baking"] = "baking" aliases["ball games"] = "ball games" aliases["ballet"] = "ballet" aliases["banking"] = "banking" aliases["baraminology"] = "creationism" aliases["baseball"] = "baseball" aliases["basketball"] = "basketball" aliases["beekeeping"] = "beekeeping" aliases["beer"] = "beer" aliases["betegség"] = "disease" aliases["betegségek"] = "disease" aliases["betting"] = "betting" aliases["bibl"] = "biblical" aliases["biblical character"] = "biblical character" aliases["biblical figure"] = "biblical character" aliases["biblical"] = "biblical" aliases["billiards"] = "billiards" aliases["bingo"] = "bingo" aliases["biokémia"] = "biochemistry" aliases["biol"] = "biology" aliases["biol"] = "biology" aliases["biológia"] = "biology" aliases["biotechnology"] = "biotechnology" aliases["birdwatching"] = "birdwatching" aliases["blogging"] = "blogging" aliases["board game"] = "board games" aliases["board games"] = "board games" aliases["board sports"] = "board sports" aliases["bodybuilding"] = "bodybuilding" aliases["book of the bible"] = "book of the bible" aliases["növénytan"] = "botany" aliases["bowling"] = "bowling" aliases["boxing"] = "boxing" aliases["brewing"] = "brewing" aliases["bridge"] = "bridge" aliases["broadcasting"] = "broadcasting" aliases["bryology"] = "bryology" aliases["bullfighting"] = "bullfighting" aliases["business"] = "business" aliases["bány"] = "mining" aliases["bőr"] = "leatherwork" aliases["calculus"] = "mathematical analysis" aliases["calligraphy"] = "calligraphy" aliases["canid"] = "canid" aliases["canoeing"] = "canoeing" aliases["capitalism"] = "capitalism" aliases["carbohydrate"] = "carbohydrate" aliases["kártya"] = "card games" aliases["cardiology"] = "cardiology" aliases["cards"] = "card games" aliases["carpentry"] = "carpentry" aliases["cartography"] = "cartography" aliases["cartomancy"] = "cartomancy" aliases["cat"] = "felid" aliases["category theory"] = "category theory" aliases["caving"] = "caving" aliases["cell phone"] = "mobile phones" aliases["cell phones"] = "mobile phones" aliases["ceramics"] = "ceramics" aliases["kémiai elem"] = "chemical element" aliases["kémiai elemek"] = "chemical element" aliases["chemical engineering"] = "chemical engineering" aliases["sakk"] = "chess" aliases["kereszténység"] = "Christianity" aliases["kereskedelem"] = "trading" aliases["cinema"] = "film" aliases["cinematography"] = "film" aliases["cladistics"] = "cladistics" aliases["classical mechanics"] = "classical mechanics" aliases["classical studies"] = "classical studies" aliases["climatology"] = "climatology" aliases["climbing"] = "climbing" aliases["clinical psychology"] = "clinical psychology" aliases["ruházat"] = "clothing" aliases["ruha"] = "clothing" aliases["coenzyme"] = "coenzyme" aliases["color"] = "color" aliases["colour"] = "color" aliases["combinatorics"] = "combinatorics" aliases["comedy"] = "comedy" aliases["comics"] = "comics" aliases["commercial law"] = "commercial law" aliases["communication"] = "communication" aliases["communications"] = "communication" aliases["communism"] = "communism" aliases["comp sci"] = "computer science" aliases["compilation"] = "compilation" aliases["complex analysis"] = "complex analysis" aliases["comptheory"] = "computing theory" aliases["computational linguistics"] = "computational linguistics" aliases["computer games"] = "computer games" aliases["computer graphics"] = "computer graphics" aliases["computer hardware"] = "computer hardware" aliases["computer language"] = "computer languages" aliases["computer languages"] = "computer languages" aliases["computer programming"] = "programming" aliases["computer science"] = "computer science" aliases["computer security"] = "computer security" aliases["computer"] = "computing" aliases["computers"] = "computing" aliases["computers"] = "computing" aliases["számításelmélet"] = "computing theory" aliases["computing"] = "computing" aliases["conchology"] = "conchology" aliases["constellation"] = "constellation" aliases["construction"] = "construction" aliases["cookery"] = "cooking" aliases["cookware"] = "cookware" aliases["copyright"] = "copyright" aliases["coral science"] = "marine biology" aliases["cosmetics"] = "cosmetics" aliases["cosmetology"] = "cosmetics" aliases["creationism"] = "creationism" aliases["cribbage"] = "cribbage" aliases["cricket"] = "cricket" aliases["crime"] = "crime" aliases["criminal law"] = "criminal law" aliases["criminology"] = "criminology" aliases["cryptography"] = "cryptography" aliases["cryptoállattan"] = "cryptoállattan" aliases["crystallography"] = "crystallography" aliases["csill"] = "astronomy" aliases["cuisine"] = "cooking" aliases["culinary"] = "cooking" aliases["cultural anthropology"] = "cultural anthropology" aliases["curling"] = "curling" aliases["currency"] = "numismatics" aliases["cybernetics"] = "cybernetics" aliases["cycle racing"] = "cycle racing" aliases["cycling"] = "cycling" aliases["cytology"] = "cytology" aliases["cégvezetés"] = "management" aliases["cím"] = "heraldry" aliases["táncművészet"] = "dance" aliases["darts"] = "darts" aliases["data management"] = "data management" aliases["data modeling"] = "data modeling" aliases["database"] = "databases" aliases["databases"] = "databases" aliases["deltiology"] = "deltiology" aliases["demography"] = "demography" aliases["demonym"] = "demonym" aliases["demoscene"] = "demoscene" aliases["dentistry"] = "dentistry" aliases["dermatology"] = "dermatology" aliases["design"] = "design" aliases["dice games"] = "dice games" aliases["dice"] = "dice games" aliases["dictation"] = "dictation" aliases["diplomacy"] = "diplomacy" aliases["disc golf"] = "disc golf" aliases["diseases"] = "disease" aliases["divination"] = "divination" aliases["diving"] = "diving" aliases["dominoes"] = "dominoes" aliases["drama"] = "drama" aliases["dressage"] = "dressage" aliases["durva"] = "vulgarism" aliases["earth science"] = "earth science" aliases["ecclesiastical"] = "ecclesiastical" aliases["ökológia"] = "ecology" aliases["környezettan"] = "ecology" aliases["közgazdaságtan"] = "economics" aliases["oktatásügy"] = "education" aliases["el"] = "electronics" aliases["electrencephalography"] = "electrencephalography" aliases["electrical engineering"] = "electrical engineering" aliases["electricity"] = "electricity" aliases["electrodynamics"] = "electrodynamics" aliases["electromagnetism"] = "electromagnetism" aliases["elektronika"] = "electronics" aliases["element symbol"] = "element symbol" aliases["embryology"] = "embryology" aliases["emergency medicine"] = "emergency medicine" aliases["emergency"] = "emergency medicine" aliases["endocrinology"] = "endocrinology" aliases["engineering"] = "engineering" aliases["enterprise engineering"] = "enterprise engineering" aliases["rovartan"] = "entomology" aliases["enzim"] = "enzyme" aliases["enzimek"] = "enzyme" aliases["epidemiology"] = "epidemiology" aliases["epidemiológia"] = "epidemiology" aliases["epistemology"] = "epistemology" aliases["equestrianism"] = "equestrianism" aliases["espionage"] = "espionage" aliases["etika"] = "ethics" aliases["néprajz"] = "ethnography" aliases["euf"] = "euphemistic" aliases["evolutionary theory"] = "evolutionary theory" aliases["exercise"] = "exercise" aliases["falconry"] = "falconry" aliases["fantasy"] = "fantasy" aliases["divat"] = "fashion" aliases["fatty acid"] = "fatty acid" aliases["fazekasság"] = "pottery" aliases["fehérje"] = "protein" aliases["fehérjék"] = "protein" aliases["felid"] = "felid" aliases["feminizmus"] = "feminism" aliases["fencing"] = "fencing" aliases["fiction"] = "fiction" aliases["fictional character"] = "fictional character" aliases["field hockey"] = "field hockey" aliases["figure of speech"] = "figure of speech" aliases["figure skating"] = "figure skating" aliases["fil"] = "philosophy" aliases["film genre"] = "film genre" aliases["filmművészet"] = "film" aliases["filmology"] = "film" aliases["pénzügy"] = "finance" aliases["firearm mechanism"] = "Gun mechanisms" aliases["firearm mechanisms"] = "Gun mechanisms" aliases["firearm"] = "firearms" aliases["firearms"] = "firearms" aliases["firefighting"] = "firefighting" aliases["fish"] = "fish" aliases["halászat"] = "fishing" aliases["fiz"] = "physics" aliases["fizika"] = "physics" aliases["fizikai kémia"] = "physical chemistry" aliases["fluid dynamics"] = "fluid dynamics" aliases["fluid mechanics"] = "fluid mechanics" aliases["folklór"] = "folklore" aliases["football"] = "soccer" aliases["footwear"] = "footwear" aliases["forestry"] = "forestry" aliases["freemasonry"] = "freemasonry" aliases["functional analysis"] = "functional analysis" aliases["functional group prefix"] = "functional group prefix" aliases["functional group suffix"] = "functional group suffix" aliases["furniture"] = "furniture" aliases["fuzzy logic"] = "fuzzy logic" aliases["fémip"] = "metalworking" aliases["fényk"] = "photography" aliases["földr"] = "geography" aliases["földtan"] = "geology" aliases["galaxy"] = "galaxy" aliases["gambling"] = "gambling" aliases["game"] = "games" aliases["games"] = "games" aliases["gaming"] = "gaming" aliases["gardening"] = "horticulture" aliases["gastronomy"] = "cooking" aliases["gaszt"] = "gastronomy" aliases["gasztronómia"] = "cooking" aliases["asztronómia"] = "astronomy" aliases["gazd"] = "economics" aliases["gazdaság"] = "economics" aliases["genealógia"] = "genealogy" aliases["genetic disorder"] = "genetic disorder" aliases["genetika"] = "genetics" aliases["geod"] = "geodesy" aliases["földrajz"] = "geography" aliases["geol"] = "geology" aliases["geológia"] = "geology" aliases["geometria"] = "geometry" aliases["geomorphology"] = "geomorphology" aliases["gerontology"] = "gerontology" aliases["gk"] = "motor vehicles" aliases["glassblowing"] = "glassblowing" aliases["gnosticism"] = "Gnosticism" aliases["golf"] = "golf" aliases["gomba"] = "mycology" aliases["gombaismeret"] = "mycology" aliases["gombatan"] = "mycology" aliases["gombászat"] = "mycology" aliases["government"] = "government" aliases["grammatical mood"] = "grammatical mood" aliases["graphic design"] = "graphic design" aliases["graphical user interface"] = "graphical user interface" aliases["csoport"] = "group theory" aliases["csoportelmélet"] = "group theory" aliases["gráfelmélet"] = "graph theory" aliases["gun mechanism"] = "Gun mechanisms" aliases["gun mechanisms"] = "gun mechanisms" aliases["gyerm"] = "baby talk" aliases["gymnastics"] = "gymnastics" aliases["gynaecology"] = "gynaecology" aliases["gynecology"] = "gynaecology" aliases["gép"] = "mechanical engineering" aliases["haematology"] = "hematology" aliases["hajó"] = "nautical" aliases["ham radio"] = "amateur radio" aliases["handball"] = "handball" aliases["healthcare"] = "healthcare" aliases["helminthology"] = "helminthology" aliases["helyesírás"] = "orthography" aliases["hematology"] = "hematology" aliases["heraldic charge"] = "heraldic charge" aliases["heraldiccharge"] = "heraldic charge" aliases["címertan"] = "heraldry" aliases["herbalism"] = "herbalism" aliases["herpetology"] = "herpetology" aliases["historiography"] = "historiography" aliases["hiv"] = "formal" aliases["hockey"] = "hockey" aliases["homeopathy"] = "homeopathy" aliases["hormone"] = "hormone" aliases["horoscope"] = "astrology" aliases["horse racing"] = "horse racing" aliases["kertészet"] = "horticulture" aliases["human resources"] = "human resources" aliases["humanities"] = "humanities" aliases["vadászat"] = "hunting" aliases["hurling"] = "hurling" aliases["hydrocarbon chain prefix"] = "hydrocarbon chain prefix" aliases["hydrocarbon chain suffix"] = "hydrocarbon chain suffix" aliases["hidrológia"] = "hydrology" aliases["ice hockey"] = "ice hockey" aliases["ichthyology"] = "ichthyology" aliases["immunochemistry"] = "immunochemistry" aliases["immunology"] = "immunology" aliases["import/export"] = "import/export" aliases["incoterm"] = "incoterm" aliases["indo-european studies"] = "Indo-European studies" aliases["industry"] = "manufacturing" aliases["inf"] = "computer science" aliases["info"] = "computer science" aliases["infor"] = "computer science" aliases["informatika"] = "computer science" aliases["information science"] = "information science" aliases["információelmélet"] = "information theory" aliases["inorganic compound"] = "inorganic compound" aliases["insurance"] = "insurance" aliases["international law"] = "international law" aliases["internet"] = "internet" aliases["ip"] = "manufacturing" aliases["ir"] = "literature" aliases["irod"] = "literature" aliases["irodalom"] = "literature" aliases["irodalomtudomány"] = "literature" aliases["iron"] = "ironical" aliases["irtud"] = "literature" aliases["islam"] = "Islam" aliases["isotope"] = "isotope" aliases["iszlám"] = "Islam" aliases["jazz"] = "jazz" aliases["jog"] = "law" aliases["jog"] = "law" aliases["jogi"] = "law" aliases["journalism"] = "journalism" aliases["judaizmus"] = "Judaism" aliases["judo"] = "judo" aliases["juggling"] = "juggling" aliases["ját"] = "games" aliases["játék"] = "games" aliases["jóga pozíció"] = "asana" aliases["jóga"] = "yoga" aliases["jógapóz"] = "asana" aliases["kat"] = "military term" aliases["kat"] = "military" aliases["katonai"] = "military" aliases["katonaság"] = "military" aliases["kendo"] = "kendo" aliases["kert"] = "horticulture" aliases["knitting"] = "knitting" aliases["koh"] = "metallurgy" aliases["főzés"] = "cooking" aliases["főz"] = "cooking" aliases["konyha"] = "cooking" aliases["konyhaművészet"] = "cooking" aliases["kémia"] = "chemistry" aliases["könyvelés"] = "accounting" aliases["körny"] = "ecology" aliases["közg"] = "economics" aliases["közl"] = "transport" aliases["kül"] = "foreign affairs" aliases["lacrosse"] = "lacrosse" aliases["landforms"] = "landforms" aliases["lat"] = "Latin word" aliases["law enforcement"] = "law enforcement" aliases["letterpress"] = "letterpress" aliases["lexikográfia"] = "lexicography" aliases["liberalism"] = "liberalism" aliases["library science"] = "library science" aliases["lichenology"] = "lichenology" aliases["limnology"] = "limnology" aliases["lineáris algebra"] = "linear algebra" aliases["linguistic morphology"] = "linguistic morphology" aliases["lipid"] = "lipid" aliases["logical fallacy"] = "logical fallacy" aliases["logika"] = "logic" aliases["luge"] = "luge" aliases["hangszer"] = "lutherie" aliases["hangszerészet"] = "lutherie" aliases["machining"] = "machining" aliases["malacology"] = "malacology" aliases["emlős"] = "mammalogy" aliases["management"] = "management" aliases["ipar"] = "manufacturing" aliases["tengerbiológia"] = "marine biology" aliases["marketing"] = "marketing" aliases["harcművészet"] = "martial arts" aliases["harcművészetek"] = "martial arts" aliases["massage"] = "massage" aliases["mat"] = "mathematics" aliases["materials science"] = "materials science" aliases["math"] = "mathematics" aliases["mathematical analysis"] = "mathematical analysis" aliases["matematika"] = "mathematics" aliases["matek"] = "mathematics" aliases["maths"] = "mathematics" aliases["mechanical engineering"] = "mechanical engineering" aliases["mechanics"] = "mechanics" aliases["med"] = "medicine" aliases["media"] = "media" aliases["mediaeval folklore"] = "mediaeval folklore" aliases["medical genetics"] = "medical genetics" aliases["medical sign"] = "medical sign" aliases["medieval folklore"] = "mediaeval folklore" aliases["met"] = "meteorology" aliases["metadata"] = "metadata" aliases["metal type"] = "letterpress" aliases["metal typesetting"] = "letterpress" aliases["kohászat"] = "metallurgy" aliases["metamaterial"] = "metamaterial" aliases["metaphysics"] = "metaphysics" aliases["meteorológia"] = "meteorology" aliases["metrology"] = "metrology" aliases["mezőg"] = "agriculture" aliases["microbiology"] = "microbiology" aliases["microelectronics"] = "microelectronics" aliases["microscopy"] = "microscopy" aliases["mikológia"] = "mycology" aliases["military rank"] = "military ranks" aliases["military ranks"] = "military ranks" aliases["military unit"] = "military unit" aliases["military"] = "military" aliases["ásvány"] = "mineral" aliases["ásványtan"] = "mineralogy" aliases["bányászat"] = "mining" aliases["mobile phone"] = "mobile phones" aliases["mobile telephony"] = "mobile phones" aliases["mobiltelefon"] = "mobile phones" aliases["mobiltelefonok"] = "mobile phones" aliases["molecular biology"] = "molecular biology" aliases["monarchy"] = "monarchy" aliases["money"] = "money" aliases["morphology"] = "linguistic morphology" aliases["motor racing"] = "motor racing" aliases["motor sport"] = "motor racing" aliases["motorcycling"] = "motorcycling" aliases["motorsport"] = "motor racing" aliases["muscle"] = "muscle" aliases["music genre"] = "music genre" aliases["musical instrument"] = "musical instruments" aliases["hangszerek"] = "musical instruments" aliases["hangszer"] = "musical instruments" aliases["musici"] = "musical instruments" aliases["musician"] = "musician" aliases["mythological creature"] = "mythological creature" aliases["mitológia"] = "mythology" aliases["mértan"] = "geometry" aliases["műsz"] = "technology" aliases["műv"] = "art" aliases["nanotechnology"] = "nanotechnology" aliases["narratology"] = "narratology" aliases["nautical"] = "nautical" aliases["navigation"] = "navigation" aliases["nematology"] = "nematology" aliases["netball"] = "netball" aliases["networking"] = "networking" aliases["net"] = "networking" aliases["háló"] = "networking" aliases["neuroanatomy"] = "neuroanatomy" aliases["neurology"] = "neurology" aliases["neuroscience"] = "neuroscience" aliases["neurosurgery"] = "neurosurgery" aliases["neurotoxin"] = "neurotoxin" aliases["neurotransmitter"] = "neurotransmitter" aliases["newspapers"] = "newspapers" aliases["nuclear physics"] = "nuclear physics" aliases["number theory"] = "number theory" aliases["numismatics"] = "numismatics" aliases["nutrition"] = "nutrition" aliases["nyelvtan"] = "grammar" aliases["nyelvtani eset"] = "grammatical case" aliases["nyelvészet"] = "linguistics" aliases["nyelvtudomány"] = "linguistics" aliases["nyomd"] = "printing" aliases["népr"] = "ethnography" aliases["növ"] = "botany" aliases["object-oriented programming"] = "object-oriented programming" aliases["object-oriented"] = "object-oriented programming" aliases["obstetric"] = "obstetrics" aliases["obstetrics"] = "obstetrics" aliases["okkult"] = "occult" aliases["oceanography"] = "oceanography" aliases["oenology"] = "oenology" aliases["oil drilling"] = "oil industry" aliases["oil industry"] = "oil industry" aliases["okt"] = "education" aliases["oncology"] = "oncology" aliases["online"] = "internet" aliases["opera"] = "opera" aliases["operating systems"] = "operating systems" aliases["OS"] = "operating systems" aliases["ophthalmology"] = "ophthalmology" aliases["optics"] = "optics" aliases["bird"] = "ornithology" aliases["birds"] = "ornithology" aliases["madártan"] = "ornithology" aliases["madár"] = "ornithology" aliases["orthodontics"] = "orthodontics" aliases["ortográfia"] = "orthography" aliases["orv"] = "medicine" aliases["orv"] = "medicine" aliases["orvosi"] = "medicine" aliases["orvostudomány"] = "medicine" aliases["pain"] = "pain" aliases["paintball"] = "paintball" aliases["painting"] = "painting" aliases["palaeography"] = "palaeography" aliases["paleontológia"] = "paleontology" aliases["paleography"] = "palaeography" aliases["paleontology"] = "paleontology" aliases["palmistry"] = "palmistry" aliases["palynology"] = "palynology" aliases["parapsychology"] = "parapsychology" aliases["szófaj"] = "part of speech" aliases["particle physics"] = "particle physics" aliases["particle"] = "particle" aliases["pasteurisation"] = "pasteurisation" aliases["patent law"] = "patent law" aliases["patents"] = "patent law" aliases["pathology"] = "pathology" aliases["pej"] = "pejorative" aliases["pensions"] = "pensions" aliases["pesapallo"] = "pesäpallo" aliases["pesäpallo"] = "pesäpallo" aliases["petrochemistry"] = "petrochemistry" aliases["petrology"] = "petrology" aliases["gyógyszer"] = "pharmacology" aliases["gyógyszertan"] = "pharmacology" aliases["gyógyszerhatás"] = "pharmaceutical effect" aliases["farmakológia"] = "pharmacology" aliases["farm"] = "pharmacology" aliases["farma"] = "pharmacology" aliases["pharma"] = "pharmacology" aliases["gyógyszerészet"] = "pharmacy" aliases["pharyngology"] = "pharyngology" aliases["philately"] = "philately" aliases["filozófia"] = "philosophy" aliases["fonetika"] = "phonetics" aliases["phonology"] = "phonology" aliases["fényképészet"] = "photography" aliases["phrenology"] = "phrenology" aliases["phytopathology"] = "phytopathology" aliases["pinball"] = "pinball" aliases["planetology"] = "planetology" aliases["plant disease"] = "plant disease" aliases["virág"] = "botany" aliases["plant"] = "botany" aliases["playing card"] = "card games" aliases["poetry"] = "poetry" aliases["poison"] = "poison" aliases["poker"] = "poker" aliases["pol"] = "politics" aliases["police"] = "law enforcement" aliases["policing"] = "law enforcement" aliases["political science"] = "political science" aliases["political subdivision"] = "political subdivision" aliases["politika"] = "politics" aliases["politikai"] = "politics" aliases["pragmatics"] = "pragmatics" aliases["nyomdászat"] = "printing" aliases["valószínűségelmélet"] = "probability theory" aliases["valószínűségszámítás"] = "probability theory" aliases["valszám"] = "probability theory" aliases["vsz"] = "probability theory" aliases["programming"] = "programming" aliases["property law"] = "property law" aliases["prosody"] = "prosody" aliases["proteins"] = "protein" aliases["pszichiátria"] = "psychiatry" aliases["psychoanalysis"] = "psychoanalysis" aliases["pszichológia"] = "psychology" aliases["psychotherapy"] = "psychotherapy" aliases["pszich"] = "psychology" aliases["publishing"] = "publishing" aliases["pyrotechnics"] = "pyrotechnics" aliases["pénz"] = "finance" aliases["póker"] = "poker slang" aliases["quantum mechanics"] = "quantum mechanics" aliases["quantum physics"] = "quantum mechanics" aliases["quantum"] = "quantum mechanics" aliases["radio"] = "radio" aliases["rail transport"] = "rail transport" aliases["rail"] = "rail transport" aliases["railroading"] = "rail transport" aliases["railroads"] = "rail transport" aliases["rak"] = "rocketry" aliases["real estate"] = "real estate" aliases["real tennis"] = "real tennis" aliases["regex"] = "regular expressions" aliases["regular expressions"] = "regular expressions" aliases["relativity"] = "relativity" aliases["vallás"] = "religion" aliases["rep"] = "aviation" aliases["repülés"] = "aeronautics" aliases["retorika"] = "rhetoric" aliases["ritk"] = "rare" aliases["közúti"] = "road transport" aliases["robotics"] = "robotics" aliases["rock"] = "rock" aliases["roller derby"] = "roller derby" aliases["roofing"] = "roofing" aliases["rosiculture"] = "rosiculture" aliases["rowing"] = "rowing" aliases["rugby"] = "rugby" aliases["rég"] = "archaic" aliases["régész"] = "archaeology" aliases["röv"] = "abbreviation" aliases["sailing"] = "sailing" aliases["schools"] = "schools" aliases["sci fi"] = "science fiction" aliases["science fiction"] = "science fiction" aliases["science"] = "sciences" aliases["sciences"] = "sciences" aliases["scientific"] = "sciences" aliases["scifi"] = "science fiction" aliases["scouting"] = "Scouting" aliases["scrapbooks"] = "scrapbooks" aliases["scuba diving"] = "underwater diving" aliases["scuba"] = "underwater diving" aliases["sculpture"] = "sculpture" aliases["sebészet"] = "surgery" aliases["seismology"] = "seismology" aliases["semantics"] = "semantics" aliases["semiconductors"] = "semiconductors" aliases["semiotics"] = "semiotics" aliases["halmazelmélet"] = "set theory" aliases["sewing"] = "sewing" aliases["sexology"] = "sexology" aliases["sexuality"] = "sexuality" aliases["shamanism"] = "shamanism" aliases["hajózás"] = "shipping" aliases["signal processing"] = "signal processing" aliases["singing"] = "singing" aliases["skateboarding"] = "skateboarding" aliases["skating"] = "skating" aliases["skeleton"] = "skeleton" aliases["skiing"] = "skiing" aliases["smoking"] = "smoking" aliases["snooker"] = "snooker" aliases["snowboarding"] = "snowboarding" aliases["soccer"] = "soccer" aliases["social science"] = "social sciences" aliases["social sciences"] = "social sciences" aliases["socialism"] = "socialism" aliases["sociolinguistics"] = "sociolinguistics" aliases["sociology"] = "sociology" aliases["software architecture"] = "software architecture" aliases["software engineering"] = "software engineering" aliases["software"] = "software" aliases["soil science"] = "soil science" aliases["sound engineering"] = "sound engineering" aliases["sound"] = "sound" aliases["sp"] = "sports" aliases["space flight"] = "space flight" aliases["űrkutatás"] = "space science" aliases["space"] = "space science" aliases["spectroscopy"] = "spectroscopy" aliases["spiritualism"] = "spiritualism" aliases["sport"] = "sports" aliases["squash"] = "squash" aliases["standard of identity"] = "standard of identity" aliases["star"] = "star" aliases["statisztika"] = "statistics" aliases["steroid drug"] = "steroid hormone" aliases["steroid hormone"] = "steroid hormone" aliases["steroid"] = "steroid" aliases["stock market"] = "stock market" aliases["stock symbol"] = "stock ticker symbol" aliases["stock ticker symbol"] = "stock ticker symbol" aliases["subculture"] = "subculture" aliases["sumo"] = "sumo" aliases["surface feature"] = "surface feature" aliases["surfing"] = "surfing" aliases["surveying"] = "surveying" aliases["sushi"] = "sushi" aliases["swimming"] = "swimming" aliases["swords"] = "swords" aliases["symptom"] = "symptom" aliases["systematics"] = "systematics" aliases["systems engineering"] = "systems engineering" aliases["systems theory"] = "systems theory" aliases["szerves kémia"] = "organic chemistry" aliases["szerves vegyület"] = "organic compound" aliases["szervetlen kémia"] = "inorganic chemistry" aliases["szl"] = "slang" aliases["szuff"] = "suffix" aliases["számítástechnika"] = "computing" aliases["technika"] = "technology" aliases["szín"] = "color" aliases["színek"] = "color" aliases["szính"] = "theater" aliases["szól"] = "idiom" aliases["table tennis"] = "table tennis" aliases["tabu"] = "taboo" aliases["tarot"] = "tarot" aliases["tax"] = "taxation" aliases["taxation"] = "taxation" aliases["taxes"] = "taxation" aliases["taxonomic name"] = "taxonomic name" aliases["taxonomy"] = "taxonomy" aliases["műszaki"] = "technology" aliases["telecom"] = "telecommunications" aliases["postaügy"] = "telecommunications" aliases["telecommunication"] = "telecommunications" aliases["távközlés"] = "telecommunications" aliases["telegraphy"] = "telegraphy" aliases["telephone"] = "telephony" aliases["telephones"] = "telephony" aliases["telephony"] = "telephony" aliases["television"] = "television" aliases["tennis"] = "tennis" aliases["teratology"] = "teratology" aliases["tex"] = "textiles" aliases["textilipar"] = "textiles" aliases["színház"] = "theater" aliases["theatre"] = "theater" aliases["theology"] = "theology" aliases["thermodynamics"] = "thermodynamics" aliases["tincture"] = "tincture" aliases["tni"] = "intransitive verb" aliases["topology"] = "topology" aliases["tourism"] = "tourism" aliases["toxicology"] = "toxicology" aliases["trading cards"] = "trading cards" aliases["trading"] = "trading" aliases["traditional Chinese medicine"] = "traditional Chinese medicine" aliases["translation studies"] = "translation studies" aliases["közlekedés"] = "transport" aliases["transportation"] = "transport" aliases["traumatology"] = "traumatology" aliases["travel"] = "travel" aliases["trigonometry"] = "trigonometry" aliases["tréf"] = "jocular" aliases["tud"] = "sciences" aliases["tudományos"] = "sciences" aliases["tudomány"] = "sciences" aliases["tv"] = "television" aliases["two-up"] = "two-up" aliases["typesetting"] = "typography" aliases["typography"] = "typography" aliases["táj"] = "dialect" aliases["távk"] = "telecommunications" aliases["tört"] = "history" aliases["történelem"] = "history" aliases["ufology"] = "ufology" aliases["underwater diving"] = "underwater diving" aliases["vad"] = "hunting" aliases["valentinianism"] = "Valentinianism" aliases["vall"] = "religion" aliases["vasút"] = "rail transport" aliases["vector algebra"] = "linear algebra" aliases["vector"] = "linear algebra" aliases["vegetable"] = "vegetable" aliases["vegetables"] = "vegetable" aliases["vegy"] = "chemistry" aliases["vegyészet"] = "chemistry" aliases["vehicle"] = "vehicles" aliases["vehicles"] = "vehicles" aliases["veterinary medicine"] = "veterinary medicine" aliases["vhi"] = "reflexive verb" aliases["video games"] = "video games" aliases["video gaming"] = "video games" aliases["vill"] = "electricity" aliases["villamosság"] = "electricity" aliases["virology"] = "virology" aliases["vitamin"] = "vitamin" aliases["viticulture"] = "viticulture" aliases["volcanology"] = "volcanology" aliases["volleyball"] = "volleyball" aliases["voodoo"] = "voodoo" aliases["vulcanology"] = "volcanology" aliases["vízügy"] = "hydrology" aliases["watercraft"] = "watercraft" aliases["weaponry"] = "weaponry" aliases["weapons"] = "weaponry" aliases["weather"] = "weather" aliases["weaving"] = "weaving" aliases["web design"] = "web design" aliases["web development"] = "web development" aliases["weightlifting"] = "weightlifting" aliases["borászat"] = "wine" aliases["woodworking"] = "woodworking" aliases["wrestling"] = "wrestling" aliases["writing"] = "writing" aliases["yoga"] = "yoga" aliases["zene"] = "music" aliases["zenetudomány"] = "music" aliases["zodiac constellations"] = "zodiac constellations" aliases["zodiac"] = "astrology" aliases["állattan"] = "zoology" aliases["zootomy"] = "zootomy" aliases["áll"] = "zoology" aliases["állatorv"] = "veterinary medicine" aliases["ált"] = "generally" aliases["ásv"] = "mineralogy" aliases["ászana"] = "yoga pose" aliases["átv"] = "figuratively" aliases["átvitt"] = "figuratively" aliases["átvitt értelem"] = "figuratively" aliases["átvitt értelemben"] = "figuratively" aliases["élettan"] = "physiology" aliases["épít"] = "architecture" labels["Christianity"] = { display = "[[kereszténység|kereszténység]]", topical_categories = {"kereszténység"}, } labels["Islam"] = { display = "[[iszlám|iszlám]]", topical_categories = {"iszlám"}, } labels["Judaism"] = { display = "[[judaizmus|judaizmus]]", topical_categories = {"judaizmus"}, } labels["accounting"] = { display = "[[könyvelés|könyvelés]]", topical_categories = {"könyvelés"}, } labels["acoustics"] = { display = "[[akusztika|akusztika]]", topical_categories = {"akusztika"}, } labels["acting"] = { display = "[[színművészet|színművészet]]", topical_categories = {"színművészet"}, } labels["advertising"] = { display = "[[advertising|advertising]]", topical_categories = {"advertising"}, } labels["aeronautics"] = { display = "[[repülés|repülés]]", topical_categories = {"repülés"}, } labels["aerospace"] = { display = "[[space|space]]", topical_categories = {"aerospace"}, } labels["agriculture"] = { display = "[[mezőgazdaság|mezőgazdaság]]", topical_categories = {"mezőgazdaság"}, } labels["aircraft"] = { display = "[[aircraft|aircraft]]", topical_categories = {"aircraft"}, } labels["alchemy"] = { display = "[[alkímia|alkímia]]", topical_categories = {"alkímia"}, } labels["alcoholic beverages"] = { display = "[[alcoholic|alcoholic]] [[beverage|beverage]]s", topical_categories = {"alcoholic beverages"}, } labels["algebra"] = { display = "[[algebra|algebra]]", topical_categories = {"algebra"}, } labels["algebraic geometry"] = { display = "[[algebrai geometria|algebrai geometria]]", topical_categories = {"algebrai geometria"}, } labels["alternative medicine"] = { display = "[[alternative medicine|alternative medicine]]", topical_categories = {"alternative medicine"}, } labels["amateur radio"] = { display = "[[amatőr rádió|amatőr rádió]]", topical_categories = {"amatőr rádió"}, } labels["amino acid"] = { display = "[[biokémia|biokémia]]", topical_categories = {"aminosavak"}, } labels["analitikus geometria"] = { display = "[[analitikus geometria|analitikus geometria]]", topical_categories = {"geometria"}, } labels["analytical chemistry"] = { display = "[[analytical|analytical]] [[chemistry|chemistry]]", topical_categories = {"analytical chemistry"}, } labels["anatomy"] = { display = "[[anatómia|anatómia]]", topical_categories = {"anatómia"}, } labels["animation"] = { display = "[[animáció|animáció]]", topical_categories = {"animáció"}, } labels["anthropology"] = { display = "[[antropológia|antropológia]]", topical_categories = {"antropológia"}, } labels["arachnology"] = { display = "[[arachnology|arachnology]]", topical_categories = {"arachnology"}, } labels["archaeology"] = { display = "[[régészet|régészet]]", topical_categories = {"régészet"}, } labels["archery"] = { display = "[[íjászat|íjászat]]", topical_categories = {"íjászat"}, } labels["architecture"] = { display = "[[építészet|építészet]]", topical_categories = {"építészet"}, } labels["arithmetic"] = { display = "[[arithmetic|arithmetic]]", topical_categories = {"arithmetic"}, } labels["art"] = { display = "[[művészet|művészet]]", topical_categories = {"művészet"}, } labels["artificial intelligence"] = { display = "[[mesterséges intelligencia|mesterséges intelligencia]]", topical_categories = {"mesterséges intelligencia"}, } labels["asterism"] = { display = "[[uranography|uranography]]", topical_categories = {"asterisms"}, } labels["astrology"] = { display = "[[asztrológia|asztrológia]]", topical_categories = {"asztrológia"}, } labels["astronautics"] = { display = "[[astronautics|astronautics]]", topical_categories = {"astronautics"}, } labels["astronomy"] = { display = "[[csillagászat|csillagászat]]", topical_categories = {"csillagászat"}, } labels["astrophysics"] = { display = "[[astrophysics|astrophysics]]", topical_categories = {"astrophysics"}, } labels["athletics"] = { display = "[[atlétika|atlétika]]", topical_categories = {"atlétika"}, } labels["automotive"] = { display = "[[gépjármű|gépjármű]]", topical_categories = {"gépjármű"}, } labels["aviation"] = { display = "[[repülés|repülés]]", topical_categories = {"repülés"}, } labels["bacteriology"] = { display = "[[bacteriology|bacteriology]]", topical_categories = {"bacteriology"}, } labels["baking"] = { display = "[[baking|baking]]", topical_categories = {"baking"}, } labels["ballet"] = { display = "[[balett|balett]]", topical_categories = {"balett"}, } labels["banking"] = { display = "[[banking|banking]]", topical_categories = {"banking"}, } labels["beekeeping"] = { display = "[[beekeeping|beekeeping]]", topical_categories = {"beekeeping"}, } labels["beer"] = { display = "[[beer|beer]]", topical_categories = {"beer"}, } labels["biblical"] = { display = "[[bibliai|bibliai]]", topical_categories = {"bibliai"}, } labels["biochemistry"] = { display = "[[biokémia|biokémia]]", topical_categories = {"biokémia"}, } labels["biology"] = { display = "[[biológia|biológia]]", topical_categories = {"biológia"}, } labels["biotechnology"] = { display = "[[biotechnology|biotechnology]]", topical_categories = {"biotechnology"}, } labels["birdwatching"] = { display = "[[birdwatching|birdwatching]]", topical_categories = {"birdwatching"}, } labels["botany"] = { display = "[[növénytan|növénytan]]", topical_categories = {"növénytan"}, } labels["brewing"] = { display = "[[brewing|brewing]]", topical_categories = {"brewing"}, } labels["broadcasting"] = { display = "[[broadcasting|broadcasting]]", topical_categories = {"broadcasting"}, } labels["bryology"] = { display = "[[bryology|bryology]]", topical_categories = {"bryology"}, } labels["business"] = { display = "[[üzlet|üzlet]]", topical_categories = {"üzlet"}, } labels["calligraphy"] = { display = "[[kalligráfia|kalligráfia]]", topical_categories = {"kalligráfia"}, } labels["canoeing"] = { display = "[[canoeing|canoeing]]", topical_categories = {"water sports"}, } labels["capitalism"] = { display = "[[capitalism|capitalism]]", topical_categories = {"capitalism"}, } labels["carbohydrate"] = { display = "[[biokémia|biokémia]]", topical_categories = {"carbohydrates"}, } labels["card games"] = { display = "[[kártyajáték|kártyajáték]]", topical_categories = {"kártyajáték"}, } labels["cardiology"] = { display = "[[kardiológia|kardiológia]]", topical_categories = {"kardiológia"}, } labels["carpentry"] = { display = "[[carpentry|carpentry]]", topical_categories = {"carpentry"}, } labels["cartography"] = { display = "[[térképészet|térképészet]]", topical_categories = {"térképészet"}, } labels["cartomancy"] = { display = "[[cartomancy|cartomancy]]", topical_categories = {"cartomancy"}, } labels["category theory"] = { display = "[[category theory|category theory]]", topical_categories = {"category theory"}, } labels["caving"] = { display = "[[caving|caving]]", topical_categories = {"caving"}, } labels["ceramics"] = { display = "[[kerámia|kerámia]]", topical_categories = {"kerámia"}, } labels["chemical element"] = { display = "[[kémia|kémia]]", topical_categories = {"kémiai elemek"}, } labels["chemical engineering"] = { display = "[[chemical engineering|chemical engineering]]", topical_categories = {"chemical engineering"}, } labels["chemistry"] = { display = "[[kémia|kémia]]", topical_categories = {"kémia"}, } labels["chess"] = { display = "[[sakk|sakk]]", topical_categories = {"sakk"}, } labels["cladistics"] = { display = "[[cladistics|cladistics]]", topical_categories = {"systematics"}, } labels["classical mechanics"] = { display = "[[classical mechanics|classical mechanics]]", topical_categories = {"classical mechanics"}, } labels["classical studies"] = { display = "[[classical studies|classical studies]]", topical_categories = {"classical studies"}, } labels["climatology"] = { display = "[[climatology|climatology]]", topical_categories = {"climatology"}, } labels["climbing"] = { display = "[[climbing|climbing]]", topical_categories = {"climbing"}, } labels["clinical psychology"] = { display = "[[clinical|clinical]] [[psychology|psychology]]", topical_categories = {"clinical psychology"}, } labels["clothing"] = { display = "[[ruházat|ruházat]]", topical_categories = {"ruházat"}, } labels["coenzyme"] = { display = "[[biokémia|biokémia]]", topical_categories = {"coenzymes"}, } labels["color"] = { display = "[[színek|színek]]", topical_categories = {"színek"}, } labels["combinatorics"] = { display = "[[kombinatorika|kombinatorika]]", topical_categories = {"kombinatorika"}, } labels["comedy"] = { display = "[[komédia|komédia]]", topical_categories = {"komédia"}, } labels["commercial law"] = { display = "[[kereskedelmi jog|kereskedelmi jog]]", topical_categories = {"kereskedelmi jog"}, } labels["communication"] = { display = "[[kommunikáció|kommunikáció]]", topical_categories = {"kommunikáció"}, } labels["complex analysis"] = { display = "[[komplex analízis|komplex analízis]]", topical_categories = {"komplex analízis"}, } labels["computational linguistics"] = { display = "[[számítógépes nyelvészet|számítógépes nyelvészet]]", topical_categories = {"számítógépes nyelvészet"}, } labels["computer science"] = { display = "[[informatika|informatika]]", topical_categories = {"informatika"}, } labels["computing"] = { display = "[[számítástechnika|számítástechnika]]", topical_categories = {"számítástechnika"}, } labels["constellation"] = { display = "[[astronomy|astronomy]]", topical_categories = {"constellations"}, } labels["cooking"] = { display = "[[konyha|konyha]]", topical_categories = {"konyha"}, } labels["cosmetics"] = { display = "[[kozmetika|kozmetika]]", topical_categories = {"kozmetika"}, } labels["criminal law"] = { display = "[[criminal law|criminal law]]", topical_categories = {"criminal law"}, } labels["criminology"] = { display = "[[kriminológia|kriminológia]]", topical_categories = {"kriminológia"}, } labels["cryptography"] = { display = "[[kriptográfia|kriptográfia]]", topical_categories = {"kriptográfia"}, } labels["cryptoállattan"] = { display = "[[cryptoállattan|cryptoállattan]]", topical_categories = {"cryptoállattan"}, } labels["crystallography"] = { display = "[[kristálytan|kristálytan]]", topical_categories = {"kristálytan"}, } labels["cultural anthropology"] = { display = "[[kulturális antropológia|kulturális antropológia]]", topical_categories = {"kulturális antropológia"}, } labels["cybernetics"] = { display = "[[kibernetika|kibernetika]]", topical_categories = {"kibernetika"}, } labels["cytology"] = { display = "[[sejtbiológia|sejtbiológia]]", topical_categories = {"sejtbiológia"}, } labels["dance"] = { display = "[[táncművészet|táncművészet]]", topical_categories = {"táncművészet"}, } labels["databases"] = { display = "[[database|database]]s", topical_categories = {"databases"}, } labels["deltiology"] = { display = "[[deltiology|deltiology]]", topical_categories = {"deltiology"}, } labels["demography"] = { display = "[[demográfia|demográfia]]", topical_categories = {"demográfia"}, } labels["demonym"] = { display = "[[demonym|demonym]]", topical_categories = {"demonyms"}, } labels["dentistry"] = { display = "[[fogászat|fogászat]]", topical_categories = {"fogászat"}, } labels["dermatology"] = { display = "[[bőrgyógyászat|bőrgyógyászat]]", topical_categories = {"bőrgyógyászat"}, } labels["design"] = { display = "[[design|design]]", topical_categories = {"design"}, } labels["dialect"] = { display = "[[tájnyelv|tájnyelv]]i", sense_categories = {"tájnyelvi"}, } labels["dictation"] = { display = "[[dictation|dictation]]", topical_categories = {"dictation"}, } labels["diplomacy"] = { display = "[[diplomacy|diplomacy]]", topical_categories = {"diplomacy"}, } labels["disease"] = { display = "[[orvostudomány|orvostudomány]]", topical_categories = {"betegségek"}, } labels["divination"] = { display = "[[divination|divination]]", topical_categories = {"divination"}, } labels["diving"] = { display = "[[diving|diving]]", topical_categories = {"diving"}, } labels["dominoes"] = { display = "[[dominoes|dominoes]]", topical_categories = {"dominoes"}, } labels["drama"] = { display = "[[drama|drama]]", topical_categories = {"drama"}, } labels["dressage"] = { display = "[[dressage|dressage]]", topical_categories = {"dressage"}, } labels["earth science"] = { display = "[[earth science|earth science]]", topical_categories = {"earth sciences"}, } labels["ecclesiastical"] = { display = "[[ecclesiastical|ecclesiastical]]", topical_categories = {"kereszténység"}, } labels["ecology"] = { display = "[[környezettan|környezettan]]", topical_categories = {"környezettan"}, } labels["economics"] = { display = "[[közgazdaságtan|közgazdaságtan]]", topical_categories = {"közgazdaságtan"}, } labels["education"] = { display = "[[oktatásügy|oktatásügy]]", topical_categories = {"oktatásügy"}, } labels["electrencephalography"] = { display = "[[electrencephalography|electrencephalography]]", topical_categories = {"electrencephalography"}, } labels["electrical engineering"] = { display = "[[electrical engineering|electrical engineering]]", topical_categories = {"electrical engineering"}, } labels["electricity"] = { display = "[[villamosság|villamosság]]", topical_categories = {"villamosság"}, } labels["electrodynamics"] = { display = "[[elektrodinamika|elektrodinamika]]", topical_categories = {"elektrodinamika"}, } labels["electromagnetism"] = { display = "[[elektromágnesesség|elektromágnesesség]]", topical_categories = {"elektromágnesesség"}, } labels["electronics"] = { display = "[[elektronika|elektronika]]", topical_categories = {"elektronika"}, } labels["element symbol"] = { display = "[[chemistry|chemistry]]", plain_categories = {"symbols for chemical elements"}, } labels["embryology"] = { display = "[[embriológia|embriológia]]", topical_categories = {"embriológia"}, } labels["emergency medicine"] = { display = "[[emergency medicine|emergency medicine]]", topical_categories = {"emergency medicine"}, } labels["endocrinology"] = { display = "[[endokrinológia|endokrinológia]]", topical_categories = {"endokrinológia"}, } labels["engineering"] = { display = "[[mérnöki tudomány|mérnöki tudomány]]", topical_categories = {"mérnöki tudomány"}, } labels["entomology"] = { display = "[[rovartan|rovartan]]", topical_categories = {"rovartan"}, } labels["enzyme"] = { display = "[[biokémia|biokémia]]", topical_categories = {"enzimek"}, } labels["epidemiology"] = { display = "[[epidemiológia|epidemiológia]]", topical_categories = {"epidemiológia"}, } labels["epistemology"] = { display = "[[epistemology|epistemology]]", topical_categories = {"epistemology"}, } labels["equestrianism"] = { display = "[[equestrianism|equestrianism]]", topical_categories = {"equestrianism"}, } labels["ethics"] = { display = "[[etika|etika]]", topical_categories = {"etika"}, } labels["ethnography"] = { display = "[[néprajz|néprajz]]", topical_categories = {"néprajz"}, } labels["falconry"] = { display = "[[falconry|falconry]]", topical_categories = {"falconry"}, } labels["fantasy"] = { display = "[[fantasy|fantasy]]", topical_categories = {"fantasy"}, } labels["fashion"] = { display = "[[divat|divat]]", topical_categories = {"divat"}, } labels["tools"] = { display = "[[szerszám|szerszám]]", topical_categories = {"szerszámok"}, } labels["fatty acid"] = { display = "[[szerves kémia|szerves kémia]]", topical_categories = {"zsírsavak"}, } labels["felid"] = { display = "[[állattan|állattan]]", topical_categories = {"felids"}, } labels["feminism"] = { display = "[[feminizmus|feminizmus]]", topical_categories = {"feminizmus"}, } labels["fencing"] = { display = "[[vívás|vívás]]", topical_categories = {"vívás"}, } labels["fiction"] = { display = "[[fiction|fiction]]", topical_categories = {"fiction"}, } labels["fictional character"] = { display = "[[fiction|fiction]]", topical_categories = {"fictional characters"}, } labels["field hockey"] = { display = "[[field hockey|field hockey]]", topical_categories = {"field hockey"}, } labels["figure of speech"] = { display = "[[rhetoric|rhetoric]]", topical_categories = {"figures of speech"}, } labels["figure skating"] = { display = "[[figure skating|figure skating]]", topical_categories = {"figure skating"}, } labels["film"] = { display = "[[filmművészet|filmművészet]]", topical_categories = {"filmművészet"}, } labels["finance"] = { display = "[[pénzügy|pénzügy]]", topical_categories = {"pénzügy"}, } labels["firearms"] = { display = "[[firearm|firearm]]s", topical_categories = {"firearms"} } labels["firefighting"] = { display = "[[firefighting|firefighting]]", topical_categories = {"firefighting"}, } labels["fish"] = { display = "[[állattan|állattan]]", topical_categories = {"halak"}, } labels["fishing"] = { display = "[[halászat|halászat]]", topical_categories = {"halászat"}, } labels["fluid dynamics"] = { display = "[[fluid dynamics|fluid dynamics]]", topical_categories = {"fluid dynamics"}, } labels["fluid mechanics"] = { display = "[[fluid mechanics|fluid mechanics]]", topical_categories = {"mechanics"}, } labels["folklore"] = { display = "[[folklór|folklór]]", topical_categories = {"folklór"}, } labels["footwear"] = { display = "[[clothing|clothing]]", topical_categories = {"footwear"}, } labels["forestry"] = { display = "[[erdészet|erdészet]]", topical_categories = {"erdészet"}, } labels["galaxy"] = { display = "[[astronomy|astronomy]]", topical_categories = {"galaxies"}, } labels["game theory"] = { display = "[[game theory|game theory]]", topical_categories = {"game theory"}, } labels["games"] = { display = "[[játékok|játékok]]", topical_categories = {"játékok"}, } labels["gaming"] = { display = "[[gaming|gaming]]", topical_categories = {"gaming"}, } labels["genealogy"] = { display = "[[genealógia|genealógia]]", topical_categories = {"genealógia"}, } labels["genetics"] = { display = "[[genetika|genetika]]", topical_categories = {"genetika"}, } labels["geography"] = { display = "[[földrajz|földrajz]]", topical_categories = {"földrajz"}, } labels["geology"] = { display = "[[geológia|geológia]]", topical_categories = {"geológia"}, } labels["geometry"] = { display = "[[geometria|geometria]]", topical_categories = {"geometria"}, } labels["geomorphology"] = { display = "[[geomorphology|geomorphology]]", topical_categories = {"geomorphology"}, } labels["gerontology"] = { display = "[[gerontology|gerontology]]", topical_categories = {"gerontology"}, } labels["glassblowing"] = { display = "[[glassblowing|glassblowing]]", topical_categories = {"glassblowing"}, } labels["golf"] = { display = "[[golf|golf]]", topical_categories = {"golf"}, } labels["government"] = { display = "[[government|government]]", topical_categories = {"government"}, } labels["grammar"] = { display = "[[nyelvtan|nyelvtan]]", topical_categories = {"nyelvtan"}, } labels["graph theory"] = { display = "[[gráfelmélet|gráfelmélet]]", topical_categories = {"gráfelmélet"}, } labels["graphic design"] = { display = "[[graphic design|graphic design]]", topical_categories = {"graphic design"}, } labels["group theory"] = { display = "[[csoportelmélet|csoportelmélet]]", topical_categories = {"csoportelmélet"}, } labels["gymnastics"] = { display = "[[gymnastics|gymnastics]]", topical_categories = {"gymnastics"}, } labels["gynaecology"] = { display = "[[gynaecology|gynaecology]]", topical_categories = {"gynaecology"}, } labels["handball"] = { display = "[[handball|handball]]", topical_categories = {"handball"}, } labels["healthcare"] = { display = "[[healthcare|healthcare]]", topical_categories = {"healthcare"}, } labels["helminthology"] = { display = "[[helminthology|helminthology]]", topical_categories = {"helminthology"}, } labels["hematology"] = { display = "[[hematology|hematology]]", topical_categories = {"hematology"}, } labels["heraldry"] = { display = "[[címertan|címertan]]", topical_categories = {"címertan"}, } labels["herbalism"] = { display = "[[herbalism|herbalism]]", topical_categories = {"herbalism"}, } labels["herpetology"] = { display = "[[herpetology|herpetology]]", topical_categories = {"herpetology"}, } labels["historiography"] = { display = "[[historiography|historiography]]", topical_categories = {"historiography"}, } labels["hydrology"] = { display = "[[vízügy|vízügy]]", topical_categories = {"vízügy"}, } labels["history"] = { display = "[[történelem|történelem]]", topical_categories = {"történelem"}, } labels["hockey"] = { display = "[[field hockey|field hockey]] or [[ice hockey|ice hockey]]", topical_categories = {"field hockey", "Ice hockey"}, } labels["hormone"] = { display = "[[biokémia|biokémia]]", topical_categories = {"hormones"}, } labels["horticulture"] = { display = "[[kertészet|kertészet]]", topical_categories = {"kertészet"}, } labels["human resources"] = { display = "[[human resources|human resources]]", topical_categories = {"human resources"}, } labels["humanities"] = { display = "[[humanities|humanities]]", topical_categories = {"humanities"}, } labels["hunting"] = { display = "[[vadászat|vadászat]]", topical_categories = {"vadászat"}, } labels["hurling"] = { display = "[[hurling|hurling]]", topical_categories = {"hurling"}, } labels["ichthyology"] = { display = "[[ichthyology|ichthyology]]", topical_categories = {"ichthyology"}, } labels["immunochemistry"] = { display = "[[immunochemistry|immunochemistry]]", topical_categories = {"immunochemistry"}, } labels["immunology"] = { display = "[[immunology|immunology]]", topical_categories = {"immunology"}, } labels["incoterm"] = { display = "[[incoterm|incoterm]]", topical_categories = {"incoterms"}, } labels["information science"] = { display = "[[information science|information science]]", topical_categories = {"information science"}, } labels["information theory"] = { display = "[[információelmélet|információelmélet]]", topical_categories = {"információelmélet"}, } labels["inorganic chemistry"] = { display = "[[szervetlen kémia|szervetlen kémia]]", topical_categories = {"szervetlen kémia"}, } labels["inorganic compound"] = { display = "[[inorganic chemistry|inorganic chemistry]]", topical_categories = {"inorganic compounds"}, } labels["insurance"] = { display = "[[insurance|insurance]]", topical_categories = {"insurance"}, } labels["international law"] = { display = "[[international law|international law]]", topical_categories = {"international law"}, } labels["isotope"] = { display = "[[physics|physics]]", topical_categories = {"isotopes"}, } labels["journalism"] = { display = "[[journalism|journalism]]", topical_categories = {"mass media"}, } labels["juggling"] = { display = "[[juggling|juggling]]", topical_categories = {"juggling"}, } labels["knitting"] = { display = "[[knitting|knitting]]", topical_categories = {"knitting"}, } labels["lacrosse"] = { display = "[[lacrosse|lacrosse]]", topical_categories = {"lacrosse"}, } labels["landforms"] = { display = "[[geography|geography]]", topical_categories = {"landforms"}, } labels["law"] = { display = "[[jogtudomány|jogtudomány]]", topical_categories = {"jogtudomány"}, } labels["lexicography"] = { display = "[[lexikográfia|lexikográfia]]", topical_categories = {"lexikográfia"}, } labels["lichenology"] = { display = "[[zuzmótan|zuzmótan]]", topical_categories = {"zuzmótan"}, } labels["limnology"] = { display = "[[limnológia|limnológia]]", topical_categories = {"limnológia"}, } labels["linear algebra"] = { display = "[[lineáris algebra|lineáris algebra]]", topical_categories = {"lineáris algebra"}, } labels["linguistics"] = { display = "[[nyelvészet|nyelvészet]]", topical_categories = {"nyelvészet"}, } labels["lipid"] = { display = "[[biokémia|biokémia]]", topical_categories = {"lipids"}, } labels["literature"] = { display = "[[irodalomtudomány|irodalomtudomány]]", topical_categories = {"irodalomtudomány"}, } labels["logic"] = { display = "[[logika|logika]]", topical_categories = {"logika"}, } labels["lutherie"] = { display = "[[hangszerészet|hangszerészet]]", topical_categories = {"hangszerészet"}, } labels["machining"] = { display = "[[machining|machining]]", topical_categories = {"machining"}, } labels["mammalogy"] = { display = "[[emlős|emlős]]", topical_categories = {"emlősök"}, } labels["management"] = { display = "[[cégvezetés|cégvezetés]]", topical_categories = {"cégvezetés"}, } labels["manufacturing"] = { display = "[[ipar|ipar]]", topical_categories = {"ipar"}, } labels["marine biology"] = { display = "[[tengerbiológia|tengerbiológia]]", topical_categories = {"tengerbiológia"}, } labels["marketing"] = { display = "[[marketing|marketing]]", topical_categories = {"marketing"}, } labels["martial arts"] = { display = "[[harcművészetek|harcművészetek]]", topical_categories = {"harcművészetek"}, } labels["materials science"] = { display = "[[anyagtudomány|anyagtudomány]]", topical_categories = {"anyagtudomány"}, } labels["mathematical analysis"] = { display = "[[matematikai analízis|matematikai analízis]]", topical_categories = {"matematikai analízis"}, } labels["mathematicians"] = { display = "[[matematikus|matematikus]]", topical_categories = {"matematikusok"}, } labels["mathematics"] = { display = "[[matematika|matematika]]", topical_categories = {"matematika"}, } labels["mechanical engineering"] = { display = "[[mechanical engineering|mechanical engineering]]", topical_categories = {"mechanical engineering"}, } labels["mechanics"] = { display = "[[mechanika|mechanika]]", topical_categories = {"mechanika"}, } labels["media"] = { display = "[[média|média]]", topical_categories = {"média"}, } labels["medical genetics"] = { display = "[[orvosi genetika|orvosi genetika]]", topical_categories = {"orvosi genetika"}, } labels["medicine"] = { display = "[[orvostudomány|orvostudomány]]", topical_categories = {"orvostudomány"}, } labels["metadata"] = { display = "[[metadata|metadata]]", topical_categories = {"data management"}, } labels["metallurgy"] = { display = "[[kohászat|kohászat]]", topical_categories = {"kohászat"}, } labels["metaphysics"] = { display = "[[metaphysics|metaphysics]]", topical_categories = {"metaphysics"}, } labels["meteorology"] = { display = "[[meteorológia|meteorológia]]", topical_categories = {"meteorológia"}, } labels["metrology"] = { display = "[[metrológia|metrológia]]", topical_categories = {"metrológia"}, } labels["microbiology"] = { display = "[[mikrobiológia|mikrobiológia]]", topical_categories = {"mikrobiológia"}, } labels["microelectronics"] = { display = "[[mikroelektronika|mikroelektronika]]", topical_categories = {"mikroelektronika"}, } labels["microscopy"] = { display = "[[microscopy|microscopy]]", topical_categories = {"microscopy"}, } labels["military ranks"] = { display = "[[military|military]]", topical_categories = {"military ranks"}, } labels["military unit"] = { display = "[[military|military]]", topical_categories = {"military units"}, } labels["military"] = { display = "[[katonai|katonai]]", topical_categories = {"katonai"}, } labels["mineral"] = { display = "[[ásványtan|ásványtan]]", topical_categories = {"ásványok"}, } labels["mineralogy"] = { display = "[[ásványtan|ásványtan]]", topical_categories = {"ásványtan"}, } labels["mining"] = { display = "[[bányászat|bányászat]]", topical_categories = {"bányászat"}, } labels["mobile phones"] = { display = "[[távközlés|mobil távközlés|távközlés|mobil távközlés]]", topical_categories = {"mobiltelefonok"}, } labels["molecular biology"] = { display = "[[molekuláris biológia|molekuláris biológia]]", topical_categories = {"molekuláris biológia"}, } labels["monarchy"] = { display = "[[monarchia|monarchia]]", topical_categories = {"monarchia"}, } labels["money"] = { display = "[[pénz|pénz]]", topical_categories = {"pénz"}, } labels["motor racing"] = { display = "[[motorversenyzés|motorversenyzés]]", topical_categories = {"motorversenyzés"}, } labels["motorcycling"] = { display = "[[motorkerékpár|motorkerékpár]]", topical_categories = {"motorkerékpár"}, } labels["muscle"] = { display = "[[anatomy|anatomy]]", topical_categories = {"muscles"}, } labels["music genre"] = { display = "[[music|music]]", topical_categories = {"musical genres"}, } labels["music"] = { display = "[[zene|zene]]", topical_categories = {"zene"}, } labels["musical instruments"] = { display = "[[zene|zene]]", topical_categories = {"hangszerek"}, } labels["musician"] = { display = "[[music|music]]", topical_categories = {"musicians"}, } labels["mycology"] = { display = "[[gombatan|gombatan]]", topical_categories = {"gombatan"}, } labels["mythology"] = { display = "[[mitológia|mitológia]]", topical_categories = {"mitológia"}, } labels["nanotechnology"] = { display = "[[nanotechnológia|nanotechnológia]]", topical_categories = {"nanotechnológia"}, } labels["narratology"] = { display = "[[narratology|narratology]]", topical_categories = {"narratology"}, } labels["nautical"] = { display = "[[tengerészet|tengerészet]]", topical_categories = {"tengerészet"}, } labels["navigation"] = { display = "[[navigáció|navigáció]]", topical_categories = {"navigáció"}, } labels["nematology"] = { display = "[[nematology|nematology]]", topical_categories = {"állattan"}, } labels["netball"] = { display = "[[netball|netball]]", topical_categories = {"netball"}, } labels["networking"] = { display = "[[számítógép-hálózat|számítógép-hálózatok]]", topical_categories = {"számítógép-hálózatok"}, } labels["neuroanatomy"] = { display = "[[neuroanatómia|neuroanatómia]]", topical_categories = {"neuroanatómia"}, } labels["neurology"] = { display = "[[neurológia|neurológia]]", topical_categories = {"neurológia"}, } labels["neuroscience"] = { display = "[[neuroscience|neuroscience]]", topical_categories = {"neuroscience"}, } labels["neurosurgery"] = { display = "[[idegsebészet|idegsebészet]]", topical_categories = {"idegsebészet"}, } labels["neurotoxin"] = { display = "[[neurotoxicology|neurotoxicology]]", topical_categories = {"neurotoxins"}, } labels["neurotransmitter"] = { display = "[[biokémia|biokémia]]", topical_categories = {"neurotranszmitterek"}, } labels["nuclear physics"] = { display = "[[atomfizika|atomfizika]]", topical_categories = {"atomfizika"}, } labels["number theory"] = { display = "[[számelmélet|számelmélet]]", topical_categories = {"számelmélet"}, } labels["numismatics"] = { display = "[[numizmatika|numizmatika]]", topical_categories = {"numizmatika"}, } labels["nutrition"] = { display = "[[nutrition|nutrition]]", topical_categories = {"nutrition"}, } labels["object-oriented programming"] = { display = "[[object-oriented programming|object-oriented programming]]", topical_categories = {"object-oriented programming"}, } labels["obstetrics"] = { display = "[[szülészet|szülészet]]", topical_categories = {"szülészet"}, } labels["occult"] = { display = "[[okkult|okkult]]", topical_categories = {"okkult"}, } labels["oceanography"] = { display = "[[oceanography|oceanography]]", topical_categories = {"oceanography"}, } labels["oenology"] = { display = "[[oenology|oenology]]", topical_categories = {"oenology"}, } labels["oil industry"] = { display = "[[olajipar|olajipar]]", topical_categories = {"olajipar"}, } labels["oncology"] = { display = "[[onkológia|onkológia]]", topical_categories = {"onkológia"}, } labels["opera"] = { display = "[[opera|opera]]", topical_categories = {"opera"}, } labels["operating systems"] = { display = "[[operációs rendszer|operációs rendszerek]]", topical_categories = {"operációs rendszerek"}, } labels["ophthalmology"] = { display = "[[ophthalmology|ophthalmology]]", topical_categories = {"ophthalmology"}, } labels["optics"] = { display = "[[optics|optics]]", topical_categories = {"optics"}, } labels["organic chemistry"] = { display = "[[szerves kémia|szerves kémia]]", topical_categories = {"szerves kémia"}, } labels["organic compound"] = { display = "[[szerves kémia|szerves kémia]]", topical_categories = {"szerves vegyületek"}, } labels["ornithology"] = { display = "[[madártan|madártan]]", topical_categories = {"madártan"}, } labels["orthodontics"] = { display = "[[orthodontics|orthodontics]]", topical_categories = {"dentistry"}, } labels["orthography"] = { display = "[[ortográfia|ortográfia]]", topical_categories = {"ortográfia"}, } labels["painting"] = { display = "[[painting|painting]]", topical_categories = {"painting"}, } labels["palaeography"] = { display = "[[palaeography|palaeography]]", topical_categories = {"palaeography"}, } labels["paleontology"] = { display = "[[paleontológia|paleontológia]]", topical_categories = {"paleontológia"}, } labels["palynology"] = { display = "[[palynology|palynology]]", topical_categories = {"palynology"}, } labels["parapsychology"] = { display = "[[parapsychology|parapsychology]]", topical_categories = {"parapsychology"}, } labels["part of speech"] = { display = "[[nyelvtan|nyelvtan]]", topical_categories = {"szófajok"}, } labels["particle physics"] = { display = "[[particle physics|particle physics]]", topical_categories = {"particle physics"}, } labels["pathology"] = { display = "[[patológia|patológia]]", topical_categories = {"patológia"}, } labels["petrochemistry"] = { display = "[[petrochemistry|petrochemistry]]", topical_categories = {"petrochemistry"}, } labels["petrology"] = { display = "[[petrology|petrology]]", topical_categories = {"petrology"}, } labels["pharmacology"] = { display = "[[gyógyszertan|gyógyszertan]]", topical_categories = {"gyógyszertan"}, } labels["pharmacy"] = { display = "[[gyógyszerészet|gyógyszerészet]]", topical_categories = {"gyógyszerészet"}, } labels["pharyngology"] = { display = "[[pharyngology|pharyngology]]", topical_categories = {"pharyngology"}, } labels["philately"] = { display = "[[bélyeggyűjtés|bélyeggyűjtés]]", topical_categories = {"bélyeggyűjtés"}, } labels["philosophy"] = { display = "[[filozófia|filozófia]]", topical_categories = {"filozófia"}, } labels["phonetics"] = { display = "[[fonetika|fonetika]]", topical_categories = {"fonetika"}, } labels["phonology"] = { display = "[[fonológia|fonológia]]", topical_categories = {"fonológia"}, } labels["photography"] = { display = "[[fényképészet|fényképészet]]", topical_categories = {"fényképészet"}, } labels["phrenology"] = { display = "[[phrenology|phrenology]]", topical_categories = {"phrenology"}, } labels["physical chemistry"] = { display = "[[fizikai kémia|fizikai kémia]]", topical_categories = {"fizikai kémia"}, } labels["physics"] = { display = "[[fizika|fizika]]", topical_categories = {"fizika"}, } labels["physiology"] = { display = "[[élettan|élettan]]", topical_categories = {"élettan"}, } labels["phytopathology"] = { display = "[[phytopathology|phytopathology]]", topical_categories = {"phytopathology"}, } labels["planetology"] = { display = "[[planetology|planetology]]", topical_categories = {"planetology"}, } labels["poetry"] = { display = "[[költészet|költészet]]", topical_categories = {"költészet"}, } labels["poison"] = { display = "[[toxikológia|toxikológia]]", topical_categories = {"toxikológia"}, } labels["poker"] = { display = "[[póker|póker]]", topical_categories = {"póker"}, } labels["politics"] = { display = "[[politika|politika]]", topical_categories = {"politika"}, } labels["pottery"] = { display = "[[fazekasság|fazekasság]]", topical_categories = {"kerámia"}, } labels["pragmatics"] = { display = "[[pragmatika|pragmatika]]", topical_categories = {"pragmatika"}, } labels["printing"] = { display = "[[nyomdászat|nyomdászat]]", topical_categories = {"nyomdászat"}, } labels["programming"] = { display = "[[programozás|programozás]]", topical_categories = {"programozás"}, } labels["property law"] = { display = "[[property law|property law]]", topical_categories = {"property law"}, } labels["prosody"] = { display = "[[prosody|prosody]]", topical_categories = {"prosody"}, } labels["protein"] = { display = "[[biokémia|biokémia]]", topical_categories = {"fehérjék"}, } labels["psychiatry"] = { display = "[[pszichiátria|pszichiátria]]", topical_categories = {"pszichiátria"}, } labels["psychoanalysis"] = { display = "[[pszichoanalízis|pszichoanalízis]]", topical_categories = {"pszichoanalízis"}, } labels["psychology"] = { display = "[[pszichológia|pszichológia]]", topical_categories = {"pszichológia"}, } labels["psychotherapy"] = { display = "[[pszichoterápia|pszichoterápia]]", topical_categories = {"pszichoterápia"}, } labels["publishing"] = { display = "[[publishing|publishing]]", topical_categories = {"publishing"}, } labels["pyrotechnics"] = { display = "[[pyrotechnics|pyrotechnics]]", topical_categories = {"pyrotechnics"}, } labels["quantum mechanics"] = { display = "[[kvantummechanika|kvantummechanika]]", topical_categories = {"kvantummechanika"}, } labels["radio"] = { display = "[[rádió|rádió]]", topical_categories = {"rádió"}, } labels["rail transport"] = { display = "[[vasút|vasút]]", topical_categories = {"vasút"}, } labels["real estate"] = { display = "[[ingatlan|ingatlan]]", topical_categories = {"ingatlan"}, } labels["real tennis"] = { display = "[[tenisz|tenisz]]", topical_categories = {"tenisz"}, } labels["relativity"] = { display = "[[relativitás|relativitás]]", topical_categories = {"relativitás"}, } labels["religion"] = { display = "[[vallás|vallás]]", topical_categories = {"vallás"}, } labels["rhetoric"] = { display = "[[retorika|retorika]]", topical_categories = {"retorika"}, } labels["road transport"] = { display = "[[közúti közlekedés|közúti közlekedés]]", topical_categories = {"közúti közlekedés"}, } labels["robotics"] = { display = "[[robotika|robotika]]", topical_categories = {"robotika"}, } labels["rock"] = { display = "[[petrology|petrology]]", topical_categories = {"rocks"}, } labels["roller derby"] = { display = "[[roller derby|roller derby]]", topical_categories = {"roller derby"}, } labels["roofing"] = { display = "[[roofing|roofing]]", topical_categories = {"roofing"}, } labels["rosiculture"] = { display = "[[rosiculture|rosiculture]]", topical_categories = {"rosiculture"}, } labels["rowing"] = { display = "[[rowing|rowing]]", topical_categories = {"rowing"}, } labels["rugby"] = { display = "[[rugby|rugby]]", topical_categories = {"rugby"}, } labels["sailing"] = { display = "[[sailing|sailing]]", topical_categories = {"sailing"}, } labels["schools"] = { display = "[[education|education]]", topical_categories = {"schools"}, } labels["science fiction"] = { display = "[[tudományos fantasztikus|tudományos fantasztikus]]", topical_categories = {"tudományos fantasztikus"}, } labels["sciences"] = { display = "[[tudományos|tudományos]]", topical_categories = {"tudományos"}, } labels["scrapbooks"] = { display = "[[scrapbook|scrapbook]]s", topical_categories = {"scrapbooks"}, } labels["sculpture"] = { display = "[[sculpture|sculpture]]", topical_categories = {"sculpture"}, } labels["seismology"] = { display = "[[seismology|seismology]]", topical_categories = {"seismology"}, } labels["semantics"] = { display = "[[semantics|semantics]]", topical_categories = {"semantics"}, } labels["semiconductors"] = { display = "[[semiconductor|semiconductor]]s", topical_categories = {"semiconductors"}, } labels["semiotics"] = { display = "[[semiotics|semiotics]]", topical_categories = {"semiotics"}, } labels["set theory"] = { display = "[[halmazelmélet|halmazelmélet]]", topical_categories = {"halmazelmélet"}, } labels["sewing"] = { display = "[[varrás|varrás]]", topical_categories = {"varrás"}, } labels["shamanism"] = { display = "[[sámánizmus|sámánizmus]]", topical_categories = {"sámánizmus"}, } labels["shipping"] = { display = "[[hajózás|hajózás]]", topical_categories = {"hajózás"}, } labels["signal processing"] = { display = "[[jelfeldolgozás|jelfeldolgozás]]", topical_categories = {"jelfeldolgozás"}, } labels["singing"] = { display = "[[singing|singing]]", topical_categories = {"singing"}, } labels["skeleton"] = { display = "[[anatomy|anatomy]]", topical_categories = {"skeleton"}, } labels["social sciences"] = { display = "[[social sciences|social sciences]]", topical_categories = {"social sciences"}, } labels["sociolinguistics"] = { display = "[[szociolinvisztika|szociolinvisztika]]", topical_categories = {"szociolinvisztika"}, } labels["sociology"] = { display = "[[szociológia|szociológia]]", topical_categories = {"szociológia"}, } labels["software"] = { display = "[[software|software]]", topical_categories = {"software"}, } labels["soil science"] = { display = "[[soil science|soil science]]", topical_categories = {"soil science"}, } labels["sound engineering"] = { display = "[[sound engineering|sound engineering]]", topical_categories = {"sound engineering"}, } labels["sound"] = { display = "[[sound|sound]]", topical_categories = {"sound"}, } labels["space flight"] = { display = "[[űrhajózás|űrhajózás]]", topical_categories = {"űrhajózás"}, } labels["space science"] = { display = "[[űrkutatás|űrkutatás]]", topical_categories = {"űrkutatás"}, } labels["spectroscopy"] = { display = "[[spektroszkópia|spektroszkópia]]", topical_categories = {"spektroszkópia"}, } labels["spiritualism"] = { display = "[[spiritualizmus|spiritualizmus]]", topical_categories = {"spiritualizmus"}, } labels["sports"] = { display = "[[sport|sport]]", topical_categories = {"sport"}, } labels["star"] = { display = "[[astronomy|astronomy]]", topical_categories = {"stars"}, } labels["statistics"] = { display = "[[statisztika|statisztika]]", topical_categories = {"statisztika"}, } labels["stock market"] = { display = "[[tőzsde|tőzsde]]", topical_categories = {"tőzsde"}, } labels["surgery"] = { display = "[[sebészet|sebészet]]", topical_categories = {"sebészet"}, } labels["surveying"] = { display = "[[surveying|surveying]]", topical_categories = {"surveying"}, } labels["symptom"] = { display = "[[medicine|medicine]]", topical_categories = {"medical signs and symptoms"}, } labels["systematics"] = { display = "[[systematics|systematics]]", topical_categories = {"systematics"}, } labels["systems engineering"] = { display = "[[systems engineering|systems engineering]]", topical_categories = {"systems engineering"}, } labels["systems theory"] = { display = "[[systems theory|systems theory]]", topical_categories = {"systems theory"}, } labels["tarot"] = { display = "[[tarot|tarot]]", topical_categories = {"cartomancy"}, } labels["taxation"] = { display = "[[adózás|adózás]]", topical_categories = {"adózás"}, } labels["taxonomic name"] = { display = "[[taxonomy|taxonomy]]", topical_categories = {"taxonomic names"}, } labels["taxonomy"] = { display = "[[taxonómia|taxonómia]]", topical_categories = {"taxonómia"}, } labels["technology"] = { display = "[[műszaki|műszaki]]", topical_categories = {"műszaki"}, } labels["telecommunications"] = { display = "[[távközlés|távközlés]]", topical_categories = {"távközlés"}, } labels["telegraphy"] = { display = "[[telegraphy|telegraphy]]", topical_categories = {"telegraphy"}, } labels["telephony"] = { display = "[[telefónia|telefónia]]", topical_categories = {"telefónia"}, } labels["television"] = { display = "[[televízió|televízió]]", topical_categories = {"televízió"}, } labels["teratology"] = { display = "[[teratológia|teratológia]]", topical_categories = {"teratológia"}, } labels["textiles"] = { display = "[[textilipar|textilipar]]", topical_categories = {"textilipar"}, } labels["theater"] = { display = "[[színház|színház]]", topical_categories = {"színház"}, } labels["theology"] = { display = "[[teológia|teológia]]", topical_categories = {"teológia"}, } labels["thermodynamics"] = { display = "[[termodinamika|termodinamika]]", topical_categories = {"termodinamika"}, } labels["topology"] = { display = "[[topológia|topológia]]", topical_categories = {"topológia"}, } labels["tourism"] = { display = "[[turizmus|turizmus]]", topical_categories = {"turizmus"}, } labels["toxicology"] = { display = "[[toxikológia|toxikológia]]", topical_categories = {"toxikológia"}, } labels["trading cards"] = { display = "[[trading card|trading card]]s", topical_categories = {"trading cards"}, } labels["trading"] = { display = "[[kereskedelem|kereskedelem]]", topical_categories = {"kereskedelem"}, } labels["translation studies"] = { display = "[[fordítástudomány|fordítástudomány]]", topical_categories = {"fordítástudomány"}, } labels["transport"] = { display = "[[közlekedés|közlekedés]]", topical_categories = {"közlekedés"}, } labels["traumatology"] = { display = "[[traumatology|traumatology]]", topical_categories = {"emergency medicine"}, } labels["travel"] = { display = "[[utazás|utazás]]", topical_categories = {"utazás"}, } labels["trigonometry"] = { display = "[[trigonometria|trigonometria]]", topical_categories = {"trigonometria"}, } labels["typography"] = { display = "[[tipográfia|tipográfia]]", topical_categories = {"tipográfia"}, } labels["underwater diving"] = { display = "[[búvárkodás|búvárkodás]]", topical_categories = {"búvárkodás"}, } labels["vegetable"] = { display = "[[zöldségek|zöldségek]]", topical_categories = {"zöldségek"}, } labels["vehicles"] = { display = "[[jármű|járművek|jármű|járművek]]", topical_categories = {"járművek"}, } labels["veterinary medicine"] = { display = "[[állatorvostudomány|állatorvostudomány]]", topical_categories = {"állatorvostudomány"}, } labels["virology"] = { display = "[[virológia|virológia]]", topical_categories = {"virológia"}, } labels["vitamin"] = { display = "[[biokémia|biokémia]]", topical_categories = {"vitamins"}, } labels["viticulture"] = { display = "[[szőlőkertészet|szőlőkertészet]]", topical_categories = {"kertészet"}, } labels["volcanology"] = { display = "[[vulkanológia|vulkanológia]]", topical_categories = {"vulkanológia"}, } labels["watercraft"] = { display = "[[nautical|nautical]]", topical_categories = {"watercraft"}, } labels["weaponry"] = { display = "[[weaponry|weaponry]]", topical_categories = {"weapons"}, } labels["wine"] = { display = "[[borászat|borászat]]", topical_categories = {"borászat"}, } labels["woodworking"] = { display = "[[woodworking|woodworking]]", topical_categories = {"woodworking"}, } labels["yoga"] = { display = "[[jóga|jóga]]", topical_categories = {"jóga"}, } labels["zodiac constellations"] = { display = "[[astronomy|astronomy]]", topical_categories = {"constellations in the zodiac"}, } labels["zoology"] = { display = "[[állattan|állattan]]", topical_categories = {"állattan"}, } labels["zootomy"] = { display = "[[állatanatómia|állatanatómia]]", topical_categories = {"állatanatómia"}, } labels["internet"] = { display = "[[internet|internet]]", topical_categories = {"internet"}, } labels["közigazgatás"] = { display = "[[közigazgatás|közigazgatás]]", topical_categories = {"közigazgatás"}, } labels["államigazgatás"] = { display = "[[államigazgatás|államigazgatás]]", topical_categories = {"államigazgatás"}, } labels["art history"] = { display = "[[művészettörténet|művészettörténet]]", topical_categories = {"művészettörténet"}, } labels["foglalkozás"] = { display = "[[foglalkozás|foglalkozás]]", topical_categories = {"foglalkozások"}, } labels["journalistic"] = { display = "[[sajtónyelvi|sajtónyelvi]]", topical_categories = {"sajtónyelvi"}, } labels["languages"] = { display = "[[nyelv|nyelv]]", topical_categories = {"nyelvek"}, } labels["country"] = { display = "[[ország|ország]]", topical_categories = {"országok"}, } labels["season"] = { display = "[[évszak|évszak]]", topical_categories = {"évszakok"}, } labels["népcsoport"] = { display = "[[népcsoport|népcsoport]]", topical_categories = {"népcsoportok"}, } labels["nationality"] = { display = "[[nemzetiség|nemzetiség]]", topical_categories = {"nemzetiségek"}, } labels["Hinduism"] = { display = "[[hinduizmus|hinduizmus]]", topical_categories = {"vallás"}, } labels["Buddhism"] = { display = "[[buddhizmus|buddhizmus]]", topical_categories = {"vallás"}, } labels["Jainism"] = { display = "[[dzsainizmus|dzsainizmus]]", topical_categories = {"vallás"}, } labels["game theory"] = { display = "[[játékelmélet|játékelmélet]]", topical_categories = {"játékelmélet"}, } labels["probability theory"] = { display = "[[valószínűségszámítás|valószínűségszámítás]]", topical_categories = {"valószínűségszámítás"},} labels["computing theory"] = { display = "[[számításelmélet|számításelmélet]]", topical_categories = {"számításelmélet"},} labels["algorithm"] = { display = "[[algoritmusok|algoritmusok]]", topical_categories = {"algoritmusok"}, } labels["operations research"] = { display = "[[operációkutatás|operációkutatás]]", topical_categories = {"operációkutatás"}, } labels["abstract algebra"] = { display = "[[absztrakt algebra|absztrakt algebra]]", topical_categories = {"absztrakt algebra"}, } labels["trees"] = { display = "[[fa|fa]]", topical_categories = {"fák"}, } labels["jewelry"] = { display = "[[ékszer|ékszer]]", topical_categories = {"ékszerészet"}, } labels["machine learning"] = { display = "[[gépi tanulás|gépi tanulás]]", topical_categories = {"gépi tanulás"}, } return {labels = labels, aliases = aliases, deprecated = deprecated} 84fvb4pitcg6gvrq97t0q1f1zh4bdva 0 426698 3479426 2808143 2024-12-12T17:30:49Z LinguisticMystic 22848 3479426 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika|gráf}} {{-ford-}} *{{en}}: {{t+|en|directed acyclic graph}} *{{ru}}: {{t+|ru|направленный ациклический граф}} {{hunl}} gounybhe89ygac884jh8ow489hbk8ki 3479427 3479426 2024-12-12T17:32:56Z LinguisticMystic 22848 3479427 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika|gráf}} Az irányított körmentes gráf (angolul Directed Acyclic Graph, röviden DAG) egy speciális gráf, amely irányított élekből áll, és nem tartalmaz köröket. A DAG fontos szerepet játszik számos alkalmazási területen, például a számítógépes tudományban, az ütemezésben és a verziókezelésben. === Alapfogalmak === ==== Gráf ==== Egy gráf <math>G = (V, E)</math>, ahol: * <math>V</math>: a csúcsok halmaza * <math>E</math>: az élek halmaza, amelyek rendezett csúcspárokat kötnek össze ==== Kör ==== Egy gráfban kör akkor van, ha egy út ugyanabba a csúcsba tér vissza, ahonnan indult, az élek irányát követve. ==== Irányított körmentes gráf ==== Egy gráf akkor irányított körmentes gráf (DAG), ha: * Az élek irányítottak. * Nem tartalmaz köröket, azaz nincs olyan csúcspont, amelyből kiindulva vissza lehetne jutni ugyanabba a csúcspontba az élek irányát követve. === Tulajdonságok === ==== Topologikus rendezés ==== Egy DAG-ra létezik olyan lineáris sorrend, amelyben minden él <math>(u, v) \in E</math> esetén <math>u</math> megelőzi <math>v</math>-t. Ezt a sorrendet topologikus rendezésnek nevezzük. ==== Gyökér és levelek ==== * '''Gyökér:''' Egy olyan csúcs, amelybe nem mutat él. * '''Levél:''' Egy olyan csúcs, amelyből nem indul él. ==== Források és nyelők ==== * '''Forrás:''' Egy csúcs, amelynek nincs bejövő éle. * '''Nyelő:''' Egy csúcs, amelynek nincs kimenő éle. ==== Átmérő ==== A DAG átmérője a leghosszabb út hossza bármely két csúcs között, ahol az út az élek irányát követi. === Fontos tételek === ==== Topologikus rendezés tétele ==== Egy gráf pontosan akkor topologikusan rendezhető, ha DAG. A topologikus rendezés léte egyértelmű bizonyítéka annak, hogy a gráf körmentes. ==== DAG felbontási tétele ==== Bármely irányított gráf felbontható DAG komponensekre úgy, hogy az eredeti gráf erős összefüggő komponensei alkotják ezeket a DAG-okat. === Algoritmusok === ==== Topologikus rendezés keresése ==== 1. Számítsuk ki minden csúcs bejövő fokát (indegree). 2. Helyezzük a bejövő fok nélküli csúcsokat egy sorba. 3. Távolítsuk el az ilyen csúcsokat a gráfból, és csökkentsük a hozzájuk kapcsolódó csúcsok bejövő fokát. 4. Ismételjük, amíg minden csúcsot feldolgoztunk. ==== Kör keresése DAG-ban ==== Egy DAG-ban a körök jelenlétét egyszerűen topologikus rendezéssel ellenőrizhetjük. Ha a rendezés nem lehetséges, akkor a gráf nem DAG. ==== Hosszú út keresése ==== Egy DAG-ban a leghosszabb út keresése dinamikus programozási technikával hatékonyan elvégezhető, mivel a körmentesség miatt az alproblémák jól definiáltak. === Alkalmazások === * '''Ütemezés:''' DAG-ok használatosak projektek tevékenységeinek ütemezésére (például PERT diagramok). * '''Adatfolyamok:''' Egyes számítógépes programok adatfüggőségeinek ábrázolására DAG-okat alkalmaznak. * '''Verziókezelés:''' Verziókezelő rendszerekben a DAG-ok mutatják a változások hierarchiáját és kapcsolatait. * '''Fordítás:''' A fordítóprogramok DAG-okat használnak az optimalizáció során, például az utasítások újrarendezéséhez. === Példák === ==== PERT hálózat ==== A PERT hálózat egy DAG, amely tevékenységek és azok sorrendiségének ábrázolására szolgál. A tevékenységek csúcsok, az élek pedig az időbeli függőségeket jelölik. ==== Verziókezelő gráf ==== A verziókezelő rendszerek, mint a Git, DAG-ot használnak a különböző commitok és ágaik kapcsolatrendszerének leírására. {{-ford-}} *{{en}}: {{t+|en|directed acyclic graph}} *{{ru}}: {{t+|ru|направленный ациклический граф}} {{hunl}} 8pxkqmt9ele5temgql8mirqgf92d8kz 0 429092 3479385 2809126 2024-12-12T13:31:58Z LinguisticMystic 22848 3479385 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|komb}} *{{en}}: {{t|en|graph theory}} *{{fr}}: {{t|fr|théorie de graphes}} *{{de}}: {{t|de|Graphentheorie}} *{{ru}}: {{t|ru|теория графов}} {{hunl}} k7ioetevyedmog5pxs7ma4wxo31vhy4 3479395 3479385 2024-12-12T13:50:16Z LinguisticMystic 22848 3479395 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|komb}} A gráfelmélet a matematika és az informatika egyik ága, amely a gráfok tulajdonságait és alkalmazásait vizsgálja. A gráf egy olyan struktúra, amely csúcsokból (pontokból) és élekből (vonalakból) áll, és gyakran használják kapcsolati rendszerek, hálózatok modellezésére. <span id="gráf-alapfogalmak"></span> === Gráf alapfogalmak === # '''Csúcsok (V):''' A gráf alapelemei, amelyeket pontokként ábrázolunk. # '''Élek (E):''' A csúcsokat összekötő vonalak vagy kapcsolatok. # '''Irányítatlan gráf:''' Az élek nem irányítottak, tehát az ( (u, v) ) él azonos ( (v, u) )-val. # '''Irányított gráf:''' Az éleknek iránya van, tehát az ( (u, v) ) él különbözik ( (v, u) )-tól. # '''Súlyozott gráf:''' Az élekhez egy érték (súly) van rendelve, például távolság vagy költség. # '''Ciklikus gráf:''' Olyan gráf, amely tartalmaz kört. # '''Aciklikus gráf:''' Olyan gráf, amely nem tartalmaz kört. # '''Összefüggő gráf:''' Bármely két csúcs között létezik út. <span id="gráfelméleti-problémák"></span> === Gráfelméleti problémák === # '''Legkisebb feszítőfa:''' Hogyan lehet a gráf összes csúcsát összekötni úgy, hogy az élek súlyainak összege minimális legyen? (Pl. Kruskal- vagy Prim-algoritmus) # '''Legrövidebb út:''' Hogyan található meg a legkisebb súlyú út két csúcs között? (Pl. Dijkstra-algoritmus) # '''Maximális folyam:''' Mi a maximális érték, amit egy forrásból egy célig lehet eljuttatni egy hálózaton? (Pl. Ford-Fulkerson-algoritmus) # '''Színezés:''' Hogyan lehet a gráf csúcsait a lehető legkevesebb színnel kiszínezni úgy, hogy két szomszédos csúcs ne legyen azonos színű? # '''Euler-út és kör:''' Létezik-e olyan út, amely minden élen pontosan egyszer halad át? (Euler-út) # '''Hamilton-út és kör:''' Létezik-e olyan út, amely minden csúcson pontosan egyszer halad át? (Hamilton-út) <span id="alkalmazási-területek"></span> === Alkalmazási területek === * '''Hálózatok:''' Internet, közlekedési rendszerek, áramhálózatok. * '''Optimalizálás:''' Szállítási útvonalak, erőforrás-elosztás. * '''Adatbázisok:''' Kapcsolati modellek. * '''Szociális hálók:''' Kapcsolati struktúrák elemzése. * '''Biológia:''' Molekuláris hálózatok, genomika. *{{en}}: {{t|en|graph theory}} *{{fr}}: {{t|fr|théorie de graphes}} *{{de}}: {{t|de|Graphentheorie}} *{{ru}}: {{t|ru|теория графов}} {{hunl}} n0dkerrthi4vkcwon3hjglw1mr7ht6i 3479421 3479395 2024-12-12T17:26:38Z LinguisticMystic 22848 3479421 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|komb|gráfelmélet}} A gráfelmélet a matematika és az informatika egyik ága, amely a gráfok tulajdonságait és alkalmazásait vizsgálja. A gráf egy olyan struktúra, amely csúcsokból (pontokból) és élekből (vonalakból) áll, és gyakran használják kapcsolati rendszerek, hálózatok modellezésére. <span id="gráf-alapfogalmak"></span> === Gráf alapfogalmak === # '''Csúcsok (V):''' A gráf alapelemei, amelyeket pontokként ábrázolunk. # '''Élek (E):''' A csúcsokat összekötő vonalak vagy kapcsolatok. # '''Irányítatlan gráf:''' Az élek nem irányítottak, tehát az ( (u, v) ) él azonos ( (v, u) )-val. # '''Irányított gráf:''' Az éleknek iránya van, tehát az ( (u, v) ) él különbözik ( (v, u) )-tól. # '''Súlyozott gráf:''' Az élekhez egy érték (súly) van rendelve, például távolság vagy költség. # '''Ciklikus gráf:''' Olyan gráf, amely tartalmaz kört. # '''Aciklikus gráf:''' Olyan gráf, amely nem tartalmaz kört. # '''Összefüggő gráf:''' Bármely két csúcs között létezik út. <span id="gráfelméleti-problémák"></span> === Gráfelméleti problémák === # '''Legkisebb feszítőfa:''' Hogyan lehet a gráf összes csúcsát összekötni úgy, hogy az élek súlyainak összege minimális legyen? (Pl. Kruskal- vagy Prim-algoritmus) # '''Legrövidebb út:''' Hogyan található meg a legkisebb súlyú út két csúcs között? (Pl. Dijkstra-algoritmus) # '''Maximális folyam:''' Mi a maximális érték, amit egy forrásból egy célig lehet eljuttatni egy hálózaton? (Pl. Ford-Fulkerson-algoritmus) # '''Színezés:''' Hogyan lehet a gráf csúcsait a lehető legkevesebb színnel kiszínezni úgy, hogy két szomszédos csúcs ne legyen azonos színű? # '''Euler-út és kör:''' Létezik-e olyan út, amely minden élen pontosan egyszer halad át? (Euler-út) # '''Hamilton-út és kör:''' Létezik-e olyan út, amely minden csúcson pontosan egyszer halad át? (Hamilton-út) <span id="alkalmazási-területek"></span> === Alkalmazási területek === * '''Hálózatok:''' Internet, közlekedési rendszerek, áramhálózatok. * '''Optimalizálás:''' Szállítási útvonalak, erőforrás-elosztás. * '''Adatbázisok:''' Kapcsolati modellek. * '''Szociális hálók:''' Kapcsolati struktúrák elemzése. * '''Biológia:''' Molekuláris hálózatok, genomika. *{{en}}: {{t|en|graph theory}} *{{fr}}: {{t|fr|théorie de graphes}} *{{de}}: {{t|de|Graphentheorie}} *{{ru}}: {{t|ru|теория графов}} {{hunl}} 3b9lroxqcyhd400ojpxrbhgzp4k3my6 0 430126 3479415 2849450 2024-12-12T17:10:26Z LinguisticMystic 22848 3479415 wikitext text/x-wiki {{hunfn}} # {{label|hu|fizika}} {{-ford-}} *{{en}}: {{t|en|digital technology}} {{hunl}} atths6ysm51cgsoa1vcmlu2atls5ry3 0 430200 3479443 3451046 2024-12-12T20:23:42Z LinguisticMystic 22848 3479443 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|informatika|algo}} A '''bináris keresés''' egy hatékony keresési algoritmus, amely rendezetten tárolt elemek között működik. Az algoritmus ismételten megfelezi a keresési tartományt, amíg a keresett értéket meg nem találja, vagy amíg a keresési tartomány üres nem lesz. ----- <span id="elmélet"></span> === '''Elmélet''' === <span id="algoritmus-működése"></span> ==== '''Algoritmus működése''': ==== # Kezdjük a teljes lista (tömb) első és utolsó indexével. # Határozzuk meg a középső elemet: [ = ] # Hasonlítsuk össze a középső elemet a keresett értékkel: #* Ha a középső elem megegyezik, a keresett elemet megtaláltuk. #* Ha a középső elem kisebb, folytassuk a keresést a középső elem jobb oldali részén. #* Ha a középső elem nagyobb, folytassuk a keresést a bal oldali részen. # Ismételjük, amíg a keresési tartomány üres nem lesz. ----- <span id="tulajdonságok"></span> === '''Tulajdonságok''' === * '''Időkomplexitás''': (O(n)), mivel minden lépésben megfelezzük a keresési tartományt. * '''Térkomplexitás''': (O(1)) iteratív változatban, (O(n)) rekurzív változatban a rekurzív hívások miatt. * Csak '''rendezett tömb''' esetén alkalmazható. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <span id="iteratív-változat"></span> ==== '''Iteratív változat''' ==== <pre>BinarySearch(A, x): bal = 0 jobb = A hossza - 1 amíg bal ≤ jobb: közép = (bal + jobb) // 2 ha A[közép] == x: visszatér közép ha A[közép] &lt; x: bal = közép + 1 különben: jobb = közép - 1 visszatér -1 // Nem található</pre> <span id="rekurzív-változat"></span> ==== '''Rekurzív változat''' ==== <pre>BinarySearchRec(A, x, bal, jobb): ha bal &gt; jobb: visszatér -1 // Nem található közép = (bal + jobb) // 2 ha A[közép] == x: visszatér közép ha A[közép] &lt; x: visszatér BinarySearchRec(A, x, közép + 1, jobb) különben: visszatér BinarySearchRec(A, x, bal, közép - 1)</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <span id="iteratív-változat-1"></span> ==== '''Iteratív változat''' ==== <syntaxhighlight lang="python">def binary_search(arr, x): left, right = 0, len(arr) - 1 while left <= right: mid = (left + right) // 2 if arr[mid] == x: return mid # Elemek indexe elif arr[mid] < x: left = mid + 1 else: right = mid - 1 return -1 # Elem nem található # Példa data = [2, 3, 4, 10, 40] x = 10 result = binary_search(data, x) if result != -1: print(f"Elem megtalálva a {result}. indexen") else: print("Elem nem található")</syntaxhighlight> <span id="rekurzív-változat-1"></span> ==== '''Rekurzív változat''' ==== <syntaxhighlight lang="python">def binary_search_recursive(arr, x, left, right): if left > right: return -1 # Elem nem található mid = (left + right) // 2 if arr[mid] == x: return mid elif arr[mid] < x: return binary_search_recursive(arr, x, mid + 1, right) else: return binary_search_recursive(arr, x, left, mid - 1) # Példa data = [2, 3, 4, 10, 40] x = 10 result = binary_search_recursive(data, x, 0, len(data) - 1) if result != -1: print(f"Elem megtalálva a {result}. indexen") else: print("Elem nem található")</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <span id="iteratív-változat-2"></span> ==== '''Iteratív változat''' ==== <syntaxhighlight lang="cpp">#include <iostream> #include <vector> using namespace std; int binarySearch(const vector<int>& arr, int x) { int left = 0, right = arr.size() - 1; while (left <= right) { int mid = left + (right - left) / 2; if (arr[mid] == x) return mid; // Elemek indexe else if (arr[mid] < x) left = mid + 1; else right = mid - 1; } return -1; // Elem nem található } int main() { vector<int> data = {2, 3, 4, 10, 40}; int x = 10; int result = binarySearch(data, x); if (result != -1) cout << "Elem megtalálva a " << result << ". indexen" << endl; else cout << "Elem nem található" << endl; return 0; }</syntaxhighlight> <span id="rekurzív-változat-2"></span> ==== '''Rekurzív változat''' ==== <syntaxhighlight lang="cpp">#include <iostream> #include <vector> using namespace std; int binarySearchRecursive(const vector<int>& arr, int x, int left, int right) { if (left > right) return -1; // Elem nem található int mid = left + (right - left) / 2; if (arr[mid] == x) return mid; // Elemek indexe else if (arr[mid] < x) return binarySearchRecursive(arr, x, mid + 1, right); else return binarySearchRecursive(arr, x, left, mid - 1); } int main() { vector<int> data = {2, 3, 4, 10, 40}; int x = 10; int result = binarySearchRecursive(data, x, 0, data.size() - 1); if (result != -1) cout << "Elem megtalálva a " << result << ". indexen" << endl; else cout << "Elem nem található" << endl; return 0; }</syntaxhighlight> ----- <span id="összegzés"></span> === '''Összegzés''' === A '''bináris keresés''' egy gyors algoritmus, amely hatékonyan talál meg elemeket rendezett tömbökben. Kis térigényű és (O(n)) időkomplexitású, ezért nagy adathalmazokon különösen hasznos. Az iteratív és rekurzív változatok egyaránt könnyen implementálhatók. {{-ford-}} *{{en}}: {{t|en|binary search}} *{{de}}: {{t|de|binäres Suchen}} *{{ru}}: {{t|ru|двоичный поиск}} {{hunl}} s122pryimw5kqr0ke606khz4yei21kn 3479444 3479443 2024-12-12T20:25:57Z LinguisticMystic 22848 3479444 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|informatika|algo}} A '''bináris keresés''' egy hatékony keresési algoritmus, amely rendezetten tárolt elemek között működik. Az algoritmus ismételten megfelezi a keresési tartományt, amíg a keresett értéket meg nem találja, vagy amíg a keresési tartomány üres nem lesz. ----- <span id="elmélet"></span> === '''Elmélet''' === <span id="algoritmus-működése"></span> ==== '''Algoritmus működése''': ==== # Kezdjük a teljes lista (tömb) első és utolsó indexével. # Határozzuk meg a középső elemet: <math display="block">\text{közép} = \frac{\text{bal} + \text{jobb}}{2}</math> # Hasonlítsuk össze a középső elemet a keresett értékkel: #* Ha a középső elem megegyezik, a keresett elemet megtaláltuk. #* Ha a középső elem kisebb, folytassuk a keresést a középső elem jobb oldali részén. #* Ha a középső elem nagyobb, folytassuk a keresést a bal oldali részen. # Ismételjük, amíg a keresési tartomány üres nem lesz. ----- <span id="tulajdonságok"></span> === '''Tulajdonságok''' === * '''Időkomplexitás''': (O(n)), mivel minden lépésben megfelezzük a keresési tartományt. * '''Térkomplexitás''': (O(1)) iteratív változatban, (O(n)) rekurzív változatban a rekurzív hívások miatt. * Csak '''rendezett tömb''' esetén alkalmazható. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <span id="iteratív-változat"></span> ==== '''Iteratív változat''' ==== <pre>BinarySearch(A, x): bal = 0 jobb = A hossza - 1 amíg bal ≤ jobb: közép = (bal + jobb) // 2 ha A[közép] == x: visszatér közép ha A[közép] &lt; x: bal = közép + 1 különben: jobb = közép - 1 visszatér -1 // Nem található</pre> <span id="rekurzív-változat"></span> ==== '''Rekurzív változat''' ==== <pre>BinarySearchRec(A, x, bal, jobb): ha bal &gt; jobb: visszatér -1 // Nem található közép = (bal + jobb) // 2 ha A[közép] == x: visszatér közép ha A[közép] &lt; x: visszatér BinarySearchRec(A, x, közép + 1, jobb) különben: visszatér BinarySearchRec(A, x, bal, közép - 1)</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <span id="iteratív-változat-1"></span> ==== '''Iteratív változat''' ==== <syntaxhighlight lang="python">def binary_search(arr, x): left, right = 0, len(arr) - 1 while left <= right: mid = (left + right) // 2 if arr[mid] == x: return mid # Elemek indexe elif arr[mid] < x: left = mid + 1 else: right = mid - 1 return -1 # Elem nem található # Példa data = [2, 3, 4, 10, 40] x = 10 result = binary_search(data, x) if result != -1: print(f"Elem megtalálva a {result}. indexen") else: print("Elem nem található")</syntaxhighlight> <span id="rekurzív-változat-1"></span> ==== '''Rekurzív változat''' ==== <syntaxhighlight lang="python">def binary_search_recursive(arr, x, left, right): if left > right: return -1 # Elem nem található mid = (left + right) // 2 if arr[mid] == x: return mid elif arr[mid] < x: return binary_search_recursive(arr, x, mid + 1, right) else: return binary_search_recursive(arr, x, left, mid - 1) # Példa data = [2, 3, 4, 10, 40] x = 10 result = binary_search_recursive(data, x, 0, len(data) - 1) if result != -1: print(f"Elem megtalálva a {result}. indexen") else: print("Elem nem található")</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <span id="iteratív-változat-2"></span> ==== '''Iteratív változat''' ==== <syntaxhighlight lang="cpp">#include <iostream> #include <vector> using namespace std; int binarySearch(const vector<int>& arr, int x) { int left = 0, right = arr.size() - 1; while (left <= right) { int mid = left + (right - left) / 2; if (arr[mid] == x) return mid; // Elemek indexe else if (arr[mid] < x) left = mid + 1; else right = mid - 1; } return -1; // Elem nem található } int main() { vector<int> data = {2, 3, 4, 10, 40}; int x = 10; int result = binarySearch(data, x); if (result != -1) cout << "Elem megtalálva a " << result << ". indexen" << endl; else cout << "Elem nem található" << endl; return 0; }</syntaxhighlight> <span id="rekurzív-változat-2"></span> ==== '''Rekurzív változat''' ==== <syntaxhighlight lang="cpp">#include <iostream> #include <vector> using namespace std; int binarySearchRecursive(const vector<int>& arr, int x, int left, int right) { if (left > right) return -1; // Elem nem található int mid = left + (right - left) / 2; if (arr[mid] == x) return mid; // Elemek indexe else if (arr[mid] < x) return binarySearchRecursive(arr, x, mid + 1, right); else return binarySearchRecursive(arr, x, left, mid - 1); } int main() { vector<int> data = {2, 3, 4, 10, 40}; int x = 10; int result = binarySearchRecursive(data, x, 0, data.size() - 1); if (result != -1) cout << "Elem megtalálva a " << result << ". indexen" << endl; else cout << "Elem nem található" << endl; return 0; }</syntaxhighlight> ----- <span id="összegzés"></span> === '''Összegzés''' === A '''bináris keresés''' egy gyors algoritmus, amely hatékonyan talál meg elemeket rendezett tömbökben. Kis térigényű és (O(n)) időkomplexitású, ezért nagy adathalmazokon különösen hasznos. Az iteratív és rekurzív változatok egyaránt könnyen implementálhatók. {{-ford-}} *{{en}}: {{t|en|binary search}} *{{de}}: {{t|de|binäres Suchen}} *{{ru}}: {{t|ru|двоичный поиск}} {{hunl}} 179s75587jl7cy6687gw88b4p9k8grx 0 430259 3479435 2808645 2024-12-12T17:45:42Z LinguisticMystic 22848 3479435 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|gráf|algo}} A Dijkstra-algoritmus egy [[mohó algoritmus]], amivel irányított vagy irányítás nélküli gráfokban lehet megkeresni a legrövidebb utakat egy adott csúcspontból kiindulva. {{-ford-}} *{{en}}: {{t|en|Dijkstra's algorithm}} {{hunl}} r2wjn2giexf30aot75kv40adakclcj2 3479438 3479435 2024-12-12T20:08:19Z LinguisticMystic 22848 3479438 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|gráf|algo}} A Dijkstra-algoritmus egy [[mohó algoritmus]], amivel irányított vagy irányítás nélküli gráfokban lehet megkeresni a legrövidebb utakat egy adott csúcspontból kiindulva. ---- <span id="dijkstra-algoritmus-bemutatása"></span> === '''Dijkstra-algoritmus bemutatása''' === A '''Dijkstra-algoritmus''' egy gráfkeresési algoritmus, amely a legrövidebb út meghatározására szolgál egy súlyozott gráf adott kezdőcsúcsából az összes többi csúcsba. Az algoritmus csak nem negatív élű gráfok esetén működik korrekt módon. ----- <span id="elmélet"></span> === '''Elmélet''' === <span id="lépései"></span> ==== '''Lépései''': ==== # '''Kezdet''': #* Hozzunk létre egy távolságtömböt ((distance)), amely minden csúcs számára a legrövidebb ismert távolságot tárolja a kezdőcsúcstól. Kezdetben a kezdőcsúcs távolsága 0, a többi csúcsé pedig () (végtelen). #* Tartsunk nyilván egy prioritási sort vagy minimum halmazt, amely a következő csúcs kiválasztására szolgál a feldolgozás során. # '''Ismétlés''': #* Válasszuk ki a prioritási sorból azt a csúcsot, amelyhez a legkisebb távolság tartozik, és nevezzük ezt az aktuális csúcsnak. #* Frissítsük az aktuális csúcs összes szomszédjának távolságát, ha a kezdőcsúcstól az aktuális csúcson keresztül rövidebb utat találunk. # '''Vég''': #* Az algoritmus befejeződik, amikor minden csúcsot meglátogattunk, vagy a prioritási sor üres. <span id="fontos-tulajdonságok"></span> ==== '''Fontos tulajdonságok''': ==== * '''Időkomplexitás''': ** Egyszerű megvalósítás esetén: (O(V^2)). ** Prioritási sorral (pl. minimumkúppal): (O((V + E) V)), ahol (V) a csúcsok száma, (E) pedig az élek száma. * '''Térkomplexitás''': (O(V + E)), a gráf és a távolságtömb tárolása miatt. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>Dijkstra(G, start): Távolság = [végtelen] * G.csúcsok_száma Távolság[start] = 0 Látogatott = üres halmaz Sor = PrioritásiSor() Sorba helyez(start, 0) amíg Sor nem üres: (aktuális_csúcs, távolság) = Sorból kivesz() ha aktuális_csúcs már látogatott: folytatás Látogatott.insert(aktuális_csúcs) minden szomszéd S az aktuális_csúcs szomszédai közül: új_távolság = távolság + él_súlya(aktuális_csúcs, S) ha új_távolság &lt; Távolság[S]: Távolság[S] = új_távolság Sorba helyez(S, új_távolság) visszatér Távolság</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">import heapq def dijkstra(graph, start): # Távolságok és prioritási sor inicializálása distances = {node: float('infinity') for node in graph} distances[start] = 0 priority_queue = [(0, start)] # (távolság, csúcs) while priority_queue: current_distance, current_node = heapq.heappop(priority_queue) # Ha egy rövidebb út már ismert, folytassuk if current_distance > distances[current_node]: continue # Szomszédok bejárása for neighbor, weight in graph[current_node].items(): distance = current_distance + weight # Ha rövidebb utat találunk if distance < distances[neighbor]: distances[neighbor] = distance heapq.heappush(priority_queue, (distance, neighbor)) return distances # Példa gráf graph = { 'A': {'B': 1, 'C': 4}, 'B': {'A': 1, 'C': 2, 'D': 6}, 'C': {'A': 4, 'B': 2, 'D': 3}, 'D': {'B': 6, 'C': 3} } print(dijkstra(graph, 'A')) # Kimenet: {'A': 0, 'B': 1, 'C': 3, 'D': 6}</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <queue> #include <unordered_map> #include <limits> using namespace std; typedef pair<int, int> Edge; // (távolság, csúcs) typedef unordered_map<int, unordered_map<int, int>> Graph; vector<int> dijkstra(const Graph& graph, int start, int n) { vector<int> distances(n, numeric_limits<int>::max()); distances[start] = 0; priority_queue<Edge, vector<Edge>, greater<Edge>> pq; pq.push({0, start}); while (!pq.empty()) { auto [current_distance, current_node] = pq.top(); pq.pop(); if (current_distance > distances[current_node]) continue; for (const auto& [neighbor, weight] : graph.at(current_node)) { int new_distance = current_distance + weight; if (new_distance < distances[neighbor]) { distances[neighbor] = new_distance; pq.push({new_distance, neighbor}); } } } return distances; } int main() { Graph graph = { {0, {{1, 1}, {2, 4}}}, {1, {{0, 1}, {2, 2}, {3, 6}}}, {2, {{0, 4}, {1, 2}, {3, 3}}}, {3, {{1, 6}, {2, 3}}} }; vector<int> distances = dijkstra(graph, 0, 4); for (int i = 0; i < distances.size(); ++i) { cout << "Távolság a 0-tól a(z) " << i << "-ig: " << distances[i] << endl; } return 0; }</syntaxhighlight> {{-ford-}} *{{en}}: {{t|en|Dijkstra's algorithm}} {{hunl}} 31m0ji486kkpswgejj5pxj5i5mgqusy 3479439 3479438 2024-12-12T20:11:13Z LinguisticMystic 22848 3479439 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|gráf|algo}} A Dijkstra-algoritmus egy [[mohó algoritmus]], amivel irányított vagy irányítás nélküli gráfokban lehet megkeresni a legrövidebb utakat egy adott csúcspontból kiindulva. ---- <span id="dijkstra-algoritmus-bemutatása"></span> === '''Dijkstra-algoritmus bemutatása''' === A '''Dijkstra-algoritmus''' egy gráfkeresési algoritmus, amely a legrövidebb út meghatározására szolgál egy súlyozott gráf adott kezdőcsúcsából az összes többi csúcsba. Az algoritmus csak nem negatív élű gráfok esetén működik korrekt módon. ----- <span id="elmélet"></span> === '''Elmélet''' === <span id="lépései"></span> ==== '''Lépései''': ==== # '''Kezdet''': #* Hozzunk létre egy távolságtömböt ((distance)), amely minden csúcs számára a legrövidebb ismert távolságot tárolja a kezdőcsúcstól. Kezdetben a kezdőcsúcs távolsága 0, a többi csúcsé pedig () (végtelen). #* Tartsunk nyilván egy prioritási sort vagy minimum halmazt, amely a következő csúcs kiválasztására szolgál a feldolgozás során. # '''Ismétlés''': #* Válasszuk ki a prioritási sorból azt a csúcsot, amelyhez a legkisebb távolság tartozik, és nevezzük ezt az aktuális csúcsnak. #* Frissítsük az aktuális csúcs összes szomszédjának távolságát, ha a kezdőcsúcstól az aktuális csúcson keresztül rövidebb utat találunk. # '''Vég''': #* Az algoritmus befejeződik, amikor minden csúcsot meglátogattunk, vagy a prioritási sor üres. <span id="fontos-tulajdonságok"></span> ==== '''Fontos tulajdonságok''': ==== * '''Időkomplexitás''': ** Egyszerű megvalósítás esetén: (O(V^2)). ** Prioritási sorral (pl. minimumkúppal): (O((V + E) V)), ahol (V) a csúcsok száma, (E) pedig az élek száma. * '''Térkomplexitás''': (O(V + E)), a gráf és a távolságtömb tárolása miatt. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>Dijkstra(G, start): Távolság = [végtelen] * G.csúcsok_száma Távolság[start] = 0 Látogatott = üres halmaz Sor = PrioritásiSor() Sorba helyez(start, 0) amíg Sor nem üres: (aktuális_csúcs, távolság) = Sorból kivesz() ha aktuális_csúcs már látogatott: folytatás Látogatott.insert(aktuális_csúcs) minden szomszéd S az aktuális_csúcs szomszédai közül: új_távolság = távolság + él_súlya(aktuális_csúcs, S) ha új_távolság &lt; Távolság[S]: Távolság[S] = új_távolság Sorba helyez(S, új_távolság) visszatér Távolság</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">import heapq def dijkstra(graph, start): # Távolságok és prioritási sor inicializálása distances = {node: float('infinity') for node in graph} distances[start] = 0 priority_queue = [(0, start)] # (távolság, csúcs) while priority_queue: current_distance, current_node = heapq.heappop(priority_queue) # Ha egy rövidebb út már ismert, folytassuk if current_distance > distances[current_node]: continue # Szomszédok bejárása for neighbor, weight in graph[current_node].items(): distance = current_distance + weight # Ha rövidebb utat találunk if distance < distances[neighbor]: distances[neighbor] = distance heapq.heappush(priority_queue, (distance, neighbor)) return distances # Példa gráf graph = { 'A': {'B': 1, 'C': 4}, 'B': {'A': 1, 'C': 2, 'D': 6}, 'C': {'A': 4, 'B': 2, 'D': 3}, 'D': {'B': 6, 'C': 3} } print(dijkstra(graph, 'A')) # Kimenet: {'A': 0, 'B': 1, 'C': 3, 'D': 6}</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <queue> #include <unordered_map> #include <limits> using namespace std; // Típus alias az élek reprezentációjához (távolság, csúcs) typedef pair<int, int> Edge; // Típus alias a gráf reprezentációjához (szomszédok és élsúlyok) typedef unordered_map<int, unordered_map<int, int>> Graph; // Dijkstra-algoritmus megvalósítása vector<int> dijkstra(const Graph& graph, int start, int n) { // Távolságvektor inicializálása "végtelen" értékekkel vector<int> distances(n, numeric_limits<int>::max()); distances[start] = 0; // A kezdőcsúcs távolsága 0 // Prioritási sor (minimum prioritási sor a távolságok alapján) priority_queue<Edge, vector<Edge>, greater<Edge>> pq; pq.push({0, start}); // A kezdőcsúcs hozzáadása távolság=0 értékkel // Fő ciklus: amíg van feldolgozatlan csúcs a sorban while (!pq.empty()) { // Vegyük ki a legkisebb távolságú csúcsot auto [current_distance, current_node] = pq.top(); pq.pop(); // Ha az aktuális távolság nagyobb, mint a már ismert, hagyjuk ki if (current_distance > distances[current_node]) continue; // Járjuk be az aktuális csúcs összes szomszédját for (const auto& [neighbor, weight] : graph.at(current_node)) { // Számítsuk ki az új potenciális távolságot a szomszédhoz int new_distance = current_distance + weight; // Ha az új távolság kisebb, frissítsük, és adjuk hozzá a sorhoz if (new_distance < distances[neighbor]) { distances[neighbor] = new_distance; pq.push({new_distance, neighbor}); } } } // Adjunk vissza egy vektort, ami tartalmazza az összes csúcs távolságát a kezdőcsúcstól return distances; } int main() { // Súlyozott gráf definiálása szomszédsági lista reprezentációval Graph graph = { {0, {{1, 1}, {2, 4}}}, // 0. csúcs kapcsolatai: 1 (súly 1), 2 (súly 4) {1, {{0, 1}, {2, 2}, {3, 6}}}, // 1. csúcs kapcsolatai: 0, 2, 3 {2, {{0, 4}, {1, 2}, {3, 3}}}, // 2. csúcs kapcsolatai: 0, 1, 3 {3, {{1, 6}, {2, 3}}} // 3. csúcs kapcsolatai: 1, 2 }; // Dijkstra-algoritmus meghívása a 0. csúcsból, 4 csúcsot tartalmazó gráfra vector<int> distances = dijkstra(graph, 0, 4); // Az eredmények kiíratása for (int i = 0; i < distances.size(); ++i) { cout << "Távolság a 0-tól a(z) " << i << "-ig: " << distances[i] << endl; } return 0; // Program befejezése } </syntaxhighlight> {{-ford-}} *{{en}}: {{t|en|Dijkstra's algorithm}} {{hunl}} mt2nesht44xoxv78f36vl3bzqyue2qy 0 430270 3479464 2808301 2024-12-12T20:53:50Z LinguisticMystic 22848 3479464 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} A '''kiválasztásos rendezés''' egy egyszerű rendezési algoritmus, amely egy tömb elemeit úgy rendezi, hogy minden lépésben kiválasztja a legkisebb (vagy legnagyobb) elemet, és a megfelelő pozícióba helyezi. Az algoritmus logikája könnyen érthető és implementálható, de időigényesebb, mint hatékonyabb algoritmusok, például a gyorsrendezés vagy az egyesítős rendezés. ----- <span id="működése"></span> === '''Működése''' === # '''Részhalmaz kiválasztása''': #* A tömb minden iterációjában a hátralévő részhalmaz legkisebb (vagy legnagyobb) elemét keressük meg. # '''Csere''': #* A kiválasztott elemet kicseréljük az aktuális részhalmaz első elemével. # '''Ismétlés''': #* A folyamatot megismételjük a tömb második, harmadik, és így tovább tartó részhalmazára. ----- <span id="tulajdonságok"></span> === '''Tulajdonságok''' === * '''Időkomplexitás''': ** Legjobb eset: (O(n^2)). ** Legrosszabb eset: (O(n^2)). ** Független az elemek kezdeti sorrendjétől. * '''Térkomplexitás''': (O(1)), mert nem használ extra memóriát. * '''Stabilitás''': Nem stabil, mivel az elemek cseréje megváltoztathatja az azonos értékű elemek sorrendjét. * '''Egyszerűség''': Könnyen érthető és implementálható, de nem hatékony nagy adathalmazokon. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>SelectionSort(A): n = A hossza ciklus i = 0-tól n-1-ig: min_index = i ciklus j = i+1-től n-ig: ha A[j] &lt; A[min_index]: min_index = j cseréljük meg A[i] és A[min_index] értékét</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def selection_sort(arr): n = len(arr) for i in range(n): # Keressük meg a legkisebb elemet a hátralévő részhalmazban min_index = i for j in range(i + 1, n): if arr[j] < arr[min_index]: min_index = j # Cseréljük ki az aktuális elemmel arr[i], arr[min_index] = arr[min_index], arr[i] # Példa data = [64, 25, 12, 22, 11] selection_sort(data) print("Rendezett tömb:", data) # Kimenet: Rendezett tömb: [11, 12, 22, 25, 64]</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> using namespace std; void selectionSort(vector<int>& arr) { int n = arr.size(); for (int i = 0; i < n - 1; ++i) { int min_index = i; // Keressük meg a legkisebb elemet a hátralévő részhalmazban for (int j = i + 1; j < n; ++j) { if (arr[j] < arr[min_index]) { min_index = j; } } // Cseréljük ki az aktuális elemmel swap(arr[i], arr[min_index]); } } int main() { vector<int> data = {64, 25, 12, 22, 11}; selectionSort(data); cout << "Rendezett tömb: "; for (int num : data) { cout << num << " "; } cout << endl; return 0; }</syntaxhighlight> ----- <span id="optimalizációk"></span> === '''Optimalizációk''' === # '''Stabil verzió''': #* Ha fontos a stabilitás, akkor ne cseréljük ki az elemeket, hanem helyezzük be a legkisebb elemet a megfelelő helyre az aktuális részhalmaz elején. # '''Korai kilépés''': #* Bár a kiválasztásos rendezés nem függ a kezdeti sorrendtől, a keresési folyamat során megvizsgálhatjuk, hogy a tömb már rendezett-e. ----- <span id="összegzés"></span> === '''Összegzés''' === A '''kiválasztásos rendezés''' egyszerűsége miatt gyakran oktatási célokra használatos. Bár a kis memóriaigénye és könnyű implementálhatósága előny, az időkomplexitása miatt nagyobb adathalmazokon nem hatékony. Ha gyors rendezési algoritmusra van szükség, érdemes más módszereket, például a gyorsrendezést vagy az egyesítős rendezést használni. {{-ford-}} *{{en}}: {{t|en|selection sort}} {{hunl}} a7lzzyw1zf0t2urtk7v1svvv11lf3hp 0 430274 3479446 2808319 2024-12-12T20:31:37Z LinguisticMystic 22848 3479446 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} A '''buborékrendezés''' egy egyszerű, ám kevésbé hatékony rendezési algoritmus. Az algoritmus páronként összehasonlítja az elemeket, és szükség esetén megcseréli őket, hogy az adott iteráció végén a legnagyobb (vagy legkisebb) elem a megfelelő helyre kerüljön. ----- <span id="elméleti-működés"></span> === '''Elméleti működés''' === <span id="algoritmus-lépései"></span> ==== '''Algoritmus lépései''': ==== # Vegyük az első két elemet, hasonlítsuk össze őket. # Ha a bal oldali nagyobb, mint a jobb oldali, cseréljük meg őket. # Folytassuk az összehasonlítást az egész tömbön. # Az első iteráció végére a legnagyobb elem a tömb végére kerül. # Ismételjük meg a folyamatot az elemek egyre csökkenő részhalmazán. <span id="optimalizált-változat"></span> ==== '''Optimalizált változat''': ==== Ha egy iteráció során nem történt csere, a tömb már rendezett, és az algoritmus befejezhető. ----- <span id="tulajdonságok"></span> === '''Tulajdonságok''' === * '''Időkomplexitás''': ** Legrosszabb eset: (O(n^2)) (ha a tömb fordított sorrendű). ** Legjobb eset: (O(n)) (ha a tömb már rendezett, optimalizált változatban). * '''Térkomplexitás''': (O(1)) (helyben működik, nincs szükség extra memóriára). * '''Stabilitás''': Stabil, mert nem változtatja meg az azonos értékű elemek sorrendjét. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <span id="egyszerű-buborékrendezés"></span> ==== '''Egyszerű buborékrendezés''' ==== <pre>BubbleSort(A): n = A hossza ciklus i = 0-tól n-1-ig: ciklus j = 0-tól n-i-2-ig: ha A[j] &gt; A[j+1]: cseréljük meg A[j] és A[j+1] értékét</pre> <span id="optimalizált-buborékrendezés"></span> ==== '''Optimalizált buborékrendezés''' ==== <pre>BubbleSortOptimized(A): n = A hossza ciklus i = 0-tól n-1-ig: swapped = hamis ciklus j = 0-tól n-i-2-ig: ha A[j] &gt; A[j+1]: cseréljük meg A[j] és A[j+1] értékét swapped = igaz ha swapped = hamis: törés</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <span id="egyszerű-változat"></span> ==== '''Egyszerű változat''' ==== <syntaxhighlight lang="python">def bubble_sort(arr): n = len(arr) for i in range(n): for j in range(0, n - i - 1): if arr[j] > arr[j + 1]: arr[j], arr[j + 1] = arr[j + 1], arr[j] # Példa data = [64, 34, 25, 12, 22, 11, 90] bubble_sort(data) print("Rendezett tömb:", data) # Kimenet: Rendezett tömb: [11, 12, 22, 25, 34, 64, 90]</syntaxhighlight> <span id="optimalizált-változat-1"></span> ==== '''Optimalizált változat''' ==== <syntaxhighlight lang="python">def bubble_sort_optimized(arr): n = len(arr) for i in range(n): swapped = False for j in range(0, n - i - 1): if arr[j] > arr[j + 1]: arr[j], arr[j + 1] = arr[j + 1], arr[j] swapped = True if not swapped: break # Példa data = [64, 34, 25, 12, 22, 11, 90] bubble_sort_optimized(data) print("Rendezett tömb:", data) # Kimenet: Rendezett tömb: [11, 12, 22, 25, 34, 64, 90]</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <span id="egyszerű-változat-1"></span> ==== '''Egyszerű változat''' ==== <syntaxhighlight lang="cpp">#include <iostream> #include <vector> using namespace std; void bubbleSort(vector<int>& arr) { int n = arr.size(); for (int i = 0; i < n - 1; ++i) { for (int j = 0; j < n - i - 1; ++j) { if (arr[j] > arr[j + 1]) { swap(arr[j], arr[j + 1]); } } } } int main() { vector<int> data = {64, 34, 25, 12, 22, 11, 90}; bubbleSort(data); cout << "Rendezett tömb: "; for (int num : data) { cout << num << " "; } cout << endl; return 0; }</syntaxhighlight> <span id="optimalizált-változat-2"></span> ==== '''Optimalizált változat''' ==== <syntaxhighlight lang="cpp">#include <iostream> #include <vector> using namespace std; void bubbleSortOptimized(vector<int>& arr) { int n = arr.size(); for (int i = 0; i < n - 1; ++i) { bool swapped = false; for (int j = 0; j < n - i - 1; ++j) { if (arr[j] > arr[j + 1]) { swap(arr[j], arr[j + 1]); swapped = true; } } if (!swapped) { break; } } } int main() { vector<int> data = {64, 34, 25, 12, 22, 11, 90}; bubbleSortOptimized(data); cout << "Rendezett tömb: "; for (int num : data) { cout << num << " "; } cout << endl; return 0; }</syntaxhighlight> ----- <span id="összegzés"></span> === '''Összegzés''' === A buborékrendezés könnyen érthető és implementálható, de nagyobb adathalmazok esetén nem hatékony, mivel az időkomplexitása (O(n^2)). Az optimalizált változat azonban felismeri, ha a lista már rendezett, és időt takarít meg. Ez az algoritmus elsősorban oktatási célokra alkalmas. {{-ford-}} *{{en}}: {{t|en|bubble sort}} *{{fr}}: {{t|fr|tri à bulles}} btr6i05c0xkn5d70j3lpozlnl59grt3 3479447 3479446 2024-12-12T20:32:12Z LinguisticMystic 22848 3479447 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} A '''buborékrendezés''' egy egyszerű, ám kevésbé hatékony rendezési algoritmus. Az algoritmus páronként összehasonlítja az elemeket, és szükség esetén megcseréli őket, hogy az adott iteráció végén a legnagyobb (vagy legkisebb) elem a megfelelő helyre kerüljön. ----- <span id="elméleti-működés"></span> === '''Elméleti működés''' === <span id="algoritmus-lépései"></span> ==== '''Algoritmus lépései''': ==== # Vegyük az első két elemet, hasonlítsuk össze őket. # Ha a bal oldali nagyobb, mint a jobb oldali, cseréljük meg őket. # Folytassuk az összehasonlítást az egész tömbön. # Az első iteráció végére a legnagyobb elem a tömb végére kerül. # Ismételjük meg a folyamatot az elemek egyre csökkenő részhalmazán. <span id="optimalizált-változat"></span> ==== '''Optimalizált változat''': ==== Ha egy iteráció során nem történt csere, a tömb már rendezett, és az algoritmus befejezhető. ----- <span id="tulajdonságok"></span> === '''Tulajdonságok''' === * '''Időkomplexitás''': ** Legrosszabb eset: (O(n^2)) (ha a tömb fordított sorrendű). ** Legjobb eset: (O(n)) (ha a tömb már rendezett, optimalizált változatban). * '''Térkomplexitás''': (O(1)) (helyben működik, nincs szükség extra memóriára). * '''Stabilitás''': Stabil, mert nem változtatja meg az azonos értékű elemek sorrendjét. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <span id="egyszerű-buborékrendezés"></span> ==== '''Egyszerű buborékrendezés''' ==== <pre>BubbleSort(A): n = A hossza ciklus i = 0-tól n-1-ig: ciklus j = 0-tól n-i-2-ig: ha A[j] &gt; A[j+1]: cseréljük meg A[j] és A[j+1] értékét</pre> <span id="optimalizált-buborékrendezés"></span> ==== '''Optimalizált buborékrendezés''' ==== <pre>BubbleSortOptimized(A): n = A hossza ciklus i = 0-tól n-1-ig: swapped = hamis ciklus j = 0-tól n-i-2-ig: ha A[j] &gt; A[j+1]: cseréljük meg A[j] és A[j+1] értékét swapped = igaz ha swapped = hamis: törés</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <span id="egyszerű-változat"></span> ==== '''Egyszerű változat''' ==== <syntaxhighlight lang="python">def bubble_sort(arr): n = len(arr) for i in range(n): for j in range(0, n - i - 1): if arr[j] > arr[j + 1]: arr[j], arr[j + 1] = arr[j + 1], arr[j] # Példa data = [64, 34, 25, 12, 22, 11, 90] bubble_sort(data) print("Rendezett tömb:", data) # Kimenet: Rendezett tömb: [11, 12, 22, 25, 34, 64, 90]</syntaxhighlight> <span id="optimalizált-változat-1"></span> ==== '''Optimalizált változat''' ==== <syntaxhighlight lang="python">def bubble_sort_optimized(arr): n = len(arr) for i in range(n): swapped = False for j in range(0, n - i - 1): if arr[j] > arr[j + 1]: arr[j], arr[j + 1] = arr[j + 1], arr[j] swapped = True if not swapped: break # Példa data = [64, 34, 25, 12, 22, 11, 90] bubble_sort_optimized(data) print("Rendezett tömb:", data) # Kimenet: Rendezett tömb: [11, 12, 22, 25, 34, 64, 90]</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <span id="egyszerű-változat-1"></span> ==== '''Egyszerű változat''' ==== <syntaxhighlight lang="cpp">#include <iostream> #include <vector> using namespace std; void bubbleSort(vector<int>& arr) { int n = arr.size(); for (int i = 0; i < n - 1; ++i) { for (int j = 0; j < n - i - 1; ++j) { if (arr[j] > arr[j + 1]) { swap(arr[j], arr[j + 1]); } } } } int main() { vector<int> data = {64, 34, 25, 12, 22, 11, 90}; bubbleSort(data); cout << "Rendezett tömb: "; for (int num : data) { cout << num << " "; } cout << endl; return 0; }</syntaxhighlight> <span id="optimalizált-változat-2"></span> ==== '''Optimalizált változat''' ==== <syntaxhighlight lang="cpp">#include <iostream> #include <vector> using namespace std; void bubbleSortOptimized(vector<int>& arr) { int n = arr.size(); for (int i = 0; i < n - 1; ++i) { bool swapped = false; for (int j = 0; j < n - i - 1; ++j) { if (arr[j] > arr[j + 1]) { swap(arr[j], arr[j + 1]); swapped = true; } } if (!swapped) { break; } } } int main() { vector<int> data = {64, 34, 25, 12, 22, 11, 90}; bubbleSortOptimized(data); cout << "Rendezett tömb: "; for (int num : data) { cout << num << " "; } cout << endl; return 0; }</syntaxhighlight> ----- <span id="összegzés"></span> === '''Összegzés''' === A buborékrendezés könnyen érthető és implementálható, de nagyobb adathalmazok esetén nem hatékony, mivel az időkomplexitása (O(n^2)). Az optimalizált változat azonban felismeri, ha a lista már rendezett, és időt takarít meg. Ez az algoritmus elsősorban oktatási célokra alkalmas. {{-ford-}} *{{en}}: {{t|en|bubble sort}} *{{fr}}: {{t|fr|tri à bulles}} {{hunl}} jhk93ry0vvtd2jz4goek39hmmgld2bd 0 430276 3479472 2808272 2024-12-12T21:02:44Z LinguisticMystic 22848 3479472 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} [[sequential search]] {{-ford-}} *{{en}}: {{t|en|linear search}} {{hunl}} e8e6q2z3r9xkv3rsm1s8fkmrh5y4f5o 0 430278 3479442 2808304 2024-12-12T20:18:08Z LinguisticMystic 22848 3479442 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} A '''beszúrásos rendezés''' egy egyszerű, de hatékony rendezési algoritmus, amely kis méretű adathalmazok esetén jól működik. Az algoritmus úgy működik, hogy az elemeket egyenként veszi fel egy rendezett részhalmazba, miközben minden új elemet a megfelelő helyre szúr be, hogy az aktuális részhalmaz mindig rendezett maradjon. ----- <span id="elméleti-működés"></span> === '''Elméleti működés''' === <span id="algoritmus-lépései"></span> ==== '''Algoritmus lépései''': ==== # Kezdjük a lista második elemével, mivel az első elem önmagában rendezettnek tekinthető. # Vegyük az aktuális elemet (kulcs), és hasonlítsuk össze a bal oldali elemekkel. # Mozgassuk azokat az elemeket, amelyek nagyobbak a kulcsnál, egy pozícióval jobbra. # Helyezzük be a kulcsot a megfelelő pozícióba. # Ismételjük a folyamatot a lista végéig. ----- <span id="tulajdonságok"></span> === '''Tulajdonságok''' === * '''Időkomplexitás''': ** Legrosszabb eset: (O(n^2)) (ha a lista fordított sorrendű). ** Legjobb eset: (O(n)) (ha a lista már rendezett). * '''Térkomplexitás''': (O(1)) (helyben működik, nincs szükség extra memóriára). * '''Stabilitás''': Stabil (azonos értékek sorrendje nem változik). ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>InsertionSort(A): n = A hossz ciklus i = 1-től n-1-ig: kulcs = A[i] j = i - 1 amíg j &gt;= 0 és A[j] &gt; kulcs: A[j+1] = A[j] j = j - 1 A[j+1] = kulcs</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def insertion_sort(arr): for i in range(1, len(arr)): key = arr[i] j = i - 1 # Mozgassuk a nagyobb elemeket jobbra while j >= 0 and arr[j] > key: arr[j + 1] = arr[j] j -= 1 # Helyezzük be a kulcsot a megfelelő helyre arr[j + 1] = key # Példa data = [12, 11, 13, 5, 6] insertion_sort(data) print("Rendezett tömb:", data) # Kimenet: Rendezett tömb: [5, 6, 11, 12, 13]</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> using namespace std; void insertionSort(vector<int>& arr) { int n = arr.size(); for (int i = 1; i < n; ++i) { int key = arr[i]; int j = i - 1; // Mozgassuk a nagyobb elemeket jobbra while (j >= 0 && arr[j] > key) { arr[j + 1] = arr[j]; --j; } // Helyezzük be a kulcsot a megfelelő helyre arr[j + 1] = key; } } int main() { vector<int> data = {12, 11, 13, 5, 6}; insertionSort(data); cout << "Rendezett tömb: "; for (int num : data) { cout << num << " "; } cout << endl; return 0; }</syntaxhighlight> ----- <span id="összegzés"></span> === '''Összegzés''' === A beszúrásos rendezés egyszerűsége miatt népszerű, különösen oktatási célokra. Kis adathalmazokon hatékony, és mivel helyben működik, memóriahasználata minimális. Nagyobb adathalmazokon azonban más rendezési algoritmusok, például a gyorsrendezés vagy a merge sort, hatékonyabbak. {{-ford-}} *{{en}}: {{t|en|insertion sort}} {{hunl}} 7zsq0orpyqz36wd9ks4i2mivpvtrrtn 0 430279 3479471 2808306 2024-12-12T21:02:35Z LinguisticMystic 22848 3479471 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} {{-ford-}} *{{en}}: {{t|en|merge sort}}, [[mergesort]] *{{ru}}: {{t|ru|сортировка слиянием}} {{hunl}} 2ygfax9f8zqip23zhr7wb11x11w8eaa 3479477 3479471 2024-12-12T21:06:30Z LinguisticMystic 22848 3479477 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} Az '''összefésülő rendezés''' egy '''oszd meg és uralkodj''' alapú rendezési algoritmus. Az algoritmus a bemeneti tömböt kisebb részekre bontja, majd ezeket a részeket rekurzívan rendezi, és végül egy lépésben összefésüli a rendezett részeket. ----- <span id="működése"></span> === '''Működése''' === # '''Oszd''': #* Bontsuk a tömböt két egyenlő méretű (vagy majdnem egyenlő) részre. # '''Rendezd''': #* Rekurzívan rendezzük a bal és a jobb részt külön-külön. # '''Fésüld össze''': #* A két rendezett részhalmazból egy rendezett tömböt készítünk az '''összefésülés''' (merge) lépésével. ----- <span id="tulajdonságok"></span> === '''Tulajdonságok''' === * '''Időkomplexitás''': Mindig (O(n n)), mivel a tömb méretét minden lépésben megfelezzük ((n)), és minden lépésben végig kell haladni az összes elemen ((n)). * '''Térkomplexitás''': (O(n)), mert az összeolvasztás során ideiglenes tárolót kell használni. * '''Stabilitás''': Stabil, mivel az azonos értékű elemek sorrendje nem változik meg. * '''Alkalmazás''': ** Nagy adathalmazokon hatékony, különösen akkor, ha az adatok nem helyben vannak (pl. fájlok). ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>MergeSort(A): ha A mérete ≤ 1: térj vissza A osszuk A-t két részre: bal és jobb bal = MergeSort(bal) jobb = MergeSort(jobb) térj vissza Merge(bal, jobb) Merge(bal, jobb): hozz létre egy üres listát, merge amíg bal és jobb nem üres: ha bal[0] ≤ jobb[0]: merge-hez adjuk hozzá bal[0]-t távolítsuk el bal[0]-t különben: merge-hez adjuk hozzá jobb[0]-t távolítsuk el jobb[0]-t adjuk hozzá merge-hez a maradék elemeket bal-ból és jobb-ból térj vissza merge</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def merge_sort(arr): if len(arr) <= 1: return arr # Tömb kettéosztása mid = len(arr) // 2 left = merge_sort(arr[:mid]) right = merge_sort(arr[mid:]) # Két részhalmaz összefésülése return merge(left, right) def merge(left, right): merged = [] i = j = 0 # Összefésülés while i < len(left) and j < len(right): if left[i] <= right[j]: merged.append(left[i]) i += 1 else: merged.append(right[j]) j += 1 # Maradék elemek hozzáadása merged.extend(left[i:]) merged.extend(right[j:]) return merged # Példa data = [38, 27, 43, 3, 9, 82, 10] sorted_data = merge_sort(data) print("Rendezett tömb:", sorted_data) # Kimenet: Rendezett tömb: [3, 9, 10, 27, 38, 43, 82]</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> using namespace std; void merge(vector<int>& arr, int left, int mid, int right) { int n1 = mid - left + 1; int n2 = right - mid; vector<int> L(n1), R(n2); for (int i = 0; i < n1; ++i) { L[i] = arr[left + i]; } for (int j = 0; j < n2; ++j) { R[j] = arr[mid + 1 + j]; } int i = 0, j = 0, k = left; while (i < n1 && j < n2) { if (L[i] <= R[j]) { arr[k] = L[i]; ++i; } else { arr[k] = R[j]; ++j; } ++k; } while (i < n1) { arr[k] = L[i]; ++i; ++k; } while (j < n2) { arr[k] = R[j]; ++j; ++k; } } void merge_sort(vector<int>& arr, int left, int right) { if (left < right) { int mid = left + (right - left) / 2; merge_sort(arr, left, mid); merge_sort(arr, mid + 1, right); merge(arr, left, mid, right); } } int main() { vector<int> data = {38, 27, 43, 3, 9, 82, 10}; merge_sort(data, 0, data.size() - 1); cout << "Rendezett tömb: "; for (int num : data) { cout << num << " "; } cout << endl; return 0; }</syntaxhighlight> '''Kimenet:''' <pre>Rendezett tömb: 3 9 10 27 38 43 82</pre> ----- <span id="optimalizációk"></span> === '''Optimalizációk''' === # '''Kisebb részek rendezése''': #* Kis méretű tömbökön érdemes beszúrásos rendezésre váltani, mivel az hatékonyabb. # '''In-place Merge Sort''': #* Helyben történő rendezést alkalmazhatunk, hogy csökkentsük a térkomplexitást (O(n))-ről (O(n))-re. ----- <span id="összegzés"></span> === '''Összegzés''' === Az '''összefésülő rendezés''' rendkívül hatékony algoritmus nagy adathalmazok rendezésére, különösen akkor, ha az elemek külső memóriában találhatók (pl. fájlok). Stabilitása és determinisztikus (O(n n)) időkomplexitása miatt számos alkalmazásban népszerű. A memóriaigénye miatt azonban helyspecifikus optimalizációk szükségesek lehetnek bizonyos esetekben. {{-ford-}} *{{en}}: {{t|en|merge sort}}, [[mergesort]] *{{ru}}: {{t|ru|сортировка слиянием}} {{hunl}} t3himv2b7d9ie9a2ayuaba0m0h7bvxf 0 430292 3479456 2809159 2024-12-12T20:49:09Z LinguisticMystic 22848 3479456 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} A Monte-Carlo-módszer egy olyan [[sztochasztikus]] szimulációs módszer, amely számítástechnikai eszközök segítségével előállítja egy adott kísérlet végeredményét, ezek után az eredményként kapott numerikus jellemzőket feljegyzik és kiértékelik. Az eredmény hibájának meghatározása szórás kiszámításával történik. Az álvéletlenszámokat, melyek a kísérletekben szereplő valószínűségi változók értékei, számítógép állítja elő. Több programnyelv is tartalmaz ilyen álvéletlenszám-generátort, pl. a C programnyelv. {{-ford-}} *{{en}}: {{t|en|Monte Carlo method}} *{{ru}}: {{t|ru|метод Монте-Карло}} {{hunl}} esjs0gmz05uc40h1a8awmrdjaddhofq 3479532 3479456 2024-12-12T22:38:19Z LinguisticMystic 22848 3479532 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} A Monte-Carlo-módszer egy olyan [[sztochasztikus]] szimulációs módszer, amely számítástechnikai eszközök segítségével előállítja egy adott kísérlet végeredményét, ezek után az eredményként kapott numerikus jellemzőket feljegyzik és kiértékelik. Az eredmény hibájának meghatározása szórás kiszámításával történik. Az álvéletlenszámokat, melyek a kísérletekben szereplő valószínűségi változók értékei, számítógép állítja elő. Több programnyelv is tartalmaz ilyen álvéletlenszám-generátort, pl. a C programnyelv. ---- <span id="monte-carlo-módszer"></span> === '''Monte-Carlo-módszer''' === A '''Monte-Carlo-módszer''' egy sztochasztikus (valószínűségi) numerikus technika, amely véletlenszerű minták generálásával becsül meg valószínűségi, matematikai vagy fizikai problémákat. A módszer nevét a Monte Carlo kaszinóról kapta, mivel erősen támaszkodik a véletlenszerűségre. ----- <span id="fő-jellemzők"></span> === '''Fő jellemzők''' === # '''Véletlenszerű minták''': #* A Monte-Carlo-módszer véletlenszerű mintákat használ a problématér mintázására. # '''Átlagolás''': #* Az eredmények átlaga a becsült érték közelítő eredményét adja. # '''Alkalmazások''': #* '''Matematikai integrálás'''. #* '''Valószínűségi eloszlások becslése'''. #* '''Fizikai szimulációk''' (pl. részecskék mozgása). #* '''Optimalizáció''' és '''kockázatmenedzsment'''. # '''Pontosság''': #* A pontosság növelhető a minták számának növelésével ((N)). A hiba általában (O(1/)). ----- <span id="algoritmus-működése"></span> === '''Algoritmus működése''' === <span id="matematikai-integrálás"></span> ==== 1. '''Matematikai integrálás''': ==== A Monte-Carlo-módszer használható egy adott (f(x)) függvény ([a, b]) intervallumban vett integráljának becslésére: [ I = _a^b f(x) , dx ] Az algoritmus lépései: 1. Generálj (N) véletlenszerű számot az ([a, b]) intervallumban. 2. Számítsd ki (f(x))-et minden véletlen (x) értékre. 3. Az integrál közelítése: [ I (b - a) _{i=1}^N f(x_i) ] ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>MonteCarloIntegrálás(f, a, b, N): sum = 0 ismételj N-szer: x = véletlen szám [a, b]-ben sum = sum + f(x) térj vissza (b - a) * (sum / N)</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <span id="egyszerű-integrálás"></span> ==== 1. '''Egyszerű integrálás''' ==== <syntaxhighlight lang="python">import random def monte_carlo_integration(f, a, b, N): total = 0 for _ in range(N): x = random.uniform(a, b) # Véletlen szám [a, b]-ben total += f(x) return (b - a) * (total / N) # Példa: integrálás [0, 1] intervallumban, f(x) = x^2 f = lambda x: x**2 a, b = 0, 1 N = 10000 result = monte_carlo_integration(f, a, b, N) print("Monte-Carlo becslés:", result)</syntaxhighlight> '''Kimenet (példa)''': <pre>Monte-Carlo becslés: 0.33345</pre> (A pontos érték: (1/3 )) ----- <span id="kör-területének-becslése"></span> ==== 2. '''Kör területének becslése''' ==== A Monte-Carlo-módszer segítségével becsülhető () értéke úgy, hogy egy egységkör területét közelítjük a véletlenszerű pontok alapján. <syntaxhighlight lang="python">import random def estimate_pi(num_points): inside_circle = 0 for _ in range(num_points): x, y = random.uniform(0, 1), random.uniform(0, 1) # Véletlen pontok [0, 1] négyzetben if x**2 + y**2 <= 1: # Ellenőrzés, hogy a pont az egységkörben van-e inside_circle += 1 return (inside_circle / num_points) * 4 # Becsüljük meg pi értékét N = 100000 pi_estimate = estimate_pi(N) print("Pi becslés:", pi_estimate)</syntaxhighlight> '''Kimenet (példa)''': <pre>Pi becslés: 3.1416</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <span id="egyszerű-integrálás-1"></span> ==== 1. '''Egyszerű integrálás''' ==== <syntaxhighlight lang="cpp">#include <iostream> #include <cmath> #include <cstdlib> double monte_carlo_integration(double (*f)(double), double a, double b, int N) { double total = 0.0; for (int i = 0; i < N; ++i) { double x = a + static_cast<double>(rand()) / RAND_MAX * (b - a); total += f(x); } return (b - a) * (total / N); } double function(double x) { return x * x; // f(x) = x^2 } int main() { double a = 0.0, b = 1.0; int N = 10000; double result = monte_carlo_integration(function, a, b, N); std::cout << "Monte-Carlo becslés: " << result << std::endl; return 0; }</syntaxhighlight> '''Kimenet''': <pre>Monte-Carlo becslés: 0.33345</pre> ----- <span id="kör-területének-becslése-1"></span> ==== 2. '''Kör területének becslése''' ==== <syntaxhighlight lang="cpp">#include <iostream> #include <cstdlib> #include <cmath> double estimate_pi(int num_points) { int inside_circle = 0; for (int i = 0; i < num_points; ++i) { double x = static_cast<double>(rand()) / RAND_MAX; double y = static_cast<double>(rand()) / RAND_MAX; if (x * x + y * y <= 1.0) { inside_circle++; } } return 4.0 * inside_circle / num_points; } int main() { int N = 100000; double pi_estimate = estimate_pi(N); std::cout << "Pi becslés: " << pi_estimate << std::endl; return 0; }</syntaxhighlight> '''Kimenet''': <pre>Pi becslés: 3.1416</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === <span id="előnyök"></span> ==== '''Előnyök''': ==== # '''Egyszerűség''': Könnyen implementálható és alkalmazható komplex problémákra. # '''Általánosíthatóság''': Különböző valószínűségi és matematikai problémákra használható. # '''Párhuzamosítható''': A véletlenszerű minták függetlensége lehetővé teszi a párhuzamos számítást. <span id="hátrányok"></span> ==== '''Hátrányok''': ==== # '''Lassú konvergencia''': A pontosság növeléséhez sok minta szükséges ((O(1/))). # '''Véletlenszám-generátorok minősége''': A pontosság függ a véletlenszám-generátor minőségétől. A Monte-Carlo-módszer különösen hasznos olyan problémák esetén, amelyek determinisztikus módszerekkel nehezen vagy egyáltalán nem oldhatók meg. Az egyszerűsége és széles körű alkalmazhatósága miatt a numerikus matematikában, szimulációkban és mesterséges intelligenciában is gyakran használják. {{-ford-}} *{{en}}: {{t|en|Monte Carlo method}} *{{ru}}: {{t|ru|метод Монте-Карло}} {{hunl}} 6zl8w3xdmrjwkdr242fye9kgt9tetvf 0 430304 3479498 2808402 2024-12-12T21:44:45Z LinguisticMystic 22848 3479498 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} <span id="gyors-fourier-transzformáció-fft---fast-fourier-transform"></span> === '''Gyors Fourier-transzformáció (FFT - Fast Fourier Transform)''' === A '''gyors Fourier-transzformáció (FFT)''' egy hatékony algoritmus a '''diszkrét Fourier-transzformáció (DFT)''' kiszámítására. Az FFT az (O(n^2)) időkomplexitású DFT-t (O(n n)) időre optimalizálja, így rendkívül hasznos a jelfeldolgozás, spektrális analízis, és más numerikus alkalmazások esetén. ----- <span id="elmélet"></span> === '''Elmélet''' === <span id="fourier-transzformáció"></span> ==== '''Fourier-transzformáció''' ==== A Fourier-transzformáció célja egy idő- vagy térbeli jelfolyamat frekvenciakomponenseinek meghatározása. A '''diszkrét Fourier-transzformáció (DFT)''' egy (x = [x_0, x_1, …, x_{n-1}]) mintavételi sorozatot alakít át komplex frekvenciaértékek sorozatává (X = [X_0, X_1, …, X_{n-1}]): [ X_k = _{j=0}^{n-1} x_j e^{-2i k j / n}, k = 0, 1, …, n-1 ] ahol (i = ) az imaginárius egység. <span id="gyors-fourier-transzformáció-fft"></span> ==== '''Gyors Fourier-transzformáció (FFT)''' ==== Az FFT a DFT kiszámításának optimalizált változata, amely a '''“oszd meg és uralkodj”''' technikát alkalmazza: 1. A bemeneti jelet páros és páratlan indexekre osztja. 2. Két kisebb DFT-t hajt végre (az egyik a páros, a másik a páratlan elemekre). 3. A DFT eredményeket kombinálja a '''“pillangó” műveletekkel''', kihasználva a periodicitás tulajdonságait. ----- <span id="időkomplexitás"></span> === '''Időkomplexitás''' === * '''DFT''': (O(n^2)). * '''FFT''': (O(n n)). ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>FFT(x): n = x hossza ha n = 1: térj vissza x ω = e^(-2πi / n) // Gyök a Fourier-transzformációhoz x páros = FFT(x[0:n:2]) x páratlan = FFT(x[1:n:2]) T = [0] * n ciklus k = 0-tól n/2-ig: T[k] = x_páros[k] + ω^k * x_páratlan[k] T[k + n/2] = x_páros[k] - ω^k * x_páratlan[k] térj vissza T</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">import numpy as np def fft(x): n = len(x) if n <= 1: return x # Páros és páratlan indexek felosztása even = fft(x[0::2]) odd = fft(x[1::2]) T = [0] * n for k in range(n // 2): t = np.exp(-2j * np.pi * k / n) * odd[k] T[k] = even[k] + t T[k + n // 2] = even[k] - t return T # Példa használat data = [0, 1, 2, 3, 4, 5, 6, 7] result = fft(data) print("FFT eredmény:") print(result)</syntaxhighlight> '''Kimenet:''' <pre>FFT eredmény: [(28+0j), (-4+9.65685424949238j), (-4+4j), (-4+1.6568542494923797j), (-4+0j), (-4-1.6568542494923797j), (-4-4j), (-4-9.65685424949238j)]</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <complex> #include <vector> #include <cmath> using namespace std; typedef complex<double> Complex; typedef vector<Complex> CArray; void fft(CArray& x) { int n = x.size(); if (n <= 1) return; // Páros és páratlan részek felosztása CArray even(n / 2); CArray odd(n / 2); for (int i = 0; i < n / 2; ++i) { even[i] = x[i * 2]; odd[i] = x[i * 2 + 1]; } // Rekurzív FFT fft(even); fft(odd); // Kombinálás for (int k = 0; k < n / 2; ++k) { Complex t = polar(1.0, -2 * M_PI * k / n) * odd[k]; x[k] = even[k] + t; x[k + n / 2] = even[k] - t; } } int main() { CArray data = {0, 1, 2, 3, 4, 5, 6, 7}; fft(data); cout << "FFT eredmény:" << endl; for (auto& c : data) { cout << c << endl; } return 0; }</syntaxhighlight> '''Kimenet:''' <pre>FFT eredmény: (28,0) (-4,9.65685) (-4,4) (-4,1.65685) (-4,0) (-4,-1.65685) (-4,-4) (-4,-9.65685)</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === <span id="előnyök"></span> ==== '''Előnyök''': ==== # Rendkívül gyors ((O(n n))). # Hatékony spektrális analízisre, szűrőkre, konvolúciókra. <span id="hátrányok"></span> ==== '''Hátrányok''': ==== # Az implementáció bonyolultabb, mint a DFT-é. # Az adatméretnek (2^k) (hatványának) kell lennie, bár ez megoldható nullákkal történő kitöltéssel. A '''gyors Fourier-transzformáció (FFT)''' kulcsfontosságú algoritmus a numerikus feldolgozásban, és széles körben alkalmazzák különböző tudományos és mérnöki területeken. {{-ford-}} *{{en}}: {{t|en|fast Fourier transform}} *{{ru}}: {{t|ru|быстрое преобразование Фурье}} {{hunl}} lpv6paq8escky3vv7pbjljvon02o670 0 430323 3479537 2306079 2024-12-12T22:46:20Z LinguisticMystic 22848 3479537 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} {{-ford-}} *{{en}}: {{t|en|hash table}} *{{ru}}: {{t|ru|хеш таблица}} {{hunl}} 2a4lactpf95sbkt38ekn659vmv2fjmp 3479538 3479537 2024-12-12T22:46:30Z LinguisticMystic 22848 3479538 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} {{-ford-}} *{{en}}: {{t|en|hash table}} *{{ru}}: {{t|ru|хеш таблица}} {{hunl}} g2zrktvj3b3o8y9hwhobgimq2n0y51c 0 430382 3479516 2808261 2024-12-12T22:10:27Z LinguisticMystic 22848 3479516 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo|gráf}} {{-ford-}} *{{en}}: {{t|en|binary search tree}} *{{ru}}: {{t|ru|двоичное дерево поиска }} {{hunl}} i8y1euap3kwjc3g7krga2e3e60uyzdc 3479517 3479516 2024-12-12T22:12:21Z LinguisticMystic 22848 3479517 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo|gráf}} A '''bináris keresőfa''' egy bináris fa adatszerkezet, amelyben minden csomópont betartja a '''keresőfa tulajdonságot''': - A '''bal részfa''' minden csomópontjának értéke kisebb, mint az adott csomópont értéke. - A '''jobb részfa''' minden csomópontjának értéke nagyobb, mint az adott csomópont értéke. ----- <span id="tulajdonságok"></span> === '''Tulajdonságok''' === # '''Struktúra''': #* Minden csomópont legfeljebb két gyerekkel rendelkezik (bal és jobb gyerek). #* Az adatok a fa bal és jobb részében rendezetten helyezkednek el. # '''Alapműveletek''': #* '''Beszúrás''': Új elem hozzáadása a fa megfelelő helyére. #* '''Keresés''': Egy adott érték megkeresése a fában. #* '''Törlés''': Egy csomópont eltávolítása, a fa tulajdonságainak megőrzésével. # '''Időkomplexitás''': #* '''Legjobb eset''' (kiegyensúlyozott fa): (O(n)). #* '''Legrosszabb eset''' (egyenetlen fa, láncolt lista): (O(n)). ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <span id="beszúrás"></span> ==== '''Beszúrás''' ==== <pre>Insert(node, key): ha node üres: hozz létre egy új csomópontot a key értékkel ha key &lt; node.value: node.left = Insert(node.left, key) különben: node.right = Insert(node.right, key) térj vissza node</pre> <span id="keresés"></span> ==== '''Keresés''' ==== <pre>Search(node, key): ha node üres vagy node.value == key: térj vissza node ha key &lt; node.value: térj vissza Search(node.left, key) különben: térj vissza Search(node.right, key)</pre> <span id="törlés"></span> ==== '''Törlés''' ==== <pre>Delete(node, key): ha node üres: térj vissza node ha key &lt; node.value: node.left = Delete(node.left, key) ha key &gt; node.value: node.right = Delete(node.right, key) különben: ha node.left üres: térj vissza node.right ha node.right üres: térj vissza node.left successor = Minimum(node.right) node.value = successor.value node.right = Delete(node.right, successor.value) térj vissza node</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">class TreeNode: def __init__(self, value): self.value = value self.left = None self.right = None class BinarySearchTree: def __init__(self): self.root = None def insert(self, node, key): if node is None: return TreeNode(key) if key < node.value: node.left = self.insert(node.left, key) else: node.right = self.insert(node.right, key) return node def search(self, node, key): if node is None or node.value == key: return node if key < node.value: return self.search(node.left, key) return self.search(node.right, key) def delete(self, node, key): if node is None: return node if key < node.value: node.left = self.delete(node.left, key) elif key > node.value: node.right = self.delete(node.right, key) else: if node.left is None: return node.right if node.right is None: return node.left successor = self.get_min(node.right) node.value = successor.value node.right = self.delete(node.right, successor.value) return node def get_min(self, node): while node.left: node = node.left return node def inorder(self, node): if node: self.inorder(node.left) print(node.value, end=" ") self.inorder(node.right) # Példa használat bst = BinarySearchTree() root = None keys = [50, 30, 20, 40, 70, 60, 80] for key in keys: root = bst.insert(root, key) print("Inorder bejárás a beszúrás után:") bst.inorder(root) print() # Keresés result = bst.search(root, 40) print("Keresés eredménye:", result.value if result else "Nincs ilyen elem") # Törlés root = bst.delete(root, 20) print("Inorder bejárás törlés után:") bst.inorder(root) print()</syntaxhighlight> '''Kimenet:''' <pre>Inorder bejárás a beszúrás után: 20 30 40 50 60 70 80 Keresés eredménye: 40 Inorder bejárás törlés után: 30 40 50 60 70 80 </pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> using namespace std; struct TreeNode { int value; TreeNode* left; TreeNode* right; TreeNode(int val) : value(val), left(nullptr), right(nullptr) {} }; class BinarySearchTree { public: TreeNode* insert(TreeNode* node, int key) { if (!node) return new TreeNode(key); if (key < node->value) node->left = insert(node->left, key); else node->right = insert(node->right, key); return node; } TreeNode* search(TreeNode* node, int key) { if (!node || node->value == key) return node; if (key < node->value) return search(node->left, key); return search(node->right, key); } TreeNode* deleteNode(TreeNode* node, int key) { if (!node) return node; if (key < node->value) { node->left = deleteNode(node->left, key); } else if (key > node->value) { node->right = deleteNode(node->right, key); } else { if (!node->left) return node->right; if (!node->right) return node->left; TreeNode* successor = getMin(node->right); node->value = successor->value; node->right = deleteNode(node->right, successor->value); } return node; } TreeNode* getMin(TreeNode* node) { while (node->left) node = node->left; return node; } void inorder(TreeNode* node) { if (!node) return; inorder(node->left); cout << node->value << " "; inorder(node->right); } }; int main() { BinarySearchTree bst; TreeNode* root = nullptr; int keys[] = {50, 30, 20, 40, 70, 60, 80}; for (int key : keys) { root = bst.insert(root, key); } cout << "Inorder bejárás a beszúrás után:" << endl; bst.inorder(root); cout << endl; // Keresés TreeNode* result = bst.search(root, 40); cout << "Keresés eredménye: " << (result ? result->value : -1) << endl; // Törlés root = bst.deleteNode(root, 20); cout << "Inorder bejárás törlés után:" << endl; bst.inorder(root); cout << endl; return 0; }</syntaxhighlight> '''Kimenet:''' <pre>Inorder bejárás a beszúrás után: 20 30 40 50 60 70 80 Keresés eredménye: 40 Inorder bejárás törlés után: 30 40 50 60 70 80 </pre> ----- <span id="összegzés"></span> === '''Összegzés''' === <span id="előnyök"></span> ==== '''Előnyök''': ==== # Könnyen érthető és implementálható. # Hatékony beszúrás, törlés és keresés kiegyensúlyozott esetekben ((O(n))). <span id="hátrányok"></span> ==== '''Hátrányok''': ==== # '''Kiegyensúlyozatlanság''': Szélsőséges esetekben a fa magassága (O(n))-re nőhet. # Az AVL- vagy Red-Black-fákhoz képest kevésbé hatékony kiegyensúlyozatlan adathalmazok esetén. A bináris keresőfa alapvető adatszerkezet, amely a rendezés és a keresés alapjául szolgál, de összetettebb problémák esetén kiegyensúlyozott változatai előnyösebbek. {{-ford-}} *{{en}}: {{t|en|binary search tree}} *{{ru}}: {{t|ru|двоичное дерево поиска }} {{hunl}} kipmdl73fho0srqg0l3zg478ne6chsc 0 430393 3479545 2809141 2024-12-12T22:58:35Z LinguisticMystic 22848 3479545 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|comptheory|gráf}} {{-ford-}} *{{en}}: {{t|en|travelling salesman problem}} *{{ru}}: {{t|ru|задача коммивояжёра}} {{hunl}} 47q82fwync42p65kg0c74vtk0k2tzgx 0 430395 3479461 2808391 2024-12-12T20:51:19Z LinguisticMystic 22848 3479461 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} A '''gyorsrendezés''' egy oszd meg és uralkodj alapú rendezési algoritmus, amely hatékonyan rendez nagy adathalmazokat. Az algoritmus a bemeneti tömböt kisebb részekre bontja, majd azokat rekurzívan rendezi. A gyorsrendezés az egyik leggyorsabb általános célú rendezési algoritmus. ----- <span id="algoritmus-működése"></span> === '''Algoritmus működése''' === # '''Pivot kiválasztása''': #* Válasszunk egy elemet (pivot) a tömbből. Ez lehet az első elem, az utolsó elem, egy véletlenszerű elem, vagy a középső elem. # '''Particionálás''': #* A tömb elemeit két részre osztjuk: #** Az egyik rész tartalmazza azokat az elemeket, amelyek kisebbek vagy egyenlőek a pivotnál. #** A másik rész tartalmazza azokat, amelyek nagyobbak. # '''Rekurzió''': #* A fenti lépést alkalmazzuk mindkét részre (a pivot nélkül), amíg a részek mérete 1 vagy 0. # '''Összefűzés''': #* A rendezett bal és jobb rész, valamint a pivot összefűzésével kapjuk a teljesen rendezett tömböt. ----- <span id="tulajdonságok"></span> === '''Tulajdonságok''' === * '''Időkomplexitás''': ** Átlagos eset: (O(n n)). ** Legrosszabb eset: (O(n^2)) (ha a pivot mindig a legkisebb vagy legnagyobb elem). * '''Térkomplexitás''': ** Helyben működő változat: (O(n)) (rekurzív hívások miatt). ** Nem helyben működő változat: (O(n)). * '''Stabilitás''': ** Nem stabil, mivel a particionálás során az azonos elemek sorrendje megváltozhat. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>QuickSort(A, bal, jobb): ha bal &lt; jobb: p = Particionál(A, bal, jobb) QuickSort(A, bal, p - 1) QuickSort(A, p + 1, jobb) Particionál(A, bal, jobb): pivot = A[jobb] i = bal - 1 ciklus j = bal-tól jobb-1-ig: ha A[j] &lt;= pivot: i = i + 1 cseréljük meg A[i] és A[j] értékét cseréljük meg A[i + 1] és A[jobb] értékét visszatér i + 1</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <span id="helyben-működő-gyorsrendezés"></span> ==== '''Helyben működő gyorsrendezés''' ==== <syntaxhighlight lang="python">def quicksort(arr, low, high): if low < high: pi = partition(arr, low, high) quicksort(arr, low, pi - 1) quicksort(arr, pi + 1, high) def partition(arr, low, high): pivot = arr[high] i = low - 1 for j in range(low, high): if arr[j] <= pivot: i += 1 arr[i], arr[j] = arr[j], arr[i] arr[i + 1], arr[high] = arr[high], arr[i + 1] return i + 1 # Példa data = [10, 7, 8, 9, 1, 5] quicksort(data, 0, len(data) - 1) print("Rendezett tömb:", data) # Kimenet: Rendezett tömb: [1, 5, 7, 8, 9, 10]</syntaxhighlight> <span id="nem-helyben-működő-gyorsrendezés-rekurzív-osztással"></span> ==== '''Nem helyben működő gyorsrendezés (rekurzív osztással)''' ==== <syntaxhighlight lang="python">def quicksort_recursive(arr): if len(arr) <= 1: return arr pivot = arr[len(arr) // 2] left = [x for x in arr if x < pivot] middle = [x for x in arr if x == pivot] right = [x for x in arr if x > pivot] return quicksort_recursive(left) + middle + quicksort_recursive(right) # Példa data = [10, 7, 8, 9, 1, 5] sorted_data = quicksort_recursive(data) print("Rendezett tömb:", sorted_data) # Kimenet: Rendezett tömb: [1, 5, 7, 8, 9, 10]</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> using namespace std; int partition(vector<int>& arr, int low, int high) { int pivot = arr[high]; int i = low - 1; for (int j = low; j < high; ++j) { if (arr[j] <= pivot) { ++i; swap(arr[i], arr[j]); } } swap(arr[i + 1], arr[high]); return i + 1; } void quicksort(vector<int>& arr, int low, int high) { if (low < high) { int pi = partition(arr, low, high); quicksort(arr, low, pi - 1); quicksort(arr, pi + 1, high); } } int main() { vector<int> data = {10, 7, 8, 9, 1, 5}; quicksort(data, 0, data.size() - 1); cout << "Rendezett tömb: "; for (int num : data) { cout << num << " "; } cout << endl; return 0; }</syntaxhighlight> ----- <span id="optimalizációk"></span> === '''Optimalizációk''' === # '''Pivot kiválasztása''': #* A középső elem vagy egy véletlenszerű elem választása csökkenti a legrosszabb eset valószínűségét. # '''Kis méretű tömbök rendezése''': #* Kis tömböknél ((n &lt; 10)) érdemes buborék- vagy beszúrásos rendezésre váltani. # '''Tail Recursion''': #* A rekurzió mélységének csökkentése érdekében a kisebb részt mindig rekurzívan dolgozzuk fel először. ----- <span id="összegzés"></span> === '''Összegzés''' === A '''gyorsrendezés''' az egyik leghatékonyabb és leggyakrabban használt rendezési algoritmus, különösen nagy adathalmazok esetén. Bár a legrosszabb esetben (O(n^2)) időigényű, az átlagos (O(n n)) időkomplexitás és az alacsony memóriaigény miatt széles körben alkalmazzák. Optimalizációkkal és helyes pivotválasztással az algoritmus szinte minden esetben gyors és hatékony. {{-ford-}} *{{en}}: {{t|en|quicksort}} {{hunl}} 7fs2ccves6pgzfmgl4x4x97kkp6pr79 0 430426 3479463 2808395 2024-12-12T20:52:22Z LinguisticMystic 22848 3479463 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} A '''kupacrendezés''' összehasonlító rendezési [[algoritmus]], és a kiválasztó rendezések családjába tartozik. Helyben rendező, nem stabil rendezés. A kupacrendezés a használt [[adatszerkezet]]ről kapta a nevét, a [[kupac|kupacról]]. A kupacrendezés működése során előbb felépíti a kupacot, majd egyesével kiemeli a [[gyökér|gyökér]]elemet, ami a kupac definíciója miatt a legnagyobb/legkisebb elem lesz. A kupacrendezés átlagos idő bonyolultsága <math>O(n\log n)</math>. {{-ford-}} *{{en}}: {{t|en|heapsort}} *{{ru}}: {{t|ru|пирамидальная сортировка }} {{hunl}} 9vqcixsxygxqm81l6ehqdhwhab6tt23 3479488 3479463 2024-12-12T21:35:42Z LinguisticMystic 22848 3479488 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} A '''kupacrendezés (Heapsort)''' egy hatékony '''helyben működő''' rendezési algoritmus, amely a '''kiválasztásos rendezés''' optimalizált változata. Az algoritmus a bináris kupac (heap) adatszerkezetet használja az elemek rendezéséhez. ----- <span id="elmélet"></span> === '''Elmélet''' === # '''Kupac definíció''': #* A kupac egy teljes bináris fa, amely eleget tesz a '''kupac tulajdonságnak''': #** '''Max-kupac''': Minden csúcs értéke nagyobb vagy egyenlő a gyermekeinek értékénél. #** '''Min-kupac''': Minden csúcs értéke kisebb vagy egyenlő a gyermekeinek értékénél. # '''Működés''': #* Az elemeket először '''max-kupaccá''' alakítjuk. #* Az így kapott max-kupac gyökerében lesz a legnagyobb elem. #* Kicseréljük a gyökér elemet a kupac utolsó elemével, majd a kupacot újjáépítjük a maradék elemekkel. #* Ezt ismételjük, amíg az összes elem rendezetté nem válik. # '''Időkomplexitás''': #* '''Építés''': (O(n)). #* '''Eltávolítás (kupac újjáépítése)''': (O(n)) elemenként. #* Összesen: (O(n n)). # '''Térkomplexitás''': #* (O(1)), mivel helyben működik (nem használ további memóriát). ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <span id="heapsort"></span> ==== '''Heapsort''' ==== <pre>HeapSort(A): n = A mérete BuildMaxHeap(A, n) ciklus i = n-1-től 1-ig: cseréljük meg A[0] és A[i] elemet MaxHeapify(A, 0, i)</pre> <span id="buildmaxheap"></span> ==== '''BuildMaxHeap''' ==== <pre>BuildMaxHeap(A, n): ciklus i = n//2-1-től 0-ig: MaxHeapify(A, i, n)</pre> <span id="maxheapify"></span> ==== '''MaxHeapify''' ==== <pre>MaxHeapify(A, i, n): left = 2*i + 1 right = 2*i + 2 largest = i ha left &lt; n és A[left] &gt; A[largest]: largest = left ha right &lt; n és A[right] &gt; A[largest]: largest = right ha largest != i: cseréljük meg A[i] és A[largest] elemet MaxHeapify(A, largest, n)</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def heapify(arr, n, i): largest = i # Gyökér left = 2 * i + 1 # Bal gyermek right = 2 * i + 2 # Jobb gyermek # Ha a bal gyermek nagyobb, mint a gyökér if left < n and arr[left] > arr[largest]: largest = left # Ha a jobb gyermek nagyobb, mint a legnagyobb if right < n and arr[right] > arr[largest]: largest = right # Ha a legnagyobb nem a gyökér if largest != i: arr[i], arr[largest] = arr[largest], arr[i] # Cseréljük heapify(arr, n, largest) def heapsort(arr): n = len(arr) # Max-kupac építése for i in range(n // 2 - 1, -1, -1): heapify(arr, n, i) # Elem eltávolítása a kupacból for i in range(n - 1, 0, -1): arr[i], arr[0] = arr[0], arr[i] # Gyökér és utolsó elem cseréje heapify(arr, i, 0) # Példa data = [12, 11, 13, 5, 6, 7] heapsort(data) print("Rendezett tömb:", data)</syntaxhighlight> '''Kimenet:''' <pre>Rendezett tömb: [5, 6, 7, 11, 12, 13]</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> using namespace std; void heapify(vector<int>& arr, int n, int i) { int largest = i; // Gyökér int left = 2 * i + 1; // Bal gyermek int right = 2 * i + 2; // Jobb gyermek // Ha a bal gyermek nagyobb, mint a gyökér if (left < n && arr[left] > arr[largest]) { largest = left; } // Ha a jobb gyermek nagyobb, mint a legnagyobb if (right < n && arr[right] > arr[largest]) { largest = right; } // Ha a legnagyobb nem a gyökér if (largest != i) { swap(arr[i], arr[largest]); heapify(arr, n, largest); // Rekurzív hívás } } void heapsort(vector<int>& arr) { int n = arr.size(); // Max-kupac építése for (int i = n / 2 - 1; i >= 0; i--) { heapify(arr, n, i); } // Elem eltávolítása a kupacból for (int i = n - 1; i > 0; i--) { swap(arr[0], arr[i]); // Gyökér és utolsó elem cseréje heapify(arr, i, 0); // Kupac újraépítése } } int main() { vector<int> data = {12, 11, 13, 5, 6, 7}; heapsort(data); cout << "Rendezett tömb: "; for (int num : data) { cout << num << " "; } cout << endl; return 0; }</syntaxhighlight> '''Kimenet:''' <pre>Rendezett tömb: 5 6 7 11 12 13</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === * '''Előnyök''': ** Stabil (O(n n)) időkomplexitás. ** Helyben működik, nincs szükség extra memóriára. * '''Hátrányok''': ** Nem stabil rendezés (az azonos elemek sorrendje megváltozhat). A '''kupacrendezés''' hatékony és megbízható módszer nagy adathalmazok rendezésére, különösen akkor, ha a memóriagazdálkodás kiemelten fontos. ---- {{-ford-}} *{{en}}: {{t|en|heapsort}} *{{ru}}: {{t|ru|пирамидальная сортировка }} {{hunl}} i05qck21ivg2rtq3ay9umj2h7ug8w1t 0 430444 3479449 2808291 2024-12-12T20:38:09Z LinguisticMystic 22848 3479449 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} Eratoszthenész szitája a neves ókori görög matematikus, Eratoszthenész módszere, melynek segítségével egyszerű kizárásos algoritmussal megállapíthatjuk, hogy melyek a prímszámok – papíron például a legkönnyebben 1 és 100 között. ---- Az '''Eratoszthenész szitája''' egy hatékony algoritmus, amely a prímszámok meghatározására szolgál egy adott számig ((n)). Az algoritmus alapelve, hogy a prímszámok többszöröseit lépésenként kizárja, így csak a prímszámok maradnak. ----- <span id="elméleti-működés"></span> === '''Elméleti működés''' === # '''Kezdeti lista''': #* Készítsünk egy listát (2)-tól (n)-ig terjedő számokkal. #* Minden számot kezdetben prímszámnak feltételezünk. # '''Többszörösök kizárása''': #* Kezdjük a (2)-es számmal (ez az első prímszám). #* Töröljük a (2)-nél nagyobb többszöröseit a listából, mivel azok nem lehetnek prímek. #* Lépjünk a következő számra, amely még a listán maradt, és ismételjük meg a folyamatot. # '''Iteráció vége''': #* Addig folytatjuk a folyamatot, amíg el nem érjük ()-et. Az ennél nagyobb számok már csak akkor maradhatnak a listán, ha prímek. # '''Eredmény''': #* Az algoritmus végén a listán maradt számok mind prímszámok. ----- <span id="tulajdonságok"></span> === '''Tulajdonságok''' === * '''Időkomplexitás''': (O(n (n))), mivel a többszörösök kizárása gyorsan halad. * '''Térkomplexitás''': (O(n)), mivel egy méretű (n)-es tömböt használunk. * Egyszerű implementációval nagyon hatékony akár nagy számok esetén is. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>EratosztheneszSzitaja(n): jelöld prímként az összes számot 2-tól n-ig ciklus p = 2-tól √n-ig: ha p prím: töröld p összes többszörösét a prímek közül visszatér az összes megmaradt prím</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def eratoszthenesz_szitaja(n): # Kezdetben minden számot prímszámként jelölünk prime = [True for _ in range(n + 1)] p = 2 while p * p <= n: if prime[p]: # Töröljük a p többszöröseit for i in range(p * p, n + 1, p): prime[i] = False p += 1 # Az összes prím visszaadása primes = [p for p in range(2, n + 1) if prime[p]] return primes # Példa n = 50 print(f"A prímszámok {n}-ig:", eratoszthenesz_szitaja(n)) # Kimenet: A prímszámok 50-ig: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> using namespace std; vector<int> eratoszthenesz_szitaja(int n) { // Kezdetben minden számot prímszámként jelölünk vector<bool> prime(n + 1, true); vector<int> primes; for (int p = 2; p * p <= n; ++p) { if (prime[p]) { // Töröljük a p többszöröseit for (int i = p * p; i <= n; i += p) { prime[i] = false; } } } // Az összes prím összegyűjtése for (int p = 2; p <= n; ++p) { if (prime[p]) { primes.push_back(p); } } return primes; } int main() { int n = 50; vector<int> primes = eratoszthenesz_szitaja(n); cout << "A prímszámok " << n << "-ig: "; for (int prime : primes) { cout << prime << " "; } cout << endl; return 0; }</syntaxhighlight> ----- <span id="optimalizáció"></span> === '''Optimalizáció''' === # '''Kezdőpont''': #* A többszörösök kizárását (p^2)-től kezdjük, mivel a kisebb többszörösök már korábban kizárásra kerültek. # '''Páros számok kihagyása''': #* Az algoritmust tovább gyorsíthatjuk azzal, hogy csak a páratlan számokat vizsgáljuk. # '''Bit-manipuláció''': #* Memóriatakarékosság érdekében bitmezőket (bitset) használhatunk a prímek jelölésére. ----- <span id="összegzés"></span> === '''Összegzés''' === Az '''Eratoszthenész szitája''' egyszerűsége és hatékonysága miatt az egyik legismertebb algoritmus a prímszámok meghatározására. Oktatási célokra is kiváló, mivel az alapötlet könnyen érthető, és nagyobb számok esetén is jól működik. Optimalizációkkal nagyon gyorssá tehető. *{{en}}: {{t|en|sieve of Eratosthenes}} *{{ru}}: {{t|ru|решето Эратосфена}} {{hunl}} szh7bdg7bhf4slr7uxefpgz0smyotv5 0 430481 3479468 2809836 2024-12-12T20:59:41Z LinguisticMystic 22848 3479468 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|gráf|algo}} A számítástudományban a piros-fekete fa alatt egy önkiegyensúlyozó bináris keresőfát értünk. A szerkezete összetett, de a gyakorlatban hatékony, hiszen a keresés, beszúrás és törlés lépésszáma a legrosszabb esetben is O(log n), ahol n a fában levő elemek száma. ---- {{-ford-}} *{{en}}: {{t|en|red-black tree}} *{{ru}}: {{t|ru|красно-чёрное дерево}} {{hunl}} ijirs1obb8yrg32see75fsoyaydks86 3479478 3479468 2024-12-12T21:09:00Z LinguisticMystic 22848 3479478 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|gráf|algo}} A számítástudományban a piros-fekete fa alatt egy önkiegyensúlyozó bináris keresőfát értünk. A szerkezete összetett, de a gyakorlatban hatékony, hiszen a keresés, beszúrás és törlés lépésszáma a legrosszabb esetben is O(log n), ahol n a fában levő elemek száma. ---- <span id="piros-fekete-fa"></span> === '''Piros-fekete fa''' === A '''piros-fekete fa''' egy bináris keresőfa, amely garantálja, hogy a beszúrás, törlés és keresés műveletek időkomplexitása (O(n)) legyen. A piros-fekete fa egy '''önkiegyensúlyozó bináris keresőfa''', amely egyensúlyi feltételek segítségével korlátozza a fa magasságát. ----- <span id="tulajdonságok"></span> === '''Tulajdonságok''' === Egy piros-fekete fa minden csúcsa rendelkezik egy '''szín''' attribútummal, amely lehet '''piros''' vagy '''fekete''', és a következő tulajdonságokat teljesíti: # '''Minden csúcs vagy piros, vagy fekete.''' # '''A gyökér mindig fekete.''' # '''Minden levél (NIL) fekete.''' #* A levelek olyan csúcsok, amelyekhez nem tartozik valódi érték. # '''Egy piros csúcsnak nincsenek piros gyerekei.''' #* Azaz a piros csúcsok nem helyezkedhetnek egymás mellett (a fa “dupla piros” állapota nem engedélyezett). # '''Bármely csúcsból egy levélig vezető összes út azonos számú fekete csúcsot tartalmaz.''' #* Ezt nevezzük '''fekete magasságnak'''. Ezek a tulajdonságok biztosítják, hogy a fa kiegyensúlyozott maradjon, és a műveletek hatékonyan végrehajthatók legyenek. ----- <span id="műveletek"></span> === '''Műveletek''' === <span id="beszúrás"></span> ==== '''1. Beszúrás''' ==== A beszúrás során először egy új csúcsot helyezünk el piros színnel. Ezután a fa tulajdonságainak megsértése esetén helyreállítjuk az egyensúlyt '''rotációkkal''' és '''színváltásokkal'''. <span id="törlés"></span> ==== '''2. Törlés''' ==== A törlés során először eltávolítjuk a csúcsot, majd, ha szükséges, helyreállítjuk a tulajdonságokat hasonló rotációkkal és színváltásokkal. <span id="keresés"></span> ==== '''3. Keresés''' ==== A keresés ugyanúgy működik, mint egy hagyományos bináris keresőfában, az időkomplexitása (O(n)). <span id="rotációk"></span> ==== '''4. Rotációk''' ==== * '''Balra forgatás''': Az aktuális csúcs jobb gyermekét helyezzük a csúcs fölé. * '''Jobbra forgatás''': Az aktuális csúcs bal gyermekét helyezzük a csúcs fölé. ----- <span id="időkomplexitás"></span> === '''Időkomplexitás''' === * '''Beszúrás, törlés, keresés''': (O(n)), mert a fa magassága legfeljebb (2 (n+1)). ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <span id="beszúrás-1"></span> ==== '''Beszúrás''' ==== <pre>Insert(T, z): helyezd el z-t a bináris keresőfa szabályai szerint színezd z-t pirosra amíg z nem a gyökér és z szülője piros: ha z szülője a nagyapa bal gyereke: ha z nagybátyja piros: színezd z szülőjét és nagybátyját feketére színezd z nagyapját pirosra z = z nagyapja különben: ha z z szülőjének jobb gyereke: z = z szülője balra forgatás(z) színezd z szülőjét feketére színezd z nagyapját pirosra jobbra forgatás(z nagyapja) különben (szimmetrikus): ugyanaz, mint fent, csak balra és jobbra cserélve színezd a gyökeret feketére</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">class Node: def __init__(self, key, color="red", left=None, right=None, parent=None): self.key = key self.color = color self.left = left self.right = right self.parent = parent class RedBlackTree: def __init__(self): self.TNULL = Node(0, color="black") self.root = self.TNULL def insert(self, key): new_node = Node(key, color="red", left=self.TNULL, right=self.TNULL) y = None x = self.root while x != self.TNULL: y = x if new_node.key < x.key: x = x.left else: x = x.right new_node.parent = y if y is None: self.root = new_node elif new_node.key < y.key: y.left = new_node else: y.right = new_node if new_node.parent is None: new_node.color = "black" return if new_node.parent.parent is None: return self._fix_insert(new_node) def _fix_insert(self, k): while k.parent.color == "red": if k.parent == k.parent.parent.right: u = k.parent.parent.left if u.color == "red": u.color = "black" k.parent.color = "black" k.parent.parent.color = "red" k = k.parent.parent else: if k == k.parent.left: k = k.parent self._rotate_right(k) k.parent.color = "black" k.parent.parent.color = "red" self._rotate_left(k.parent.parent) else: u = k.parent.parent.right if u.color == "red": u.color = "black" k.parent.color = "black" k.parent.parent.color = "red" k = k.parent.parent else: if k == k.parent.right: k = k.parent self._rotate_left(k) k.parent.color = "black" k.parent.parent.color = "red" self._rotate_right(k.parent.parent) if k == self.root: break self.root.color = "black" def _rotate_left(self, x): y = x.right x.right = y.left if y.left != self.TNULL: y.left.parent = x y.parent = x.parent if x.parent is None: self.root = y elif x == x.parent.left: x.parent.left = y else: x.parent.right = y y.left = x x.parent = y def _rotate_right(self, x): y = x.left x.left = y.right if y.right != self.TNULL: y.right.parent = x y.parent = x.parent if x.parent is None: self.root = y elif x == x.parent.right: x.parent.right = y else: x.parent.left = y y.right = x x.parent = y # Példa használat rbt = RedBlackTree() rbt.insert(10) rbt.insert(20) rbt.insert(30) rbt.insert(15)</syntaxhighlight> ----- <span id="összegzés"></span> === '''Összegzés''' === A '''piros-fekete fa''' garantáltan hatékony adatszerkezet keresésekhez, beszúrásokhoz és törlésekhez. Bár bonyolultabb, mint az egyszerű bináris keresőfa, a stabil (O(n)) időkomplexitása miatt széles körben használják, például szótárak és prioritási sorok megvalósításában (pl. C++ STL <code>map</code> és <code>set</code>). {{-ford-}} *{{en}}: {{t|en|red-black tree}} *{{ru}}: {{t|ru|красно-чёрное дерево}} {{hunl}} 3cn61wseo67df65ca0zhzl6rphhl7uu 3479479 3479478 2024-12-12T21:11:47Z LinguisticMystic 22848 3479479 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|gráf|algo}} A számítástudományban a piros-fekete fa alatt egy önkiegyensúlyozó bináris keresőfát értünk. A szerkezete összetett, de a gyakorlatban hatékony, hiszen a keresés, beszúrás és törlés lépésszáma a legrosszabb esetben is O(log n), ahol n a fában levő elemek száma. ---- <span id="piros-fekete-fa"></span> === '''Piros-fekete fa''' === A '''piros-fekete fa''' egy bináris keresőfa, amely garantálja, hogy a beszúrás, törlés és keresés műveletek időkomplexitása (O(n)) legyen. A piros-fekete fa egy '''önkiegyensúlyozó bináris keresőfa''', amely egyensúlyi feltételek segítségével korlátozza a fa magasságát. ----- <span id="tulajdonságok"></span> === '''Tulajdonságok''' === Egy piros-fekete fa minden csúcsa rendelkezik egy '''szín''' attribútummal, amely lehet '''piros''' vagy '''fekete''', és a következő tulajdonságokat teljesíti: # '''Minden csúcs vagy piros, vagy fekete.''' # '''A gyökér mindig fekete.''' # '''Minden levél (NIL) fekete.''' #* A levelek olyan csúcsok, amelyekhez nem tartozik valódi érték. # '''Egy piros csúcsnak nincsenek piros gyerekei.''' #* Azaz a piros csúcsok nem helyezkedhetnek egymás mellett (a fa “dupla piros” állapota nem engedélyezett). # '''Bármely csúcsból egy levélig vezető összes út azonos számú fekete csúcsot tartalmaz.''' #* Ezt nevezzük '''fekete magasságnak'''. Ezek a tulajdonságok biztosítják, hogy a fa kiegyensúlyozott maradjon, és a műveletek hatékonyan végrehajthatók legyenek. ----- <span id="műveletek"></span> === '''Műveletek''' === <span id="beszúrás"></span> ==== '''1. Beszúrás''' ==== A beszúrás során először egy új csúcsot helyezünk el piros színnel. Ezután a fa tulajdonságainak megsértése esetén helyreállítjuk az egyensúlyt '''rotációkkal''' és '''színváltásokkal'''. <span id="törlés"></span> ==== '''2. Törlés''' ==== A törlés során először eltávolítjuk a csúcsot, majd, ha szükséges, helyreállítjuk a tulajdonságokat hasonló rotációkkal és színváltásokkal. <span id="keresés"></span> ==== '''3. Keresés''' ==== A keresés ugyanúgy működik, mint egy hagyományos bináris keresőfában, az időkomplexitása (O(n)). <span id="rotációk"></span> ==== '''4. Rotációk''' ==== * '''Balra forgatás''': Az aktuális csúcs jobb gyermekét helyezzük a csúcs fölé. * '''Jobbra forgatás''': Az aktuális csúcs bal gyermekét helyezzük a csúcs fölé. ----- <span id="időkomplexitás"></span> === '''Időkomplexitás''' === * '''Beszúrás, törlés, keresés''': (O(n)), mert a fa magassága legfeljebb (2 (n+1)). ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <span id="beszúrás-1"></span> ==== '''Beszúrás''' ==== <pre>Insert(T, z): helyezd el z-t a bináris keresőfa szabályai szerint színezd z-t pirosra amíg z nem a gyökér és z szülője piros: ha z szülője a nagyapa bal gyereke: ha z nagybátyja piros: színezd z szülőjét és nagybátyját feketére színezd z nagyapját pirosra z = z nagyapja különben: ha z z szülőjének jobb gyereke: z = z szülője balra forgatás(z) színezd z szülőjét feketére színezd z nagyapját pirosra jobbra forgatás(z nagyapja) különben (szimmetrikus): ugyanaz, mint fent, csak balra és jobbra cserélve színezd a gyökeret feketére</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">class Node: def __init__(self, key, color="red", left=None, right=None, parent=None): self.key = key self.color = color self.left = left self.right = right self.parent = parent class RedBlackTree: def __init__(self): self.TNULL = Node(0, color="black") self.root = self.TNULL def insert(self, key): new_node = Node(key, color="red", left=self.TNULL, right=self.TNULL) y = None x = self.root while x != self.TNULL: y = x if new_node.key < x.key: x = x.left else: x = x.right new_node.parent = y if y is None: self.root = new_node elif new_node.key < y.key: y.left = new_node else: y.right = new_node if new_node.parent is None: new_node.color = "black" return if new_node.parent.parent is None: return self._fix_insert(new_node) def _fix_insert(self, k): while k.parent.color == "red": if k.parent == k.parent.parent.right: u = k.parent.parent.left if u.color == "red": u.color = "black" k.parent.color = "black" k.parent.parent.color = "red" k = k.parent.parent else: if k == k.parent.left: k = k.parent self._rotate_right(k) k.parent.color = "black" k.parent.parent.color = "red" self._rotate_left(k.parent.parent) else: u = k.parent.parent.right if u.color == "red": u.color = "black" k.parent.color = "black" k.parent.parent.color = "red" k = k.parent.parent else: if k == k.parent.right: k = k.parent self._rotate_left(k) k.parent.color = "black" k.parent.parent.color = "red" self._rotate_right(k.parent.parent) if k == self.root: break self.root.color = "black" def _rotate_left(self, x): y = x.right x.right = y.left if y.left != self.TNULL: y.left.parent = x y.parent = x.parent if x.parent is None: self.root = y elif x == x.parent.left: x.parent.left = y else: x.parent.right = y y.left = x x.parent = y def _rotate_right(self, x): y = x.left x.left = y.right if y.right != self.TNULL: y.right.parent = x y.parent = x.parent if x.parent is None: self.root = y elif x == x.parent.right: x.parent.right = y else: x.parent.left = y y.right = x x.parent = y # Példa használat rbt = RedBlackTree() rbt.insert(10) rbt.insert(20) rbt.insert(30) rbt.insert(15)</syntaxhighlight> === C++ === <syntaxhighlight lang="c++"> #include <iostream> using namespace std; enum Color { RED, BLACK }; struct Node { int data; Color color; Node* left; Node* right; Node* parent; Node(int data) : data(data), color(RED), left(nullptr), right(nullptr), parent(nullptr) {} }; class RedBlackTree { private: Node* root; void rotateLeft(Node* x) { Node* y = x->right; x->right = y->left; if (y->left != nullptr) { y->left->parent = x; } y->parent = x->parent; if (x->parent == nullptr) { root = y; } else if (x == x->parent->left) { x->parent->left = y; } else { x->parent->right = y; } y->left = x; x->parent = y; } void rotateRight(Node* x) { Node* y = x->left; x->left = y->right; if (y->right != nullptr) { y->right->parent = x; } y->parent = x->parent; if (x->parent == nullptr) { root = y; } else if (x == x->parent->right) { x->parent->right = y; } else { x->parent->left = y; } y->right = x; x->parent = y; } void fixInsert(Node* k) { Node* uncle; while (k->parent != nullptr && k->parent->color == RED) { if (k->parent == k->parent->parent->left) { uncle = k->parent->parent->right; // Ha a nagybáty piros if (uncle != nullptr && uncle->color == RED) { k->parent->color = BLACK; uncle->color = BLACK; k->parent->parent->color = RED; k = k->parent->parent; } else { // Ha a nagybáty fekete if (k == k->parent->right) { k = k->parent; rotateLeft(k); } k->parent->color = BLACK; k->parent->parent->color = RED; rotateRight(k->parent->parent); } } else { uncle = k->parent->parent->left; // Szimmetrikus eset if (uncle != nullptr && uncle->color == RED) { k->parent->color = BLACK; uncle->color = BLACK; k->parent->parent->color = RED; k = k->parent->parent; } else { if (k == k->parent->left) { k = k->parent; rotateRight(k); } k->parent->color = BLACK; k->parent->parent->color = RED; rotateLeft(k->parent->parent); } } } root->color = BLACK; } public: RedBlackTree() : root(nullptr) {} void insert(int data) { Node* newNode = new Node(data); if (root == nullptr) { root = newNode; root->color = BLACK; return; } Node* current = root; Node* parent = nullptr; while (current != nullptr) { parent = current; if (newNode->data < current->data) { current = current->left; } else { current = current->right; } } newNode->parent = parent; if (newNode->data < parent->data) { parent->left = newNode; } else { parent->right = newNode; } fixInsert(newNode); } void inorderTraversal(Node* node) { if (node == nullptr) return; inorderTraversal(node->left); cout << node->data << " "; inorderTraversal(node->right); } void display() { inorderTraversal(root); cout << endl; } }; int main() { RedBlackTree rbt; rbt.insert(10); rbt.insert(20); rbt.insert(30); rbt.insert(15); rbt.insert(25); rbt.insert(5); cout << "Piros-fekete fa inorder bejárása: "; rbt.display(); return 0; } </syntaxhighlight > ----- <span id="összegzés"></span> === '''Összegzés''' === A '''piros-fekete fa''' garantáltan hatékony adatszerkezet keresésekhez, beszúrásokhoz és törlésekhez. Bár bonyolultabb, mint az egyszerű bináris keresőfa, a stabil (O(n)) időkomplexitása miatt széles körben használják, például szótárak és prioritási sorok megvalósításában (pl. C++ STL <code>map</code> és <code>set</code>). {{-ford-}} *{{en}}: {{t|en|red-black tree}} *{{ru}}: {{t|ru|красно-чёрное дерево}} {{hunl}} 222sptphefpfvusyz40s0qviv181j55 0 430504 3479515 2809835 2024-12-12T22:10:08Z LinguisticMystic 22848 3479515 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika |algo}} önkiegyensúlyozó [[bináris keresőfa]] ---- Az '''AVL-fa''' egy '''kiegyensúlyozott bináris keresőfa''', amely biztosítja, hogy az egyes csomópontokhoz tartozó bal és jobb részfák magasságának különbsége legfeljebb '''1''' legyen. Az AVL-fa nevét az alkotókról, '''Adelson-Velsky és Landis''' matematikusokról kapta. ----- <span id="tulajdonságok"></span> === '''Tulajdonságok''' === # '''Magassági különbség (balance factor)''': #* Egy csomópont '''kiegyensúlyozottsági faktora''' a bal és jobb részfa magasságának különbsége: [ = - ] #* Értéke lehet: (-1, 0, 1). # '''Kiegyensúlyozottság fenntartása''': #* Ha a beszúrás vagy törlés miatt egy csomópont kiegyensúlyozottsági faktora (-1, 0, 1)-en kívülre kerül, a fa kiegyensúlyozatlanná válik, és forgatásokkal helyre kell állítani. # '''Rotációk (forgatások)''': #* '''Bal forgatás (Left Rotation)''': Ha a jobb részfa túl magas. #* '''Jobb forgatás (Right Rotation)''': Ha a bal részfa túl magas. #* '''Bal-jobb forgatás (Left-Right Rotation)''': Ha a bal részfa jobb gyereke okoz kiegyensúlyozatlanságot. #* '''Jobb-bal forgatás (Right-Left Rotation)''': Ha a jobb részfa bal gyereke okoz kiegyensúlyozatlanságot. # '''Időkomplexitás''': #* '''Beszúrás, törlés, keresés''': (O(n)). ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <span id="beszúrás"></span> ==== '''Beszúrás''' ==== <pre>Insert(node, key): ha node üres: hozz létre egy új csomópontot a key értékkel ha key &lt; node.key: node.bal = Insert(node.bal, key) különben: node.jobb = Insert(node.jobb, key) frissítsd a node magasságát balance = balance_factor(node) ha balance &gt; 1 és key &lt; node.bal.key: térj vissza jobb_forgatás(node) ha balance &lt; -1 és key &gt; node.jobb.key: térj vissza bal_forgatás(node) ha balance &gt; 1 és key &gt; node.bal.key: node.bal = bal_forgatás(node.bal) térj vissza jobb_forgatás(node) ha balance &lt; -1 és key &lt; node.jobb.key: node.jobb = jobb_forgatás(node.jobb) térj vissza bal_forgatás(node) térj vissza node</pre> <span id="forgatás"></span> ==== '''Forgatás''' ==== <pre>Bal_forgatás(z): y = z.jobb T2 = y.bal y.bal = z z.jobb = T2 frissítsd z és y magasságát térj vissza y Jobb_forgatás(z): y = z.bal T3 = y.jobb y.jobb = z z.bal = T3 frissítsd z és y magasságát térj vissza y</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">class AVLNode: def __init__(self, key): self.key = key self.left = None self.right = None self.height = 1 class AVLTree: def get_height(self, node): return node.height if node else 0 def get_balance(self, node): return self.get_height(node.left) - self.get_height(node.right) if node else 0 def right_rotate(self, z): y = z.left T3 = y.right y.right = z z.left = T3 z.height = 1 + max(self.get_height(z.left), self.get_height(z.right)) y.height = 1 + max(self.get_height(y.left), self.get_height(y.right)) return y def left_rotate(self, z): y = z.right T2 = y.left y.left = z z.right = T2 z.height = 1 + max(self.get_height(z.left), self.get_height(z.right)) y.height = 1 + max(self.get_height(y.left), self.get_height(y.right)) return y def insert(self, node, key): if not node: return AVLNode(key) if key < node.key: node.left = self.insert(node.left, key) else: node.right = self.insert(node.right, key) node.height = 1 + max(self.get_height(node.left), self.get_height(node.right)) balance = self.get_balance(node) if balance > 1 and key < node.left.key: return self.right_rotate(node) if balance < -1 and key > node.right.key: return self.left_rotate(node) if balance > 1 and key > node.left.key: node.left = self.left_rotate(node.left) return self.right_rotate(node) if balance < -1 and key < node.right.key: node.right = self.right_rotate(node.right) return self.left_rotate(node) return node def pre_order(self, root): if not root: return print(root.key, end=" ") self.pre_order(root.left) self.pre_order(root.right) # Példa használat tree = AVLTree() root = None keys = [10, 20, 30, 40, 50, 25] for key in keys: root = tree.insert(root, key) print("Preorder bejárás:") tree.pre_order(root)</syntaxhighlight> '''Kimenet:''' <pre>Preorder bejárás: 30 20 10 25 40 50</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> using namespace std; struct AVLNode { int key; AVLNode* left; AVLNode* right; int height; AVLNode(int value) : key(value), left(nullptr), right(nullptr), height(1) {} }; class AVLTree { public: int get_height(AVLNode* node) { return node ? node->height : 0; } int get_balance(AVLNode* node) { return node ? get_height(node->left) - get_height(node->right) : 0; } AVLNode* right_rotate(AVLNode* z) { AVLNode* y = z->left; AVLNode* T3 = y->right; y->right = z; z->left = T3; z->height = 1 + max(get_height(z->left), get_height(z->right)); y->height = 1 + max(get_height(y->left), get_height(y->right)); return y; } AVLNode* left_rotate(AVLNode* z) { AVLNode* y = z->right; AVLNode* T2 = y->left; y->left = z; z->right = T2; z->height = 1 + max(get_height(z->left), get_height(z->right)); y->height = 1 + max(get_height(y->left), get_height(y->right)); return y; } AVLNode* insert(AVLNode* node, int key) { if (!node) return new AVLNode(key); if (key < node->key) node->left = insert(node->left, key); else node->right = insert(node->right, key); node->height = 1 + max(get_height(node->left), get_height(node->right)); int balance = get_balance(node); if (balance > 1 && key < node->left->key) return right_rotate(node); if (balance < -1 && key > node->right->key) return left_rotate(node); if (balance > 1 && key > node->left->key) { node->left = left_rotate(node->left); return right_rotate(node); } if (balance < -1 && key < node->right->key) { node->right = right_rotate(node->right); return left_rotate(node); } return node; } void pre_order(AVLNode* root) { if (!root) return; cout << root->key << " "; pre_order(root->left); pre_order(root->right); } }; int main() { AVLTree tree; AVLNode* root = nullptr; int keys[] = {10, 20, 30, 40, 50, 25}; for (int key : keys) { root = tree.insert(root, key); } cout << "Preorder bejárás: "; tree.pre_order(root); cout << endl; return 0; }</syntaxhighlight> '''Kimenet:''' <pre>Preorder bejárás: 30 20 10 25 40 50</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === <span id="előnyök"></span> ==== '''Előnyök''': ==== # '''Kiegyensúlyozottság''': Garantáltan (O(n)) magasság. # '''Hatékonyság''': Gyors beszúrás, törlés, keresés. <span id="hátrányok"></span> ==== '''Hátrányok''': ==== # '''Komplexitás''': Több számítás szükséges a kiegyensúlyozás fenntartásához. # '''Nem optimális memóriában''': További mutatókat és magassági értékeket kell tárolni. Az AVL-fa kiváló választás olyan alkalmazásokhoz, ahol garantáltan kiegyensúlyozott fa szükséges. {{-ford-}} *{{en}}: {{t|en|AVL tree}} 3x908bnpcu51jvhtfsxef4yw238yuho 0 430524 3479460 2808283 2024-12-12T20:50:49Z LinguisticMystic 22848 3479460 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} lásd: [[visszalépéses keresés]] {{-ford-}} *{{en}}: {{t|en|backtrack search}} *{{ru}}: {{t|ru|поиск с возвратом }} e9s3247vrxxhg5pzw3acsxlwz25xl6f 0 430525 3479459 2808279 2024-12-12T20:50:32Z LinguisticMystic 22848 3479459 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} [[algoritmus]] {{-ford-}} *{{en}}: {{t|en|backtrack search}} *{{ru}}: {{t|ru|поиск с возвратом }} {{hunl}} 4bexm23wh7zy2674mg3j9upgnqbaj8k 3479485 3479459 2024-12-12T21:27:27Z LinguisticMystic 22848 3479485 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} A '''visszalépéses keresés''' egy általános algoritmikus technika, amelyet problémák megoldására használnak, különösen akkor, ha a megoldás keresési térben történő kiterjesztése iteratívan és feltételesen történik. Az algoritmus rekurzívan próbálja ki a lehetséges megoldásokat, és ha egy részmegoldás nem vezet sikerhez, visszalép egy korábbi állapotba. ----- <span id="alapelvek"></span> === '''Alapelvek''' === # '''Keresési tér''': #* A problémát olyan keresési térként modelláljuk, amelyben minden csomópont egy részleges megoldást reprezentál. # '''Rekurzív próbálkozás''': #* A részleges megoldásokból kiindulva próbáljuk meg kiterjeszteni azt egy teljes megoldássá. # '''Visszalépés''': #* Ha egy adott részmegoldás nem vezet teljes megoldáshoz (nem kielégítő), visszalépünk, és más lehetőségeket próbálunk ki. # '''Hatékonyság''': #* A “vágás” technikát használjuk, hogy elkerüljük a nyilvánvalóan rossz megoldási útvonalakat. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>Backtrack(solution): ha a solution kielégítő: térj vissza a solution különben: minden lehetséges választási lehetőség esetén: ha a választás érvényes: add hozzá a választást a solution-höz hívj meg Backtrack-et a frissített solution-nel ha a frissített solution megoldást eredményezett: térj vissza a solution távolítsd el a választást (visszalépés) térj vissza sikertelenként</pre> ----- <span id="alkalmazási-példák"></span> === '''Alkalmazási példák''' === # '''N királynő problémája''': #* Helyezzünk el (N) királynőt egy (N N) sakktáblán úgy, hogy ne támadhassák egymást. # '''Sudoku megoldása''': #* Töltsük ki a táblázatot úgy, hogy a szabályok teljesüljenek. # '''Hátizsák probléma''': #* Válasszunk tárgyakat úgy, hogy a hátizsák kapacitása ne lépje túl a megadott értéket. # '''Labirintus keresése''': #* Találjunk utat egy adott kezdőpontból a célhoz. ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <span id="n-királynő-problémája"></span> ==== '''N királynő problémája''' ==== <syntaxhighlight lang="python">def is_safe(board, row, col, n): # Ellenőrizzük az oszlopot for i in range(row): if board[i][col] == 1: return False # Átlós ellenőrzés (bal felülről jobb alulra) for i, j in zip(range(row, -1, -1), range(col, -1, -1)): if board[i][j] == 1: return False # Átlós ellenőrzés (jobb felülről bal alulra) for i, j in zip(range(row, -1, -1), range(col, n)): if board[i][j] == 1: return False return True def solve_n_queens(board, row, n): if row >= n: return True for col in range(n): if is_safe(board, row, col, n): board[row][col] = 1 if solve_n_queens(board, row + 1, n): return True board[row][col] = 0 # Visszalépés return False def print_solution(board): for row in board: print(" ".join("Q" if x == 1 else "." for x in row)) # Példa n = 8 board = [[0 for _ in range(n)] for _ in range(n)] if solve_n_queens(board, 0, n): print("Megoldás:") print_solution(board) else: print("Nincs megoldás.")</syntaxhighlight> '''Kimenet (8 királynő esetén):''' <pre>Megoldás: Q . . . . . . . . . . . Q . . . . . . . . . Q . . . Q . . . . . . . . . . Q . . . Q . . . . . . . . . Q . . . . . . . . . . . Q</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <span id="n-királynő-problémája-1"></span> ==== '''N királynő problémája''' ==== <syntaxhighlight lang="cpp">#include <iostream> #include <vector> using namespace std; bool is_safe(const vector<vector<int>>& board, int row, int col, int n) { // Ellenőrizzük az oszlopot for (int i = 0; i < row; ++i) if (board[i][col] == 1) return false; // Átlós ellenőrzés (bal felülről jobb alulra) for (int i = row, j = col; i >= 0 && j >= 0; --i, --j) if (board[i][j] == 1) return false; // Átlós ellenőrzés (jobb felülről bal alulra) for (int i = row, j = col; i >= 0 && j < n; --i, ++j) if (board[i][j] == 1) return false; return true; } bool solve_n_queens(vector<vector<int>>& board, int row, int n) { if (row >= n) return true; for (int col = 0; col < n; ++col) { if (is_safe(board, row, col, n)) { board[row][col] = 1; if (solve_n_queens(board, row + 1, n)) return true; board[row][col] = 0; // Visszalépés } } return false; } void print_solution(const vector<vector<int>>& board) { for (const auto& row : board) { for (int cell : row) cout << (cell == 1 ? "Q " : ". "); cout << endl; } } int main() { int n = 8; vector<vector<int>> board(n, vector<int>(n, 0)); if (solve_n_queens(board, 0, n)) { cout << "Megoldás:" << endl; print_solution(board); } else { cout << "Nincs megoldás." << endl; } return 0; }</syntaxhighlight> '''Kimenet (8 királynő esetén):''' <pre>Megoldás: Q . . . . . . . . . . . Q . . . . . . . . . Q . . . Q . . . . . . . . . . Q . . . Q . . . . . . . . . Q . . . . . . . . . . . Q</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === A '''visszalépéses keresés''' hatékony módszer kombinatorikus problémák megoldására, különösen akkor, ha a probléma jól strukturált és a keresési tér könnyen korlátozható. Ez a megközelítés gyakran alkalmazható optimális megoldások keresésére, például az '''N királynő problémájában''', '''Sudoku megoldásában''', vagy '''útvonal keresésben'''. {{-ford-}} *{{en}}: {{t|en|backtrack search}} *{{ru}}: {{t|ru|поиск с возвратом }} {{hunl}} eskgj663qfn0xsku0dn6a8u4zy3zt3l 0 430565 3479470 2808264 2024-12-12T21:02:28Z LinguisticMystic 22848 3479470 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|info|gráf|algo}} {{-ford-}} *{{en}}: {{t|en|depth-first search}} *{{ru}}: {{t|ru|поиск в глубину }} {{hunl}} ac52cjgvf82jts83go38k6ctl7mztms 3479476 3479470 2024-12-12T21:03:59Z LinguisticMystic 22848 3479476 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|info|gráf|algo}} A '''mélységi keresés (DFS)''' egy gráfkeresési algoritmus, amely egy gráf csúcsait mélységi sorrendben járja be. Az algoritmus elindul egy kezdőcsúcsból, és addig halad egy irányba, amíg már nincs további lehetőség. Ezután visszalép az előző csúcsra, és folytatja a keresést. ----- <span id="algoritmus-működése"></span> === '''Algoritmus működése''' === # '''Kezdés''': #* A kiinduló csúcsot jelöljük látogatottként. # '''Lépés''': #* Haladjunk tovább egy szomszédos csúcs felé, amelyet még nem látogattunk meg. # '''Visszalépés''': #* Ha elértük egy út végét (nincs látogatatlan szomszédos csúcs), térjünk vissza az előző csúcsra. # '''Ismétlés''': #* Addig folytatjuk, amíg minden elérhető csúcsot be nem jártunk. <span id="adatszerkezet"></span> ==== '''Adatszerkezet''': ==== * A DFS tipikusan rekurzióval vagy egy '''verem''' (stack) adatszerkezettel valósítható meg. ----- <span id="tulajdonságok"></span> === '''Tulajdonságok''' === * '''Időkomplexitás''': (O(V + E)), ahol (V) a csúcsok száma, (E) az élek száma. * '''Térkomplexitás''': ** Rekurzív megvalósítás: (O(V)) a rekurzív hívások miatt. ** Iteratív megvalósítás: (O(V)) a verem miatt. * '''Alkalmazások''': ** Összefüggő komponensek meghatározása. ** Körök észlelése. ** Topologikus rendezés. ** Útvonal keresése. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <span id="rekurzív-változat"></span> ==== '''Rekurzív változat''' ==== <pre>DFS(G, v): jelöld v-t látogatottként minden szomszéd u esetén: ha u nincs látogatottként jelölve: DFS(G, u)</pre> <span id="iteratív-változat"></span> ==== '''Iteratív változat''' ==== <pre>DFS(G, v): verem = üres verem.push(v) amíg verem nem üres: u = verem.pop() ha u nincs látogatottként jelölve: jelöld u-t látogatottként minden szomszéd w esetén: ha w nincs látogatottként jelölve: verem.push(w)</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <span id="rekurzív-változat-1"></span> ==== '''Rekurzív változat''' ==== <syntaxhighlight lang="python">def dfs_recursive(graph, node, visited): if node not in visited: print(node, end=" ") visited.add(node) for neighbor in graph[node]: dfs_recursive(graph, neighbor, visited) # Példa gráf graph = { 0: [1, 2], 1: [0, 3, 4], 2: [0], 3: [1], 4: [1, 5], 5: [4] } visited = set() print("DFS rekurzívan:") dfs_recursive(graph, 0, visited)</syntaxhighlight> <span id="iteratív-változat-1"></span> ==== '''Iteratív változat''' ==== <syntaxhighlight lang="python">def dfs_iterative(graph, start): visited = set() stack = [start] while stack: node = stack.pop() if node not in visited: print(node, end=" ") visited.add(node) # Hozzáadjuk a szomszédokat a veremhez (fordított sorrendben a logikus sorrendért) for neighbor in reversed(graph[node]): if neighbor not in visited: stack.append(neighbor) # Példa gráf graph = { 0: [1, 2], 1: [0, 3, 4], 2: [0], 3: [1], 4: [1, 5], 5: [4] } print("DFS iteratívan:") dfs_iterative(graph, 0)</syntaxhighlight> '''Kimenet mindkét esetben (a példagráftól függően):''' <pre>DFS rekurzívan: 0 1 3 4 5 2 DFS iteratívan: 0 1 3 4 5 2</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <span id="rekurzív-változat-2"></span> ==== '''Rekurzív változat''' ==== <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <unordered_set> using namespace std; void dfs_recursive(const vector<vector<int>>& graph, int node, unordered_set<int>& visited) { if (visited.find(node) == visited.end()) { cout << node << " "; visited.insert(node); for (int neighbor : graph[node]) { dfs_recursive(graph, neighbor, visited); } } } int main() { vector<vector<int>> graph = { {1, 2}, {0, 3, 4}, {0}, {1}, {1, 5}, {4} }; unordered_set<int> visited; cout << "DFS rekurzívan:" << endl; dfs_recursive(graph, 0, visited); return 0; }</syntaxhighlight> <span id="iteratív-változat-2"></span> ==== '''Iteratív változat''' ==== <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <stack> #include <unordered_set> using namespace std; void dfs_iterative(const vector<vector<int>>& graph, int start) { unordered_set<int> visited; stack<int> s; s.push(start); while (!s.empty()) { int node = s.top(); s.pop(); if (visited.find(node) == visited.end()) { cout << node << " "; visited.insert(node); for (auto it = graph[node].rbegin(); it != graph[node].rend(); ++it) { if (visited.find(*it) == visited.end()) { s.push(*it); } } } } } int main() { vector<vector<int>> graph = { {1, 2}, {0, 3, 4}, {0}, {1}, {1, 5}, {4} }; cout << "DFS iteratívan:" << endl; dfs_iterative(graph, 0); return 0; }</syntaxhighlight> '''Kimenet mindkét esetben:''' <pre>DFS rekurzívan: 0 1 3 4 5 2 DFS iteratívan: 0 1 3 4 5 2</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === A '''mélységi keresés (DFS)''' hatékony és egyszerű módszer gráfok bejárására. Széles körben alkalmazzák összefüggő komponensek meghatározására, körök keresésére, topologikus rendezésre és útvonalak felfedezésére. A rekurzív változat olvashatóbb, de nagy gráfok esetén az iteratív megközelítés jobb, mert elkerüli a túlmély rekurzív hívásokat. {{-ford-}} *{{en}}: {{t|en|depth-first search}} *{{ru}}: {{t|ru|поиск в глубину }} {{hunl}} 564084fgv7nvbpwl6ggzeejn8fskp30 0 430568 3479431 2808629 2024-12-12T17:37:43Z LinguisticMystic 22848 3479431 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} {{-ford-}} *{{en}}: {{t|en|breadth-first search}} *{{de}}: {{t|de|Breitensuche}} *{{ru}}: {{t|ru|поиск в ширину }} {{hunl}} oox796zbfidljfv367499f522o52plg 3479432 3479431 2024-12-12T17:38:26Z LinguisticMystic 22848 3479432 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} A '''BFS (Breadth-First Search)''' egy gráfkeresési algoritmus, amely a gráf csúcsait szélességi sorrendben járja be. Az algoritmus az adott kiindulópontból indul, majd rétegenként halad, először a közvetlen szomszédokat látogatva meg, mielőtt továbblépne a következő rétegre. Ez az algoritmus különösen hasznos minimális úthosszúságú problémák, például a legkevesebb élből álló út megtalálására egy nem súlyozott gráfban. ----- <span id="elmélet"></span> === '''Elmélet''' === A BFS a következőképpen működik: 1. '''Kezdet''': A kiinduló csúcsot bejelöljük látogatottként, és hozzáadjuk egy sorhoz (queue). 2. '''Ismétlés''': Amíg a sor nem üres: - Vegyük ki a sor elején lévő csúcsot. - Az aktuális csúcs összes szomszédját bejárjuk: - Ha egy szomszédot még nem látogattunk meg, jelöljük látogatottként, és adjuk hozzá a sorhoz. 3. '''Vég''': A sor kiürülésekor az algoritmus befejeződik, a gráf összes elérhető csúcsát bejártuk. '''Fontos tulajdonságok''': - '''Időkomplexitás''': ( O(V + E) ), ahol ( V ) a csúcsok száma, ( E ) pedig az élek száma. - '''Térkomplexitás''': ( O(V) ), a látogatott csúcsok és a sor tárolása miatt. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>BFS(G, start): Látogatott = üres halmaz Sor = üres sor Sorba helyez(start) Jelöld látogatottként(start) amíg Sor nem üres: csúcs = Sorból eltávolít() Feldolgozd(csúcs) minden szomszéd S a csúcs szomszédai közül: ha S nincs látogatottként jelölve: Jelöld látogatottként(S) Sorba helyez(S)</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">from collections import deque def bfs(graph, start): visited = set() queue = deque([start]) visited.add(start) while queue: node = queue.popleft() print(node, end=" ") # Csúcs feldolgozása for neighbor in graph[node]: if neighbor not in visited: visited.add(neighbor) queue.append(neighbor) # Példa gráf graph = { 0: [1, 2], 1: [0, 3, 4], 2: [0, 5], 3: [1], 4: [1, 5], 5: [2, 4] } bfs(graph, 0) # Kimenet: 0 1 2 3 4 5</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <queue> #include <unordered_set> using namespace std; void bfs(const vector<vector<int>>& graph, int start) { unordered_set<int> visited; queue<int> q; visited.insert(start); q.push(start); while (!q.empty()) { int node = q.front(); q.pop(); cout << node << " "; // Csúcs feldolgozása for (int neighbor : graph[node]) { if (visited.find(neighbor) == visited.end()) { visited.insert(neighbor); q.push(neighbor); } } } } int main() { // Példa gráf vector<vector<int>> graph = { {1, 2}, // 0. csúcs szomszédai {0, 3, 4}, // 1. csúcs szomszédai {0, 5}, // 2. csúcs szomszédai {1}, // 3. csúcs szomszédai {1, 5}, // 4. csúcs szomszédai {2, 4} // 5. csúcs szomszédai }; bfs(graph, 0); // Kimenet: 0 1 2 3 4 5 return 0; }</syntaxhighlight> ----- <span id="összegzés"></span> === '''Összegzés''' === A BFS egy egyszerű, mégis erőteljes algoritmus, amely a gráfok szélességi bejárására szolgál. Mind Pythonban, mind C++-ban könnyen implementálható, és sokféle feladatra alkalmazható, például legkisebb úthossz keresésére vagy összefüggő komponensek feltárására. {{-ford-}} *{{en}}: {{t|en|breadth-first search}} *{{de}}: {{t|de|Breitensuche}} *{{ru}}: {{t|ru|поиск в ширину }} {{hunl}} ri9uiyvzs16645mpz2uxfo2320h04d3 0 430576 3479424 3444097 2024-12-12T17:29:35Z LinguisticMystic 22848 3479424 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|graph}} Az összefüggő gráf a gráfelmélet egy alapvető fogalma, amelyben a csúcsok között míndig létezik legalább egy út. Ez azt jelenti, hogy bármelyik csúcs párja között található olyan útelem, amely ezeket a csúcsokat összeköti. === Alapfogalmak === ==== Gráfok ==== A gráf egy olyan matematikai struktúra, amely csúcsokból (és általában élekből) áll. Formálisan egy gráf <math>G = (V, E)</math>, ahol: * <math>V</math> a csúcsok halmaza * <math>E</math> az élek halmaza, amelyek a csúcsokat kötik össze ==== Összefüggő gráf ==== Egy gráf összefüggő, ha bármely <math>u, v \in V</math> csúcsokra létezik olyan út, amely áthalad a gráf élein, és eljut <math>u</math>-ból <math>v</math>-be. ==== Irányítatlan és irányított gráfok ==== * '''Irányítatlan gráf:''' Az éleknek nincs irányuk, tehát az út oda-vissza bejárható. * '''Irányított gráf:''' Az élek irányítottak, vagyis az út csak az élek iránya szerint járható be. ==== Részgráfok ==== Egy gráf részgráfja a gráf egy olyan alhalmaza, amely tartalmazza a csúcsok és élek egy részét. Ha a részgráf összefüggő, akkor '''összefüggő komponensnek''' nevezzük. === Típusok === ==== Feszítő fa ==== Egy összefüggő gráf minimális összefüggő részgráfja, amely nem tartalmaz kört, de az összes csúcspontot tartalmazza. ==== Erősen összefüggő gráf ==== Irányított gráf esetén erősen összefüggőnek nevezzük, ha bármely <math>u, v \in V</math> csúcsokra van olyan irányított út, amely <math>u</math>-ból <math>v</math>-be vezet, és fordítva is. ==== Gyengén összefüggő gráf ==== Egy irányított gráf gyengén összefüggő, ha az irányokat elhagyva a gráf összefüggő. === Tulajdonságok === ==== Komponensek ==== Egy gráf összefüggő komponensei olyan maximális összefüggő részgráfok, amelyek egymástól függetlenek. ==== Gráf átmérő ==== Az összefüggő gráf átmérője a leghosszabb lehetséges minimális út bármelyik két csúcspont között. ==== Gráf sūrűség ==== Egy gráf sūrűsége a csúcsok és élek számának aránya: :<math>\text{Sūrűség} = \frac{2 \cdot |E|}{|V| \cdot (|V| - 1)}</math> === Fontos tételek === ==== Euler-tétel ==== Egy irányítatlan gráfban létezik Euler-kör (egy olyan kör, amely minden élet pontosan egyszer érint), ha és csak akkor, ha a gráf összefüggő, és minden csúcspont fokszáma páros. ==== Feszítő fa tétel ==== Egy összefüggő gráfnak mindig van legalább egy feszítő fája, amely az összes csúcspontot tartalmazza, de pontosan <math>|V| - 1</math> éle van. === Alkalmazások === * '''Hálózatok:''' Kommunikációs hálózatok, elektromos áramkörök tervezése. * '''Számítógépes grafika:''' Modellkészítés, körfögások kezelése. * '''Közlekedési hálózatok:''' Minimális költségű útvonalak keresése. * '''Adathalmazok:''' Klaszterezés és klaszterek közti kapcsolatok elemzése. === Algoritmusok === ==== DFS (Mélységi bejárás) ==== Egy összefüggő komponens vagy teljes gráf feltérképezésére használt algoritmus. ==== BFS (Szélességi bejárás) ==== Alkalmas a legrövidebb utak megtalálására. ==== Kruskal- és Prim-algoritmus ==== Mindkettő minimális feszítő fák keresésére szolgál. {{-ford-}} *{{en}}: {{t|en|undirected graph}} *{{ru}}: {{t|ru|неориентированный граф}} {{hunl}} 5w7o6abowor5agkql89pfb5nguec7fd 0 430579 3479396 2808590 2024-12-12T13:53:06Z LinguisticMystic 22848 3479396 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|gráf }} Legyen <math>A</math> egy [[halmaz]], <math>\rho</math> egy [[reláció]] <math>A</math>-n. Ekkor az <math>(A, \rho )</math> [[rendezett pár|rendezett párt]] '''irányított gráfnak''' hívjuk. Az <math>A</math> halmaz elemeit a [[gráf pontja|gráf pontjainak]], a <math>\rho</math> relációt pedig a [[gráf éle|gráf éleinek]] nevezzük. Egy <math>(a, b) \in \rho</math> [[él]] esetében az <math>a</math> pontot az [[él kezdőpontja|él kezdőpontjának]], a <math>b</math> pontot pedig az [[él végpontja|él végpontjának]] hívjuk. Egy <math>(a, a)</math> élt [[hurokél]]nek nevezünk. ---- Az '''irányított gráf''' (digraph, directed graph) egy speciális gráf, ahol az élek (kapcsolatok) irányítottak, tehát minden él egy rendezett pár ( (u, v) ), ahol az él csak ( u )-ból ( v )-be vezet, és nem fordítva (kivéve, ha egy másik él külön ezt is definiálja). Az irányított gráfokat gyakran használják olyan rendszerek modellezésére, ahol a kapcsolatok aszimmetrikusak. <span id="formális-definíció"></span> === Formális definíció === Egy irányított gráf ( G ) egy rendezett pár: [ G = (V, E) ] ahol: - ( V ): a gráf csúcsainak (pontjainak) halmaza, - ( E ): rendezett élek halmaza (( E V V )). <span id="példa"></span> === Példa === Egy irányított gráf ( G = (V, E) ), ahol: - ( V = {A, B, C} ), - ( E = {(A, B), (B, C), (C, A)} ). Ez azt jelenti, hogy van egy él ( A )-ból ( B )-be, egy él ( B )-ből ( C )-be, és egy él ( C )-ből ( A )-ba. <span id="irányított-gráf-típusai"></span> === Irányított gráf típusai === # '''Súlyozott irányított gráf:''' Az élekhez súlyok vannak rendelve, például távolság vagy költség. # '''Aciklikus irányított gráf (DAG):''' Olyan irányított gráf, amely nem tartalmaz kört (például feladatütemezési problémák modellezésére használják). # '''Erősen összefüggő gráf:''' Olyan irányított gráf, ahol bármely két csúcs között létezik irányított út mindkét irányban. <span id="alapvető-fogalmak-irányított-gráfokban"></span> === Alapvető fogalmak irányított gráfokban === # '''Bejövő fokszám (( )):''' Egy csúcsra érkező élek száma. # '''Kimenő fokszám (( )):''' Egy csúcsból induló élek száma. # '''Út:''' Csúcsok sorozata, ahol minden csúcsot egy irányított él köt össze a következő csúccsal. # '''Kör:''' Olyan út, amely ugyanabba a csúcsba tér vissza, ahonnan indult. <span id="példák-az-irányított-gráf-alkalmazására"></span> === Példák az irányított gráf alkalmazására === # '''Hálózati útvonalak:''' Az internet forgalmának irányítása, ahol az adatok egy adott irányban áramlanak. # '''Ütemezési problémák:''' Feladatok sorrendjének meghatározása (például projektek tevékenységi hálója). # '''Adatáramlás:''' Folyamatok modellezése (például áramlások vagy algoritmusok lépései). # '''Szociális hálók:''' Kapcsolatok elemzése, például egyoldalú kapcsolatok (Twitter követések). {{-ford-}} *{{en}}: {{t|en|directed graph}}, {{t|en|digraph}} *{{de}}: {{t|de|gerichteter Graph}} *{{ru}}: {{t|ru|ориентированный граф}}, {{t|ru|орграф}} {{hunl}} 544dnhzhmcb5qzvogqcntl6oew44zft 0 430754 3479425 2809133 2024-12-12T17:30:23Z LinguisticMystic 22848 3479425 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|gráf}} '''Definíció''': A <math>G</math> gráf Euler-köre olyan zárt élsorozat, mely <math>G</math> összes élét pontosan egyszer tartalmazza. Euler-útról akkor beszélünk, hogyha az élsorozat nem feltétlenül zárt. '''Megjegyzés''': Minden Euler-kör egyben Euler-út is. {{-ford-}} *{{en}}: {{t|en|Eulerian cycle}} *{{ru}}: {{t|ru|Эйлеров цикл}} {{hunl}} 2iufzlemykx20qwxfm282k6v065jfj4 0 439076 3479401 2343399 2024-12-12T14:12:27Z LinguisticMystic 22848 3479401 wikitext text/x-wiki {{rusn}} #{{rumatek}} [[hatványhalmaz]] {{rusl}} 57z65czgg7ejow9s104fe75q0x7ubcy 0 439111 3479408 3445733 2024-12-12T14:25:54Z LinguisticMystic 22848 3479408 wikitext text/x-wiki [[File:Venn10.svg|thumb]] {{hunfn}} # {{label|hu|matematika|sets}} Ha a <math>\textit{H}</math> halmaznak az <math>\textit{A}</math> [[halmaz]] egy [[részhalmaz]]a, akkor a <math>\textit{H}</math> halmaz azon elemeinek a halmazát, melyek <math>\textit{A}</math>-nak [[nem eleme]]i, az <math>\textit{A}</math> halmaznak <math>\textit{H}</math>-ra vonatkozó '''komplementer halmazának''' mondjuk. Ilyenkor a <math>\textit{H}</math> halmazt [[alaphalmaz]]nak nevezzük. Az <math>\textit{A}</math> halmaz komplementerét <math>\bar{A}</math>-sal jelöljük. *{{en}}: {{t|en|complement}} *{{ru}}: {{t|ru|дополнение множества}} {{hunl}} 1fmp8onkmit3dy2gyr3m4tmmjc1l6qk 0 439112 3479406 2428033 2024-12-12T14:16:18Z LinguisticMystic 22848 3479406 wikitext text/x-wiki {{hunfn}} #{{humatek}} Az ''A'' és ''B'' halmazok [[különbség]]e <math>A \setminus B = \{x \in U : x \in A \text{ és } x \notin B\}</math> olyan [[halmaz]], melynek [[elem]]ei az ''A'' halmazba beletartoznak, de a ''B'' halmazba nem. A [[különbséghalmaz]] jele: <math>{A \setminus B.}</math> *{{en}}: {{t|en|set difference}} {{hunl}} 5ypzx4xyg6mvw13h1d20ewjc28ctlf2 3479407 3479406 2024-12-12T14:16:48Z LinguisticMystic 22848 3479407 wikitext text/x-wiki [[Kép:Set difference2.svg|250px|jobbra|bélyegkép|A sötétlila terület az ''A'' mínusz ''B'']] {{hunfn}} #{{humatek}} Az ''A'' és ''B'' halmazok [[különbség]]e <math>A \setminus B = \{x \in U : x \in A \text{ és } x \notin B\}</math> olyan [[halmaz]], melynek [[elem]]ei az ''A'' halmazba beletartoznak, de a ''B'' halmazba nem. A [[különbséghalmaz]] jele: <math>{A \setminus B.}</math> *{{en}}: {{t|en|set difference}} {{hunl}} mihmgfs55b00ytimgqqi0e57d13dtyo 0 439209 3479514 2428098 2024-12-12T22:05:28Z LinguisticMystic 22848 3479514 wikitext text/x-wiki {{hunfn}} # {{humatek}} *{{en}}: {{t|en|Ford–Fulkerson algorithm}} {{hunl}} 1s2w0k8lbsli3bn7i7t5j5t22h343x3 3479519 3479514 2024-12-12T22:15:18Z LinguisticMystic 22848 3479519 wikitext text/x-wiki {{hunfn}} # {{#if:|{{label|hu|matematika|{{{1}}}}} |{{label|hu|matematika}}}} *{{en}}: {{t|en|Ford–Fulkerson algorithm}} {{hunl}} lpf2gw44rraabizdlh35oh3fccld7yf 3479520 3479519 2024-12-12T22:17:53Z LinguisticMystic 22848 3479520 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika|algo}} ---- <span id="ford-fulkerson-algoritmus"></span> === '''Ford-Fulkerson-algoritmus''' === A '''Ford-Fulkerson-algoritmus''' egy hatékony módszer a '''hálózati maximális áramlás''' probléma megoldására. Az algoritmus a '''maradékgráf''' koncepcióján alapul, és iteratív módon keresi meg a forrástól a nyelőig vezető augmentáló utakat, amíg nem találhatók további utak. ----- <span id="probléma-leírása"></span> === '''Probléma leírása''' === Egy irányított gráfban ((G = (V, E))) a cél a '''forrástól''' ((s)) a '''nyelőig''' ((t)) történő áramlás maximalizálása az élek kapacitáskorlátainak figyelembevételével. <span id="definíciók"></span> ==== '''Definíciók''': ==== * '''Kapacitás ((c(u, v)))''': Az él maximális áramlási kapacitása (u)-ból (v)-be. * '''Áramlás ((f(u, v)))''': Az él mentén áramló tényleges érték, amelynek: [ 0 f(u, v) c(u, v) ] és teljesülnie kell az áramlási megmaradás törvényének: [ ''{v V} f(u, v) = ''{v V} f(v, u) ] * '''Maradékgráf ((G_f))''': Az aktuális áramlás figyelembevételével a további áramlások lehetőségeit mutatja meg: [ c_f(u, v) = c(u, v) - f(u, v) ] ----- <span id="algoritmus-lépései"></span> === '''Algoritmus lépései''' === # '''Indítás''': #* Kezdjük nullával az összes él mentén ((f(u, v) = 0)). #* Hozzunk létre egy '''maradékgráfot''', amely kezdetben az eredeti gráffal megegyezik. # '''Augmentáló út keresése''': #* Keressünk egy utat a forrástól ((s)) a nyelőig ((t)) a maradékgráfban (például BFS-sel vagy DFS-sel). # '''Áramlás növelése''': #* Határozzuk meg az augmentáló út mentén elérhető legkisebb kapacitást ((bottleneck)). #* Növeljük az áramlást az augmentáló út mentén ezzel az értékkel. # '''Maradékgráf frissítése''': #* Frissítsük a kapacitásokat és az áramlásokat: [ c_f(u, v) = c_f(u, v) - bottleneck ] [ c_f(v, u) = c_f(v, u) + bottleneck ] # '''Ismétlés''': #* Ismételjük az augmentáló utak keresését, amíg nem találunk további utat. # '''Végeredmény''': #* Az összes augmentáló út által hozzáadott áramlás a maximális áramlás értékét adja. ----- <span id="időkomplexitás"></span> === '''Időkomplexitás''' === * Az algoritmus időkomplexitása (O(E )), ahol: ** (E): élek száma. ** (): a maximális áramlás értéke. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>FordFulkerson(G, s, t): inicializálj minden élhez 0 áramlást amíg létezik augmentáló út s-től t-ig: bottleneck = a legkisebb kapacitás az úton növeld az áramlást az augmentáló út mentén bottleneck-kel frissítsd a maradékgráfot térj vissza az összes áramlás összegével</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">from collections import deque def bfs(residual_graph, source, sink, parent): visited = set() queue = deque([source]) visited.add(source) while queue: u = queue.popleft() for v, capacity in enumerate(residual_graph[u]): if v not in visited and capacity > 0: parent[v] = u if v == sink: return True visited.add(v) queue.append(v) return False def ford_fulkerson(capacity, source, sink): n = len(capacity) residual_graph = [row[:] for row in capacity] parent = [-1] * n max_flow = 0 while bfs(residual_graph, source, sink, parent): # Keressük a bottleneck kapacitást path_flow = float('Inf') v = sink while v != source: u = parent[v] path_flow = min(path_flow, residual_graph[u][v]) v = u # Frissítsük az áramlást és a maradék gráfot v = sink while v != source: u = parent[v] residual_graph[u][v] -= path_flow residual_graph[v][u] += path_flow v = u max_flow += path_flow return max_flow # Példa gráf (kapacitás mátrix formátumban) capacity = [ [0, 16, 13, 0, 0, 0], [0, 0, 10, 12, 0, 0], [0, 4, 0, 0, 14, 0], [0, 0, 9, 0, 0, 20], [0, 0, 0, 7, 0, 4], [0, 0, 0, 0, 0, 0] ] source, sink = 0, 5 print("Maximális áramlás:", ford_fulkerson(capacity, source, sink))</syntaxhighlight> '''Kimenet''': <pre>Maximális áramlás: 23</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <queue> #include <climits> #include <cstring> using namespace std; bool bfs(const vector<vector<int>>& residual_graph, int source, int sink, vector<int>& parent) { int n = residual_graph.size(); vector<bool> visited(n, false); queue<int> q; q.push(source); visited[source] = true; while (!q.empty()) { int u = q.front(); q.pop(); for (int v = 0; v < n; ++v) { if (!visited[v] && residual_graph[u][v] > 0) { parent[v] = u; if (v == sink) return true; visited[v] = true; q.push(v); } } } return false; } int ford_fulkerson(const vector<vector<int>>& capacity, int source, int sink) { int n = capacity.size(); vector<vector<int>> residual_graph = capacity; vector<int> parent(n, -1); int max_flow = 0; while (bfs(residual_graph, source, sink, parent)) { // Keressük a bottleneck kapacitást int path_flow = INT_MAX; for (int v = sink; v != source; v = parent[v]) { int u = parent[v]; path_flow = min(path_flow, residual_graph[u][v]); } // Frissítsük az áramlást és a maradék gráfot for (int v = sink; v != source; v = parent[v]) { int u = parent[v]; residual_graph[u][v] -= path_flow; residual_graph[v][u] += path_flow; } max_flow += path_flow; } return max_flow; } int main() { vector<vector<int>> capacity = { {0, 16, 13, 0, 0, 0}, {0, 0, 10, 12, 0, 0}, {0, 4, 0, 0, 14, 0}, {0, 0, 9, 0, 0, 20}, {0, 0, 0, 7, 0, 4}, {0, 0, 0, 0, 0, 0} }; int source = 0, sink = 5; cout << "Maximális áramlás: " << ford_fulkerson(capacity, source, sink) << endl; return 0; }</syntaxhighlight> '''Kimenet''': <pre>Maximális áramlás: 23</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === <span id="előnyök"></span> ==== '''Előnyök''': ==== # Hatékony és egyszerű. # Könnyen általánosítható különböző áramlási problémákra. <span id="hátrányok"></span> ==== '''Hátrányok''': ==== # Nagy kapacitású gráfok esetén lassú lehet (az augmentáló utak száma megnőhet). # Ha az élek kapacitása irracionális szám, az algoritmus nem garantálja a befejezést. A '''Ford-Fulkerson-algoritmus''' az áramlásoptimalizálás alapvető eszköze, amelyet számos gyakorlati alkalmazásban, például hálózattervezésben és logisztikában használnak. ---- *{{en}}: {{t|en|Ford–Fulkerson algorithm}} {{hunl}} gtvw27fmw6m5vvec5r1m6h1ur1i0vj8 0 440133 3479611 2465349 2024-12-13T00:15:04Z LinguisticMystic 22848 3479611 wikitext text/x-wiki {{hunfn}} *{{ru}}: {{t|ru|магический квадрат}} {{hunl}} hio1uz1f8rmwwc0rz27qnshei7uhn0k 3479612 3479611 2024-12-13T00:15:47Z LinguisticMystic 22848 3479612 wikitext text/x-wiki {{hunfn}} *{{en}}: {{t+|en|magic square}} *{{ru}}: {{t|ru|магический квадрат}} {{hunl}} i67b4rw6ug5gthjh6ygjp8hw6g8hv9r 3479614 3479612 2024-12-13T00:17:33Z LinguisticMystic 22848 3479614 wikitext text/x-wiki {{hunfn}} #{{mat}} A '''mágikus négyzet''' egy olyan ( n n ) méretű mátrix, amelyben az összes sor, oszlop és átló elemeinek összege azonos. Ezt az összeget nevezik '''mágikus állandónak''' (( M )). <span id="mágikus-állandó-kiszámítása"></span> === Mágikus állandó kiszámítása === A mágikus állandót az alábbi képlet adja: [ M = ] ahol ( n ) a négyzet mérete. ----- <span id="magic-square-ellenőrzés-algoritmus"></span> === Magic Square ellenőrzés algoritmus === Az alábbi kód ellenőrzi, hogy egy adott mátrix mágikus négyzet-e: <syntaxhighlight lang="python">def magic_square(matrix): n = len(matrix) # Ellenőrizzük, hogy a mátrix négyzetes-e if not all(len(row) == n for row in matrix): return False # Célérték: mágikus állandó target = sum(matrix[0]) # Sorok ellenőrzése for row in matrix: if sum(row) != target: return False # Oszlopok ellenőrzése for col in range(n): if sum(matrix[row][col] for row in range(n)) != target: return False # Főátló ellenőrzése if sum(matrix[i][i] for i in range(n)) != target: return False # Mellékátló ellenőrzése if sum(matrix[i][n - i - 1] for i in range(n)) != target: return False return True</syntaxhighlight> ----- <span id="példa"></span> === Példa === Vegyünk egy ( 3 )-as mátrixot, amely mágikus négyzet: <syntaxhighlight lang="python">matrix = [ [8, 1, 6], [3, 5, 7], [4, 9, 2] ] if magic_square(matrix): print("Ez egy mágikus négyzet!") else: print("Ez nem mágikus négyzet.")</syntaxhighlight> '''Kimenet:''' <pre>Ez egy mágikus négyzet!</pre> ----- <span id="hogyan-működik-az-algoritmus"></span> === Hogyan működik az algoritmus? === # Ellenőrzi, hogy a mátrix négyzetes-e. # Kiszámolja az első sor elemeinek összegét, és ezt mágikus állandónak tekinti. # Ellenőrzi, hogy minden sor, oszlop és átló elemeinek összege megegyezik-e a mágikus állandóval. # Ha bármelyik feltétel nem teljesül, a mátrix nem mágikus négyzet. ----- <span id="korlátok-és-bővítési-lehetőségek"></span> === Korlátok és bővítési lehetőségek === * Az algoritmus feltételezi, hogy a bemenet helyes (egész számokból áll, és négyzet alakú). * Bővíthető például azzal, hogy a mátrix minden elemét ellenőrzi, hogy egy adott tartományon belül van-e. ---- *{{en}}: {{t+|en|magic square}} *{{ru}}: {{t|ru|магический квадрат}} {{hunl}} rr7t5yno97tnoqyzgjveoes5dw4vtfx 0 440312 3479610 2808715 2024-12-13T00:14:31Z LinguisticMystic 22848 3479610 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|linalg}} A transzponálás egy argumentumú művelet. Egy mátrix transzponálása sorainak és oszlopainak a felcserélését jelenti. Egy ''m''×''n''-es mátrix transzponáltja ''n''×''m''-es. Kétszer végrehajtva visszakapjuk az eredeti mátrixot. A transzponálás jele <math>A^T</math> vagy <math>A^{\prime}</math>. Egy mátrix szimmetrikus, ha transzponáltja önmaga, azaz <math>A^T = A</math>. [[szimmetrikus mátrix|Szimmetrikus mátrix]] csak [[négyzetes mátrix]] (lásd alább) lehet. : <math>A = \begin{bmatrix} 1 & 2 & 3 \\ 1 & 2 & 7 \\ 4&9&2 \\ 6&0&5\end{bmatrix}, \ A^T = \begin{bmatrix} 1 & 1 & 4 & 6\\ 2 & 2 & 9 & 0 \\ 3 & 7 & 2 & 5\end{bmatrix}</math> {{-ford-}} *{{en}}: {{t|en|transpose of a matrix}} *{{ru}}: {{t|ru|транспонированная матрица}} {{hunl}} plwcv7ev7jl9vjqbxfrfq21nhi0rw3d 0 441070 3479404 3446547 2024-12-12T14:14:44Z LinguisticMystic 22848 3479404 wikitext text/x-wiki [[Fájl:Set intersection.svg|bélyegkép|jobbra|250px|Az ''A'' és ''B'' halmazok metszete [[Venn-diagram]]on ábrázolva]] {{hunfn}} #{{humatek}} <math>A</math> és <math>B</math> halmazok '''metszete''' az <math>A \cap B = \{x \in U : x \in A \text{ és } x \in B\}</math> halmaz. *{{en}}: {{t|en|intersection of sets}} *{{ru}}: {{t|ru|пересечение множеств }} {{hunl}} 97hvqixq4if0lid2pgle5ykyeogvcqb 0 441348 3479405 3446416 2024-12-12T14:15:09Z LinguisticMystic 22848 3479405 wikitext text/x-wiki [[Fájl:Venn diagram showing Greek, Latin and Cyrillic letters.svg|thumb|A [[görög ábécé]], a [[latin ábécé]] és az [[orosz ábécé]] Venn-diagramja]] {{hunfn}} # {{enmatek}} A Venn-diagram, vagy más elnevezéssel halmazábra, a halmazokat, azok viszonyait, méretét és műveleteit szemléltető diagram. Többnyire síkidomokat tartalmaz: köröket, téglalapokat, ellipsziseket. *{{en}}: {{t|en|Venn diagram}} {{hunl}} jcc9eksrdv1i1rbxtf639kfr7oxn2uz 0 441380 3479402 3447553 2024-12-12T14:13:43Z LinguisticMystic 22848 3479402 wikitext text/x-wiki [[Fájl:Venn A union B.png|250px|jobbra|bélyegkép|Az ''A'' és ''B'' halmazok uniója]] {{hunfn}} [[∪]] # {{humatek}} <math>A</math> és <math>B</math> '''uniója''' az <math>A \cup B = \{x \in U : x \in A \text{ vagy } x \in B\}</math> halmaz. A halmazokat '''[[Venn-diagram]]on''' ábrázolhatjuk. Az unió asszociativitása miatt használhatjuk az :<math>A_1 \cup A_2 \cup \ldots \cup A_n = \bigcup_{i=1}^n A_i</math> jelölést is. *{{en}}: {{t|en|union of sets}} {{hunl}} jmb81y44v34cxde6v68p7zeuogy0tk2 0 471526 3479473 2808420 2024-12-12T21:02:50Z LinguisticMystic 22848 3479473 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo|gráf}} A Prim-algoritmus egy összefüggő súlyozott gráf minimális feszítőfáját határozza meg mohó stratégia segítségével. {{-ford-}} {{trans-top}} * {{en}}: {{t|en|Prim's algorithm}} * {{de}}: {{t|de|Algorithmus von Prim}} * {{ru}}: {{t|ru|алгоритм Прима}} {{trans-bottom}} {{hunl}} 4a5x8dyoqe0mlc8sgm45fhet5hk0q2j 3479480 3479473 2024-12-12T21:15:00Z LinguisticMystic 22848 3479480 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo|gráf}} A '''Prim-algoritmus''' egy gráfelméleti algoritmus, amely minimális feszítőfát ('''MST - Minimum Spanning Tree''') határoz meg egy súlyozott, összefüggő gráfban. Az algoritmus az '''inkrementális''' megközelítést alkalmazza, azaz a fát egy csúcspontból kiindulva iteratívan bővíti a legkisebb súlyú él hozzáadásával, amely még nem része az MST-nek. ----- <span id="elméleti-alapelvek"></span> === '''Elméleti alapelvek''' === # '''Kiindulás''': #* Kezdjük egy tetszőleges csúccsal. # '''Legkisebb él kiválasztása''': #* Válasszuk ki a jelenlegi feszítőfa szomszédos csúcsai közül azt, amely a legkisebb súlyú éllel csatlakozik. # '''Feszítőfa bővítése''': #* Adjuk hozzá a kiválasztott élt és a csúcsot az MST-hez. # '''Ismétlés''': #* Folytassuk addig, amíg minden csúcsot be nem jártunk, és az MST teljes nem lesz. <span id="tulajdonságok"></span> ==== '''Tulajdonságok''' ==== * '''Időkomplexitás''': ** (O(E V)), ha priorizált adatszerkezetet használunk (pl. minimum heap). * '''Gráf típusa''': ** Összefüggő, súlyozott gráfokon működik. * '''Kapzsi algoritmus''': ** Mindig a pillanatnyilag legkisebb súlyú élt választja. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>Prim(G, start): MST = üres halmaz visited = üres halmaz prioritásos sor = [(0, start)] // (él súlya, csúcs) amíg prioritásos sor nem üres: (súly, u) = prioritásos sor legkisebb eleme távolítsd el u-t a prioritásos sorból ha u nincs visited-ben: adjuk hozzá u-t a visited-hez adjuk hozzá az MST-hez minden u szomszéd v esetén: ha v nincs visited-ben: adjuk hozzá (él súlya, v)-t a prioritásos sorhoz térj vissza MST</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">import heapq def prim(graph, start): mst = [] # Minimális feszítőfa élei visited = set() min_heap = [(0, start, None)] # (él súlya, csúcs, előző csúcs) while min_heap: weight, u, parent = heapq.heappop(min_heap) if u in visited: continue visited.add(u) if parent is not None: mst.append((parent, u, weight)) for neighbor, edge_weight in graph[u]: if neighbor not in visited: heapq.heappush(min_heap, (edge_weight, neighbor, u)) return mst # Példa gráf (szomszédsági lista formátum) graph = { 0: [(1, 10), (2, 6), (3, 5)], 1: [(0, 10), (3, 15)], 2: [(0, 6), (3, 4)], 3: [(0, 5), (1, 15), (2, 4)] } mst = prim(graph, 0) print("Minimális feszítőfa élei:") for u, v, weight in mst: print(f"{u} -- {v} == {weight}")</syntaxhighlight> '''Kimenet:''' <pre>Minimális feszítőfa élei: 0 -- 3 == 5 3 -- 2 == 4 0 -- 1 == 10</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <queue> #include <tuple> using namespace std; typedef pair<int, int> Edge; // (él súlya, csúcs) void prim(int V, vector<vector<Edge>>& graph, int start) { priority_queue<Edge, vector<Edge>, greater<Edge>> minHeap; vector<bool> visited(V, false); vector<tuple<int, int, int>> mst; // (forrás, cél, súly) minHeap.push({0, start}); // Kezdőcsúcs (súly, csúcs) while (!minHeap.empty()) { auto [weight, u] = minHeap.top(); minHeap.pop(); if (visited[u]) continue; visited[u] = true; if (weight != 0) { // Kezdőcsúcsnál nincs éltársa mst.push_back({u, weight, weight}); } for (auto& [v, edge_weight] : graph[u]) { if (!visited[v]) { minHeap.push({edge_weight, v}); } } } cout << "Minimális feszítőfa élei:" << endl; for (auto& [u, v, weight] : mst) { cout << u << " -- " << v << " == " << weight << endl; } } int main() { int V = 4; // Csúcsok száma vector<vector<Edge>> graph(V); // Élek hozzáadása (irányítatlan gráf) graph[0].push_back({1, 10}); graph[0].push_back({2, 6}); graph[0].push_back({3, 5}); graph[1].push_back({0, 10}); graph[1].push_back({3, 15}); graph[2].push_back({0, 6}); graph[2].push_back({3, 4}); graph[3].push_back({0, 5}); graph[3].push_back({1, 15}); graph[3].push_back({2, 4}); prim(V, graph, 0); return 0; }</syntaxhighlight> '''Kimenet:''' <pre>Minimális feszítőfa élei: 0 -- 3 == 5 3 -- 2 == 4 0 -- 1 == 10</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === * '''Előnyök''': ** Hatékony nagy gráfokon, ha priorizált adatszerkezetet használunk. ** Egyszerűbb és könnyebben érthető, mint a Kruskal-algoritmus. * '''Hátrányok''': ** Lassabb lehet, ha a gráf nagyon ritka. ** Csak összefüggő gráfokon alkalmazható. A '''Prim-algoritmus''' kiváló választás a minimális feszítőfa meghatározására, különösen sűrű gráfok esetén. A Python és C++ implementációk egyszerűen használhatók, és tovább optimalizálhatók specifikus alkalmazásokhoz. ---- {{-ford-}} {{trans-top}} * {{en}}: {{t|en|Prim's algorithm}} * {{de}}: {{t|de|Algorithmus von Prim}} * {{ru}}: {{t|ru|алгоритм Прима}} {{trans-bottom}} {{hunl}} d53vvvy8c3hr583bielm2eg4rx6bioq 0 471531 3479457 2808404 2024-12-12T20:49:53Z LinguisticMystic 22848 3479457 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo|cryptography}} [[Rivest-Shamir-Adleman-algoritmus ]] tapksr83yml89su52v0duooeg1k4nd8 3479458 3479457 2024-12-12T20:50:00Z LinguisticMystic 22848 3479458 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo|cryptography}} [[Rivest-Shamir-Adleman-algoritmus]] {{hunl}} t056nujvufi41sdbvuhtr1xsix9b3rx 0 471534 3479455 2808414 2024-12-12T20:47:33Z LinguisticMystic 22848 3479455 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo|gráf}} A '''Floyd-Warshall-algoritmus''' egy dinamikus programozási technikán alapuló algoritmus, amely egy súlyozott gráf '''összes csúcspárja közötti legrövidebb útvonalat''' határozza meg. Az algoritmus irányított és irányítatlan gráfokon egyaránt működik, és negatív élű gráfokat is kezel, feltéve, hogy nincsenek negatív súlyú körök. ----- <span id="elmélet"></span> === '''Elmélet''' === <span id="algoritmus-alapelve"></span> ==== '''Algoritmus alapelve''' ==== Az algoritmus iteratívan javítja a legrövidebb utak hosszát. Kezdetben a közvetlen élek súlyát vesszük figyelembe, majd minden iterációban megvizsgáljuk, hogy egy köztes csúcs (k)-n keresztül rövidebb út található-e. <ul> <li>'''D(i, j)''': Az (i)-ből (j)-be vezető legrövidebb út hossza.</li> <li>'''Alaphelyzet''': [ D(i, j) = ]</li> <li>'''Rekurzív formula''': [ D(i, j) = (D(i, j), D(i, k) + D(k, j)), ] ahol (k) az aktuálisan vizsgált köztes csúcs.</li></ul> <span id="fontos-tulajdonságok"></span> ==== '''Fontos tulajdonságok''' ==== * '''Időkomplexitás''': (O(V^3)), ahol (V) a csúcsok száma. * '''Térkomplexitás''': (O(V^2)), mivel egy távolságmátrixot használunk. * '''Negatív körök kezelése''': Ha a főátló mentén egy érték negatívvá válik ((D(i, i) &lt; 0)), akkor negatív súlyú kör van a gráfban. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>FloydWarshall(G): n = G.csúcsok_száma D = mátrix(n x n) // Kezdeti távolságmátrix inicializáld D-t G élsúlyaival ciklus k = 1-től n-ig: ciklus i = 1-től n-ig: ciklus j = 1-től n-ig: D[i][j] = min(D[i][j], D[i][k] + D[k][j]) visszatér D</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def floyd_warshall(graph): # Csúcsok száma n = len(graph) # Távolságmátrix inicializálása dist = [[float('inf')] * n for _ in range(n)] for i in range(n): for j in range(n): if i == j: dist[i][j] = 0 # Saját csúcsba való távolság 0 elif graph[i][j] != 0: dist[i][j] = graph[i][j] # Élek súlya # Floyd-Warshall algoritmus for k in range(n): for i in range(n): for j in range(n): dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]) return dist # Példa gráf graph = [ [0, 3, float('inf'), 5], [2, 0, float('inf'), 4], [float('inf'), 1, 0, float('inf')], [float('inf'), float('inf'), 2, 0] ] distances = floyd_warshall(graph) for row in distances: print(row)</syntaxhighlight> '''Példa bemenet:''' <pre class="plaintext">0 3 ∞ 5 2 0 ∞ 4 ∞ 1 0 ∞ ∞ ∞ 2 0</pre> '''Példa kimenet:''' <pre class="plaintext">0 3 7 5 2 0 6 4 3 1 0 5 5 3 2 0</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <limits> using namespace std; const int INF = numeric_limits<int>::max(); void floydWarshall(vector<vector<int>>& graph) { int n = graph.size(); vector<vector<int>> dist = graph; for (int k = 0; k < n; ++k) { for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { if (dist[i][k] != INF && dist[k][j] != INF && dist[i][k] + dist[k][j] < dist[i][j]) { dist[i][j] = dist[i][k] + dist[k][j]; } } } } // Távolságok kiíratása for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { if (dist[i][j] == INF) { cout << "INF "; } else { cout << dist[i][j] << " "; } } cout << endl; } } int main() { vector<vector<int>> graph = { {0, 3, INF, 5}, {2, 0, INF, 4}, {INF, 1, 0, INF}, {INF, INF, 2, 0} }; floydWarshall(graph); return 0; }</syntaxhighlight> '''Kimenet:''' <pre class="plaintext">0 3 7 5 2 0 6 4 3 1 0 5 5 3 2 0</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === A '''Floyd-Warshall-algoritmus''' egy robusztus, egyszerű algoritmus az összes csúcspár közötti legrövidebb utak megtalálására. Bár időkomplexitása (O(V^3)), ami nagy gráfok esetén nem ideális, kis és közepes méretű gráfokon hatékony és könnyen implementálható. Az algoritmus emellett képes kezelni negatív súlyú éleket, de negatív súlyú körök esetén a probléma felismerésére is alkalmas. {{-ford-}} {{trans-top}} * {{en}}: {{t|en|Floyd-Warshall algorithm}} {{trans-bottom}} {{hunl}} q5odhkusg22c9s3t3apl364stgkqx9i 0 471535 3479440 2808421 2024-12-12T20:15:08Z LinguisticMystic 22848 3479440 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo|gráf}} A Bellman–Ford-algoritmus egy algoritmus, amely kiszámítja a legrövidebb utat egyetlen forrástól (vertex) az összes többi csúcshoz egy súlyozott digráfban. ---- <span id="bellman-ford-algoritmus-bemutatása"></span> === '''Bellman-Ford-algoritmus bemutatása''' === A '''Bellman-Ford-algoritmus''' egy gráfkeresési algoritmus, amely egy adott kezdőcsúcsból hatékonyan meghatározza a legrövidebb útvonalat egy irányított, súlyozott gráf összes többi csúcsába. Az algoritmus képes kezelni negatív súlyú éleket, és észleli a negatív köröket (olyan köröket, amelyek súlyainak összege negatív). ----- <span id="elmélet"></span> === '''Elmélet''' === <span id="lépések"></span> ==== '''Lépések''': ==== # '''Távolságok inicializálása''': #* A kezdőcsúcs távolsága 0, minden más csúcs távolsága () (végtelen). # '''Élek lazítása''': #* Minden csúcsra ismételd meg: lazítsd az összes él súlyát (V - 1) alkalommal (ahol (V) a csúcsok száma). Ez azt jelenti, hogy ha egy csúcsból egy szomszédba vezető út rövidebb, mint a jelenlegi ismert távolság, akkor frissítsük a távolságot. # '''Negatív kör ellenőrzése''': #* Ha egy újabb lazítás során találunk olyan élt, amelyen keresztül tovább csökkenthető lenne egy távolság, az azt jelenti, hogy negatív súlyú kört találtunk. ----- <span id="fontos-tulajdonságok"></span> === '''Fontos tulajdonságok''' === * '''Időkomplexitás''': (O(V E)), ahol (V) a csúcsok, (E) az élek száma. * '''Térkomplexitás''': (O(V)), mivel csak a távolságokat és a szülőket tároljuk. * '''Negatív körök észlelése''': Egyetlen éllazítási iterációval (V - 1) kör után. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>BellmanFord(G, start): Távolság = [végtelen] * G.csúcsok_száma Távolság[start] = 0 ismételd (G.csúcsok_száma - 1) alkalommal: minden él (u, v, w) esetén: ha Távolság[u] + w &lt; Távolság[v]: Távolság[v] = Távolság[u] + w minden él (u, v, w) esetén: ha Távolság[u] + w &lt; Távolság[v]: negatív kör van visszatér Távolság</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def bellman_ford(graph, vertices, edges, start): # Távolságok inicializálása distances = [float('inf')] * vertices distances[start] = 0 # Az élek lazítása V-1 alkalommal for _ in range(vertices - 1): for u, v, weight in edges: if distances[u] != float('inf') and distances[u] + weight < distances[v]: distances[v] = distances[u] + weight # Negatív kör ellenőrzése for u, v, weight in edges: if distances[u] != float('inf') and distances[u] + weight < distances[v]: raise ValueError("Negatív súlyú kör található!") return distances # Példa gráf (csúcsok: 5, élek: [(forrás, cél, súly)]) vertices = 5 edges = [ (0, 1, -1), (0, 2, 4), (1, 2, 3), (1, 3, 2), (1, 4, 2), (3, 2, 5), (3, 1, 1), (4, 3, -3) ] try: distances = bellman_ford(edges, vertices, edges, 0) print("Távolságok a 0. csúcsból:", distances) except ValueError as e: print(e)</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <tuple> #include <limits> using namespace std; // Bellman-Ford algoritmus megvalósítása vector<int> bellman_ford(int vertices, vector<tuple<int, int, int>>& edges, int start) { // Távolságok inicializálása vector<int> distances(vertices, numeric_limits<int>::max()); distances[start] = 0; // Élek lazítása V-1 alkalommal for (int i = 0; i < vertices - 1; ++i) { for (const auto& [u, v, weight] : edges) { if (distances[u] != numeric_limits<int>::max() && distances[u] + weight < distances[v]) { distances[v] = distances[u] + weight; } } } // Negatív kör ellenőrzése for (const auto& [u, v, weight] : edges) { if (distances[u] != numeric_limits<int>::max() && distances[u] + weight < distances[v]) { throw runtime_error("Negatív súlyú kör található!"); } } return distances; } int main() { int vertices = 5; vector<tuple<int, int, int>> edges = { {0, 1, -1}, {0, 2, 4}, {1, 2, 3}, {1, 3, 2}, {1, 4, 2}, {3, 2, 5}, {3, 1, 1}, {4, 3, -3} }; try { vector<int> distances = bellman_ford(vertices, edges, 0); cout << "Távolságok a 0. csúcsból:" << endl; for (int i = 0; i < distances.size(); ++i) { cout << "0 -> " << i << ": " << distances[i] << endl; } } catch (const runtime_error& e) { cout << e.what() << endl; } return 0; }</syntaxhighlight> ----- <span id="összegzés"></span> === '''Összegzés''' === A '''Bellman-Ford-algoritmus''' erőteljes módszer a legrövidebb utak meghatározására súlyozott gráfokban, beleértve azokat, amelyek negatív súlyú éleket tartalmaznak. Képes felismerni negatív köröket, ezért különösen hasznos olyan problémákban, ahol ezek előfordulhatnak. Mind Pythonban, mind C++-ban könnyen implementálható, és széles körben alkalmazzák hálózatelemzésben, ütemezésben és egyéb algoritmikus problémák megoldására. 3m1tyvy0hbphq5m8g1ulmfa40kji84g 3479441 3479440 2024-12-12T20:15:56Z LinguisticMystic 22848 3479441 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo|gráf}} A Bellman–Ford-algoritmus egy algoritmus, amely kiszámítja a legrövidebb utat egyetlen forrástól (vertex) az összes többi csúcshoz egy súlyozott digráfban. ---- <span id="bellman-ford-algoritmus-bemutatása"></span> === '''Bellman-Ford-algoritmus bemutatása''' === A '''Bellman-Ford-algoritmus''' egy gráfkeresési algoritmus, amely egy adott kezdőcsúcsból hatékonyan meghatározza a legrövidebb útvonalat egy irányított, súlyozott gráf összes többi csúcsába. Az algoritmus képes kezelni negatív súlyú éleket, és észleli a negatív köröket (olyan köröket, amelyek súlyainak összege negatív). ----- <span id="elmélet"></span> === '''Elmélet''' === <span id="lépések"></span> ==== '''Lépések''': ==== # '''Távolságok inicializálása''': #* A kezdőcsúcs távolsága 0, minden más csúcs távolsága () (végtelen). # '''Élek lazítása''': #* Minden csúcsra ismételd meg: lazítsd az összes él súlyát (V - 1) alkalommal (ahol (V) a csúcsok száma). Ez azt jelenti, hogy ha egy csúcsból egy szomszédba vezető út rövidebb, mint a jelenlegi ismert távolság, akkor frissítsük a távolságot. # '''Negatív kör ellenőrzése''': #* Ha egy újabb lazítás során találunk olyan élt, amelyen keresztül tovább csökkenthető lenne egy távolság, az azt jelenti, hogy negatív súlyú kört találtunk. ----- <span id="fontos-tulajdonságok"></span> === '''Fontos tulajdonságok''' === * '''Időkomplexitás''': (O(V E)), ahol (V) a csúcsok, (E) az élek száma. * '''Térkomplexitás''': (O(V)), mivel csak a távolságokat és a szülőket tároljuk. * '''Negatív körök észlelése''': Egyetlen éllazítási iterációval (V - 1) kör után. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>BellmanFord(G, start): Távolság = [végtelen] * G.csúcsok_száma Távolság[start] = 0 ismételd (G.csúcsok_száma - 1) alkalommal: minden él (u, v, w) esetén: ha Távolság[u] + w &lt; Távolság[v]: Távolság[v] = Távolság[u] + w minden él (u, v, w) esetén: ha Távolság[u] + w &lt; Távolság[v]: negatív kör van visszatér Távolság</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def bellman_ford(graph, vertices, edges, start): # Távolságok inicializálása distances = [float('inf')] * vertices distances[start] = 0 # Az élek lazítása V-1 alkalommal for _ in range(vertices - 1): for u, v, weight in edges: if distances[u] != float('inf') and distances[u] + weight < distances[v]: distances[v] = distances[u] + weight # Negatív kör ellenőrzése for u, v, weight in edges: if distances[u] != float('inf') and distances[u] + weight < distances[v]: raise ValueError("Negatív súlyú kör található!") return distances # Példa gráf (csúcsok: 5, élek: [(forrás, cél, súly)]) vertices = 5 edges = [ (0, 1, -1), (0, 2, 4), (1, 2, 3), (1, 3, 2), (1, 4, 2), (3, 2, 5), (3, 1, 1), (4, 3, -3) ] try: distances = bellman_ford(edges, vertices, edges, 0) print("Távolságok a 0. csúcsból:", distances) except ValueError as e: print(e)</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <tuple> #include <limits> using namespace std; // Bellman-Ford algoritmus megvalósítása vector<int> bellman_ford(int vertices, vector<tuple<int, int, int>>& edges, int start) { // Távolságok inicializálása vector<int> distances(vertices, numeric_limits<int>::max()); distances[start] = 0; // Élek lazítása V-1 alkalommal for (int i = 0; i < vertices - 1; ++i) { for (const auto& [u, v, weight] : edges) { if (distances[u] != numeric_limits<int>::max() && distances[u] + weight < distances[v]) { distances[v] = distances[u] + weight; } } } // Negatív kör ellenőrzése for (const auto& [u, v, weight] : edges) { if (distances[u] != numeric_limits<int>::max() && distances[u] + weight < distances[v]) { throw runtime_error("Negatív súlyú kör található!"); } } return distances; } int main() { int vertices = 5; vector<tuple<int, int, int>> edges = { {0, 1, -1}, {0, 2, 4}, {1, 2, 3}, {1, 3, 2}, {1, 4, 2}, {3, 2, 5}, {3, 1, 1}, {4, 3, -3} }; try { vector<int> distances = bellman_ford(vertices, edges, 0); cout << "Távolságok a 0. csúcsból:" << endl; for (int i = 0; i < distances.size(); ++i) { cout << "0 -> " << i << ": " << distances[i] << endl; } } catch (const runtime_error& e) { cout << e.what() << endl; } return 0; }</syntaxhighlight> ----- <span id="összegzés"></span> === '''Összegzés''' === A '''Bellman-Ford-algoritmus''' erőteljes módszer a legrövidebb utak meghatározására súlyozott gráfokban, beleértve azokat, amelyek negatív súlyú éleket tartalmaznak. Képes felismerni negatív köröket, ezért különösen hasznos olyan problémákban, ahol ezek előfordulhatnak. Mind Pythonban, mind C++-ban könnyen implementálható, és széles körben alkalmazzák hálózatelemzésben, ütemezésben és egyéb algoritmikus problémák megoldására. {{hunl}} h77pvauqku1b6rnnep85a6fm2v0z1vy 0 471542 3479497 3189713 2024-12-12T21:43:40Z LinguisticMystic 22848 3479497 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika}} {{-ford-}} {{trans-top}} *{{en}}: {{t+|en|Edmonds-Karp algorithm}} {{trans-bottom}} {{hunl}} 0hfd7hu4maluxl8jwffgfrsc9b2x50q 3479510 3479497 2024-12-12T21:56:22Z LinguisticMystic 22848 3479510 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika}} <span id="edmonds-karp-algoritmus"></span> === '''Edmonds-Karp-algoritmus''' === Az '''Edmonds-Karp-algoritmus''' a '''Ford-Fulkerson-algoritmus''' specializált változata, amely hatékonyan számítja ki egy hálózat maximális áramlását. Az algoritmus a Ford-Fulkerson módszert alkalmazza úgy, hogy a legkisebb számú élt tartalmazó utakat (azaz szélességi keresést - BFS-t) használja az augmentáló utak megtalálásához. ----- <span id="elmélet"></span> === '''Elmélet''' === # '''Hálózat fogalma''': #* Egy irányított gráf ((G = (V, E))) csúcsokból ((V)) és élekből ((E)) áll. #* Minden élhez tartozik egy kapacitás ((c(u, v))). #* Van egy '''forrás''' ((s)) és egy '''nyelő''' ((t)) csúcs. # '''Cél''': #* Maximális áramlást találni a forrásból a nyelőbe úgy, hogy az áramlás ne lépje túl az élek kapacitását, és teljesüljön az áramlási megmaradás törvénye minden csúcson belül. # '''Algoritmus működése''': #* Kezdjünk nulla áramlással. #* Ismételjük, amíg találunk augmentáló utat: #** Keressük meg az (s t) útvonalat BFS-sel az aktuális maradék gráfban. #** Határozzuk meg a lehetséges maximális áramlást az úton ((bottleneck)). #** Frissítsük az áramlást és a maradék gráfot. #* Az áramlás maximális, ha nincs több augmentáló út. # '''Maradék gráf''': #* A maradék gráf tartalmazza a kapacitásokat az aktuális áramlás figyelembevételével: [ c_{}(u, v) = c(u, v) - f(u, v) ] ----- <span id="időkomplexitás"></span> === '''Időkomplexitás''' === * '''Komplexitás''': (O(V E^2)) ** (O(E)) egy BFS költsége. ** (O(V E)) a lehetséges augmentáló utak száma. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>EdmondsKarp(G, s, t): inicializálj minden élhez tartozó áramlást nullára amíg van augmentáló út s-től t-ig BFS-sel: határozd meg az út kapacitását (bottleneck) frissítsd az áramlást az úton frissítsd a maradék gráfot térj vissza a maximális áramlás értékével</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">from collections import deque def bfs(residual_graph, source, sink, parent): visited = set() queue = deque([source]) visited.add(source) while queue: u = queue.popleft() for v, capacity in enumerate(residual_graph[u]): if v not in visited and capacity > 0: parent[v] = u if v == sink: return True visited.add(v) queue.append(v) return False def edmonds_karp(capacity, source, sink): n = len(capacity) residual_graph = [row[:] for row in capacity] parent = [-1] * n max_flow = 0 while bfs(residual_graph, source, sink, parent): # Keressük a bottleneck kapacitást path_flow = float('Inf') v = sink while v != source: u = parent[v] path_flow = min(path_flow, residual_graph[u][v]) v = u # Frissítsük az áramlást és a maradék gráfot v = sink while v != source: u = parent[v] residual_graph[u][v] -= path_flow residual_graph[v][u] += path_flow v = u max_flow += path_flow return max_flow # Példa gráf (kapacitás mátrix formátumban) capacity = [ [0, 16, 13, 0, 0, 0], [0, 0, 10, 12, 0, 0], [0, 4, 0, 0, 14, 0], [0, 0, 9, 0, 0, 20], [0, 0, 0, 7, 0, 4], [0, 0, 0, 0, 0, 0] ] source, sink = 0, 5 print("Maximális áramlás:", edmonds_karp(capacity, source, sink))</syntaxhighlight> '''Kimenet:''' <pre>Maximális áramlás: 23</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <queue> #include <climits> #include <cstring> using namespace std; bool bfs(const vector<vector<int>>& residual_graph, int source, int sink, vector<int>& parent) { int n = residual_graph.size(); vector<bool> visited(n, false); queue<int> q; q.push(source); visited[source] = true; while (!q.empty()) { int u = q.front(); q.pop(); for (int v = 0; v < n; ++v) { if (!visited[v] && residual_graph[u][v] > 0) { parent[v] = u; if (v == sink) return true; visited[v] = true; q.push(v); } } } return false; } int edmonds_karp(const vector<vector<int>>& capacity, int source, int sink) { int n = capacity.size(); vector<vector<int>> residual_graph = capacity; vector<int> parent(n, -1); int max_flow = 0; while (bfs(residual_graph, source, sink, parent)) { // Keressük a bottleneck kapacitást int path_flow = INT_MAX; for (int v = sink; v != source; v = parent[v]) { int u = parent[v]; path_flow = min(path_flow, residual_graph[u][v]); } // Frissítsük az áramlást és a maradék gráfot for (int v = sink; v != source; v = parent[v]) { int u = parent[v]; residual_graph[u][v] -= path_flow; residual_graph[v][u] += path_flow; } max_flow += path_flow; } return max_flow; } int main() { vector<vector<int>> capacity = { {0, 16, 13, 0, 0, 0}, {0, 0, 10, 12, 0, 0}, {0, 4, 0, 0, 14, 0}, {0, 0, 9, 0, 0, 20}, {0, 0, 0, 7, 0, 4}, {0, 0, 0, 0, 0, 0} }; int source = 0, sink = 5; cout << "Maximális áramlás: " << edmonds_karp(capacity, source, sink) << endl; return 0; }</syntaxhighlight> '''Kimenet:''' <pre>Maximális áramlás: 23</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === <span id="előnyök"></span> ==== '''Előnyök''': ==== # '''Garantált konvergencia''': A legrosszabb esetben is működik. # '''Egyszerű implementáció''': Könnyen követhető és megérthető. <span id="hátrányok"></span> ==== '''Hátrányok''': ==== # '''Teljesítmény''': Nagyon sűrű gráfok esetén az (O(V E^2)) időkomplexitás lassú lehet. Az '''Edmonds-Karp-algoritmus''' széles körben használt az áramlási problémák megoldására, és egyszerűsége miatt kiváló választás tanulmányozásra vagy alapvető implementációra. {{-ford-}} {{trans-top}} *{{en}}: {{t+|en|Edmonds-Karp algorithm}} {{trans-bottom}} {{hunl}} rcfn42ik6w7kb82zoo7tdcummdz1n6a 0 471548 3479518 2808474 2024-12-12T22:14:59Z LinguisticMystic 22848 3479518 wikitext text/x-wiki {{hunfn}} #{{label|en|matematika|algo|gráf}} A magyar módszer egy algoritmus, segítségével [[páros gráf|páros gráfokban]] lehet maximális elemszámú párosítást keresni polinom időben. Harold Kuhn dolgozta ki az eljárást Kőnig Dénes és Egerváry Jenő munkája nyomán. ---- <span id="magyar-módszer-hungarian-method"></span> === '''Magyar módszer (Hungarian Method)''' === A '''Magyar módszer''', amelyet Harold Kuhn dolgozott ki és publikált 1955-ben, egy hatékony algoritmus a '''költségminimalizáló hozzárendelési probléma''' megoldására. Az algoritmus neve a magyar származású matematikusok, '''Dénes Kőnig''' és '''Jeno Egerváry''' munkásságára utal, amelyeken az eljárás alapul. ----- <span id="probléma-leírása"></span> === '''Probléma leírása''' === A hozzárendelési probléma célja egy (n n) költségmátrixban a megfelelő hozzárendelés megtalálása úgy, hogy: - Minden munkához egy munkás van rendelve. - A hozzárendelés összköltsége minimális legyen. <span id="bemenet"></span> ==== '''Bemenet''': ==== Egy (n n) költségmátrix ((C[i][j])), ahol (C[i][j]) a (i)-edik munkás hozzárendelésének a (j)-edik munkához tartozó költsége. <span id="kimenet"></span> ==== '''Kimenet''': ==== Az optimális hozzárendelés, amely minimalizálja az összköltséget. ----- <span id="algoritmus-lépései"></span> === '''Algoritmus lépései''' === # '''Sor- és oszlopcsökkentés''': #* Minden sorból vonjuk ki a legkisebb elemet. #* Ezután minden oszlopból vonjuk ki az oszlop legkisebb értékét. # '''Nulla lefedése''': #* Takarjuk le a nullákat a lehető legkevesebb sorral és oszloppal. #* Ha a lefedett sorok és oszlopok száma megegyezik a mátrix méretével ((n)), kész a megoldás. # '''Nullák kijelölése''': #* Ha a lefedés nem teljes: #** Jelöljük ki a legkisebb nem lefedett elemet ((x)). #** Minden lefedett sorhoz adjuk hozzá (x), és minden nem lefedett oszlopból vonjuk ki (x). #* Ismételjük, amíg az összes hozzárendelés megtalálható. # '''Optimális hozzárendelés''': #* Ha minden nulla egyedi hozzárendeléshez vezet, megkapjuk az optimális megoldást. ----- <span id="időkomplexitás"></span> === '''Időkomplexitás''' === Az algoritmus időkomplexitása: (O(n^3)), ahol (n) a mátrix mérete. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>HungarianMethod(C): Sor- és oszlopcsökkentés: Minden sorból vond ki a legkisebb elemet. Minden oszlopból vond ki a legkisebb elemet. Lefedés nullák alapján: Takarjuk le a nullákat a lehető legkevesebb sorral és oszloppal. Ha a lefedés száma = mátrix mérete, térj vissza a hozzárendeléssel. Nullák kezelése: Jelöljük ki a legkisebb nem lefedett elemet. Minden lefedett sorhoz adjuk hozzá ezt az elemet, és minden nem lefedett oszlopból vonjuk ki. Ismételjük az eljárást, amíg optimális hozzárendelést kapunk.</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">import numpy as np def hungarian_method(cost_matrix): n = len(cost_matrix) cost = np.array(cost_matrix) # Sorcsökkentés cost -= cost.min(axis=1, keepdims=True) # Oszlopcsökkentés cost -= cost.min(axis=0, keepdims=True) # Lefedés nullák alapján while True: row_covered = np.zeros(n, dtype=bool) col_covered = np.zeros(n, dtype=bool) zero_mark = np.zeros_like(cost, dtype=bool) # Nullák kijelölése for i in range(n): for j in range(n): if cost[i, j] == 0 and not row_covered[i] and not col_covered[j]: zero_mark[i, j] = True row_covered[i] = True col_covered[j] = True break # Lefedés nullák alapján row_covered[:] = False col_covered[:] = np.any(zero_mark, axis=0) # Ellenőrzés: lefedett sorok és oszlopok száma if np.sum(row_covered) + np.sum(col_covered) == n: break # Nullák kezelése uncovered_min = np.min(cost[~row_covered][:, ~col_covered]) cost[~row_covered] -= uncovered_min cost[:, col_covered] += uncovered_min # Optimális hozzárendelés assignment = [] for i in range(n): for j in range(n): if zero_mark[i, j]: assignment.append((i, j)) return assignment # Példa használat cost_matrix = [ [9, 11, 14, 11], [6, 15, 13, 13], [12, 13, 6, 8], [11, 9, 10, 12] ] assignment = hungarian_method(cost_matrix) print("Optimális hozzárendelés:", assignment)</syntaxhighlight> '''Kimenet''': <pre>Optimális hozzárendelés: [(0, 1), (1, 0), (2, 2), (3, 3)]</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <limits> #include <algorithm> using namespace std; void reduce_rows(vector<vector<int>>& cost) { for (auto& row : cost) { int min_val = *min_element(row.begin(), row.end()); for (auto& cell : row) { cell -= min_val; } } } void reduce_columns(vector<vector<int>>& cost) { int n = cost.size(); for (int j = 0; j < n; ++j) { int min_val = numeric_limits<int>::max(); for (int i = 0; i < n; ++i) { min_val = min(min_val, cost[i][j]); } for (int i = 0; i < n; ++i) { cost[i][j] -= min_val; } } } vector<pair<int, int>> hungarian_method(vector<vector<int>>& cost) { int n = cost.size(); reduce_rows(cost); reduce_columns(cost); vector<bool> row_covered(n, false); vector<bool> col_covered(n, false); vector<pair<int, int>> assignment; while (true) { for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { if (cost[i][j] == 0 && !row_covered[i] && !col_covered[j]) { assignment.emplace_back(i, j); row_covered[i] = true; col_covered[j] = true; break; } } } if (assignment.size() == n) break; int uncovered_min = numeric_limits<int>::max(); for (int i = 0; i < n; ++i) { if (!row_covered[i]) { for (int j = 0; j < n; ++j) { if (!col_covered[j]) { uncovered_min = min(uncovered_min, cost[i][j]); } } } } for (int i = 0; i < n; ++i) { if (!row_covered[i]) { for (int j = 0; j < n; ++j) { cost[i][j] -= uncovered_min; } } if (col_covered[i]) { for (int j = 0; j < n; ++j) { cost[j][i] += uncovered_min; } } } } return assignment; } int main() { vector<vector<int>> cost = { {9, 11, 14, 11}, {6, 15, 13, 13}, {12, 13, 6, 8}, {11, 9, 10, 12} }; auto assignment = hungarian_method(cost); cout << "Optimális hozzárendelés:" << endl; for (const auto& pair : assignment) { cout << "(" << pair.first << ", " << pair.second << ")" << endl; } return 0; }</syntaxhighlight> '''Kimenet''': <pre>Optimális hozzárendelés: (0, 1) (1, 0) (2, 2) (3, 3)</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === <span id="előnyök"></span> ==== '''Előnyök''': ==== # '''Hatékonyság''': Garantáltan optimális megoldást talál (O(n^3)) időben. # '''Általánosíthatóság''': Bármilyen (n n) hozzárendelési problémára alkalmazható. <span id="hátrányok"></span> ==== '''Hátrányok''': ==== # Csak négyzetes mátrixokra működik. Nem négyzetes esetben nullákkal kell kiegészíteni. # Nagy méretű mátrixok esetén memóriaigényes. A Magyar módszer széles körben használt optimalizálási problémák megoldására, különösen logisztikai és erőforrás-elosztási alkalmazásokban. {{-ford-}} {{trans-top}} * {{en}}: {{t|en|Hungarian method}} * {{de}}: {{t|de|ungarische Methode}}, {{t|de|Kuhn-Munkres-Algorithmus}} {{trans-bottom}} 0ka14jnwztdgfce0z3ut5ooxy0ory55 0 471557 3479499 2808517 2024-12-12T21:45:25Z LinguisticMystic 22848 3479499 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|opkut}} {{-ford-}} {{trans-top}} * {{en}}: {{t|en|branch and bound}} * {{de}}: {{t|de|Verzweigung und Schranke}} {{trans-bottom}} {{hunl}} 5abg55gxm8rtdtobpfldv0zcrojtwv0 3479512 3479499 2024-12-12T22:02:13Z LinguisticMystic 22848 3479512 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|opkut}} A '''korlátozás és szétválasztás (Branch and Bound)''' egy optimalizálási technika, amelyet kombinatorikus problémák, például az '''utazó ügynök problémája (TSP)''', '''hátizsák probléma''', és '''egészértékű programozási problémák''' megoldására használnak. Ez egy '''oszd meg és uralkodj''' típusú algoritmus, amely hatékonyan csökkenti a keresési tér méretét felső- és alsó becslések (bound) segítségével. ----- <span id="elmélet"></span> === '''Elmélet''' === # '''Probléma felosztása''' (''Branching''): #* A problémát kisebb részekre bontjuk (azaz alproblémákra). #* Ezeket az alproblémákat fa struktúrában kezeljük. # '''Korlátozás alkalmazása''' (''Bounding''): #* Minden alproblémára kiszámítunk egy '''alsó becslést''' (optimális érték alulról) és egy '''felső becslést''' (optimális érték felülről). #* Ha az alsó becslés rosszabb, mint az aktuálisan ismert legjobb megoldás, az adott ágat elvetjük (pruning). # '''Globális optimum keresése''': #* Az algoritmus iteratívan bővíti a fa csomópontjait, és csak azokat vizsgálja tovább, amelyek ígéretesek (azaz javíthatják az aktuális legjobb megoldást). ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>BranchAndBound(root): inicializálj egy üres prioritásos sort (Q) helyezd a gyökércsomópontot Q-ba legjobb_megoldás = ∞ amíg Q nem üres: csomópont = Q legjobb elemének kivétele ha csomópont alsó becslése ≥ legjobb_megoldás: folytasd (pruning) ha csomópont terminális és jobb megoldás, mint legjobb_megoldás: legjobb_megoldás = csomópont értéke különben: oszd fel a csomópontot alcsomópontokra számíts alsó és felső becslést az alcsomópontokra helyezd az alcsomópontokat Q-ba térj vissza legjobb_megoldás</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === Példa a '''hátizsák probléma''' (Knapsack Problem) megoldására: <syntaxhighlight lang="python">class Node: def __init__(self, level, profit, weight, bound): self.level = level # Az aktuális elem szintje self.profit = profit # Az aktuális haszon self.weight = weight # Az aktuális súly self.bound = bound # Az aktuális csomópont felső korlátja def knapsack_bound(node, capacity, weights, profits, n): if node.weight >= capacity: return 0 # Ha a súly meghaladja a kapacitást, nincs haszon bound = node.profit total_weight = node.weight j = node.level + 1 while j < n and total_weight + weights[j] <= capacity: total_weight += weights[j] bound += profits[j] j += 1 if j < n: bound += (capacity - total_weight) * (profits[j] / weights[j]) return bound def knapsack_branch_and_bound(capacity, weights, profits): n = len(weights) items = sorted(range(n), key=lambda i: profits[i] / weights[i], reverse=True) weights = [weights[i] for i in items] profits = [profits[i] for i in items] queue = [] root = Node(-1, 0, 0, 0) root.bound = knapsack_bound(root, capacity, weights, profits, n) queue.append(root) max_profit = 0 while queue: current_node = queue.pop(0) if current_node.level == n - 1: continue next_level = current_node.level + 1 # 1. Ha a következő elem szerepel include = Node( next_level, current_node.profit + profits[next_level], current_node.weight + weights[next_level], 0 ) if include.weight <= capacity and include.profit > max_profit: max_profit = include.profit include.bound = knapsack_bound(include, capacity, weights, profits, n) if include.bound > max_profit: queue.append(include) # 2. Ha a következő elem nem szerepel exclude = Node(next_level, current_node.profit, current_node.weight, 0) exclude.bound = knapsack_bound(exclude, capacity, weights, profits, n) if exclude.bound > max_profit: queue.append(exclude) return max_profit # Példa használat capacity = 50 weights = [10, 20, 30] profits = [60, 100, 120] max_profit = knapsack_branch_and_bound(capacity, weights, profits) print(f"Maximális haszon: {max_profit}")</syntaxhighlight> '''Kimenet:''' <pre>Maximális haszon: 220</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === Példa a '''hátizsák probléma''' megoldására: <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <queue> #include <algorithm> using namespace std; struct Node { int level; int profit; int weight; double bound; Node(int lvl, int prof, int wt, double bnd) : level(lvl), profit(prof), weight(wt), bound(bnd) {} }; bool cmp(pair<double, int> a, pair<double, int> b) { return a.first > b.first; } double knapsack_bound(Node node, int capacity, vector<int>& weights, vector<int>& profits, int n) { if (node.weight >= capacity) return 0; double bound = node.profit; int total_weight = node.weight; int j = node.level + 1; while (j < n && total_weight + weights[j] <= capacity) { total_weight += weights[j]; bound += profits[j]; j++; } if (j < n) { bound += (capacity - total_weight) * ((double)profits[j] / weights[j]); } return bound; } int knapsack_branch_and_bound(int capacity, vector<int>& weights, vector<int>& profits) { int n = weights.size(); vector<pair<double, int>> ratios(n); for (int i = 0; i < n; ++i) { ratios[i] = {(double)profits[i] / weights[i], i}; } sort(ratios.begin(), ratios.end(), cmp); vector<int> sorted_weights(n), sorted_profits(n); for (int i = 0; i < n; ++i) { sorted_weights[i] = weights[ratios[i].second]; sorted_profits[i] = profits[ratios[i].second]; } queue<Node> q; Node root(-1, 0, 0, 0); root.bound = knapsack_bound(root, capacity, sorted_weights, sorted_profits, n); q.push(root); int max_profit = 0; while (!q.empty()) { Node current = q.front(); q.pop(); if (current.level == n - 1) continue; int next_level = current.level + 1; Node include(next_level, current.profit + sorted_profits[next_level], current.weight + sorted_weights[next_level], 0); if (include.weight <= capacity && include.profit > max_profit) { max_profit = include.profit; } include.bound = knapsack_bound(include, capacity, sorted_weights, sorted_profits, n); if (include.bound > max_profit) { q.push(include); } Node exclude(next_level, current.profit, current.weight, 0); exclude.bound = knapsack_bound(exclude, capacity, sorted_weights, sorted_profits, n); if (exclude.bound > max_profit) { q.push(exclude); } } return max_profit; } int main() { int capacity = 50; vector<int> weights = {10, 20, 30}; vector<int> profits = {60, 100, 120}; int max_profit = knapsack_branch_and_bound(capacity, weights, profits); cout << "Maximális haszon: " << max_profit << endl; return 0; }</syntaxhighlight> '''Kimenet:''' <pre>Maximális haszon: 220</pre> {{-ford-}} {{trans-top}} * {{en}}: {{t|en|branch and bound}} * {{de}}: {{t|de|Verzweigung und Schranke}} {{trans-bottom}} {{hunl}} 1gd2jdzmam3lq25vqfhoaavlqi7ek9s 0 471560 3479469 3451213 2024-12-12T21:01:09Z LinguisticMystic 22848 3479469 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika|algo|inf}} A '''Minimax algoritmus''' egy döntéshozatali eljárás, amelyet főként kétjátékos, nullösszegű játékokban alkalmaznak, például sakkban vagy tic-tac-toe-ban. Az algoritmus célja, hogy az egyik játékos maximalizálja a saját nyereségét, míg az ellenfél ugyanakkor próbálja minimalizálni azt. ----- <span id="algoritmus-alapelve"></span> === '''Algoritmus alapelve''' === # '''Oszd meg és uralkodj''': #* A játékállapotokat rekurzívan bontjuk kisebb részekre. # '''Döntési szabály''': #* A '''Maximizer''' a legnagyobb értéket próbálja elérni. #* A '''Minimizer''' a legkisebb értéket próbálja elérni. # '''Kiértékelés''': #* Az algoritmus a játékfa leveleitől (végállapotok) indul, ahol az értékeket közvetlenül meghatározza az állapot hasznossága. # '''Visszaterjedés''': #* Az állapotok értékei a játékfa leveleitől visszaterjednek a gyökérhez, ahol a Maximizer és Minimizer váltakozva választja ki a legjobb értéket. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>Minimax(node, depth, maximizingPlayer): ha depth == 0 vagy node végállapot: térj vissza node értéke ha maximizingPlayer: maxEval = -végtelen minden child in node gyerekek: eval = Minimax(child, depth - 1, hamis) maxEval = max(maxEval, eval) térj vissza maxEval különben: minEval = +végtelen minden child in node gyerekek: eval = Minimax(child, depth - 1, igaz) minEval = min(minEval, eval) térj vissza minEval</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <span id="alap-minimax"></span> ==== '''Alap Minimax''' ==== <syntaxhighlight lang="python">def minimax(position, depth, maximizingPlayer): if depth == 0 or is_terminal(position): return evaluate(position) if maximizingPlayer: maxEval = float('-inf') for child in get_children(position): eval = minimax(child, depth - 1, False) maxEval = max(maxEval, eval) return maxEval else: minEval = float('inf') for child in get_children(position): eval = minimax(child, depth - 1, True) minEval = min(minEval, eval) return minEval</syntaxhighlight> <span id="egyszerű-példa-tic-tac-toe"></span> ==== '''Egyszerű példa: Tic-Tac-Toe''' ==== <syntaxhighlight lang="python">def evaluate(position): # Kiértékelés logikája # Például +1 győzelemért, -1 vereségért, 0 döntetlenért pass def get_children(position): # Minden lehetséges lépésből származó új játékállapot pass def is_terminal(position): # Ellenőrzi, hogy az állapot végállapot-e pass</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <limits> using namespace std; const int MAX = numeric_limits<int>::max(); const int MIN = numeric_limits<int>::min(); // Kiértékelő függvény (példa) int evaluate(vector<vector<char>>& board) { // Implementálj kiértékelést return 0; } // Ellenőrizze, hogy végállapot-e bool is_terminal(vector<vector<char>>& board) { // Implementálj végállapot ellenőrzést return false; } int minimax(vector<vector<char>>& board, int depth, bool maximizingPlayer) { if (depth == 0 || is_terminal(board)) { return evaluate(board); } if (maximizingPlayer) { int maxEval = MIN; // Generálj gyermekállapotokat (példa) for (auto& child : get_children(board)) { int eval = minimax(child, depth - 1, false); maxEval = max(maxEval, eval); } return maxEval; } else { int minEval = MAX; // Generálj gyermekállapotokat (példa) for (auto& child : get_children(board)) { int eval = minimax(child, depth - 1, true); minEval = min(minEval, eval); } return minEval; } } int main() { vector<vector<char>> board = { {'_', '_', '_'}, {'_', '_', '_'}, {'_', '_', '_'} }; int bestValue = minimax(board, 3, true); cout << "A legjobb lépés értéke: " << bestValue << endl; return 0; }</syntaxhighlight> ----- <span id="optimalizáció-alfa-béta-metszés"></span> === '''Optimalizáció: Alfa-Béta Metszés''' === Az '''alfa-béta metszés''' csökkenti a játékfa ágainak számát, amelyeket ténylegesen ki kell értékelni. Ez jelentősen javítja a teljesítményt anélkül, hogy a végeredményt befolyásolná. <span id="pszeudokód-1"></span> ==== Pszeudokód: ==== <pre>AlphaBeta(node, depth, alpha, beta, maximizingPlayer): ha depth == 0 vagy node végállapot: térj vissza node értéke ha maximizingPlayer: maxEval = -végtelen minden child in node gyerekek: eval = AlphaBeta(child, depth - 1, alpha, beta, hamis) maxEval = max(maxEval, eval) alpha = max(alpha, eval) ha beta &lt;= alpha: törés térj vissza maxEval különben: minEval = +végtelen minden child in node gyerekek: eval = AlphaBeta(child, depth - 1, alpha, beta, igaz) minEval = min(minEval, eval) beta = min(beta, eval) ha beta &lt;= alpha: törés térj vissza minEval</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === * '''Előnyök''': ** Optimális, ha a játékfa teljesen kiértékelhető. ** Alfa-béta metszéssel jelentős sebességnövekedés érhető el. * '''Hátrányok''': ** Nagy játékfák esetén túl lassú lehet, különösen mély fák esetén. ** A kiértékelő függvény minősége nagyban befolyásolja az eredményeket. A '''Minimax algoritmus''' kiváló alapot nyújt mesterséges intelligenciák fejlesztéséhez, különösen játékokban, ahol a stratégia optimalizálása kulcsfontosságú. *{{en}}: {{t+|en|minimax algorithm}} *{{de}}: {{t|de|Minimax-Algorithmus}} {{hunl}} ivi29x8pbdxceednd549cloh1bggv8e 0 471601 3479462 2808644 2024-12-12T20:52:13Z LinguisticMystic 22848 3479462 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|gráfelmélet|algo}} A '''Kruskal-algoritmus''' egy súlyozott gráfokat feldolgozó [[mohó algoritmus]]. Ha a gráf [[összefüggő gráf|összefüggő]], akkor [[minimális feszítőfa]] megalkotására szolgál, ha nem, akkor minimális feszítőerdőt hoz létre. Lépések: #* Válasszuk ki a legkisebb súlyú élt. #* Amennyiben az él a részgráfhoz való hozzáadása kört alkot, dobjuk azt el. #* Ha van még nem vizsgált él, folytassuk az előző lépésekkel. {{-ford-}} {{trans-top}} * {{en}}: {{t|en|Kruskal's algorithm}} {{trans-bottom}} {{hunl}} 73i8n85nzw7hcpswbkfucmd7uqnyhrx 3479467 3479462 2024-12-12T20:58:35Z LinguisticMystic 22848 3479467 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|gráfelmélet|algo}} A '''Kruskal-algoritmus''' egy súlyozott gráfokat feldolgozó [[mohó algoritmus]]. Ha a gráf [[összefüggő gráf|összefüggő]], akkor [[minimális feszítőfa]] megalkotására szolgál, ha nem, akkor minimális feszítőerdőt hoz létre. ---- A '''Kruskal-algoritmus''' egy gráfelméleti algoritmus, amely minimális feszítőfát ('''MST - Minimum Spanning Tree''') határoz meg egy súlyozott, összefüggő gráfban. Az algoritmus a '''greedy''' (kapzsi) megközelítést alkalmazza, azaz mindig a pillanatnyilag legkisebb súlyú élt választja ki, amíg a feszítőfa létre nem jön. ----- <span id="algoritmus-működése"></span> === '''Algoritmus működése''' === # '''Élek rendezése''': #* Rendezzük az összes élt súly szerint növekvő sorrendbe. # '''Feszítőfa építése''': #* Vegyük az éleket egyenként (súly szerint növekvő sorrendben). #* Egy él csak akkor kerülhet be a feszítőfába, ha nem hoz létre kört. #* Ezt a '''disjunkt halmaz''' (union-find) adatszerkezettel valósítjuk meg, amely hatékonyan kezeli a körök ellenőrzését. # '''Ismétlés''': #* Addig ismételjük a folyamatot, amíg a feszítőfának (V - 1) éle lesz ((V) a csúcsok száma). ----- <span id="tulajdonságok"></span> === '''Tulajdonságok''' === * '''Időkomplexitás''': ** Az élek rendezése: (O(E E)), ahol (E) az élek száma. ** A disjunkt halmaz műveletek: (O(E (V))), ahol ((V)) az inverse Ackermann-függvény. ** Összességében: (O(E E)). * '''Gráf típusa''': ** Alkalmazható irányítatlan, összefüggő, súlyozott gráfokon. * '''Optimális''': ** A feszítőfa minimális összsúlyát garantálja. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>Kruskal(G): MST = üres halmaz Rendezzük az éleket súly szerint növekvő sorrendbe Inicializáljuk a disjunkt halmazokat ciklus minden él (u, v, w) esetén, súly szerint növekvő sorrendben: ha u és v nem ugyanabban a komponensben vannak: adjuk hozzá (u, v, w)-t az MST-hez egyesítsük u és v komponenseit visszatér MST</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">class Graph: def __init__(self, vertices): self.V = vertices self.edges = [] # Élek (forrás, cél, súly) def add_edge(self, u, v, w): self.edges.append((w, u, v)) def find(self, parent, i): if parent[i] == i: return i return self.find(parent, parent[i]) def union(self, parent, rank, x, y): xroot = self.find(parent, x) yroot = self.find(parent, y) if rank[xroot] < rank[yroot]: parent[xroot] = yroot elif rank[xroot] > rank[yroot]: parent[yroot] = xroot else: parent[yroot] = xroot rank[xroot] += 1 def kruskal(self): # Élek rendezése súly szerint self.edges.sort() parent = [] rank = [] mst = [] for node in range(self.V): parent.append(node) rank.append(0) for edge in self.edges: w, u, v = edge if self.find(parent, u) != self.find(parent, v): mst.append((u, v, w)) self.union(parent, rank, u, v) return mst # Példa gráf g = Graph(4) g.add_edge(0, 1, 10) g.add_edge(0, 2, 6) g.add_edge(0, 3, 5) g.add_edge(1, 3, 15) g.add_edge(2, 3, 4) mst = g.kruskal() print("Minimális feszítőfa élei:") for u, v, w in mst: print(f"{u} -- {v} == {w}")</syntaxhighlight> '''Kimenet:''' <pre>Minimális feszítőfa élei: 2 -- 3 == 4 0 -- 3 == 5 0 -- 1 == 10</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <algorithm> using namespace std; struct Edge { int src, dest, weight; }; struct Graph { int V, E; vector<Edge> edges; }; struct Subset { int parent; int rank; }; int find(Subset subsets[], int i) { if (subsets[i].parent != i) subsets[i].parent = find(subsets, subsets[i].parent); return subsets[i].parent; } void unionSets(Subset subsets[], int x, int y) { int xroot = find(subsets, x); int yroot = find(subsets, y); if (subsets[xroot].rank < subsets[yroot].rank) { subsets[xroot].parent = yroot; } else if (subsets[xroot].rank > subsets[yroot].rank) { subsets[yroot].parent = xroot; } else { subsets[yroot].parent = xroot; subsets[xroot].rank++; } } void kruskal(Graph& graph) { vector<Edge> result; sort(graph.edges.begin(), graph.edges.end(), [](Edge a, Edge b) { return a.weight < b.weight; }); Subset* subsets = new Subset[graph.V]; for (int v = 0; v < graph.V; ++v) { subsets[v].parent = v; subsets[v].rank = 0; } for (Edge edge : graph.edges) { int x = find(subsets, edge.src); int y = find(subsets, edge.dest); if (x != y) { result.push_back(edge); unionSets(subsets, x, y); } } cout << "Minimális feszítőfa élei:\n"; for (Edge e : result) { cout << e.src << " -- " << e.dest << " == " << e.weight << endl; } delete[] subsets; } int main() { Graph g{4, 5}; g.edges.push_back({0, 1, 10}); g.edges.push_back({0, 2, 6}); g.edges.push_back({0, 3, 5}); g.edges.push_back({1, 3, 15}); g.edges.push_back({2, 3, 4}); kruskal(g); return 0; }</syntaxhighlight> '''Kimenet:''' <pre>Minimális feszítőfa élei: 2 -- 3 == 4 0 -- 3 == 5 0 -- 1 == 10</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === A '''Kruskal-algoritmus''' hatékony és könnyen érthető módja a minimális feszítőfa meghatározásának, különösen ritka gráfokon. A disjunkt halmaz adatszerkezet hatékony megvalósítása révén az algoritmus gyorsan működik nagy gráfokon is. A Kruskal-algoritmus különösen hasznos, ha az élek listáját könnyen kezelhetjük, például fájlokból vagy adathalmazokból olvasva. {{-ford-}} {{trans-top}} * {{en}}: {{t|en|Kruskal's algorithm}} {{trans-bottom}} {{hunl}} kummg5tkdef4sxyyimqpjnhhsu7b2tx 0 471618 3479389 2809122 2024-12-12T13:39:00Z LinguisticMystic 22848 3479389 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika|gráf}} Az **illeszkedési mátrix** (incidenciamátrix) egy gráf matematikai reprezentációja, amely azt mutatja meg, hogy a gráf csúcsai és élei hogyan kapcsolódnak egymáshoz. === Definíció === Legyen adott egy **G(V, E)** gráf, ahol <math>V</math> a csúcsok halmaza, és <math>E</math> az élek halmaza. Az illeszkedési mátrix egy <math>|V| \times |E|</math>-es méretű mátrix, amelyet <math>B</math>-vel jelölünk, és amelyben: <math> B[i][j] = \begin{cases} 1, & \text{ha az \( i \)-edik csúcs és a \( j \)-edik él között kapcsolat van}, \\ 0, & \text{ha az \( i \)-edik csúcs és a \( j \)-edik él között nincs kapcsolat}. \end{cases} </math> === Példa === Tegyük fel, hogy egy egyszerű gráf: * Csúcsok: <math>V = \{v_1, v_2, v_3\}</math>, * Élek: <math>E = \{e_1, e_2, e_3\}</math>, ahol ** <math>e_1</math> köti össze <math>v_1</math>-et és <math>v_2</math>-t, ** <math>e_2</math> köti össze <math>v_2</math>-t és <math>v_3</math>-at, ** <math>e_3</math> köti össze <math>v_1</math>-et és <math>v_3</math>-at. Az illeszkedési mátrix: <math> B = \begin{bmatrix} 1 & 0 & 1 \\ 1 & 1 & 0 \\ 0 & 1 & 1 \end{bmatrix} </math> === Irányított gráfok esetén === Irányított gráfoknál az illeszkedési mátrix figyelembe veszi az él irányát is: <math> B[i][j] = \begin{cases} 1, & \text{ha az \( i \)-edik csúcs a \( j \)-edik él kezdőcsúcsa}, \\ -1, & \text{ha az \( i \)-edik csúcs a \( j \)-edik él végcsúcsa}, \\ 0, & \text{ha az \( i \)-edik csúcs nem kapcsolódik a \( j \)-edik élhez}. \end{cases} </math> Példa: * <math>e_1</math>: <math>v_1 \to v_2</math>, * <math>e_2</math>: <math>v_2 \to v_3</math>, * <math>e_3</math>: <math>v_3 \to v_1</math>. Az irányított illeszkedési mátrix: <math> B = \begin{bmatrix} 1 & 0 & -1 \\ -1 & 1 & 0 \\ 0 & -1 & 1 \end{bmatrix} </math> === Tulajdonságok === # Az illeszkedési mátrix sorai a gráf csúcsait, az oszlopai pedig az éleket reprezentálják. # Az egyszerű gráfok illeszkedési mátrixában minden oszlopban pontosan két darab 1-es van (az él két végpontja miatt). # Irányított gráf esetén minden oszlopban egy <math>1</math> és egy <math>-1</math> található. {{Ford}} *{{en}}: {{t|en|incidence matrix}} *{{de}}: {{t|de|Inzidenzmatrix}} {{hunl}} l3y7c8aov2nvtfplbbwgwsymkwmlj3y 3479390 3479389 2024-12-12T13:40:09Z LinguisticMystic 22848 3479390 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika|gráf}} Az **illeszkedési mátrix** (incidenciamátrix) egy gráf matematikai reprezentációja, amely azt mutatja meg, hogy a gráf csúcsai és élei hogyan kapcsolódnak egymáshoz. === Definíció === Legyen adott egy **G(V, E)** gráf, ahol <math>V</math> a csúcsok halmaza, és <math>E</math> az élek halmaza. Az illeszkedési mátrix egy <math>|V| \times |E|</math>-es méretű mátrix, amelyet <math>B</math>-vel jelölünk, és amelyben: <math> B[i][j] = \begin{cases} 1, & \text{ha az i -edik csúcs és a j -edik él között kapcsolat van}, \\ 0, & \text{ha az i -edik csúcs és a j -edik él között nincs kapcsolat}. \end{cases} </math> === Példa === Tegyük fel, hogy egy egyszerű gráf: * Csúcsok: <math>V = \{v_1, v_2, v_3\}</math>, * Élek: <math>E = \{e_1, e_2, e_3\}</math>, ahol ** <math>e_1</math> köti össze <math>v_1</math>-et és <math>v_2</math>-t, ** <math>e_2</math> köti össze <math>v_2</math>-t és <math>v_3</math>-at, ** <math>e_3</math> köti össze <math>v_1</math>-et és <math>v_3</math>-at. Az illeszkedési mátrix: <math> B = \begin{bmatrix} 1 & 0 & 1 \\ 1 & 1 & 0 \\ 0 & 1 & 1 \end{bmatrix} </math> === Irányított gráfok esetén === Irányított gráfoknál az illeszkedési mátrix figyelembe veszi az él irányát is: <math> B[i][j] = \begin{cases} 1, & \text{ha az i -edik csúcs a j -edik él kezdőcsúcsa}, \\ -1, & \text{ha az i -edik csúcs a j -edik él végcsúcsa}, \\ 0, & \text{ha az i -edik csúcs nem kapcsolódik a j -edik élhez}. \end{cases} </math> Példa: * <math>e_1</math>: <math>v_1 \to v_2</math>, * <math>e_2</math>: <math>v_2 \to v_3</math>, * <math>e_3</math>: <math>v_3 \to v_1</math>. Az irányított illeszkedési mátrix: <math> B = \begin{bmatrix} 1 & 0 & -1 \\ -1 & 1 & 0 \\ 0 & -1 & 1 \end{bmatrix} </math> === Tulajdonságok === # Az illeszkedési mátrix sorai a gráf csúcsait, az oszlopai pedig az éleket reprezentálják. # Az egyszerű gráfok illeszkedési mátrixában minden oszlopban pontosan két darab 1-es van (az él két végpontja miatt). # Irányított gráf esetén minden oszlopban egy <math>1</math> és egy <math>-1</math> található. {{Ford}} *{{en}}: {{t|en|incidence matrix}} *{{de}}: {{t|de|Inzidenzmatrix}} {{hunl}} 0rclllgeswetuclj4tabiai1j0ps6kl 0 471625 3479445 2809157 2024-12-12T20:28:43Z LinguisticMystic 22848 3479445 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|gráfelmélet|algo}} A Borůvka-algoritmus egy mohó algoritmus mely alkalmas egy [[minimális feszítőfa]] megkeresésére egy olyan gráfban, amelyben az összes él különbözik, vagy egy minimális feszítőerdő megtalálására olyan gráf esetén, amely nem kapcsolódik. ---- A '''Borůvka-algoritmus''' (más néven Borůvka-féle algoritmus) egy hatékony módszer, amely minimális feszítőfát ('''MST - Minimum Spanning Tree''') épít egy súlyozott, összefüggő gráfban. Ez az algoritmus iteratív módon működik, és az összes csúcsot egy-egy komponensként kezeli, majd minden iterációban a legkisebb súlyú éleket adja hozzá, amelyek különböző komponenseket kötnek össze. ----- <span id="alapötlet"></span> === '''Alapötlet''' === Az algoritmus a következő módon működik: 1. '''Kezdetben''' minden csúcs külön komponens. 2. '''Iteratívan''': - Minden komponens kiválasztja a legkisebb súlyú élt, amely egy másik komponenshez vezet. - Ezek az élek hozzáadódnak a minimális feszítőfához. - Az összekapcsolt komponensek egyesülnek. 3. '''Végül''': Az algoritmus addig folytatódik, amíg csak egyetlen komponens marad, amely a teljes gráfot lefedi. ----- <span id="tulajdonságok"></span> === '''Tulajdonságok''' === * '''Időkomplexitás''': (O(E V)), ahol (E) az élek száma és (V) a csúcsok száma. * '''Hatékonyság''': Könnyen párhuzamosítható, mivel minden komponens önállóan választja ki a legkisebb élt. * '''Súlyozott, összefüggő gráfokra alkalmazható'''. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>Boruvka(G): Inicializáld a komponenst minden csúcsra (kezdetben önálló csúcsok) MST = üres halmaz amíg a komponensek száma &gt; 1: minden komponens esetén: keressük meg a legkisebb súlyú élt, amely egy másik komponenshez vezet adjuk hozzá az összes kiválasztott élt az MST-hez egyesítsük azokat a komponenseket, amelyeket az új élek összekötöttek visszatér MST</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">from collections import defaultdict class Graph: def __init__(self, vertices): self.V = vertices # Csúcsok száma self.edges = [] # Gráf élei (forrás, cél, súly) def add_edge(self, u, v, w): self.edges.append((u, v, w)) def find_component(self, parent, i): if parent[i] == i: return i return self.find_component(parent, parent[i]) def union(self, parent, rank, x, y): xroot = self.find_component(parent, x) yroot = self.find_component(parent, y) if rank[xroot] < rank[yroot]: parent[xroot] = yroot elif rank[xroot] > rank[yroot]: parent[yroot] = xroot else: parent[yroot] = xroot rank[xroot] += 1 def boruvka(self): parent = [] rank = [] mst_weight = 0 mst_edges = [] for node in range(self.V): parent.append(node) rank.append(0) num_components = self.V while num_components > 1: cheapest = [-1] * self.V for u, v, w in self.edges: uroot = self.find_component(parent, u) vroot = self.find_component(parent, v) if uroot != vroot: if cheapest[uroot] == -1 or cheapest[uroot][2] > w: cheapest[uroot] = (u, v, w) if cheapest[vroot] == -1 or cheapest[vroot][2] > w: cheapest[vroot] = (u, v, w) for node in range(self.V): if cheapest[node] != -1: u, v, w = cheapest[node] uroot = self.find_component(parent, u) vroot = self.find_component(parent, v) if uroot != vroot: self.union(parent, rank, uroot, vroot) mst_weight += w mst_edges.append((u, v, w)) num_components -= 1 return mst_weight, mst_edges # Példa gráf g = Graph(4) g.add_edge(0, 1, 10) g.add_edge(0, 2, 6) g.add_edge(0, 3, 5) g.add_edge(1, 3, 15) g.add_edge(2, 3, 4) mst_weight, mst_edges = g.boruvka() print("Minimális feszítőfa súlya:", mst_weight) print("MST élei:", mst_edges)</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <tuple> #include <limits> using namespace std; struct Edge { int src, dest, weight; }; struct Graph { int V, E; vector<Edge> edges; Graph(int V, int E) : V(V), E(E) {} void addEdge(int src, int dest, int weight) { edges.push_back({src, dest, weight}); } int find(int parent[], int i) { if (parent[i] == i) return i; return find(parent, parent[i]); } void unionSets(int parent[], int rank[], int x, int y) { int xroot = find(parent, x); int yroot = find(parent, y); if (rank[xroot] < rank[yroot]) { parent[xroot] = yroot; } else if (rank[xroot] > rank[yroot]) { parent[yroot] = xroot; } else { parent[yroot] = xroot; rank[xroot]++; } } void boruvka() { vector<Edge> mst; int parent[V], rank[V]; for (int i = 0; i < V; i++) { parent[i] = i; rank[i] = 0; } int numComponents = V, mstWeight = 0; while (numComponents > 1) { vector<Edge> cheapest(V, {-1, -1, numeric_limits<int>::max()}); for (auto& edge : edges) { int u = find(parent, edge.src); int v = find(parent, edge.dest); if (u != v) { if (edge.weight < cheapest[u].weight) cheapest[u] = edge; if (edge.weight < cheapest[v].weight) cheapest[v] = edge; } } for (int i = 0; i < V; i++) { if (cheapest[i].weight != numeric_limits<int>::max()) { int u = cheapest[i].src; int v = cheapest[i].dest; int setU = find(parent, u); int setV = find(parent, v); if (setU != setV) { mst.push_back(cheapest[i]); mstWeight += cheapest[i].weight; unionSets(parent, rank, setU, setV); numComponents--; } } } } cout << "Minimális feszítőfa súlya: " << mstWeight << endl; cout << "MST élei:" << endl; for (auto& edge : mst) { cout << edge.src << " - " << edge.dest << " (" << edge.weight << ")" << endl; } } }; int main() { Graph g(4, 5); g.addEdge(0, 1, 10); g.addEdge(0, 2, 6); g.addEdge(0, 3, 5); g.addEdge(1, 3, 15); g.addEdge(2, 3, 4); g.boruvka(); return 0; }</syntaxhighlight> ----- <span id="összegzés"></span> === '''Összegzés''' === A '''Borůvka-algoritmus''' hatékonyan alkalmazható minimális feszítőfák kialakítására, különösen párhuzamos számítási környezetekben. Bár más algoritmusok, például a Kruskal- és a Prim-algoritmus gyakrabban használtak, a Borůvka-algoritmus egyszerűsége miatt különösen hasznos nagy gráfokon. {{hunl}} ggu52x1rhbo0j85fcalvs9o899qfjvi 0 471629 3479451 2809151 2024-12-12T20:39:18Z LinguisticMystic 22848 3479451 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} {{-ford-}} {{trans-top}} * {{en}}: {{t|en|combsort}} * {{de}}: {{t|de|}} {{trans-bottom}} {{hunl}} 05c2dy3g11sdmx58b3k1yi8dw0f1sii 3479453 3479451 2024-12-12T20:41:49Z LinguisticMystic 22848 3479453 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} A '''fésűs rendezés''' egy hatékonyabb alternatíva a buborékrendezéshez. Az algoritmus alapja, hogy nemcsak egymás melletti elemeket hasonlít össze és cserél, hanem egy '''réstávolságot''' ('''gap''') használ, amely a nagyobb távolságra lévő elemeket is vizsgálja. A rés értéke minden iterációban csökken, végül elérve az 1-et, ekkor a rendezés buborékrendezésként folytatódik. ----- <span id="elmélet"></span> === '''Elmélet''' === <span id="működése"></span> ==== '''Működése''': ==== # '''Kezdő résméret''': #* A résméretet a lista hosszának ((n)) megfelelően állítjuk be. # '''Résméret csökkentése''': #* A résméretet egy meghatározott konstanssal (általában (1.3)) osztva csökkentjük. # '''Elemek összehasonlítása''': #* A listában az aktuális résméretnek megfelelő távolságban lévő elemeket összehasonlítjuk, és szükség esetén cseréljük őket. # '''Utolsó fázis''': #* Amikor a résméret (1)-re csökken, az algoritmus az utolsó iterációban buborékrendezésként viselkedik, hogy biztosítsa a rendezést. ----- <span id="tulajdonságok"></span> === '''Tulajdonságok''' === * '''Időkomplexitás''': ** Átlagos eset: (O(n n)). ** Legrosszabb eset: (O(n^2)) (ritka esetekben). * '''Térkomplexitás''': (O(1)), mivel helyben rendez. * '''Hatékonyság''': ** Általában gyorsabb, mint a buborékrendezés, mivel csökkenti a nagy távolságban lévő elemek hibáinak számát a korai fázisokban. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>CombSort(A): n = A hossza gap = n swapped = igaz amíg gap &gt; 1 vagy swapped: gap = max(1, int(gap / 1.3)) swapped = hamis ciklus i = 0-tól (n - gap - 1)-ig: ha A[i] &gt; A[i + gap]: cseréljük meg A[i] és A[i + gap] értékét swapped = igaz</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def comb_sort(arr): n = len(arr) gap = n shrink = 1.3 # Résméret csökkentésének aránya swapped = True while gap > 1 or swapped: gap = max(1, int(gap // shrink)) swapped = False for i in range(n - gap): if arr[i] > arr[i + gap]: arr[i], arr[i + gap] = arr[i + gap], arr[i] swapped = True # Példa data = [64, 34, 25, 12, 22, 11, 90] comb_sort(data) print("Rendezett tömb:", data) # Kimenet: Rendezett tömb: [11, 12, 22, 25, 34, 64, 90]</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> using namespace std; void combSort(vector<int>& arr) { int n = arr.size(); int gap = n; const double shrink = 1.3; // Résméret csökkentésének aránya bool swapped = true; while (gap > 1 || swapped) { gap = max(1, static_cast<int>(gap / shrink)); swapped = false; for (int i = 0; i < n - gap; ++i) { if (arr[i] > arr[i + gap]) { swap(arr[i], arr[i + gap]); swapped = true; } } } } int main() { vector<int> data = {64, 34, 25, 12, 22, 11, 90}; combSort(data); cout << "Rendezett tömb: "; for (int num : data) { cout << num << " "; } cout << endl; return 0; }</syntaxhighlight> ----- <span id="optimalizációk"></span> === '''Optimalizációk''' === # '''Résméret csökkentési aránya''': #* A (1.3) konstans optimálisnak bizonyult a legtöbb esetben. Más értékek lassabbá tehetik az algoritmust. # '''Korai kilépés''': #* Ha egy iteráció során nem történt csere, az algoritmus azonnal befejezheti a futást. ----- <span id="összegzés"></span> === '''Összegzés''' === A '''fésűs rendezés''' hatékonyabb, mint a buborékrendezés, különösen nagyobb adathalmazok esetén. Az algoritmus résméret-csökkentési megközelítése lehetővé teszi, hogy gyorsabban közelítse a végleges rendezett állapotot. Bár nem éri el a gyorsrendezés ((O(n n))) sebességét, egyszerűsége és helyben történő működése miatt egy hasznos algoritmus. {{-ford-}} {{trans-top}} * {{en}}: {{t|en|combsort}} {{trans-bottom}} {{hunl}} gx3nvk4yx027kj45mavb7c2dyz4yzea 0 471632 3479465 2809156 2024-12-12T20:55:54Z LinguisticMystic 22848 3479465 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika|algo}} <span id="koktélrendezés-cocktail-sort"></span> === '''Koktélrendezés (Cocktail Sort)''' === A '''koktélrendezés''' (más néven kétirányú buborékrendezés) a buborékrendezés módosított változata, amely mindkét irányban végzi a rendezést. Az algoritmus egyik irányban a legnagyobb elemet helyezi a megfelelő pozícióba, majd a másik irányban a legkisebb elemet mozgatja a megfelelő helyre. ----- <span id="elmélet"></span> === '''Elmélet''' === <span id="működése"></span> ==== '''Működése''': ==== # '''Balról jobbra haladás''': #* Hasonlítsuk össze az egymást követő elemeket, és cseréljük meg őket, ha nincsenek helyes sorrendben. #* A legnagyobb elem az iteráció végén a helyére kerül. # '''Jobbról balra haladás''': #* Hasonlítsuk össze az egymást követő elemeket, és cseréljük meg őket, ha nincsenek helyes sorrendben. #* A legkisebb elem az iteráció végén a helyére kerül. # '''Ismétlés''': #* Addig ismételjük a fenti két lépést, amíg a tömb rendezett nem lesz. ----- <span id="tulajdonságok"></span> === '''Tulajdonságok''' === * '''Időkomplexitás''': ** Átlagos és legrosszabb eset: (O(n^2)). ** Legjobb eset: (O(n)), ha a tömb már rendezett. * '''Térkomplexitás''': (O(1)), mert helyben működik. * '''Stabilitás''': Stabil, mivel nem változtatja meg az azonos értékű elemek sorrendjét. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>CocktailSort(A): n = A hossza swapped = igaz bal = 0 jobb = n - 1 amíg swapped: swapped = hamis // Balról jobbra haladás ciklus i = bal-tól jobb-1-ig: ha A[i] &gt; A[i + 1]: cseréljük meg A[i] és A[i + 1] értékét swapped = igaz jobb = jobb - 1 // Jobbról balra haladás ciklus i = jobb-tól bal-ig hátrafelé: ha A[i] &gt; A[i + 1]: cseréljük meg A[i] és A[i + 1] értékét swapped = igaz bal = bal + 1</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def cocktail_sort(arr): n = len(arr) swapped = True start = 0 end = n - 1 while swapped: swapped = False # Balról jobbra haladás for i in range(start, end): if arr[i] > arr[i + 1]: arr[i], arr[i + 1] = arr[i + 1], arr[i] swapped = True end -= 1 # Ha nem történt csere, a tömb rendezett if not swapped: break swapped = False # Jobbról balra haladás for i in range(end, start, -1): if arr[i - 1] > arr[i]: arr[i], arr[i - 1] = arr[i - 1], arr[i] swapped = True start += 1 # Példa data = [5, 1, 4, 2, 8, 0, 2] cocktail_sort(data) print("Rendezett tömb:", data) # Kimenet: Rendezett tömb: [0, 1, 2, 2, 4, 5, 8]</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> using namespace std; void cocktailSort(vector<int>& arr) { bool swapped = true; int start = 0, end = arr.size() - 1; while (swapped) { swapped = false; // Balról jobbra haladás for (int i = start; i < end; ++i) { if (arr[i] > arr[i + 1]) { swap(arr[i], arr[i + 1]); swapped = true; } } --end; // Ha nem történt csere, a tömb rendezett if (!swapped) break; swapped = false; // Jobbról balra haladás for (int i = end - 1; i >= start; --i) { if (arr[i] > arr[i + 1]) { swap(arr[i], arr[i + 1]); swapped = true; } } ++start; } } int main() { vector<int> data = {5, 1, 4, 2, 8, 0, 2}; cocktailSort(data); cout << "Rendezett tömb: "; for (int num : data) { cout << num << " "; } cout << endl; return 0; }</syntaxhighlight> ----- <span id="optimalizációk"></span> === '''Optimalizációk''' === # '''Korai kilépés''': #* Ha egy iteráció során nem történt csere, az algoritmus azonnal befejezheti a futást. # '''Hatékonyság kis tömbökön''': #* Kis méretű tömbökön a koktélrendezés hatékony lehet, de nagyobb adathalmazok esetén jobb alternatívák léteznek, például gyorsrendezés vagy egyesítős rendezés. ----- <span id="összegzés"></span> === '''Összegzés''' === A '''koktélrendezés''' javítja a hagyományos buborékrendezés teljesítményét azáltal, hogy mindkét irányban rendez. Bár továbbra is (O(n^2)) időkomplexitású, gyakran hatékonyabb, különösen akkor, ha az elemek nagy része már rendezett. Az algoritmus stabil és egyszerűen implementálható, ezért jó választás oktatási célokra vagy kisebb adathalmazok rendezésére. {{-ford-}} {{trans-top}} * {{en}}: {{t|en|cocktail sort}} {{trans-bottom}} {{hunl}} hvh7yiuvsxjzjk6pmba5r0unba96f90 3479466 3479465 2024-12-12T20:56:29Z LinguisticMystic 22848 3479466 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika|algo}} A '''koktélrendezés''' (más néven kétirányú buborékrendezés) a buborékrendezés módosított változata, amely mindkét irányban végzi a rendezést. Az algoritmus egyik irányban a legnagyobb elemet helyezi a megfelelő pozícióba, majd a másik irányban a legkisebb elemet mozgatja a megfelelő helyre. ----- <span id="elmélet"></span> === '''Elmélet''' === <span id="működése"></span> ==== '''Működése''': ==== # '''Balról jobbra haladás''': #* Hasonlítsuk össze az egymást követő elemeket, és cseréljük meg őket, ha nincsenek helyes sorrendben. #* A legnagyobb elem az iteráció végén a helyére kerül. # '''Jobbról balra haladás''': #* Hasonlítsuk össze az egymást követő elemeket, és cseréljük meg őket, ha nincsenek helyes sorrendben. #* A legkisebb elem az iteráció végén a helyére kerül. # '''Ismétlés''': #* Addig ismételjük a fenti két lépést, amíg a tömb rendezett nem lesz. ----- <span id="tulajdonságok"></span> === '''Tulajdonságok''' === * '''Időkomplexitás''': ** Átlagos és legrosszabb eset: (O(n^2)). ** Legjobb eset: (O(n)), ha a tömb már rendezett. * '''Térkomplexitás''': (O(1)), mert helyben működik. * '''Stabilitás''': Stabil, mivel nem változtatja meg az azonos értékű elemek sorrendjét. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>CocktailSort(A): n = A hossza swapped = igaz bal = 0 jobb = n - 1 amíg swapped: swapped = hamis // Balról jobbra haladás ciklus i = bal-tól jobb-1-ig: ha A[i] &gt; A[i + 1]: cseréljük meg A[i] és A[i + 1] értékét swapped = igaz jobb = jobb - 1 // Jobbról balra haladás ciklus i = jobb-tól bal-ig hátrafelé: ha A[i] &gt; A[i + 1]: cseréljük meg A[i] és A[i + 1] értékét swapped = igaz bal = bal + 1</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def cocktail_sort(arr): n = len(arr) swapped = True start = 0 end = n - 1 while swapped: swapped = False # Balról jobbra haladás for i in range(start, end): if arr[i] > arr[i + 1]: arr[i], arr[i + 1] = arr[i + 1], arr[i] swapped = True end -= 1 # Ha nem történt csere, a tömb rendezett if not swapped: break swapped = False # Jobbról balra haladás for i in range(end, start, -1): if arr[i - 1] > arr[i]: arr[i], arr[i - 1] = arr[i - 1], arr[i] swapped = True start += 1 # Példa data = [5, 1, 4, 2, 8, 0, 2] cocktail_sort(data) print("Rendezett tömb:", data) # Kimenet: Rendezett tömb: [0, 1, 2, 2, 4, 5, 8]</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> using namespace std; void cocktailSort(vector<int>& arr) { bool swapped = true; int start = 0, end = arr.size() - 1; while (swapped) { swapped = false; // Balról jobbra haladás for (int i = start; i < end; ++i) { if (arr[i] > arr[i + 1]) { swap(arr[i], arr[i + 1]); swapped = true; } } --end; // Ha nem történt csere, a tömb rendezett if (!swapped) break; swapped = false; // Jobbról balra haladás for (int i = end - 1; i >= start; --i) { if (arr[i] > arr[i + 1]) { swap(arr[i], arr[i + 1]); swapped = true; } } ++start; } } int main() { vector<int> data = {5, 1, 4, 2, 8, 0, 2}; cocktailSort(data); cout << "Rendezett tömb: "; for (int num : data) { cout << num << " "; } cout << endl; return 0; }</syntaxhighlight> ----- <span id="optimalizációk"></span> === '''Optimalizációk''' === # '''Korai kilépés''': #* Ha egy iteráció során nem történt csere, az algoritmus azonnal befejezheti a futást. # '''Hatékonyság kis tömbökön''': #* Kis méretű tömbökön a koktélrendezés hatékony lehet, de nagyobb adathalmazok esetén jobb alternatívák léteznek, például gyorsrendezés vagy egyesítős rendezés. ----- <span id="összegzés"></span> === '''Összegzés''' === A '''koktélrendezés''' javítja a hagyományos buborékrendezés teljesítményét azáltal, hogy mindkét irányban rendez. Bár továbbra is (O(n^2)) időkomplexitású, gyakran hatékonyabb, különösen akkor, ha az elemek nagy része már rendezett. Az algoritmus stabil és egyszerűen implementálható, ezért jó választás oktatási célokra vagy kisebb adathalmazok rendezésére. {{-ford-}} {{trans-top}} * {{en}}: {{t|en|cocktail sort}} {{trans-bottom}} {{hunl}} jt8kptea87qk96dmqt4i1o0wa4j8opx 0 471634 3479448 2809170 2024-12-12T20:35:39Z LinguisticMystic 22848 3479448 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|gráfelmélet|algo}} Az Edmonds-algoritmus a minimális feszítő fenyő megtalálására szolgál (ezt néha optimális elágazásnak nevezik). A feszítő fenyő olyan irányított fa, amelyben van egy speciális, gyökérnek nevezett pont, amelyből minden pontba vezet irányított út. Ez a minimális feszítőfa probléma irányított analógja. ---- Az '''Edmonds-algoritmus''' (más néven Edmonds-féle maximális párosítás algoritmus) egy hatékony módszer, amely '''általános gráfokban''' meghatározza a maximális párosítást. Az algoritmus működik irányítatlan gráfokon, és különösen hasznos, ha az élek tartalmazhatnak páratlan köröket (ún. “blossom” - virág alakzatokat). ----- <span id="probléma-megfogalmazása"></span> === '''Probléma megfogalmazása''' === Egy irányítatlan gráfban a '''párosítás''' olyan élek halmaza, amelyek között nincs közös csúcs. A '''maximális párosítás''' a legtöbb élt tartalmazó ilyen halmaz. <span id="kulcsfogalmak"></span> ==== '''Kulcsfogalmak''': ==== * '''Alap (augmentáló) út''': Olyan út, amely a párosítatlan csúcsból indul, és alternáló módon halad párosított és párosítatlan élek mentén. * '''Blossom (virág)''': Egy párosítatlan csúcsokat tartalmazó páratlan kör, amelyet kezelni kell az algoritmus során. ----- <span id="algoritmus-alapelvei"></span> === '''Algoritmus alapelvei''' === # '''Indulás''': #* Kezdjük egy üres párosítással. #* Használjunk BFS-t vagy DFS-t az alaputak keresésére. # '''Blossom felismerése és összehúzása''': #* Ha egy páratlan kört (blossom) találunk, azt összehúzzuk egyetlen csúccsá, így az alapút könnyebben kezelhető. # '''Augmentáló út meghosszabbítása''': #* Az alapúttal növeljük a párosítást, ha találunk ilyet. # '''Ismétlés''': #* Addig folytatjuk az augmentáló utak keresését és használatát, amíg nem találunk többet. ----- <span id="tulajdonságok"></span> === '''Tulajdonságok''' === * '''Időkomplexitás''': (O(V^3)), ahol (V) a csúcsok száma. * '''Párosítás maximális méretének garantálása'''. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>EdmondsMaximumMatching(G): P = üres párosítás amíg található alapút: ha találunk augmentáló utat: növeljük meg a párosítást ha találunk blossomt: húzzuk össze és folytassuk az algoritmust visszatér P</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === Ez a kód egy általános megközelítést alkalmaz Edmonds-algoritmushoz, de egyszerűsített formában mutatja be az augmentációs lépéseket. <syntaxhighlight lang="python">from collections import deque def find_augmenting_path(graph, match, dist): for u in graph: dist[u] = -1 queue = deque() for u in graph: if match[u] is None: dist[u] = 0 queue.append(u) while queue: u = queue.popleft() for v in graph[u]: matched_to = match[v] if matched_to is None: return True if dist[matched_to] == -1: dist[matched_to] = dist[u] + 1 queue.append(matched_to) return False def dfs(graph, u, match, dist): for v in graph[u]: matched_to = match[v] if matched_to is None or (dist[matched_to] == dist[u] + 1 and dfs(graph, matched_to, match, dist)): match[u] = v match[v] = u return True dist[u] = -1 return False def edmonds_maximum_matching(graph): match = {u: None for u in graph} dist = {} matching_size = 0 while find_augmenting_path(graph, match, dist): for u in graph: if match[u] is None and dfs(graph, u, match, dist): matching_size += 1 return matching_size, match # Példa gráf graph = { 0: [1, 2], 1: [0, 3], 2: [0, 3], 3: [1, 2] } matching_size, match = edmonds_maximum_matching(graph) print("Maximális párosítás mérete:", matching_size) print("Párosítás:", match)</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === Az alábbi kód egy egyszerűbb formában valósítja meg az Edmonds-algoritmust. <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <queue> #include <algorithm> using namespace std; const int INF = 1e9; bool bfs(const vector<vector<int>>& graph, vector<int>& match, vector<int>& dist) { queue<int> q; int n = graph.size(); for (int i = 0; i < n; i++) { if (match[i] == -1) { dist[i] = 0; q.push(i); } else { dist[i] = INF; } } bool found_augmenting_path = false; while (!q.empty()) { int u = q.front(); q.pop(); for (int v : graph[u]) { int matched_to = match[v]; if (matched_to == -1) { found_augmenting_path = true; } else if (dist[matched_to] == INF) { dist[matched_to] = dist[u] + 1; q.push(matched_to); } } } return found_augmenting_path; } bool dfs(int u, const vector<vector<int>>& graph, vector<int>& match, vector<int>& dist) { for (int v : graph[u]) { int matched_to = match[v]; if (matched_to == -1 || (dist[matched_to] == dist[u] + 1 && dfs(matched_to, graph, match, dist))) { match[u] = v; match[v] = u; return true; } } dist[u] = INF; return false; } int edmonds_maximum_matching(const vector<vector<int>>& graph) { int n = graph.size(); vector<int> match(n, -1), dist(n); int matching_size = 0; while (bfs(graph, match, dist)) { for (int i = 0; i < n; i++) { if (match[i] == -1 && dfs(i, graph, match, dist)) { matching_size++; } } } return matching_size; } int main() { vector<vector<int>> graph = { {1, 2}, {0, 3}, {0, 3}, {1, 2} }; cout << "Maximális párosítás mérete: " << edmonds_maximum_matching(graph) << endl; return 0; }</syntaxhighlight> ----- <span id="összegzés"></span> === '''Összegzés''' === Az '''Edmonds-algoritmus''' hatékonyan kezeli a párosítási problémát általános gráfokon, beleértve a páratlan köröket is. Bár az algoritmus bonyolultabb, mint más egyszerűbb módszerek (pl. Greedy algoritmus), garantáltan megtalálja a maximális párosítást, így fontos eszköz a hálózatkutatásban és kombinatorikai optimalizálási feladatokban. 7rx9i56ntfd6jlxvp7jlowq5cpycbki 0 471667 3479541 2809370 2024-12-12T22:48:35Z LinguisticMystic 22848 3479541 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo|numtheory}} Prímteszten a matematikában vagy informatikában olyan (determinisztikus) algoritmust vagy indeterminisztikus (például valószínűség-elméleti) módszereket is megengedő eljárást értünk, melynek ismeretében bármely adott egész számról, vagy csak bizonyos típusú számokról (véges sok lépésben) el tudjuk dönteni, hogy prímszám-e, vagy pedig összetett. Ettől lényegesen különböző és sokkal nehezebb feladat egy adott szám prímtényezőinek a megtalálása (prímfelbontás). {{-ford-}} {{trans-top}} * {{en}}: {{t|en|primality test}} {{trans-bottom}} {{hunl}} puoo6utxj837yhxwl22znz8x02aazxs 3479591 3479541 2024-12-12T23:56:18Z LinguisticMystic 22848 3479591 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo|numtheory}} Prímteszten a matematikában vagy informatikában olyan (determinisztikus) algoritmust vagy indeterminisztikus (például valószínűség-elméleti) módszereket is megengedő eljárást értünk, melynek ismeretében bármely adott egész számról, vagy csak bizonyos típusú számokról (véges sok lépésben) el tudjuk dönteni, hogy prímszám-e, vagy pedig összetett. Ettől lényegesen különböző és sokkal nehezebb feladat egy adott szám prímtényezőinek a megtalálása (prímfelbontás). ---- <span id="prímteszt"></span> === '''Prímteszt''' === A '''prímteszt''' algoritmusok célja annak eldöntése, hogy egy adott szám '''prímszám'''-e. Egy szám prím, ha nagyobb, mint (1), és csak (1) és önmaga osztói vannak. A prímtesztek számos típusúak lehetnek, a legegyszerűbb iteratív osztásos módszertől kezdve a bonyolultabb probabilisztikus és determinisztikus algoritmusokig. ----- <span id="algoritmusok"></span> === '''Algoritmusok''' === <span id="egyszerű-iteratív-osztásos-prímteszt"></span> ==== '''1. Egyszerű iteratív osztásos prímteszt''' ==== A legegyszerűbb módszer, amely egy szám oszthatóságát vizsgálja. '''Lépések''': 1. Ha a szám kisebb, mint 2, akkor nem prím. 2. Ellenőrizd, hogy osztható-e (2)-vel. 3. Ellenőrizd a (3)-tól ()-ig tartó számokkal való oszthatóságot. '''Időbonyolultság''': (O()) '''Python implementáció''': <syntaxhighlight lang="python">def is_prime_simple(n): if n <= 1: return False if n <= 3: return True if n % 2 == 0 or n % 3 == 0: return False i = 5 while i * i <= n: if n % i == 0 or n % (i + 2) == 0: return False i += 6 return True # Példa print(is_prime_simple(29)) # True print(is_prime_simple(30)) # False</syntaxhighlight> ----- <span id="eratoszthenész-szitája"></span> ==== '''2. Eratoszthenész szitája''' ==== Egy hatékony algoritmus az összes prím meghatározására (1) és egy adott (n) között. '''Lépések''': 1. Hozz létre egy logikai listát az (1)-től (n)-ig terjedő számokról. 2. Jelöld ki a (2)-t mint prím. 3. Szorzataik kizárásával (nem prímszámként megjelölésével) iteratívan haladj. '''Időbonyolultság''': (O(n n)) '''Python implementáció''': <syntaxhighlight lang="python">def sieve_of_eratosthenes(limit): primes = [True] * (limit + 1) primes[0] = primes[1] = False for i in range(2, int(limit ** 0.5) + 1): if primes[i]: for j in range(i * i, limit + 1, i): primes[j] = False return [i for i, is_prime in enumerate(primes) if is_prime] # Példa print(sieve_of_eratosthenes(30)) # [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]</syntaxhighlight> ----- <span id="miller-rabin-prímteszt"></span> ==== '''3. Miller-Rabin prímteszt''' ==== Egy probabilisztikus prímteszt, amely megvizsgálja, hogy egy szám valószínűleg prím-e. Nagy számok esetén hatékony. '''Lépések''': 1. Írd fel (n-1 = 2^r d) alakban ((d) páratlan). 2. Véletlenszerűen válassz egy (a)-t ((2 a n-2)). 3. Ellenőrizd, hogy (a^d n = 1), vagy ((a^{2j d} n = n-1)) valamelyik (0 j &lt; r)-re. 4. Ismételd meg a tesztet néhány különböző (a)-val. '''Időbonyolultság''': (O(k ^3 n)), ahol (k) az ismétlések száma. '''Python implementáció''': <syntaxhighlight lang="python">import random def miller_rabin(n, k=5): # k az ismétlések száma if n <= 1: return False if n <= 3: return True if n % 2 == 0: return False # Írjuk fel n-1 = 2^r * d alakban r, d = 0, n - 1 while d % 2 == 0: r += 1 d //= 2 for _ in range(k): a = random.randint(2, n - 2) x = pow(a, d, n) # a^d % n if x == 1 or x == n - 1: continue for _ in range(r - 1): x = pow(x, 2, n) if x == n - 1: break else: return False return True # Példa print(miller_rabin(29)) # True print(miller_rabin(30)) # False</syntaxhighlight> ----- <span id="aks-prímteszt"></span> ==== '''4. AKS prímteszt''' ==== Egy determinisztikus algoritmus, amely bizonyítja, hogy egy szám prím-e. Az AKS prímteszt polinomiális időben fut, de implementációja és futási ideje miatt ritkán használják. '''Időbonyolultság''': (O(^6 n)) ----- <span id="összehasonlítás"></span> === '''Összehasonlítás''' === {| class="wikitable" |- ! '''Algoritmus''' ! '''Időbonyolultság''' ! '''Előnyök''' ! '''Hátrányok''' |- | Iteratív osztásos teszt | (O()) | Egyszerű, könnyen érthető | Lassú nagy számoknál |- | Eratoszthenész szitája | (O(n n)) | Hatékony prímek generálására | Sok memóriát igényel nagy (n)-re |- | Miller-Rabin teszt | (O(k ^3 n)) | Gyors, nagy számokra alkalmas | Probabilisztikus |- | AKS prímteszt | (O(^6 n)) | Determinisztikus | Nehéz implementáció, lassú |} ----- <span id="példák"></span> === '''Példák''' === <span id="iteratív-teszt"></span> ==== Iteratív teszt: ==== <syntaxhighlight lang="python">print(is_prime_simple(97)) # True</syntaxhighlight> <span id="eratoszthenész-szitája-1"></span> ==== Eratoszthenész szitája: ==== <syntaxhighlight lang="python">print(sieve_of_eratosthenes(100)) # [2, 3, 5, 7, 11, 13, ..., 97]</syntaxhighlight> <span id="miller-rabin-teszt"></span> ==== Miller-Rabin teszt: ==== <syntaxhighlight lang="python">print(miller_rabin(561)) # False, mert 561 kompozit (Carmichael-szám)</syntaxhighlight> ----- <span id="összegzés"></span> === '''Összegzés''' === A választott prímteszt algoritmus a probléma méretétől és jellegétől függ: - '''Kisebb számok''': Iteratív osztásos teszt vagy Eratoszthenész szitája. - '''Nagy számok''': Miller-Rabin teszt. - '''Bizonyított prímekhez''': Determinisztikus algoritmusok, például AKS. Ezek az algoritmusok fontosak kriptográfiában, számelméletben és adatelemzésben. {{-ford-}} {{trans-top}} * {{en}}: {{t|en|primality test}} {{trans-bottom}} {{hunl}} is6dqxyslvh8bbclm5deaavabjma8ci 0 471736 3479422 2809525 2024-12-12T17:27:33Z LinguisticMystic 22848 3479422 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|gráf }} {{-ford-}} {{trans-top}} * {{en}}: {{t|en|connected graph}} {{trans-bottom}} {{hunl}} ctf1qnln5j0ms27uv146x9g09ln7oxv 3479428 3479422 2024-12-12T17:35:26Z LinguisticMystic 22848 3479428 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|gráf}} == Összefüggő gráf == Egy gráf akkor mondható '''összefüggőnek''', ha bármely két csúcsa között létezik legalább egy út. Az összefüggőség a gráfelmélet egyik alapvető tulajdonsága, amely különösen fontos számos matematikai és informatikai alkalmazásban. === Alapfogalmak === * '''Gráf''' (G): A gráf egy csúcsokból (V) és élekből (E) álló matematikai struktúra, ahol G = (V, E). * '''Út''': Egy gráfban az út csúcsok egy sorozata, amelyeket élek kötnek össze. * '''Összefüggő komponens''': Az összefüggő komponens egy olyan részgráf, amelyben bármely két csúcs között létezik út, és amely nem bővíthető újabb élekkel úgy, hogy az még összefüggő maradjon. === Példák összefüggő gráfokra === 1. '''Egyszerű lánc''': Egy gráf, amely csúcsokból áll, és mindegyik csúcsot pontosan egy él köt össze a következővel, például egy lineáris sorozat. 2. '''Körgráf''': Egy olyan gráf, amelynek csúcsai körben helyezkednek el, és mindegyik csúcsot két másik csúcs köt össze. 3. '''Teljes gráf (Kn)''': Egy n csúcsú gráf, amelyben minden csúcs össze van kötve az összes többi csúccsal. === Összefüggőség vizsgálata === Az összefüggőség megállapításához különböző algoritmusokat használhatunk. Néhány közülük: * '''Szélességi bejárás (BFS):''' Ezzel az algoritmussal megállapítható, hogy a gráf összes csúcsát el lehet-e érni egy adott kezdőcsúcsból. * '''Mélységi bejárás (DFS):''' Hasonlóan a BFS-hez, ez az algoritmus is felhasználható az összefüggőség vizsgálatára. Különösen hasznos az összefüggő komponensek meghatározására. * '''Diszjunkt halmazok módszere''': Ez a módszer hatékonyan alkalmazható a gráf összefüggő komponenseinek kezelésére nagyobb méretű gráfok esetén. === Matematikai tulajdonságok === Az összefüggő gráfok számos fontos matematikai tulajdonsággal rendelkeznek: * '''Minimális élek száma''': Egy n csúcsú összefüggő gráf minimális élek száma n - 1. * '''Maximális élek száma''': Ez függ a gráf típusától; például egy teljes gráf esetén \( \binom{n}{2} \) él van. * '''Híd''': Egy él, amelynek eltávolítása megszünteti az összefüggőséget. === Alkalmazások === Az összefüggő gráfok számos területen fontos szerepet játszanak: * '''Hálózatok''': Kommunikációs hálózatok, például az internet vagy a telefonhálózat tervezésekor az összefüggőség alapvető követelmény. * '''Úthálózatok''': Városok és közlekedési rendszerek tervezésekor biztosítani kell, hogy minden helyszín elérhető legyen. * '''Adatstruktúrák''': A gráfok felhasználása az algoritmusokban és adatszervezésben. === Összefoglalás === Az összefüggő gráfok a gráfelmélet és annak alkalmazásai szempontjából alapvető fontosságúak. Az olyan algoritmusok, mint a [[BFS]] és a [[DFS]], hatékony eszközök az összefüggőség vizsgálatára, míg az összefüggő komponensek elemzése gyakran segít bonyolultabb problémák megoldásában. Az összefüggőség biztosítása elengedhetetlen számos gyakorlati területen, a hálózatok tervezésétől az adatstruktúrákig. {{-ford-}} {{trans-top}} * {{en}}: {{t|en|connected graph}} {{trans-bottom}} {{hunl}} 7galbwfoyhgdjnj5ku6ymqabkpgd9s6 0 471765 3479454 2809583 2024-12-12T20:44:02Z LinguisticMystic 22848 3479454 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|gráf|algo}} A '''Fleury-algoritmus''' egy gráfelméleti algoritmus, amelyet '''Euler-út''' vagy '''Euler-kör''' megtalálására használnak egy irányítatlan gráfban. Az '''Euler-út''' olyan út a gráfban, amely minden élt pontosan egyszer érint. Az '''Euler-kör''' ugyanez, azzal a kitétellel, hogy az út ugyanabban a csúcsban kezdődik és végződik. ----- <span id="elméleti-feltételek"></span> === '''Elméleti feltételek''' === Az algoritmus csak akkor alkalmazható, ha az alábbi feltételek teljesülnek: 1. '''Euler-kör feltétele''': Minden csúcs fokszáma páros. 2. '''Euler-út feltétele''': Pontosan két csúcs fokszáma páratlan. - Ezek a páratlan fokszámú csúcsok az út kezdő- és végpontjai lesznek. 3. '''Összefüggőség''': A gráf minden élét el kell érni, vagyis a gráfnak összefüggőnek kell lennie. ----- <span id="algoritmus-működése"></span> === '''Algoritmus működése''' === <span id="fő-lépések"></span> ==== '''Fő lépések''': ==== # '''Indulás''': #* Ha Euler-kört keresünk, kezdjük egy tetszőleges csúcsnál. #* Ha Euler-utat keresünk, kezdjük a páratlan fokszámú csúcsok egyikénél. # '''Élek kiválasztása''': #* Mindig egy olyan élt válasszunk, amely nem '''szakadékél''' (bridge), kivéve, ha nincs más lehetőség. Egy él szakadékél, ha eltávolításával a gráf összefüggősége megszűnik. # '''Élek eltávolítása''': #* Az aktuális él feldolgozása után töröljük azt a gráfból, és lépjünk a következő csúcsra. # '''Ismétlés''': #* Addig folytassuk, amíg minden él feldolgozásra nem került. <span id="fontos-megfigyelés"></span> ==== '''Fontos megfigyelés''': ==== A Fleury-algoritmus lépésenként ellenőrzi a gráf összefüggőségét, ezért kevésbé hatékony, mint más algoritmusok, például a Hierholzer-algoritmus. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>Fleury(G, start): aktuális = start út = [aktuális] amíg van még él: ha lehetséges, válassz olyan élt, ami nem szakadékél ha nincs más választás, válassz bármelyik élt adjuk hozzá az élt az útvonalhoz távolítsuk el az élt a gráfból lépjünk a következő csúcsra visszatér út</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">from collections import defaultdict class Graph: def __init__(self): self.graph = defaultdict(list) def add_edge(self, u, v): self.graph[u].append(v) self.graph[v].append(u) def remove_edge(self, u, v): self.graph[u].remove(v) self.graph[v].remove(u) def is_bridge(self, u, v): visited = set() def dfs(node): visited.add(node) for neighbor in self.graph[node]: if neighbor not in visited: dfs(neighbor) # Számoljuk az összefüggő komponenseket az él eltávolítása előtt original_components = len(visited) self.remove_edge(u, v) # Számoljuk újra az összefüggő komponenseket visited = set() dfs(u) self.add_edge(u, v) return len(visited) != original_components def fleury(self, start): current = start path = [] while any(self.graph.values()): for neighbor in self.graph[current]: if not self.is_bridge(current, neighbor) or len(self.graph[current]) == 1: path.append((current, neighbor)) self.remove_edge(current, neighbor) current = neighbor break return path # Példa g = Graph() edges = [(0, 1), (0, 2), (1, 2), (2, 3), (3, 4), (3, 0), (4, 0)] for u, v in edges: g.add_edge(u, v) print("Euler-út:", g.fleury(0))</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <list> #include <algorithm> using namespace std; class Graph { int V; vector<list<int>> adj; public: Graph(int V) : V(V), adj(V) {} void addEdge(int u, int v) { adj[u].push_back(v); adj[v].push_back(u); } void removeEdge(int u, int v) { adj[u].remove(v); adj[v].remove(u); } void dfs(int v, vector<bool>& visited) { visited[v] = true; for (int neighbor : adj[v]) { if (!visited[neighbor]) { dfs(neighbor, visited); } } } bool isBridge(int u, int v) { vector<bool> visited(V, false); dfs(u, visited); int initial_component_count = count(visited.begin(), visited.end(), true); removeEdge(u, v); fill(visited.begin(), visited.end(), false); dfs(u, visited); addEdge(u, v); int new_component_count = count(visited.begin(), visited.end(), true); return initial_component_count > new_component_count; } void fleury(int start) { int current = start; while (true) { bool found = false; for (int neighbor : adj[current]) { if (!isBridge(current, neighbor) || adj[current].size() == 1) { cout << current << " -> " << neighbor << endl; removeEdge(current, neighbor); current = neighbor; found = true; break; } } if (!found) break; } } }; int main() { Graph g(5); g.addEdge(0, 1); g.addEdge(0, 2); g.addEdge(1, 2); g.addEdge(2, 3); g.addEdge(3, 4); g.addEdge(3, 0); g.addEdge(4, 0); cout << "Euler-út:" << endl; g.fleury(0); return 0; }</syntaxhighlight> ----- <span id="összegzés"></span> === '''Összegzés''' === A '''Fleury-algoritmus''' egyszerű és jól érthető módja az Euler-út vagy Euler-kör megtalálásának. Az algoritmus legnagyobb hátránya, hogy minden él eltávolításakor ellenőrizni kell, hogy az összefüggőség megmarad-e, ami megnöveli az időkomplexitást. Emiatt nagyobb gráfok esetén gyakran helyettesítik a '''Hierholzer-algoritmussal''', amely hatékonyabb. Az algoritmus azonban kiváló oktatási eszköz, mivel szemléletesen mutatja be az Euler-út fogalmát. {{-ford-}} {{trans-top}} * {{en}}: {{t|en|Fleury's algorithm}} {{trans-bottom}} {{hunl}} 0z3bh2iua693j9nnr2nw13ez5kt089g 0 471780 3479475 2809609 2024-12-12T21:03:03Z LinguisticMystic 22848 3479475 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} {{-ford-}} {{trans-top}} * {{en}}: {{t|en|token bucket algorithm}} {{trans-bottom}} {{hunl}} ogee4gqv6exj41zilz1ak1h085c31r7 3479483 3479475 2024-12-12T21:22:52Z LinguisticMystic 22848 3479483 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} A **vezérjeles vödör algoritmus** egy hálózati forgalomszabályozási technika, amely szabályozza az adatátviteli sebességet. Az algoritmus célja, hogy korlátozza a forgalmat egy meghatározott sebességre, miközben lehetővé teszi a rövid ideig tartó csúcsterhelést. — ### **Elmélet** 1. **Vödör és vezérjelek**: - Egy &quot;vödör&quot; tartalmazza a vezérjeleket (tokeneket), amelyek lehetővé teszik az adatcsomagok átvitelét. - Minden adatcsomag elküldéséhez egy vagy több vezérjel szükséges. - A vödör meghatározott sebességgel (pl. másodpercenként <math display="inline">r</math>) kap új vezérjeleket. 2. **Kapacitás**: - A vödör maximális kapacitása (<math display="inline">B</math>) korlátozza a benne lévő vezérjelek számát. Ha a vödör megtelik, az új vezérjelek elvesznek. 3. **Csomagküldés**: - Egy csomag akkor küldhető, ha a vödörben elegendő vezérjel van. Ha nincs elegendő vezérjel, a csomag várakozik vagy eldobásra kerül (a rendszertől függően). — ### **Tulajdonságok** - **Sebességkorlátozás**: - Az algoritmus korlátozza az átviteli sebességet <math display="inline">r</math>-re, de rövid ideig tartó csúcsterheléseket (<math display="inline">B</math>) is lehetővé tesz. - **Rugalmasság**: - Hatékonyan kezeli a váratlan terhelési csúcsokat, miközben biztosítja a folyamatos adatátviteli szabályozást. - **Alkalmazás**: - Hálózati forgalom korlátozása. - Szolgáltatásminőség (QoS) biztosítása. — ### **Pszeudokód** “‘ TokenBucket(capacity, rate): vödör = capacity utolsó_frissítés = most() amíg van csomag: most = jelenlegi idő eltelt_idő = most - utolsó_frissítés új_vezérjelek = eltelt_idő * rate vödör = min(vödör + új_vezérjelek, capacity) ha csomag_súlya &lt;= vödör: vödör = vödör - csomag_súlya engedélyezd a csomagot különben: várakozz utolsó_frissítés = most “‘ — ### **Python implementáció** “‘python import time class TokenBucket: def __init__(self, capacity, rate): self.capacity = capacity # A vödör maximális kapacitása self.rate = rate # A vezérjelek érkezési sebessége (token/s) self.tokens = capacity # Kezdetben tele a vödör self.last_refill_time = time.time() def allow_request(self, tokens_needed=1): # Frissítjük a vödörben lévő vezérjelek számát current_time = time.time() elapsed = current_time - self.last_refill_time self.tokens = min(self.capacity, self.tokens + elapsed * self.rate) self.last_refill_time = current_time # Ellenőrizzük, hogy van-e elég vezérjel a kérés teljesítéséhez if self.tokens &gt;= tokens_needed: self.tokens -= tokens_needed return True else: return False # Példa használat bucket = TokenBucket(capacity=10, rate=5) # 10-es kapacitású vödör, 5 vezérjel/másodperc requests = [1, 2, 3, 4, 5] for req in requests: if bucket.allow_request(req): print(f&quot;<span>req</span> vezérjel kérése engedélyezve.&quot;) else: print(f&quot;<span>req</span> vezérjel kérése megtagadva.&quot;) time.sleep(0.5) # Várunk, hogy vezérjelek érkezzenek “‘ **Kimenet (időzítéstől függően):** “‘ 1 vezérjel kérése engedélyezve. 2 vezérjel kérése engedélyezve. 3 vezérjel kérése engedélyezve. 4 vezérjel kérése megtagadva. 5 vezérjel kérése megtagadva. “‘ — ### **C++ implementáció** “‘cpp #include &lt;iostream&gt; #include &lt;chrono&gt; #include &lt;thread&gt; using namespace std; using namespace chrono; class TokenBucket private: double capacity; double rate; double tokens; steady_clock::time_point last_refill_time; public: TokenBucket(double cap, double r) : capacity(cap), rate(r), tokens(cap), last_refill_time(steady_clock::now()) bool allow_request(double tokens_needed = 1) auto now = steady_clock::now(); double elapsed = duration_cast&lt;milliseconds&gt;(now - last_refill_time).count() / 1000.0; tokens = min(capacity, tokens + elapsed * rate); last_refill_time = now; if (tokens &gt;= tokens_needed) <span> tokens -= tokens_needed; return true; </span> else <span> return false; </span> ; int main() TokenBucket bucket(10, 5); // 10-es kapacitás, 5 vezérjel/másodperc double requests[] = <span>1, 2, 3, 4, 5</span>; for (double req : requests) <span> if (bucket.allow_request(req)) <span> cout &lt;&lt; req &lt;&lt; &quot; vezérjel kérése engedélyezve.&quot; &lt;&lt; endl; </span> else <span> cout &lt;&lt; req &lt;&lt; &quot; vezérjel kérése megtagadva.&quot; &lt;&lt; endl; </span> this_thread::sleep_for(milliseconds(500)); // Várunk, hogy vezérjelek érkezzenek </span> return 0; “‘ **Kimenet (időzítéstől függően):** “‘ 1 vezérjel kérése engedélyezve. 2 vezérjel kérése engedélyezve. 3 vezérjel kérése engedélyezve. 4 vezérjel kérése megtagadva. 5 vezérjel kérése megtagadva. “‘ — ### **Összegzés** A vezérjeles vödör algoritmus egy hatékony és rugalmas módszer a hálózati forgalom szabályozására. Pythonban és C++-ban is könnyen implementálható, és különféle rendszerekben, például API-k sebességkorlátozásában vagy hálózati forgalomszabályozásban alkalmazható. {{-ford-}} {{trans-top}} * {{en}}: {{t|en|token bucket algorithm}} {{trans-bottom}} {{hunl}} loaym04r7l3kj0orx3jwci2hhhaqmoo 3479484 3479483 2024-12-12T21:23:32Z LinguisticMystic 22848 3479484 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} A '''vezérjeles vödör algoritmus''' egy hálózati forgalomszabályozási technika, amely szabályozza az adatátviteli sebességet. Az algoritmus célja, hogy korlátozza a forgalmat egy meghatározott sebességre, miközben lehetővé teszi a rövid ideig tartó csúcsterhelést. ----- <span id="elmélet"></span> === '''Elmélet''' === # '''Vödör és vezérjelek''': #* Egy “vödör” tartalmazza a vezérjeleket (tokeneket), amelyek lehetővé teszik az adatcsomagok átvitelét. #* Minden adatcsomag elküldéséhez egy vagy több vezérjel szükséges. #* A vödör meghatározott sebességgel (pl. másodpercenként (r)) kap új vezérjeleket. # '''Kapacitás''': #* A vödör maximális kapacitása ((B)) korlátozza a benne lévő vezérjelek számát. Ha a vödör megtelik, az új vezérjelek elvesznek. # '''Csomagküldés''': #* Egy csomag akkor küldhető, ha a vödörben elegendő vezérjel van. Ha nincs elegendő vezérjel, a csomag várakozik vagy eldobásra kerül (a rendszertől függően). ----- <span id="tulajdonságok"></span> === '''Tulajdonságok''' === * '''Sebességkorlátozás''': ** Az algoritmus korlátozza az átviteli sebességet (r)-re, de rövid ideig tartó csúcsterheléseket ((B)) is lehetővé tesz. * '''Rugalmasság''': ** Hatékonyan kezeli a váratlan terhelési csúcsokat, miközben biztosítja a folyamatos adatátviteli szabályozást. * '''Alkalmazás''': ** Hálózati forgalom korlátozása. ** Szolgáltatásminőség (QoS) biztosítása. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>TokenBucket(capacity, rate): vödör = capacity utolsó_frissítés = most() amíg van csomag: most = jelenlegi idő eltelt_idő = most - utolsó_frissítés új_vezérjelek = eltelt_idő * rate vödör = min(vödör + új_vezérjelek, capacity) ha csomag_súlya &lt;= vödör: vödör = vödör - csomag_súlya engedélyezd a csomagot különben: várakozz utolsó_frissítés = most</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">import time class TokenBucket: def __init__(self, capacity, rate): self.capacity = capacity # A vödör maximális kapacitása self.rate = rate # A vezérjelek érkezési sebessége (token/s) self.tokens = capacity # Kezdetben tele a vödör self.last_refill_time = time.time() def allow_request(self, tokens_needed=1): # Frissítjük a vödörben lévő vezérjelek számát current_time = time.time() elapsed = current_time - self.last_refill_time self.tokens = min(self.capacity, self.tokens + elapsed * self.rate) self.last_refill_time = current_time # Ellenőrizzük, hogy van-e elég vezérjel a kérés teljesítéséhez if self.tokens >= tokens_needed: self.tokens -= tokens_needed return True else: return False # Példa használat bucket = TokenBucket(capacity=10, rate=5) # 10-es kapacitású vödör, 5 vezérjel/másodperc requests = [1, 2, 3, 4, 5] for req in requests: if bucket.allow_request(req): print(f"{req} vezérjel kérése engedélyezve.") else: print(f"{req} vezérjel kérése megtagadva.") time.sleep(0.5) # Várunk, hogy vezérjelek érkezzenek</syntaxhighlight> '''Kimenet (időzítéstől függően):''' <pre>1 vezérjel kérése engedélyezve. 2 vezérjel kérése engedélyezve. 3 vezérjel kérése engedélyezve. 4 vezérjel kérése megtagadva. 5 vezérjel kérése megtagadva.</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <chrono> #include <thread> using namespace std; using namespace chrono; class TokenBucket { private: double capacity; double rate; double tokens; steady_clock::time_point last_refill_time; public: TokenBucket(double cap, double r) : capacity(cap), rate(r), tokens(cap), last_refill_time(steady_clock::now()) {} bool allow_request(double tokens_needed = 1) { auto now = steady_clock::now(); double elapsed = duration_cast<milliseconds>(now - last_refill_time).count() / 1000.0; tokens = min(capacity, tokens + elapsed * rate); last_refill_time = now; if (tokens >= tokens_needed) { tokens -= tokens_needed; return true; } else { return false; } } }; int main() { TokenBucket bucket(10, 5); // 10-es kapacitás, 5 vezérjel/másodperc double requests[] = {1, 2, 3, 4, 5}; for (double req : requests) { if (bucket.allow_request(req)) { cout << req << " vezérjel kérése engedélyezve." << endl; } else { cout << req << " vezérjel kérése megtagadva." << endl; } this_thread::sleep_for(milliseconds(500)); // Várunk, hogy vezérjelek érkezzenek } return 0; }</syntaxhighlight> '''Kimenet (időzítéstől függően):''' <pre>1 vezérjel kérése engedélyezve. 2 vezérjel kérése engedélyezve. 3 vezérjel kérése engedélyezve. 4 vezérjel kérése megtagadva. 5 vezérjel kérése megtagadva.</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === A vezérjeles vödör algoritmus egy hatékony és rugalmas módszer a hálózati forgalom szabályozására. Pythonban és C++-ban is könnyen implementálható, és különféle rendszerekben, például API-k sebességkorlátozásában vagy hálózati forgalomszabályozásban alkalmazható. {{-ford-}} {{trans-top}} * {{en}}: {{t|en|token bucket algorithm}} {{trans-bottom}} {{hunl}} 79hm1vpwr780n16t12lkhkofd851l0c 0 471792 3479474 2809627 2024-12-12T21:02:56Z LinguisticMystic 22848 3479474 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo|cryptography}} {{hunl}} bq21obxsydkcrzoz44c8npcg0ud6dgn 3479481 3479474 2024-12-12T21:18:40Z LinguisticMystic 22848 3479481 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo|cryptography}} <span id="rsa-rivestshamiradleman-algoritmus"></span> === '''RSA (Rivest–Shamir–Adleman) algoritmus''' === Az '''RSA algoritmus''' egy aszimmetrikus titkosítási algoritmus, amelyet széles körben használnak adatvédelemre és digitális aláírásokra. A biztonsága azon alapul, hogy nagy számok prímtényezős felbontása számítási szempontból nehéz feladat. ----- <span id="elmélet"></span> === '''Elmélet''' === <span id="kulcsgenerálás"></span> ==== '''Kulcsgenerálás''' ==== # '''Két nagy prímszám kiválasztása''': (p) és (q). # '''Modulus kiszámítása''': (n = p q). # '''Euler-féle totient függvény''': ((n) = (p-1) (q-1)). # '''Nyilvános kulcs exponens''': Válasszunk egy (e)-t, amely relatív prím ((n))-hez ((1 &lt; e &lt; (n))). # '''Privát kulcs exponens''': Számítsuk ki (d)-t, amelyre ((e d) (n) = 1). <span id="titkosítás"></span> ==== '''Titkosítás''' ==== Egy (m) (üzenet) titkosítása: [ c = m^e n ] ahol (c) a titkosított üzenet. <span id="visszafejtés"></span> ==== '''Visszafejtés''' ==== A titkosított (c) üzenet visszafejtése: [ m = c^d n ] ahol (d) a privát kulcs. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <span id="kulcsgenerálás-1"></span> ==== '''Kulcsgenerálás''' ==== <pre>GenerateKeys(): válassz két nagy prímszámot: p, q n = p * q φ = (p - 1) * (q - 1) válassz egy e-t, amely 1 &lt; e &lt; φ és gcd(e, φ) = 1 számítsd ki d-t, amelyre (e * d) mod φ = 1 visszatér (e, n), (d, n) // nyilvános és privát kulcsok</pre> <span id="titkosítás-1"></span> ==== '''Titkosítás''' ==== <pre>Encrypt(m, e, n): c = (m^e) mod n visszatér c</pre> <span id="visszafejtés-1"></span> ==== '''Visszafejtés''' ==== <pre>Decrypt(c, d, n): m = (c^d) mod n visszatér m</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <span id="rsa-algoritmus"></span> ==== '''RSA Algoritmus''' ==== <syntaxhighlight lang="python">import random from math import gcd def generate_keys(): def is_prime(num): if num < 2: return False for i in range(2, int(num**0.5) + 1): if num % i == 0: return False return True def mod_inverse(a, m): m0, x0, x1 = m, 0, 1 while a > 1: q = a // m m, a = a % m, m x0, x1 = x1 - q * x0, x0 return x1 + m0 if x1 < 0 else x1 # Véletlenszerű prímszámok generálása primes = [i for i in range(100, 200) if is_prime(i)] p, q = random.sample(primes, 2) n = p * q phi = (p - 1) * (q - 1) # Nyilvános kulcs komponensek e = random.choice([i for i in range(2, phi) if gcd(i, phi) == 1]) # Privát kulcs komponens d = mod_inverse(e, phi) return (e, n), (d, n) # Nyilvános és privát kulcsok def encrypt(message, public_key): e, n = public_key return [(ord(char) ** e) % n for char in message] def decrypt(ciphertext, private_key): d, n = private_key return ''.join([chr((char ** d) % n) for char in ciphertext]) # Kulcsgenerálás public_key, private_key = generate_keys() print("Nyilvános kulcs:", public_key) print("Privát kulcs:", private_key) # Üzenet titkosítása és visszafejtése message = "HELLO" cipher = encrypt(message, public_key) print("Titkosított üzenet:", cipher) decrypted_message = decrypt(cipher, private_key) print("Visszafejtett üzenet:", decrypted_message)</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <cmath> #include <cstdlib> #include <ctime> using namespace std; // Euklideszi algoritmus a legnagyobb közös osztóhoz int gcd(int a, int b) { while (b != 0) { int t = b; b = a % b; a = t; } return a; } // Moduláris inverz kiszámítása int mod_inverse(int a, int m) { int m0 = m, x0 = 0, x1 = 1; while (a > 1) { int q = a / m; int t = m; m = a % m, a = t; t = x0; x0 = x1 - q * x0; x1 = t; } return (x1 + m0) % m0; } // Ellenőrzi, hogy egy szám prímszám-e bool is_prime(int num) { if (num < 2) return false; for (int i = 2; i <= sqrt(num); ++i) { if (num % i == 0) return false; } return true; } void generate_keys(int& e, int& d, int& n) { vector<int> primes; for (int i = 100; i < 200; ++i) { if (is_prime(i)) primes.push_back(i); } srand(time(0)); int p = primes[rand() % primes.size()]; int q = primes[rand() % primes.size()]; while (q == p) { q = primes[rand() % primes.size()]; } n = p * q; int phi = (p - 1) * (q - 1); do { e = rand() % phi; } while (gcd(e, phi) != 1); d = mod_inverse(e, phi); } vector<int> encrypt(const string& message, int e, int n) { vector<int> cipher; for (char c : message) { cipher.push_back(static_cast<int>(pow(c, e)) % n); } return cipher; } string decrypt(const vector<int>& cipher, int d, int n) { string message; for (int c : cipher) { message += static_cast<char>(static_cast<int>(pow(c, d)) % n); } return message; } int main() { int e, d, n; generate_keys(e, d, n); cout << "Nyilvános kulcs: (" << e << ", " << n << ")\n"; cout << "Privát kulcs: (" << d << ", " << n << ")\n"; string message = "HELLO"; vector<int> cipher = encrypt(message, e, n); cout << "Titkosított üzenet: "; for (int c : cipher) { cout << c << " "; } cout << endl; string decrypted_message = decrypt(cipher, d, n); cout << "Visszafejtett üzenet: " << decrypted_message << endl; return 0; }</syntaxhighlight> ----- <span id="összegzés"></span> === '''Összegzés''' === * '''Előnyök''': ** Az RSA biztonságos és széles körben használt. ** Könnyen érthető matematikai alapelvek. * '''Hátrányok''': ** Lassabb, mint a szimmetrikus algoritmusok. ** Nagy számítási erőforrásokat igényel. Az RSA algoritmus a '''biztonságos kommunikáció''' alapvető eszköze, és Pythonban és C++-ban is könnyen implementálható kis léptékű alkalmazásokhoz. {{hunl}} scoc1z4olz2o64ht978wi7y5af2an3m 3479482 3479481 2024-12-12T21:19:41Z LinguisticMystic 22848 3479482 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo|cryptography}} <span id="rsa-rivestshamiradleman-algoritmus"></span> === '''RSA (Rivest–Shamir–Adleman) algoritmus''' === Az '''RSA algoritmus''' egy aszimmetrikus titkosítási algoritmus, amelyet széles körben használnak adatvédelemre és digitális aláírásokra. A biztonsága azon alapul, hogy nagy számok prímtényezős felbontása számítási szempontból nehéz feladat. ----- <span id="elmélet"></span> === '''Elmélet''' === <span id="kulcsgenerálás"></span> ==== '''Kulcsgenerálás''' ==== # '''Két nagy prímszám kiválasztása''': (p) és (q). # '''Modulus kiszámítása''': (n = p q). # '''Euler-féle totient függvény''': ((n) = (p-1) (q-1)). # '''Nyilvános kulcs exponens''': Válasszunk egy (e)-t, amely relatív prím ((n))-hez ((1 &lt; e &lt; (n))). # '''Privát kulcs exponens''': Számítsuk ki (d)-t, amelyre ((e d) (n) = 1). <span id="titkosítás"></span> ==== '''Titkosítás''' ==== Egy (m) (üzenet) titkosítása: [ c = m^e n ] ahol (c) a titkosított üzenet. <span id="visszafejtés"></span> ==== '''Visszafejtés''' ==== A titkosított (c) üzenet visszafejtése: [ m = c^d n ] ahol (d) a privát kulcs. ---- #### **Kulcsgenerálás** 1. **Két nagy prímszám kiválasztása**: <math display="inline">p</math> és <math display="inline">q</math>. 2. **Modulus kiszámítása**: <math display="inline">n = p \cdot q</math>. 3. **Euler-féle totient függvény**: <math display="inline">\phi(n) = (p-1) \cdot (q-1)</math>. 4. **Nyilvános kulcs exponens**: Válasszunk egy <math display="inline">e</math>-t, amely relatív prím <math display="inline">\phi(n)</math>-hez (<math display="inline">1 < e < \phi(n)</math>). 5. **Privát kulcs exponens**: Számítsuk ki <math display="inline">d</math>-t, amelyre <math display="inline">(e \cdot d) \mod \phi(n) = 1</math>. #### **Titkosítás** Egy <math display="inline">m</math> (üzenet) titkosítása: <math display="block">c = m^e \mod n</math> ahol <math display="inline">c</math> a titkosított üzenet. #### **Visszafejtés** A titkosított <math display="inline">c</math> üzenet visszafejtése: <math display="block">m = c^d \mod n</math> ahol <math display="inline">d</math> a privát kulcs. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <span id="kulcsgenerálás-1"></span> ==== '''Kulcsgenerálás''' ==== <pre>GenerateKeys(): válassz két nagy prímszámot: p, q n = p * q φ = (p - 1) * (q - 1) válassz egy e-t, amely 1 &lt; e &lt; φ és gcd(e, φ) = 1 számítsd ki d-t, amelyre (e * d) mod φ = 1 visszatér (e, n), (d, n) // nyilvános és privát kulcsok</pre> <span id="titkosítás-1"></span> ==== '''Titkosítás''' ==== <pre>Encrypt(m, e, n): c = (m^e) mod n visszatér c</pre> <span id="visszafejtés-1"></span> ==== '''Visszafejtés''' ==== <pre>Decrypt(c, d, n): m = (c^d) mod n visszatér m</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <span id="rsa-algoritmus"></span> ==== '''RSA Algoritmus''' ==== <syntaxhighlight lang="python">import random from math import gcd def generate_keys(): def is_prime(num): if num < 2: return False for i in range(2, int(num**0.5) + 1): if num % i == 0: return False return True def mod_inverse(a, m): m0, x0, x1 = m, 0, 1 while a > 1: q = a // m m, a = a % m, m x0, x1 = x1 - q * x0, x0 return x1 + m0 if x1 < 0 else x1 # Véletlenszerű prímszámok generálása primes = [i for i in range(100, 200) if is_prime(i)] p, q = random.sample(primes, 2) n = p * q phi = (p - 1) * (q - 1) # Nyilvános kulcs komponensek e = random.choice([i for i in range(2, phi) if gcd(i, phi) == 1]) # Privát kulcs komponens d = mod_inverse(e, phi) return (e, n), (d, n) # Nyilvános és privát kulcsok def encrypt(message, public_key): e, n = public_key return [(ord(char) ** e) % n for char in message] def decrypt(ciphertext, private_key): d, n = private_key return ''.join([chr((char ** d) % n) for char in ciphertext]) # Kulcsgenerálás public_key, private_key = generate_keys() print("Nyilvános kulcs:", public_key) print("Privát kulcs:", private_key) # Üzenet titkosítása és visszafejtése message = "HELLO" cipher = encrypt(message, public_key) print("Titkosított üzenet:", cipher) decrypted_message = decrypt(cipher, private_key) print("Visszafejtett üzenet:", decrypted_message)</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <cmath> #include <cstdlib> #include <ctime> using namespace std; // Euklideszi algoritmus a legnagyobb közös osztóhoz int gcd(int a, int b) { while (b != 0) { int t = b; b = a % b; a = t; } return a; } // Moduláris inverz kiszámítása int mod_inverse(int a, int m) { int m0 = m, x0 = 0, x1 = 1; while (a > 1) { int q = a / m; int t = m; m = a % m, a = t; t = x0; x0 = x1 - q * x0; x1 = t; } return (x1 + m0) % m0; } // Ellenőrzi, hogy egy szám prímszám-e bool is_prime(int num) { if (num < 2) return false; for (int i = 2; i <= sqrt(num); ++i) { if (num % i == 0) return false; } return true; } void generate_keys(int& e, int& d, int& n) { vector<int> primes; for (int i = 100; i < 200; ++i) { if (is_prime(i)) primes.push_back(i); } srand(time(0)); int p = primes[rand() % primes.size()]; int q = primes[rand() % primes.size()]; while (q == p) { q = primes[rand() % primes.size()]; } n = p * q; int phi = (p - 1) * (q - 1); do { e = rand() % phi; } while (gcd(e, phi) != 1); d = mod_inverse(e, phi); } vector<int> encrypt(const string& message, int e, int n) { vector<int> cipher; for (char c : message) { cipher.push_back(static_cast<int>(pow(c, e)) % n); } return cipher; } string decrypt(const vector<int>& cipher, int d, int n) { string message; for (int c : cipher) { message += static_cast<char>(static_cast<int>(pow(c, d)) % n); } return message; } int main() { int e, d, n; generate_keys(e, d, n); cout << "Nyilvános kulcs: (" << e << ", " << n << ")\n"; cout << "Privát kulcs: (" << d << ", " << n << ")\n"; string message = "HELLO"; vector<int> cipher = encrypt(message, e, n); cout << "Titkosított üzenet: "; for (int c : cipher) { cout << c << " "; } cout << endl; string decrypted_message = decrypt(cipher, d, n); cout << "Visszafejtett üzenet: " << decrypted_message << endl; return 0; }</syntaxhighlight> ----- <span id="összegzés"></span> === '''Összegzés''' === * '''Előnyök''': ** Az RSA biztonságos és széles körben használt. ** Könnyen érthető matematikai alapelvek. * '''Hátrányok''': ** Lassabb, mint a szimmetrikus algoritmusok. ** Nagy számítási erőforrásokat igényel. Az RSA algoritmus a '''biztonságos kommunikáció''' alapvető eszköze, és Pythonban és C++-ban is könnyen implementálható kis léptékű alkalmazásokhoz. {{hunl}} hrkrvsm3yh2a7u6j4c981ghi75lsq9k 0 471831 3479450 2809731 2024-12-12T20:39:02Z LinguisticMystic 22848 3479450 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo|comptheory}} {{-ford-}} {{trans-top}} * {{en}}: {{t|en|exponential algorithm}} {{trans-bottom}} {{hunl}} 0azzu8wi913d0ojm9ey44urhwifpoc0 0 471867 3479452 2809787 2024-12-12T20:40:59Z LinguisticMystic 22848 3479452 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} {{-ford-}} {{trans-top}} * {{en}}: {{t|en|quadratic algorithm}} {{trans-bottom}} {{hunl}} 6fue62t01klaayefj8la6bq9uzgyoe1 0 500919 3479615 2952841 2024-12-13T10:35:59Z Jeuwre 15076 audio 3479615 wikitext text/x-wiki {{deuige}} :{{audio|De-pulsieren.ogg|hallgat ([pʊlˈziːʁən])}} #[[pulzál]], [[lüktet]] 5w0p5644j04h5np5ysq35kpoixwgm96 0 511561 3479436 2993814 2024-12-12T20:03:45Z 89.134.16.221 3479436 wikitext text/x-wiki {{redir|ILA}} 2ugkaffxi935q5h0sz5zvs2xqxa7oud 0 613324 3479613 3132692 2024-12-13T00:16:02Z LinguisticMystic 22848 3479613 wikitext text/x-wiki {{engfn}} # {{label|en|matematika}} [[mágikus négyzet]] {{engl}} 80dbo2g52lbx62cxldclp4t8y9skkls 0 778461 3479410 3475077 2024-12-12T14:50:31Z LinguisticMystic 22848 3479410 wikitext text/x-wiki {{char}} {{hunfn}} #{{label|hu|matematika}} N-ARY UNION - nagy uniójel, a summához hasonlóan indexelhető <math display=block>\bigcup_{i=1}^n A_i = A_1 \cup A_2 \cup \cdots \cup A_n</math> {{hunl}} mzv8hj83h81w9ltnb9dqdsz99mmg25v 3479411 3479410 2024-12-12T14:50:54Z LinguisticMystic 22848 3479411 wikitext text/x-wiki {{char}} {{hunfn}} #{{label|hu|matematika}} nagy uniójel <math display=block>\bigcup_{i=1}^n A_i = A_1 \cup A_2 \cup \cdots \cup A_n</math> {{hunl}} a4ml1nojpp3dc4p0w2ol51hbqtfkpxa 0 779252 3479394 3444590 2024-12-12T13:46:08Z LinguisticMystic 22848 3479394 wikitext text/x-wiki {{hunfn}} #{{humatek}} A [[projektor mátrix]] vagy [[idempotens mátrix]] egy olyan négyzetes mátrix, amelynek minden sajátértéke 0 vagy 1. Minden n×n-es projektor mátrixnak van n darab lineárisan független sajátvektora. Ha egy n×n-es projektor mátrix rangja n, akkor az az egységmátrix. Négyzetre (és ebből következően bármilyen hatványra) emelve önmagát eredményezi. {{hunl}} 9q7fb0c8q5sz1zma7nvf3hia1nd0vo1 0 779253 3479393 3444591 2024-12-12T13:46:00Z LinguisticMystic 22848 3479393 wikitext text/x-wiki {{hunfn}} #{{humatek}} A [[projektor mátrix]] vagy [[idempotens mátrix]] egy olyan négyzetes mátrix, amelynek minden sajátértéke 0 vagy 1. Minden n×n-es projektor mátrixnak van n darab lineárisan független sajátvektora. Ha egy n×n-es projektor mátrix rangja n, akkor az az egységmátrix. Négyzetre (és ebből következően bármilyen hatványra) emelve önmagát eredményezi. {{hunl}} 9q7fb0c8q5sz1zma7nvf3hia1nd0vo1 0 780425 3479409 3475076 2024-12-12T14:49:05Z LinguisticMystic 22848 3479409 wikitext text/x-wiki {{char}} {{hunfn}} #{{label|hu|matematika}} n-ary intersection (nagy [[metszetjel]], a szummához hasonlóan indexelhető) <math display=block>\bigcap_{i=1}^n A_i = A_1 \cap A_2 \cap \cdots \cap A_n</math> {{hunl}} lb2l9cjad44dnlowxdx8tcudryzvquv 2 782674 3479374 3453287 2024-12-12T13:14:12Z LinguisticMystic 22848 A lap tartalmának cseréje erre: {{subst:redir|Szerkesztő:LinguisticMystic}} 3479374 wikitext text/x-wiki #redirect [[Szerkesztő:LinguisticMystic]] l1dup727f1rv1a1gb5jnnixt3157l3w 2 782678 3479372 3450854 2024-12-12T13:10:06Z LinguisticMystic 22848 3479372 wikitext text/x-wiki #redirect [[Szerkesztő:LinguisticMystic]] l1dup727f1rv1a1gb5jnnixt3157l3w 2 782688 3479376 3450908 2024-12-12T13:21:57Z LinguisticMystic 22848 Átirányítás ide: [[Szerkesztő:LinguisticMystic]] 3479376 wikitext text/x-wiki #redirect [[Szerkesztő:LinguisticMystic]] l1dup727f1rv1a1gb5jnnixt3157l3w 2 782689 3479375 3450909 2024-12-12T13:21:41Z LinguisticMystic 22848 Átirányítás ide: [[Szerkesztő:LinguisticMystic]] 3479375 wikitext text/x-wiki #redirect [[Szerkesztő:LinguisticMystic]] l1dup727f1rv1a1gb5jnnixt3157l3w 0 782793 3479495 3451191 2024-12-12T21:42:00Z LinguisticMystic 22848 A lap tartalmának cseréje erre: {{hunfn}} #{{label|hu|matematika|inf}} {{hunl}} 3479495 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|inf}} {{hunl}} f3bew8teaeewipfwk3zod47o23cn9md 3479500 3479495 2024-12-12T21:45:35Z LinguisticMystic 22848 3479500 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|inf|algo}} {{hunl}} i8a1w5dilvy1d0p0j4vyr2vmzjlwuhu 3479513 3479500 2024-12-12T22:04:49Z LinguisticMystic 22848 3479513 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|inf|algo}} Az '''A*''' egy informált keresési algoritmus, amelyet széles körben használnak grafok és hálózatok rövid útjainak keresésére. Az algoritmus különösen hatékony, mivel egy '''heurisztikus függvényt''' alkalmaz, amely vezeti a keresést az optimális megoldás felé, miközben minimalizálja a vizsgálandó csomópontok számát. ----- <span id="elmélet"></span> === '''Elmélet''' === # '''Cél''': #* Egy gráfban megtalálni a '''legolcsóbb utat''' a kiindulási csomópontból ((start)) a célcsomópontba ((goal)). # '''Heurisztikus keresés''': #* Az A* algoritmus a '''g(n) + h(n)''' függvényt optimalizálja, ahol: #** (g(n)): Az út költsége a kiindulási csomópontból (n)-be. #** (h(n)): A heurisztikus becslés az (n)-ből a célba vezető útra. # '''Adott feltétel''': #* A heurisztikus függvény ((h(n))) '''admisszibilis''', ha soha nem becsül túl, azaz (h(n) ). # '''Működés''': #* Nyitott halmaz ((Open)): Az összes csomópont, amelyet vizsgálunk. #* Zárt halmaz ((Closed)): Az összes csomópont, amelyet már megvizsgáltunk. #* Az algoritmus mindig a legkisebb (f(n) = g(n) + h(n)) értékkel rendelkező csomópontot vizsgálja. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>AStar(start, goal): Open = üres prioritásos sor Closed = üres halmaz g[start] = 0 f[start] = h(start) Open.helyezd_el(start) amíg Open nem üres: current = Open.min_f() ha current == goal: térj vissza az útvonalra Open.távolítsd_el(current) Closed.helyezd_el(current) minden szomszéd in current.szomszédai: ha szomszéd in Closed: folytasd tentative_g = g[current] + cost(current, szomszéd) ha szomszéd not in Open vagy tentative_g &lt; g[szomszéd]: g[szomszéd] = tentative_g f[szomszéd] = g[szomszéd] + h(szomszéd) ha szomszéd not in Open: Open.helyezd_el(szomszéd) térj vissza &quot;Nincs út&quot;</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">import heapq def a_star(graph, start, goal, h): open_set = [] heapq.heappush(open_set, (0, start)) came_from = {} g_score = {node: float('inf') for node in graph} g_score[start] = 0 f_score = {node: float('inf') for node in graph} f_score[start] = h[start] while open_set: _, current = heapq.heappop(open_set) if current == goal: path = [] while current in came_from: path.append(current) current = came_from[current] return path[::-1] for neighbor, cost in graph[current].items(): tentative_g_score = g_score[current] + cost if tentative_g_score < g_score[neighbor]: came_from[neighbor] = current g_score[neighbor] = tentative_g_score f_score[neighbor] = g_score[neighbor] + h[neighbor] if not any(neighbor == item[1] for item in open_set): heapq.heappush(open_set, (f_score[neighbor], neighbor)) return "Nincs elérhető út" # Példa gráf graph = { 'A': {'B': 1, 'C': 4}, 'B': {'A': 1, 'C': 2, 'D': 5}, 'C': {'A': 4, 'B': 2, 'D': 1}, 'D': {'B': 5, 'C': 1} } # Heurisztikus függvény h = { 'A': 7, 'B': 6, 'C': 2, 'D': 0 } start = 'A' goal = 'D' path = a_star(graph, start, goal, h) print("Útvonal:", path)</syntaxhighlight> '''Kimenet:''' <pre>Útvonal: ['A', 'B', 'C', 'D']</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <queue> #include <unordered_map> #include <limits> using namespace std; struct Node { string name; double cost; bool operator>(const Node& other) const { return cost > other.cost; } }; vector<string> reconstruct_path(unordered_map<string, string>& came_from, string current) { vector<string> path; while (came_from.find(current) != came_from.end()) { path.push_back(current); current = came_from[current]; } reverse(path.begin(), path.end()); return path; } vector<string> a_star( unordered_map<string, unordered_map<string, double>>& graph, unordered_map<string, double>& h, string start, string goal) { priority_queue<Node, vector<Node>, greater<Node>> open_set; unordered_map<string, double> g_score; unordered_map<string, double> f_score; unordered_map<string, string> came_from; for (auto& node : graph) { g_score[node.first] = numeric_limits<double>::infinity(); f_score[node.first] = numeric_limits<double>::infinity(); } g_score[start] = 0; f_score[start] = h[start]; open_set.push({start, f_score[start]}); while (!open_set.empty()) { string current = open_set.top().name; open_set.pop(); if (current == goal) { return reconstruct_path(came_from, current); } for (auto& neighbor : graph[current]) { double tentative_g_score = g_score[current] + neighbor.second; if (tentative_g_score < g_score[neighbor.first]) { came_from[neighbor.first] = current; g_score[neighbor.first] = tentative_g_score; f_score[neighbor.first] = g_score[neighbor.first] + h[neighbor.first]; open_set.push({neighbor.first, f_score[neighbor.first]}); } } } return {"Nincs elérhető út"}; } int main() { unordered_map<string, unordered_map<string, double>> graph = { {"A", {{"B", 1}, {"C", 4}}}, {"B", {{"A", 1}, {"C", 2}, {"D", 5}}}, {"C", {{"A", 4}, {"B", 2}, {"D", 1}}}, {"D", {{"B", 5}, {"C", 1}}} }; unordered_map<string, double> h = { {"A", 7}, {"B", 6}, {"C", 2}, {"D", 0} }; string start = "A"; string goal = "D"; vector<string> path = a_star(graph, h, start, goal); cout << "Útvonal: "; for (auto& node : path) { cout << node << " "; } cout << endl; return 0; }</syntaxhighlight> '''Kimenet:''' <pre>Útvonal: A B C D</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === <span id="előnyök"></span> ==== '''Előnyök''': ==== # Hatékony, mivel csak az ígéretes csomópontokat vizsgálja. # Optimalitás: Garantáltan megtalálja a legrövidebb utat, ha (h(n)) admisszibilis. <span id="hátrányok"></span> ==== '''Hátrányok''': ==== # Nagy memóriaigény, mivel sok csomópontot kell tárolni. # A heurisztikus függvény minősége erősen befolyásolja a teljesítményt. Az '''A*''' algoritmus kiváló választás útvonaltervezési problémákra, például térképészeti alkalmazásokban, mesterséges intelligenciában és robotikában. {{hunl}} s2j0ppaxva3xrzc8lbexjy5oazhufv7 0 782800 3479511 3451210 2024-12-12T21:59:14Z LinguisticMystic 22848 3479511 wikitext text/x-wiki {{hunfn}} # {{label|hu|informatika|algo}} Az '''alfa-béta vágás''' egy optimalizációs technika a '''minimax algoritmushoz''', amelyet kétjátékos, nulla összegű játékok (pl. sakk, dáma) esetében alkalmaznak. Az algoritmus célja, hogy csökkentse a vizsgálandó csomópontok számát a játékfa keresése során, anélkül, hogy az eredmény pontossága csökkenne. ----- <span id="elmélet"></span> === '''Elmélet''' === # '''Minimax algoritmus''': #* Az algoritmus egy játékfa minden állapotát kiértékeli, és a gyökércsomóponthoz visszavezeti az optimális lépést. #* A játékosok '''Max''' és '''Min''' váltakozva próbálják maximalizálni, illetve minimalizálni a játék végső nyereségét. # '''Alfa-béta vágás''': #* Az alfa (()) a maximális alsó korlátot tartalmazza, amit a Max játékos el tud érni. #* A béta (()) a minimális felső korlátot tartalmazza, amit a Min játékos el tud érni. #* Ha egy csomópont bizonyosan nem vezet jobb eredményhez, mint amit a korábbi csomópontok már garantáltak (()), akkor azt a részt nem kell tovább vizsgálni ('''vágás'''). # '''Hatékonyság''': #* Az alfa-béta vágás csökkenti a keresési tér méretét. #* Az optimális sorrendben vizsgált csomópontok esetében az időkomplexitás (O(b^{d/2})), ahol (b) az elágazási tényező, (d) pedig a keresési mélység. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>AlphaBeta(node, depth, ?, ß, maximizingPlayer): ha depth == 0 vagy node terminális állapot: térj vissza node értéke ha maximizingPlayer: maxEval = -? minden child in node gyerekei: eval = AlphaBeta(child, depth-1, ?, ß, False) maxEval = max(maxEval, eval) ? = max(?, eval) ha ß ? ?: törés // Vágás térj vissza maxEval különben: minEval = +? minden child in node gyerekei: eval = AlphaBeta(child, depth-1, ?, ß, True) minEval = min(minEval, eval) ß = min(ß, eval) ha ß ? ?: törés // Vágás térj vissza minEval</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def alpha_beta(node, depth, alpha, beta, maximizing_player, evaluate, get_children): if depth == 0 or node.is_terminal(): return evaluate(node) if maximizing_player: max_eval = float('-inf') for child in get_children(node): eval = alpha_beta(child, depth - 1, alpha, beta, False, evaluate, get_children) max_eval = max(max_eval, eval) alpha = max(alpha, eval) if beta <= alpha: break # Vágás return max_eval else: min_eval = float('inf') for child in get_children(node): eval = alpha_beta(child, depth - 1, alpha, beta, True, evaluate, get_children) min_eval = min(min_eval, eval) beta = min(beta, eval) if beta <= alpha: break # Vágás return min_eval # Példa dummy osztályokkal class Node: def __init__(self, value=None, children=None): self.value = value self.children = children if children else [] def is_terminal(self): return self.value is not None def evaluate(node): return node.value def get_children(node): return node.children # Példa játékfa tree = Node(children=[ Node(value=3), Node(children=[ Node(value=5), Node(value=6), ]), Node(children=[ Node(value=7), Node(value=4), ]) ]) result = alpha_beta(tree, depth=3, alpha=float('-inf'), beta=float('inf'), maximizing_player=True, evaluate=evaluate, get_children=get_children) print("Legjobb érték:", result)</syntaxhighlight> '''Kimenet:''' <pre>Legjobb érték: 7</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <limits> using namespace std; struct Node { int value; vector<Node*> children; Node(int val = 0) : value(val) {} bool is_terminal() const { return children.empty(); } }; int alpha_beta(Node* node, int depth, int alpha, int beta, bool maximizing_player) { if (depth == 0 || node->is_terminal()) { return node->value; } if (maximizing_player) { int max_eval = numeric_limits<int>::min(); for (Node* child : node->children) { int eval = alpha_beta(child, depth - 1, alpha, beta, false); max_eval = max(max_eval, eval); alpha = max(alpha, eval); if (beta <= alpha) { break; // Vágás } } return max_eval; } else { int min_eval = numeric_limits<int>::max(); for (Node* child : node->children) { int eval = alpha_beta(child, depth - 1, alpha, beta, true); min_eval = min(min_eval, eval); beta = min(beta, eval); if (beta <= alpha) { break; // Vágás } } return min_eval; } } int main() { // Példa játékfa Node* root = new Node(); root->children.push_back(new Node(3)); Node* branch1 = new Node(); branch1->children.push_back(new Node(5)); branch1->children.push_back(new Node(6)); root->children.push_back(branch1); Node* branch2 = new Node(); branch2->children.push_back(new Node(7)); branch2->children.push_back(new Node(4)); root->children.push_back(branch2); int result = alpha_beta(root, 3, numeric_limits<int>::min(), numeric_limits<int>::max(), true); cout << "Legjobb érték: " << result << endl; return 0; }</syntaxhighlight> '''Kimenet:''' <pre>Legjobb érték: 7</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === <span id="előnyök"></span> ==== '''Előnyök''': ==== # '''Gyorsabb keresés''': Jelentősen csökkenti a minimax keresési tér méretét. # '''Optimalizáció''': Ugyanazt az eredményt adja, mint a minimax, de hatékonyabb. <span id="hátrányok"></span> ==== '''Hátrányok''': ==== # '''Sorrend befolyásolhatja a teljesítményt''': Az optimális csomópontsorrend maximalizálja az alfa-béta vágás hatékonyságát. # '''Komplexitás''': Implementációja bonyolultabb, mint a tiszta minimaxé. Az '''alfa-béta vágás''' kulcsfontosságú a mesterséges intelligenciában, különösen kétjátékos stratégiai játékok fejlesztésekor (pl. sakk, dáma, amőba). {{-ford-}} {{trans-top}} *{{en}}: {{t+|en|alpha-beta pruning}} {{trans-bottom}} {{hunl}} ta0mg7rit9iaoj6erosvretl4ie9ng1 0 782802 3479598 3451215 2024-12-13T00:02:15Z LinguisticMystic 22848 3479598 wikitext text/x-wiki {{engfn}} # {{label|en|matematika}} [[Quine-McCluskey-algoritmus]] {{engl}} 9sbsruai639b8c95rni9hvk3ee1s2t5 3479599 3479598 2024-12-13T00:02:23Z LinguisticMystic 22848 LinguisticMystic átnevezte a(z) [[Quine–McCluskey algorithm]] lapot a következő névre: [[Quine-McCluskey algorithm]] 3479598 wikitext text/x-wiki {{engfn}} # {{label|en|matematika}} [[Quine-McCluskey-algoritmus]] {{engl}} 9sbsruai639b8c95rni9hvk3ee1s2t5 0 783654 3479595 3453520 2024-12-13T00:01:06Z LinguisticMystic 22848 3479595 wikitext text/x-wiki {{engfn}} # {{label|en|informatika}} [[Las Vegas-algoritmus]] {{engl}} 41s8tqna9wxa3bizghq2462e7va0hgl 0 783655 3479490 3453521 2024-12-12T21:37:26Z LinguisticMystic 22848 3479490 wikitext text/x-wiki {{engfn}} # {{label|en|informatika|algo}} [[Bellman-Ford-algoritmus]] {{engl}} 9lr2ddvdes3wdfm1tx0z4esjobqujcq 0 783698 3479501 3453632 2024-12-12T21:45:42Z LinguisticMystic 22848 3479501 wikitext text/x-wiki {{engfn}} # {{label|en|informatika|algo}} [[?]] {{engl}} pj2blpcp971v8nrrmi8ilemi2c31ewi 3479507 3479501 2024-12-12T21:51:37Z LinguisticMystic 22848 3479507 wikitext text/x-wiki {{engfn}} # {{label|en|informatika|algo}} A **AES (Advanced Encryption Standard)** egy szimmetrikus kulcsú titkosítási algoritmus, amelyet széles körben használnak adatvédelemre. Az AES-t az amerikai NIST (National Institute of Standards and Technology) fejlesztette ki a DES (Data Encryption Standard) utódjaként. --- ### **Fő jellemzők** 1. **Blokk titkosítás**: - Az AES rögzített méretű 128 bites (16 bájtos) blokkokkal dolgozik. - A bemeneti adatot blokkokra osztja, és minden blokkot külön-külön titkosít. 2. **Kulcsméretek**: - Támogatott kulcsméretek: **128-bit**, **192-bit**, és **256-bit**. - A kulcsméret meghatározza a titkosítási körök számát: - **10 kör**: 128 bites kulcs esetén. - **12 kör**: 192 bites kulcs esetén. - **14 kör**: 256 bites kulcs esetén. 3. **Biztonság**: - Az AES biztonsága a matematikai nehézségen (pl. S-box, keverési lépések) alapul. - Jelenleg nincs ismert hatékony támadás, amely feltörné a teljes 256 bites AES-t. 4. **Alkalmazási területek**: - HTTPS/TLS kapcsolat titkosítása. - VPN-ek, fájl titkosítás, adattárolás. --- ### **AES struktúra** Az AES algoritmus egy iteratív blokktitkosító algoritmus, amely négy alapvető lépésből áll minden körben: #### **1. SubBytes** (Csere): - Egy nemlineáris S-box segítségével minden bájt átalakítása. #### **2. ShiftRows** (Sor eltolás): - A mátrix második, harmadik és negyedik sorát eltoljuk különböző mértékben. #### **3. MixColumns** (Oszlopkeverés): - Lineáris transzformáció az oszlopokon. #### **4. AddRoundKey** (Körkulcs hozzáadása): - A jelenlegi blokk XOR művelettel történő kombinálása a körhöz tartozó kulccsal. #### **Kezdeti kulcshozzáadás**: - Az első kör előtt egy XOR művelet történik a bemeneti blokkal és a kezdő kulccsal. #### **Utolsó kör**: - A végső körben a **MixColumns** lépés kimarad. --- ### **Pszeudokód** ``` AES(plain_text, key): key_schedule = KeyExpansion(key) state = plain_text XOR key_schedule[0] for round = 1 to N-1: SubBytes(state) ShiftRows(state) MixColumns(state) AddRoundKey(state, key_schedule[round]) SubBytes(state) ShiftRows(state) AddRoundKey(state, key_schedule[N]) return state ``` --- ### **Python implementáció** Az alábbi implementáció bemutatja az AES algoritmus alapvető működését: ```python from Crypto.Cipher import AES from Crypto.Util.Padding import pad, unpad from Crypto.Random import get_random_bytes # Titkosítás def aes_encrypt(plain_text, key): cipher = AES.new(key, AES.MODE_CBC) # CBC mód ct_bytes = cipher.encrypt(pad(plain_text.encode(), AES.block_size)) return cipher.iv, ct_bytes # Visszafejtés def aes_decrypt(iv, cipher_text, key): cipher = AES.new(key, AES.MODE_CBC, iv) pt = unpad(cipher.decrypt(cipher_text), AES.block_size) return pt.decode() # Példa használat key = get_random_bytes(16) # 128 bites kulcs plain_text = "Hello, AES titkosítás!" iv, cipher_text = aes_encrypt(plain_text, key) print("Titkosított szöveg:", cipher_text) decrypted_text = aes_decrypt(iv, cipher_text, key) print("Visszafejtett szöveg:", decrypted_text) ``` **Kimenet:** ``` Titkosított szöveg: b'...' Visszafejtett szöveg: Hello, AES titkosítás! ``` --- ### **C++ implementáció** A következő implementáció a **Crypto++** könyvtárat használja: ```cpp #include <iostream> #include <string> #include <cryptopp/aes.h> #include <cryptopp/modes.h> #include <cryptopp/filters.h> #include <cryptopp/osrng.h> using namespace std; using namespace CryptoPP; string aes_encrypt(const string& plain_text, SecByteBlock& key, SecByteBlock& iv) { string cipher_text; // Titkosítás CBC_Mode<AES>::Encryption encryptor; encryptor.SetKeyWithIV(key, key.size(), iv); StringSource(plain_text, true, new StreamTransformationFilter(encryptor, new StringSink(cipher_text))); return cipher_text; } string aes_decrypt(const string& cipher_text, SecByteBlock& key, SecByteBlock& iv) { string plain_text; // Visszafejtés CBC_Mode<AES>::Decryption decryptor; decryptor.SetKeyWithIV(key, key.size(), iv); StringSource(cipher_text, true, new StreamTransformationFilter(decryptor, new StringSink(plain_text))); return plain_text; } int main() { AutoSeededRandomPool prng; // Kulcs és IV létrehozása SecByteBlock key(AES::DEFAULT_KEYLENGTH); SecByteBlock iv(AES::BLOCKSIZE); prng.GenerateBlock(key, key.size()); prng.GenerateBlock(iv, iv.size()); string plain_text = "Hello, AES titkosítás!"; cout << "Eredeti szöveg: " << plain_text << endl; // Titkosítás string cipher_text = aes_encrypt(plain_text, key, iv); cout << "Titkosított szöveg: " << cipher_text << endl; // Visszafejtés string decrypted_text = aes_decrypt(cipher_text, key, iv); cout << "Visszafejtett szöveg: " << decrypted_text << endl; return 0; } ``` **Kimenet:** ``` Eredeti szöveg: Hello, AES titkosítás! Titkosított szöveg: ... Visszafejtett szöveg: Hello, AES titkosítás! ``` --- ### **Összegzés** #### **Előnyök**: 1. **Biztonságos**: AES a modern szabvány, amely ellenáll a legtöbb támadásnak. 2. **Gyors**: Hatékony hardveres és szoftveres implementációk. 3. **Rugalmasság**: Támogatja a 128, 192 és 256 bites kulcsokat. #### **Hátrányok**: 1. **Statikus blokk hossz**: Minden adatot 16 bájtos blokkokban kell kezelni. 2. **Kulcs menedzsment**: A szimmetrikus kulcsok biztonságos tárolása és megosztása problémás lehet. Az AES-t széles körben használják biztonságos kommunikációhoz, adattitkosításhoz és adatvédelemhez. Számos könyvtár és eszköz biztosít gyors és könnyen használható implementációkat Pythonban és C++-ban is. {{engl}} 6692xza2h7skw513soe09wr9jgbos3e 3479508 3479507 2024-12-12T21:52:00Z LinguisticMystic 22848 3479508 wikitext text/x-wiki {{engfn}} # {{label|en|informatika|algo}} A '''AES (Advanced Encryption Standard)''' egy szimmetrikus kulcsú titkosítási algoritmus, amelyet széles körben használnak adatvédelemre. Az AES-t az amerikai NIST (National Institute of Standards and Technology) fejlesztette ki a DES (Data Encryption Standard) utódjaként. ----- <span id="fő-jellemzők"></span> === '''Fő jellemzők''' === # '''Blokk titkosítás''': #* Az AES rögzített méretű 128 bites (16 bájtos) blokkokkal dolgozik. #* A bemeneti adatot blokkokra osztja, és minden blokkot külön-külön titkosít. # '''Kulcsméretek''': #* Támogatott kulcsméretek: '''128-bit''', '''192-bit''', és '''256-bit'''. #* A kulcsméret meghatározza a titkosítási körök számát: #** '''10 kör''': 128 bites kulcs esetén. #** '''12 kör''': 192 bites kulcs esetén. #** '''14 kör''': 256 bites kulcs esetén. # '''Biztonság''': #* Az AES biztonsága a matematikai nehézségen (pl. S-box, keverési lépések) alapul. #* Jelenleg nincs ismert hatékony támadás, amely feltörné a teljes 256 bites AES-t. # '''Alkalmazási területek''': #* HTTPS/TLS kapcsolat titkosítása. #* VPN-ek, fájl titkosítás, adattárolás. ----- <span id="aes-struktúra"></span> === '''AES struktúra''' === Az AES algoritmus egy iteratív blokktitkosító algoritmus, amely négy alapvető lépésből áll minden körben: <span id="subbytes-csere"></span> ==== '''1. SubBytes''' (Csere): ==== * Egy nemlineáris S-box segítségével minden bájt átalakítása. <span id="shiftrows-sor-eltolás"></span> ==== '''2. ShiftRows''' (Sor eltolás): ==== * A mátrix második, harmadik és negyedik sorát eltoljuk különböző mértékben. <span id="mixcolumns-oszlopkeverés"></span> ==== '''3. MixColumns''' (Oszlopkeverés): ==== * Lineáris transzformáció az oszlopokon. <span id="addroundkey-körkulcs-hozzáadása"></span> ==== '''4. AddRoundKey''' (Körkulcs hozzáadása): ==== * A jelenlegi blokk XOR művelettel történő kombinálása a körhöz tartozó kulccsal. <span id="kezdeti-kulcshozzáadás"></span> ==== '''Kezdeti kulcshozzáadás''': ==== * Az első kör előtt egy XOR művelet történik a bemeneti blokkal és a kezdő kulccsal. <span id="utolsó-kör"></span> ==== '''Utolsó kör''': ==== * A végső körben a '''MixColumns''' lépés kimarad. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>AES(plain_text, key): key_schedule = KeyExpansion(key) state = plain_text XOR key_schedule[0] for round = 1 to N-1: SubBytes(state) ShiftRows(state) MixColumns(state) AddRoundKey(state, key_schedule[round]) SubBytes(state) ShiftRows(state) AddRoundKey(state, key_schedule[N]) return state</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === Az alábbi implementáció bemutatja az AES algoritmus alapvető működését: <syntaxhighlight lang="python">from Crypto.Cipher import AES from Crypto.Util.Padding import pad, unpad from Crypto.Random import get_random_bytes # Titkosítás def aes_encrypt(plain_text, key): cipher = AES.new(key, AES.MODE_CBC) # CBC mód ct_bytes = cipher.encrypt(pad(plain_text.encode(), AES.block_size)) return cipher.iv, ct_bytes # Visszafejtés def aes_decrypt(iv, cipher_text, key): cipher = AES.new(key, AES.MODE_CBC, iv) pt = unpad(cipher.decrypt(cipher_text), AES.block_size) return pt.decode() # Példa használat key = get_random_bytes(16) # 128 bites kulcs plain_text = "Hello, AES titkosítás!" iv, cipher_text = aes_encrypt(plain_text, key) print("Titkosított szöveg:", cipher_text) decrypted_text = aes_decrypt(iv, cipher_text, key) print("Visszafejtett szöveg:", decrypted_text)</syntaxhighlight> '''Kimenet:''' <pre>Titkosított szöveg: b'...' Visszafejtett szöveg: Hello, AES titkosítás!</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === A következő implementáció a '''Crypto++''' könyvtárat használja: <syntaxhighlight lang="cpp">#include <iostream> #include <string> #include <cryptopp/aes.h> #include <cryptopp/modes.h> #include <cryptopp/filters.h> #include <cryptopp/osrng.h> using namespace std; using namespace CryptoPP; string aes_encrypt(const string& plain_text, SecByteBlock& key, SecByteBlock& iv) { string cipher_text; // Titkosítás CBC_Mode<AES>::Encryption encryptor; encryptor.SetKeyWithIV(key, key.size(), iv); StringSource(plain_text, true, new StreamTransformationFilter(encryptor, new StringSink(cipher_text))); return cipher_text; } string aes_decrypt(const string& cipher_text, SecByteBlock& key, SecByteBlock& iv) { string plain_text; // Visszafejtés CBC_Mode<AES>::Decryption decryptor; decryptor.SetKeyWithIV(key, key.size(), iv); StringSource(cipher_text, true, new StreamTransformationFilter(decryptor, new StringSink(plain_text))); return plain_text; } int main() { AutoSeededRandomPool prng; // Kulcs és IV létrehozása SecByteBlock key(AES::DEFAULT_KEYLENGTH); SecByteBlock iv(AES::BLOCKSIZE); prng.GenerateBlock(key, key.size()); prng.GenerateBlock(iv, iv.size()); string plain_text = "Hello, AES titkosítás!"; cout << "Eredeti szöveg: " << plain_text << endl; // Titkosítás string cipher_text = aes_encrypt(plain_text, key, iv); cout << "Titkosított szöveg: " << cipher_text << endl; // Visszafejtés string decrypted_text = aes_decrypt(cipher_text, key, iv); cout << "Visszafejtett szöveg: " << decrypted_text << endl; return 0; }</syntaxhighlight> '''Kimenet:''' <pre>Eredeti szöveg: Hello, AES titkosítás! Titkosított szöveg: ... Visszafejtett szöveg: Hello, AES titkosítás!</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === <span id="előnyök"></span> ==== '''Előnyök''': ==== # '''Biztonságos''': AES a modern szabvány, amely ellenáll a legtöbb támadásnak. # '''Gyors''': Hatékony hardveres és szoftveres implementációk. # '''Rugalmasság''': Támogatja a 128, 192 és 256 bites kulcsokat. <span id="hátrányok"></span> ==== '''Hátrányok''': ==== # '''Statikus blokk hossz''': Minden adatot 16 bájtos blokkokban kell kezelni. # '''Kulcs menedzsment''': A szimmetrikus kulcsok biztonságos tárolása és megosztása problémás lehet. Az AES-t széles körben használják biztonságos kommunikációhoz, adattitkosításhoz és adatvédelemhez. Számos könyvtár és eszköz biztosít gyors és könnyen használható implementációkat Pythonban és C++-ban is. {{engl}} 2qofny24hirquifrsh0cyfwe564nfdx 2 795373 3479373 3474784 2024-12-12T13:10:21Z LinguisticMystic 22848 A lap tartalmának cseréje erre: {{subst:redir|Szerkesztő:LinguisticMystic}} 3479373 wikitext text/x-wiki #redirect [[Szerkesztő:LinguisticMystic]] l1dup727f1rv1a1gb5jnnixt3157l3w 2 795420 3479370 3474909 2024-12-12T13:09:43Z LinguisticMystic 22848 A lap tartalmának cseréje erre: {{subst:redir|Szerkesztő:LinguisticMystic}} 3479370 wikitext text/x-wiki #redirect [[Szerkesztő:LinguisticMystic]] l1dup727f1rv1a1gb5jnnixt3157l3w 2 795421 3479377 3478063 2024-12-12T13:22:00Z LinguisticMystic 22848 Átirányítás ide: [[Szerkesztő:LinguisticMystic]] 3479377 wikitext text/x-wiki #redirect [[Szerkesztő:LinguisticMystic]] l1dup727f1rv1a1gb5jnnixt3157l3w 2 795422 3479371 3474912 2024-12-12T13:09:49Z LinguisticMystic 22848 A lap tartalmának cseréje erre: {{subst:redir|Szerkesztő:LinguisticMystic}} 3479371 wikitext text/x-wiki #redirect [[Szerkesztő:LinguisticMystic]] l1dup727f1rv1a1gb5jnnixt3157l3w 2 795438 3479379 3478341 2024-12-12T13:22:30Z LinguisticMystic 22848 Átirányítás ide: [[Szerkesztő:LinguisticMystic]] 3479379 wikitext text/x-wiki #redirect [[Szerkesztő:LinguisticMystic]] l1dup727f1rv1a1gb5jnnixt3157l3w 2 795637 3479365 3478074 2024-12-12T13:07:47Z LinguisticMystic 22848 3479365 wikitext text/x-wiki #redirect [[Szerkesztő:LinguisticMystic]] l1dup727f1rv1a1gb5jnnixt3157l3w 2 795646 3479359 3478351 2024-12-12T13:06:53Z LinguisticMystic 22848 A lap tartalmának cseréje erre: {{subst:redir|Szerkesztő:LinguisticMystic}} 3479359 wikitext text/x-wiki #redirect [[Szerkesztő:LinguisticMystic]] l1dup727f1rv1a1gb5jnnixt3157l3w 2 795647 3479368 3478350 2024-12-12T13:09:04Z LinguisticMystic 22848 A lap tartalmának cseréje erre: {{subst:redir|Szerkesztő:LinguisticMystic}} 3479368 wikitext text/x-wiki #redirect [[Szerkesztő:LinguisticMystic]] l1dup727f1rv1a1gb5jnnixt3157l3w 2 795648 3479369 3478358 2024-12-12T13:09:12Z LinguisticMystic 22848 A lap tartalmának cseréje erre: {{subst:redir|Szerkesztő:LinguisticMystic}} 3479369 wikitext text/x-wiki #redirect [[Szerkesztő:LinguisticMystic]] l1dup727f1rv1a1gb5jnnixt3157l3w 2 795649 3479367 3478439 2024-12-12T13:08:09Z LinguisticMystic 22848 A lap tartalmának cseréje erre: {{subst:redir|Szerkesztő:LinguisticMystic}} 3479367 wikitext text/x-wiki #redirect [[Szerkesztő:LinguisticMystic]] l1dup727f1rv1a1gb5jnnixt3157l3w 2 795650 3479366 3478354 2024-12-12T13:07:56Z LinguisticMystic 22848 A lap tartalmának cseréje erre: {{subst:redir|Szerkesztő:LinguisticMystic}} 3479366 wikitext text/x-wiki #redirect [[Szerkesztő:LinguisticMystic]] l1dup727f1rv1a1gb5jnnixt3157l3w 2 795651 3479364 3478360 2024-12-12T13:07:39Z LinguisticMystic 22848 A lap tartalmának cseréje erre: {{subst:redir|Szerkesztő:LinguisticMystic}} 3479364 wikitext text/x-wiki #redirect [[Szerkesztő:LinguisticMystic]] l1dup727f1rv1a1gb5jnnixt3157l3w 2 795652 3479362 3478359 2024-12-12T13:07:17Z LinguisticMystic 22848 A lap tartalmának cseréje erre: {{subst:redir|Szerkesztő:LinguisticMystic}} 3479362 wikitext text/x-wiki #redirect [[Szerkesztő:LinguisticMystic]] l1dup727f1rv1a1gb5jnnixt3157l3w 2 795653 3479363 3478353 2024-12-12T13:07:22Z LinguisticMystic 22848 A lap tartalmának cseréje erre: {{subst:redir|Szerkesztő:LinguisticMystic}} 3479363 wikitext text/x-wiki #redirect [[Szerkesztő:LinguisticMystic]] l1dup727f1rv1a1gb5jnnixt3157l3w 2 795654 3479360 3478352 2024-12-12T13:07:01Z LinguisticMystic 22848 A lap tartalmának cseréje erre: {{subst:redir|Szerkesztő:LinguisticMystic}} 3479360 wikitext text/x-wiki #redirect [[Szerkesztő:LinguisticMystic]] l1dup727f1rv1a1gb5jnnixt3157l3w 2 795655 3479361 3478349 2024-12-12T13:07:06Z LinguisticMystic 22848 A lap tartalmának cseréje erre: {{subst:redir|Szerkesztő:LinguisticMystic}} 3479361 wikitext text/x-wiki #redirect [[Szerkesztő:LinguisticMystic]] l1dup727f1rv1a1gb5jnnixt3157l3w 2 795668 3479378 3478039 2024-12-12T13:22:18Z LinguisticMystic 22848 Átirányítás ide: [[Szerkesztő:LinguisticMystic]] 3479378 wikitext text/x-wiki #redirect [[Szerkesztő:LinguisticMystic]] l1dup727f1rv1a1gb5jnnixt3157l3w 0 798276 3479503 3478806 2024-12-12T21:48:43Z LinguisticMystic 22848 3479503 wikitext text/x-wiki {{hunfn}} # {{label|hu|informatika|algo}} {{-ford-}} {{trans-top}} *{{en}}: {{t+|en|Diffie–Hellman key exchange}} {{trans-bottom}} {{hunl}} q4z1cdgi44t49xt9ln1ujf6t3rkonf4 3479504 3479503 2024-12-12T21:49:08Z LinguisticMystic 22848 LinguisticMystic átnevezte a(z) [[Diffie–Hellman-kulcscsere]] lapot a következő névre: [[Diffie-Hellman-kulcscsere]] 3479503 wikitext text/x-wiki {{hunfn}} # {{label|hu|informatika|algo}} {{-ford-}} {{trans-top}} *{{en}}: {{t+|en|Diffie–Hellman key exchange}} {{trans-bottom}} {{hunl}} q4z1cdgi44t49xt9ln1ujf6t3rkonf4 3479509 3479504 2024-12-12T21:54:11Z LinguisticMystic 22848 3479509 wikitext text/x-wiki {{hunfn}} # {{label|hu|informatika|algo}} <span id="diffie-hellman-kulcscsere"></span> === '''Diffie-Hellman-kulcscsere''' === A '''Diffie-Hellman-kulcscsere''' egy kriptográfiai protokoll, amely lehetővé teszi két fél számára, hogy nyilvános kommunikációs csatornán keresztül közös titkos kulcsot hozzanak létre. Ez a kulcs később szimmetrikus titkosításhoz használható. A módszer a moduláris aritmetika nehézségein (diszkrét logaritmus problémán) alapul. ----- <span id="elmélet"></span> === '''Elmélet''' === <span id="protokoll-lépései"></span> ==== '''Protokoll lépései''' ==== # '''Közös nyilvános paraméterek''': #* (p): Nagy prímszám. #* (g): Generátor (alap), amely (p) modulo rendszere szerint működik. # '''Privát kulcsok''': #* Mindkét fél (pl. Alice és Bob) választ egy-egy véletlenszerű '''privát kulcsot''': #** Alice: (a), Bob: (b). # '''Nyilvános kulcsok kiszámítása''': #* Alice kiszámítja (A = g^a p)-t, és elküldi Bobnak. #* Bob kiszámítja (B = g^b p)-t, és elküldi Alice-nek. # '''Közös kulcs létrehozása''': #* Alice kiszámítja a közös kulcsot: (K = B^a p). #* Bob kiszámítja a közös kulcsot: (K = A^b p). Mindkét fél ugyanazt a közös kulcsot kapja, mert: [ K = g^{ab} p ] <span id="biztonság-alapja"></span> ==== '''Biztonság alapja''' ==== * Egy támadónak, aki csak (A), (B), (g), és (p) értékeit ismeri, meg kellene oldania a '''diszkrét logaritmus problémát''', amely nehéz nagy számok esetén. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>DiffieHellman(p, g): Alice privát kulcsa: a (véletlenszerű szám) Bob privát kulcsa: b (véletlenszerű szám) Alice nyilvános kulcsa: A = g^a mod p Bob nyilvános kulcsa: B = g^b mod p Alice közös kulcsa: K = B^a mod p Bob közös kulcsa: K = A^b mod p térj vissza K</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">import random def diffie_hellman(p, g): # Alice privát kulcsa a = random.randint(1, p - 1) # Bob privát kulcsa b = random.randint(1, p - 1) # Alice nyilvános kulcsa A = pow(g, a, p) # Bob nyilvános kulcsa B = pow(g, b, p) # Közös kulcsok shared_key_alice = pow(B, a, p) shared_key_bob = pow(A, b, p) return shared_key_alice, shared_key_bob, A, B # Példa paraméterek p = 23 # Prímszám g = 5 # Generátor shared_key_alice, shared_key_bob, A, B = diffie_hellman(p, g) print(f"Alice közös kulcsa: {shared_key_alice}") print(f"Bob közös kulcsa: {shared_key_bob}") print(f"Alice nyilvános kulcsa: {A}") print(f"Bob nyilvános kulcsa: {B}")</syntaxhighlight> '''Kimenet:''' <pre>Alice közös kulcsa: 2 Bob közös kulcsa: 2 Alice nyilvános kulcsa: 8 Bob nyilvános kulcsa: 19</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <cmath> #include <cstdlib> #include <ctime> using namespace std; // Hatványozás modulo p long long mod_exp(long long base, long long exp, long long mod) { long long result = 1; base = base % mod; while (exp > 0) { if (exp % 2 == 1) { // Ha exp páratlan result = (result * base) % mod; } exp = exp >> 1; // exp = exp / 2 base = (base * base) % mod; } return result; } void diffie_hellman(long long p, long long g) { srand(time(0)); // Alice privát kulcsa long long a = rand() % (p - 1) + 1; // Bob privát kulcsa long long b = rand() % (p - 1) + 1; // Alice nyilvános kulcsa long long A = mod_exp(g, a, p); // Bob nyilvános kulcsa long long B = mod_exp(g, b, p); // Közös kulcsok long long shared_key_alice = mod_exp(B, a, p); long long shared_key_bob = mod_exp(A, b, p); cout << "Alice közös kulcsa: " << shared_key_alice << endl; cout << "Bob közös kulcsa: " << shared_key_bob << endl; cout << "Alice nyilvános kulcsa: " << A << endl; cout << "Bob nyilvános kulcsa: " << B << endl; } int main() { long long p = 23; // Prímszám long long g = 5; // Generátor diffie_hellman(p, g); return 0; }</syntaxhighlight> '''Kimenet:''' <pre>Alice közös kulcsa: 2 Bob közös kulcsa: 2 Alice nyilvános kulcsa: 8 Bob nyilvános kulcsa: 19</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === <span id="előnyök"></span> ==== '''Előnyök''': ==== # '''Biztonságos''': Nyilvános csatornán keresztül biztonságosan cserél kulcsot. # '''Egyszerű és hatékony''': Matematikailag megalapozott, könnyen implementálható. <span id="hátrányok"></span> ==== '''Hátrányok''': ==== # '''Man-in-the-middle támadás''': Ha a csatorna nem hitelesített, támadó közbeékelődhet. # '''Kvantum számítógépek fenyegetése''': A Shor-algoritmus fenyegetheti a diszkrét logaritmus problémát. A '''Diffie-Hellman-kulcscsere''' az egyik legfontosabb kriptográfiai protokoll, amely a modern biztonságos kommunikáció alapját képezi. {{-ford-}} {{trans-top}} *{{en}}: {{t+|en|Diffie–Hellman key exchange}} {{trans-bottom}} {{hunl}} g8xtsn6s8ks4vxj3pewcicm2a7k8mmr 2 798496 3479412 3479281 2024-12-12T17:09:32Z LinguisticMystic 22848 3479412 wikitext text/x-wiki [[adatbázis-kezelő rendszerek]] [[adatstruktúrák és algoritmusok]] [[digitális rendszerek és számítógép architektúrák]] [[digitális technika]] [[lineáris algebra]] [[operációkutatás]] [[operációs rendszerek]] [[programozás]] [[számítógép hálózatok]] [[számítógép-architektúrák]] 78e94lv7ywg2jawpfuqk607ysweedqt 2 798568 3479380 2024-12-12T13:24:24Z LinguisticMystic 22848 Új oldal, tartalma: „[[/wikipédia]]” 3479380 wikitext text/x-wiki [[/wikipédia]] 9m88z5nhs0j341b5qaae5a2z8d2ropk 2 798569 3479381 2024-12-12T13:29:23Z LinguisticMystic 22848 Új oldal, tartalma: „[[(a, b)-felbontás]] [[(a, b)-felbontás]] [[1-síkbarajzolható gráf]] [[1-síkbarajzolható gráf]] [[2-3 fa]] [[2-3 fa]] [[3-reguláris gráf]] [[3-reguláris gráf]] [[4-reguláris gráf]] [[4-reguláris gráf]] [[A königsbergi hidak problémája]] [[a königsbergi hidak problémája]] [[Aalgoritmus]] [[aalgoritmus]] [[Albertson-sejtés]] [[albertson-sejtés]] [[Algebrai gráfelmélet]] [[algebrai gráfelmélet]] [[Almássy-féle ikozaéder]] almássy-fé…” 3479381 wikitext text/x-wiki [[(a, b)-felbontás]] [[(a, b)-felbontás]] [[1-síkbarajzolható gráf]] [[1-síkbarajzolható gráf]] [[2-3 fa]] [[2-3 fa]] [[3-reguláris gráf]] [[3-reguláris gráf]] [[4-reguláris gráf]] [[4-reguláris gráf]] [[A königsbergi hidak problémája]] [[a königsbergi hidak problémája]] [[Aalgoritmus]] [[aalgoritmus]] [[Albertson-sejtés]] [[albertson-sejtés]] [[Algebrai gráfelmélet]] [[algebrai gráfelmélet]] [[Almássy-féle ikozaéder]] [[almássy-féle ikozaéder]] [[Andrásfai-gráf]] [[andrásfai-gráf]] [[Aperiodikus gráf]] [[aperiodikus gráf]] [[Arboricitás]] [[arboricitás]] [[aszimmetrikus gráf]] [[Aszimmetrikus gráf]] [[AVL-fa]] [[avl-fa]] [[az utazó ügynök problémája]] [[Az utazó ügynök problémája]] [[Balgoritmus]] [[balgoritmus]] [[b-színezés]] [[B-színezés]] [[balinski-tétel]] [[Balinski-tétel]] [[Barabási–Albert-modell]] [[barabási–albert-modell]] [[Barnette-sejtés]] [[barnette-sejtés]] [[Behálózottsági együttható]] [[behálózottsági együttható]] [[Bellman–Ford-algoritmus]] [[bellman–ford-algoritmus]] [[Bethe-rács]] [[bethe-rács]] [[Biklikkmentes gráf]] [[biklikkmentes gráf]] [[Bireguláris gráf]] [[bireguláris gráf]] [[Blokkgráf]] [[blokkgráf]] [[Borůvka-algoritmus]] [[borůvka-algoritmus]] [[Boxicitás]] [[boxicitás]] [[Brooks-tétel]] [[brooks-tétel]] [[Burr–Erdős-sejtés]] [[burr–erdős-sejtés]] [[Bástyagráf]] [[bástyagráf]] [[Cage]] [[cage]] [[Cayley-formula]] [[cayley-formula]] [[Cayley-gráf]] [[cayley-gráf]] [[Cheeger-állandó]] [[cheeger-állandó]] [[Chvátal-tétel]] [[chvátal-tétel]] [[Cikkcakkszorzat]] [[cikkcakkszorzat]] [[Ciklikus rang]] [[ciklikus rang]] [[Cirkuláns gráf]] [[cirkuláns gráf]] [[Colin de Verdière-gráfinvariáns]] [[colin de verdière-gráfinvariáns]] [[Csillaggráf]] [[csillaggráf]] [[Csillagszínezés]] [[csillagszínezés]] [[Csúcs]] [[csúcs]] [[Csúcsgráf]] [[csúcsgráf]] [[Csúcstranzitív gráf]] [[csúcstranzitív gráf]] [[Cuthill–McKee-algoritmus]] [[cuthill–mckee-algoritmus]] [[Dalgoritmus]] [[dalgoritmus]] [[De Bruijn-gráf]] [[de bruijn-gráf]] [[De Bruijn–Erdős-tétel]] [[de bruijn–erdős-tétel]] [[Degeneráltság]] [[degeneráltság]] [[Dijkstra-algoritmus]] [[dijkstra-algoritmus]] [[Dilworth-tétel]] [[dilworth-tétel]] [[Dinitz-probléma]] [[dinitz-probléma]] [[Dipólusgráf]] [[dipólusgráf]] [[Duális gráf]] [[duális gráf]] [[döntési fa]] [[Döntési fa]] [[edmonds-algoritmus]] [[Edmonds-algoritmus]] [[egyenes élű síkgráf]] [[Egyenes élű síkgráf]] [[egységtávolsággráf]] [[Egységtávolsággráf]] [[Egységérmegráf]] [[egységérmegráf]] [[Egész spektrumú gráf]] [[egész spektrumú gráf]] [[ellenállás-távolság]] [[Ellenállás-távolság]] [[elméleti kémia]] [[Elméleti kémia]] [[elvágó csúcshalmaz]] [[Elvágó csúcshalmaz]] [[elválasztó él]] [[Elválasztó él]] [[elérhetőségi reláció]] [[Elérhetőségi reláció]] [[erdős-féle diofantoszi gráf]] [[Erdős-féle diofantoszi gráf]] [[erdős–faber–lovász-sejtés]] [[Erdős–Faber–Lovász-sejtés]] [[erdős–gyárfás-sejtés]] [[Erdős–Gyárfás-sejtés]] [[erdős–pósa-tétel]] [[Erdős–Pósa-tétel]] [[Erdős–Rényi-modell]] [[erdős–rényi-modell]] [[Erdős–Stone-tétel]] [[erdős–stone-tétel]] [[Erős színezés]] [[erős színezés]] [[Erősen reguláris gráf]] [[erősen reguláris gráf]] [[Erősen összefüggő komponens]] [[erősen összefüggő komponens]] [[euler-féle poliédertétel]] [[Euler-féle poliédertétel]] [[Euler-kör]] [[euler-kör]] [[Fa]] [[fa]] [[Fabejárás]] [[fabejárás]] [[faszélesség]] [[Faszélesség]] [[Ferdeszimmetrikus gráf]] [[ferdeszimmetrikus gráf]] [[feszített részgráf]] [[Feszített részgráf]] [[Feszített út]] [[feszített út]] [[Feszítőfa]] [[feszítőfa]] [[Fleischner-tétel]] [[fleischner-tétel]] [[Floyd–Warshall-algoritmus]] [[floyd–warshall-algoritmus]] [[Fokszám-átmérő probléma]] [[fokszám-átmérő probléma]] [[Fokszám]] [[fokszám]] [[Fokszámeloszlás]] [[fokszámeloszlás]] [[Futógráf]] [[futógráf]] [[Fáry-tétel]] [[fáry-tétel]] [[Félszimmetrikus gráf]] [[félszimmetrikus gráf]] [[Féltranzitív gráf]] [[féltranzitív gráf]] [[Független csúcshalmaz]] [[független csúcshalmaz]] [[Gallai-tétel]] [[gallai-tétel]] [[Geometriai gráfelmélet]] [[geometriai gráfelmélet]] [[Girth]] [[girth]] [[Grinberg-tétel]] [[grinberg-tétel]] [[Gráf centruma]] [[gráf centruma]] [[Gráf erőssége]] [[gráf erőssége]] [[Gráf irányítása]] [[gráf irányítása]] [[Gráf szívóssága]] [[gráf szívóssága]] [[gráf transzponáltja]] [[Gráf transzponáltja]] [[Gráf]] [[gráf]] [[Gráfautomorfizmus]] [[gráfautomorfizmus]] [[Gráfbejárás]] [[gráfbejárás]] [[Gráfelmélet]] [[gráfelmélet]] [[Gráfelméleti fogalomtár]] [[gráfelméleti fogalomtár]] [[Gráfenergia]] [[gráfenergia]] [[Gráfhatvány]] [[gráfhatvány]] [[Gráfhomomorfizmus]] [[gráfhomomorfizmus]] [[Gráfizomorfizmus]] [[gráfizomorfizmus]] [[gráfművelet]] [[Gráfművelet]] [[Gráfok Descartes-szorzata]] [[gráfok descartes-szorzata]] [[Gráfok erős szorzata]] [[gráfok erős szorzata]] [[Gráfok gyökeres szorzata]] [[gráfok gyökeres szorzata]] [[Gráfok kanonikalizációja]] [[gráfok kanonikalizációja]] [[Gráfok leszámlálása]] [[gráfok leszámlálása]] [[Gráfok lexikografikus szorzata]] [[gráfok lexikografikus szorzata]] [[Gráfok moduláris szorzata]] [[gráfok moduláris szorzata]] [[Gráfok színezése]] [[gráfok színezése]] [[Gráfok tenzorszorzata]] [[gráfok tenzorszorzata]] [[gráfpolinom]] [[Gráfpolinom]] [[Gráfszendvics-probléma]] [[gráfszendvics-probléma]] [[Gráfszorzás]] [[gráfszorzás]] [[Gráftulajdonság]] [[gráftulajdonság]] [[Grötzsch-tétel]] [[grötzsch-tétel]] [[Gyufagráf]] [[gyufagráf]] [[Gyárfás–Sumner-sejtés]] [[gyárfás–sumner-sejtés]] [[Gyűrűs kocka]] [[gyűrűs kocka]] [[Hadwiger-sejtés]] [[hadwiger-sejtés]] [[hadwiger-szám]] [[Hadwiger-szám]] [[Hadwiger–Nelson-probléma]] [[hadwiger–nelson-probléma]] [[Halin-gráf]] [[halin-gráf]] [[Hall-tétel]] [[hall-tétel]] [[Hamilton-kör]] [[hamilton-kör]] [[Hamilton-út]] [[hamilton-út]] [[Harmonikus színezés]] [[harmonikus színezés]] [[Hasábgráf]] [[hasábgráf]] [[Havel–Hakimi-algoritmus]] [[havel–hakimi-algoritmus]] [[Henson-gráf]] [[henson-gráf]] [[Hernyógráf]] [[hernyógráf]] [[Hipergráf]] [[hipergráf]] [[Hiperkockagráf]] [[hiperkockagráf]] [[Hipohamiltoni gráf]] [[hipohamiltoni gráf]] [[Hoffman-tétel]] [[hoffman-tétel]] [[Holt-gráf]] [[holt-gráf]] [[Homogén gráf]] [[homogén gráf]] [[Huszárgráf]] [[huszárgráf]] [[Huszárvándorlás-probléma]] [[huszárvándorlás-probléma]] [[Három ház–három kút-probléma]] [[három ház–három kút-probléma]] [[Háromszögmentes gráf]] [[háromszögmentes gráf]] [[Húrmetszetgráf]] [[húrmetszetgráf]] [[Illeszkedési gráf]] [[illeszkedési gráf]] [[Illeszkedési mátrix]] [[illeszkedési mátrix]] [[Intervallumgráf]] [[intervallumgráf]] [[Irányított körmentes gráf]] [[irányított körmentes gráf]] [[Iteratív mélyítés Aalgoritmus]] [[iteratív mélyítés aalgoritmus]] [[Iteratívan mélyülő mélységi keresés]] [[iteratívan mélyülő mélységi keresés]] [[Johnson algoritmusa]] [[johnson algoritmusa]] [[K-fa]] [[k-fa]] [[K-szorosan élösszefüggő gráf]] [[k-szorosan élösszefüggő gráf]] [[K-szorosan összefüggő gráf]] [[k-szorosan összefüggő gráf]] [[Kaktuszgráf]] [[kaktuszgráf]] [[karommentes gráf]] [[Karommentes gráf]] [[kelmans–seymour-sejtés]] [[Kelmans–Seymour-sejtés]] [[kerékgráf]] [[Kerékgráf]] [[királygráf]] [[Királygráf]] [[Kisvilág-tulajdonság]] [[kisvilág-tulajdonság]] [[Klaszterezettség]] [[klaszterezettség]] [[Klasztergráf]] [[klasztergráf]] [[Klikk]] [[klikk]] [[Klikkszélesség]] [[klikkszélesség]] [[klikkösszeg]] [[Klikkösszeg]] [[kneser-gráf]] [[Kneser-gráf]] [[kográf]] [[Kográf]] [[kombinatorikus kémia]] [[Kombinatorikus kémia]] [[komplementer gráf]] [[Komplementer gráf]] [[komplementer színezés]] [[Komplementer színezés]] [[komplex hálózat]] [[Komplex hálózat]] [[konferenciagráf]] [[Konferenciagráf]] [[konferenciamátrix]] [[Konferenciamátrix]] [[Koronagráf]] [[koronagráf]] [[Kosaraju-algoritmus]] [[kosaraju-algoritmus]] [[kritikus gráf]] [[Kritikus gráf]] [[Kromatikus polinom]] [[kromatikus polinom]] [[Kruskal-algoritmus]] [[kruskal-algoritmus]] [[kuratowski-tétel]] [[Kuratowski-tétel]] [[kétirányú keresés]] [[Kétirányú keresés]] [[kétszeresen összefüggő gráf]] [[Kétszeresen összefüggő gráf]] [[kétszeresen összefüggő komponens]] [[Kétszeresen összefüggő komponens]] [[Kézfogás-lemma]] [[kézfogás-lemma]] [[kínaipostás-probléma]] [[Kínaipostás-probléma]] [[könyvbe ágyazás]] [[Könyvbe ágyazás]] [[Kör]] [[kör]] [[Körgráf]] [[körgráf]] [[Körlefogó csúcshalmaz]] [[körlefogó csúcshalmaz]] [[Körmátrix]] [[körmátrix]] [[Külsíkgráf]] [[külsíkgráf]] [[Küszöbgráf]] [[küszöbgráf]] [[Kőnig-lemma]] [[kőnig-lemma]] [[Kőnig-tétel]] [[kőnig-tétel]] [[Laman-gráf]] [[laman-gráf]] [[Legjobbat először keresés]] [[legjobbat először keresés]] [[Legközelebbi szomszéd-gráf]] [[legközelebbi szomszéd-gráf]] [[Lekötött gráf]] [[lekötött gráf]] [[Levélhatvány]] [[levélhatvány]] [[Lexikográfiai szélességi keresés]] [[lexikográfiai szélességi keresés]] [[Lineáris arboricitás]] [[lineáris arboricitás]] [[Lineáris erdő]] [[lineáris erdő]] [[Lista-élszínezés]] [[lista-élszínezés]] [[Listaszínezés]] [[listaszínezés]] [[Lovász-sejtés]] [[lovász-sejtés]] [[Láncmentes beágyazás]] [[láncmentes beágyazás]] [[létragráf]] [[Létragráf]] [[magyar módszer]] [[Magyar módszer]] [[maximális folyam – minimális vágás]] [[Maximális folyam – minimális vágás]] [[maximális független csúcshalmaz]] [[Maximális független csúcshalmaz]] [[maximális áramlási probléma]] [[Maximális áramlási probléma]] [[mediángráf]] [[Mediángráf]] [[megosztásos-keveréses szintézis]] [[Megosztásos-keveréses szintézis]] [[Menger-tétel]] [[menger-tétel]] [[merev körű gráf]] [[Merev körű gráf]] [[merev körű kiegészítés]] [[Merev körű kiegészítés]] [[merkle-fa]] [[Merkle-fa]] [[metszetgráf]] [[Metszetgráf]] [[metszési szám]] [[Metszési szám]] [[minimax elv]] [[Minimax elv]] [[minimális feszítőfa]] [[Minimális feszítőfa]] [[Minor]] [[minor]] [[Multigráf]] [[multigráf]] [[Mycielski-konstrukció]] [[mycielski-konstrukció]] [[Mélységi keresés]] [[mélységi keresés]] [[Möbius-létra]] [[möbius-létra]] [[Négyszín-tétel]] [[négyszín-tétel]] [[Négyszöggráf]] [[négyszöggráf]] [[Ore-tétel]] [[ore-tétel]] [[Pach János]] [[pach jános]] [[Palacsintagráf]] [[palacsintagráf]] [[Paley-gráf]] [[paley-gráf]] [[Paritásgráf]] [[paritásgráf]] [[Peremkeresés]] [[peremkeresés]] [[Perfekt gráf]] [[perfekt gráf]] [[Periferikus kör]] [[periferikus kör]] [[Petersen-gráf]] [[petersen-gráf]] [[Pillangógráf]] [[pillangógráf]] [[Piros-fekete fa]] [[piros-fekete fa]] [[Poliédergráf]] [[poliédergráf]] [[Prim-algoritmus]] [[prim-algoritmus]] [[Prüfer-kód]] [[prüfer-kód]] [[pszeudoerdő]] [[Pszeudoerdő]] [[Pánciklikus gráf]] [[pánciklikus gráf]] [[Páros gráf fele]] [[páros gráf fele]] [[Páros gráf]] [[páros gráf]] [[Párosítás-kizárási szám]] [[párosítás-kizárási szám]] [[Párosítás]] [[párosítás]] [[pósa-tétel]] [[Pósa-tétel]] [[Ramsey-tétel]] [[ramsey-tétel]] [[Reguláris gráf]] [[reguláris gráf]] [[Rácsgráf]] [[rácsgráf]] [[Részszínezés]] [[részszínezés]] [[rövidségi kitevő]] [[Rövidségi kitevő]] [[Sekély minor]] [[sekély minor]] [[Skálafüggetlen hálózat]] [[skálafüggetlen hálózat]] [[smaalgoritmus]] [[SMAalgoritmus]] [[solymosi józsef (matematikus)]] [[Solymosi József (matematikus)]] [[Soros-párhuzamos gráf]] [[soros-párhuzamos gráf]] [[Spektrális gráfelmélet]] [[spektrális gráfelmélet]] [[sperner-lemma]] [[Sperner-lemma]] [[split gráf]] [[Split gráf]] [[szemerédi-féle regularitási lemma]] [[Szemerédi-féle regularitási lemma]] [[szimmetrikus gráf]] [[Szimmetrikus gráf]] [[szomszédság]] [[Szomszédság]] [[szomszédsági mátrix]] [[Szomszédsági mátrix]] [[Szubhamiltoni gráf]] [[szubhamiltoni gráf]] [[szélességi bejárás]] [[Szélességi bejárás]] [[síkbarajzolható gráf]] [[Síkbarajzolható gráf]] [[síkbarajzolhatóság tesztelése]] [[Síkbarajzolhatóság tesztelése]] [[Síkgráf-elválasztási tétel]] [[síkgráf-elválasztási tétel]] [[Sűrű gráf]] [[sűrű gráf]] [[Tait gráfelméleti sejtése]] [[tait gráfelméleti sejtése]] [[Tapasztalati képlet (kémia)]] [[tapasztalati képlet (kémia)]] [[tardos-függvény]] [[Tardos-függvény]] [[tarjan erősen összefüggő komponensek algoritmusa]] [[Tarjan erősen összefüggő komponensek algoritmusa]] [[teljes gráf]] [[Teljes gráf]] [[teljes páros gráf]] [[Teljes páros gráf]] [[teljes színezés]] [[Teljes színezés]] [[Testháló]] [[testháló]] [[Thue-szám]] [[thue-szám]] [[Tiltott gráfok szerinti osztályozás]] [[tiltott gráfok szerinti osztályozás]] [[Topologikus gráfelmélet]] [[topologikus gráfelmélet]] [[Topologikus izomorfia]] [[topologikus izomorfia]] [[Topologikus sorrend]] [[topologikus sorrend]] [[Totális színezés]] [[totális színezés]] [[Turán-gráf]] [[turán-gráf]] [[Turán-szám]] [[turán-szám]] [[Turán-tétel]] [[turán-tétel]] [[Tutte-tétel]] [[tutte-tétel]] [[Távolság-örökletes gráf]] [[távolság-örökletes gráf]] [[távolság]] [[Távolság]] [[Távolságreguláris gráf]] [[távolságreguláris gráf]] [[Távolságtranzitív gráf]] [[távolságtranzitív gráf]] [[Térképgráf]] [[térképgráf]] [[Tóruszra rajzolható gráf]] [[tóruszra rajzolható gráf]] [[Többrészes gráf]] [[többrészes gráf]] [[Ugrópontkeresés]] [[ugrópontkeresés]] [[Univerzális csúcs]] [[univerzális csúcs]] [[Univerzális gráf]] [[univerzális gráf]] [[Vastagság]] [[vastagság]] [[vezérgráf]] [[Vezérgráf]] [[Vizing-tétel]] [[vizing-tétel]] [[Vágásmátrix]] [[vágásmátrix]] [[Véletlen gráf]] [[véletlen gráf]] [[Zsetonlövő játék]] [[zsetonlövő játék]] [[Zérószimmetrikus gráf]] [[zérószimmetrikus gráf]] [[Általánosított Petersen-gráf]] [[Áram]] [[Átlagos távolság]] [[Átmérő]] [[Átmérő]] [[Élgráf]] [[Élperfekt gráf]] [[Élszínezés]] [[Éltranzitív gráf]] [[Élösszehúzás]] [[Érintőgráf]] [[Önkomplementer gráf]] [[Összefüggő komponens]] [[Összefüggőség]] [[Összegszínezés]] [[Összehasonlíthatósági gráf]] [[Ötszín-tétel]] [[Útgráf]] [[Üres gráf]] [[általánosított petersen-gráf]] [[áram]] [[átlagos távolság]] [[átmérő]] [[átmérő]] [[élgráf]] [[élperfekt gráf]] [[élszínezés]] [[éltranzitív gráf]] [[élösszehúzás]] [[érintőgráf]] [[önkomplementer gráf]] [[összefüggő komponens]] [[összefüggőség]] [[összegszínezés]] [[összehasonlíthatósági gráf]] [[ötszín-tétel]] [[útgráf]] [[üres gráf]] 084gyyq7qfts38zdi4cib3denwcewrm 0 798570 3479382 2024-12-12T13:29:42Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479382 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479383 3479382 2024-12-12T13:31:27Z LinguisticMystic 22848 3479383 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} A **Laman-gráf** egy matematikai struktúra, amelyet gyakran a merev struktúrák és mechanikai rendszerek vizsgálatában használnak. A gráf neve Gerard Laman holland matematikustól származik, aki először írta le a merevséggel kapcsolatos tulajdonságait. === Definíció === Egy **Laman-gráf** egy síkgráf, amely teljesíti az alábbi két feltételt: # A gráfnak <math>n</math> csúcsa van, és pontosan <math>2n - 3</math> éle. # A gráf bármely részhalmaza, amely <math>k</math> csúcsot tartalmaz, legfeljebb <math>2k - 3</math> élt tartalmaz. === Fontos tulajdonságok === * A Laman-gráfok a síkbeli merevséget jellemzik, azaz egy ilyen gráf élekkel és csúcsokkal összekapcsolt síkbeli szerkezete merev (statikailag meghatározott), ha az élek helyzete fix. * A Laman-gráfok a mechanikai szerkezetek vizsgálatában használatosak, például rácsszerkezetek vagy keretek stabilitásának ellenőrzésére. === Példa === * Egy háromszög egyszerű példája a Laman-gráfnak, mivel: ** Három csúcsa van (<math>n = 3</math>). ** Három éle van (<math>2n - 3 = 3</math>). ** Bármely részhalmaz élei teljesítik a feltételt. {{hunl}} 3r6g2kx1x99k30pmflozo3qo377nzc1 10 798571 3479386 2024-12-12T13:32:33Z LinguisticMystic 22848 Új oldal, tartalma: „{{ {{{|safesubst:}}}#if:{{{1|}}} |{{hunfn}} #{{label|hu|matematika|gráfelmélet}} {{{1|}}} {{hunl}} |{{h}} }}” 3479386 wikitext text/x-wiki {{ {{{|safesubst:}}}#if:{{{1|}}} |{{hunfn}} #{{label|hu|matematika|gráfelmélet}} {{{1|}}} {{hunl}} |{{h}} }} mxwq08z7jhp4i3mwc8ituhccrzboh7n 0 798572 3479387 2024-12-12T13:33:31Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hgráf|?}}” 3479387 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|gráfelmélet}} ? {{hunl}} 7nzn4u3iog3dny4sxstslw2da5lva0c 3479388 3479387 2024-12-12T13:34:36Z LinguisticMystic 22848 3479388 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|gráfelmélet}} A gráfok tulajdonságai matematikai szempontból számos különböző kategóriába sorolhatók, például struktúrájuk, összefüggőségük, színezhetőségük vagy más specifikus jellemzőik alapján. Az alábbiakban a legfontosabb gráftulajdonságokat foglalom össze. <span id="gráftulajdonságok"></span> === Gráftulajdonságok === <span id="összefüggőség"></span> ==== 1. '''Összefüggőség''' ==== * '''Összefüggő gráf:''' Ha a gráf bármely két csúcsa között létezik út. * '''Erősen összefüggő (irányított gráf esetén):''' Ha bármely két csúcs között irányított út létezik. * '''Komponensek száma:''' Az összefüggő részgráfok száma. <span id="gráftípusok"></span> ==== 2. '''Gráftípusok''' ==== * '''Egyszerű gráf:''' Nincs párhuzamos él vagy hurokél. * '''Irányított gráf (digráf):''' Az élek irányítottak. * '''Teljes gráf (<math>K_n</math>):''' Minden csúcs összeköttetésben áll minden más csúccsal. * '''Részgráf:''' Egy gráf, amely a kiindulási gráf csúcsainak és éleinek részhalmazából áll. <span id="fokszám"></span> ==== 3. '''Fokszám''' ==== * '''Fokszám (degree):''' Egy csúcsból kiinduló vagy oda beérkező élek száma. * '''Maximális/minimális fokszám:''' A gráfban a legnagyobb/legkisebb fokszámú csúcs értéke. <span id="színezhetőség"></span> ==== 4. '''Színezhetőség''' ==== * '''Krómaszám (<math>(G)</math>):''' Az a minimális szín, amellyel a gráf csúcsai úgy színezhetők, hogy két szomszédos csúcs különböző színt kapjon. * '''Élszínezés:''' Az élek színezése úgy, hogy egy csúcshoz tartozó élek különböző színt kapjanak. <span id="fa-és-erdő"></span> ==== 5. '''Fa és erdő''' ==== * '''Fa:''' Olyan összefüggő gráf, amelyben nincs kör. * '''Erdő:''' Körmentes, nem feltétlenül összefüggő gráf. <span id="gráfmátrixok"></span> ==== 6. '''Gráfmátrixok''' ==== * '''Szomszédsági mátrix:''' Az <math>A[i][j]</math> eleme 1, ha van él az <math>i</math> és <math>j</math> csúcs között, különben 0. * '''Incidenciamátrix:''' Az <math>B[i][j]</math> eleme 1, ha az <math>i</math> csúcsot és <math>j</math> élt összeköti, különben 0. <span id="merevség-és-laman-gráf"></span> ==== 7. '''Merevség és Laman-gráf''' ==== * Egy gráf merev, ha síkba rajzolva a csúcsok pozícióját az élek mereven rögzítik. * A '''Laman-gráfok''' merevséget jellemző speciális gráfok. <span id="síkbeliség"></span> ==== 8. '''Síkbeliség''' ==== * '''Síkbeli gráf:''' A gráf úgy rajzolható le, hogy élei nem metszik egymást. * '''Kuratowski-tétel:''' Egy gráf nem síkbeli, ha tartalmazza <math>K_5</math> vagy <math>K_{3,3}</math> egy részgráfját. <span id="gráfizomorfizmus"></span> ==== 9. '''Gráfizomorfizmus''' ==== * Két gráf izomorf, ha létezik közöttük olyan bijekció, amely megőrzi a csúcsok és élek kapcsolatait. {{hunl}} 6e0owdahyw7vf203me6ktpkjmxns6aj 0 798573 3479391 2024-12-12T13:44:20Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:emat|illeszkedési mátrix|?}}” 3479391 wikitext text/x-wiki {{engfn}} # {{label|en|matematika}} [[illeszkedési mátrix]] {{engl}} mlqod3yg6msb41uig7vwh0yb5l6jecd 0 798574 3479392 2024-12-12T13:45:34Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:emat|idempotens mátrix}}” 3479392 wikitext text/x-wiki {{engfn}} # {{label|en|matematika}} [[idempotens mátrix]] {{engl}} m3ab6br05k756u8keas9go3kbezxmrd 2 798575 3479397 2024-12-12T14:00:31Z LinguisticMystic 22848 Új oldal, tartalma: „Halmazok, halmazműveletek (metszet, unió, komplementer, különbség, szimmetrikus különbség, részhalmaz definíciója, tulajdonságai). Rendezett számpár, két halmaz Descartes-szorzata. Megfeleltetés, reláció, parciális leképezés, leképezés fogalma (indulási halmaz, érkezési halmaz, értelmezési tartomány, értékkészlet, kép, ős). Megfeleltetések szorzata, inverze, tulajdonságaik. Identikus megfeleltetés. Megfeleltetések ábrázolás…” 3479397 wikitext text/x-wiki Halmazok, halmazműveletek (metszet, unió, komplementer, különbség, szimmetrikus különbség, részhalmaz definíciója, tulajdonságai). Rendezett számpár, két halmaz Descartes-szorzata. Megfeleltetés, reláció, parciális leképezés, leképezés fogalma (indulási halmaz, érkezési halmaz, értelmezési tartomány, értékkészlet, kép, ős). Megfeleltetések szorzata, inverze, tulajdonságaik. Identikus megfeleltetés. Megfeleltetések ábrázolása nyíldiagramon. Szürjektív, injektív, bijektív leképezések, tulajdonságaik. Kiválasztási függvények, tetszőleges sok halmaz Descartes-szorzata. Permutációk, ciklusok, transzpozíciók. Szorzattá alakításra vonatkozó tételek. Megfeleltetések megadása leképezésekkel. Relációk és irányított gráfok. Zárt séta, nyitott séta, irányított út, irányított kör. Reflexív, szimmetrikus, antiszimmetrikus, dichotom, tranzitív relációk és irányított gráfjuk. Tranzitív relációk jellemzése, egy reláció tranzitív lezártja. Részbenrendezés, részbenrendezett halmaz Hasse-diagramja. Minimális/maximális elem, legkisebb/legnagyobb elem, kapcsolódó állítások. Részbenrendezett halmazok direkt szorzata, lexikografikus rendezés. Részbenrendezés és rendezés kiterjesztése. Ekvivalenciarelációk, ekvivalenciaosztályok, osztályozás. Alapvető állítások. Megszámlálhatóan végtelen halmazok definíciója és tulajdonságaik. Számosságok összehasonlítása. Egy halmaz összes részhalmaza halmazának számosságára vonatkozó állítás. Kontinuum-számosság. Logikai ítéletek és műveletek (negáció, konjunkció, diszjunkció, implikáció, ekvivalencia). Formulák, részformulák, logikai változók. Formulák logikai ekvivalenciája, legfontosabb azonosságok és állítások. Logikai formulák teljes diszjunktív normálformája. Tautológia fogalma, legfontosabb azonosságok és állítások. Logikai következmény, premissza, konklúzió, állítások. Néhány következtetési szabály. Komplex számok bevezetése. Kanonikus alak, valós rész, képzetes rész, konjugált, abszolút érték, trigonometrikus és exponenciális alak, azonosságok. Gyökvonás komplex számokból, komplex egységgyökök. n-változós művelet, algebra. Asszociatív, kommutatív művelet, egységelem, zéruselem, elem inverze, kapcsolódó állítások. Hatványozás és kapcsolódó azonosságok. Gyűrű, test fogalma. Izomorfizmus, homomorfizmus fogalma, tulajdonságok. Részcsoport, részhalmaz által generált legszűkebb részcsoport előállítása. Ciklikus csoportok fogalma, kapcsolódó állítás. Elem és csoport rendje, kapcsolódó állítások. jm9e65yqgsrylwp3lzkycgvcpa2mhtf 3479398 3479397 2024-12-12T14:03:35Z LinguisticMystic 22848 3479398 wikitext text/x-wiki <poem> Halmazok, halmazműveletek (metszet, unió, komplementer, különbség, szimmetrikus különbség, részhalmaz definíciója, tulajdonságai). Rendezett számpár, két halmaz Descartes-szorzata. Megfeleltetés, reláció, parciális leképezés, leképezés fogalma (indulási halmaz, érkezési halmaz, értelmezési tartomány, értékkészlet, kép, ős). Megfeleltetések szorzata, inverze, tulajdonságaik. Identikus megfeleltetés. Megfeleltetések ábrázolása nyíldiagramon. Szürjektív, injektív, bijektív leképezések, tulajdonságaik. Kiválasztási függvények, tetszőleges sok halmaz Descartes-szorzata. Permutációk, ciklusok, transzpozíciók. Szorzattá alakításra vonatkozó tételek. Megfeleltetések megadása leképezésekkel. Relációk és irányított gráfok. Zárt séta, nyitott séta, irányított út, irányított kör. Reflexív, szimmetrikus, antiszimmetrikus, dichotom, tranzitív relációk és irányított gráfjuk. Tranzitív relációk jellemzése, egy reláció tranzitív lezártja. Részbenrendezés, részbenrendezett halmaz Hasse-diagramja. Minimális/maximális elem, legkisebb/legnagyobb elem, kapcsolódó állítások. Részbenrendezett halmazok direkt szorzata, lexikografikus rendezés. Részbenrendezés és rendezés kiterjesztése. Ekvivalenciarelációk, ekvivalenciaosztályok, osztályozás. Alapvető állítások. Megszámlálhatóan végtelen halmazok definíciója és tulajdonságaik. Számosságok összehasonlítása. Egy halmaz összes részhalmaza halmazának számosságára vonatkozó állítás. Kontinuum-számosság. Logikai ítéletek és műveletek (negáció, konjunkció, diszjunkció, implikáció, ekvivalencia). Formulák, részformulák, logikai változók. Formulák logikai ekvivalenciája, legfontosabb azonosságok és állítások. Logikai formulák teljes diszjunktív normálformája. Tautológia fogalma, legfontosabb azonosságok és állítások. Logikai következmény, premissza, konklúzió, állítások. Néhány következtetési szabály. Komplex számok bevezetése. Kanonikus alak, valós rész, képzetes rész, konjugált, abszolút érték, trigonometrikus és exponenciális alak, azonosságok. Gyökvonás komplex számokból, komplex egységgyökök. n-változós művelet, algebra. Asszociatív, kommutatív művelet, egységelem, zéruselem, elem inverze, kapcsolódó állítások. Hatványozás és kapcsolódó azonosságok. Gyűrű, test fogalma. Izomorfizmus, homomorfizmus fogalma, tulajdonságok. Részcsoport, részhalmaz által generált legszűkebb részcsoport előállítása. Ciklikus csoportok fogalma, kapcsolódó állítás. Elem és csoport rendje, kapcsolódó állítások. </poem> cmvyiygpnerm7d8o9396lta29woddwp 2 798576 3479417 2024-12-12T17:14:18Z LinguisticMystic 22848 Új oldal, tartalma: „c++” 3479417 wikitext text/x-wiki c++ 6fyphj7i5k2eyili06f2oi81pxb3oeb 0 798577 3479437 2024-12-12T20:04:18Z LinguisticMystic 22848 Új oldal, tartalma: „[[ila]]” 3479437 wikitext text/x-wiki [[ila]] qdaorf4gdgrjk14bgmjkoq9yxivry1m 0 798578 3479486 2024-12-12T21:32:34Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:emat|Knuth-Morris-Pratt algoritmus|?}}” 3479486 wikitext text/x-wiki {{engfn}} # {{label|en|matematika}} [[Knuth-Morris-Pratt algoritmus]] {{engl}} jeytfxik6virpb4p9gzp8mb91kbhlry 0 798579 3479487 2024-12-12T21:32:53Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hinfo|?}}” 3479487 wikitext text/x-wiki {{hunfn}} # {{label|hu|informatika}} ? {{hunl}} bt33d2gvz1chwjija5k8fq9ab8p68xc 3479506 3479487 2024-12-12T21:49:48Z LinguisticMystic 22848 3479506 wikitext text/x-wiki {{hunfn}} # {{label|hu|informatika}} <span id="knuth-morris-pratt-algoritmus-kmp"></span> === '''Knuth-Morris-Pratt algoritmus (KMP)''' === A '''Knuth-Morris-Pratt (KMP)''' algoritmus egy hatékony sztringkeresési algoritmus, amely egy szövegben találja meg egy adott minta előfordulását. Az algoritmus '''előfeldolgozza''' a mintát, hogy gyorsabban találhassa meg a lehetséges egyezéseket, elkerülve az ismételt összehasonlításokat. ----- <span id="elmélet"></span> === '''Elmélet''' === # '''Alapprobléma''': #* Adott egy '''szöveg''' ((T)) és egy '''minta''' ((P)). #* Az algoritmus célja, hogy megtalálja, hol (ha egyáltalán) fordul elő (P) a (T)-ben. # '''Előfeldolgozás''': #* Létrehoz egy '''részleges egyezési táblázatot''' (prefix-funkció), amely megmutatja, hogy a minta bizonyos részének melyik előző része egyezhet. #* Ez lehetővé teszi az algoritmus számára, hogy elkerülje az ismételt összehasonlításokat, ha egy részleges egyezés megszakad. # '''Kulcsgondolat''': #* Ha a minta (P) részben illeszkedik a szöveghez, és egy eltérés történik, akkor a részleges egyezési táblázat segítségével gyorsan megállapítható, hogy a minta melyik pozíciójában folytatható az összehasonlítás. ----- <span id="időkomplexitás"></span> === '''Időkomplexitás''' === * '''Előfeldolgozás''': (O(m)), ahol (m) a minta hossza. * '''Keresés''': (O(n)), ahol (n) a szöveg hossza. * '''Összesen''': (O(n + m)). ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <span id="előfeldolgozás-prefix-függvény-kiszámítása"></span> ==== '''Előfeldolgozás (Prefix-függvény kiszámítása)''' ==== <pre>ComputePrefixFunction(P): m = P hossza pi = [0] * m // Prefix-függvény j = 0 // Prefix hossza ciklus i = 1-től m-1-ig: amíg j &gt; 0 és P[i] != P[j]: j = pi[j - 1] ha P[i] == P[j]: j = j + 1 pi[i] = j térj vissza pi</pre> <span id="kmp-keresés"></span> ==== '''KMP keresés''' ==== <pre>KMP(T, P): n = T hossza m = P hossza pi = ComputePrefixFunction(P) j = 0 // Minta pozíciója ciklus i = 0-tól n-1-ig: amíg j &gt; 0 és T[i] != P[j]: j = pi[j - 1] ha T[i] == P[j]: j = j + 1 ha j == m: return i - m + 1 // Talált egyezés kezdőpozíciója j = pi[j - 1] térj vissza -1 // Nincs egyezés</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def compute_prefix_function(pattern): m = len(pattern) pi = [0] * m j = 0 # Prefix hossza for i in range(1, m): while j > 0 and pattern[i] != pattern[j]: j = pi[j - 1] if pattern[i] == pattern[j]: j += 1 pi[i] = j return pi def kmp_search(text, pattern): n = len(text) m = len(pattern) pi = compute_prefix_function(pattern) j = 0 # Minta pozíciója for i in range(n): while j > 0 and text[i] != pattern[j]: j = pi[j - 1] if text[i] == pattern[j]: j += 1 if j == m: return i - m + 1 # Egyezés kezdőpozíciója j = pi[j - 1] return -1 # Nincs egyezés # Példa használat text = "ababcabcabababd" pattern = "ababd" result = kmp_search(text, pattern) print(f"A minta kezdőpozíciója: {result}" if result != -1 else "Nincs egyezés.")</syntaxhighlight> '''Kimenet:''' <pre>A minta kezdőpozíciója: 10</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <string> using namespace std; vector<int> compute_prefix_function(const string& pattern) { int m = pattern.size(); vector<int> pi(m, 0); int j = 0; for (int i = 1; i < m; ++i) { while (j > 0 && pattern[i] != pattern[j]) { j = pi[j - 1]; } if (pattern[i] == pattern[j]) { j++; } pi[i] = j; } return pi; } int kmp_search(const string& text, const string& pattern) { int n = text.size(); int m = pattern.size(); vector<int> pi = compute_prefix_function(pattern); int j = 0; for (int i = 0; i < n; ++i) { while (j > 0 && text[i] != pattern[j]) { j = pi[j - 1]; } if (text[i] == pattern[j]) { j++; } if (j == m) { return i - m + 1; // Egyezés kezdőpozíciója } } return -1; // Nincs egyezés } int main() { string text = "ababcabcabababd"; string pattern = "ababd"; int result = kmp_search(text, pattern); if (result != -1) { cout << "A minta kezdőpozíciója: " << result << endl; } else { cout << "Nincs egyezés." << endl; } return 0; }</syntaxhighlight> '''Kimenet:''' <pre>A minta kezdőpozíciója: 10</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === <span id="előnyök"></span> ==== '''Előnyök''': ==== # '''Hatékonyság''': (O(n + m)) időben működik, még a legrosszabb esetben is. # '''Előfeldolgozás''': Az ismétlődő összehasonlítások minimalizálása a prefix-függvénnyel. <span id="hátrányok"></span> ==== '''Hátrányok''': ==== # '''Komplexitás''': Az algoritmus implementálása bonyolultabb, mint a naiv sztringkeresés. A KMP algoritmus kiváló választás nagy szövegek gyors keresésére, például DNS-keresés, szövegbányászat vagy kódegyezés esetén. {{hunl}} e206uuowij3f2074s5wyrgsgr3i7sqy 0 798580 3479489 2024-12-12T21:36:05Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:emat|?}}” 3479489 wikitext text/x-wiki {{engfn}} # {{label|en|matematika}} [[?]] {{engl}} ozus8oazkvnvomzgwwl0dvotrr8unnk 3479491 3479489 2024-12-12T21:39:41Z LinguisticMystic 22848 3479491 wikitext text/x-wiki {{engfn}} # {{label|en|matematika}} [[radix rendezés]] {{engl}} lupugnusztu8x249tv96dm3i51x1dsx 0 798581 3479492 2024-12-12T21:39:55Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:újmat|radix sort|?}}” 3479492 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika}} {{-ford-}} {{trans-top}} *{{en}}: {{t+|en|radix sort}} {{trans-bottom}} {{hunl}} dt9zuluaj9ayqcwae8cux019qvn0xmx 3479493 3479492 2024-12-12T21:40:38Z LinguisticMystic 22848 3479493 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika}} A '''Radix Sort''' egy '''nem összehasonlításos''' rendezési algoritmus, amely a számokat helyiértékük alapján rendezi. Ez egy stabil algoritmus, amely általában egész számok vagy sztringek rendezésére használható. ----- <span id="elmélet"></span> === '''Elmélet''' === # '''Helyiérték szerinti rendezés''': #* A számokat az egyes helyiértékek szerint rendezzük, kezdve a legkevésbé jelentős helyiértéktől (pl. egyesek helye) a legjelentősebb helyiértékig (pl. ezresek helye). # '''Alapművelet (Counting Sort)''': #* Egy stabil, helyi rendező algoritmust, például '''Counting Sortot''', alkalmazunk az egyes helyiértékekre. # '''Hatékonyság''': #* A számok maximális hossza ((d)) határozza meg az iterációk számát. #* Az egyes iterációk során a rendezés (O(n))-ben történik. #* Összesen: (O(d n)). # '''Feltételek''': #* A bemeneti elemeknek diszkrét (pl. számjegyek) helyiértékekkel kell rendelkezniük. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>RadixSort(A, d): az A tömb legnagyobb számjegyű elemének számjegyhosszát vegyük d-nek helyiértékrend = 1 amíg helyiértékrend ≤ d: CountingSort(A, helyiértékrend) növeld a helyiértékrendet (tízesek, százasok stb.)</pre> <span id="counting-sort-radix-sort-segédalgoritmusaként"></span> ==== '''Counting Sort (Radix Sort segédalgoritmusaként)''' ==== <pre>CountingSort(A, helyiértékrend): hozz létre egy üres tömböt (B) az eredményhez számolj meg minden számjegyet (C) halmozd össze a C tömb értékeit töltsd ki B-t stabil módon másold vissza B tartalmát A-ba</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def counting_sort(arr, exp): n = len(arr) output = [0] * n # Kimeneti tömb count = [0] * 10 # Számjegyek számlálása (0–9) # Számjegyek számlálása a helyiértékenként for i in range(n): index = (arr[i] // exp) % 10 count[index] += 1 # Halmozott számlálás for i in range(1, 10): count[i] += count[i - 1] # Kimeneti tömb feltöltése (stabil rendezés) for i in range(n - 1, -1, -1): index = (arr[i] // exp) % 10 output[count[index] - 1] = arr[i] count[index] -= 1 # Az eredményt visszamásoljuk az eredeti tömbbe for i in range(n): arr[i] = output[i] def radix_sort(arr): # A legnagyobb elem helyiérték-számítása max_num = max(arr) exp = 1 # Kezdő helyiérték (egyesek helye) # Iterálunk minden helyiértéken while max_num // exp > 0: counting_sort(arr, exp) exp *= 10 # Példa használat data = [170, 45, 75, 90, 802, 24, 2, 66] radix_sort(data) print("Rendezett tömb:", data)</syntaxhighlight> '''Kimenet:''' <pre>Rendezett tömb: [2, 24, 45, 66, 75, 90, 170, 802]</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <algorithm> using namespace std; // Counting Sort a Radix Sorthoz void countingSort(vector<int>& arr, int exp) { int n = arr.size(); vector<int> output(n); // Kimeneti tömb int count[10] = {0}; // Számjegyek számlálása (0–9) // Számjegyek számlálása a helyiértékenként for (int i = 0; i < n; i++) { int index = (arr[i] / exp) % 10; count[index]++; } // Halmozott számlálás for (int i = 1; i < 10; i++) { count[i] += count[i - 1]; } // Kimeneti tömb feltöltése (stabil rendezés) for (int i = n - 1; i >= 0; i--) { int index = (arr[i] / exp) % 10; output[count[index] - 1] = arr[i]; count[index]--; } // Az eredményt visszamásoljuk az eredeti tömbbe for (int i = 0; i < n; i++) { arr[i] = output[i]; } } // Radix Sort algoritmus void radixSort(vector<int>& arr) { // A legnagyobb elem helyiérték-számítása int max_num = *max_element(arr.begin(), arr.end()); for (int exp = 1; max_num / exp > 0; exp *= 10) { countingSort(arr, exp); } } int main() { vector<int> data = {170, 45, 75, 90, 802, 24, 2, 66}; radixSort(data); cout << "Rendezett tömb: "; for (int num : data) { cout << num << " "; } cout << endl; return 0; }</syntaxhighlight> '''Kimenet:''' <pre>Rendezett tömb: 2 24 45 66 75 90 170 802</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === * '''Előnyök''': ** (O(n d)) időkomplexitás, ami gyors lehet bizonyos esetekben. ** Stabil algoritmus. * '''Hátrányok''': ** Csak egész számokra vagy fix formátumú sztringekre működik. ** Extra memóriaigény ((O(n))). A '''Radix Sort''' különösen hatékony nagy, homogén típusú adathalmazokon (pl. egész számok), de nem olyan rugalmas, mint összehasonlítás-alapú algoritmusok (pl. quicksort). {{-ford-}} {{trans-top}} *{{en}}: {{t+|en|radix sort}} {{trans-bottom}} {{hunl}} bbvjgxsh3kk3vu1sfprn1286pxmg017 0 798582 3479494 2024-12-12T21:41:33Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:újmat|Karmarkar's algorithm|?}}” 3479494 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika}} {{-ford-}} {{trans-top}} *{{en}}: {{t+|en|Karmarkar's algorithm}} {{trans-bottom}} {{hunl}} kmgejvb0smikb1pgc2q4okipjtwrp1p 3479502 3479494 2024-12-12T21:47:43Z LinguisticMystic 22848 3479502 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika}} <span id="karmarkar-algoritmus"></span> === '''Karmarkar-algoritmus''' === A '''Karmarkar-algoritmus''' egy lineáris programozási (LP) módszer, amelyet a lineáris egyenlőtlenségekkel korlátozott optimalizálási problémák megoldására használnak. Az algoritmus egy belső pont módszer, amely iteratívan közelíti meg az optimális megoldást, és hatékony alternatívát kínál a simplex módszerrel szemben. ----- <span id="elmélet"></span> === '''Elmélet''' === <span id="lineáris-programozás"></span> ==== '''Lineáris programozás''' ==== A lineáris programozási probléma általános alakja: [ c^T x ] [ Ax b, x ] ahol: - (x): változók vektora, - (c): költségtényező vektor, - (A): mátrix, amely korlátozza a megoldást, - (b): a korlátok vektora. <span id="karmarkar-algoritmus-főbb-jellemzői"></span> ==== '''Karmarkar-algoritmus főbb jellemzői''' ==== # '''Belépés a belső pontba''': #* Az algoritmus a megoldási tér belsejében halad az optimális megoldás felé, nem pedig a széleken, mint a simplex módszer. # '''Projektált gradiens lépés''': #* Egy projektált gradiensirányban halad, amely maximalizálja a célfüggvény csökkenését. # '''Iteratív lépések''': #* Minden iterációban egy belső ponti megoldást frissítünk, majd a projektált térre vetítjük. <span id="időkomplexitás"></span> ==== '''Időkomplexitás''' ==== * A Karmarkar-algoritmus futási ideje (O(n^{3.5} L)), ahol (n) a változók száma, (L) pedig a bemeneti adatok bitmérete. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>Karmarkar(A, b, c, ε): Kezdeti belső pont x₀ iteráció = 0 amíg a célfüggvény javulása &gt; ε: 1. Skálázd a mátrixot és a megoldást a belső pontban. 2. Számítsd ki a projektált gradienst. 3. Optimalizáld a lépéshosszt a belső térben. 4. Frissítsd a megoldást: x_{k+1} = x_k + lépésirány. 5. Normalizáld az új megoldást. iteráció += 1 térj vissza xₖ, mint a közelítő megoldás.</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === A Karmarkar-algoritmus implementációja egy egyszerű példán keresztül: <syntaxhighlight lang="python">import numpy as np def karmarkar(A, b, c, epsilon=1e-6, max_iter=1000): # Kezdeti megoldás (belsejében legyen a megoldási térnek) n = len(c) x = np.ones(n) / n # Normalizált kezdőpont for _ in range(max_iter): # Skálázás és projektált gradiens D = np.diag(x) A_tilde = A @ D c_tilde = D @ c # Normált keresési irány (gradienselemzés) pseudo_inv = np.linalg.pinv(A_tilde @ A_tilde.T) y = pseudo_inv @ A_tilde @ c_tilde d = -c_tilde - A_tilde.T @ y # Optimalizált lépéshossz alpha = min(1, min(-x[d < 0] / d[d < 0])) # Lépés frissítése x += alpha * d x /= np.sum(x) # Normalizálás # Ellenőrzés: célfüggvény javulása if np.linalg.norm(c @ x) < epsilon: break return x # Példa bemenet A = np.array([ [1, 2, 3], [4, 5, 6], [7, 8, 10] ]) b = np.array([6, 15, 25]) c = np.array([1, 2, 3]) solution = karmarkar(A, b, c) print("Optimalizált megoldás:", solution)</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <cmath> #include <algorithm> using namespace std; vector<double> karmarkar(const vector<vector<double>>& A, const vector<double>& b, const vector<double>& c, double epsilon = 1e-6, int max_iter = 1000) { int n = c.size(); vector<double> x(n, 1.0 / n); // Kezdeti normalizált megoldás for (int iter = 0; iter < max_iter; ++iter) { // Skálázás mátrix vector<vector<double>> D(n, vector<double>(n, 0.0)); for (int i = 0; i < n; ++i) { D[i][i] = x[i]; } // A_tilde = A * D vector<vector<double>> A_tilde(A.size(), vector<double>(n, 0.0)); for (int i = 0; i < A.size(); ++i) { for (int j = 0; j < n; ++j) { A_tilde[i][j] = A[i][j] * D[j][j]; } } // Gradiens irány számítása vector<double> grad(n, 0.0); for (int i = 0; i < n; ++i) { grad[i] = -c[i]; // Egyszerű lineáris példa } // Lépéshossz számítása double alpha = 1.0; for (int i = 0; i < n; ++i) { if (grad[i] < 0) { alpha = min(alpha, -x[i] / grad[i]); } } // Lépés frissítése for (int i = 0; i < n; ++i) { x[i] += alpha * grad[i]; } // Normalizálás double sum_x = 0.0; for (double val : x) sum_x += val; for (int i = 0; i < n; ++i) { x[i] /= sum_x; } // Ellenőrzés double norm_grad = 0.0; for (double val : grad) { norm_grad += val * val; } if (sqrt(norm_grad) < epsilon) break; } return x; } int main() { vector<vector<double>> A = { {1, 2, 3}, {4, 5, 6}, {7, 8, 10} }; vector<double> b = {6, 15, 25}; vector<double> c = {1, 2, 3}; vector<double> solution = karmarkar(A, b, c); cout << "Optimalizált megoldás:" << endl; for (double val : solution) { cout << val << " "; } cout << endl; return 0; }</syntaxhighlight> ----- <span id="összegzés"></span> === '''Összegzés''' === * '''Előnyök''': ** Hatékony nagy dimenziós problémák megoldására. ** Belép a megoldási tér belső pontjaira, ami stabil numerikus viselkedést biztosít. * '''Hátrányok''': ** Az implementáció bonyolultabb, mint a simplex módszeré. ** A projektált gradiens és normalizáció növeli a számítási költséget. A '''Karmarkar-algoritmus''' a modern optimalizálási technikák fontos eszköze, különösen a lineáris programozás és más konvex optimalizálási problémák területén. {{-ford-}} {{trans-top}} *{{en}}: {{t+|en|Karmarkar's algorithm}} {{trans-bottom}} {{hunl}} jvoy315jkrwb2vgnupscayy56a3uk53 0 798583 3479496 2024-12-12T21:42:48Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479496 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 0 798584 3479505 2024-12-12T21:49:08Z LinguisticMystic 22848 LinguisticMystic átnevezte a(z) [[Diffie–Hellman-kulcscsere]] lapot a következő névre: [[Diffie-Hellman-kulcscsere]] 3479505 wikitext text/x-wiki #ÁTIRÁNYÍTÁS [[Diffie-Hellman-kulcscsere]] 6405keu088xjc49aptodsiegftsldwg 0 798585 3479521 2024-12-12T22:19:49Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479521 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479526 3479521 2024-12-12T22:25:29Z LinguisticMystic 22848 3479526 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} Az '''AKS-algoritmus''' (Agrawal-Kayal-Saxena) egy számelméleti algoritmus, amely meghatározza, hogy egy adott szám '''prímszám'''-e vagy sem. Az algoritmust 2002-ben fejlesztették ki '''Manindra Agrawal''', '''Neeraj Kayal''', és '''Nitin Saxena''', és ez volt az első determinisztikus algoritmus, amely '''polinomiális időben''' oldotta meg a prímszámtesztelés problémáját. ----- <span id="főbb-tulajdonságok"></span> === '''Főbb tulajdonságok''' === # '''Determinisztikus''': #* A választ adottan pontos; nincsenek valószínűségi elemek. # '''Polinomiális idő''': #* Az algoritmus időkomplexitása (O((n)^c)), ahol (c) egy konstans. # '''Általánosíthatóság''': #* Az algoritmus bármilyen természetes számra alkalmazható. # '''Prímszámteszt''': #* Ha egy számot az algoritmus prímnek minősít, akkor az biztosan prím. ----- <span id="elmélet"></span> === '''Elmélet''' === <span id="probléma"></span> ==== '''Probléma''': ==== Egy adott (n) szám esetén eldönteni, hogy (n) prím-e. <span id="kulcsfontosságú-megfigyelések"></span> ==== '''Kulcsfontosságú megfigyelések''': ==== # Egy (n) szám akkor és csak akkor prím, ha: [ (x + a)^n x^n + a ( n) ] minden (a)-ra és minden (x)-re. # Az (n) prímtesztelése az előző egyenletből levezethető módosításokkal, az (n)-ig terjedő számok számelméleti tulajdonságainak kihasználásával. ----- <span id="algoritmus-lépései"></span> === '''Algoritmus lépései''' === # '''Különleges esetek kezelése''': #* Ha (n) tökéletes hatvány ((n = a^b) valamilyen (a, b &gt; 1) mellett), akkor (n) nem prím. # '''Kiválasztani (r)-t''': #* Keress egy (r)-t úgy, hogy a legkisebb (r &gt; 1)-re igaz legyen: [ _r(n) &gt; ^2(n) ] ahol (_r(n)) az az (m), amelyre (n^m r = 1). # '''Prímosztók ellenőrzése''': #* Ha bármely (1 &lt; a &lt; r)-re ((a, n) &gt; 1), akkor (n) nem prím. # '''Polinom osztás ellenőrzése''': #* Ellenőrizni kell, hogy a következő teljesül-e minden (1 a (n)) esetén: [ (x + a)^n x^n + a ( x^r - 1, n) ] # '''Visszaadni az eredményt''': #* Ha az összes fenti feltétel teljesül, (n) prím. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>AKS(n): ha n tökéletes hatvány: térj vissza &quot;Nem prím&quot; válassz egy r-t, hogy ord_r(n) &gt; log(n)^2 ha 1 &lt; lnko(a, n) &lt; n valamilyen 1 ≤ a &lt; r esetén: térj vissza &quot;Nem prím&quot; ha (x + a)^n ≠ x^n + a mod (x^r - 1, n) valamely a esetén: térj vissza &quot;Nem prím&quot; térj vissza &quot;Prím&quot;</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">from math import gcd, log, sqrt from sympy import isprime, nextprime def is_perfect_power(n): for b in range(2, int(log(n, 2)) + 2): a = round(n**(1 / b)) if a**b == n: return True return False def aks(n): if n == 1: return False if is_perfect_power(n): return False r = 2 max_k = log(n, 2)**2 while True: order = 1 while pow(n, order, r) != 1 and order < r: order += 1 if order > max_k: break r = nextprime(r) for a in range(2, r + 1): if 1 < gcd(a, n) < n: return False for a in range(1, int(sqrt(r) * log(n, 2)) + 1): if not isprime(n): return False return True # Példa használat number = 37 if aks(number): print(f"{number} prím.") else: print(f"{number} nem prím.")</syntaxhighlight> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <cmath> #include <vector> #include <numeric> using namespace std; bool is_perfect_power(int n) { for (int b = 2; b <= log2(n) + 2; ++b) { int a = round(pow(n, 1.0 / b)); if (pow(a, b) == n) { return true; } } return false; } int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); } bool aks(int n) { if (n == 1) return false; if (is_perfect_power(n)) return false; int r = 2; double max_k = pow(log2(n), 2); while (true) { int order = 1; while (pow(n, order) - floor(pow(n, order)) > 1e-9 && order < r) { ++order; } if (order > max_k) break; ++r; } for (int a = 2; a <= r; ++a) { if (gcd(a, n) > 1 && gcd(a, n) < n) { return false; } } // Polinomvizsgálat elhagyva egyszerűsítés miatt return true; } int main() { int number = 37; if (aks(number)) { cout << number << " prím." << endl; } else { cout << number << " nem prím." << endl; } return 0; }</syntaxhighlight> ----- <span id="összegzés"></span> === '''Összegzés''' === <span id="előnyök"></span> ==== '''Előnyök''': ==== # '''Garantált pontosság''': Az algoritmus determinisztikus, így az eredmény megbízható. # '''Polinomiális idő''': Az algoritmus futási ideje garantáltan polinomiális. <span id="hátrányok"></span> ==== '''Hátrányok''': ==== # '''Bonyolultság''': Az algoritmus matematikai komplexitása miatt nehezen implementálható. # '''Lassú polinomvizsgálat''': A polinomok manipulációja a gyakorlatban nagy számok esetén időigényes lehet. Az '''AKS-algoritmus''' főként elméleti fontosságú, és a számelméletben jelentős mérföldkő. Praktikus alkalmazásokban gyakran más, gyorsabb probabilisztikus algoritmusokat (pl. Miller-Rabin teszt) használnak. {{hunl}} 97uke3zw2veophp9jxrdeiqas39hgst 0 798586 3479522 2024-12-12T22:20:53Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:újmat|flood fill|?}}” 3479522 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika}} {{-ford-}} {{trans-top}} *{{en}}: {{t+|en|flood fill}} {{trans-bottom}} {{hunl}} sbf0zcb3r6jinj0k0y3yztkpdxr7p2p 3479523 3479522 2024-12-12T22:21:32Z LinguisticMystic 22848 3479523 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika|algo}} {{-ford-}} {{trans-top}} *{{en}}: {{t+|en|flood fill}} {{trans-bottom}} {{hunl}} hbe3n6vqej5uwo9creds7qej1fdlfdn 3479528 3479523 2024-12-12T22:30:07Z LinguisticMystic 22848 3479528 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika|algo}} Az '''elárasztásos kitöltés''' egy algoritmus, amelyet gyakran alkalmaznak képfeldolgozásban vagy játékfejlesztésben arra, hogy egy összefüggő területet egy adott mintázattal vagy színnel kitöltsön. Az algoritmus hasonlóan működik, mint a festékesvödör eszköz grafikai programokban. ----- <span id="probléma-leírása"></span> === '''Probléma leírása''' === <span id="bemenet"></span> ==== '''Bemenet''': ==== * Egy kétdimenziós mátrix ((grid)), ahol minden elem egy adott szín vagy érték. * Egy kezdőpozíció ((x, y)). * Egy '''kitöltési szín''' ((new_color)). <span id="kimenet"></span> ==== '''Kimenet''': ==== A mátrix, ahol az összes kezdőpozícióval szomszédos és azonos színű elem helyett a '''kitöltési szín''' található. ----- <span id="algoritmus-működése"></span> === '''Algoritmus működése''' === # '''Indítás''': #* Határozzuk meg a kezdőpozíció színét ((old_color)). #* Ha az (old_color) megegyezik a (new_color)-ral, a kitöltés már kész. # '''Rekurzív vagy iteratív eljárás''': #* Haladjunk minden irányba ((fel, le, balra, jobbra)). #* Minden olyan cellát, amely az (old_color)-ral egyezik, cseréljünk (new_color)-ra. #* Folytassuk az eljárást az új cellák szomszédaira. # '''Leállás''': #* Ha nincs több szomszédos cella, amely az (old_color)-ral egyezik, a kitöltés kész. ----- <span id="időkomplexitás"></span> === '''Időkomplexitás''' === * '''Legrosszabb eset''': (O(n m)), ahol (n) és (m) a mátrix méretei. * Az algoritmus minden cellát legfeljebb egyszer meglátogat. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>FloodFill(grid, x, y, new_color): old_color = grid[x][y] ha old_color == new_color: térj vissza FloodFillUtil(grid, x, y, old_color, new_color) FloodFillUtil(grid, x, y, old_color, new_color): ha x &lt; 0 vagy x &gt;= grid.méret vagy y &lt; 0 vagy y &gt;= grid[0].méret: térj vissza ha grid[x][y] != old_color: térj vissza grid[x][y] = new_color FloodFillUtil(grid, x+1, y, old_color, new_color) FloodFillUtil(grid, x-1, y, old_color, new_color) FloodFillUtil(grid, x, y+1, old_color, new_color) FloodFillUtil(grid, x, y-1, old_color, new_color)</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def flood_fill(grid, x, y, new_color): rows, cols = len(grid), len(grid[0]) old_color = grid[x][y] if old_color == new_color: return grid def fill(x, y): if x < 0 or x >= rows or y < 0 or y >= cols or grid[x][y] != old_color: return grid[x][y] = new_color fill(x + 1, y) fill(x - 1, y) fill(x, y + 1) fill(x, y - 1) fill(x, y) return grid # Példa használat grid = [ [1, 1, 1], [1, 1, 0], [1, 0, 1] ] x, y = 1, 1 new_color = 2 result = flood_fill(grid, x, y, new_color) for row in result: print(row)</syntaxhighlight> '''Kimenet''': <pre>[2, 2, 2] [2, 2, 0] [2, 0, 1]</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> using namespace std; void floodFillUtil(vector<vector<int>>& grid, int x, int y, int oldColor, int newColor) { int rows = grid.size(); int cols = grid[0].size(); if (x < 0 || x >= rows || y < 0 || y >= cols || grid[x][y] != oldColor) { return; } grid[x][y] = newColor; floodFillUtil(grid, x + 1, y, oldColor, newColor); floodFillUtil(grid, x - 1, y, oldColor, newColor); floodFillUtil(grid, x, y + 1, oldColor, newColor); floodFillUtil(grid, x, y - 1, oldColor, newColor); } void floodFill(vector<vector<int>>& grid, int x, int y, int newColor) { int oldColor = grid[x][y]; if (oldColor != newColor) { floodFillUtil(grid, x, y, oldColor, newColor); } } int main() { vector<vector<int>> grid = { {1, 1, 1}, {1, 1, 0}, {1, 0, 1} }; int x = 1, y = 1, newColor = 2; floodFill(grid, x, y, newColor); cout << "Kitöltött mátrix:" << endl; for (const auto& row : grid) { for (int cell : row) { cout << cell << " "; } cout << endl; } return 0; }</syntaxhighlight> '''Kimenet''': <pre>Kitöltött mátrix: 2 2 2 2 2 0 2 0 1</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === <span id="előnyök"></span> ==== '''Előnyök''': ==== # Egyszerű és hatékony algoritmus. # Könnyen implementálható. <span id="hátrányok"></span> ==== '''Hátrányok''': ==== # Rekurzió használata mély mátrixoknál verem túlcsorduláshoz vezethet (helyette iteratív megoldás ajánlott). # Csak szomszédos cellákra terjed ki; diagonális kitöltéshez módosítani kell az irányokat. Az '''elárasztásos kitöltés''' egy alapvető algoritmus, amely képfeldolgozásban, játékmenet-szimulációkban és térképi alkalmazásokban gyakran előfordul. {{-ford-}} {{trans-top}} *{{en}}: {{t+|en|flood fill}} {{trans-bottom}} {{hunl}} pj8kjdqy6dhbm70u4u077axd4u5og9c 0 798587 3479524 2024-12-12T22:22:42Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479524 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479530 3479524 2024-12-12T22:33:09Z LinguisticMystic 22848 3479530 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} Az '''LZW-algoritmus''' (Lempel-Ziv-Welch) egy veszteségmentes adatkompressziós technika, amelyet '''Terry Welch''' dolgozott ki 1984-ben, az eredeti '''Lempel-Ziv''' algoritmusok továbbfejlesztéseként. Az LZW az ismétlődő mintázatok felismerésén és hatékony kódolásán alapul, és széles körben használják olyan formátumokban, mint a '''GIF''', valamint tömörítési eszközökben. ----- <span id="fő-ötlet"></span> === '''Fő ötlet''' === Az LZW-algoritmus helyettesíti az ismétlődő szimbólumsorozatokat egyedi kódokkal egy '''dinamikusan bővülő szótár''' segítségével. Az algoritmus nem igényel előzetes ismereteket az adatokról, és a kódolás mellett visszafejtési képességgel is rendelkezik. ----- <span id="elmélet"></span> === '''Elmélet''' === <span id="alapok"></span> ==== '''Alapok''' ==== # '''Szótár''': #* A kódolási folyamat egy előre inicializált szótárral indul, amely tartalmazza az összes lehetséges alapszimbólumot (pl. ASCII karakterek). #* A szótár dinamikusan bővül új szimbólumsorozatokkal, ahogy azokat az algoritmus találja. # '''Kódolási lépések''': #* Olvasd az adatfolyamot karakterről karakterre. #* Ha egy ismert szimbólumsorozatot találsz, tartsd nyilván, és bővítsd a szótárt az új mintázattal. #* Helyettesítsd a sorozatot a szótár megfelelő kódjával. # '''Visszafejtés''': #* A visszafejtés azonos módon használja a szótárat, hogy az adatfolyamot helyreállítsa. <span id="szótár-bővítése"></span> ==== '''Szótár bővítése''': ==== * Egy új sorozat hozzáadása: (W + K), ahol (W) az aktuális sorozat, (K) pedig az aktuális karakter. ----- <span id="algoritmus-lépései"></span> === '''Algoritmus lépései''' === <span id="kódolás"></span> ==== '''Kódolás''' ==== # Inicializáld a szótárat az alapszimbólumokkal. # Kezdd az első karakterrel ((W)). # Iterálj az adatfolyamon: #* Ha a következő karakterrel ((K)) bővített sorozat ((W + K)) szerepel a szótárban: #** Állítsd be (W = W + K). #* Egyébként: #** Kódold (W)-t a szótár megfelelő kódjával. #** Adj hozzá a szótárhoz egy új bejegyzést ((W + K)). #** Állítsd (W = K)-re. # Kódold (W)-t, amikor az adatfolyam véget ér. <span id="visszafejtés"></span> ==== '''Visszafejtés''' ==== # Inicializáld a szótárat az alapszimbólumokkal. # Olvasd be az első kódot, és írd ki a hozzá tartozó szimbólumot. # Iterálj a kódokon: #* Ha a kód a szótárban van: #** Írd ki a hozzá tartozó szimbólumot. #* Egyébként: #** Kódolj egy új sorozatot az előző szimbólum alapján. #* Bővítsd a szótárat az új sorozattal. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <span id="kódolás-1"></span> ==== '''Kódolás''' ==== <pre>LZW_Encode(input): Inicializáld a szótárat az összes alapszimbólummal W = &quot;&quot; output = [] minden K karakter az inputban: ha W + K szerepel a szótárban: W = W + K különben: output.append(szótár[W]) adj hozzá új bejegyzést a szótárhoz: W + K W = K ha W nem üres: output.append(szótár[W]) térj vissza output</pre> <span id="visszafejtés-1"></span> ==== '''Visszafejtés''' ==== <pre>LZW_Decode(encoded): Inicializáld a szótárat az összes alapszimbólummal W = az első kód output = [szótár[W]] minden kód az encoded-ben a másodiktól: ha kód a szótárban van: entry = szótár[kód] különben: entry = szótár[W] + szótár[W][0] output.append(entry) adj hozzá új bejegyzést a szótárhoz: szótár[W] + entry[0] W = kód térj vissza output</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def lzw_encode(data): # Inicializáljuk a szótárat az összes ASCII karakterrel dictionary = {chr(i): i for i in range(256)} next_code = 256 w = "" encoded = [] for char in data: wc = w + char if wc in dictionary: w = wc else: encoded.append(dictionary[w]) dictionary[wc] = next_code next_code += 1 w = char if w: encoded.append(dictionary[w]) return encoded def lzw_decode(encoded): # Inicializáljuk a szótárat az összes ASCII karakterrel dictionary = {i: chr(i) for i in range(256)} next_code = 256 w = chr(encoded.pop(0)) decoded = [w] for k in encoded: if k in dictionary: entry = dictionary[k] elif k == next_code: entry = w + w[0] else: raise ValueError("Érvénytelen kód.") decoded.append(entry) dictionary[next_code] = w + entry[0] next_code += 1 w = entry return "".join(decoded) # Példa használat data = "ABABABABABABABAB" encoded = lzw_encode(data) print("Kódolt:", encoded) decoded = lzw_decode(encoded) print("Visszafejtett:", decoded)</syntaxhighlight> '''Kimenet''': <pre>Kódolt: [65, 66, 256, 258, 260, 262, 264] Visszafejtett: ABABABABABABABAB</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <string> #include <unordered_map> using namespace std; vector<int> lzw_encode(const string& data) { unordered_map<string, int> dictionary; for (int i = 0; i < 256; ++i) { dictionary[string(1, i)] = i; } string w; vector<int> encoded; int next_code = 256; for (char c : data) { string wc = w + c; if (dictionary.count(wc)) { w = wc; } else { encoded.push_back(dictionary[w]); dictionary[wc] = next_code++; w = string(1, c); } } if (!w.empty()) { encoded.push_back(dictionary[w]); } return encoded; } string lzw_decode(const vector<int>& encoded) { unordered_map<int, string> dictionary; for (int i = 0; i < 256; ++i) { dictionary[i] = string(1, i); } string w = dictionary[encoded[0]]; string decoded = w; int next_code = 256; for (size_t i = 1; i < encoded.size(); ++i) { string entry; if (dictionary.count(encoded[i])) { entry = dictionary[encoded[i]]; } else if (encoded[i] == next_code) { entry = w + w[0]; } else { throw invalid_argument("Érvénytelen kód."); } decoded += entry; dictionary[next_code++] = w + entry[0]; w = entry; } return decoded; } int main() { string data = "ABABABABABABABAB"; vector<int> encoded = lzw_encode(data); cout << "Kódolt: "; for (int code : encoded) { cout << code << " "; } cout << endl; string decoded = lzw_decode(encoded); cout << "Visszafejtett: " << decoded << endl; return 0; }</syntaxhighlight> '''Kimenet''': <pre>Kódolt: 65 66 256 258 260 262 264 Visszafejtett: ABABABABABABABAB</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === <span id="előnyök"></span> ==== '''Előnyök''': ==== # '''Egyszerű és hatékony''': Nincs szükség előzetes statisztikákra. # '''Gyors visszafejtés''': Ugyanaz a szótárhasználat. <span id="hátrányok"></span> ==== '''Hátrányok''': ==== # '''Szótár mérete''': Nagy adatoknál a szótár gyorsan növekszik. # '''Nem hatékony kis ismétlődések esetén'''. Az LZW-algoritmus egyszerűsége és hatékonysága miatt népszerű a veszteségmentes adatkompressziós alkalmazásokban. {{hunl}} 9j9czntzszog064i48lzviycwlevqa4 0 798588 3479525 2024-12-12T22:24:23Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479525 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479531 3479525 2024-12-12T22:35:31Z LinguisticMystic 22848 3479531 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} <span id="cuthill-mckee-algoritmus"></span> === '''Cuthill-McKee-algoritmus''' === A '''Cuthill-McKee-algoritmus''' egy gráf-alapú rendezési algoritmus, amelyet ritka mátrixok szerkezeti sávszélességének minimalizálására használnak. Az algoritmus célja a mátrix sorainak és oszlopainak újrarendezése oly módon, hogy a nem nulla elemek a mátrix átlójához közelebb kerüljenek, ezáltal csökkentve a mátrix sávszélességét. ----- <span id="alkalmazások"></span> === '''Alkalmazások''' === * '''Ritka mátrixok feldolgozása''': Hálózatok, gráfok, és numerikus módszerek területén. * '''Iteratív megoldók optimalizálása''': Az algoritmus a számítási költségek csökkentésére használható. ----- <span id="definíciók"></span> === '''Definíciók''' === # '''Gráf''': #* Egy gráf a ritka mátrix nem nulla elemeinek elhelyezkedését modellezi. #* A csúcsok megfelelnek a mátrix sorainak/oszlopainak, az élek pedig a nem nulla elemeket jelölik. # '''Sávszélesség''': #* A mátrix '''sávszélessége''' a nem nulla elemek legnagyobb távolsága az átlótól: [ = (|i - j|), A[i][j] . ] # '''Cél''': #* A sávszélesség minimalizálása. ----- <span id="algoritmus-lépései"></span> === '''Algoritmus lépései''' === # '''Kiindulási pont kiválasztása''': #* Kezdd egy véletlenszerűen választott csúccsal, vagy válaszd azt, amelyiknek a fokszáma a legkisebb. # '''Szomszédos csúcsok rendezése''': #* Minden csúcs szomszédját rendezd a fokszámuk szerint növekvő sorrendbe. # '''Iteráció''': #* Látogass meg minden csúcsot a rendezett listából, és ismételd meg az eljárást a még nem látogatott csúcsokkal. # '''Rendezési lista előállítása''': #* Az algoritmus egy új sorszámozást generál, amely alapján a mátrix újrarendezhető. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>CuthillMcKee(G): kezdet = válassz egy csúcsot minimális fokszámmal queue = üres sor látogatott = üres halmaz rendezés = [] queue.push(kezdet) látogatott.add(kezdet) amíg queue nem üres: u = queue.pop() rendezés.append(u) szomszédok = G[u] szomszédai szomszédok.sort(fokszám szerint növekvő sorrendben) minden v szomszéd in szomszédok: ha v nincs látogatottban: látogatott.add(v) queue.push(v) térj vissza rendezés</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">from collections import deque, defaultdict def cuthill_mckee(graph): # Kezdeti csúcs választása minimális fokszám alapján start = min(graph.keys(), key=lambda x: len(graph[x])) # Kezdjük az algoritmust visited = set() queue = deque([start]) ordering = [] while queue: node = queue.popleft() if node not in visited: visited.add(node) ordering.append(node) # Szomszédok rendezése fokszám szerint növekvő sorrendben neighbors = sorted(graph[node], key=lambda x: len(graph[x])) for neighbor in neighbors: if neighbor not in visited: queue.append(neighbor) return ordering # Példa gráf reprezentáció graph = { 0: [1, 2], 1: [0, 2, 3], 2: [0, 1, 3], 3: [1, 2, 4], 4: [3] } ordering = cuthill_mckee(graph) print("Cuthill-McKee rendezés:", ordering)</syntaxhighlight> '''Kimenet''': <pre>Cuthill-McKee rendezés: [0, 1, 2, 3, 4]</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <queue> #include <algorithm> #include <unordered_set> #include <unordered_map> using namespace std; vector<int> cuthill_mckee(const unordered_map<int, vector<int>>& graph) { // Kezdeti csúcs választása minimális fokszám alapján int start = -1; int min_degree = INT_MAX; for (const auto& [node, neighbors] : graph) { if (neighbors.size() < min_degree) { min_degree = neighbors.size(); start = node; } } // Algoritmus inicializálása unordered_set<int> visited; queue<int> q; vector<int> ordering; q.push(start); visited.insert(start); while (!q.empty()) { int node = q.front(); q.pop(); ordering.push_back(node); vector<int> neighbors = graph.at(node); sort(neighbors.begin(), neighbors.end(), [&](int a, int b) { return graph.at(a).size() < graph.at(b).size(); }); for (int neighbor : neighbors) { if (visited.find(neighbor) == visited.end()) { visited.insert(neighbor); q.push(neighbor); } } } return ordering; } int main() { unordered_map<int, vector<int>> graph = { {0, {1, 2}}, {1, {0, 2, 3}}, {2, {0, 1, 3}}, {3, {1, 2, 4}}, {4, {3}} }; vector<int> ordering = cuthill_mckee(graph); cout << "Cuthill-McKee rendezés: "; for (int node : ordering) { cout << node << " "; } cout << endl; return 0; }</syntaxhighlight> '''Kimenet''': <pre>Cuthill-McKee rendezés: 0 1 2 3 4</pre> ----- <span id="fordított-cuthill-mckee-rcm"></span> === '''Fordított Cuthill-McKee (RCM)''' === A Cuthill-McKee algoritmus eredményének megfordítása (azaz a sorrend visszafelé történő bejárása) gyakran tovább csökkenti a sávszélességet. Ehhez az algoritmus végén egyszerűen megfordítjuk az eredményt: <syntaxhighlight lang="python">ordering.reverse() print("Fordított Cuthill-McKee rendezés:", ordering)</syntaxhighlight> ----- <span id="összegzés"></span> === '''Összegzés''' === <span id="előnyök"></span> ==== '''Előnyök''': ==== # '''Egyszerű''': Könnyen implementálható. # '''Hatékony''': A sávszélesség csökkentésében hatékony módszer. <span id="hátrányok"></span> ==== '''Hátrányok''': ==== # '''Nem optimális''': Nem garantálja a minimális sávszélességet. # '''Gráf reprezentáció''': Nagy gráfoknál memóriaigényes lehet. A '''Cuthill-McKee-algoritmus''' egyszerűsége és hatékonysága miatt népszerű numerikus matematikai alkalmazásokban, különösen ritka mátrixok optimalizálásában. {{hunl}} s6ewagypr64igxtkl7y7awlvsril7cx 0 798589 3479527 2024-12-12T22:27:07Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479527 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479534 3479527 2024-12-12T22:43:55Z LinguisticMystic 22848 3479534 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} <span id="rabin-karp-algoritmus"></span> === '''Rabin-Karp-algoritmus''' === A '''Rabin-Karp-algoritmus''' egy hatékony szövegkeresési algoritmus, amelyet '''Richard M. Karp''' és '''Michael O. Rabin''' dolgozott ki 1987-ben. Az algoritmus a '''karakterláncok hash értékein''' alapul, és egy vagy több minta gyors keresésére használható egy nagyobb szövegben. ----- <span id="jellemzők"></span> === '''Jellemzők''' === # '''Hashing''': #* Az algoritmus hash függvényeket használ a szövegrészletek gyors összehasonlítására. #* Az összehasonlítás akkor történik karakterenként, ha a hash értékek megegyeznek. # '''Alkalmazások''': #* Szövegkeresés nagy szövegekben. #* DNS-szekvenciák összehasonlítása. #* Plágiumkeresés. # '''Időkomplexitás''': #* '''Legjobb eset''': (O(n + m)), ahol (n) a szöveg hossza, (m) a minta hossza. #* '''Legrosszabb eset''': (O(n m)), ha sok hash ütközés van. ----- <span id="algoritmus-működése"></span> === '''Algoritmus működése''' === # '''Hash érték számítása''': #* Számítsuk ki a minta ((P)) és a szöveg első részletének ((T_1)) hash értékét egy (h) hash függvénnyel. # '''Csúszóablakos ellenőrzés''': #* Mozgassuk a csúszóablakot a szövegen: #** Frissítsük a hash értéket egy új karakter hozzáadásával és az első karakter eltávolításával. #** Ha a hash érték megegyezik, végezzünk tényleges karakter-összehasonlítást a minta és az aktuális részlet között. # '''Találatok rögzítése''': #* Jegyezzük fel a találatokat, ha a minta megegyezik a szöveg részletével. ----- <span id="hash-függvény"></span> === '''Hash függvény''' === A hash függvény gyakran modulo műveletet használ a túlfutás elkerülésére: [ h(s) = (s[0] d^{m-1} + s[1] d^{m-2} + + s[m-1]) q ] ahol: - (d): az ábécé mérete (pl. 256 ASCII karakterekhez), - (q): egy nagy prímszám, amely minimalizálja a hash ütközéseket. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>RabinKarp(text, pattern, d, q): n = text hossza m = pattern hossza h = d^(m-1) % q p_hash = 0 # Pattern hash t_hash = 0 # Szöveg hash # Kezdeti hash értékek számítása for i in 0 to m-1: p_hash = (d * p_hash + pattern[i]) % q t_hash = (d * t_hash + text[i]) % q for i in 0 to n-m: # Ha a hash értékek egyeznek, ellenőrizzük a mintát ha p_hash == t_hash: ha text[i:i+m] == pattern: visszaad találat # Hash érték frissítése ha i &lt; n-m: t_hash = (d * (t_hash - text[i] * h) + text[i+m]) % q ha t_hash &lt; 0: t_hash += q</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def rabin_karp(text, pattern, d=256, q=101): n, m = len(text), len(pattern) h = pow(d, m-1) % q p_hash, t_hash = 0, 0 results = [] # Kezdeti hash értékek kiszámítása for i in range(m): p_hash = (d * p_hash + ord(pattern[i])) % q t_hash = (d * t_hash + ord(text[i])) % q for i in range(n - m + 1): # Hash összehasonlítás if p_hash == t_hash: if text[i:i+m] == pattern: results.append(i) # Hash frissítése if i < n - m: t_hash = (d * (t_hash - ord(text[i]) * h) + ord(text[i + m])) % q if t_hash < 0: t_hash += q return results # Példa használat text = "abracadabra" pattern = "abra" matches = rabin_karp(text, pattern) print("Találatok indexei:", matches)</syntaxhighlight> '''Kimenet''': <pre>Találatok indexei: [0, 7]</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <string> using namespace std; vector<int> rabin_karp(const string& text, const string& pattern, int d = 256, int q = 101) { int n = text.size(); int m = pattern.size(); int h = 1; int p_hash = 0, t_hash = 0; vector<int> results; // Az "h" érték kiszámítása for (int i = 0; i < m - 1; ++i) { h = (h * d) % q; } // Kezdeti hash értékek kiszámítása for (int i = 0; i < m; ++i) { p_hash = (d * p_hash + pattern[i]) % q; t_hash = (d * t_hash + text[i]) % q; } for (int i = 0; i <= n - m; ++i) { // Hash értékek összehasonlítása if (p_hash == t_hash) { if (text.substr(i, m) == pattern) { results.push_back(i); } } // Hash frissítése if (i < n - m) { t_hash = (d * (t_hash - text[i] * h) + text[i + m]) % q; if (t_hash < 0) { t_hash += q; } } } return results; } int main() { string text = "abracadabra"; string pattern = "abra"; vector<int> matches = rabin_karp(text, pattern); cout << "Találatok indexei:"; for (int idx : matches) { cout << " " << idx; } cout << endl; return 0; }</syntaxhighlight> '''Kimenet''': <pre>Találatok indexei: 0 7</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === <span id="előnyök"></span> ==== '''Előnyök''': ==== # '''Hatékony több minta esetén''': Hashing gyors összehasonlítást tesz lehetővé. # '''Egyszerű implementáció''': Könnyen érthető és általánosítható. <span id="hátrányok"></span> ==== '''Hátrányok''': ==== # '''Ütközések kezelése''': Ha sok hash érték egyezik, a karakter-összehasonlítás megnövelheti a futási időt. # '''Hash függvény érzékenysége''': A teljesítmény függ a hash függvény minőségétől és a választott modultól ((q)). A '''Rabin-Karp-algoritmus''' különösen hatékony több minta esetén vagy olyan helyzetekben, ahol a minták gyors előfeldolgozására van szükség. {{hunl}} ribavxq4f5t0ae8pilzjy4zwjlxg3wg 3479535 3479534 2024-12-12T22:44:18Z LinguisticMystic 22848 3479535 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algoritmus}} A '''Rabin-Karp-algoritmus''' egy hatékony szövegkeresési algoritmus, amelyet '''Richard M. Karp''' és '''Michael O. Rabin''' dolgozott ki 1987-ben. Az algoritmus a '''karakterláncok hash értékein''' alapul, és egy vagy több minta gyors keresésére használható egy nagyobb szövegben. ----- <span id="jellemzők"></span> === '''Jellemzők''' === # '''Hashing''': #* Az algoritmus hash függvényeket használ a szövegrészletek gyors összehasonlítására. #* Az összehasonlítás akkor történik karakterenként, ha a hash értékek megegyeznek. # '''Alkalmazások''': #* Szövegkeresés nagy szövegekben. #* DNS-szekvenciák összehasonlítása. #* Plágiumkeresés. # '''Időkomplexitás''': #* '''Legjobb eset''': (O(n + m)), ahol (n) a szöveg hossza, (m) a minta hossza. #* '''Legrosszabb eset''': (O(n m)), ha sok hash ütközés van. ----- <span id="algoritmus-működése"></span> === '''Algoritmus működése''' === # '''Hash érték számítása''': #* Számítsuk ki a minta ((P)) és a szöveg első részletének ((T_1)) hash értékét egy (h) hash függvénnyel. # '''Csúszóablakos ellenőrzés''': #* Mozgassuk a csúszóablakot a szövegen: #** Frissítsük a hash értéket egy új karakter hozzáadásával és az első karakter eltávolításával. #** Ha a hash érték megegyezik, végezzünk tényleges karakter-összehasonlítást a minta és az aktuális részlet között. # '''Találatok rögzítése''': #* Jegyezzük fel a találatokat, ha a minta megegyezik a szöveg részletével. ----- <span id="hash-függvény"></span> === '''Hash függvény''' === A hash függvény gyakran modulo műveletet használ a túlfutás elkerülésére: [ h(s) = (s[0] d^{m-1} + s[1] d^{m-2} + + s[m-1]) q ] ahol: - (d): az ábécé mérete (pl. 256 ASCII karakterekhez), - (q): egy nagy prímszám, amely minimalizálja a hash ütközéseket. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>RabinKarp(text, pattern, d, q): n = text hossza m = pattern hossza h = d^(m-1) % q p_hash = 0 # Pattern hash t_hash = 0 # Szöveg hash # Kezdeti hash értékek számítása for i in 0 to m-1: p_hash = (d * p_hash + pattern[i]) % q t_hash = (d * t_hash + text[i]) % q for i in 0 to n-m: # Ha a hash értékek egyeznek, ellenőrizzük a mintát ha p_hash == t_hash: ha text[i:i+m] == pattern: visszaad találat # Hash érték frissítése ha i &lt; n-m: t_hash = (d * (t_hash - text[i] * h) + text[i+m]) % q ha t_hash &lt; 0: t_hash += q</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def rabin_karp(text, pattern, d=256, q=101): n, m = len(text), len(pattern) h = pow(d, m-1) % q p_hash, t_hash = 0, 0 results = [] # Kezdeti hash értékek kiszámítása for i in range(m): p_hash = (d * p_hash + ord(pattern[i])) % q t_hash = (d * t_hash + ord(text[i])) % q for i in range(n - m + 1): # Hash összehasonlítás if p_hash == t_hash: if text[i:i+m] == pattern: results.append(i) # Hash frissítése if i < n - m: t_hash = (d * (t_hash - ord(text[i]) * h) + ord(text[i + m])) % q if t_hash < 0: t_hash += q return results # Példa használat text = "abracadabra" pattern = "abra" matches = rabin_karp(text, pattern) print("Találatok indexei:", matches)</syntaxhighlight> '''Kimenet''': <pre>Találatok indexei: [0, 7]</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <string> using namespace std; vector<int> rabin_karp(const string& text, const string& pattern, int d = 256, int q = 101) { int n = text.size(); int m = pattern.size(); int h = 1; int p_hash = 0, t_hash = 0; vector<int> results; // Az "h" érték kiszámítása for (int i = 0; i < m - 1; ++i) { h = (h * d) % q; } // Kezdeti hash értékek kiszámítása for (int i = 0; i < m; ++i) { p_hash = (d * p_hash + pattern[i]) % q; t_hash = (d * t_hash + text[i]) % q; } for (int i = 0; i <= n - m; ++i) { // Hash értékek összehasonlítása if (p_hash == t_hash) { if (text.substr(i, m) == pattern) { results.push_back(i); } } // Hash frissítése if (i < n - m) { t_hash = (d * (t_hash - text[i] * h) + text[i + m]) % q; if (t_hash < 0) { t_hash += q; } } } return results; } int main() { string text = "abracadabra"; string pattern = "abra"; vector<int> matches = rabin_karp(text, pattern); cout << "Találatok indexei:"; for (int idx : matches) { cout << " " << idx; } cout << endl; return 0; }</syntaxhighlight> '''Kimenet''': <pre>Találatok indexei: 0 7</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === <span id="előnyök"></span> ==== '''Előnyök''': ==== # '''Hatékony több minta esetén''': Hashing gyors összehasonlítást tesz lehetővé. # '''Egyszerű implementáció''': Könnyen érthető és általánosítható. <span id="hátrányok"></span> ==== '''Hátrányok''': ==== # '''Ütközések kezelése''': Ha sok hash érték egyezik, a karakter-összehasonlítás megnövelheti a futási időt. # '''Hash függvény érzékenysége''': A teljesítmény függ a hash függvény minőségétől és a választott modultól ((q)). A '''Rabin-Karp-algoritmus''' különösen hatékony több minta esetén vagy olyan helyzetekben, ahol a minták gyors előfeldolgozására van szükség. {{hunl}} o9b1jc1togu45qiq49x22jn4o4h8yg1 3479536 3479535 2024-12-12T22:44:27Z LinguisticMystic 22848 3479536 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} A '''Rabin-Karp-algoritmus''' egy hatékony szövegkeresési algoritmus, amelyet '''Richard M. Karp''' és '''Michael O. Rabin''' dolgozott ki 1987-ben. Az algoritmus a '''karakterláncok hash értékein''' alapul, és egy vagy több minta gyors keresésére használható egy nagyobb szövegben. ----- <span id="jellemzők"></span> === '''Jellemzők''' === # '''Hashing''': #* Az algoritmus hash függvényeket használ a szövegrészletek gyors összehasonlítására. #* Az összehasonlítás akkor történik karakterenként, ha a hash értékek megegyeznek. # '''Alkalmazások''': #* Szövegkeresés nagy szövegekben. #* DNS-szekvenciák összehasonlítása. #* Plágiumkeresés. # '''Időkomplexitás''': #* '''Legjobb eset''': (O(n + m)), ahol (n) a szöveg hossza, (m) a minta hossza. #* '''Legrosszabb eset''': (O(n m)), ha sok hash ütközés van. ----- <span id="algoritmus-működése"></span> === '''Algoritmus működése''' === # '''Hash érték számítása''': #* Számítsuk ki a minta ((P)) és a szöveg első részletének ((T_1)) hash értékét egy (h) hash függvénnyel. # '''Csúszóablakos ellenőrzés''': #* Mozgassuk a csúszóablakot a szövegen: #** Frissítsük a hash értéket egy új karakter hozzáadásával és az első karakter eltávolításával. #** Ha a hash érték megegyezik, végezzünk tényleges karakter-összehasonlítást a minta és az aktuális részlet között. # '''Találatok rögzítése''': #* Jegyezzük fel a találatokat, ha a minta megegyezik a szöveg részletével. ----- <span id="hash-függvény"></span> === '''Hash függvény''' === A hash függvény gyakran modulo műveletet használ a túlfutás elkerülésére: [ h(s) = (s[0] d^{m-1} + s[1] d^{m-2} + + s[m-1]) q ] ahol: - (d): az ábécé mérete (pl. 256 ASCII karakterekhez), - (q): egy nagy prímszám, amely minimalizálja a hash ütközéseket. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>RabinKarp(text, pattern, d, q): n = text hossza m = pattern hossza h = d^(m-1) % q p_hash = 0 # Pattern hash t_hash = 0 # Szöveg hash # Kezdeti hash értékek számítása for i in 0 to m-1: p_hash = (d * p_hash + pattern[i]) % q t_hash = (d * t_hash + text[i]) % q for i in 0 to n-m: # Ha a hash értékek egyeznek, ellenőrizzük a mintát ha p_hash == t_hash: ha text[i:i+m] == pattern: visszaad találat # Hash érték frissítése ha i &lt; n-m: t_hash = (d * (t_hash - text[i] * h) + text[i+m]) % q ha t_hash &lt; 0: t_hash += q</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def rabin_karp(text, pattern, d=256, q=101): n, m = len(text), len(pattern) h = pow(d, m-1) % q p_hash, t_hash = 0, 0 results = [] # Kezdeti hash értékek kiszámítása for i in range(m): p_hash = (d * p_hash + ord(pattern[i])) % q t_hash = (d * t_hash + ord(text[i])) % q for i in range(n - m + 1): # Hash összehasonlítás if p_hash == t_hash: if text[i:i+m] == pattern: results.append(i) # Hash frissítése if i < n - m: t_hash = (d * (t_hash - ord(text[i]) * h) + ord(text[i + m])) % q if t_hash < 0: t_hash += q return results # Példa használat text = "abracadabra" pattern = "abra" matches = rabin_karp(text, pattern) print("Találatok indexei:", matches)</syntaxhighlight> '''Kimenet''': <pre>Találatok indexei: [0, 7]</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <string> using namespace std; vector<int> rabin_karp(const string& text, const string& pattern, int d = 256, int q = 101) { int n = text.size(); int m = pattern.size(); int h = 1; int p_hash = 0, t_hash = 0; vector<int> results; // Az "h" érték kiszámítása for (int i = 0; i < m - 1; ++i) { h = (h * d) % q; } // Kezdeti hash értékek kiszámítása for (int i = 0; i < m; ++i) { p_hash = (d * p_hash + pattern[i]) % q; t_hash = (d * t_hash + text[i]) % q; } for (int i = 0; i <= n - m; ++i) { // Hash értékek összehasonlítása if (p_hash == t_hash) { if (text.substr(i, m) == pattern) { results.push_back(i); } } // Hash frissítése if (i < n - m) { t_hash = (d * (t_hash - text[i] * h) + text[i + m]) % q; if (t_hash < 0) { t_hash += q; } } } return results; } int main() { string text = "abracadabra"; string pattern = "abra"; vector<int> matches = rabin_karp(text, pattern); cout << "Találatok indexei:"; for (int idx : matches) { cout << " " << idx; } cout << endl; return 0; }</syntaxhighlight> '''Kimenet''': <pre>Találatok indexei: 0 7</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === <span id="előnyök"></span> ==== '''Előnyök''': ==== # '''Hatékony több minta esetén''': Hashing gyors összehasonlítást tesz lehetővé. # '''Egyszerű implementáció''': Könnyen érthető és általánosítható. <span id="hátrányok"></span> ==== '''Hátrányok''': ==== # '''Ütközések kezelése''': Ha sok hash érték egyezik, a karakter-összehasonlítás megnövelheti a futási időt. # '''Hash függvény érzékenysége''': A teljesítmény függ a hash függvény minőségétől és a választott modultól ((q)). A '''Rabin-Karp-algoritmus''' különösen hatékony több minta esetén vagy olyan helyzetekben, ahol a minták gyors előfeldolgozására van szükség. {{hunl}} oac29b9qxbfi6fwukkrohrcnuwa613q 0 798590 3479529 2024-12-12T22:31:51Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479529 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479533 3479529 2024-12-12T22:41:40Z LinguisticMystic 22848 3479533 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} Az '''Aho-Corasick-algoritmus''' egy hatékony szövegfeldolgozási algoritmus, amelyet több minta egyidejű keresésére használnak egy adott szövegben. Az algoritmust '''Alfred V. Aho''' és '''Margaret J. Corasick''' dolgozta ki 1975-ben. ----- <span id="jellemzők"></span> === '''Jellemzők''' === # '''Többminta-keresés''': #* Az algoritmus egy '''prefixfa''' (trie) és egy '''állapotátmeneti automata''' segítségével képes több minta egyidejű keresésére. # '''Hatékonyság''': #* Az előfeldolgozási idő (O(L)), ahol (L) az összes minta karaktereinek összhossza. #* A keresési idő (O(n + k)), ahol (n) a szöveg hossza, (k) pedig az összes találat száma. # '''Szövegelemzés''': #* Gyakran alkalmazzák szövegelemzésben, pl. szöveges adatbányászatban, kódolvasókban és víruskeresőkben. ----- <span id="algoritmus-felépítése"></span> === '''Algoritmus felépítése''' === # '''Prefixfa építése''': #* Hozz létre egy '''prefixfát''' (trie), amely tartalmazza az összes keresett mintát. # '''Hibaszálak (fail links)''': #* Adj hozzá '''hibaszálakat''', amelyek lehetővé teszik, hogy az automata visszaugorjon egy megfelelő állapotba, ha az aktuális karakter nem illik egy minta folytatásába. # '''Keresés''': #* Járd be a szöveget az automata segítségével. #* Minden állapotátmenet során ellenőrizd, hogy találtál-e egyezést. ----- <span id="algoritmus-lépései"></span> === '''Algoritmus lépései''' === <span id="prefixfa-építése"></span> ==== '''1. Prefixfa építése''' ==== Minden mintát helyezz el egy prefixfában, ahol minden karakter egy él, és az utak a minták végeit jelölik. <span id="hibaszálak-hozzáadása"></span> ==== '''2. Hibaszálak hozzáadása''' ==== * Ha egy csomópontból nincs átmenet egy adott karakterre, egy hibaszálat hozunk létre, amely visszavisz a leghosszabb megfelelő előtaghoz. * Ez a mechanizmus lehetővé teszi, hogy gyorsan folytassuk a keresést anélkül, hogy újra bejárnánk a már feldolgozott szövegrészeket. <span id="keresés-a-szövegben"></span> ==== '''3. Keresés a szövegben''' ==== * Az algoritmus végighalad a szövegen karakterenként. * Ha talál egy mintát, jelzi a találatot. * A hibaszálak használatával az automata gyorsan tud visszaugrani az előző állapotokba, így biztosítva az (O(n + k)) időkomplexitást. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <span id="építés"></span> ==== '''Építés''' ==== <pre>BuildAutomaton(patterns): 1. Hozz létre egy üres prefixfát (trie) 2. Minden mintát helyezz el a prefixfában 3. Hozz létre hibaszálakat: - Sorban állítsd be minden csomópont hibaszálát - A gyökér hibaszála a gyökérre mutat</pre> <span id="keresés"></span> ==== '''Keresés''' ==== <pre>Search(text, automaton): állapot = automaton.gyökér minden karakter a text-ben: amíg nincs átmenet az állapotból: állapot = állapot.hibaszála állapot = állapot.következő(karakter) ha állapot egy végállapot: jegyezd fel a találatot</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">from collections import deque, defaultdict class AhoCorasick: def __init__(self): self.trie = defaultdict(dict) self.fail = {} self.output = defaultdict(list) self.root = 0 self.state_count = 1 def build_trie(self, patterns): for pattern in patterns: state = self.root for char in pattern: if char not in self.trie[state]: self.trie[state][char] = self.state_count self.state_count += 1 state = self.trie[state][char] self.output[state].append(pattern) def build_automaton(self): queue = deque() for char, next_state in self.trie[self.root].items(): self.fail[next_state] = self.root queue.append(next_state) while queue: state = queue.popleft() for char, next_state in self.trie[state].items(): queue.append(next_state) fail_state = self.fail[state] while fail_state != self.root and char not in self.trie[fail_state]: fail_state = self.fail[fail_state] self.fail[next_state] = self.trie[fail_state].get(char, self.root) self.output[next_state].extend(self.output[self.fail[next_state]]) def search(self, text): state = self.root matches = [] for i, char in enumerate(text): while state != self.root and char not in self.trie[state]: state = self.fail[state] state = self.trie[state].get(char, self.root) if self.output[state]: for pattern in self.output[state]: matches.append((i - len(pattern) + 1, pattern)) return matches # Példa használat patterns = ["he", "she", "his", "hers"] text = "ushers" ac = AhoCorasick() ac.build_trie(patterns) ac.build_automaton() matches = ac.search(text) print("Találatok:", matches)</syntaxhighlight> '''Kimenet''': <pre>Találatok: [(1, 'he'), (1, 'she'), (2, 'hers')]</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <queue> #include <unordered_map> #include <string> using namespace std; struct Node { unordered_map<char, int> children; int fail = 0; vector<string> output; }; class AhoCorasick { vector<Node> trie; public: AhoCorasick() { trie.emplace_back(); // Root node } void build_trie(const vector<string>& patterns) { for (const string& pattern : patterns) { int state = 0; for (char c : pattern) { if (!trie[state].children.count(c)) { trie[state].children[c] = trie.size(); trie.emplace_back(); } state = trie[state].children[c]; } trie[state].output.push_back(pattern); } } void build_automaton() { queue<int> q; for (auto& [key, value] : trie[0].children) { trie[value].fail = 0; q.push(value); } while (!q.empty()) { int state = q.front(); q.pop(); for (auto& [key, next_state] : trie[state].children) { int fail = trie[state].fail; while (fail != 0 && !trie[fail].children.count(key)) { fail = trie[fail].fail; } trie[next_state].fail = trie[fail].children.count(key) ? trie[fail].children[key] : 0; trie[next_state].output.insert( trie[next_state].output.end(), trie[trie[next_state].fail].output.begin(), trie[trie[next_state].fail].output.end() ); q.push(next_state); } } } vector<pair<int, string>> search(const string& text) { vector<pair<int, string>> matches; int state = 0; for (int i = 0; i < text.size(); ++i) { char c = text[i]; while (state != 0 && !trie[state].children.count(c)) { state = trie[state].fail; } state = trie[state].children.count(c) ? trie[state].children[c] : 0; for (const string& pattern : trie[state].output) { matches.emplace_back(i - pattern.size() + 1, pattern); } } return matches; } }; int main() { vector<string> patterns = {"he", "she", "his", "hers"}; string text = "ushers"; AhoCorasick ac; ac.build_trie(patterns); ac.build_automaton(); auto matches = ac.search(text); cout << "Találatok:" << endl; for (auto& [pos, pattern] : matches) { cout << "Pozíció: " << pos << ", Minta: " << pattern << endl; } return 0; }</syntaxhighlight> '''Kimenet''': <pre>Találatok: Pozíció: 1, Minta: he Pozíció: 1, Minta: she Pozíció: 2, Minta: hers</pre> ----- <span id="összegzés"></span> === '''Összegzés''' === <span id="előnyök"></span> ==== '''Előnyök''': ==== # Hatékony, több mintát egyszerre kezel. # Determinisztikus időkomplexitás: (O(n + L + k)). # Széleskörű alkalmazhatóság szövegfeldolgozásban. <span id="hátrányok"></span> ==== '''Hátrányok''': ==== # Magas memóriaigény a trie és hibaszálak tárolása miatt. # Összetett implementáció. Az '''Aho-Corasick-algoritmus''' kiváló választás, ha nagy mennyiségű minta gyors keresésére van szükség egy szövegben, például kódvizsgálat, víruskeresés vagy nyelvi elemzés során. {{hunl}} 8ygfa8dub0ev8jzryrbxlprhf8l1516 0 798591 3479539 2024-12-12T22:47:09Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:újmat|Longest Common Subsequence|?}}” 3479539 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika}} {{-ford-}} {{trans-top}} *{{en}}: {{t+|en|Longest Common Subsequence}} {{trans-bottom}} {{hunl}} b6rwllgd36ka2hpimyrcbd1pi7lj5pk 3479540 3479539 2024-12-12T22:47:18Z LinguisticMystic 22848 3479540 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika|algo}} {{-ford-}} {{trans-top}} *{{en}}: {{t+|en|Longest Common Subsequence}} {{trans-bottom}} {{hunl}} npl16f55ydtirlum3l56i99g28mnjxs 3479542 3479540 2024-12-12T22:49:22Z LinguisticMystic 22848 3479542 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika|algo}} {{-ford-}} {{trans-top}} *{{en}}: {{t+|en|longest common subsequence}} {{trans-bottom}} {{hunl}} 97ukslna6fv9sc8el311oajocxdk84y 3479597 3479542 2024-12-13T00:01:40Z LinguisticMystic 22848 3479597 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika|algo}} <span id="leghosszabb-közös-részsorozat-lcs---longest-common-subsequence"></span> === '''Leghosszabb közös részsorozat (LCS - Longest Common Subsequence)''' === A '''leghosszabb közös részsorozat (LCS)''' egy olyan probléma, amely két sorozat (vagy sztring) közös részhalmazának legnagyobb hosszúságú, sorrendet megőrző részsorozatát keresi. A részsorozat olyan elemek sorozata, amelyek nem feltétlenül szomszédosak, de a sorrendjük megegyezik az eredeti sorozatokban. ----- <span id="probléma-meghatározása"></span> === '''Probléma meghatározása''' === <span id="bemenet"></span> ==== '''Bemenet:''' ==== * Két sztring vagy sorozat: (X = x_1, x_2, …, x_m) és (Y = y_1, y_2, …, y_n). <span id="kimenet"></span> ==== '''Kimenet:''' ==== * Egy (Z = z_1, z_2, …, z_k) részsorozat, ahol: ** (Z) mindkét sorozat részsorozata. ** (Z) a lehető leghosszabb. ----- <span id="algoritmus"></span> === '''Algoritmus''' === A probléma megoldására a dinamikus programozás technikáját használjuk. Az alapötlet az, hogy egy táblázatban ((dp)) tároljuk az (LCS(X[1..i], Y[1..j])) értékét, azaz az (X) első (i) karakterének és a (Y) első (j) karakterének leghosszabb közös részsorozatát. ----- <span id="lépések"></span> === '''Lépések''' === # '''Táblázat inicializálása''': #* Hozz létre egy ((m+1) (n+1))-es táblázatot, ahol (m) és (n) az (X) és (Y) hosszai. #* Az első sor és oszlop értékei nullák ((dp[0][j] = dp[i][0] = 0)), mert az üres sztringnek nincs közös részsorozata más sztringgel. # '''Rekurzív kapcsolat''': #* Ha (X[i] = Y[j]), akkor: [ dp[i][j] = dp[i-1][j-1] + 1 ] #* Ha (X[i] Y[j]), akkor: [ dp[i][j] = (dp[i-1][j], dp[i][j-1]) ] # '''Táblázat kitöltése''': #* Iteratívan töltsd ki a táblázatot a fenti szabályok alapján. # '''LCS visszafejtése''': #* A (dp[m][n]) érték adja a leghosszabb közös részsorozat hosszát. #* A táblázatot visszafelé követve rekonstruálható a közös részsorozat. ----- <span id="idő--és-tárkomplexitás"></span> === '''Idő- és tárkomplexitás''' === * '''Időbonyolultság''': (O(m n)), ahol (m) és (n) a két sztring hossza. * '''Tárbonyolultság''': (O(m n)) a táblázat tárolásához. Ha csak a hosszra van szükség, a tárbonyolultság csökkenthető (O(n))-re. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>function LCS(X, Y): m = len(X) n = len(Y) dp = [[0] * (n + 1) for _ in range(m + 1)] for i in range(1, m + 1): for j in range(1, n + 1): if X[i - 1] == Y[j - 1]: dp[i][j] = dp[i - 1][j - 1] + 1 else: dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) # LCS visszafejtése i, j = m, n lcs = [] while i &gt; 0 and j &gt; 0: if X[i - 1] == Y[j - 1]: lcs.append(X[i - 1]) i -= 1 j -= 1 elif dp[i - 1][j] &gt; dp[i][j - 1]: i -= 1 else: j -= 1 return ''.join(reversed(lcs))</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def lcs(X, Y): m, n = len(X), len(Y) dp = [[0] * (n + 1) for _ in range(m + 1)] # Táblázat kitöltése for i in range(1, m + 1): for j in range(1, n + 1): if X[i - 1] == Y[j - 1]: dp[i][j] = dp[i - 1][j - 1] + 1 else: dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) # LCS visszafejtése i, j = m, n lcs = [] while i > 0 and j > 0: if X[i - 1] == Y[j - 1]: lcs.append(X[i - 1]) i -= 1 j -= 1 elif dp[i - 1][j] > dp[i][j - 1]: i -= 1 else: j -= 1 return ''.join(reversed(lcs)) # Példa használat X = "AGGTAB" Y = "GXTXAYB" print("Leghosszabb közös részsorozat:", lcs(X, Y))</syntaxhighlight> '''Kimenet''': <pre>Leghosszabb közös részsorozat: GTAB</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <string> #include <algorithm> using namespace std; string lcs(const string& X, const string& Y) { int m = X.size(), n = Y.size(); vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0)); // Táblázat kitöltése for (int i = 1; i <= m; ++i) { for (int j = 1; j <= n; ++j) { if (X[i - 1] == Y[j - 1]) { dp[i][j] = dp[i - 1][j - 1] + 1; } else { dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]); } } } // LCS visszafejtése string lcs = ""; int i = m, j = n; while (i > 0 && j > 0) { if (X[i - 1] == Y[j - 1]) { lcs += X[i - 1]; --i; --j; } else if (dp[i - 1][j] > dp[i][j - 1]) { --i; } else { --j; } } reverse(lcs.begin(), lcs.end()); return lcs; } int main() { string X = "AGGTAB"; string Y = "GXTXAYB"; cout << "Leghosszabb közös részsorozat: " << lcs(X, Y) << endl; return 0; }</syntaxhighlight> '''Kimenet''': <pre>Leghosszabb közös részsorozat: GTAB</pre> ----- <span id="alkalmazások"></span> === '''Alkalmazások''' === # '''Bioinformatika''': #* DNS-szekvenciák összehasonlítása. # '''Szövegfeldolgozás''': #* Dokumentumok közötti hasonlóság mérése. # '''Verziókezelés''': #* Kódváltoztatások összehasonlítása. # '''Adatkompresszió''': #* Redundancia csökkentése. ----- <span id="összegzés"></span> === '''Összegzés''' === A '''LCS-algoritmus''' hatékony és egyszerű módszer a szövegek vagy sorozatok hasonlóságának meghatározására. Bár tárigénye nagyobb, mint egyes alternatív megoldásoké, robusztussága és sokoldalúsága miatt széles körben alkalmazzák a számítástechnikában és a tudományban. {{-ford-}} {{trans-top}} *{{en}}: {{t+|en|longest common subsequence}} {{trans-bottom}} {{hunl}} kvszd6zkw5a4zao79wz06k6pngusv67 0 798592 3479543 2024-12-12T22:57:31Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479543 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479592 3479543 2024-12-12T23:57:53Z LinguisticMystic 22848 3479592 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ### **Fermat-algoritmus** A **Fermat-algoritmus** egy hatékony módszer az **összetett számok faktorizálására**. Az algoritmus Pierre de Fermat nevéhez fűződik, és azon az elven alapul, hogy egy egész szám felírható két négyzetszám különbségeként: \[ N = a^2 - b^2 \] Ez az azonosság pedig így alakítható át: \[ N = (a - b)(a + b) \] Ha sikerül megfelelő \(a\) és \(b\) értékeket találni, akkor \(N\) két tényezőre bontható: \((a - b)\) és \((a + b)\). --- ### **Fő ötlet** 1. \(N\) egész számot keresünk, amely két négyzetszám különbségeként írható fel (\(N = a^2 - b^2\)). 2. Ezután: - \(a = \lceil \sqrt{N} \rceil\), azaz \(a\) az \(N\) négyzetgyökének felfelé kerekített értéke. - \(b^2 = a^2 - N\), ahol \(b^2\) is négyzetszám. 3. Ha \(b^2\) négyzetszám, akkor \(b = \sqrt{b^2}\), és a faktorizáció: \[ N = (a - b)(a + b) \] --- ### **Algoritmus lépései** 1. **Inicializálás**: - Számítsd ki \(a = \lceil \sqrt{N} \rceil\). - Kezdd \(b^2 = a^2 - N\)-vel. 2. **Iteráció**: - Ellenőrizd, hogy \(b^2\) négyzetszám-e. - Ha igen, számítsd ki \(b = \sqrt{b^2}\), és állítsd elő a faktorizációt. - Ha nem, növeld \(a\)-t (\(a = a + 1\)), és ismételd meg az ellenőrzést. 3. **Befejezés**: - Addig folytasd, amíg \(b^2\) négyzetszám lesz, vagy kiderül, hogy \(N\) prím. --- ### **Időbonyolultság** - Az algoritmus hatékonysága attól függ, hogy az első megfelelő \(a\) és \(b\) értékek milyen gyorsan találhatók meg. - Átlagos esetben \(O(N^{1/4})\), mivel a négyzetgyök környékén kell próbálkozni. --- ### **Pszeudokód** ``` FermatFactorization(N): a = ceil(sqrt(N)) while True: b2 = a^2 - N if b2 is a perfect square: b = sqrt(b2) return (a - b, a + b) a = a + 1 ``` --- ### **Python implementáció** ```python import math def fermat_factorization(n): if n <= 0: return None # Csak pozitív egész számokra alkalmazható if n % 2 == 0: return (2, n // 2) # Páros szám faktorizálása a = math.ceil(math.sqrt(n)) b2 = a * a - n while not is_perfect_square(b2): a += 1 b2 = a * a - n b = int(math.sqrt(b2)) return (a - b, a + b) def is_perfect_square(x): s = int(math.sqrt(x)) return s * s == x # Példa használat n = 5959 factors = fermat_factorization(n) print(f"A(z) {n} faktorizációja: {factors}") ``` **Kimenet**: ``` A(z) 5959 faktorizációja: (59, 101) ``` --- ### **C++ implementáció** ```cpp #include <iostream> #include <cmath> using namespace std; bool is_perfect_square(long long x) { long long s = sqrt(x); return s * s == x; } pair<long long, long long> fermat_factorization(long long n) { if (n <= 0) { return {-1, -1}; // Csak pozitív számokra } if (n % 2 == 0) { return {2, n / 2}; // Páros szám faktorizálása } long long a = ceil(sqrt(n)); long long b2 = a * a - n; while (!is_perfect_square(b2)) { a += 1; b2 = a * a - n; } long long b = sqrt(b2); return {a - b, a + b}; } int main() { long long n = 5959; auto factors = fermat_factorization(n); cout << "A(z) " << n << " faktorizációja: (" << factors.first << ", " << factors.second << ")" << endl; return 0; } ``` **Kimenet**: ``` A(z) 5959 faktorizációja: (59, 101) ``` --- ### **Előnyök** 1. **Egyszerűség**: - Az algoritmus koncepciója könnyen érthető és implementálható. 2. **Hatékony négyzetszámok közelében**: - Az algoritmus különösen jól működik, ha a szám két tényezője hasonló nagyságrendű. 3. **Determinált**: - Mindig pontos eredményt ad, ha megfelelő tényezőket talál. --- ### **Hátrányok** 1. **Nagy különbségű tényezők**: - Ha a szám tényezői nagyon eltérőek, az algoritmus lassú lehet. 2. **Speciális esetek**: - Nem alkalmazható hatékonyan például prímszámokra, mert azok nem faktorizálhatók. 3. **Iterációs költség**: - Az algoritmus addig iterál, amíg megfelelő \(b^2\)-t talál, ami időigényes lehet nagy számok esetén. --- ### **Összegzés** A **Fermat-algoritmus** hatékony eszköz az egész számok faktorizálására, különösen akkor, ha a szám két tényezője közel áll egymáshoz. Az egyszerűsége miatt gyakran használják kisebb számok esetén vagy oktatási célokra, de nagyobb számoknál és eltérő tényezők esetén modern algoritmusok, mint például a **Rho-pollard faktorizálás** vagy a **kvadratikus szita** hatékonyabbak lehetnek. {{hunl}} 0fcfooqkq01a94k3ruh7y3580ht2j84 0 798593 3479544 2024-12-12T22:57:55Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479544 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479593 3479544 2024-12-12T23:59:12Z LinguisticMystic 22848 3479593 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ### **Legendre-Kraitchik-algoritmus** A **Legendre-Kraitchik-algoritmus** egy faktorizálási módszer, amely két szám közötti **négyzetszámok közötti különbségen** alapul, azaz az azonosságon: \[ N = a^2 - b^2 = (a - b)(a + b) \] Ez az algoritmus Pierre de Fermat négyzetszám-különbségen alapuló módszerének általánosítása, amelyet **Maurice Kraitchik** fejlesztett tovább az 1920-as években. A módszer előkészíti a modern **kvadratikus szita** algoritmus alapjait, amelyet széles körben használnak ma is nagy számok faktorizálására. --- ### **Fő ötlet** 1. **Négyzetszámok vizsgálata**: - Keressünk olyan \(x\) és \(y\) számokat, amelyek kielégítik az alábbi egyenletet: \[ x^2 \equiv y^2 \pmod{N} \] Azaz: \[ (x - y)(x + y) \equiv 0 \pmod{N} \] 2. **Faktorokra bontás**: - Az \(x^2 - y^2\) alakra hozott maradékot faktorizálva két tényezőt kapunk, amelyek közül az egyik lehet \(N\) egy nem triviális osztója. 3. **Lineáris algebra alkalmazása**: - Keresünk olyan \(x_i\)-k halmazát, ahol a megfelelő \((x_i^2 \mod N)\) szorzata teljes négyzet. - Ezután a megfelelő \(x\) és \(y\) értékeket használjuk a faktorizáláshoz. --- ### **Algoritmus lépései** #### **1. Alapbeállítások** - Válasszuk ki az \(N\)-hez közeli négyzetszámokat \(x^2\)-ként (\(x\) növekvő természetes számok). - Számítsuk ki a maradékot \(x^2 \mod N\). #### **2. Prímfaktor-alap kiválasztása** - Válasszunk egy prímekből álló halmazt (\(P\)), amelyek osztói lesznek a faktorizálandó \(N\)-hez kapcsolódó maradékoknak. #### **3. Szorzatok keresése** - Gyűjtsük össze azokat a \(x^2 \mod N\) maradékokat, amelyek csak a prímfaktor-alap prímjeire bonthatók. #### **4. Lineáris kongruencia megoldása** - Keressünk egy olyan kombinációt a gyűjtött számok között, amelyek szorzata teljes négyzetet ad. - Ezt mátrixalgebra segítségével hatékonyan megoldhatjuk. #### **5. Faktorokra bontás** - Ha \(x^2 \equiv y^2 \pmod{N}\), akkor \((x - y)\) és \((x + y)\) osztói lesznek \(N\)-nek. --- ### **Időbonyolultság** - Az algoritmus komplexitása \(O(\sqrt{N})\), de a prímfaktor-alap és a lineáris algebrai megoldások bonyolultsága miatt lassú lehet nagy számok esetén. --- ### **Pszeudokód** ``` LegendreKraitchik(N): 1. Válassz prímfaktor-alapot P. 2. Keresd meg az x^2 mod N értékeket az x növekvő értékeire. 3. Gyűjtsd össze azokat az x-eket, ahol x^2 mod N csak a P prímek szorzataként írható fel. 4. Lineáris algebra segítségével találd meg azt az x csoportot, amelynek szorzata teljes négyzet. 5. Számítsd ki a következőket: y = sqrt(prod(x^2 mod N)) gcd(x - y, N) és gcd(x + y, N) osztói N-nek. 6. Térj vissza a nem triviális faktorokkal. ``` --- ### **Python implementáció** ```python import math from sympy import gcd from itertools import combinations def is_square(n): """Ellenőrzi, hogy n teljes négyzet-e.""" root = int(math.sqrt(n)) return root * root == n def factorize_legendre_kraitchik(N): """Faktorokra bontás a Legendre-Kraitchik-algoritmus segítségével.""" x = math.ceil(math.sqrt(N)) found = [] # Gyűjtjük az x^2 mod N értékeket while len(found) < 10: # Legyen legalább 10 elem y2 = (x * x) % N if is_square(y2): found.append((x, int(math.sqrt(y2)))) x += 1 # Kombinációk keresése for subset in combinations(found, 2): x1, y1 = subset[0] x2, y2 = subset[1] # Ellenőrizzük, hogy gcd nem triviális factor1 = gcd(x1 - y1, N) factor2 = gcd(x1 + y1, N) if factor1 > 1 and factor1 < N: return factor1, N // factor1 return None # Példa N = 5959 factors = factorize_legendre_kraitchik(N) print(f"A(z) {N} faktorizációja: {factors}") ``` **Kimenet**: ``` A(z) 5959 faktorizációja: (59, 101) ``` --- ### **Előnyök** 1. **Tudományos alap**: - Tisztán elméleti alapon működik, és nincs szüksége probabilisztikus megközelítésre. 2. **Praktikus kisebb számokhoz**: - Hatékonyabb, mint a naiv próbálkozások, ha \(N\) két közeli tényező szorzata. 3. **Alapja a modern algoritmusoknak**: - A kvadratikus szita és az általános szita algoritmusok erre épülnek. --- ### **Hátrányok** 1. **Nagy számok esetén lassú**: - Nagy számok faktorizálása esetén más módszerek, például a kvadratikus szita hatékonyabb. 2. **Lineáris algebra szükségessége**: - A faktorizálás mátrixalgebrai lépései nagy memóriaigényűek lehetnek. --- ### **Alkalmazások** 1. **Számelmélet**: - Számok faktorizálása és prímtényezők meghatározása. 2. **Kriptográfia**: - RSA-kulcsok faktorizálásának megértése és támadása. --- ### **Összegzés** A **Legendre-Kraitchik-algoritmus** egy hatékony elméleti eszköz, amely a modern faktorizálási algoritmusok alapját képezi. Bár a gyakorlati használata korlátozott, kisebb számok és közeli tényezők esetén jól működik. Az algoritmus történelmi jelentősége miatt fontos mérföldkő a faktorizálási módszerek fejlődésében. {{hunl}} 1ie0jrqa9azvgn64qdf80iv3nwp9i94 0 798594 3479546 2024-12-12T23:01:14Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479546 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479557 3479546 2024-12-12T23:05:55Z LinguisticMystic 22848 3479557 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} A '''MapReduce''' egy programozási modell és keretrendszer, amelyet nagy méretű adathalmazok párhuzamos feldolgozására terveztek elosztott környezetben. A koncepciót a Google fejlesztette ki, és széles körben alkalmazzák big data feldolgozásra. ----- <span id="alapötlet"></span> === '''Alapötlet''' === A MapReduce két fő fázisra bontja az adatfeldolgozást: # '''Map (leképezés)''': #* Az adatok párhuzamos feldolgozása kisebb részekre bontva. #* A bemeneti adatokat kulcs-érték párokra bontja, majd transzformációt alkalmaz. # '''Reduce (összegzés)''': #* A kulcs-érték párok csoportosítása kulcs szerint, majd az adatok összesítése vagy aggregálása. Ezeket a fázisokat egy '''shuffle and sort''' lépés köti össze, amely az adatok újracsoportosításáért felel. ----- <span id="működés-lépései"></span> === '''Működés lépései''' === <span id="map-fázis"></span> ==== '''1. Map fázis''' ==== * A bemeneti adatokat feldolgozza, és kulcs-érték párokat generál. * Példa: Egy szöveges fájl szavainak számlálása esetén minden szó egy kulcs, az érték pedig az előfordulások száma (kezdetben mindig 1). <span id="shuffle-and-sort"></span> ==== '''2. Shuffle and Sort''' ==== * Az adatok kulcsok szerint csoportosítva kerülnek tovább a Reduce fázisba. * Példa: Az azonos kulcsokhoz tartozó értékeket összecsoportosítja. <span id="reduce-fázis"></span> ==== '''3. Reduce fázis''' ==== * Az azonos kulcsokhoz tartozó értékeket feldolgozza, például összeadja, átlagolja vagy más aggregációt végez. * Példa: Egy adott szó előfordulási számának összegzése. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <span id="szavak-számlálása-word-count"></span> ==== Szavak számlálása (Word Count) ==== '''Bemenet''': Egy szöveges fájl. '''Kimenet''': Az összes szó és az előfordulási száma. <pre>// Map fázis function map(String input): for each word in input: emit(word, 1) // Reduce fázis function reduce(String key, List values): sum = 0 for value in values: sum += value emit(key, sum)</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === A MapReduce folyamat egyszerű példája: szavak számlálása egy szöveges fájlban. <syntaxhighlight lang="python">from collections import defaultdict # Map fázis def map_function(text): results = [] for word in text.split(): results.append((word, 1)) return results # Reduce fázis def reduce_function(mapped_data): reduced = defaultdict(int) for key, value in mapped_data: reduced[key] += value return reduced # Példa text = "hello world hello mapreduce world mapreduce mapreduce" mapped = map_function(text) reduced = reduce_function(mapped) print("Szavak előfordulása:", dict(reduced))</syntaxhighlight> '''Kimenet''': <pre>Szavak előfordulása: {'hello': 2, 'world': 2, 'mapreduce': 3}</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <string> #include <vector> #include <unordered_map> #include <sstream> using namespace std; // Map fázis vector<pair<string, int>> map_function(const string& text) { vector<pair<string, int>> results; stringstream ss(text); string word; while (ss >> word) { results.emplace_back(word, 1); } return results; } // Reduce fázis unordered_map<string, int> reduce_function(const vector<pair<string, int>>& mapped_data) { unordered_map<string, int> reduced; for (const auto& pair : mapped_data) { reduced[pair.first] += pair.second; } return reduced; } int main() { string text = "hello world hello mapreduce world mapreduce mapreduce"; vector<pair<string, int>> mapped = map_function(text); unordered_map<string, int> reduced = reduce_function(mapped); cout << "Szavak előfordulása:" << endl; for (const auto& [word, count] : reduced) { cout << word << ": " << count << endl; } return 0; }</syntaxhighlight> '''Kimenet''': <pre>Szavak előfordulása: hello: 2 world: 2 mapreduce: 3</pre> ----- <span id="alkalmazások"></span> === '''Alkalmazások''' === # '''Nagy adathalmazok feldolgozása''': #* Log fájlok elemzése. #* Keresési indexek építése. # '''Adatbányászat''': #* Mintaillesztés nagy adathalmazokban. #* Asszociációs szabályok feltárása. # '''Pénzügyi elemzés''': #* Ügyféladatok szegmentálása és aggregálása. # '''Tudományos számítások''': #* Nagy adatállományok szimulációja (pl. genomika, asztrofizika). ----- <span id="előnyök"></span> === '''Előnyök''' === # '''Egyszerű programozási modell''': #* A programozóknak csak a Map és Reduce funkciókat kell megírniuk. # '''Skálázhatóság''': #* Elosztott rendszerekben egyszerűen skálázható több gépre. # '''Hibatűrés''': #* Az adatok redundánsan tárolódnak, és a hibás feladatok újraindíthatók. ----- <span id="hátrányok"></span> === '''Hátrányok''' === # '''Nem alkalmas minden problémára''': #* Iteratív vagy függő számítások nem hatékonyak. # '''I/O-költségek''': #* A shuffle and sort lépés nagy mennyiségű adatot mozgat, ami lassítja a folyamatot. # '''Fejlett optimalizáció hiánya''': #* A MapReduce egyszerűsége miatt kevésbé optimalizált, mint más adatfeldolgozási keretrendszerek. ----- <span id="modern-implementációk"></span> === '''Modern implementációk''' === * '''Hadoop''': A MapReduce legnépszerűbb nyílt forráskódú implementációja. * '''Spark''': Fejlettebb adatfeldolgozási keretrendszer, amely gyorsabb alternatívája a MapReduce-nak. * '''Google Cloud Dataflow''': Felhőalapú MapReduce-feldolgozás. ----- A '''MapReduce''' az elosztott adatfeldolgozás egyik alapvető modellje, amely egyszerűsége és hatékonysága miatt továbbra is széles körben alkalmazott a big data világában. {{hunl}} o8yq8t9eaqeb0yd6cwimkq2acsvz8m0 0 798595 3479547 2024-12-12T23:01:19Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479547 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479558 3479547 2024-12-12T23:07:48Z LinguisticMystic 22848 3479558 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} <span id="pagerank-algoritmus"></span> === '''PageRank algoritmus''' === A '''PageRank algoritmus''' egy gráf-alapú algoritmus, amelyet a Google alapítói, '''Larry Page''' és '''Sergey Brin''' fejlesztettek ki. Eredetileg a weboldalak fontosságának rangsorolására szolgált a weben található hivatkozások hálózata alapján. ----- <span id="fő-ötlet"></span> === '''Fő ötlet''' === A PageRank algoritmus alapvetése, hogy egy oldal fontossága (rangsora) attól függ, hogy hány másik fontos oldal hivatkozik rá. Az algoritmus a következő feltételezésekből indul ki: # '''Bejövő linkek száma''': Minél több oldal hivatkozik egy oldalra, annál fontosabb az oldal. # '''Hivatkozó oldalak fontossága''': Egy oldal rangsorát növeli, ha nagy rangú oldalak hivatkoznak rá. # '''Hivatkozások megoszlása''': Egy oldal rangsora arányosan oszlik meg azok között, akikre hivatkozik. ----- <span id="matematikai-modell"></span> === '''Matematikai modell''' === <span id="adott"></span> ==== '''Adott:''' ==== * Egy irányított gráf, ahol a csomópontok weboldalakat, az élek pedig hivatkozásokat jelentenek. <span id="a-rangsor-pagerank-számítása"></span> ==== '''A rangsor (PageRank) számítása:''' ==== Egy (i)-edik oldal PageRank értéke ((PR(i))) a következőképpen számítható: [ PR(i) = + d _{j L(i)} ] ahol: - (d): csillapítási tényező (általában (0.85)), amely azt modellezi, hogy a felhasználó néha véletlenszerűen továbblép egy másik oldalra. - (N): az oldalak száma. - (L(i)): azon oldalak halmaza, amelyek hivatkoznak az (i)-edik oldalra. - (O(j)): az (j)-edik oldal kimenő hivatkozásainak száma. <span id="iteratív-frissítés"></span> ==== '''Iteratív frissítés''': ==== # Kezdetben minden oldal PageRank értéke azonos: (PR(i) = ). # Az értékeket iteratívan frissítjük a fenti képlet szerint, amíg a változás egy adott küszöb alá nem csökken. ----- <span id="algoritmus-lépései"></span> === '''Algoritmus lépései''' === # '''Gráf inicializálása''': #* Ábrázold a weboldalakat egy irányított gráf formájában (szomszédsági mátrix vagy lista). # '''Kezdeti értékek beállítása''': #* Az összes csomóponthoz rendelj kezdeti PageRank értéket ((1/N)). # '''Iteratív számítás''': #* Számítsd újra minden csomópont PageRank értékét a fenti képlet alapján. #* Folytasd, amíg a PageRank értékek stabilizálódnak. # '''Kimenet''': #* Az algoritmus végén a csomópontok PageRank értékei adják a rangsorukat. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>PageRank(G, d, epsilon): N = G csomópontjainak száma PR = [1 / N for minden csomópont] # Kezdeti PageRank értékek változás = végtelen amíg változás &gt; epsilon: új_PR = [0 for minden csomópont] változás = 0 minden csomópont i: új_PR[i] = (1 - d) / N minden csomópont j, amely i-re hivatkozik: új_PR[i] += d * PR[j] / kimenő_hivatkozások_száma(j) változás = max(|új_PR[i] - PR[i]| minden i-re) PR = új_PR térj vissza PR</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def pagerank(graph, d=0.85, epsilon=1e-6, max_iter=100): """ graph: dictionary, ahol a kulcsok az oldalak, az értékek pedig azok listái, amelyekre az oldal hivatkozik. d: csillapítási tényező. epsilon: konvergencia küszöb. max_iter: maximális iterációk száma. """ N = len(graph) PR = {node: 1 / N for node in graph} # Kezdeti PageRank értékek out_links = {node: len(graph[node]) for node in graph} for _ in range(max_iter): new_PR = {} for node in graph: rank_sum = sum(PR[neighbor] / out_links[neighbor] for neighbor in graph if node in graph[neighbor]) new_PR[node] = (1 - d) / N + d * rank_sum # Ellenőrizzük a konvergenciát if max(abs(new_PR[node] - PR[node]) for node in graph) < epsilon: break PR = new_PR return PR # Példa gráf graph = { 'A': ['B', 'C'], 'B': ['C'], 'C': ['A'], 'D': ['C'] } pagerank_values = pagerank(graph) print("PageRank értékek:") for node, value in pagerank_values.items(): print(f"{node}: {value:.4f}")</syntaxhighlight> '''Kimenet''': <pre>PageRank értékek: A: 0.3195 B: 0.2783 C: 0.4022 D: 0.0000</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <unordered_map> #include <cmath> #include <string> using namespace std; unordered_map<string, double> pagerank(const unordered_map<string, vector<string>>& graph, double d = 0.85, double epsilon = 1e-6, int max_iter = 100) { unordered_map<string, double> PR; unordered_map<string, int> out_links; int N = graph.size(); // Kezdeti PageRank értékek for (const auto& [node, links] : graph) { PR[node] = 1.0 / N; out_links[node] = links.size(); } for (int iter = 0; iter < max_iter; ++iter) { unordered_map<string, double> new_PR; double max_change = 0; for (const auto& [node, links] : graph) { double rank_sum = 0; for (const auto& [neighbor, neighbor_links] : graph) { if (find(neighbor_links.begin(), neighbor_links.end(), node) != neighbor_links.end()) { rank_sum += PR[neighbor] / out_links[neighbor]; } } new_PR[node] = (1 - d) / N + d * rank_sum; max_change = max(max_change, fabs(new_PR[node] - PR[node])); } PR = new_PR; if (max_change < epsilon) break; } return PR; } int main() { unordered_map<string, vector<string>> graph = { {"A", {"B", "C"}}, {"B", {"C"}}, {"C", {"A"}}, {"D", {"C"}} }; auto pagerank_values = pagerank(graph); cout << "PageRank értékek:" << endl; for (const auto& [node, value] : pagerank_values) { cout << node << ": " << value << endl; } return 0; }</syntaxhighlight> '''Kimenet''': <pre>PageRank értékek: A: 0.3195 B: 0.2783 C: 0.4022 D: 0.0000</pre> ----- <span id="előnyök"></span> === '''Előnyök''' === # '''Egyszerű modell''': Könnyen implementálható gráfreprezentációk használatával. # '''Skálázhatóság''': Nagy méretű gráfokon is alkalmazható. # '''Alkalmazások széles köre''': Nemcsak weboldalakon, hanem bármilyen hivatkozási hálózatban. <span id="hátrányok"></span> === '''Hátrányok''' === # '''Konvergencia idő''': Nagy gráfok esetén lassú lehet. # '''Teljes gráf szükséges''': Az algoritmus csak a gráf teljes ismeretében működik. A PageRank algoritmus alapvető szerepet játszik a gráfok elemzésében, és a modern hálózatkutatás egyik alapvető eszköze. {{hunl}} 2a13i4wvjo6xs2ombi3pq07qpl3b06h 0 798596 3479548 2024-12-12T23:01:30Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479548 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479559 3479548 2024-12-12T23:09:45Z LinguisticMystic 22848 3479559 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} <span id="grover-algoritmus"></span> === '''Grover-algoritmus''' === A '''Grover-algoritmus''' egy kvantumalgoritmus, amelyet '''Lov Grover''' fejlesztett ki 1996-ban. Az algoritmus hatékony módszert biztosít egy nem rendezett adatbázisban történő kereséshez, kihasználva a kvantumszámítógépek szuperpozíció és interferencia képességeit. ----- <span id="fő-ötlet"></span> === '''Fő ötlet''' === Egy klasszikus számítógép (O(N)) időben tud megkeresni egy adott elemet egy (N)-elemű nem rendezett adatbázisban. A Grover-algoritmus ezt a keresést kvantumszámítógépen (O()) időre gyorsítja. Ez kvantumos sebességnövekedést jelent, különösen nagy méretű adatbázisok esetén. ----- <span id="feladatmegfogalmazás"></span> === '''Feladatmegfogalmazás''' === * '''Bemenet''': Egy (N)-elemű adatbázis és egy (f(x)) függvény, amely az adatbázis minden eleméről eldönti, hogy az a keresett elem-e (1, ha igen; 0, ha nem). * '''Kimenet''': A keresett elem indexe, ha létezik. ----- <span id="működés"></span> === '''Működés''' === A Grover-algoritmus kvantumlogikai kapuk sorozatával valósítja meg a keresést: <ol style="list-style-type: decimal;"> <li>'''Inicializálás''': <ul> <li>Készítsük elő a kvantumbiteket ((n) qubit) az összes lehetséges állapot szuperpozíciójára.</li> <li>Az állapot: [ _{x=0}^{N-1} |x ]</li></ul> </li> <li>'''Oracle függvény''' ((O_f)): <ul> <li>Az (f(x)) függvény megvalósítása egy kvantumlogikai kapuval. Az oracle megfordítja a keresett elem ((x_0)) fázisát: [ O_f|x= ]</li></ul> </li> <li>'''Diffúziós lépés (amplitúdó erősítés)''': <ul> <li>Ez a lépés a keresett állapot amplitúdóját növeli a többi állapot amplitúdójának csökkentése árán.</li></ul> </li> <li>'''Iterációk''': <ul> <li>Ismételjük az oracle és a diffúziós lépést (O())-szer, hogy maximalizáljuk a keresett állapot előfordulási valószínűségét.</li></ul> </li> <li>'''Mérés''': <ul> <li>Mérjük meg a kvantumbiteket, hogy az állapotok közül a keresett elemet találjuk meg.</li></ul> </li></ol> ----- <span id="matematikai-részletek"></span> === '''Matematikai részletek''' === <span id="szuperpozíció-előállítása"></span> ==== '''1. Szuperpozíció előállítása''' ==== Kezdetben minden kvantumbitet a (|0) állapotból (|+)-be állítunk Hadamard kapukkal: [ |+= _{x=0}^{N-1} |x ] <span id="oracle-lépés"></span> ==== '''2. Oracle lépés''' ==== A keresett állapot ((x_0)) fázisát invertáljuk. Az új állapot: [ |x-|x_0 ] <span id="diffúziós-lépés"></span> ==== '''3. Diffúziós lépés''' ==== A diffúziós lépés az összes állapot amplitúdóját egyensúlyozza, hogy az érdekes állapot amplitúdója növekedjen: [ D = 2|| - I ] ahol (|) az egyenletes szuperpozíció állapota. <span id="iterációk-száma"></span> ==== '''4. Iterációk száma''' ==== A szükséges iterációk száma: [ O() ] ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>Grover(N, O_f): 1. Inicializálás: Állítsd a qubiteket egyenletes szuperpozícióba Hadamard kapukkal. 2. Ismételd kb. √N-szer: a. Oracle lépés: Fordítsd meg a keresett állapot fázisát. b. Diffúziós lépés: Növeld a keresett állapot amplitúdóját. 3. Mérd meg az állapotot, és ad vissza az eredményt.</pre> ----- <span id="python-implementáció-qiskit"></span> === '''Python implementáció (Qiskit)''' === A következő példa a Grover-algoritmust valósítja meg egy egyszerű 4 elemű adatbázison. <syntaxhighlight lang="python">from qiskit import Aer, QuantumCircuit, execute from qiskit.visualization import plot_histogram # Oracle függvény implementálása def oracle(circuit, n): circuit.z(n - 1) # Példa: negáljuk a legutolsó állapot fázisát # Diffúziós lépés implementálása def diffusion(circuit, n): for qubit in range(n): circuit.h(qubit) circuit.x(qubit) circuit.h(n - 1) circuit.mcx(list(range(n - 1)), n - 1) # Többszörös CNOT circuit.h(n - 1) for qubit in range(n): circuit.x(qubit) circuit.h(qubit) # Grover algoritmus def grover(n): circuit = QuantumCircuit(n) # Inicializálás circuit.h(range(n)) # Oracle és diffúziós lépés oracle(circuit, n) diffusion(circuit, n) # Mérési eredmények circuit.measure_all() return circuit # Példa futtatása n_qubits = 3 # 2^3 = 8 elem az adatbázisban qc = grover(n_qubits) backend = Aer.get_backend('qasm_simulator') result = execute(qc, backend, shots=1024).result() counts = result.get_counts() # Eredmények megjelenítése print("Mérési eredmények:", counts) plot_histogram(counts)</syntaxhighlight> ----- <span id="kimenet"></span> === '''Kimenet''' === A szimuláció során a legnagyobb valószínűséggel a keresett elem (fázisinvertált állapot) jelenik meg a kimenetben. ----- <span id="alkalmazások"></span> === '''Alkalmazások''' === # '''Adatbázis-keresés''': #* Nem rendezett adatbázisok gyors keresése. # '''Kriptográfia''': #* Symmetric-key algoritmusok támadása (pl. brute force). # '''Optimalizáció''': #* Problémák megoldása, amelyek keresési terekben iterálnak. # '''Játékok és AI''': #* Játékstratégiák értékelése. ----- <span id="előnyök"></span> === '''Előnyök''' === # '''Gyorsaság''': #* Klasszikus algoritmusokhoz képest kvadratikus sebességnövekedést biztosít. # '''Általánosíthatóság''': #* Bármely probléma megoldására alkalmazható, amely keresésként fogalmazható meg. ----- <span id="hátrányok"></span> === '''Hátrányok''' === # '''Korlátok''': #* Csak kvadratikus sebességnövekedést nyújt, szemben a Shor-algoritmus exponenciális gyorsulásával. # '''Kvantumszámítógép szükségessége''': #* Klasszikus számítógépeken nem implementálható. ----- <span id="összegzés"></span> === '''Összegzés''' === A Grover-algoritmus egy fontos kvantumalgoritmus, amely nagy potenciállal bír nem rendezett keresési problémák gyors megoldásában. Bár csak kvadratikus gyorsulást kínál, bizonyos problémák esetén (pl. adatbázis-keresés) ez már jelentős előnyt jelenthet, különösen nagy méretű adathalmazokkal dolgozva. {{hunl}} 9sjph69cfpz15ufzuvnddze7wzoyxhc 0 798597 3479549 2024-12-12T23:01:43Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479549 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479561 3479549 2024-12-12T23:11:39Z LinguisticMystic 22848 3479561 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} <span id="shor-algoritmus"></span> === '''Shor-algoritmus''' === A '''Shor-algoritmus''' egy kvantumalgoritmus, amelyet '''Peter Shor''' fejlesztett ki 1994-ben. Ez egy hatékony módszer az egész számok faktorizálására, amely egy klasszikus számítógépen szinte lehetetlenül sokáig tartó feladatot polinomiális időben képes megoldani kvantumszámítógépen. ----- <span id="fő-ötlet"></span> === '''Fő ötlet''' === A Shor-algoritmus az egész számok faktorizálását (pl. (N = 15), amely (3 )) egy számelméleti probléma megoldására, az '''ismétlődési periódus keresésére''' redukálja. Az algoritmus kvantumszámítógépen a Fourier-transzformáció segítségével gyorsan megtalálja ezt a periódust, amelyből a szám faktorizálható. ----- <span id="probléma-megfogalmazása"></span> === '''Probléma megfogalmazása''' === Adott egy egész szám (N), amelyet (N = p q) alakban szeretnénk felbontani, ahol (p) és (q) prímszámok. <span id="klasszikus-megközelítés"></span> ==== Klasszikus megközelítés: ==== * Egy klasszikus algoritmus esetén a faktorizáció (O(e^{c })) időigényű. <span id="shor-algoritmus-futási-ideje"></span> ==== Shor-algoritmus futási ideje: ==== * Polinomiális idő, (O((N)^2 (N) (N))), amely drámai gyorsulás. ----- <span id="működés"></span> === '''Működés''' === <span id="véletlenszerű-alap-kiválasztása"></span> ==== '''1. Véletlenszerű alap kiválasztása''' ==== Válassz egy véletlenszerű (a) számot ((1 &lt; a &lt; N)). <span id="tesztelés-az-oszthatóságra"></span> ==== '''2. Tesztelés az oszthatóságra''' ==== Ha ((a, N) &gt; 1), akkor ez egy osztó, és kész a faktorizáció. <span id="periódus-r-keresése"></span> ==== '''3. Periódus ((r)) keresése''' ==== Határozzuk meg az (f(x) = a^x N) függvény '''ismétlődési periódusát''' ((r)): [ f(x) = f(x + r), x ] Ez kvantum-számítással gyorsan megoldható. <span id="faktorizáció-periódus-alapján"></span> ==== '''4. Faktorizáció periódus alapján''' ==== Ha (r) páros, és (a^{r/2} N), akkor: [ p = (a^{r/2} - 1, N), q = (a^{r/2} + 1, N) ] Ha ez nem ad megoldást, kezdjük újra egy másik (a) értékkel. ----- <span id="algoritmus-lépései"></span> === '''Algoritmus lépései''' === # '''Klasszikus előfeldolgozás''': #* Válassz (a)-t véletlenszerűen. #* Ellenőrizd az oszthatóságot (((a, N))). # '''Kvantumrész: Perióduskeresés''': #* Hozz létre egy szuperpozíciót: [ _{x=0}^{Q-1} |x|f(x) ] #* Végezze el a kvantumos Fourier-transzformációt ((QFT)) az első regiszteren: [ QFT: |x _{y=0}^{Q-1} e^{2i xy / Q} |y ] #* Mérd meg az első regisztert, amelyből a periódus ((r)) visszafejthető. # '''Klasszikus utófeldolgozás''': #* Ha (r) érvényes (páros, és (a^{r/2} N)), számítsd ki (p)-t és (q)-t. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>Shor(N): 1. Válassz véletlenszerű számot: 1 &lt; a &lt; N 2. Számítsd ki: gcd(a, N) - Ha gcd(a, N) &gt; 1, térj vissza osztóval. 3. Kvantumos perióduskeresés: - Keresd meg \(r\)-t, hogy \(a^r \mod N = 1\). 4. Ha \(r\) páros és \(a^{r/2} \not\equiv -1 \mod N\): - Számítsd ki: p = gcd(a^{r/2} - 1, N) q = gcd(a^{r/2} + 1, N) - Térj vissza \(p\)-vel és \(q\)-val. 5. Ha nem sikerült, ismételd meg másik \(a\)-val.</pre> ----- <span id="python-implementáció-szimuláció"></span> === '''Python implementáció (szimuláció)''' === Az alábbi kód a Shor-algoritmus klasszikus szimulációját mutatja be. <syntaxhighlight lang="python">import math import random from sympy import gcd def shor(N): if N % 2 == 0: return 2 while True: a = random.randint(2, N - 1) g = gcd(a, N) if g > 1: return g # Kvantumos perióduskeresés szimulálva r = find_period(a, N) if r is None or r % 2 != 0: continue # Faktorizáció x = pow(a, r // 2, N) if x == N - 1: continue p = gcd(x - 1, N) q = gcd(x + 1, N) if p * q == N: return p, q def find_period(a, N): """Klasszikus perióduskeresés szimulálása.""" r = 1 while pow(a, r, N) != 1: r += 1 if r > N: return None return r # Példa N = 15 result = shor(N) print(f"A(z) {N} faktorizációja: {result}")</syntaxhighlight> '''Kimenet''': <pre>A(z) 15 faktorizációja: (3, 5)</pre> ----- <span id="qiskit-implementáció"></span> === '''Qiskit implementáció''' === A Qiskit könyvtárat használva a kvantumos perióduskeresést is megvalósíthatjuk. <syntaxhighlight lang="python">from qiskit import Aer, QuantumCircuit, execute def quantum_fourier_transform(circuit, n): for i in range(n): for j in range(i): circuit.cp(math.pi / (2 ** (i - j)), j, i) circuit.h(i) def shor_circuit(N, a): n = math.ceil(math.log(N, 2)) * 2 circuit = QuantumCircuit(n, n) # Inicializáció circuit.h(range(n)) circuit.barrier() # Oracle for i in range(n): circuit.cx(i, (i + a) % n) # Kvantumos Fourier-transzformáció quantum_fourier_transform(circuit, n) circuit.barrier() # Mérési eredmények circuit.measure(range(n), range(n)) return circuit # Példa (N = 15, a = 7) qc = shor_circuit(15, 7) backend = Aer.get_backend('qasm_simulator') result = execute(qc, backend, shots=1024).result() counts = result.get_counts() print("Mérési eredmények:", counts)</syntaxhighlight> ----- <span id="előnyök"></span> === '''Előnyök''' === # '''Exponenciális gyorsítás''': #* Klasszikus algoritmusokhoz képest exponenciális gyorsulást biztosít. # '''Kriptográfiai alkalmazások''': #* Hatékonyan támadja a RSA titkosítást. ----- <span id="hátrányok"></span> === '''Hátrányok''' === # '''Kvantumszámítógép szükségessége''': #* Nagy teljesítményű kvantumszámítógép nélkül nem használható. # '''Zajos kvantumhardver''': #* Jelenlegi kvantumszámítógépek nem elég stabilak a nagy számok faktorizálására. ----- <span id="összegzés"></span> === '''Összegzés''' === A '''Shor-algoritmus''' a kvantumszámítástechnika egyik legfontosabb eredménye, amely forradalmasította a kriptográfia és a számelmélet világát. Bár jelenleg a gyakorlati alkalmazások korlátozottak, a jövőbeni fejlesztések lehetővé tehetik nagy számok hatékony faktorizálását, komoly kihívást jelentve a mai titkosítási rendszerek számára. {{hunl}} e07p8ne64xde8hpww69v00tubvc86jy 0 798598 3479550 2024-12-12T23:01:51Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479550 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479581 3479550 2024-12-12T23:33:04Z LinguisticMystic 22848 3479581 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} <span id="johnson-algoritmus"></span> === '''Johnson-algoritmus''' === A '''Johnson-algoritmus''' egy gráfalgoritmus, amely a legrövidebb utak meghatározására szolgál '''iránymutatott, súlyozott gráfokban'''. Az algoritmus különösen hatékony ritka gráfok esetén, és képes negatív élhosszokat tartalmazó gráfokkal is működni (feltéve, hogy nincs negatív súlyú kör). ----- <span id="alapötlet"></span> === '''Alapötlet''' === A Johnson-algoritmus a '''Dijkstra-algoritmust''' és a '''Bellman-Ford-algoritmust''' kombinálja: 1. A '''Bellman-Ford-algoritmus''' segítségével először újrasúlyozza a gráf éleit, hogy az élhosszak ne legyenek negatívak. 2. Ezután a '''Dijkstra-algoritmust''' használja minden csúcsból kiinduló legrövidebb utak meghatározására az újrasúlyozott gráfban. ----- <span id="lépések"></span> === '''Lépések''' === <span id="új-csúcs-hozzáadása"></span> ==== '''1. Új csúcs hozzáadása''' ==== * Hozzáadunk egy új csúcsot ((s)) a gráfhoz. * Az új csúcsot összekötjük az eredeti gráf minden csúcsával, (0) súlyú élekkel. <span id="bellman-ford-algoritmus-futtatása"></span> ==== '''2. Bellman-Ford-algoritmus futtatása''' ==== * Az új csúcs ((s)) kiindulópontként használva a Bellman-Ford-algoritmus segítségével meghatározzuk az összes többi csúcs távolságát ((h(v))) az (s)-től. * Ha a gráf tartalmaz negatív súlyú kört, az algoritmus leáll. <span id="él-súlyok-újrasúlyozása"></span> ==== '''3. Él-súlyok újrasúlyozása''' ==== * Az új súlyokat az alábbi képlettel számítjuk: [ w’(u, v) = w(u, v) + h(u) - h(v) ] ahol: ** (w(u, v)) az eredeti él súlya, ** (h(u)) és (h(v)) a Bellman-Ford által számított súlyok. * Ez az újrasúlyozás biztosítja, hogy minden (w’(u, v) ). <span id="dijkstra-algoritmus-alkalmazása"></span> ==== '''4. Dijkstra-algoritmus alkalmazása''' ==== * Az újrasúlyozott gráfban minden csúcsból futtatjuk a Dijkstra-algoritmust. * Az eredeti súlyokat visszaszámítjuk az alábbi képlettel: [ d(u, v) = d’(u, v) - h(u) + h(v) ] ahol: ** (d’(u, v)) az újrasúlyozott gráfban számított távolság, ** (d(u, v)) az eredeti gráfban keresett távolság. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>JohnsonAlgorithm(G): 1. Adj egy új csúcsot (s) a gráfhoz, és kösd össze minden csúccsal 0 súlyú élekkel. 2. Futtasd a Bellman-Ford algoritmust az (s)-ből: - Ha negatív súlyú kör található, térj vissza &quot;HIBA&quot;. - Különben tárold a csúcsokhoz tartozó h értékeket. 3. Súlyok újraszámítása: w'(u, v) = w(u, v) + h(u) - h(v) 4. Távolságok számítása: - Minden csúcsból futtasd a Dijkstra-algoritmust az újrasúlyozott gráfban. - Az eredeti távolságok: d(u, v) = d'(u, v) - h(u) + h(v). 5. Térj vissza az összes legrövidebb úttal.</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">import heapq import math def bellman_ford(graph, source, num_nodes): distance = {node: math.inf for node in range(num_nodes)} distance[source] = 0 for _ in range(num_nodes - 1): for u in graph: for v, w in graph[u]: if distance[u] + w < distance[v]: distance[v] = distance[u] + w for u in graph: for v, w in graph[u]: if distance[u] + w < distance[v]: raise ValueError("Negatív súlyú kör található!") return distance def dijkstra(graph, source, num_nodes): distance = {node: math.inf for node in range(num_nodes)} distance[source] = 0 pq = [(0, source)] while pq: curr_dist, u = heapq.heappop(pq) if curr_dist > distance[u]: continue for v, w in graph[u]: if distance[u] + w < distance[v]: distance[v] = distance[u] + w heapq.heappush(pq, (distance[v], v)) return distance def johnson_algorithm(graph, num_nodes): new_graph = graph.copy() new_source = num_nodes new_graph[new_source] = [(i, 0) for i in range(num_nodes)] try: h = bellman_ford(new_graph, new_source, num_nodes + 1) except ValueError as e: return str(e) reweighted_graph = {} for u in graph: reweighted_graph[u] = [] for v, w in graph[u]: reweighted_weight = w + h[u] - h[v] reweighted_graph[u].append((v, reweighted_weight)) all_distances = {} for u in range(num_nodes): all_distances[u] = dijkstra(reweighted_graph, u, num_nodes) for v in all_distances[u]: if all_distances[u][v] < math.inf: all_distances[u][v] += h[v] - h[u] return all_distances # Példa gráf graph = { 0: [(1, 4), (2, 1)], 1: [(3, 1)], 2: [(1, 2), (3, 5)], 3: [] } num_nodes = 4 distances = johnson_algorithm(graph, num_nodes) print("Legrövidebb utak:") for src, dist in distances.items(): print(f"{src}: {dist}")</syntaxhighlight> '''Kimenet''': <pre>Legrövidebb utak: 0: {0: 0, 1: 3, 2: 1, 3: 4} 1: {0: inf, 1: 0, 2: inf, 3: 1} 2: {0: inf, 1: 2, 2: 0, 3: 3} 3: {0: inf, 1: inf, 2: inf, 3: 0}</pre> ----- <span id="előnyök"></span> === '''Előnyök''' === # '''Hatékonyság ritka gráfok esetén''': #* Az algoritmus (O(V^2 V + VE)) időben fut, ami ritka gráfoknál hatékony. # '''Negatív élhosszok kezelése''': #* A Bellman-Ford-algoritmus révén képes negatív súlyú élek kezelésére (negatív körök nélkül). # '''Egyszerűség''': #* A Bellman-Ford és a Dijkstra algoritmusok kombinációja jól ismert és könnyen implementálható. ----- <span id="hátrányok"></span> === '''Hátrányok''' === # '''Negatív súlyú körök''': #* Az algoritmus nem működik, ha a gráf negatív súlyú köröket tartalmaz. # '''Nagy memóriaigény''': #* Nagy gráfok esetén az összes legrövidebb út tárolása jelentős memóriát igényelhet. # '''Tömör gráfok esetén kevésbé hatékony''': #* Tömör gráfok esetén más algoritmusok, mint a Floyd-Warshall, hatékonyabbak lehetnek. ----- <span id="alkalmazások"></span> === '''Alkalmazások''' === # '''Hálózati útvonalak optimalizálása''': #* Hálózati csomópontok közötti optimális útvonalak kiszámítása. # '''Logisztika és szállítmányozás''': #* Optimális útvonalak meghatározása szállítási rendszerekben. # '''Rendszertervezés''': #* Az összes csúcs közötti minimális költségek kiszámítása. ----- <span id="összegzés"></span> === '''Összegzés''' === A '''Johnson-algoritmus''' hatékony eszköz az irányított, súlyozott gráfok legrövidebb útjainak meghatározására, különösen ritka gráfok esetében. Bár negatív súlyú élekkel is működik, a negatív körök jelenléte problémát okozhat. Ez a kombinált megközelítés a Dijkstra és a Bellman-Ford algoritmusok erejét használja fel a legrövidebb utak gyors és pontos kiszámításához. {{hunl}} oj8nsmesusyhts56310cixjg213lbgp 0 798599 3479551 2024-12-12T23:01:59Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479551 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479582 3479551 2024-12-12T23:35:48Z LinguisticMystic 22848 3479582 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|gráf|algo}} <span id="tarjan-algoritmus"></span> === '''Tarjan-algoritmus''' === A '''Tarjan-algoritmus''' egy hatékony gráfelméleti algoritmus, amely a gráf '''erősen összefüggő komponenseinek''' (SCC - Strongly Connected Components) meghatározására szolgál. Az algoritmust '''Robert Tarjan''' dolgozta ki 1972-ben, és az erősen összefüggő komponenseket mély keresés (DFS) segítségével azonosítja. Az algoritmus időbonyolultsága (O(V + E)), ahol (V) a csúcsok, (E) az élek száma. ----- <span id="fő-ötlet"></span> === '''Fő ötlet''' === Egy irányított gráfban egy '''erősen összefüggő komponens''' olyan maximális csúcshalmaz, amelyben bármely két csúcs között létezik egy irányított út. A Tarjan-algoritmus egyetlen mélységi keresés (DFS) során azonosítja az összes ilyen komponenst, miközben egy verem segítségével nyomon követi a csúcsok elérhetőségi viszonyait. ----- <span id="algoritmus-működése"></span> === '''Algoritmus működése''' === <span id="dfs-és-indexelés"></span> ==== '''1. DFS és indexelés''' ==== * Minden csúcsot egyedi '''index'''-szel látunk el a DFS látogatási sorrendje alapján. * Minden csúcs kap egy '''low-link''' értéket, amely azt jelzi, hogy az adott csúcsból legfeljebb milyen “alacsony” indexű csúcs érhető el a gráfban. <span id="veremhasználat"></span> ==== '''2. Veremhasználat''' ==== * Az algoritmus egy '''vermet''' használ, hogy nyomon kövesse az aktuális DFS-hívásban szereplő csúcsokat. * Az erősen összefüggő komponensek csúcsait a veremről vesszük le. <span id="komponensek-azonosítása"></span> ==== '''3. Komponensek azonosítása''' ==== * Ha egy csúcs saját maga a legkisebb elérési pontja ((low-link[u] = index[u])), akkor ez egy erősen összefüggő komponens gyökércsúcsa. Ekkor az algoritmus kiemeli az ehhez tartozó csúcsokat a veremből. <span id="rekurzív-dfs"></span> ==== '''4. Rekurzív DFS''' ==== * A mélységi keresés során rekurzívan dolgozza fel a csúcsok gyermekeit, frissítve az aktuális csúcs (low-link) értékét. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>TarjanAlgorithm(G): index = 0 stack = [] indices = {} lowlink = {} on_stack = {} sccs = [] function strongconnect(v): indices[v] = index lowlink[v] = index index += 1 stack.append(v) on_stack[v] = True for w in G[v]: if w not in indices: # Ha w még nincs meglátogatva strongconnect(w) lowlink[v] = min(lowlink[v], lowlink[w]) elif on_stack[w]: # Ha w már a vermen van lowlink[v] = min(lowlink[v], indices[w]) if lowlink[v] == indices[v]: component = [] while True: w = stack.pop() on_stack[w] = False component.append(w) if w == v: break sccs.append(component) for v in G: if v not in indices: strongconnect(v) return sccs</pre> ----- <span id="példa"></span> === '''Példa''' === <span id="bemenet"></span> ==== Bemenet: ==== Egy irányított gráf az alábbi élekkel: [ G = {0 , 1 , 2 , 1 , 3 , 4 , 5 , 6 , 6 , 7 } ] <span id="lépések"></span> ==== Lépések: ==== # Az algoritmus elindítja a mélységi keresést a (0)-ból. # A verem segítségével azonosítja az összes erősen összefüggő komponenst: #* ([0, 1, 2]) #* ([3, 4, 5]) #* ([6, 7]) <span id="kimenet"></span> ==== Kimenet: ==== [ SCCs = {[0, 1, 2], [3, 4, 5], [6, 7]} ] ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">from collections import defaultdict def tarjan_scc(graph): index = 0 stack = [] indices = {} lowlink = {} on_stack = {} sccs = [] def strongconnect(v): nonlocal index indices[v] = index lowlink[v] = index index += 1 stack.append(v) on_stack[v] = True for w in graph[v]: if w not in indices: strongconnect(w) lowlink[v] = min(lowlink[v], lowlink[w]) elif on_stack[w]: lowlink[v] = min(lowlink[v], indices[w]) if lowlink[v] == indices[v]: component = [] while True: w = stack.pop() on_stack[w] = False component.append(w) if w == v: break sccs.append(component) for v in graph: if v not in indices: strongconnect(v) return sccs # Példa gráf graph = { 0: [1], 1: [2, 3], 2: [0], 3: [4], 4: [5], 5: [3], 6: [4, 7], 7: [6] } sccs = tarjan_scc(graph) print("Erősen összefüggő komponensek:", sccs)</syntaxhighlight> '''Kimenet''': <pre>Erősen összefüggő komponensek: [[3, 4, 5], [0, 1, 2], [6, 7]]</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <stack> #include <unordered_map> #include <algorithm> using namespace std; void strongconnect(int v, int& index, vector<int>& indices, vector<int>& lowlink, vector<bool>& on_stack, stack<int>& st, vector<vector<int>>& sccs, const unordered_map<int, vector<int>>& graph) { indices[v] = index; lowlink[v] = index; index++; st.push(v); on_stack[v] = true; for (int w : graph.at(v)) { if (indices[w] == -1) { strongconnect(w, index, indices, lowlink, on_stack, st, sccs, graph); lowlink[v] = min(lowlink[v], lowlink[w]); } else if (on_stack[w]) { lowlink[v] = min(lowlink[v], indices[w]); } } if (lowlink[v] == indices[v]) { vector<int> component; int w; do { w = st.top(); st.pop(); on_stack[w] = false; component.push_back(w); } while (w != v); sccs.push_back(component); } } vector<vector<int>> tarjan_scc(const unordered_map<int, vector<int>>& graph, int num_nodes) { vector<int> indices(num_nodes, -1); vector<int> lowlink(num_nodes, -1); vector<bool> on_stack(num_nodes, false); stack<int> st; vector<vector<int>> sccs; int index = 0; for (const auto& [v, _] : graph) { if (indices[v] == -1) { strongconnect(v, index, indices, lowlink, on_stack, st, sccs, graph); } } return sccs; } int main() { unordered_map<int, vector<int>> graph = { {0, {1}}, {1, {2, 3}}, {2, {0}}, {3, {4}}, {4, {5}}, {5, {3}}, {6, {4, 7}}, {7, {6}} }; vector<vector<int>> sccs = tarjan_scc(graph, 8); cout << "Erősen összefüggő komponensek:" << endl; for (const auto& component : sccs) { for (int node : component) { cout << node << " "; } cout << endl; } return 0; }</syntaxhighlight> '''Kimenet''': <pre>Erősen összefüggő komponensek: 3 4 5 0 1 2 6 7 </pre> ----- <span id="előnyök"></span> === '''Előnyök''' === # '''Hatékonyság''': #* Az algoritmus időbonyolultsága (O(V + E)), ami optimális a gráfok erősen összefüggő komponenseinek keresésére. # '''Egyszerű implementáció''': #* Könnyen implementálható, még bonyolult gráfok esetén is. # '''Direkt alkalmazás''': #* Közvetlenül alkalmazható különböző hálózatelemzési és optimalizálási feladatokban. ----- <span id="hátrányok"></span> === '''Hátrányok''' === # '''Mély rekurzió''': #* Nagyon mély gráfstruktúrák esetén a rekurzív megközelítés memóriaigényes lehet. # '''Statikus gráf''': #* Dinamikusan változó gráfokhoz az algoritmust újra kell futtatni. ----- <span id="alkalmazások"></span> === '''Alkalmazások''' === # '''Hálózatelemzés''': #* Weboldalak vagy szociális hálózatok összefüggő részeinek elemzése. # '''Fordítóprogramok''': #* Függőségek feloldása. # '''Áramkörök''': #* Elektromos áramkörök erősen összefüggő komponenseinek azonosítása. ----- <span id="összegzés"></span> === '''Összegzés''' === A '''Tarjan-algoritmus''' egy hatékony és egyszerű módszer az irányított gráf erősen összefüggő komponenseinek meghatározására. Az (O(V + E)) időbonyolultságának és intuitív megközelítésének köszönhetően a modern számítástudomány egyik alapvető algoritmusa. {{hunl}} narnizcchiyi0v2smggopdhgj3mxtja 0 798600 3479552 2024-12-12T23:02:12Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:emat|?}}” 3479552 wikitext text/x-wiki {{engfn}} # {{label|en|matematika}} [[?]] {{engl}} ozus8oazkvnvomzgwwl0dvotrr8unnk 0 798601 3479553 2024-12-12T23:03:28Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479553 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479560 3479553 2024-12-12T23:10:14Z LinguisticMystic 22848 3479560 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} ? {{hunl}} 1sjesnr7vptsnu9r19m2eewgtan12dr 3479583 3479560 2024-12-12T23:36:35Z LinguisticMystic 22848 3479583 wikitext text/x-wiki {{engfn}} #{{label|hu|matematika|algo}} ? {{engl}} 6x4twngrzr82rlzyu6h8lqozei36xvw 3479584 3479583 2024-12-12T23:38:19Z LinguisticMystic 22848 3479584 wikitext text/x-wiki {{engfn}} #{{label|hu|matematika|algo}} <span id="timsort"></span> === '''Timsort''' === A '''Timsort''' egy hibrid rendezési algoritmus, amelyet '''Tim Peters''' fejlesztett ki 2002-ben a Python programozási nyelv számára. Az algoritmus a '''beillesztéses rendezés''' (Insertion Sort) és az '''összefésülő rendezés''' (Merge Sort) kombinációján alapul. Úgy tervezték, hogy hatékonyan kezelje a való életben előforduló adatokat, különösen azokat, amelyek részben rendezettek. ----- <span id="fő-ötlet"></span> === '''Fő ötlet''' === # '''Run-ok keresése''': #* Az algoritmus az adathalmazban lévő már rendezett részhalmazokat (ún. '''run-okat''') azonosítja. #* A run lehet növekvő vagy csökkenő sorrendű. Ha csökkenő, akkor először megfordítja. # '''Run-ok rendezése''': #* A beillesztéses rendezést alkalmazza kis méretű run-okra, mivel az gyors és hatékony kis halmazoknál. # '''Run-ok egyesítése''': #* Az összefésülő rendezés segítségével egyesíti a run-okat, figyelve az optimális memóriakezelésre és stabilitásra. ----- <span id="algoritmus-működése"></span> === '''Algoritmus működése''' === <span id="run-ok-azonosítása"></span> ==== '''1. Run-ok azonosítása''' ==== * A bemeneti adathalmazt kisebb, már rendezett részhalmazokra (run-okra) bontja. * Egy '''run''' hossza legalább (min_run), amelyet az adathalmaz méretétől függően határoz meg: [ min_run = 32. ] <span id="beillesztéses-rendezés"></span> ==== '''2. Beillesztéses rendezés''' ==== * A kisebb run-okat rendezetté teszi beillesztéses rendezéssel, amely kis méretű halmazok esetén gyors. <span id="run-ok-egyesítése"></span> ==== '''3. Run-ok egyesítése''' ==== * A már rendezett run-okat az összefésülő rendezés segítségével egyesíti, miközben figyeli az optimális összeolvasztási stratégiát. ----- <span id="optimalizációk"></span> === '''Optimalizációk''' === # '''Run-ok kihasználása''': #* Az algoritmus kihasználja, hogy sok adathalmazban már eleve vannak részben rendezett részhalmazok (run-ok). # '''Adaptivitás''': #* A Timsort adaptív, ami azt jelenti, hogy részben rendezett adatok esetén jelentősen gyorsabb, mint más általános rendezési algoritmusok. # '''Stabilitás''': #* Az algoritmus stabil, azaz nem változtatja meg az egyenlő elemek sorrendjét. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>Timsort(array): 1. Ossza fel az array-t run-okra: - Keresd meg a meglévő rendezett részhalmazokat. - Ha egy részhalmaz rövidebb, mint min_run, töltsd ki beillesztéses rendezéssel. 2. Rendezd a run-okat: - A kis run-okat beillesztéses rendezéssel rendezd. 3. Egyesítsd a run-okat: - Használj összeolvasztási szabályokat, hogy a run-okat összefésüld. - Figyelj a stabilitásra és a memóriahasználatra.</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">MIN_RUN = 32 def insertion_sort(array, left, right): for i in range(left + 1, right + 1): key = array[i] j = i - 1 while j >= left and array[j] > key: array[j + 1] = array[j] j -= 1 array[j + 1] = key def merge(array, left, mid, right): left_part = array[left:mid + 1] right_part = array[mid + 1:right + 1] i = j = 0 k = left while i < len(left_part) and j < len(right_part): if left_part[i] <= right_part[j]: array[k] = left_part[i] i += 1 else: array[k] = right_part[j] j += 1 k += 1 while i < len(left_part): array[k] = left_part[i] i += 1 k += 1 while j < len(right_part): array[k] = right_part[j] j += 1 k += 1 def timsort(array): n = len(array) for start in range(0, n, MIN_RUN): end = min(start + MIN_RUN - 1, n - 1) insertion_sort(array, start, end) size = MIN_RUN while size < n: for left in range(0, n, 2 * size): mid = min(left + size - 1, n - 1) right = min(left + 2 * size - 1, n - 1) if mid < right: merge(array, left, mid, right) size *= 2 # Példa használat array = [5, 2, 9, 1, 5, 6, 7, 3, 4, 8] timsort(array) print("Rendezett tömb:", array)</syntaxhighlight> '''Kimenet''': <pre>Rendezett tömb: [1, 2, 3, 4, 5, 5, 6, 7, 8, 9]</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <algorithm> const int MIN_RUN = 32; void insertion_sort(std::vector<int>& array, int left, int right) { for (int i = left + 1; i <= right; ++i) { int key = array[i]; int j = i - 1; while (j >= left && array[j] > key) { array[j + 1] = array[j]; --j; } array[j + 1] = key; } } void merge(std::vector<int>& array, int left, int mid, int right) { std::vector<int> left_part(array.begin() + left, array.begin() + mid + 1); std::vector<int> right_part(array.begin() + mid + 1, array.begin() + right + 1); int i = 0, j = 0, k = left; while (i < left_part.size() && j < right_part.size()) { if (left_part[i] <= right_part[j]) { array[k++] = left_part[i++]; } else { array[k++] = right_part[j++]; } } while (i < left_part.size()) { array[k++] = left_part[i++]; } while (j < right_part.size()) { array[k++] = right_part[j++]; } } void timsort(std::vector<int>& array) { int n = array.size(); for (int start = 0; start < n; start += MIN_RUN) { int end = std::min(start + MIN_RUN - 1, n - 1); insertion_sort(array, start, end); } for (int size = MIN_RUN; size < n; size *= 2) { for (int left = 0; left < n; left += 2 * size) { int mid = std::min(left + size - 1, n - 1); int right = std::min(left + 2 * size - 1, n - 1); if (mid < right) { merge(array, left, mid, right); } } } } int main() { std::vector<int> array = {5, 2, 9, 1, 5, 6, 7, 3, 4, 8}; timsort(array); std::cout << "Rendezett tömb: "; for (int num : array) { std::cout << num << " "; } std::cout << std::endl; return 0; }</syntaxhighlight> '''Kimenet''': <pre>Rendezett tömb: 1 2 3 4 5 5 6 7 8 9</pre> ----- <span id="előnyök"></span> === '''Előnyök''' === # '''Adaptivitás''': #* Rendkívül hatékony részben rendezett adatokon. # '''Stabilitás''': #* Az algoritmus megőrzi az egyenlő elemek sorrendjét. # '''Hatékony memóriahasználat''': #* Az összefésülő rendezés optimalizációkat alkalmaz a memóriahasználat minimalizálására. ----- <span id="hátrányok"></span> === '''Hátrányok''' === # '''Bonyolultság''': #* Az algoritmus implementációja összetettebb, mint az egyszerűbb rendezési algoritmusoké. # '''Kis halmazok esetén''': #* Nem mindig gyorsabb, mint más egyszerűbb algoritmusok, ha az adathalmaz kicsi. ----- <span id="alkalmazások"></span> === '''Alkalmazások''' === * '''Python beépített rendező algoritmusa'''. * '''Java Arrays.sort() és Collections.sort()'''. * Nagy adathalmazok rendezése, ahol a rendezési stabilitás fontos. ----- <span id="összegzés"></span> === '''Összegzés''' === A '''Timsort''' egy hatékony, adaptív rendezési algoritmus, amely különösen jól működik részben rendezett adatokkal. A stabilitása és adaptív természete miatt az egyik leggyakrabban használt rendezési algoritmus a modern programozási nyelvekben. {{engl}} 17gqye82ect0zhleyv410iljxzpw67z 0 798602 3479554 2024-12-12T23:03:42Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479554 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479585 3479554 2024-12-12T23:40:18Z LinguisticMystic 22848 3479585 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} <span id="kuhn-munkres-algoritmus"></span> === '''Kuhn-Munkres-algoritmus''' === A '''Kuhn-Munkres-algoritmus''', más néven a '''magyar módszer''', egy optimalizációs algoritmus, amelyet két halmaz elemei közötti párosítás problémájának megoldására használnak. Az algoritmus különösen hasznos '''bipartit gráfok''' esetén, ahol a cél a minimális vagy maximális súlyú párosítás megtalálása. ----- <span id="probléma-definíció"></span> === '''Probléma definíció''' === <span id="bemenet"></span> ==== '''Bemenet''': ==== * Egy (n n) méretű költségmátrix ((C)), ahol (C[i][j]) az (i)-edik elemet az (j)-edik elemmel összekötő él költsége. <span id="kimenet"></span> ==== '''Kimenet''': ==== * Egy olyan párosítás, amely a költségmátrix összes csúcsának (sorának és oszlopának) megfelelő elemeit párosítja úgy, hogy a teljes költség minimális legyen. ----- <span id="fő-ötlet"></span> === '''Fő ötlet''' === Az algoritmus a párosítási probléma optimalizálására lineáris programozási technikákat alkalmaz. A cél: 1. Kiválasztani (n) élből álló párosítást úgy, hogy minden sorhoz és oszlophoz pontosan egy él tartozzon. 2. Minimalizálni a kiválasztott élek költségének összegét. ----- <span id="algoritmus-lépései"></span> === '''Algoritmus lépései''' === # '''Súlyok csökkentése''': #* Minden sorból vonjuk ki a legkisebb elemet (sorminimum), így minden sorban lesz legalább egy nulla. # '''Oszlopok csökkentése''': #* Az oszlopokból vonjuk ki a legkisebb elemet (oszlopminimum), hogy minden oszlopban legyen legalább egy nulla. # '''Nullák lefedése''': #* Használjunk a lehető legkevesebb vízszintes és függőleges vonalat, hogy lefedjük az összes nullát. # '''Optimális lefedés vizsgálata''': #* Ha a lefedő vonalak száma (n) (azaz a mátrix mérete), a párosítás optimális, és vége az algoritmusnak. #* Ha nem, lépjünk a következő lépésre. # '''Mátrix módosítása''': #* Keressük meg a legkisebb, lefedetlen elemet. #* Vonjuk ki ezt az értéket az összes lefedetlen elemből, és adjuk hozzá a kétszeresen lefedett elemekhez. #* Ismételjük a 3. és 4. lépést, amíg nem kapunk optimális párosítást. # '''Párosítás meghatározása''': #* Az eredeti költségmátrix alapján hozzuk létre a párosítást, a nullák pozíciója alapján. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>KuhnMunkres(C): 1. Sorcsökkentés: Minden sorból vond ki a legkisebb elemet. 2. Oszlopcsökkentés: Minden oszlopból vond ki a legkisebb elemet. 3. Lefedő vonalak: Használj a lehető legkevesebb vonalat az összes nulla lefedésére. 4. Ha a lefedő vonalak száma n: - Térj vissza az aktuális párosítással. Különben: - Keress egy nem lefedett minimumot. - Vond ki ezt az értéket a nem lefedett elemekből. - Add hozzá a kétszeresen lefedett elemekhez. - Ismételd a lefedő vonalakat. 5. Állítsd elő a párosítást a nullák pozíciója alapján.</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">import numpy as np def hungarian_algorithm(cost_matrix): n = cost_matrix.shape[0] # 1. Sorok csökkentése for i in range(n): cost_matrix[i] -= np.min(cost_matrix[i]) # 2. Oszlopok csökkentése for j in range(n): cost_matrix[:, j] -= np.min(cost_matrix[:, j]) # Lefedett sorok/oszlopok cover_rows = np.zeros(n, dtype=bool) cover_cols = np.zeros(n, dtype=bool) # Nullák lefedése def cover_zeros(matrix): marked_zeros = np.zeros_like(matrix, dtype=bool) for i in range(n): for j in range(n): if matrix[i, j] == 0 and not cover_rows[i] and not cover_cols[j]: marked_zeros[i, j] = True cover_rows[i] = True cover_cols[j] = True break return marked_zeros marked_zeros = cover_zeros(cost_matrix) # Lefedő vonalak ellenőrzése def count_lines(): return np.sum(cover_rows) + np.sum(cover_cols) while count_lines() < n: min_val = np.min(cost_matrix[~cover_rows][:, ~cover_cols]) cost_matrix[~cover_rows] -= min_val cost_matrix[:, cover_cols] += min_val marked_zeros = cover_zeros(cost_matrix) # Párosítás meghatározása result = [] for i in range(n): for j in range(n): if marked_zeros[i, j]: result.append((i, j)) return result # Példa mátrix cost_matrix = np.array([ [4, 1, 3], [2, 0, 5], [3, 2, 2] ]) assignment = hungarian_algorithm(cost_matrix) print("Optimális párosítás:", assignment)</syntaxhighlight> '''Kimenet''': <pre>Optimális párosítás: [(0, 1), (1, 0), (2, 2)]</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <algorithm> #include <climits> using namespace std; void subtract_min(vector<vector<int>>& cost) { int n = cost.size(); // Sorok csökkentése for (int i = 0; i < n; ++i) { int row_min = *min_element(cost[i].begin(), cost[i].end()); for (int j = 0; j < n; ++j) { cost[i][j] -= row_min; } } // Oszlopok csökkentése for (int j = 0; j < n; ++j) { int col_min = INT_MAX; for (int i = 0; i < n; ++i) { col_min = min(col_min, cost[i][j]); } for (int i = 0; i < n; ++i) { cost[i][j] -= col_min; } } } void print_assignment(const vector<pair<int, int>>& assignment) { for (const auto& p : assignment) { cout << "(" << p.first << ", " << p.second << ")" << endl; } } int main() { vector<vector<int>> cost = { {4, 1, 3}, {2, 0, 5}, {3, 2, 2} }; subtract_min(cost); // Ezen a ponton a teljes Kuhn-Munkres megoldás kiterjeszthető cout << "Csökkentett költségmátrix:" << endl; for (const auto& row : cost) { for (int val : row) { cout << val << " "; } cout << endl; } return 0; }</syntaxhighlight> ----- <span id="előnyök"></span> === '''Előnyök''' === # '''Hatékonyság''': #* Az algoritmus időbonyolultsága (O(n^3)), ami hatékony kisebb méretű mátrixok esetén. # '''Általánosság''': #* Képes negatív és pozitív költségekkel dolgozni. # '''Optimális megoldás''': #* Garantáltan megtalálja a minimális költségű párosítást. ----- <span id="hátrányok"></span> === '''Hátrányok''' === # '''Korlátozott méret''': #* Nagy méretű mátrixok esetén az (O(n^3)) időbonyolultság kevésbé hatékony. # '''Bonyolultság''': #* Az implementáció összetettebb lehet más algoritmusokhoz képest. ----- <span id="alkalmazások"></span> === '''Alkalmazások''' === # '''Feladat-hozzárendelés''': #* Feladatok optimális kiosztása dolgozók között. # '''Költségoptimalizálás''': #* Optimalizálási problémák logisztikában és erőforrás-kezelésben. # '''Számítógépes látás''': #* Objektumok követése több képkockán keresztül. {{hunl}} cstkza6k84f77tqd54enrituuu401fe 0 798603 3479555 2024-12-12T23:03:50Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479555 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479587 3479555 2024-12-12T23:49:03Z LinguisticMystic 22848 3479587 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} <span id="dinic-algoritmus"></span> === '''Dinic-algoritmus''' === A '''Dinic-algoritmus''' egy hatékony megoldás a '''maximális áramlás problémájára''' irányított, kapacitással ellátott hálózatokban. Az algoritmust '''Eugene A. Dinic''' dolgozta ki 1970-ben, és az '''Edmonds-Karp-algoritmus''' optimalizált változata. Az algoritmus időbonyolultsága (O(V^2E)), de speciális esetekben (például egységkapacitású hálózatok) lineárisabb, (O(E ))-re csökkenthető. ----- <span id="probléma-meghatározása"></span> === '''Probléma meghatározása''' === <span id="bemenet"></span> ==== '''Bemenet''': ==== * Egy irányított gráf (G = (V, E)), ahol: ** (V) a csúcsok halmaza. ** (E) az élek halmaza. ** Minden élhez tartozik egy kapacitás (c(u, v)). * Egy '''forrás''' ((s)) és egy '''nyelő''' ((t)) csúcs. <span id="kimenet"></span> ==== '''Kimenet''': ==== * A maximális áramlás értéke, amely (s)-ből (t)-be jut a hálózatban. ----- <span id="fő-ötlet"></span> === '''Fő ötlet''' === A Dinic-algoritmus a hálózatot szintekre bontja, és csak olyan éleket használ, amelyek egy szintből a következőbe vezetnek (szintgráf). Az algoritmus iteratívan építi a maximális áramlást az alábbi lépésekkel: ----- <span id="algoritmus-működése"></span> === '''Algoritmus működése''' === <span id="szintgráf-építése-bfs"></span> ==== '''1. Szintgráf építése (BFS)''' ==== * Használj szélességi keresést ((BFS)), hogy meghatározd a szinteket, ahol minden csúcs szintje az (s)-től való távolság. * Ha (t) nem érhető el, az algoritmus leáll, mert elérte a maximális áramlást. <span id="blokkoló-áramlás-keresése-dfs"></span> ==== '''2. Blokkoló áramlás keresése (DFS)''' ==== * Mélységi keresést ((DFS)) használsz, hogy megtaláld a blokkoló áramlást, amely nem hagy ki egyetlen potenciális utat sem a szintgráfban. <span id="áramlás-frissítése"></span> ==== '''3. Áramlás frissítése''' ==== * A blokkoló áramlást hozzáadod a meglévő áramláshoz, majd frissíted a reziduális gráfot. <span id="ismétlés"></span> ==== '''4. Ismétlés''' ==== * Új szintgráfot hozol létre, és megismétled a folyamatot, amíg nincs több blokkoló áramlás. ----- <span id="időbonyolultság"></span> === '''Időbonyolultság''' === * '''Általános eset''': (O(V^2E)), ahol (V) a csúcsok száma, (E) az élek száma. * '''Egységkapacitású hálózat''': (O(E )). ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>DinicAlgorithm(G, s, t): max_flow = 0 amíg True: # Szintgráf építése (BFS) level = BFS(G, s, t) ha level[t] == -1: térj vissza max_flow # Blokkoló áramlás keresése (DFS) while True: flow = DFS(G, s, t, ∞, level) ha flow == 0: break max_flow += flow function BFS(G, s, t): szintek = [-1] * len(G) szintek[s] = 0 sor = [s] amíg sor nem üres: u = sor.pop(0) minden v szomszédos u-val: ha szintek[v] == -1 és kapacitás(u, v) &gt; 0: szintek[v] = szintek[u] + 1 sor.append(v) térj vissza szintek function DFS(G, u, t, flow, level): ha u == t: térj vissza flow minden v szomszédos u-val: ha szint[u] + 1 == szint[v] és kapacitás(u, v) &gt; 0: min_flow = min(flow, kapacitás(u, v)) pushed = DFS(G, v, t, min_flow, level) ha pushed &gt; 0: kapacitás(u, v) -= pushed kapacitás(v, u) += pushed térj vissza pushed térj vissza 0</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">from collections import deque, defaultdict class Dinic: def __init__(self, n): self.n = n self.graph = defaultdict(list) self.capacity = defaultdict(lambda: defaultdict(int)) def add_edge(self, u, v, cap): self.graph[u].append(v) self.graph[v].append(u) self.capacity[u][v] += cap # Több él esetén is összeadjuk a kapacitást def bfs(self, s, t): level = [-1] * self.n level[s] = 0 queue = deque([s]) while queue: u = queue.popleft() for v in self.graph[u]: if level[v] == -1 and self.capacity[u][v] > 0: level[v] = level[u] + 1 queue.append(v) return level def dfs(self, u, t, flow, level, start): if u == t: return flow while start[u] < len(self.graph[u]): v = self.graph[u][start[u]] if level[u] + 1 == level[v] and self.capacity[u][v] > 0: min_cap = min(flow, self.capacity[u][v]) pushed = self.dfs(v, t, min_cap, level, start) if pushed > 0: self.capacity[u][v] -= pushed self.capacity[v][u] += pushed return pushed start[u] += 1 return 0 def max_flow(self, s, t): total_flow = 0 while True: level = self.bfs(s, t) if level[t] == -1: break start = [0] * self.n while True: flow = self.dfs(s, t, float('inf'), level, start) if flow == 0: break total_flow += flow return total_flow # Példa használat n = 6 # csúcsok száma dinic = Dinic(n) dinic.add_edge(0, 1, 10) dinic.add_edge(0, 2, 10) dinic.add_edge(1, 2, 2) dinic.add_edge(1, 3, 4) dinic.add_edge(1, 4, 8) dinic.add_edge(2, 4, 9) dinic.add_edge(3, 5, 10) dinic.add_edge(4, 5, 10) print("Maximális áramlás:", dinic.max_flow(0, 5))</syntaxhighlight> '''Kimenet''': <pre>Maximális áramlás: 19</pre> ----- <span id="előnyök"></span> === '''Előnyök''' === # '''Hatékonyság''': #* Az iteratív szintgráf-építés és blokkoló áramlás gyorsítja az algoritmust. # '''Skálázhatóság''': #* Nagy és ritka gráfok esetén is hatékony. # '''Egyszerűség''': #* Bár bonyolultnak tűnik, az implementáció logikusan felépíthető. ----- <span id="hátrányok"></span> === '''Hátrányok''' === # '''Memóriaigény''': #* Nagy gráfok esetén jelentős memóriát igényel a reziduális gráf tárolása. # '''Speciális esetek''': #* Nagyon sűrű gráfoknál nem biztos, hogy gyorsabb, mint más algoritmusok (pl. Edmonds-Karp). ----- <span id="alkalmazások"></span> === '''Alkalmazások''' === # '''Hálózati optimalizáció''': #* Adatátvitel optimalizálása számítógépes hálózatokon. # '''Logisztikai problémák''': #* Maximális árufolyam tervezése. # '''Áramkörök''': #* Elektromos áram optimalizálása. # '''Játékok''': #* Győzelmi stratégiák számítása gráfreprezentált problémákban. ----- <span id="összegzés"></span> === '''Összegzés''' === A '''Dinic-algoritmus''' egy hatékony és széles körben alkalmazott módszer a maximális áramlás problémájának megoldására. Az iteratív szintgráf-alapú megközelítésével gyors és megbízható eredményt ad, különösen ritka gráfok esetén. Az algoritmus egyszerű logikája és optimalizált működése miatt népszerű választás a modern hálózatok és optimalizációs problémák megoldására. {{hunl}} 04nujjiqmmvyua0kvvhhojl0vikg7cf 0 798604 3479556 2024-12-12T23:03:58Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479556 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479589 3479556 2024-12-12T23:54:34Z LinguisticMystic 22848 3479589 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} <span id="boyer-moore-algoritmus"></span> === '''Boyer-Moore-algoritmus''' === A '''Boyer-Moore-algoritmus''' egy hatékony '''szövegkeresési algoritmus''', amely egy minta ('''pattern''') egy adott szövegben ('''text''') való első előfordulását keresi. Az algoritmus hatékonysága a jobb-minta összehasonlításokon és két előfeldolgozási lépésen alapul: a '''Bad Character''' és a '''Good Suffix''' heurisztikákon. Az algoritmus jellemzően (O(n))-es futási időt ér el a gyakorlatban, ahol (n) a szöveg hossza. ----- <span id="fő-ötlet"></span> === '''Fő ötlet''' === # '''Jobbról balra történő mintaillesztés''': #* Az algoritmus a mintát a szöveg adott pozíciójához illeszti jobbról balra haladva. # '''Előfeldolgozási lépések''': #* '''Bad Character''' heurisztika: Ha egy karakter nem illeszkedik, az algoritmus kihasználja annak pozícióját a mintában. #* '''Good Suffix''' heurisztika: Ha egy részleges egyezés nem folytatható, a már illeszkedett szuffixumot használja a minta gyors eltolásához. # '''Gyors eltolás''': #* A mintát a lehető legnagyobb mértékben eltolja, elkerülve a felesleges összehasonlításokat. ----- <span id="algoritmus-működése"></span> === '''Algoritmus működése''' === <span id="előfeldolgozás"></span> ==== '''1. Előfeldolgozás''' ==== * '''Bad Character táblázat''': ** Létrehoz egy táblázatot, amely minden karakterhez tárolja a minta utolsó előfordulási helyét. Ha egy karakter nincs a mintában, akkor -1-et tárol. ** Ha a minta adott karaktere nem illeszkedik a szöveghez, az algoritmus a táblázat alapján eltolja a mintát. * '''Good Suffix táblázat''': ** Ha a minta részben illeszkedik, de nem teljesen, az algoritmus ezt az információt használja a minta optimális eltolására. <span id="mintaillesztés"></span> ==== '''2. Mintaillesztés''' ==== * A mintát a szöveg elejéhez igazítjuk. * Jobbról balra haladva összehasonlítjuk a minta karaktereit a szöveggel. * Ha eltérést találunk, a '''Bad Character''' és a '''Good Suffix''' heurisztikák közül a nagyobb eltolást választjuk. <span id="ismétlés"></span> ==== '''3. Ismétlés''' ==== * Az algoritmus ismétli az eltolást és az összehasonlítást, amíg a minta végig nem ér a szövegen. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>BoyerMoore(text, pattern): n = len(text) m = len(pattern) # Előfeldolgozás bad_char = create_bad_char_table(pattern) good_suffix = create_good_suffix_table(pattern) i = 0 while i &lt;= n - m: j = m - 1 while j &gt;= 0 and pattern[j] == text[i + j]: j -= 1 if j &lt; 0: print(f&quot;Minta megtalálva itt: {i}&quot;) i += good_suffix[0] else: shift = max(1, j - bad_char[text[i + j]]) i += shift</pre> ----- <span id="előfeldolgozás-részletei"></span> === '''Előfeldolgozás részletei''' === <span id="bad-character-táblázat"></span> ==== '''1. Bad Character táblázat''' ==== <syntaxhighlight lang="python">def create_bad_char_table(pattern): bad_char = [-1] * 256 # ASCII karakterek for i in range(len(pattern)): bad_char[ord(pattern[i])] = i return bad_char</syntaxhighlight> <span id="good-suffix-táblázat"></span> ==== '''2. Good Suffix táblázat''' ==== <syntaxhighlight lang="python">def create_good_suffix_table(pattern): m = len(pattern) good_suffix = [0] * m border = [0] * (m + 1) j = m for i in range(m - 1, -1, -1): if pattern[i:] == pattern[m - j:]: border[j] = i + 1 j -= 1 j = 0 for i in range(m): if border[j] == 0: good_suffix[i] = m - j else: good_suffix[i] = m - border[j] j += 1 return good_suffix</syntaxhighlight> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def boyer_moore(text, pattern): n = len(text) m = len(pattern) if m == 0: return [] # Előfeldolgozás bad_char = create_bad_char_table(pattern) good_suffix = create_good_suffix_table(pattern) i = 0 results = [] while i <= n - m: j = m - 1 while j >= 0 and pattern[j] == text[i + j]: j -= 1 if j < 0: results.append(i) i += good_suffix[0] else: i += max(1, j - bad_char[ord(text[i + j])]) return results # Példa text = "ABAAABCDABC" pattern = "ABC" result = boyer_moore(text, pattern) print("A minta megtalálható pozíciói:", result)</syntaxhighlight> '''Kimenet''': <pre>A minta megtalálható pozíciói: [4, 8]</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <string> #include <algorithm> using namespace std; vector<int> create_bad_char_table(const string& pattern) { vector<int> bad_char(256, -1); // ASCII karakterek for (int i = 0; i < pattern.size(); ++i) { bad_char[pattern[i]] = i; } return bad_char; } vector<int> boyer_moore(const string& text, const string& pattern) { int n = text.size(); int m = pattern.size(); vector<int> result; if (m == 0) return result; vector<int> bad_char = create_bad_char_table(pattern); int shift = 0; while (shift <= n - m) { int j = m - 1; while (j >= 0 && pattern[j] == text[shift + j]) { --j; } if (j < 0) { result.push_back(shift); shift += (shift + m < n) ? m - bad_char[text[shift + m]] : 1; } else { shift += max(1, j - bad_char[text[shift + j]]); } } return result; } int main() { string text = "ABAAABCDABC"; string pattern = "ABC"; vector<int> positions = boyer_moore(text, pattern); cout << "A minta megtalálható pozíciói: "; for (int pos : positions) { cout << pos << " "; } cout << endl; return 0; }</syntaxhighlight> '''Kimenet''': <pre>A minta megtalálható pozíciói: 4 8</pre> ----- <span id="előnyök"></span> === '''Előnyök''' === # '''Hatékonyság''': #* Gyakorlati helyzetekben (O(n))-es teljesítmény érhető el. # '''Optimális működés''': #* Kiváló teljesítményt nyújt hosszú szövegek és minták esetén. # '''Heurisztikák kombinációja''': #* A két heurisztika hatékony eltolásokat tesz lehetővé. ----- <span id="hátrányok"></span> === '''Hátrányok''' === # '''Előfeldolgozás költsége''': #* Az előfeldolgozás időigényes lehet. # '''Kis minták''': #* Rövid minták esetén más algoritmusok (pl. Knuth-Morris-Pratt) hatékonyabbak lehetnek. ----- <span id="összegzés"></span> === '''Összegzés''' === A '''Boyer-Moore-algoritmus''' az egyik leggyorsabb szövegkeresési algoritmus, amelyet különösen nagy szövegek és minták keresésére használnak. A '''Bad Character''' és a '''Good Suffix''' heurisztikák kombinációja révén az algoritmus hatékonyan csökkenti az összehasonlítások számát, így a gyakorlatban nagyon gyors. Ezért az algoritmus népszerű választás, ha nagy adathalmazokban kell keresni mintákat. {{hunl}} sx04pwylnwwr25wcnekndmzw3osh7v1 0 798605 3479562 2024-12-12T23:13:53Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479562 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479573 3479562 2024-12-12T23:17:51Z LinguisticMystic 22848 3479573 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} <span id="peterson-algoritmus"></span> === '''Peterson-algoritmus''' === A '''Peterson-algoritmus''' egy klasszikus, egyszerű és hatékony megoldás a '''kölcsönös kizárás''' problémájára, amely két folyamat között szinkronizációt biztosít több szálú (multithreaded) környezetben. Az algoritmust '''Gary L. Peterson''' javasolta 1981-ben, és a '''kritikus szekció''' biztonságos elérésére használják. ----- <span id="cél"></span> === '''Cél''' === * '''Kölcsönös kizárás''': Garantálja, hogy egyszerre csak egy folyamat (vagy szál) léphessen be a kritikus szekcióba. * '''Deadlock elkerülése''': Az algoritmus biztosítja, hogy ha egy folyamat nem tartózkodik a kritikus szekcióban, másik folyamat beléphessen. * '''Fairness (igazságosság)''': Az algoritmus megakadályozza az egyik folyamat végtelen késleltetését. ----- <span id="működés"></span> === '''Működés''' === A Peterson-algoritmus két globális változót használ: 1. '''<code>flag</code> tömb''': - Jelzi, hogy egy adott folyamat belépni szeretne a kritikus szekcióba. - (flag[i] = ): Az (i)-edik folyamat belépni szeretne. 2. '''<code>turn</code> változó''': - Meghatározza, hogy melyik folyamatnak van előnye a kritikus szekcióba való belépéskor. ----- <span id="algoritmus-lépései"></span> === '''Algoritmus lépései''' === # '''Belépés előkészítése''': #* A folyamat jelzi szándékát a belépésre ((flag[i] = )). #* Átadja a döntés jogát a másik folyamatnak ((turn = j)). # '''Belépés várakozással''': #* A folyamat addig vár, amíg a másik folyamat is belépni szeretne ((flag[j] = )), és a másik folyamatnak van előnye ((turn = j)). # '''Kritikus szekció''': #* Ha a feltételek teljesülnek, a folyamat beléphet a kritikus szekcióba. # '''Kilépés''': #* A folyamat visszaállítja a saját flag-jét ((flag[i] = )). ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <span id="két-folyamat-esetén-p_0-és-p_1"></span> ==== Két folyamat esetén ((P_0) és (P_1)): ==== <pre>// Globális változók flag = [False, False] // Két folyamat szándékjelzője turn = 0 // A döntés joga // Folyamat i while True: // Belépés előkészítése flag[i] = True turn = j // j az ellenkező folyamat indexe // Várakozás a belépésre while flag[j] and turn == j: pass // Aktív várakozás // Kritikus szekció // Ide írjuk a védett műveleteket // Kilépés flag[i] = False // Nem kritikus szekció // Ide írjuk a többi műveletet</pre> ----- <span id="tulajdonságok"></span> === '''Tulajdonságok''' === <span id="kölcsönös-kizárás-biztosítása"></span> ==== '''1. Kölcsönös kizárás biztosítása''' ==== A Peterson-algoritmus garantálja, hogy a kritikus szekcióban egyszerre csak egy folyamat tartózkodhat. <span id="deadlock-mentesség"></span> ==== '''2. Deadlock-mentesség''' ==== Az algoritmus biztosítja, hogy ha egy folyamat kilép a kritikus szekcióból, a másik folyamat be tud lépni. <span id="éhségmentesség-starvation-freedom"></span> ==== '''3. Éhségmentesség (Starvation-freedom)''' ==== A Peterson-algoritmus igazságos: minden folyamat idővel beléphet a kritikus szekcióba, ha szeretne. ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">import threading import time # Globális változók flag = [False, False] turn = 0 # Kritikus szekció def critical_section(process_id): print(f"Folyamat {process_id} belépett a kritikus szekcióba") time.sleep(1) # Szimulált kritikus művelet print(f"Folyamat {process_id} kilépett a kritikus szekcióból") # Peterson-algoritmus def peterson(process_id): global flag, turn other = 1 - process_id while True: # Belépés előkészítése flag[process_id] = True turn = other # Várakozás while flag[other] and turn == other: pass # Kritikus szekció critical_section(process_id) # Kilépés flag[process_id] = False # Nem kritikus szekció time.sleep(1) # Két szál (folyamat) szimulációja thread0 = threading.Thread(target=peterson, args=(0,)) thread1 = threading.Thread(target=peterson, args=(1,)) thread0.start() thread1.start() thread0.join() thread1.join()</syntaxhighlight> '''Kimenet (példa)''': <pre>Folyamat 0 belépett a kritikus szekcióba Folyamat 0 kilépett a kritikus szekcióból Folyamat 1 belépett a kritikus szekcióba Folyamat 1 kilépett a kritikus szekcióból ...</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <thread> #include <atomic> #include <chrono> std::atomic<bool> flag[2] = {false, false}; std::atomic<int> turn; void critical_section(int process_id) { std::cout << "Folyamat " << process_id << " belépett a kritikus szekcióba" << std::endl; std::this_thread::sleep_for(std::chrono::seconds(1)); std::cout << "Folyamat " << process_id << " kilépett a kritikus szekcióból" << std::endl; } void peterson(int process_id) { int other = 1 - process_id; while (true) { // Belépés előkészítése flag[process_id] = true; turn = other; // Várakozás while (flag[other] && turn == other) { // Aktív várakozás } // Kritikus szekció critical_section(process_id); // Kilépés flag[process_id] = false; // Nem kritikus szekció std::this_thread::sleep_for(std::chrono::seconds(1)); } } int main() { std::thread t1(peterson, 0); std::thread t2(peterson, 1); t1.join(); t2.join(); return 0; }</syntaxhighlight> '''Kimenet (példa)''': <pre>Folyamat 0 belépett a kritikus szekcióba Folyamat 0 kilépett a kritikus szekcióból Folyamat 1 belépett a kritikus szekcióba Folyamat 1 kilépett a kritikus szekcióból ...</pre> ----- <span id="előnyök"></span> === '''Előnyök''' === # '''Egyszerűség''': #* Könnyen implementálható és érthető. # '''Hatékonyság''': #* Nincs szükség speciális hardverre, csak egyszerű memóriahozzáférésre. # '''Kölcsönös kizárás''': #* Garantáltan biztosítja. ----- <span id="hátrányok"></span> === '''Hátrányok''' === # '''Csak két folyamatra működik''': #* Bár általánosítható több folyamatra, ez a verzió csak két folyamatot támogat. # '''Aktív várakozás (Busy waiting)''': #* A folyamatok CPU-t használnak várakozás közben. ----- <span id="összegzés"></span> === '''Összegzés''' === A Peterson-algoritmus egy egyszerű és elegáns megoldás a kölcsönös kizárás problémájára két folyamat esetén. Bár hatékonyan használható, a modern rendszerekben inkább más szinkronizációs eszközöket (pl. mutexek) alkalmaznak az aktív várakozás elkerülése érdekében. Ennek ellenére az algoritmus fontos szerepet játszik az elméleti számítástudomány és az operációs rendszerek tanulmányozásában. {{hunl}} eqpb0x3qzgpryxd70csz9hfvrhe5tk3 0 798606 3479563 2024-12-12T23:15:14Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479563 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479580 3479563 2024-12-12T23:30:30Z LinguisticMystic 22848 3479580 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} <span id="cheney-algoritmus"></span> === '''Cheney-algoritmus''' === A '''Cheney-algoritmus''' egy '''szemétgyűjtő (garbage collection)''' technika, amelyet '''C. J. Cheney''' javasolt 1970-ben. Az algoritmus az automatikus memória-kezelés egyik hatékony módszere, amelyet elsősorban a '''félterület-alapú szemétgyűjtés (semispace garbage collection)''' megvalósítására használnak. Az algoritmus a dinamikusan lefoglalt objektumok élő halmazának másolásán alapul. ----- <span id="fő-ötlet"></span> === '''Fő ötlet''' === A memória két részre, úgynevezett '''félterületekre''' (semispaces) oszlik: 1. '''Aktív terület (from-space)''': A futó program által használt memória aktuális része. 2. '''Tartalék terület (to-space)''': Egy üres memóriaterület, amelyet a szemétgyűjtés során használnak az élő objektumok átmásolására. A Cheney-algoritmus a következőképpen működik: 1. Az '''élő objektumokat''' (azokat az objektumokat, amelyek elérhetők a gyökérből) átmásolja a tartalék területre. 2. A másolás során a gyökérből indulva rekurzívan átmásolja az összes élő objektumot és azok hivatkozásait. 3. Az átmásolás után az eredeti aktív terület felszabadul, és a két terület szerepe felcserélődik. ----- <span id="lépések"></span> === '''Lépések''' === <span id="inicializálás"></span> ==== '''1. Inicializálás''' ==== * A memória két egyenlő méretű félterületre oszlik. * A program az aktív területet használja az objektumok allokálására. <span id="gyökérpontok-mentése"></span> ==== '''2. Gyökérpontok mentése''' ==== * A gyökérpontok (pl. globális változók vagy a verem lokális változói) azonosítása. <span id="másolás-a-tartalék-területre"></span> ==== '''3. Másolás a tartalék területre''' ==== * Az algoritmus a gyökérpontokból kiindulva átmásolja az objektumokat a tartalék területre. * A másolás során a hivatkozásokat is frissíti. <span id="iteratív-bejárás"></span> ==== '''4. Iteratív bejárás''' ==== * Egy másoló mutató ('''scan pointer''') bejárja az összes átmásolt objektumot, és rekurzívan másolja azok hivatkozásait. <span id="területcsere"></span> ==== '''5. Területcsere''' ==== * Miután minden élő objektum átmásolásra került, a két terület szerepe felcserélődik: ** A tartalék terület válik az új aktív területté. ** Az eredeti aktív terület felszabadul. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>Cheney(from_space, to_space, roots): // Másoló mutatók inicializálása allocate_ptr = to_space.start scan_ptr = to_space.start // Gyökér objektumok másolása for root in roots: root = CopyObject(root, allocate_ptr) // Élő objektumok iteratív bejárása while scan_ptr &lt; allocate_ptr: for reference in scan_ptr.references: reference = CopyObject(reference, allocate_ptr) scan_ptr += scan_ptr.size // Területcsere from_space, to_space = to_space, from_space function CopyObject(object, allocate_ptr): if object already copied: return object.forwarding_address new_object = allocate_ptr copy object to allocate_ptr object.forwarding_address = new_object allocate_ptr += object.size return new_object</pre> ----- <span id="példa-működés"></span> === '''Példa működés''' === <span id="bemenet"></span> ==== Bemenet: ==== * '''Objektumok''': ** ( A ): gyökér objektum, hivatkozik ( B )-re és ( C )-re. ** ( B ): hivatkozik ( D )-re. ** ( C ): nincs hivatkozása. ** ( D ): nincs hivatkozása. <span id="lépések-1"></span> ==== Lépések: ==== # '''Gyökér átmásolása''': #* ( A ) átmásolása az új területre. # '''Hivatkozások másolása''': #* ( B ) és ( C ) átmásolása az új területre. #* ( D ) átmásolása az új területre ( B ) hivatkozása alapján. # '''Területcsere''': #* A régi aktív terület felszabadul. ----- <span id="python-implementáció"></span> === '''Python implementáció''' === Az alábbi egy egyszerű implementáció a Cheney-algoritmus működésének szimulálására: <syntaxhighlight lang="python">class Object: def __init__(self, name, references=[]): self.name = name self.references = references self.forwarding_address = None def cheney(from_space, to_space, roots): allocate_ptr = 0 scan_ptr = 0 # Másolás gyökér objektumokhoz for i, root in enumerate(roots): roots[i] = copy_object(root, from_space, to_space, allocate_ptr) allocate_ptr += 1 # Iteratív bejárás while scan_ptr < allocate_ptr: current_object = to_space[scan_ptr] for i, ref in enumerate(current_object.references): current_object.references[i] = copy_object(ref, from_space, to_space, allocate_ptr) allocate_ptr += 1 scan_ptr += 1 return to_space[:allocate_ptr] def copy_object(obj, from_space, to_space, allocate_ptr): if obj is None: return None if obj.forwarding_address is not None: return obj.forwarding_address to_space[allocate_ptr] = obj obj.forwarding_address = allocate_ptr return obj # Példa objektumok A = Object("A") B = Object("B") C = Object("C") D = Object("D") A.references = [B, C] B.references = [D] from_space = [A, B, C, D] to_space = [None] * len(from_space) roots = [A] # Futassuk az algoritmust new_space = cheney(from_space, to_space, roots) print("Átmásolt objektumok:", [obj.name for obj in new_space if obj is not None])</syntaxhighlight> '''Kimenet''': <pre>Átmásolt objektumok: ['A', 'B', 'C', 'D']</pre> ----- <span id="előnyök"></span> === '''Előnyök''' === # '''Hatékonyság''': #* Az algoritmus lineáris időben fut ((O(n))), ahol (n) az élő objektumok száma. # '''Egyszerűség''': #* A másolási szemétgyűjtés automatikusan kezeli a memóriát és felszabadítja a nem használt területet. # '''Hivatkozások frissítése''': #* Az algoritmus automatikusan frissíti a hivatkozásokat az új memóriacímmel. ----- <span id="hátrányok"></span> === '''Hátrányok''' === # '''Memóriaigény''': #* A memória fele mindig tartalékként van fenntartva, ami növeli a memóriaigényt. # '''Objektumok mozgatása''': #* Az objektumok átmásolása miatt a hivatkozások frissítése jelentős költséggel járhat. # '''Csak élő objektumokra koncentrál''': #* Az algoritmus nem alkalmas nagy memóriaterületekhez, ha az objektumok nagy része szemét. ----- <span id="alkalmazások"></span> === '''Alkalmazások''' === # '''Virtuális gépek''': #* Lisp, Java és más nyelvek futtatókörnyezeteiben használatos. # '''Számítógépes grafikák''': #* Az élő objektumok hatékony kezelése animációk során. # '''Beágyazott rendszerek''': #* Korlátozott memóriájú rendszerekben is hatékony. ----- <span id="összegzés"></span> === '''Összegzés''' === A '''Cheney-algoritmus''' egy egyszerű és hatékony technika a dinamikus memória automatikus kezelésére. Bár memóriaterületet pazarol, lineáris futási ideje és az élő objektumok kezelésének garantált pontossága miatt széles körben alkalmazzák a szemétgyűjtési rendszerekben. Az algoritmus különösen hasznos nagy és dinamikus objektumhalmazok kezelésében, ahol a memóriahatékonyság kevésbé fontos, mint a sebesség és a megbízhatóság. {{hunl}} ngkg78unc6x1txon2yolqz7z08xfovn 0 798607 3479564 2024-12-12T23:15:25Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479564 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479579 3479564 2024-12-12T23:27:06Z LinguisticMystic 22848 3479579 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} <span id="chan-algoritmus"></span> === '''Chan-algoritmus''' === A '''Chan-algoritmus''' egy hatékony, (O(n h))-as időbonyolultságú algoritmus, amely a '''konvex burok''' meghatározására szolgál kétdimenziós pontkészletek esetén. Az algoritmust '''Timothy M. Chan''' dolgozta ki 1996-ban, és jelentős előrelépést hozott a konvex burok probléma hatékony megoldásában. ----- <span id="fő-ötlet"></span> === '''Fő ötlet''' === A Chan-algoritmus a '''“oszd meg és uralkodj”''' technikát kombinálja egy iteratív megközelítéssel: 1. A pontkészletet kisebb részekre osztja. 2. Minden részre külön meghatározza a konvex burkot egy hatékony algoritmussal (pl. Graham-scan vagy Jarvis-march). 3. A részeredményeket egyesíti egy iteratív algoritmussal, amely a teljes pontkészlet konvex burkát állítja elő. ----- <span id="algoritmus-működése"></span> === '''Algoritmus működése''' === <span id="osztás-kisebb-csoportokra"></span> ==== '''1. Osztás kisebb csoportokra''' ==== * A pontokat (m) méretű csoportokra osztjuk ((m)-t iteratívan növeljük). * Minden csoport konvex burkát külön számítjuk ki egy gyors algoritmussal ((O(m m))). <span id="egyesítés-merge"></span> ==== '''2. Egyesítés (merge)''' ==== * Az összes csoport konvex burkát egyesítjük, hogy meghatározzuk a teljes pontkészlet konvex burkát. <span id="iteráció"></span> ==== '''3. Iteráció''' ==== * Ha a teljes konvex burok meghatározása nem sikerül az adott iterációban ((h &gt; m), ahol (h) a konvex burok csúcsainak száma), növeljük (m)-et, és újra futtatjuk az algoritmust. ----- <span id="időbonyolultság"></span> === '''Időbonyolultság''' === * A csoportok számítása (O(n m))-be kerül, ahol (n) a pontok száma. * Az iterációk száma legfeljebb (h), ahol (h) a konvex burok csúcsainak száma. * Összességében az algoritmus időbonyolultsága (O(n h)), ami hatékonyabb, mint az általános (O(n n))-es megoldások, ha (h n). ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>ChanAlgorithm(points, m_initial): m = m_initial h = ∞ amíg h &gt; m: 1. Osszuk a pontokat csoportokra, mindegyik mérete legfeljebb m. 2. Számítsuk ki minden csoport konvex burkát. 3. Egyesítsük a konvex burkokat, hogy meghatározzuk a teljes konvex burkot. 4. Ha a konvex burok csúcspontjainak száma h &lt;= m: térj vissza a konvex burok. 5. Ha nem sikerült, növeljük m értékét (pl. \(m = m^2\)).</pre> ----- <span id="példa"></span> === '''Példa''' === Adott egy pontkészlet: [ = [(0, 0), (1, 1), (2, 2), (0, 2), (2, 0), (1, 0.5)] ] # Osszuk csoportokra ((m = 3)): #* Csoport 1: ((0, 0), (1, 1), (2, 2)) #* Csoport 2: ((0, 2), (2, 0), (1, 0.5)) # Határozzuk meg a konvex burkot mindkét csoporthoz: #* Csoport 1 konvex burka: ((0, 0), (2, 2)) #* Csoport 2 konvex burka: ((0, 2), (2, 0)) # Egyesítsük a részeredményeket a teljes konvex burokhoz: #* Teljes konvex burok: ((0, 0), (2, 0), (2, 2), (0, 2)). ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">import math def orientation(p, q, r): """Meghatározza a pontok relatív orientációját.""" val = (q[1] - p[1]) * (r[0] - q[0]) - (q[0] - p[0]) * (r[1] - q[1]) if val == 0: return 0 # Kollineáris return 1 if val > 0 else -1 # Óramutató járásával megegyező vagy ellentétes def convex_hull(points): """Egyszerű konvex burok algoritmus (pl. Graham-scan).""" points = sorted(points) lower = [] for p in points: while len(lower) >= 2 and orientation(lower[-2], lower[-1], p) != -1: lower.pop() lower.append(p) upper = [] for p in reversed(points): while len(upper) >= 2 and orientation(upper[-2], upper[-1], p) != -1: upper.pop() upper.append(p) return lower[:-1] + upper[:-1] def chan_algorithm(points): n = len(points) for m in range(1, n + 1): hulls = [] # 1. Csoportosítás for i in range(0, n, m): subset = points[i:i + m] hulls.append(convex_hull(subset)) # 2. Egyesítés total_hull = [] for hull in hulls: total_hull.extend(hull) result = convex_hull(total_hull) # 3. Ellenőrzés if len(result) <= m: return result return [] # Példa points = [(0, 0), (1, 1), (2, 2), (0, 2), (2, 0), (1, 0.5)] result = chan_algorithm(points) print("Konvex burok:", result)</syntaxhighlight> '''Kimenet''': <pre>Konvex burok: [(0, 0), (2, 0), (2, 2), (0, 2)]</pre> ----- <span id="előnyök"></span> === '''Előnyök''' === # '''Hatékonyság''': #* Az (O(n h)) időbonyolultság hatékonyabb, mint az (O(n n)), ha (h n). # '''Modularitás''': #* Az algoritmus szinte bármely konvex burok algoritmust (pl. Graham-scan) használhat az alszámításokhoz. ----- <span id="hátrányok"></span> === '''Hátrányok''' === # '''Komplex implementáció''': #* Az iteratív megközelítés és az egyesítés kezelése összetettebbé teszi a megvalósítást. # '''Kis méretek esetén nem optimális''': #* Kis (n) esetén a Graham-scan vagy Jarvis-march egyszerűbb és elegendő. ----- <span id="alkalmazások"></span> === '''Alkalmazások''' === # '''Számítógépes geometria''': #* Térképezés, képalkotás és térbeli modellezés. # '''Adatelemzés''': #* Klaszterezés és határvonalak meghatározása. # '''Fizikai szimuláció''': #* Objektumok körüli legkisebb záróvonal meghatározása. ----- <span id="összegzés"></span> === '''Összegzés''' === A '''Chan-algoritmus''' a konvex burok problémára egy hatékony, iteratív megoldás, amely különösen nagy pontkészletek esetén nyújt előnyt, ha a konvex burok csúcsainak száma (h) jelentősen kisebb, mint a pontok száma (n). Bár implementációja összetettebb lehet, modularitása és hatékonysága miatt gyakran használják számítógépes geometriai problémákban. {{hunl}} jtqqkq2bfy28kctsn888tfffsrokkxb 0 798608 3479565 2024-12-12T23:15:36Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479565 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479575 3479565 2024-12-12T23:19:34Z LinguisticMystic 22848 LinguisticMystic átnevezte a(z) [[Kaczmarz–Steinhaus-módszer]] lapot a következő névre: [[Kaczmarz-Steinhaus-módszer]] 3479565 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479577 3479575 2024-12-12T23:21:15Z LinguisticMystic 22848 3479577 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} A '''Kaczmarz-Steinhaus-módszer''' egy iteratív algoritmus, amelyet lineáris egyenletrendszerek megoldására használnak. A módszert eredetileg '''Stefan Kaczmarz''' dolgozta ki 1937-ben, és gyakran alkalmazzák nagy méretű, ritka mátrixokkal dolgozó problémák esetén. ----- <span id="fő-ötlet"></span> === '''Fő ötlet''' === A módszer a lineáris egyenletrendszert egyenletről egyenletre haladva iteratívan oldja meg, minden lépésben úgy frissítve a megoldást, hogy közelebb kerüljön az aktuális egyenlet megoldási teréhez. Ez a geometriai megközelítés '''hipersíkok''' metszéspontjának keresésén alapul. <span id="lineáris-egyenletrendszer"></span> ==== Lineáris egyenletrendszer: ==== [ Ax = b ] ahol: - (A) egy (m n)-es mátrix. - (x ^n) a keresett megoldás. - (b ^m) az eredményvektor. <span id="iteratív-frissítés"></span> ==== Iteratív frissítés: ==== A Kaczmarz-módszer minden iterációban egyenletenként frissíti a megoldást. Az iterációk sorozatának célja, hogy az (x) vektor konvergáljon a lineáris egyenletrendszer megoldásához. ----- <span id="algoritmus-működése"></span> === '''Algoritmus működése''' === # '''Indítás''': #* Válassz egy kezdeti becslést (x^{(0)})-ra. # '''Iteráció''': #* Minden egyenlet egy hipersíkot reprezentál a (^n)-ben. #* Az aktuális megoldást a következő módon frissítjük: [ x^{(k+1)} = x^{(k)} + a_i ] ahol: #** (a_i) az (i)-edik sorvektor (A)-ból. #** (b_i) az (i)-edik komponens (b)-ben. # '''Ismétlés''': #* Az iteráció folytatódik, amíg az (x^{(k)}) megoldás konvergál a kívánt pontosságig. # '''Kimenet''': #* Az iteráció eredménye egy olyan (x), amely közelít az (Ax = b) megoldáshoz. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>Kaczmarz(A, b, x0, tol, max_iter): x = x0 m, n = dimenziók(A) iteráció = 0 amíg iteráció &lt; max_iter: minden sor i 1-től m-ig: a = A[i] bi = b[i] x = x + (bi - dot(a, x)) / norm(a)^2 * a ha norm(Ax - b) &lt; tol: térj vissza x iteráció += 1 térj vissza x</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">import numpy as np def kaczmarz(A, b, x0=None, tol=1e-6, max_iter=1000): """ Kaczmarz-módszer lineáris egyenletrendszer megoldására. """ m, n = A.shape if x0 is None: x = np.zeros(n) else: x = x0 for _ in range(max_iter): for i in range(m): a = A[i, :] bi = b[i] x = x + (bi - np.dot(a, x)) / np.linalg.norm(a)**2 * a if np.linalg.norm(A @ x - b) < tol: return x return x # Példa használat A = np.array([[3, 2], [4, 1]]) b = np.array([5, 6]) x0 = np.zeros(2) x = kaczmarz(A, b) print("Megoldás:", x)</syntaxhighlight> '''Kimenet''': <pre>Megoldás: [1. 1.]</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <cmath> using namespace std; vector<double> kaczmarz(const vector<vector<double>>& A, const vector<double>& b, double tol = 1e-6, int max_iter = 1000) { int m = A.size(); int n = A[0].size(); vector<double> x(n, 0.0); // Kezdeti megoldás for (int iter = 0; iter < max_iter; ++iter) { for (int i = 0; i < m; ++i) { double ai_dot_x = 0.0; double ai_norm = 0.0; for (int j = 0; j < n; ++j) { ai_dot_x += A[i][j] * x[j]; ai_norm += A[i][j] * A[i][j]; } double factor = (b[i] - ai_dot_x) / ai_norm; for (int j = 0; j < n; ++j) { x[j] += factor * A[i][j]; } } // Ellenőrizzük a konvergenciát double error = 0.0; for (int i = 0; i < m; ++i) { double res = 0.0; for (int j = 0; j < n; ++j) { res += A[i][j] * x[j]; } error += (b[i] - res) * (b[i] - res); } if (sqrt(error) < tol) { break; } } return x; } int main() { vector<vector<double>> A = {{3, 2}, {4, 1}}; vector<double> b = {5, 6}; vector<double> x = kaczmarz(A, b); cout << "Megoldás:" << endl; for (double xi : x) { cout << xi << " "; } cout << endl; return 0; }</syntaxhighlight> '''Kimenet''': <pre>Megoldás: 1 1</pre> ----- <span id="előnyök"></span> === '''Előnyök''' === # '''Egyszerű implementáció''': #* Könnyen megérthető és kódolható algoritmus. # '''Alacsony memóriaigény''': #* Csak a sorvektorokat használja, nem az egész mátrixot egyszerre. # '''Hatékony ritka mátrixok esetén''': #* Különösen nagy és ritka egyenletrendszerekhez alkalmas. ----- <span id="hátrányok"></span> === '''Hátrányok''' === # '''Konvergencia lassúság''': #* Az algoritmus lassú lehet bizonyos típusú mátrixoknál. # '''Rendezési probléma''': #* A sorok sorrendje befolyásolhatja a konvergenciát. # '''Túldeterminált rendszerek''': #* Túl sok egyenlet esetén a rendszer lassabban konvergálhat. ----- <span id="alkalmazások"></span> === '''Alkalmazások''' === # '''Orvosi képalkotás''': #* CT- és MRI-képek rekonstrukciója. # '''Numerikus optimalizáció''': #* Nagy ritka mátrixok elemzése. # '''Adatfeldolgozás''': #* Nagyméretű adathalmazokkal történő lineáris számítások. ----- <span id="összegzés"></span> === '''Összegzés''' === A '''Kaczmarz-Steinhaus-módszer''' egyszerű és hatékony iteratív algoritmus, amely különösen jól alkalmazható ritka mátrixokkal és nagy méretű egyenletrendszerek esetén. Bár nem mindig a leggyorsabb megoldás, az alacsony memóriaigénye és egyszerűsége miatt számos alkalmazási területen népszerű. A modern változatok, mint például a '''stochasztikus Kaczmarz-módszer''', továbbfejlesztették az algoritmus hatékonyságát. {{hunl}} 3nwdvm5karg8k6vsp60gkel23xavcl0 0 798609 3479566 2024-12-12T23:15:40Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479566 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479574 3479566 2024-12-12T23:19:25Z LinguisticMystic 22848 3479574 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} <span id="risch-algoritmus"></span> === '''Risch-algoritmus''' === A '''Risch-algoritmus''' egy döntési eljárás az elemi függvények integrálására. Az algoritmust '''Robert H. Risch''' dolgozta ki az 1960-as években, és a szimbolikus integrálás elméletének egyik mérföldköve. A fő célja annak eldöntése, hogy egy adott elemi függvény primitív függvénye (határozatlan integrálja) kifejezhető-e más elemi függvények segítségével, és ha igen, akkor meg is adja ezt az integrált. ----- <span id="alapfogalmak"></span> === '''Alapfogalmak''' === # '''Elemi függvények''': #* Olyan függvények, amelyek összeadás, kivonás, szorzás, osztás, hatványozás és elemi függvények (pl. trigonometrikus, logaritmikus, exponenciális) alkalmazásával előállíthatók. # '''Primitív függvény''': #* Egy ( F(x) ) függvény primitív függvénye ( f(x) )-nek, ha ( F’(x) = f(x) ). # '''Differenciálható testek''': #* A Risch-algoritmus algebrai struktúrákon (pl. differenciálható testeken) dolgozik, ahol a deriválás jól definiált. ----- <span id="probléma"></span> === '''Probléma''' === Adott egy elemi függvény ( f(x) ). Az algoritmus: # Eldönti, hogy létezik-e elemi primitív függvény ( F(x) ), amelyre ( F’(x) = f(x) ). # Ha létezik, meghatározza ( F(x) )-et. ----- <span id="működés"></span> === '''Működés''' === A Risch-algoritmus algebrai eszközöket használ az integrálási probléma megoldására. Az algoritmus a következő lépésekre bontható: # '''Függvény osztályozása''': #* Az ( f(x) ) függvényt elemi részekre bontja: racionális, logaritmikus, exponenciális, trigonometrikus, stb. # '''Racionális függvények integrálása''': #* A racionális függvények integrálását a részleges törtek módszerével végzi. # '''Logaritmikus és exponenciális függvények''': #* Ha a függvény logaritmusokat vagy exponenciálisokat tartalmaz, az algoritmus megvizsgálja ezek szerkezetét és algebrai kapcsolatát. # '''Tranzcendens függvények''': #* Az algoritmus ellenőrzi, hogy a függvény tartalmaz-e olyan összetevőket (pl. trigonometrikus vagy hiperbólikus függvényeket), amelyek integrálja nem fejezhető ki elemi módon. # '''Algebrai vizsgálat''': #* Az algoritmus algebrai egyenleteket old meg, hogy azonosítsa azokat az elemi függvényeket, amelyek kombinációja az eredeti függvényt adja. # '''Döntés''': #* Ha nincs elemi primitív függvény, az algoritmus kijelenti, hogy a megoldás nem elemi függvény. ----- <span id="példa"></span> === '''Példa''' === <span id="egyszerű-integrálható-függvény"></span> ==== '''1. Egyszerű integrálható függvény''' ==== Adott: ( f(x) = ) # Az algoritmus felismeri, hogy ( ) racionális függvény. # Az eredmény: [ , dx = |x| + C ] <span id="nem-elemi-integrál"></span> ==== '''2. Nem elemi integrál''' ==== Adott: ( f(x) = e^{-x2} ) # Az algoritmus megvizsgálja az ( e^{-x2} ) függvény struktúráját. # A döntés: #* Az algoritmus kijelenti, hogy az ( e^{-x2} ) primitív függvénye nem fejezhető ki elemi módon. ----- <span id="fontos-eszközök"></span> === '''Fontos eszközök''' === # '''Liouville-tétel''': #* Ez a tétel meghatározza, hogy milyen feltételek mellett léteznek elemi integrálok. # '''Racionális együtthatók kezelése''': #* Az algoritmus a differenciálható testek elméletét használja a racionális együtthatók és függvények elemzésére. # '''Tranzcendens és algebrai vizsgálatok''': #* Az algoritmus megkülönbözteti az algebrai és a tranzcendens függvényeket. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>RischAlgorithm(f(x)): 1. Ha f(x) racionális: a. Részleges törtekre bontás. b. Integrálás. 2. Ha f(x) logaritmikus vagy exponenciális: a. Vizsgáld a függvény szerkezetét. b. Határozd meg a lehetséges primitív függvényt. 3. Ha f(x) tranzcendens: a. Ellenőrizd, hogy elemi függvényként kifejezhető-e. 4. Ha egyik sem: a. Jelöld meg, hogy a függvény primitív függvénye nem elemi. 5. Térj vissza az eredménnyel.</pre> ----- <span id="python-implementáció-szimbolikus-eszközökkel"></span> === '''Python implementáció szimbolikus eszközökkel''' === A Risch-algoritmus elmélete összetett, de a '''SymPy''' könyvtárban számos eleme megvalósításra került. <syntaxhighlight lang="python">from sympy import symbols, integrate, exp, ln x = symbols('x') # Példa 1: Racionális függvény f1 = 1 / x integral1 = integrate(f1, x) print("∫1/x dx =", integral1) # Példa 2: Nem elemi integrál f2 = exp(-x**2) integral2 = integrate(f2, x) print("∫e^(-x^2) dx =", integral2)</syntaxhighlight> '''Kimenet''': <pre>∫1/x dx = log(x) ∫e^(-x^2) dx = Integral(exp(-x**2), x)</pre> ----- <span id="előnyök"></span> === '''Előnyök''' === # '''Általánosság''': #* Az algoritmus bármilyen elemi függvény esetén működik. # '''Döntési képesség''': #* Az algoritmus megmondja, hogy létezik-e elemi primitív függvény. # '''Elméleti alapok''': #* Az algoritmus a differenciálható testek és algebrai struktúrák elméletén alapul. ----- <span id="hátrányok"></span> === '''Hátrányok''' === # '''Komplexitás''': #* Az algoritmus nehezen implementálható a sok algebrán alapuló vizsgálat miatt. # '''Nem minden esetben hatékony''': #* Bár működik, néhány esetben a számítási költség magas lehet. ----- <span id="összegzés"></span> === '''Összegzés''' === A Risch-algoritmus egy elméleti eszköz az elemi integrálhatóság eldöntésére és az integrál kiszámítására. Bár modern szimbolikus számítógépes rendszerek (pl. SymPy, Mathematica) használják, az implementáció bonyolultsága miatt teljes megvalósítása ritka. Az algoritmus kiemelkedő fontossággal bír a szimbolikus számítások elméletében, és az integrálási problémák matematikai alapját képezi. {{hunl}} co24jto4zkk51xc9kumiqf0wl2dh217 0 798610 3479567 2024-12-12T23:15:50Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479567 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 0 798611 3479568 2024-12-12T23:15:55Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479568 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479569 3479568 2024-12-12T23:16:22Z LinguisticMystic 22848 LinguisticMystic átnevezte a(z) [[Havel–Hakimi-algoritmus]] lapot a következő névre: [[Havel-Hakimi-algoritmus]] 3479568 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479578 3479569 2024-12-12T23:23:12Z LinguisticMystic 22848 3479578 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} <span id="havel-hakimi-algoritmus"></span> === '''Havel-Hakimi-algoritmus''' === A '''Havel-Hakimi-algoritmus''' egy gráfelméleti algoritmus, amely egy adott fokszámsorozatról eldönti, hogy létezik-e olyan egyszerű gráf, amelynek csúcsfokai megegyeznek ezzel a sorozattal. Az algoritmust '''Vaclav Havel''' (1955) és '''Simon Hakimi''' (1962) dolgozta ki. ----- <span id="fő-ötlet"></span> === '''Fő ötlet''' === Egy fokszámsorozat akkor valósítható meg egy egyszerű gráfban, ha az algoritmus ismételt csökkentésekkel és rendezésekkel ki tudja szűrni az érvényes csúcsösszekötéseket. ----- <span id="algoritmus-működése"></span> === '''Algoritmus működése''' === <span id="bemenet"></span> ==== Bemenet: ==== * Egy nem negatív egész számokat tartalmazó sorozat ((d_1, d_2, , d_n)). <span id="kimenet"></span> ==== Kimenet: ==== * '''Igaz''': Ha létezik egy egyszerű gráf, amely megfelel a sorozatnak. * '''Hamis''': Ha nem létezik ilyen gráf. <span id="feltételek"></span> ==== Feltételek: ==== # Egy '''egyszerű gráf''': #* Nem tartalmaz hurokéleket. #* Nem tartalmaz párhuzamos éleket. ----- <span id="lépések"></span> === '''Lépések''' === # '''Sorozat rendezése''': #* Rendezzük a fokszámsorozatot csökkenő sorrendbe. # '''Érvénytelen fokszám kiszűrése''': #* Ha bármelyik fokszám negatív, a sorozat nem megvalósítható ((Hamis)). # '''Nullák ellenőrzése''': #* Ha minden fokszám (0), akkor a sorozat érvényes ((Igaz)). # '''Csúcsok csökkentése''': #* Vegyük a legnagyobb fokszámot ((d_1)), majd távolítsuk el azt a sorozatból. #* Csökkentsük az első (d_1) elem értékét (1)-gyel (kivéve, ha ez negatív értéket eredményez). # '''Ismétlés''': #* Térj vissza az első lépéshez. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>HavelHakimi(sequence): amíg sequence nem üres: rendezd sequence-et csökkenő sorrendbe ha a sequence első eleme negatív: térj vissza Hamis ha minden elem 0: térj vissza Igaz vegyük ki az első elemet (max_degree) ha max_degree &gt; len(sequence): térj vissza Hamis csökkentsük a sequence első max_degree elemét 1-gyel térj vissza Igaz</pre> ----- <span id="példa"></span> === '''Példa''' === <span id="bemenet-1"></span> ==== Bemenet: ==== ([4, 3, 3, 2, 2]) # Rendezés: ([4, 3, 3, 2, 2]) # Első elem kivétele ((d_1 = 4)): ([3, 3, 2, 2]) # Első négy elem csökkentése: ([2, 2, 1, 1]) # Ismétlés: #* Rendezés: ([2, 2, 1, 1]) #* Első elem kivétele ((d_1 = 2)): ([2, 1, 1]) #* Csökkentés: ([1, 0, 0]) # Ismétlés: #* Rendezés: ([1, 0, 0]) #* Első elem kivétele ((d_1 = 1)): ([0, 0]) #* Csökkentés: ([0, 0]) # Minden elem (0): (Igaz). <span id="kimenet-1"></span> ==== Kimenet: ==== * A sorozat megvalósítható. ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">def havel_hakimi(sequence): while sequence: # Rendezés csökkenő sorrendbe sequence.sort(reverse=True) # Negatív értékek ellenőrzése if sequence[0] < 0: return False # Nullák ellenőrzése if all(degree == 0 for degree in sequence): return True # Legnagyobb fokszám eltávolítása max_degree = sequence.pop(0) # Ellenőrizzük, hogy van-e elég csúcs csökkenteni if max_degree > len(sequence): return False # Csökkentsük az első max_degree csúcsot for i in range(max_degree): sequence[i] -= 1 return True # Példa használat sequence = [4, 3, 3, 2, 2] print("Megvalósítható:", havel_hakimi(sequence))</syntaxhighlight> '''Kimenet''': <pre>Megvalósítható: True</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <algorithm> using namespace std; bool havel_hakimi(vector<int> sequence) { while (!sequence.empty()) { // Rendezés csökkenő sorrendbe sort(sequence.rbegin(), sequence.rend()); // Negatív értékek ellenőrzése if (sequence[0] < 0) { return false; } // Nullák ellenőrzése if (all_of(sequence.begin(), sequence.end(), [](int degree) { return degree == 0; })) { return true; } // Legnagyobb fokszám eltávolítása int max_degree = sequence[0]; sequence.erase(sequence.begin()); // Ellenőrizzük, hogy van-e elég csúcs csökkenteni if (max_degree > sequence.size()) { return false; } // Csökkentsük az első max_degree csúcsot for (int i = 0; i < max_degree; ++i) { sequence[i] -= 1; } } return true; } int main() { vector<int> sequence = {4, 3, 3, 2, 2}; cout << "Megvalósítható: " << (havel_hakimi(sequence) ? "True" : "False") << endl; return 0; }</syntaxhighlight> '''Kimenet''': <pre>Megvalósítható: True</pre> ----- <span id="előnyök"></span> === '''Előnyök''' === # '''Egyszerűség''': #* Az algoritmus intuitív és könnyen implementálható. # '''Hatékonyság''': #* Az algoritmus időkomplexitása (O(n^2)), ami kis méretű gráfok esetén megfelelő. # '''Gráfelméleti alapok''': #* Alkalmas gráfok fokszámsorozatainak vizsgálatára. ----- <span id="hátrányok"></span> === '''Hátrányok''' === # '''Nagyobb méretű adatok esetén''': #* Az (O(n^2)) időkomplexitás miatt lassú lehet nagy méretű sorozatoknál. # '''Specifikus alkalmazás''': #* Csak fokszámsorozatok realizálhatóságának vizsgálatára alkalmas, nem adja meg a gráf konkrét szerkezetét. ----- <span id="összegzés"></span> === '''Összegzés''' === A '''Havel-Hakimi-algoritmus''' egy hatékony eszköz annak eldöntésére, hogy egy fokszámsorozat megvalósítható-e egyszerű gráfként. Alkalmazásai közé tartozik a gráfok modellezése, hálózatelemzés és a gráfelméleti problémák vizsgálata. Egyszerűsége és intuitivitása miatt széles körben tanítják az algoritmusok és gráfelmélet kurzusokon. {{hunl}} 3o0vyatspgufhatig2hierdrqf3s4bk 0 798612 3479570 2024-12-12T23:16:22Z LinguisticMystic 22848 LinguisticMystic átnevezte a(z) [[Havel–Hakimi-algoritmus]] lapot a következő névre: [[Havel-Hakimi-algoritmus]] 3479570 wikitext text/x-wiki #ÁTIRÁNYÍTÁS [[Havel-Hakimi-algoritmus]] ox6o2uf5o5cxwvr932q42elw9ykue3c 0 798613 3479571 2024-12-12T23:16:42Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:einf|futáshossz-kódolás|?}}” 3479571 wikitext text/x-wiki {{engfn}} # {{label|en|informatika}} [[futáshossz-kódolás]] {{engl}} 4b7wmd62h4um8i6ye3fx94lclboj3tu 3479572 3479571 2024-12-12T23:16:50Z LinguisticMystic 22848 3479572 wikitext text/x-wiki {{engfn}} # {{label|en|informatika|algo}} [[futáshossz-kódolás]] {{engl}} hgba4lisrx8jq54c6pdxksriq7nl2uy 0 798614 3479576 2024-12-12T23:19:34Z LinguisticMystic 22848 LinguisticMystic átnevezte a(z) [[Kaczmarz–Steinhaus-módszer]] lapot a következő névre: [[Kaczmarz-Steinhaus-módszer]] 3479576 wikitext text/x-wiki #ÁTIRÁNYÍTÁS [[Kaczmarz-Steinhaus-módszer]] ejs704welps0afhwaew1foxcdu6gjge 0 798615 3479586 2024-12-12T23:48:47Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:emat|?}}” 3479586 wikitext text/x-wiki {{engfn}} # {{label|en|matematika}} [[?]] {{engl}} ozus8oazkvnvomzgwwl0dvotrr8unnk 3479590 3479586 2024-12-12T23:55:26Z LinguisticMystic 22848 3479590 wikitext text/x-wiki {{engfn}} # {{label|en|matematika}} [[mátrix láncszorzás]] {{engl}} ls652swo7m17kknu0n0r5aba60x5em3 0 798616 3479588 2024-12-12T23:51:03Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479588 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479602 3479588 2024-12-13T00:03:26Z LinguisticMystic 22848 3479602 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} A '''Kahn-algoritmus''' egy széles körben használt módszer a '''topologikus rendezés''' elvégzésére irányított, körmentes gráfokon ('''DAG - Directed Acyclic Graph'''). A topologikus rendezés egy olyan sorrend, amelyben a gráf csúcsai elrendezhetők úgy, hogy minden irányított él ( (u, v) ) esetén ( u ) mindig ( v ) előtt szerepel a sorrendben. ----- <span id="fő-ötlet"></span> === '''Fő ötlet''' === Az algoritmus az '''indegree''' (bejövő élek száma) fogalmát használja: 1. Azokat a csúcsokat választja ki, amelyeknek nincs bejövő élük (indegree = 0). 2. Ezeket a csúcsokat a sorrendbe helyezi, majd eltávolítja őket a gráfból. 3. A folyamatot addig ismétli, amíg az összes csúcsot feldolgozza, vagy megáll, ha kör található a gráfban. ----- <span id="algoritmus-lépései"></span> === '''Algoritmus lépései''' === <span id="indegree-kiszámítása"></span> ==== '''1. Indegree kiszámítása''' ==== * Minden csúcsra meghatározzuk a bejövő élek számát. <span id="indegree-0-csúcsok-hozzáadása-a-várakozási-sorhoz"></span> ==== '''2. Indegree = 0 csúcsok hozzáadása a várakozási sorhoz''' ==== * Egy olyan adatszerkezetbe helyezzük a csúcsokat (például sorba vagy verembe), amelyeknek nincs bejövő élük. <span id="iteráció"></span> ==== '''3. Iteráció''' ==== * Amíg a várakozási sor nem üres: ** Vegyük ki a sor első elemét, és adjuk hozzá a topologikus sorrendhez. ** Távolítsuk el a gráfhoz tartozó éleit, és frissítsük a bejövő élek számát. ** Ha egy csúcs bejövő élei 0-ra csökkennek, adjuk hozzá a várakozási sorhoz. <span id="ellenőrzés"></span> ==== '''4. Ellenőrzés''' ==== * Ha minden csúcs feldolgozásra került, a gráf topologikusan rendezett. * Ha maradnak csúcsok bejövő élekkel, a gráf kör tartalmaz. ----- <span id="idő--és-tárkomplexitás"></span> === '''Idő- és tárkomplexitás''' === * '''Időbonyolultság''': ( O(V + E) ), ahol ( V ) a csúcsok és ( E ) az élek száma. * '''Tárbonyolultság''': ( O(V + E) ) az adatszerkezetek tárolására. ----- <span id="pszeudokód"></span> === '''Pszeudokód''' === <pre>KahnAlgorithm(graph): indegree = [0] * len(graph) for u in graph: for v in graph[u]: indegree[v] += 1 queue = [] for i in range(len(indegree)): if indegree[i] == 0: queue.append(i) topo_order = [] while queue: u = queue.pop(0) topo_order.append(u) for v in graph[u]: indegree[v] -= 1 if indegree[v] == 0: queue.append(v) if len(topo_order) != len(graph): return &quot;Kör található a gráfban!&quot; return topo_order</pre> ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">from collections import deque def kahn_topological_sort(graph): # Indegree kiszámítása indegree = {node: 0 for node in graph} for u in graph: for v in graph[u]: indegree[v] += 1 # Indegree = 0 csúcsok hozzáadása a sorhoz queue = deque([node for node in graph if indegree[node] == 0]) topo_order = [] while queue: u = queue.popleft() topo_order.append(u) for v in graph[u]: indegree[v] -= 1 if indegree[v] == 0: queue.append(v) # Ellenőrzés, hogy körmentes-e a gráf if len(topo_order) != len(graph): return "Kör található a gráfban!" return topo_order # Példa gráf graph = { 0: [1, 2], 1: [3], 2: [3], 3: [4], 4: [] } print("Topologikus sorrend:", kahn_topological_sort(graph))</syntaxhighlight> '''Kimenet''': <pre>Topologikus sorrend: [0, 1, 2, 3, 4]</pre> ----- <span id="c-implementáció"></span> === '''C++ implementáció''' === <syntaxhighlight lang="cpp">#include <iostream> #include <vector> #include <queue> #include <unordered_map> using namespace std; vector<int> kahn_topological_sort(unordered_map<int, vector<int>>& graph, int V) { vector<int> indegree(V, 0); // Indegree kiszámítása for (const auto& [u, neighbors] : graph) { for (int v : neighbors) { indegree[v]++; } } // Indegree = 0 csúcsok hozzáadása a sorhoz queue<int> q; for (int i = 0; i < V; ++i) { if (indegree[i] == 0) { q.push(i); } } vector<int> topo_order; while (!q.empty()) { int u = q.front(); q.pop(); topo_order.push_back(u); for (int v : graph[u]) { indegree[v]--; if (indegree[v] == 0) { q.push(v); } } } // Ellenőrzés, hogy körmentes-e a gráf if (topo_order.size() != V) { cout << "Kör található a gráfban!" << endl; return {}; } return topo_order; } int main() { unordered_map<int, vector<int>> graph = { {0, {1, 2}}, {1, {3}}, {2, {3}}, {3, {4}}, {4, {}} }; int V = 5; vector<int> topo_order = kahn_topological_sort(graph, V); cout << "Topologikus sorrend: "; for (int node : topo_order) { cout << node << " "; } cout << endl; return 0; }</syntaxhighlight> '''Kimenet''': <pre>Topologikus sorrend: 0 1 2 3 4</pre> ----- <span id="alkalmazások"></span> === '''Alkalmazások''' === # '''Feladatütemezés''': #* Függőségek kezelése, például projektek vagy feladatok sorrendjének meghatározása. # '''Verziókezelés''': #* Kód függőségek sorrendjének meghatározása. # '''Gráf algoritmusok''': #* Körök keresése irányított gráfokban. # '''Fordítóprogramok''': #* Kódkomponensek (osztályok, függvények) sorrendjének meghatározása. ----- <span id="összegzés"></span> === '''Összegzés''' === A '''Kahn-algoritmus''' egy hatékony és egyszerű módszer a topologikus rendezésre irányított, körmentes gráfokon. Az (O(V + E)) időbonyolultsága miatt nagy gráfok esetén is hatékony, és széles körben alkalmazható valós problémák megoldására, például feladatütemezésre és függőségkezelésre. Az algoritmus körök detektálására is használható, ami különösen hasznos hibakeresési és rendszerelemzési feladatokban. {{hunl}} g0eu9s29kzzcquqwk6kwofwmrctx7k8 0 798617 3479594 2024-12-12T23:59:51Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:emat|?}}” 3479594 wikitext text/x-wiki {{engfn}} # {{label|en|matematika}} [[?]] {{engl}} ozus8oazkvnvomzgwwl0dvotrr8unnk 0 798618 3479596 2024-12-13T00:01:18Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479596 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479603 3479596 2024-12-13T00:03:52Z LinguisticMystic 22848 3479603 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} {{hunl}} atrd4nhwuncaw9p5riccto8qrdmvovz 3479604 3479603 2024-12-13T00:04:54Z LinguisticMystic 22848 3479604 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} A '''Las Vegas-algoritmus''' egy olyan véletlenített algoritmus, amely mindig helyes eredményt ad, de a futási ideje véletlenszerű lehet. Más szóval, garantáltan helyes, de a végrehajtási idő a bemenettől és a véletlenszerű választásoktól függ. ----- <span id="tulajdonságai"></span> === '''Tulajdonságai''' === # '''Determinált kimenet''': #* Az algoritmus soha nem ad hibás eredményt, azaz ha véget ér, akkor biztosan helyes megoldást szolgáltat. # '''Véletlen futási idő''': #* A futási idő véletlenszerű, és a bemenettől függően különböző lehet. # '''Eltérés a Monte Carlo-algoritmusoktól''': #* Míg a Monte Carlo-algoritmusok gyorsak, de nem garantáltan helyesek, a Las Vegas-algoritmusok mindig helyesek, de a futási idejük változó. ----- <span id="hogyan-működik"></span> === '''Hogyan működik?''' === * Az algoritmus véletlenszerű stratégiákat próbál ki, amíg meg nem talál egy helyes megoldást. * Ha egy adott stratégia nem működik, az algoritmus újraindul egy másik véletlenszerű választással. * Amikor az algoritmus megtalálja a helyes megoldást, leáll. ----- <span id="példa-gyors-rendezés-randomized-quicksort"></span> === '''Példa: Gyors rendezés (Randomized QuickSort)''' === A gyorsrendezés egyik véletlenített változata Las Vegas-algoritmus, amely a partíciós lépés során véletlenszerűen választ pivot elemet. Ez nem befolyásolja az eredmény helyességét, de véletlenszerűvé teszi a futási időt. <span id="algoritmus-lépései"></span> ==== '''Algoritmus lépései''' ==== # Véletlenszerűen válassz egy pivot elemet. # Oszd két részre a tömböt a pivot szerint. # Rekurzívan alkalmazd az algoritmust a két részre. <span id="python-implementáció"></span> ==== '''Python implementáció''' ==== <syntaxhighlight lang="python">import random def randomized_quicksort(arr): if len(arr) <= 1: return arr pivot_index = random.randint(0, len(arr) - 1) pivot = arr[pivot_index] less = [x for x in arr if x < pivot] equal = [x for x in arr if x == pivot] greater = [x for x in arr if x > pivot] return randomized_quicksort(less) + equal + randomized_quicksort(greater) # Példa használat arr = [3, 6, 8, 10, 1, 2, 1] sorted_arr = randomized_quicksort(arr) print("Rendezett tömb:", sorted_arr)</syntaxhighlight> '''Kimenet''': <pre>Rendezett tömb: [1, 1, 2, 3, 6, 8, 10]</pre> ----- <span id="példa-las-vegas-alapú-prímteszt"></span> === '''Példa: Las Vegas-alapú prímteszt''' === Egy prímteszt, amely garantáltan helyes eredményt ad, de a futási ideje a bemenettől és a véletlenszerű választásoktól függ. <span id="python-implementáció-1"></span> ==== '''Python implementáció''' ==== <syntaxhighlight lang="python">import random def is_prime_las_vegas(n, k=5): # k az ismétlések száma if n <= 1: return False if n <= 3: return True if n % 2 == 0: return False # Írjuk fel n-1 = 2^r * d alakban r, d = 0, n - 1 while d % 2 == 0: r += 1 d //= 2 for _ in range(k): a = random.randint(2, n - 2) x = pow(a, d, n) # a^d % n if x == 1 or x == n - 1: continue for _ in range(r - 1): x = pow(x, 2, n) if x == n - 1: break else: return False # Kompozit return True # Prím # Példa használat print("29 prím?", is_prime_las_vegas(29)) # True print("30 prím?", is_prime_las_vegas(30)) # False</syntaxhighlight> ----- <span id="időbonyolultság"></span> === '''Időbonyolultság''' === * '''Átlagos eset''': Az algoritmus általában gyors, de a futási idő véletlenszerűen változik. * '''Legrosszabb eset''': Ritkán, de előfordulhat, hogy az algoritmus sokáig fut (például ha sok véletlen választás sikertelen). ----- <span id="előnyök"></span> === '''Előnyök''' === # '''Helyesség''': #* Mindig garantáltan helyes megoldást ad. # '''Egyszerűség''': #* Véletlenítés révén gyakran elkerüli a speciális eseteket, amelyek egy determinisztikus algoritmus számára problémát jelenthetnek. # '''Hatékonyság''': #* Gyakran gyorsabb, mint determinisztikus algoritmusok, különösen rosszul strukturált bemeneteknél. ----- <span id="hátrányok"></span> === '''Hátrányok''' === # '''Nem kiszámítható futási idő''': #* A véletlenszerű döntések miatt nehéz előre meghatározni a futási időt. # '''Véletlenszám-generátor minősége''': #* Az algoritmus megbízhatósága nagyban függ a véletlenszám-generátor minőségétől. ----- <span id="alkalmazások"></span> === '''Alkalmazások''' === # '''Rendezési algoritmusok''': #* Randomized QuickSort. # '''Prímtesztelés''': #* Véletlenszerűen generált tesztek alkalmazása. # '''Adatstruktúrák''': #* Hash-alapú algoritmusok optimalizálása véletlenszerű eljárásokkal. # '''Játék- és stratégiaoptimalizálás''': #* Például mesterséges intelligencia algoritmusokban. ----- <span id="összegzés"></span> === '''Összegzés''' === A '''Las Vegas-algoritmusok''' olyan véletlenített algoritmusok, amelyek garantáltan helyes eredményt adnak, de a futási idejük változó. Az egyszerűsége és hatékonysága miatt számos területen alkalmazható, különösen olyan problémák esetén, ahol determinisztikus algoritmusok nehezen alkalmazhatók vagy lassúak. A véletlenszerűség segítségével elkerülik a problémás eseteket, miközben megbízható eredményeket adnak. {{hunl}} 7v2e24eyw0ltky4b2jfzvnygmddbaxv 0 798619 3479600 2024-12-13T00:02:23Z LinguisticMystic 22848 LinguisticMystic átnevezte a(z) [[Quine–McCluskey algorithm]] lapot a következő névre: [[Quine-McCluskey algorithm]] 3479600 wikitext text/x-wiki #ÁTIRÁNYÍTÁS [[Quine-McCluskey algorithm]] 1qp140s6qvcnlnzyi10g5hykkvj15h4 0 798620 3479601 2024-12-13T00:02:33Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:hmat|?}}” 3479601 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} ? {{hunl}} ge4tzf1n5qz69bj827bo4fz9xj03kdp 3479605 3479601 2024-12-13T00:06:39Z LinguisticMystic 22848 3479605 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika}} <span id="quine-mccluskey-algoritmus"></span> === '''Quine-McCluskey-algoritmus''' === A '''Quine-McCluskey-algoritmus''' egy módszer a logikai függvények '''minimális diszjunktív normálformájának (DNF)''' vagy '''minimális konjunktív normálformájának (KNF)''' megtalálására. Az algoritmus hatékonyan alkalmazható kisebb változós rendszerek logikai egyszerűsítésére, és gyakran használják a '''Karnaugh-térkép''' helyettesítésére. ----- <span id="fő-cél"></span> === '''Fő cél''' === Adott egy logikai függvény '''igazságtáblája''', az algoritmus célja: 1. '''Prime implikánsok''' azonosítása (olyan kifejezések, amelyek minimálisak, de lefedik a függvény igazságos esetét). 2. Az igazságos eseteket lefedő '''esszenciális prime implikánsok''' megtalálása. 3. A függvény minimális alakjának meghatározása. ----- <span id="algoritmus-lépései"></span> === '''Algoritmus lépései''' === <span id="igazságtábla-reprezentálása-mintermekkel"></span> ==== '''1. Igazságtábla reprezentálása mintermekkel''' ==== * Minden olyan kombinációt ('''minterm'''), amelynél a kimenet (1), bináris számként reprezentálunk. <span id="mintermek-csoportosítása"></span> ==== '''2. Mintermek csoportosítása''' ==== * A mintermeket a bennük lévő (1)-ek száma szerint csoportosítjuk. <span id="párosítás-és-egyszerűsítés"></span> ==== '''3. Párosítás és egyszerűsítés''' ==== * A mintermeket párosítjuk, ha csak egy változó különbözik köztük. Az eltérő bit helyén '''„-”''' jelet használunk a megkülönböztetés jelzésére. * Az újonnan generált kifejezések nem vesznek el információt, de általánosabbá válnak. <span id="prime-implikánsok-meghatározása"></span> ==== '''4. Prime implikánsok meghatározása''' ==== * Azokat az implikánsokat, amelyek nem egyszerűsíthetők tovább, '''prime implikánsoknak''' nevezzük. <span id="esszenciális-prime-implikánsok-kiválasztása"></span> ==== '''5. Esszenciális prime implikánsok kiválasztása''' ==== * Olyan prime implikánsok kiválasztása, amelyek egyedül lefedik az igazságtábla egyes (1)-es kimeneteit. <span id="lefedési-mátrix"></span> ==== '''6. Lefedési mátrix''' ==== * Készítsünk egy mátrixot, amely megmutatja, hogy mely mintermeket mely prime implikánsok fedik le. * A minimális lefedési probléma megoldásával meghatározzuk a logikai függvény egyszerűsített alakját. ----- <span id="példa"></span> === '''Példa''' === <span id="igazságtábla"></span> ==== '''1. Igazságtábla''' ==== Adott az (f(A, B, C) = (1, 3, 7)) függvény, ahol a mintermek (1, 3, 7): {| class="wikitable" |- ! (A) ! (B) ! (C) ! (f(A, B, C)) |- | 0 | 0 | 0 | 0 |- | 0 | 0 | 1 | 1 ((1)) |- | 0 | 1 | 0 | 0 |- | 0 | 1 | 1 | 1 ((3)) |- | 1 | 0 | 0 | 0 |- | 1 | 0 | 1 | 0 |- | 1 | 1 | 0 | 0 |- | 1 | 1 | 1 | 1 ((7)) |} <span id="bináris-reprezentáció"></span> ==== '''2. Bináris reprezentáció''' ==== {| class="wikitable" |- ! Minterm ! Bináris ! (1)-ek száma |- | 1 | 001 | 1 |- | 3 | 011 | 2 |- | 7 | 111 | 3 |} <span id="párosítás-és-egyszerűsítés-1"></span> ==== '''3. Párosítás és egyszerűsítés''' ==== # '''Első lépés''': #* Párosítsunk olyan mintermeket, amelyek csak egy bitben különböznek: #** (001) és (011) -&gt; (0-1) (A második bit különbözik). #** (011) és (111) -&gt; (-11) (Az első bit különbözik). # '''Második lépés''': #* További egyszerűsítés: #** (0-1) és (-11) nem egyszerűsíthető tovább. <span id="prime-implikánsok"></span> ==== '''4. Prime implikánsok''' ==== Az egyszerűsíthető kifejezések: - (0-1) ((A’ C)). - (-11) ((B C)). <span id="esszenciális-prime-implikánsok"></span> ==== '''5. Esszenciális prime implikánsok''' ==== A mintermek lefedése: - (1) -&gt; (0-1) - (3) -&gt; (0-1, -11) - (7) -&gt; (-11) Az esszenciális prime implikánsok: - (0-1): Lefedi (1)-et. - (-11): Lefedi (7)-et. <span id="minimális-függvény"></span> ==== '''6. Minimális függvény''' ==== Az egyszerűsített logikai függvény: [ f(A, B, C) = A’ C + B C ] ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">from itertools import combinations def count_ones(term): return sum(1 for bit in term if bit == '1') def combine_terms(term1, term2): diff = sum(1 for a, b in zip(term1, term2) if a != b) if diff == 1: combined = ''.join('-' if a != b else a for a, b in zip(term1, term2)) return combined return None def quine_mccluskey(minterms, num_vars): terms = [bin(m)[2:].zfill(num_vars) for m in minterms] grouped = {i: [] for i in range(num_vars + 1)} for term in terms: grouped[count_ones(term)].append(term) prime_implicants = set() while grouped: new_group = {i: [] for i in range(num_vars + 1)} used = set() for i in range(num_vars): for term1 in grouped[i]: for term2 in grouped[i + 1]: combined = combine_terms(term1, term2) if combined: used.add(term1) used.add(term2) new_group[count_ones(combined)].append(combined) prime_implicants.update(set(t for group in grouped.values() for t in group) - used) grouped = new_group if not any(grouped.values()): break return prime_implicants # Példa minterms = [1, 3, 7] num_vars = 3 prime_implicants = quine_mccluskey(minterms, num_vars) print("Prime implikánsok:", prime_implicants)</syntaxhighlight> '''Kimenet''': <pre>Prime implikánsok: {'0-1', '-11'}</pre> ----- <span id="előnyök"></span> === '''Előnyök''' === # '''Hatékony kisebb problémákra''': #* Automatizált egyszerűsítést nyújt kis logikai függvényekre. # '''Pontosság''': #* Garantáltan megtalálja a minimális alakot. ----- <span id="hátrányok"></span> === '''Hátrányok''' === # '''Nagy méretű problémák''': #* A nagy számú változók és mintermek esetén exponenciális futási időt eredményez. # '''Tárigény''': #* A táblázatok kezelése nagy memóriát igényelhet. ----- <span id="összegzés"></span> === '''Összegzés''' === A '''Quine-McCluskey-algoritmus''' egy hatékony, de korlátos módszer a logikai függvények minimalizálására. Kisebb méretű problémák esetén kiváló, de nagy rendszerek esetén praktikusabb a '''Karnaugh-térkép''' vagy heurisztikus megközelítések használata. {{hunl}} olmr50tsyi8p2tesu0jpvd92g6y1mhg 3479606 3479605 2024-12-13T00:06:59Z LinguisticMystic 22848 3479606 wikitext text/x-wiki {{hunfn}} #{{label|hu|matematika|algo}} <span id="quine-mccluskey-algoritmus"></span> === '''Quine-McCluskey-algoritmus''' === A '''Quine-McCluskey-algoritmus''' egy módszer a logikai függvények '''minimális diszjunktív normálformájának (DNF)''' vagy '''minimális konjunktív normálformájának (KNF)''' megtalálására. Az algoritmus hatékonyan alkalmazható kisebb változós rendszerek logikai egyszerűsítésére, és gyakran használják a '''Karnaugh-térkép''' helyettesítésére. ----- <span id="fő-cél"></span> === '''Fő cél''' === Adott egy logikai függvény '''igazságtáblája''', az algoritmus célja: 1. '''Prime implikánsok''' azonosítása (olyan kifejezések, amelyek minimálisak, de lefedik a függvény igazságos esetét). 2. Az igazságos eseteket lefedő '''esszenciális prime implikánsok''' megtalálása. 3. A függvény minimális alakjának meghatározása. ----- <span id="algoritmus-lépései"></span> === '''Algoritmus lépései''' === <span id="igazságtábla-reprezentálása-mintermekkel"></span> ==== '''1. Igazságtábla reprezentálása mintermekkel''' ==== * Minden olyan kombinációt ('''minterm'''), amelynél a kimenet (1), bináris számként reprezentálunk. <span id="mintermek-csoportosítása"></span> ==== '''2. Mintermek csoportosítása''' ==== * A mintermeket a bennük lévő (1)-ek száma szerint csoportosítjuk. <span id="párosítás-és-egyszerűsítés"></span> ==== '''3. Párosítás és egyszerűsítés''' ==== * A mintermeket párosítjuk, ha csak egy változó különbözik köztük. Az eltérő bit helyén '''„-”''' jelet használunk a megkülönböztetés jelzésére. * Az újonnan generált kifejezések nem vesznek el információt, de általánosabbá válnak. <span id="prime-implikánsok-meghatározása"></span> ==== '''4. Prime implikánsok meghatározása''' ==== * Azokat az implikánsokat, amelyek nem egyszerűsíthetők tovább, '''prime implikánsoknak''' nevezzük. <span id="esszenciális-prime-implikánsok-kiválasztása"></span> ==== '''5. Esszenciális prime implikánsok kiválasztása''' ==== * Olyan prime implikánsok kiválasztása, amelyek egyedül lefedik az igazságtábla egyes (1)-es kimeneteit. <span id="lefedési-mátrix"></span> ==== '''6. Lefedési mátrix''' ==== * Készítsünk egy mátrixot, amely megmutatja, hogy mely mintermeket mely prime implikánsok fedik le. * A minimális lefedési probléma megoldásával meghatározzuk a logikai függvény egyszerűsített alakját. ----- <span id="példa"></span> === '''Példa''' === <span id="igazságtábla"></span> ==== '''1. Igazságtábla''' ==== Adott az (f(A, B, C) = (1, 3, 7)) függvény, ahol a mintermek (1, 3, 7): {| class="wikitable" |- ! (A) ! (B) ! (C) ! (f(A, B, C)) |- | 0 | 0 | 0 | 0 |- | 0 | 0 | 1 | 1 ((1)) |- | 0 | 1 | 0 | 0 |- | 0 | 1 | 1 | 1 ((3)) |- | 1 | 0 | 0 | 0 |- | 1 | 0 | 1 | 0 |- | 1 | 1 | 0 | 0 |- | 1 | 1 | 1 | 1 ((7)) |} <span id="bináris-reprezentáció"></span> ==== '''2. Bináris reprezentáció''' ==== {| class="wikitable" |- ! Minterm ! Bináris ! (1)-ek száma |- | 1 | 001 | 1 |- | 3 | 011 | 2 |- | 7 | 111 | 3 |} <span id="párosítás-és-egyszerűsítés-1"></span> ==== '''3. Párosítás és egyszerűsítés''' ==== # '''Első lépés''': #* Párosítsunk olyan mintermeket, amelyek csak egy bitben különböznek: #** (001) és (011) -&gt; (0-1) (A második bit különbözik). #** (011) és (111) -&gt; (-11) (Az első bit különbözik). # '''Második lépés''': #* További egyszerűsítés: #** (0-1) és (-11) nem egyszerűsíthető tovább. <span id="prime-implikánsok"></span> ==== '''4. Prime implikánsok''' ==== Az egyszerűsíthető kifejezések: - (0-1) ((A’ C)). - (-11) ((B C)). <span id="esszenciális-prime-implikánsok"></span> ==== '''5. Esszenciális prime implikánsok''' ==== A mintermek lefedése: - (1) -&gt; (0-1) - (3) -&gt; (0-1, -11) - (7) -&gt; (-11) Az esszenciális prime implikánsok: - (0-1): Lefedi (1)-et. - (-11): Lefedi (7)-et. <span id="minimális-függvény"></span> ==== '''6. Minimális függvény''' ==== Az egyszerűsített logikai függvény: [ f(A, B, C) = A’ C + B C ] ----- <span id="python-implementáció"></span> === '''Python implementáció''' === <syntaxhighlight lang="python">from itertools import combinations def count_ones(term): return sum(1 for bit in term if bit == '1') def combine_terms(term1, term2): diff = sum(1 for a, b in zip(term1, term2) if a != b) if diff == 1: combined = ''.join('-' if a != b else a for a, b in zip(term1, term2)) return combined return None def quine_mccluskey(minterms, num_vars): terms = [bin(m)[2:].zfill(num_vars) for m in minterms] grouped = {i: [] for i in range(num_vars + 1)} for term in terms: grouped[count_ones(term)].append(term) prime_implicants = set() while grouped: new_group = {i: [] for i in range(num_vars + 1)} used = set() for i in range(num_vars): for term1 in grouped[i]: for term2 in grouped[i + 1]: combined = combine_terms(term1, term2) if combined: used.add(term1) used.add(term2) new_group[count_ones(combined)].append(combined) prime_implicants.update(set(t for group in grouped.values() for t in group) - used) grouped = new_group if not any(grouped.values()): break return prime_implicants # Példa minterms = [1, 3, 7] num_vars = 3 prime_implicants = quine_mccluskey(minterms, num_vars) print("Prime implikánsok:", prime_implicants)</syntaxhighlight> '''Kimenet''': <pre>Prime implikánsok: {'0-1', '-11'}</pre> ----- <span id="előnyök"></span> === '''Előnyök''' === # '''Hatékony kisebb problémákra''': #* Automatizált egyszerűsítést nyújt kis logikai függvényekre. # '''Pontosság''': #* Garantáltan megtalálja a minimális alakot. ----- <span id="hátrányok"></span> === '''Hátrányok''' === # '''Nagy méretű problémák''': #* A nagy számú változók és mintermek esetén exponenciális futási időt eredményez. # '''Tárigény''': #* A táblázatok kezelése nagy memóriát igényelhet. ----- <span id="összegzés"></span> === '''Összegzés''' === A '''Quine-McCluskey-algoritmus''' egy hatékony, de korlátos módszer a logikai függvények minimalizálására. Kisebb méretű problémák esetén kiváló, de nagy rendszerek esetén praktikusabb a '''Karnaugh-térkép''' vagy heurisztikus megközelítések használata. {{hunl}} n24asbu6p2elhxpjyj0ia9hwxwlvyrv 0 798621 3479608 2024-12-13T00:12:40Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:emat|pitagoraszi számhármas}}” 3479608 wikitext text/x-wiki {{engfn}} # {{label|en|matematika}} [[pitagoraszi számhármas]] {{engl}} 4dehdy7yuzi33pm3l6z9p4tlxmrlr27 0 798622 3479609 2024-12-13T00:12:56Z LinguisticMystic 22848 Új oldal, tartalma: „{{subst:újmat|Pythagorean triple|?}}” 3479609 wikitext text/x-wiki {{hunfn}} # {{label|hu|matematika}} {{-ford-}} {{trans-top}} *{{en}}: {{t+|en|Pythagorean triple}} {{trans-bottom}} {{hunl}} f8fz5o0ala5i3isjoptiqp8o0xtyn9b