Gráfok tulajdonságai

Használható segédanyagok: Haskell könyvtárainak dokumentációja, (lokális!) Hoogle, a tárgy honlapja és a BE-AD rendszerbe feltöltött beadandók. Ha bármilyen kérdés, észrevétel felmerül, azt a felügyelőknek kell jelezni, nem a diáktársaknak!

A feladatok egymásra épülnek ezért érdemes ezeket a megadásuk sorrendjében megoldani, de legalább megérteni az aktuális feladatot megelőző feladatokat! A függvények definíciójában lehet, sőt javasolt is alkalmazni a korábban definiált függvényeket (függetlenül attól, hogy sikerült-e azokat megadni).

Tekintve, hogy a tesztesetek, bár odafigyelés mellett íródnak, nem fedik le minden esetben a függvény teljes működését, határozottan javasolt még külön próbálgatni a megoldásokat beadás előtt, vagy megkérdezni a felügyelőket!

Részpontszámokat csak az elégséges szint elérése után lehet kapni!

A feladat összefoglaló leírása (Összesen: 17 pont)

Ebben a feladatban a matematikából ismert gráfok bizonyos tulajdonságainak vizsgálatát kell megvalósítani. Egy gráfot csomópontok vagy más néven csúcsok alkotnak, és ezeken értelmezünk összeköttetéseket, éleket. Az élek lényegében az adják meg, hogy melyik két csúcs között van kapcsolat. A gráfok csúcsai címkézettek, azaz meg lehet különböztetni ezeket. Az élek szerint egy gráf irányított vagy irányítatlan attól függően, hogy az élek feldolgozásakor különbséget teszük aközött, hogy az él megadásakor melyik volt a kiinduló csúcs és melyik a cél. Ha irányított, akkor ezt figyelembe vesszük, ha irányítatlan, akkor pedig nem.

A feladat során most címkézett, irányítatlan gráfokkal kell dolgoznunk, és ennek megfelelően a gráfokat listában adjuk meg, amely az éleket tartalmazza. Az élek rendezett párként jelennek meg, ahol az első komponens a kiinduló-, a második a célcsúcs.

Ezzel az ábrázolással például így adhatunk meg gráfokat. Ezeket a későbbiekben a tesztekben is alkalmazni fogjuk:

graph1 :: [(Int,Int)]
graph1 = []

Graphsb96c93db25a18d1bd34bdc39e477c8c5.png

graph2 = [(1,2), (2,4), (2,3), (4,1)]

Graphs42fe2a84e08275ce7fdfd4811acc8aad.png

graph3 = [(1,2), (2,3), (3,4), (4,1)]

Graphs333f80e65a9359ddf3d6877ccb3189b6.png

graph4 = [(1,2), (1,3), (1,4), (2,3), (2,4), (3,4)]

Graphs739b752dbb8c6453ea2a4dea9626b582.png

graph5 = [(3,4), (6,8), (5,3), (5,4), (2,1), (6,7), (8,7)]

Graphs6ae088d5cc3671a1caefe3bba84f2161.png

graph6 = [(2,3)]

A gráf csúcsai és a gráf csúcsainak száma (2 pont)

Készítsünk egy olyan függvényt, amely megadja egy gráf csúcsait egy listában! Ügyeljünk arra, hogy minden csúcs csak egyszer szerepeljen!

nodesOf :: Eq a => [(a, a)] -> [a]

Test>
[] :: [Int]
Test>
[1, 2, 3, 4] :: [Integer]
Test>
[1, 2, 3, 4] :: [Integer]
Test>
[1, 2, 3, 4] :: [Integer]
Test>
[1, 2, 3, 4, 5, 6, 7, 8] :: [Integer]
Test>
[2, 3] :: [Integer]

Készítsünk egy függvényt, amely megadja a gráf csúcsainak számát!

numberOfNodes :: Eq a => [(a, a)] -> Int

Test>
0 :: Int
Test>
4 :: Int
Test>
4 :: Int
Test>
4 :: Int
Test>
8 :: Int
Test>
2 :: Int

Szomszédos-e két csúcs? (1 pont)

Definiáljunk egy függvényt, amely egy gráf ismeretében el tudja dönteni, hogy benne két csúcs szomszédja-e egymásnak! Két csúcsot szomszédosnak tekintünk, amennyiben létezik köztük él (akármelyik irányban). Ha valamelyik csúcs nem található a gráfban, akkor az eredmény legyen hamis!

areNeighbors :: Eq a => [(a, a)] -> a -> a -> Bool

