private void GetDrum(Retea retea, Nod nodStoc, Nod nodSursa)
{
nodStoc.Distanta = 0;
Stack <Nod> stack = new Stack <Nod>();
List <Drum> drumuri = new List <Drum>();
List <Nod> noduriDrum = new List <Nod>();
stack.Push(nodStoc);
while (stack.Count() != 0)
{
Nod nodCurent = stack.Pop();
noduriDrum.Add(nodCurent);
if (nodCurent.Id == nodSursa.Id)
{
noduriDrum.Reverse();
drumuri.Add(new Drum(retea, noduriDrum));
noduriDrum = new List <Nod>();
}
List <Arc> arce = retea.Arce.Where(arc => arc.Y.Id == nodCurent.Id && arc.X.Id == nodCurent.Predecesor.Id).ToList();
arce.ForEach(a => {
stack.Push(a.X);
});
}
}
public double GetValoareMaxima(Retea retea)
{
Console.WriteLine("Retea initiala: \n");
Console.WriteLine(retea.ToString());
Retea reteaUpdatata = UpdateRetea(retea);
return(reteaUpdatata.GetValoareMaxima());
}
private void InaintareReetichetare(Retea retea, Nod x)
{
List <Arc> arceDinX = retea.Arce.Where(a => a.X.Id == x.Id).OrderBy(a => a.Y.Id).ToList();
Queue <Arc> coadaArce = new Queue <Arc>(arceDinX);
Arc arc = coadaArce.Dequeue();
bool esteReetichetat = false;
do
{
if (arc.EsteAdmisibil(retea))
{
arc.Flux += Math.Min(x.GetExces(retea), arc.GetCapacitateReziduala(retea));
Arc arcInvers = retea.Arce.FirstOrDefault(a => a.X.Id == arc.Y.Id && a.Y.Id == arc.X.Id);
if (arcInvers == null)
{
arcInvers = new Arc(arc.Y, arc.X, 0, 0);
retea.Arce.Add(arcInvers);
}
if (!_L.Contains(arc.Y) && !arc.Y.EsteNodSursa && !arc.Y.EsteNodStoc)
{
_L.Enqueue(arc.Y);
}
}
if (x.GetExces(retea) > 0)
{
if (coadaArce.Count() > 0)
{
arc = coadaArce.Dequeue();
}
else
{
x.Distanta = arceDinX.Where(a => a.GetCapacitateReziduala(retea) > 0).Min(a => a.Y.Distanta + 1);
esteReetichetat = true;
}
}
Console.WriteLine(retea.ToString());
Console.Write("Distante:");
retea.Noduri.Select(n => n.Distanta).ToList().ForEach(d => Console.Write($"{d}, "));
Console.WriteLine("\n");
} while (x.GetExces(retea) != 0 && !esteReetichetat);
if (x.GetExces(retea) > 0)
{
_L.Enqueue(x);
}
}
public Retea UpdateRetea(Retea retea)
{
Initializare(retea);
while (_L.Count() != 0)
{
Nod nod = _L.Dequeue();
InaintareReetichetare(retea, nod);
}
return(retea);
}
//private void Marire(Retea retea)
//{
// Console.WriteLine("\n\n");
// Console.WriteLine(retea.ToString());
// Drum drum = CreeazaDrum(retea);
// Console.WriteLine(drum.AsString(retea));
// drum.Arce.ForEach(arc => arc.Flux += drum.GetCapacitateRezidualaMin(retea));
// //todo: check if arcs are updated by reference
//}
private void Marire(Retea retea)
{
//Console.WriteLine("\n\n");
//Console.WriteLine(retea.ToString());
Drum drum = CreeazaDrum(retea);
//Console.WriteLine(drum.AsString(retea));
double r = drum.GetCapacitateRezidualaMin(retea);
Console.WriteLine($"{drum.AsString(retea)} | r(D)={r}");
if (r > 0)
{
drum.Arce.ForEach(arc => {
arc.Flux += r;
Arc arcRetea = retea.Arce.FirstOrDefault(a => a.X.Id == arc.X.Id && a.Y.Id == arc.Y.Id);
arcRetea.Flux += r;
Arc arcInvers = retea.Arce.FirstOrDefault(a => a.X.Id == arc.Y.Id && a.Y.Id == arc.X.Id);
if (arcInvers == null)
{
arcInvers = new Arc(arc.Y, arc.X, 0, 0);
retea.Arce.Add(arcInvers);
}
else
{
if (arcInvers.GetCapacitateReziduala(retea) <= 0)
{
retea.Arce.Remove(arcInvers);
}
}
if (arcRetea.GetCapacitateReziduala(retea) <= 0)
{
retea.Arce.Remove(arcRetea);
}
});
Console.WriteLine("\n\n");
Console.WriteLine(retea.ToString());
Console.WriteLine($"Max value: {retea.GetValoareMaxima()}");
}
//todo: check if arcs are updated by reference
}
public Retea UpdateRetea(Retea retea)
{
// Initializarea listei de noduri etichetate si neanalizate din retea (V)
Queue <Nod> V = new Queue <Nod>();
Nod nodSursa = retea.Noduri.FirstOrDefault(nod => nod.EsteNodSursa);
Nod nodStoc = retea.Noduri.FirstOrDefault(nod => nod.EsteNodStoc);
do
{
V = new Queue <Nod>();
// Setarea predecesorilor nodurilor din retea cu 0/null
retea.Noduri.ForEach(n => { n.Predecesor = null; });
// Adaugarea nodului sursa in lista V, lista de noduri etichetate si neanalizate
V.Enqueue(nodSursa);
nodSursa.Predecesor = nodStoc;
while (V?.Count() > 0 && nodStoc.Predecesor == null)
{
// Se extrage un nod x din NoduriEtichetateNeanalizate (V)
Nod x = V.Dequeue();
// FOR (x,y) din A(f) do
List <Arc> arceDinX = retea.Arce.Where(arc => arc.X.Id == x.Id).ToList();
arceDinX.Where(arc => arc.GetCapacitateReziduala(retea) > 0)
.OrderBy(arc => arc.Y.Id).ToList()
.ForEach(arc => {
// IF p[y]!=0 THEN
if (arc.Y.Predecesor == null)
{
arc.Y.Predecesor = arc.X; // p[y] = x
V.Enqueue(arc.Y); // V = V U {y}
}
});
}
if (nodStoc.Predecesor != null)
{
Marire(retea);
}
} while (nodStoc.Predecesor != null);
return(retea);
}
private bool TryGetArcAdmisibil(Retea retea, Nod nod, out Arc arcAdmisibil)
{
List <Arc> arce = retea.Arce.Where(arc => arc.X.Id == nod.Id && arc.EsteAdmisibil(retea)).ToList();
if (arce?.Count() == 0)
{
arcAdmisibil = null;
return(false);
}
Random random = new Random();
int index = random.Next(0, arce.Count - 1);
arcAdmisibil = arce[index];
return(true);
}
public Retea UpdateRetea(Retea retea)
{
Nod nodSursa = retea.Noduri.FirstOrDefault(nod => nod.EsteNodSursa);
Nod nodStoc = retea.Noduri.FirstOrDefault(nod => nod.EsteNodStoc);
retea.Arce.ForEach(arc => arc.Flux = 0);
Nod x = nodSursa;
SetDistances(retea, nodStoc);
while (nodSursa.Distanta < retea.Noduri.Count)
{
if (TryGetArcAdmisibil(retea, x, out Arc arcAdmisibil))
{
arcAdmisibil.Y.Predecesor = x;
x = arcAdmisibil.Y;
if (x.Id == nodStoc.Id)
{
Marire(retea);
x = nodSursa;
}
}
else
{
List <Arc> arceDinX = retea.Arce.Where(arc => arc.X.Id == x.Id).ToList();
if (arceDinX?.Count() == 0)
{
x.Distanta++;
}
else
{
x.Distanta = arceDinX.Min(a => a.Y.Distanta + 1);
}
if (x.Id != nodSursa.Id)
{
x = x.Predecesor;
}
}
}
return(retea);
}
private void SetDistances(Retea retea, Nod nodStoc)
{
nodStoc.Distanta = 0;
Queue <Nod> noduriVizitate = new Queue <Nod>();
noduriVizitate.Enqueue(nodStoc);
while (noduriVizitate.Count() != 0)
{
Nod nodCurent = noduriVizitate.Dequeue();
List <Arc> arce = retea.Arce.Where(arc => arc.Y.Id == nodCurent.Id).ToList();
arce.ForEach(a => {
a.X.Distanta = a.Y.Distanta + 1;
noduriVizitate.Enqueue(a.X);
});
}
}
private Drum CreeazaDrum(Retea retea)
{
List <Nod> noduri = new List <Nod>();
Nod nodStoc = retea.Noduri.FirstOrDefault(nod => nod.EsteNodStoc);
Nod nodCurent = nodStoc;
while (nodCurent.Predecesor != null && nodCurent.Predecesor.Id != nodStoc.Id)
{
noduri.Add(nodCurent);
nodCurent = nodCurent.Predecesor;
}
noduri.Add(nodCurent);
noduri.Reverse();
Drum drum = new Drum(retea, noduri);
return(drum);
}
private void Marire(Retea retea)
{
Console.WriteLine("\n\n");
Console.WriteLine($"MARIRE FLUX NR.{_nrIteratie}: ");
_nrIteratie++;
// Predecesori
List <Nod> predecesori = new List <Nod>();
retea.Noduri.ForEach(n => predecesori.Add(n.Predecesor));
Console.Write("Predecesori: ");
predecesori.ForEach(p => Console.Write($"{((p != null) ? p.ToString() : "-")}, "));
// Creare drum
Drum drum = CreeazaDrum(retea);
double rDrum = drum.GetCapacitateRezidualaMin(retea);
Console.WriteLine($"{drum.AsString(retea)} | r(D)={rDrum}");
Console.WriteLine();
if (rDrum > 0)
{
drum.Arce.ForEach(arc => {
arc.Flux += rDrum;
Arc arcInvers = retea.Arce.FirstOrDefault(a => a.X.Id == arc.Y.Id && a.Y.Id == arc.X.Id);
if (arcInvers == null)
{
arcInvers = new Arc(arc.Y, arc.X, 0, 0);
retea.Arce.Add(arcInvers);
}
});
Console.WriteLine(retea.ToString());
Console.WriteLine($"Max value: {retea.GetValoareMaxima()}");
}
}
private void Initializare(Retea retea)
{
_nodSursa = retea.Noduri.FirstOrDefault(nod => nod.EsteNodSursa);
_nodStoc = retea.Noduri.FirstOrDefault(nod => nod.EsteNodStoc);
retea.Arce.ForEach(arc => arc.Flux = 0);
_L = new Queue <Nod>();
SetDistances(retea, _nodStoc);
retea.Arce.Where(a => a.X.Id == _nodSursa.Id).ToList()
.ForEach(arc => {
arc.Flux += arc.GetCapacitateReziduala(retea);
Arc arcInvers = retea.Arce.FirstOrDefault(a => a.X.Id == arc.Y.Id && a.Y.Id == arc.X.Id);
if (arcInvers == null)
{
arcInvers = new Arc(arc.Y, arc.X, 0, 0);
retea.Arce.Add(arcInvers);
}
if (arc.Y.GetExces(retea) > 0 && arc.Y.Id != _nodStoc.Id)
{
_L.Enqueue(arc.Y);
}
});
_nodSursa.Distanta = retea.Noduri.Count();
Console.WriteLine("\nRetea initializata in Preflux FIFO");
Console.WriteLine(retea.ToString());
Console.Write("Distante: ");
retea.Noduri.Select(n => n.Distanta).ToList().ForEach(d => Console.Write($"{d}, "));
Console.WriteLine("\n");
}
public double GetMaxValue(Retea retea)
{
Retea reteaUpdatata = UpdateRetea(retea);
return(reteaUpdatata.GetValoareMaxima());
}
public static void Main(string[] args)
{
Data data = DataProvider.Instance.ReadData("DateProblema.txt");
Retea retea = new Retea();
int nrNoduri = data.NrAsociatii + data.NrLocuitori + data.NrPartidePolitice + 2;
Nod nodSursa = new Nod {
Id = 1,
EsteNodSursa = true,
EsteNodStoc = false,
};
Nod nodStoc = new Nod {
Id = nrNoduri,
EsteNodSursa = false,
EsteNodStoc = true,
};
retea.Noduri.Add(nodSursa);
int idNodCurent = nodSursa.Id;
data.Asociatii.ForEach(asociatie => {
Nod nodAsociatie = retea.Noduri.FirstOrDefault(n => n.IdAsociatie == asociatie.Id);
if (nodAsociatie == null)
{
idNodCurent++;
nodAsociatie = new Nod {
Id = idNodCurent, IdAsociatie = asociatie.Id
};
retea.Noduri.Add(nodAsociatie);
}
Arc arc = new Arc(nodSursa, nodAsociatie, flux: 0, capacitate: 1);
retea.Arce.Add(arc);
});
data.Locuitori.ForEach(locuitor => {
Nod nodLocuitor = retea.Noduri.FirstOrDefault(n => n.IdLocuitor == locuitor.Id);
if (nodLocuitor == null)
{
idNodCurent++;
nodLocuitor = new Nod {
Id = idNodCurent, IdLocuitor = locuitor.Id
};
retea.Noduri.Add(nodLocuitor);
}
List <Asociatie> asociatii = data.Asociatii.Where(asociatie => asociatie.Membrii.Contains(locuitor)).ToList();
asociatii.ForEach(asociatie => {
Nod nodAsociatie = retea.Noduri.FirstOrDefault(n => n.IdAsociatie == asociatie.Id);
if (nodAsociatie == null)
{
throw new InvalidOperationException($"Nu a fost creat nod pentru asociatia cu id-ul {asociatie.Id}.");
}
Arc arc = new Arc(nodAsociatie, nodLocuitor, 0, 1);
retea.Arce.Add(arc);
});
});
List <Arc> arcePartide = new List <Arc>();
data.PartidePolitice.ForEach(partid => {
Nod nodPartid = retea.Noduri.FirstOrDefault(n => n.IdPartid == partid.Id);
if (nodPartid == null)
{
idNodCurent++;
nodPartid = new Nod {
Id = idNodCurent, IdPartid = partid.Id
};
retea.Noduri.Add(nodPartid);
}
partid.Membrii.ForEach(locuitor => {
Nod nodLocuitor = retea.Noduri.FirstOrDefault(n => n.IdLocuitor == locuitor.Id);
if (nodLocuitor == null)
{
throw new InvalidOperationException($"Nu a fost creat nod pentru locuitorul cu id-ul {locuitor.Id}.");
}
retea.Arce.Add(new Arc(nodLocuitor, nodPartid, 0, 1));
});
Arc arc = new Arc(nodPartid, nodStoc, flux: 0, capacitate: partid.NrReprezentantiInConsiliu);
arcePartide.Add(arc);
});
retea.Arce.AddRange(arcePartide);
data.Locuitori.ForEach(locuitor => {
IEnumerable <PartidPolitic> partide = data.PartidePolitice.Where(p => p.Membrii.Contains(locuitor));
if (partide?.Count() == 0)
{
Nod nodLocuitor = retea.Noduri.FirstOrDefault(n => n.IdLocuitor == locuitor.Id);
if (nodLocuitor == null)
{
throw new InvalidOperationException($"Nu a fost creat nod pentru locuitorul cu id-ul {locuitor.Id}.");
}
retea.Arce.Add(new Arc(nodLocuitor, nodStoc, 0, 1));
}
});
retea.Noduri.Add(nodStoc);
EdmondsKarp edmondsKarp = new EdmondsKarp();
AhujaOrlin ahujaOrlin = new AhujaOrlin();
PrefluxFIFO prefluxFIFO = new PrefluxFIFO();
double maxValue = -1;
string option = string.Empty;
while (true)
{
Console.WriteLine("Selectati algoritmul: ");
Console.WriteLine("1. Edmonds Karp");
Console.WriteLine("2. Preflux FIFO");
Console.WriteLine("3. Iesire program");
string input = Console.ReadLine();
switch (input.Trim())
{
case "1":
maxValue = edmondsKarp.GetValoareMaxima(new Retea(retea));
break;
case "2":
maxValue = prefluxFIFO.GetValoareMaxima(new Retea(retea));
break;
case "3":
default:
return;
}
Console.WriteLine($"Valoarea maxima: {maxValue}");
Console.WriteLine($"Consiliul orasului {((maxValue == data.NrAsociatii) ? "" : "NU ")}este echilibrat!");
Console.ReadKey();
}
}
