/// <summary>
/// Metoda znajdująca cyrkulację w grafie, z określonymi żądaniami wierzchołków.
/// Żądania opisane są w tablicy demands. Szukamy funkcji, która dla każdego wierzchołka będzie spełniała warunek:
/// suma wartości na krawędziach wchodzących - suma wartości na krawędziach wychodzących = demands[v]
/// </summary>
/// <param name="G">Graf wejściowy, wagi krawędzi oznaczają przepustowości</param>
/// <param name="demands">Żądania wierzchołków</param>
/// <returns>Graf reprezentujący wynikową cyrkulację.
/// Reprezentacja cyrkulacji jest analogiczna, jak reprezentacja przepływu w innych funkcjach w bibliotece.
/// Należy zwrócić kopię grafu G, gdzie wagi krawędzi odpowiadają przepływom na tych krawędziach.
/// Zwróć uwagę na rozróżnienie sytuacji, kiedy mamy zerowy przeływ na krawędzi (czyli istnieje
/// krawędź z wagą 0) od sytuacji braku krawędzi.
/// Jeśli żądana cyrkulacja nie istnieje, zwróć null.
/// </returns>
/// <remarks>
/// Nie można modyfikować danych wejściowych!
/// Złożoność metody powinna być asymptotycznie równa złożoności metody znajdującej największy przeływ (z biblioteki).
/// </remarks>
public Graph FindCirculation(Graph G, double[] demands)
{
int n = G.VerticesCount;
double p = 0;
foreach (double d in demands)
{
p += d;
}
if (p != 0)
{
return(null);
}
Graph g = G.IsolatedVerticesGraph(G.Directed, n + 2); // graf ze zrodlem i ujsciem
Graph gg = G.IsolatedVerticesGraph(); // graf na wynik
// n - zrodlo, n+1 ujscie
double[] tab = new double[n];
for (int i = 0; i < G.VerticesCount; ++i)
{
if (demands[i] < 0)
{
g.AddEdge(n, i, -demands[i]);
}
else
{
g.AddEdge(i, n + 1, demands[i]);//if (G.OutDegree(i) == 0) g.AddEdge(i, n + 1, demands[i]); // krawedz do zrodla, jaka wartosc? moze -
}
foreach (Edge e in G.OutEdges(i))
{
g.AddEdge(e);
}
}
(double value, Graph tmp) = MaxFlowGraphExtender.PushRelabelMaxFlow(g, n, n + 1, null, false);
double[] tmpVal = new double[G.VerticesCount];
for (int i = 0; i < n; ++i)
{
foreach (Edge e in tmp.OutEdges(i))
{
if (e.From < n && e.To < n)
{
tmpVal[e.To] += e.Weight;
tmpVal[e.From] -= e.Weight;
gg.Add(e);
}
}
}
for (int i = 0; i < n; ++i)
{
if (demands[i] != tmpVal[i])
{
return(null);
}
}
return(gg);
}
/// <summary>
/// Znajduje najliczniejszy multizbiór tras
/// </summary>
/// <returns>Znaleziony multizbiór</returns>
/// <param name="g">Graf opisujący muzeum</param>
/// <param name="cLevel">Tablica o długości równej liczbie wierzchołków w grafie -- poziomy ciekawości wystaw</param>
/// <param name="entrances">Wejścia</param>
/// <param name="exits">Wyjścia</param>
public static MuseumRoutes FindRoutes(Graph g, int[] cLevel, int[] entrances, int[] exits)
{
Graph seekFlowGraph = BuildSeekFlowGraph(g, cLevel, entrances, exits);
//var ge = new GraphExport();
//ge.Export(g);
//ge.Export(seekFlowGraph);
var maxFlow = MaxFlowGraphExtender.FordFulkersonDinicMaxFlow(seekFlowGraph, 0, 1, MaxFlowGraphExtender.OriginalDinicBlockingFlow);
return(new MuseumRoutes((int)maxFlow.value, null));
}
/// <summary>
/// Znajduje przepływ w sieci N z ograniczonymi przepustowościami wierzchołków (c(v)).
/// Do ograniczeń wynikających ze klasycznego problemu maksymalnego przepływu
/// w sieci dokładamy dodatkowe:
/// dla każdego wierzchołka v, niebędącego źródłem lub ujściem przepływ przez
/// dany wierzchołek nie może przekraczać jego przepustowości.
/// Przepływ taki możemy znaleźć konstruując pomocniczą sieć N':
/// V(N') = { v_in, v_out dla każdego v należącego do V(N) \ {s,t} } u {s,t}
/// Dla każdego v należącego do V(N) \ {s,t} wierzchołki v_in i v_out łączymy krawędzią
/// o przepustowości c(v). Każda krawędź (u,v) w E(N) jest reprezentowana przez krawędź
/// (u_out, v_in) w N'. (przyjmujemy, że w N' s=s_in=s_out i t=t_in=t_out) - przepustowości pozostają bez zmian.
/// Maksymalny przepływ w sieci N' odpowiada maksymalnemu przepływowi z ograniczeniami w sieci N.
///
/// </summary>
/// <param name="network">sieć wejściowa</param>
/// <param name="s">źródło sieci</param>
/// <param name="t">ujście sieci</param>
/// <param name="capacity">przepustowości wierzchołków, przepustowości źródła i ujścia to int.MaxValue</param>
/// <param name="flowGraph">Znaleziony graf przepływu w sieci wejściowej</param>
/// <returns>Wartość maksymalnego przepływu</returns>
/// <remarks>
/// Wskazówka: Można przyjąć, że przepustowości źródła i ujścia są nieskończone
/// i traktować je jak wszystkie inne wierzchołki.
/// </remarks>
public static int ConstrainedMaxFlow(this Graph network, int s, int t, int[] capacity, out Graph flowGraph)
{
//
// TODO (1 pkt.)
//
Graph net = new AdjacencyMatrixGraph(true, network.VerticesCount * 2);
for (int v = 0; v < network.VerticesCount; ++v)
{
if (v != s && v != t)
{
net.AddEdge(v + network.VerticesCount, v, capacity[v]);
}
foreach (Edge e in network.OutEdges(v))
{
if (e.To != t)
{
net.AddEdge(v, e.To + network.VerticesCount, e.Weight);
}
else
{
net.AddEdge(e);
}
}
}
int flow = (int)MaxFlowGraphExtender.PushRelabelMaxFlow(net, s, t, out flowGraph);
Graph fll = new AdjacencyMatrixGraph(true, network.VerticesCount);
for (int v = 0; v < fll.VerticesCount; ++v)
{
foreach (Edge e in flowGraph.OutEdges(v))
{
if (e.To != t)
{
fll.AddEdge(v, e.To - network.VerticesCount, e.Weight);
}
else
{
fll.AddEdge(e);
}
}
}
flowGraph = fll;
return(flow);
}
/// <summary>
/// Metoda znajdująca cyrkulację w grafie, z określonymi żądaniami wierzchołków.
/// Żądania opisane są w tablicy demands. Szukamy funkcji, która dla każdego wierzchołka będzie spełniała warunek:
/// suma wartości na krawędziach wchodzących - suma wartości na krawędziach wychodzących = demands[v]
/// </summary>
/// <param name="G">Graf wejściowy, wagi krawędzi oznaczają przepustowości</param>
/// <param name="demands">Żądania wierzchołków</param>
/// <returns>Graf reprezentujący wynikową cyrkulację.
/// Reprezentacja cyrkulacji jest analogiczna, jak reprezentacja przepływu w innych funkcjach w bibliotece.
/// Należy zwrócić kopię grafu G, gdzie wagi krawędzi odpowiadają przepływom na tych krawędziach.
/// Zwróć uwagę na rozróżnienie sytuacji, kiedy mamy zerowy przeływ na krawędzi (czyli istnieje
/// krawędź z wagą 0) od sytuacji braku krawędzi.
/// Jeśli żądana cyrkulacja nie istnieje, zwróć null.
/// </returns>
/// <remarks>
/// Nie można modyfikować danych wejściowych!
/// Złożoność metody powinna być asymptotycznie równa złożoności metody znajdującej największy przeływ (z biblioteki).
/// </remarks>
public Graph FindCirculation(Graph G, double[] demands)
{
Graph Network = new AdjacencyMatrixGraph(true, G.VerticesCount + 2);
int n = G.VerticesCount;
//g.VerticesCount - zrodlo, g.VerticesCount + 1 - ujscie
//zrodlo z ujemnymi, dodatnie z ujsciem
double flows = 0;
for (int i = 0; i < demands.Length; i++)
{
flows += demands[i];
}
if (flows != 0)
{
return(null);
}
for (int i = 0; i < demands.Length; i++)
{
if (demands[i] < 0)
{
Network.AddEdge(new Edge(n, i, Math.Abs(demands[i])));
}
else
{
Network.AddEdge(new Edge(i, n + 1, demands[i]));
}
foreach (Edge e in G.OutEdges(i))
{
Network.Add(e);
}
}
(double max_flow, Graph Flow) = MaxFlowGraphExtender.FordFulkersonDinicMaxFlow(Network, n, n + 1, MaxFlowGraphExtender.DFSBlockingFlow);
Graph Circulation = new AdjacencyMatrixGraph(true, n);
double[] degrees = new double[n];
for (int i = 0; i < n; i++)
{
foreach (Edge e in Flow.OutEdges(i))
{
if (e.To != n + 1)
{
Circulation.Add(e);
degrees[i] -= e.Weight;
degrees[e.To] += e.Weight;
}
}
}
for (int i = 0; i < n; i++)
{
if (degrees[i] != demands[i])
{
return(null);
}
}
return(Circulation);
}