Test>
False :: Bool
Test>
False :: Bool
Test>
True :: Bool
Test>
True :: Bool
Test>
False :: Bool
Test>
True :: Bool
Test>
False :: Bool
Test>
False :: Bool
Test>
True :: Bool
Test>
True :: Bool

Gráf teljessége (2 pont)

Döntsük el egy gráfról, hogy teljes-e! Egy gráfot teljesnek nevezünk, ha minden csúcsát él köti össze, vagyis minden csúcsa össze van kötve minden más csúccsal.

isCompleteGraph :: Eq a => [(a, a)] -> Bool

Test>
False :: Bool
Test>
False :: Bool
Test>
False :: Bool
Test>
True :: Bool
Test>
False :: Bool
Test>
True :: Bool

Egy csúcs szomszédjai (1 pont)

Írjunk egy olyan függvényt, amely egy gráf ismeretében megadja egy adott csúcs összes szomszédját egy listában! Szomszédosnak azokat a csúcsokat vesszük a gráfban, amelyekhez van él a megadottból. Vigyázzunk arra, hogy az eredményben minden csúcs csak egyszer szerepeljen!

neighborsOf :: Eq a => [(a, a)] -> a -> [a]

Test>
[] :: [Int]
Test>
[] :: [Integer]
Test>
[2, 4] :: [Integer]
Test>
[1, 3, 4] :: [Integer]
Test>
[2, 4] :: [Integer]
Test>
[1, 3] :: [Integer]
Test>
[2, 3, 4] :: [Integer]
Test>
[1, 3, 4] :: [Integer]
Test>
[3, 4] :: [Integer]
Test>
[6, 7] :: [Integer]
Test>
[3] :: [Integer]

Reguláris-e a gráf? (3 pont)

Döntsük el egy gráfról, hogy reguláris-e! Egy gráfot regulárisnak hívunk, ha minden csúcsából pontosan megegyező számú él indul ki, azaz mindegyik csúcsnak pontosan ugyanannyi szomszédja van.

isRegularGraph :: Eq a => [(a, a)] -> Bool

Test>
False :: Bool
Test>
False :: Bool
Test>
True :: Bool
Test>
True :: Bool
Test>
False :: Bool
Test>
True :: Bool

Utak két csúcs között (3 pont)

Adjuk meg azt a függvényt, amely listákban megadja két csúcs között azokat a csúcsokat, amelyeken keresztül az egyikből elérhető a másik! Ezek lesznek a két csúcs közti utak a gráfban. Mindegyik út tartalmazza a kiinduló- és célcsúcsot is. Ha valamelyik csúcs nem szerepel a gráfban, a két csúcs megegyezik, vagy nincs köztük út, akkor az eredmény legyen üres lista!

pathsBetween :: Eq a => [(a, a)] -> a -> a -> [[a]]

Test>
[] :: [[Int]]
Test>
[[1, 2, 3], [1, 4, 2, 3]] :: [[Integer]]
Test>
[[2, 3]] :: [[Integer]]
Test>
[[1, 2, 3, 4], [1, 4]] :: [[Integer]]
Test>
[[1, 2, 3, 4], [1, 2, 4], [1, 3, 2, 4], [1, 3, 4], [1, 4]] :: [[Integer]]
Test>
[[2, 1, 3, 4], [2, 1, 4], [2, 3, 1, 4], [2, 3, 4], [2, 4]] :: [[Integer]]
Test>
[] :: [[Integer]]
Test>
[[6, 7], [6, 8, 7]] :: [[Integer]]
Test>
[] :: [[Integer]]
Test>
[] :: [[Integer]]
Test>
[[2, 3]] :: [[Integer]]

Egyik csúcs elérhetősége a másikból (2 pont)

Definiáljunk egy függvényt, amellyel egy gráf ismeretében meg tudjuk állapítani, hogy egy csúcs elérhető-e a másikból! Egy csúcsot egy másikból elérhetőnek tekintünk, ha létezik köztük legalább egy út.

areConnected :: Eq a => [(a, a)] -> a -> a -> Bool

Test>
False :: Bool
Test>
True :: Bool
Test>
True :: Bool
Test>
True :: Bool
Test>
True :: Bool
Test>
False :: Bool
Test>
False :: Bool
Test>
False :: Bool
Test>
True :: Bool

Összefüggő-e a gráf? (3 pont)

Döntsük el, hogy a gráf összefüggő-e! Egy gráfot összefüggőnek nevezünk, amennyiben minden csúcsából elérhető az összes többi.

isConnectedGraph :: Eq a => [(a, a)] -> Bool

Test>
False :: Bool
Test>
True :: Bool
Test>
True :: Bool
Test>
True :: Bool
Test>
False :: Bool
Test>
True :: Bool

Pontozás