public static List <int> DFS(List <wierzcholek> lista, int start)
{
List <int> rozwiazanie = new List <int>();
List <int> stos = new List <int>();
stos.Add(start);
rozwiazanie.Add(start);
wybierzWierzcholek(lista, start).odwiedz();
while (stos.Count > 0)
{
wierzcholek obecny = wybierzWierzcholek(lista, stos.Last());
List <int> sasiedzi = obecny.dajSasiadow();
bool znalazl = false;
foreach (int i in sasiedzi)
{
wierzcholek nowy = wybierzWierzcholek(lista, i);
if (nowy.CzyOdwiedzony() == false)
{
znalazl = true;
nowy.odwiedz();
stos.Add(nowy.dajNumer());
rozwiazanie.Add(nowy.dajNumer());
break;
}
}
if (znalazl == false)
{
stos.Remove(stos.Last());
}
}
return(rozwiazanie);
}
public int porownaj(wierzcholek a)
{
if (stopienAkt > a.dajAktualny())
{
return(-1);
}
else
{
return(1);
}
}
public static void usun(List <wierzcholek> drzewo, krawedz k)
{
int a = k.dajA();
int b = k.dajB();
wierzcholek A = wybierzWierzcholek(drzewo, a);
wierzcholek B = wybierzWierzcholek(drzewo, b);
A.usunSasiada(b);
B.usunSasiada(a);
if (A.dajSasiadow().Count == 0)
{
drzewo.Remove(A);
}
if (B.dajSasiadow().Count == 0)
{
drzewo.Remove(B);
}
}
public static void usunKrawedz(List <wierzcholek> lista, int a, int b)
{
Console.WriteLine("Usuwam krawędź " + a + "-" + b);
wierzcholek roboczy = wybierzWierzcholek(lista, a);
roboczy.usunSasiada(b);
if (roboczy.dajStopien() == 0)
{
lista.Remove(roboczy);
Console.WriteLine("Usuwam wierzcholek " + a);
}
roboczy = wybierzWierzcholek(lista, b);
roboczy.usunSasiada(a);
if (roboczy.dajStopien() == 0)
{
lista.Remove(roboczy);
Console.WriteLine("Usuwam wierzcholek " + b);
}
}
public static void dodaj(List <wierzcholek> drzewo, krawedz k)
{
int a = k.dajA();
int b = k.dajB();
wierzcholek A = wybierzWierzcholek(drzewo, a);
wierzcholek B = wybierzWierzcholek(drzewo, b);
if (A == null)
{
A = new wierzcholek(a);
drzewo.Add(A);
}
if (B == null)
{
B = new wierzcholek(b);
drzewo.Add(B);
}
A.dodajSasiada(b);
B.dodajSasiada(a);
}
public static bool czySpojny(List <wierzcholek> lista)
{
if (lista.Count == 0)
{
return(true);
}
if (lista.Count != 0 && wybierzWierzcholek(lista, 1) == null)
{
return(false);
}
List <int> kolejka = new List <int>();
List <int> zbadane = new List <int>();
kolejka.Add(1);
zbadane.Add(1);
while (kolejka.Count > 0)
{
wierzcholek obecny = wybierzWierzcholek(lista, kolejka.ElementAt(0));
List <int> sasiedzi = obecny.dajSasiadow();
foreach (int i in sasiedzi)
{
if (czyNaLiscie(zbadane, i) == false)
{
kolejka.Add(i);
zbadane.Add(i);
}
}
kolejka.Remove(kolejka.ElementAt(0));
}
if (zbadane.Count == lista.Count)
{
return(true);
}
else
{
return(false);
}
}
public static void dodajKrawedz(List <wierzcholek> lista, int a, int b)
{
Console.WriteLine("Dodaje krawędź " + a + "-" + b);
wierzcholek roboczy = wybierzWierzcholek(lista, a);
if (roboczy == null)
{
roboczy = new wierzcholek(a);
lista.Add(roboczy);
Console.WriteLine("Dodaje wierzcholek " + a);
}
roboczy.dodajSasiada(b);
roboczy = wybierzWierzcholek(lista, b);
if (roboczy == null)
{
roboczy = new wierzcholek(b);
lista.Add(roboczy);
Console.WriteLine("Dodaje wierzcholek " + b);
}
roboczy.dodajSasiada(a);
}
public static bool czyCykl(List <wierzcholek> drzewo, int i)
{
foreach (wierzcholek w in drzewo)
{
w.odznacz();
}
List <int> kolejka = new List <int>();
kolejka.Add(i);
int ileWiezcholkow = 0;
int ileKrawedzi = 0;
while (kolejka.Count != 0)
{
wierzcholek sprawdzany = wybierzWierzcholek(drzewo, kolejka.ElementAt(0));
if (sprawdzany.CzyOdwiedzony() == false)
{
ileWiezcholkow++;
ileKrawedzi += sprawdzany.dajSasiadow().Count;
foreach (int x in sprawdzany.dajSasiadow())
{
kolejka.Add(x);
}
sprawdzany.odwiedz();
}
kolejka.Remove(kolejka.ElementAt(0));
}
ileKrawedzi = ileKrawedzi / 2;
ileWiezcholkow--;
if (ileWiezcholkow == ileKrawedzi)
{
return(false);
}
else
{
return(true);
}
}
public static List <int> DFS(List <wierzcholek> lista)
{
List <int> rozwiazanie = new List <int>();
List <int> stos = new List <int>();
wierzcholek obecny = lista.ElementAt(0);
stos.Add(obecny.dajNumer());
rozwiazanie.Add(obecny.dajNumer());
while (stos.Count > 0)
{
List <int> sasiedzi = obecny.dajSasiadow();
bool znalazl = false;
foreach (int i in sasiedzi)
{
wierzcholek nowy = wybierzWierzcholek(lista, i);
if (czyWybrany(rozwiazanie, nowy.dajNumer()) == false)
{
znalazl = true;
stos.Add(nowy.dajNumer());
rozwiazanie.Add(nowy.dajNumer());
obecny = nowy;
break;
}
}
if (znalazl == false)
{
stos.Remove(stos.Last());
if (stos.Count > 0)
{
obecny = wybierzWierzcholek(lista, stos.Last());
}
}
}
return(rozwiazanie);
}
static void Main(string[] args)
{
List <List <int> > macierz = new List <List <int> >();
var s = new FileInfo(Directory.GetCurrentDirectory());
var s2 = s.Directory.Parent.Parent;
String sciezka = s2.ToString() + "\\dane.csv";
using (var reader = new StreamReader(sciezka))
{
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
var values = line.Split(',');
List <int> zad = new List <int>();
for (int x = 0; x < values.Length; x++)
{
zad.Add(Convert.ToInt32(values[x]));
}
macierz.Add(zad);
}
}
bool flaga = true;
for (int x = 1; x <= macierz.Count; x++)
{
for (int y = x + 1; y <= macierz.Count; y++)
{
int jeden = dajPole(macierz, x, y);
int dwa = dajPole(macierz, y, x);
if (jeden != dwa)
{
flaga = false;
}
}
}
if (flaga == false)
{
Console.WriteLine("Podana macierz nie jest grafem");
Console.ReadKey();
return;
}
flaga = true;
for (int x = 1; x <= macierz.Count; x++)
{
if (dajPole(macierz, x, x) != 0)
{
flaga = false;
}
}
if (flaga == false)
{
Console.WriteLine("Podany graf ma pętle");
Console.ReadKey();
return;
}
List <wierzcholek> wierzcholki = new List <wierzcholek>();
for (int numer = 1; numer <= macierz.Count; numer++)
{
wierzcholek nowy = new wierzcholek(numer);
List <int> zad = macierz.ElementAt((numer - 1));
for (int i = 1; i <= zad.Count; i++)
{
int a = i - 1;
if (zad.ElementAt(a) != 0)
{
nowy.dodajSasiada(i);
}
}
wierzcholki.Add(nowy);
}
foreach (wierzcholek w in wierzcholki)
{
w.napisz();
}
Console.WriteLine();
List <krawedz> krawedzie = new List <krawedz>();
for (int x = 1; x <= macierz.Count; x++)
{
for (int y = x + 1; y <= macierz.Count; y++)
{
if (dajPole(macierz, x, y) != 0)
{
krawedz nowa = new krawedz(x, y, dajPole(macierz, x, y));
krawedzie.Add(nowa);
}
}
}
krawedzie.Sort((a, b) => a.porownaj(b));
foreach (krawedz k in krawedzie)
{
k.napisz();
}
List <wierzcholek> drzewo = new List <wierzcholek>();
int max = wierzcholki.Count();
max--;
int ile = 0;
Console.WriteLine();
while (ile < max)
{
krawedz dodawana = krawedzie.ElementAt(0);
dodaj(drzewo, dodawana);
if (czyCykl(drzewo, dodawana.dajA()) == true)
{
usun(drzewo, dodawana);
Console.WriteLine("Nie dodano krawędzi o masie " + dodawana.dajWage());
}
else
{
ile++;
Console.WriteLine("Dodano krawędź o masie " + dodawana.dajWage());
}
krawedzie.Remove(dodawana);
}
Console.WriteLine();
Console.WriteLine("Minimalne drzewo rozpinające:");
foreach (wierzcholek w in drzewo)
{
w.napisz();
}
Console.ReadKey();
}
static void Main(string[] args)
{
List <List <int> > macierz = new List <List <int> >();
var s = new FileInfo(Directory.GetCurrentDirectory());
var s2 = s.Directory.Parent.Parent;
String sciezka = s2.ToString() + "\\dane.csv";
using (var reader = new StreamReader(sciezka))
{
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
var values = line.Split(',');
List <int> zad = new List <int>();
for (int x = 0; x < values.Length; x++)
{
zad.Add(Convert.ToInt32(values[x]));
}
macierz.Add(zad);
}
}
bool flaga = true;
for (int x = 1; x <= macierz.Count; x++)
{
if (dajPole(macierz, x, x) != 0)
{
flaga = false;
}
}
if (flaga == false)
{
Console.WriteLine("Podany graf ma pętle");
Console.ReadKey();
return;
}
List <wierzcholek> wierzcholki = new List <wierzcholek>();
for (int numer = 1; numer <= macierz.Count; numer++)
{
wierzcholek nowy = new wierzcholek(numer);
List <int> zad = macierz.ElementAt((numer - 1));
for (int i = 1; i <= zad.Count; i++)
{
int a = i - 1;
if (zad.ElementAt(a) != 0)
{
nowy.dodajSasiada(i);
}
}
wierzcholki.Add(nowy);
}
foreach (wierzcholek w in wierzcholki)
{
w.napisz();
}
List <wierzcholek> odwrocony = new List <wierzcholek>();
foreach (wierzcholek w in wierzcholki)
{
wierzcholek nowy = new wierzcholek(w.dajNumer());
odwrocony.Add(nowy);
}
foreach (wierzcholek w in wierzcholki)
{
foreach (int i in w.dajSasiadow())
{
wybierzWierzcholek(odwrocony, i).dodajSasiada(w.dajNumer());
}
}
Console.WriteLine();
foreach (wierzcholek w in odwrocony)
{
w.napisz();
}
List <int> stosKosaraju = new List <int>();
foreach (wierzcholek w in wierzcholki)
{
if (w.CzyOdwiedzony() == false)
{
DFS(wierzcholki, w.dajNumer(), stosKosaraju);
}
}
Console.WriteLine();
string wypis = "Stos: ";
foreach (int i in stosKosaraju)
{
wypis += i;
wypis += ", ";
}
Console.WriteLine(wypis);
Console.WriteLine();
int licznik = 1;
while (stosKosaraju.Count > 0)
{
foreach (wierzcholek w in odwrocony)
{
w.odznacz();
}
List <int> skladowa = DFS(odwrocony, stosKosaraju.Last());
string napis = licznik + " składowa spójności składa sie z wierzchołków: ";
foreach (int i in skladowa)
{
napis += i;
napis += ", ";
stosKosaraju.Remove(i);
odwrocony.Remove(wybierzWierzcholek(odwrocony, i));
foreach (wierzcholek w in odwrocony)
{
w.usunSasiada(i);
}
}
licznik++;
Console.WriteLine(napis);
}
Console.ReadKey();
}
static void Main(string[] args)
{
Console.WriteLine("Witam w analizatorze ciągów grafowych by wardasz");
Console.WriteLine("Podaj ciąg:");
string ciag = Console.ReadLine();
List <wierzcholek> elementy = new List <wierzcholek>();
var czesci = ciag.Split(',');
for (int x = 0; x < czesci.Length; x++)
{
int a = x + 1;
int b = Convert.ToInt32(czesci[x]);
elementy.Add(new wierzcholek(a, b));
}
while (suma(elementy) > 0)
{
elementy.Sort((a, b) => (a.porownaj(b)));
wierzcholek kasowany = elementy.ElementAt(0);
int ile = kasowany.dajAktualny();
kasowany.zeruj();
int kasowanyNumer = kasowany.dajNumer();
for (int x = 1; x <= ile; x++)
{
wierzcholek roboczy = elementy.ElementAt(x);
int roboczyNumer = roboczy.dajNumer();
roboczy.obniz();
kasowany.dodajSasiada(roboczyNumer);
roboczy.dodajSasiada(kasowanyNumer);
}
foreach (wierzcholek w in elementy)
{
if (w.dajAktualny() < 0)
{
Console.WriteLine("Podany ciąg nie jest ciągiem grafowym");
Console.ReadKey();
return;
}
}
}
//tworzenie maciezy
List <List <int> > maciez = new List <List <int> >();
for (int x = 0; x < elementy.Count; x++)
{
List <int> nowa = new List <int>();
for (int y = 0; y < elementy.Count; y++)
{
nowa.Add(0);
}
maciez.Add(nowa);
}
foreach (wierzcholek w in elementy)
{
int numer = w.dajNumer();
numer--;
List <int> sasiedzi = w.dajSasiadow();
foreach (int i in sasiedzi)
{
int n = i - 1;
maciez.ElementAt(numer)[n]++;
}
}
//wypisywanie
int rozmiar = maciez.Count;
string szczyt = " | ";
string linia = "--+";
for (int x = 1; x <= rozmiar; x++)
{
szczyt += x;
if (x < 10)
{
szczyt += " ";
}
szczyt += " ";
linia += "---";
}
Console.WriteLine(szczyt);
Console.WriteLine(linia);
int licznik = 1;
foreach (List <int> zad in maciez)
{
string kolejna = licznik.ToString();
if (licznik < 10)
{
kolejna += " ";
}
kolejna += "|";
foreach (int pole in zad)
{
kolejna += " ";
kolejna += pole.ToString();
if (pole < 10)
{
kolejna += " ";
}
}
Console.WriteLine(kolejna);
licznik++;
}
Console.ReadKey();
}
static void Main(string[] args)
{
List <List <int> > macierz = new List <List <int> >();
var s = new FileInfo(Directory.GetCurrentDirectory());
var s2 = s.Directory.Parent.Parent;
String sciezka = s2.ToString() + "\\dane.csv";
using (var reader = new StreamReader(sciezka))
{
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
var values = line.Split(',');
List <int> zad = new List <int>();
for (int x = 0; x < values.Length; x++)
{
zad.Add(Convert.ToInt32(values[x]));
}
macierz.Add(zad);
}
}
bool flaga = true;
for (int x = 1; x <= macierz.Count; x++)
{
for (int y = x + 1; y <= macierz.Count; y++)
{
int jeden = dajPole(macierz, x, y);
int dwa = dajPole(macierz, y, x);
if (jeden != dwa)
{
flaga = false;
}
}
}
if (flaga == false)
{
Console.WriteLine("Podana macierz nie jest grafem");
Console.ReadKey();
return;
}
List <wierzcholek> wierzcholki = new List <wierzcholek>();
for (int numer = 1; numer <= macierz.Count; numer++)
{
wierzcholek nowy = new wierzcholek(numer);
List <int> zad = macierz.ElementAt((numer - 1));
for (int i = 1; i <= zad.Count; i++)
{
int a = i - 1;
int licznik = zad.ElementAt(a);
while (licznik > 0)
{
nowy.dodajSasiada(i);
licznik--;
}
}
wierzcholki.Add(nowy);
}
flaga = true;
foreach (wierzcholek w in wierzcholki)
{
if (w.dajStopien() % 2 == 1)
{
flaga = false;
}
}
if (flaga == false)
{
Console.WriteLine("Graf nie jest grafem eulerowskim");
Console.ReadKey();
return;
}
if (czySpojny(wierzcholki) == false)
{
Console.WriteLine("Graf nie jest grafem spójnym");
Console.ReadKey();
return;
}
foreach (wierzcholek w in wierzcholki)
{
w.napisz();
}
Console.WriteLine();
List <int> euler = new List <int>();
euler.Add(1);
while (wierzcholki.Count > 0)
{
int a = euler.Last();
List <int> sasiedzi = new List <int>();
foreach (int i in wybierzWierzcholek(wierzcholki, a).dajSasiadow())
{
sasiedzi.Add(i);
}
foreach (int b in sasiedzi)
{
usunKrawedz(wierzcholki, a, b);
if (czySpojny(wierzcholki) == true)
{
euler.Add(b);
break;
}
else
{
dodajKrawedz(wierzcholki, a, b);
}
}
}
string wynik = "Cykl Eulera w podanym grafie: ";
foreach (int i in euler)
{
wynik += i;
wynik += ", ";
}
Console.WriteLine(wynik);
Console.ReadKey();
}
static void Main(string[] args)
{
List <List <int> > macierz = new List <List <int> >();
var s = new FileInfo(Directory.GetCurrentDirectory());
var s2 = s.Directory.Parent.Parent;
String sciezka = s2.ToString() + "\\dane.csv";
using (var reader = new StreamReader(sciezka))
{
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
var values = line.Split(',');
List <int> zad = new List <int>();
for (int x = 0; x < values.Length; x++)
{
zad.Add(Convert.ToInt32(values[x]));
}
macierz.Add(zad);
}
}
bool flaga = true;
for (int x = 1; x <= macierz.Count; x++)
{
for (int y = x + 1; y <= macierz.Count; y++)
{
int jeden = dajPole(macierz, x, y);
int dwa = dajPole(macierz, y, x);
if (jeden != dwa)
{
flaga = false;
}
}
}
if (flaga == false)
{
Console.WriteLine("Podana macierz nie jest grafem");
Console.ReadKey();
return;
}
flaga = true;
foreach (List <int> zad in macierz)
{
foreach (int i in zad)
{
if (i == 0 || i == 1)
{
}
else
{
flaga = false;
}
}
}
if (flaga == false)
{
Console.WriteLine("Podana macierz reprezentuje graf, który nie jest grafem prostym");
Console.ReadKey();
return;
}
List <wierzcholek> wierzcholki = new List <wierzcholek>();
for (int numer = 1; numer <= macierz.Count; numer++)
{
wierzcholek nowy = new wierzcholek(numer);
List <int> zad = macierz.ElementAt((numer - 1));
for (int i = 1; i <= zad.Count; i++)
{
int a = i - 1;
if (zad.ElementAt(a) == 1)
{
nowy.dodajSasiada(i);
}
}
wierzcholki.Add(nowy);
}
int minStopien = wierzcholki.ElementAt(0).dajStopien();
foreach (wierzcholek w in wierzcholki)
{
if (w.dajStopien() < minStopien)
{
minStopien = w.dajStopien();
}
}
if (minStopien < 2)
{
Console.WriteLine("Graf ma za mały minimalny stopień");
Console.ReadKey();
return;
}
List <lancuch> lancuchy = new List <lancuch>();
foreach (wierzcholek w in wierzcholki)
{
lancuch nowy = new lancuch(w.dajNumer());
lancuchy.Add(nowy);
}
flaga = true;
while (flaga == true)
{
foreach (lancuch l in lancuchy)
{
l.napisz();
}
Console.WriteLine();
flaga = false;
List <lancuch> nowe = new List <lancuch>();
foreach (lancuch l in lancuchy)
{
wierzcholek krancowy = dajWierzcholek2(wierzcholki, l.dajOstatni());
List <int> sasiednie = krancowy.dajSasiadow();
foreach (int i in sasiednie)
{
if (l.czyW(i) == false)
{
lancuch nowy = new lancuch(l, i);
nowe.Add(nowy);
flaga = true;
}
}
}
if (flaga == true)
{
lancuchy = nowe;
}
}
foreach (lancuch l in lancuchy)
{
flaga = true;
while (flaga == true)
{
if (l.dajDlugosc() > minStopien)
{
int kraniec = l.dajOstatni();
wierzcholek ostatni = dajWierzcholek2(wierzcholki, kraniec);
int pierwszy = l.dajPierwszy();
if (ostatni.czySasiaduje(pierwszy) == true)
{
Console.WriteLine("Znaleziono cykl o długości większej od minimalnego stopnia grafu. Biegnie on następującymi wierzchołkami:");
string wynik = "";
foreach (int i in l.dajWierzcholki())
{
wynik += i;
wynik += ", ";
}
Console.WriteLine(wynik);
Console.ReadKey();
return;
}
else
{
l.skroc();
}
}
else
{
flaga = false;
}
}
}
Console.ReadKey();
}
static void Main(string[] args)
{
List <List <int> > macierz = new List <List <int> >();
var s = new FileInfo(Directory.GetCurrentDirectory());
var s2 = s.Directory.Parent.Parent;
String sciezka = s2.ToString() + "\\dane.csv";
using (var reader = new StreamReader(sciezka))
{
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
var values = line.Split(',');
List <int> zad = new List <int>();
for (int x = 0; x < values.Length; x++)
{
zad.Add(Convert.ToInt32(values[x]));
}
macierz.Add(zad);
}
}
bool flaga = true;
for (int x = 1; x <= macierz.Count; x++)
{
for (int y = x + 1; y <= macierz.Count; y++)
{
int jeden = dajPole(macierz, x, y);
int dwa = dajPole(macierz, y, x);
if (jeden != dwa)
{
flaga = false;
}
}
}
if (flaga == false)
{
Console.WriteLine("Podana macierz nie jest grafem");
Console.ReadKey();
return;
}
flaga = true;
foreach (List <int> zad in macierz)
{
foreach (int i in zad)
{
if (i == 0 || i == 1)
{
}
else
{
flaga = false;
}
}
}
if (flaga == false)
{
Console.WriteLine("Podana macierz reprezentuje graf, który nie jest grafem prostym");
Console.ReadKey();
return;
}
List <wierzcholek> wierzcholki = new List <wierzcholek>();
for (int numer = 1; numer <= macierz.Count; numer++)
{
wierzcholek nowy = new wierzcholek(numer);
List <int> zad = macierz.ElementAt((numer - 1));
for (int i = 1; i <= zad.Count; i++)
{
int a = i - 1;
if (zad.ElementAt(a) == 1)
{
nowy.dodajSasiada(i);
}
}
wierzcholki.Add(nowy);
}
foreach (wierzcholek w in wierzcholki)
{
w.napisz();
}
Console.WriteLine();
foreach (wierzcholek w in wierzcholki)
{
if (w.dajKolor() == 0)
{
List <int> kolejka = new List <int>();
kolejka.Add(w.dajNumer());
w.zaznacz();
w.koloruj(1);
while (kolejka.Count != 0)
{
wierzcholek robiony = wybierzWierzcholek(wierzcholki, kolejka.ElementAt(0));
List <int> sasiedzi = robiony.dajSasiadow();
int obecny = robiony.dajKolor();
int nastepny;
if (obecny == 1)
{
nastepny = 2;
}
else
{
nastepny = 1;
}
foreach (int i in sasiedzi)
{
wierzcholek kolorowany = wybierzWierzcholek(wierzcholki, i);
if (kolorowany.koloruj(nastepny) == false)
{
Console.WriteLine("Graf nie jest dwudzielny");
Console.ReadKey();
return;
}
if (kolorowany.dajFlage() == false)
{
kolorowany.zaznacz();
kolejka.Add(i);
}
}
kolejka.Remove(kolejka.ElementAt(0));
}
}
}
Console.WriteLine("Graf jest dwudzielny");
foreach (wierzcholek w in wierzcholki)
{
w.napisz();
}
List <sciezka> siec = new List <sciezka>();
sciezka nowa;
foreach (wierzcholek w in wierzcholki)
{
w.odznacz();
if (w.dajKolor() == 1)
{
foreach (int i in w.dajSasiadow())
{
nowa = new sciezka(w.dajNumer().ToString(), i.ToString(), 1);
siec.Add(nowa);
}
nowa = new sciezka("z", w.dajNumer().ToString(), 1);
siec.Add(nowa);
}
else
{
nowa = new sciezka(w.dajNumer().ToString(), "u", 1);
siec.Add(nowa);
}
}
Console.WriteLine();
foreach (sciezka sc in siec)
{
sc.napisz();
}
Console.WriteLine();
while (true)
{
List <sciezka> rezywualna = zrobSiecRezywualna(siec);
List <string> sciezkaPowiekszajaca = BFS(rezywualna);
if (sciezkaPowiekszajaca == null)
{
break;
}
int maksimum = 1;
bool znalazl;
for (int x = 0; x < (sciezkaPowiekszajaca.Count) - 1; x++)
{
znalazl = false;
foreach (sciezka r in siec)
{
if (r.skad() == sciezkaPowiekszajaca.ElementAt(x) && r.dokad() == sciezkaPowiekszajaca.ElementAt(x + 1))
{
znalazl = true;
r.powiekszPrzeplyw(maksimum);
}
}
if (znalazl == false)
{
foreach (sciezka r in siec)
{
if (r.dokad() == sciezkaPowiekszajaca.ElementAt(x) && r.skad() == sciezkaPowiekszajaca.ElementAt(x + 1))
{
r.pomniejszPrzeplyw(maksimum);
}
}
}
}
}
int licznik = 0;
foreach (sciezka sc in siec)
{
if (sc.skad() != "z" && sc.dokad() != "u" && sc.dajPrzeplyw() == 1)
{
Console.WriteLine("Krawędz skojarzenia łącząca wierzchołki " + sc.skad() + " i " + sc.dokad());
licznik++;
}
}
Console.WriteLine("Maksymalne skojarzenie zawiera " + licznik + " krawędzi.");
Console.ReadKey();
}
static void Main(string[] args)
{
List <List <int> > macierz = new List <List <int> >();
var s = new FileInfo(Directory.GetCurrentDirectory());
var s2 = s.Directory.Parent.Parent;
String sciezka = s2.ToString() + "\\dane.csv";
using (var reader = new StreamReader(sciezka))
{
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
var values = line.Split(',');
List <int> zad = new List <int>();
for (int x = 0; x < values.Length; x++)
{
zad.Add(Convert.ToInt32(values[x]));
}
macierz.Add(zad);
}
}
bool flaga = true;
for (int x = 1; x <= macierz.Count; x++)
{
for (int y = x + 1; y <= macierz.Count; y++)
{
int jeden = dajPole(macierz, x, y);
int dwa = dajPole(macierz, y, x);
if (jeden != dwa)
{
flaga = false;
}
}
}
if (flaga == false)
{
Console.WriteLine("Podana macierz nie jest grafem");
Console.ReadKey();
return;
}
flaga = true;
foreach (List <int> zad in macierz)
{
foreach (int i in zad)
{
if (i == 0 || i == 1)
{
}
else
{
flaga = false;
}
}
}
if (flaga == false)
{
Console.WriteLine("Podana macierz reprezentuje graf, który nie jest grafem prostym");
Console.ReadKey();
return;
}
List <wierzcholek> wierzcholki = new List <wierzcholek>();
for (int numer = 1; numer <= macierz.Count; numer++)
{
wierzcholek nowy = new wierzcholek(numer);
List <int> zad = macierz.ElementAt((numer - 1));
for (int i = 1; i <= zad.Count; i++)
{
int a = i - 1;
if (zad.ElementAt(a) == 1)
{
nowy.dodajSasiada(i);
}
}
wierzcholki.Add(nowy);
}
int suma = 0;
foreach (wierzcholek w in wierzcholki)
{
suma += w.dajStopien();
}
int krawendzie = suma / 2;
int wenzly = wierzcholki.Count;
if (wenzly != (krawendzie + 1))
{
Console.WriteLine("Podana macierz reprezentuje graf, który nie jest acykliczny");
Console.ReadKey();
return;
}
while (wierzcholki.Count > 2)
{
foreach (wierzcholek w in wierzcholki)
{
w.napisz();
}
Console.WriteLine();
List <wierzcholek> usuwane = new List <wierzcholek>();
foreach (wierzcholek w in wierzcholki)
{
if (w.dajStopien() == 1)
{
usuwane.Add(w);
}
}
foreach (wierzcholek u in usuwane)
{
wierzcholki.Remove(u);
}
foreach (wierzcholek u in usuwane)
{
foreach (wierzcholek w in wierzcholki)
{
if (u.dajNumer() == w.dajNumer())
{
wierzcholki.Remove(w);
}
else
{
w.usunSasiada(u.dajNumer());
}
}
}
}
if (wierzcholki.Count == 1)
{
Console.WriteLine("Centrum drzewa jest wierzchołek " + wierzcholki.ElementAt(0).dajNumer());
}
else
{
Console.WriteLine("Centrum drzewa są wierzchołki " + wierzcholki.ElementAt(0).dajNumer() + " i " + wierzcholki.ElementAt(1).dajNumer());
}
Console.ReadKey();
}
static void Main(string[] args)
{
List <List <int> > macierz = new List <List <int> >();
var s = new FileInfo(Directory.GetCurrentDirectory());
var s2 = s.Directory.Parent.Parent;
String sciezka = s2.ToString() + "\\dane.csv";
using (var reader = new StreamReader(sciezka))
{
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
var values = line.Split(',');
List <int> zad = new List <int>();
for (int x = 0; x < values.Length; x++)
{
zad.Add(Convert.ToInt32(values[x]));
}
macierz.Add(zad);
}
}
bool flaga = true;
for (int x = 1; x <= macierz.Count; x++)
{
for (int y = x + 1; y <= macierz.Count; y++)
{
int jeden = dajPole(macierz, x, y);
int dwa = dajPole(macierz, y, x);
if (jeden != dwa)
{
flaga = false;
}
}
}
if (flaga == false)
{
Console.WriteLine("Podana macierz nie jest grafem");
Console.ReadKey();
return;
}
List <wierzcholek> wierzcholki = new List <wierzcholek>();
for (int numer = 1; numer <= macierz.Count; numer++)
{
wierzcholek nowy = new wierzcholek(numer);
List <int> zad = macierz.ElementAt((numer - 1));
for (int i = 1; i <= zad.Count; i++)
{
int a = i - 1;
if (zad.ElementAt(a) == 1)
{
nowy.dodajSasiada(i);
}
}
wierzcholki.Add(nowy);
}
foreach (wierzcholek w in wierzcholki)
{
w.napisz();
}
Console.WriteLine();
List <int> pierwsza = DFS(wierzcholki);
if (pierwsza.Count == wierzcholki.Count)
{
Console.WriteLine("Graf jest spójny");
}
else
{
List <List <int> > skladowe = new List <List <int> >();
skladowe.Add(pierwsza);
foreach (int i in pierwsza)
{
wierzcholek kasowany = wybierzWierzcholek(wierzcholki, i);
wierzcholki.Remove(kasowany);
}
while (wierzcholki.Count > 0)
{
List <int> kolejna = DFS(wierzcholki);
skladowe.Add(kolejna);
foreach (int i in kolejna)
{
wierzcholek kasowany = wybierzWierzcholek(wierzcholki, i);
wierzcholki.Remove(kasowany);
}
}
Console.WriteLine("Graf nie jest spójny");
int licznik = 1;
foreach (List <int> skladowa in skladowe)
{
string wynik = licznik + " składowa spójności: ";
foreach (int i in skladowa)
{
wynik += i;
wynik += ", ";
}
Console.WriteLine(wynik);
licznik++;
}
}
Console.ReadKey();
}
static void Main(string[] args)
{
List <List <int> > macierz = new List <List <int> >();
var s = new FileInfo(Directory.GetCurrentDirectory());
var s2 = s.Directory.Parent.Parent;
String sciezka = s2.ToString() + "\\dane.csv";
using (var reader = new StreamReader(sciezka))
{
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
var values = line.Split(',');
List <int> zad = new List <int>();
for (int x = 0; x < values.Length; x++)
{
zad.Add(Convert.ToInt32(values[x]));
}
macierz.Add(zad);
}
}
bool flaga = true;
for (int x = 1; x <= macierz.Count; x++)
{
for (int y = x + 1; y <= macierz.Count; y++)
{
int jeden = dajPole(macierz, x, y);
int dwa = dajPole(macierz, y, x);
if (jeden != dwa)
{
flaga = false;
}
}
}
if (flaga == false)
{
Console.WriteLine("Podana macierz nie jest grafem");
Console.ReadKey();
return;
}
List <wierzcholek> wierzcholki = new List <wierzcholek>();
for (int numer = 1; numer <= macierz.Count; numer++)
{
wierzcholek nowy = new wierzcholek(numer);
List <int> zad = macierz.ElementAt((numer - 1));
for (int i = 1; i <= zad.Count; i++)
{
int a = i - 1;
if (zad.ElementAt(a) == 1)
{
nowy.dodajSasiada(i);
}
}
wierzcholki.Add(nowy);
}
foreach (wierzcholek w in wierzcholki)
{
w.napisz();
}
List <int> stos = new List <int>();
wierzcholek obecny = wybierzWierzcholek(wierzcholki, 1);
obecny.naDrzewo();
List <sciezka> sciezki = new List <sciezka>();
stos.Add(1);
while (stos.Count > 0)
{
List <int> sasiedzi = obecny.dajSasiadow();
bool znalazl = false;
foreach (int i in sasiedzi)
{
wierzcholek nowy = wybierzWierzcholek(wierzcholki, i);
if (nowy.czyNaDrzewie() == false)
{
znalazl = true;
nowy.naDrzewo();
stos.Add(nowy.dajNumer());
sciezki.Add(new sciezka(obecny.dajNumer(), nowy.dajNumer()));
obecny = nowy;
break;
}
}
if (znalazl == false)
{
stos.Remove(stos.Last());
if (stos.Count > 0)
{
obecny = wybierzWierzcholek(wierzcholki, stos.Last());
}
}
}
Console.WriteLine();
flaga = true;
foreach (wierzcholek w in wierzcholki)
{
if (w.czyNaDrzewie() == false)
{
flaga = false;
}
}
if (flaga == false)
{
Console.WriteLine("Podany graf nie jest spójny");
}
else
{
Console.WriteLine("Podany graf zawiera następujące drzewo spójności");
string wynik = "";
foreach (sciezka x in sciezki)
{
wynik += x.opis();
wynik += ", ";
}
wynik.Remove(wynik.Last());
wynik.Remove(wynik.Last());
Console.WriteLine(wynik);
}
Console.ReadKey();
}