public void TestHasCycleReturnFalseForCorrectGraph()
{
var graph = new WeightedGraph();
graph.AddNode("a");
graph.AddNode("b");
graph.AddNode("c");
graph.AddNode("p");
graph.AddEdge("a", "b", 0);
graph.AddEdge("b", "c", 0);
var hasCycle = graph.HasCycle();
Assert.That(false, Is.EqualTo(hasCycle));
}
public void TestHasCycleReturnTrueIfThereIsCycle()
{
var graph = new WeightedGraph();
graph.AddNode("a");
graph.AddNode("b");
graph.AddNode("c");
graph.AddNode("p");
graph.AddEdge("a", "b", 0);
graph.AddEdge("b", "c", 0);
graph.AddEdge("c", "a", 0);
var hasCycle = graph.HasCycle();
Assert.That(true, Is.EqualTo(hasCycle));
}
public void TestGetShortedPath()
{
var graph = new WeightedGraph();
graph.AddNode("a");
graph.AddNode("b");
graph.AddNode("c");
graph.AddNode("p");
graph.AddEdge("a", "b", 1);
graph.AddEdge("b", "c", 2);
graph.AddEdge("a", "c", 10);
var path = graph.GetShortedPath("a", "c");
StringAssert.AreEqualIgnoringCase("a,b,c", path.ToString());
}
public Day09() : base(9, 2015, "All in a Single Night")
{
// We only need to build the graph once
foreach (string line in Input)
{
string[] data = line.Split(' ');
graph.AddEdge(data[0], data[2], Int32.Parse(data[^ 1]));
public override IEnumerable <object> Solve(TextReader inputStream)
{
var n = inputStream.ReadInt();
graph = new WeightedGraph(n);
for (int i = 0; i < n - 1; i++)
{
var(a, b) = inputStream.ReadValue <int, int>();
a--;
b--;
graph.AddEdge(new WeightedEdge(a, b));
graph.AddEdge(new WeightedEdge(b, a));
}
var dijkstra = new Dijkstra <BasicNode, WeightedEdge>(graph);
var distances = dijkstra.GetDistancesFrom(new BasicNode(0));
long max = 0;
var index = -1;
for (int i = 0; i < distances.Length; i++)
{
if (distances[i] > max)
{
max = distances[i];
index = i;
}
}
var from = index;
distances = dijkstra.GetDistancesFrom(new BasicNode(from));
max = 0;
for (int i = 0; i < distances.Length; i++)
{
if (distances[i] > max)
{
max = distances[i];
index = i;
}
}
var to = index;
yield return($"{from + 1} {to + 1}");
}
public void FloydWarshall_Smoke_Test()
{
var graph = new WeightedGraph <char, int>();
graph.AddVertex('S');
graph.AddVertex('A');
graph.AddVertex('B');
graph.AddVertex('C');
graph.AddVertex('D');
graph.AddVertex('T');
graph.AddEdge('S', 'A', 8);
graph.AddEdge('S', 'C', 10);
graph.AddEdge('A', 'B', 10);
graph.AddEdge('A', 'C', 1);
graph.AddEdge('A', 'D', 8);
graph.AddEdge('B', 'T', 4);
graph.AddEdge('C', 'D', 1);
graph.AddEdge('D', 'B', 1);
graph.AddEdge('D', 'T', 10);
var algo = new FloydWarshallShortestPath <char, int>(new FloydWarshallShortestPathOperators());
var result = algo.GetAllPairShortestPaths(graph);
var testCase = result.First(x => x.Source == 'S' && x.Destination == 'T');
Assert.AreEqual(15, testCase.Distance);
var expectedPath = new char[] { 'S', 'A', 'C', 'D', 'B', 'T' };
for (int i = 0; i < expectedPath.Length; i++)
{
Assert.AreEqual(expectedPath[i], testCase.Path[i]);
}
testCase = result.First(x => x.Source == 'T' && x.Destination == 'S');
Assert.AreEqual(15, testCase.Distance);
expectedPath = new char[] { 'T', 'B', 'D', 'C', 'A', 'S' };
for (int i = 0; i < expectedPath.Length; i++)
{
Assert.AreEqual(expectedPath[i], testCase.Path[i]);
}
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var(cityCount, railwayCount, initialSilver) = inputStream.ReadValue <int, int, int>();
const int extended = 2500;
var graph = new WeightedGraph(cityCount * (extended + 1));
for (int i = 0; i < railwayCount; i++)
{
var(u, v, a, b) = inputStream.ReadValue <int, int, int, int>();
u--;
v--;
for (int shift = 0; shift + a <= extended; shift++)
{
graph.AddEdge(new WeightedEdge(ToGraphNodeIndex(cityCount, u, shift + a), ToGraphNodeIndex(cityCount, v, shift), b));
graph.AddEdge(new WeightedEdge(ToGraphNodeIndex(cityCount, v, shift + a), ToGraphNodeIndex(cityCount, u, shift), b));
}
}
for (int city = 0; city < cityCount; city++)
{
var(c, d) = inputStream.ReadValue <int, int>();
for (int shift = 0; shift < extended; shift++)
{
graph.AddEdge(new WeightedEdge(ToGraphNodeIndex(cityCount, city, shift), ToGraphNodeIndex(cityCount, city, Math.Min(shift + c, extended)), d));
}
}
var dijkstra = new Dijkstra <BasicNode, WeightedEdge>(graph);
var distances = dijkstra.GetDistancesFrom(ToGraphNodeIndex(cityCount, 0, Math.Min(initialSilver, extended)));
for (int city = 1; city < cityCount; city++)
{
var min = long.MaxValue;
for (int silver = 0; silver <= extended; silver++)
{
min = Math.Min(min, distances[ToGraphNodeIndex(cityCount, city, silver)]);
}
yield return(min);
}
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var(n, m) = inputStream.ReadValue <int, int>();
var edges = new List <WeightedEdge>();
const long Inf = 1L << 60;
var startAndDistances = new List <StartAndDistance>();
for (int i = 0; i < m; i++)
{
var(u, v, l) = inputStream.ReadValue <int, int, int>();
u--;
v--;
edges.Add(new WeightedEdge(u, v, l));
edges.Add(new WeightedEdge(v, u, l));
if (u == 0)
{
startAndDistances.Add(new StartAndDistance(v, l));
}
}
long min = Inf;
for (int startIndex = 0; startIndex < startAndDistances.Count; startIndex++)
{
var(start, startDistance) = startAndDistances[startIndex];
var graph = new WeightedGraph(n);
foreach (var edge in edges)
{
if (!(edge.From == 0 && edge.To == start) && !(edge.From == start && edge.To == 0))
{
graph.AddEdge(edge);
}
}
var dijkstra = new Dijkstra <BasicNode, WeightedEdge>(graph);
min = Math.Min(min, startDistance + dijkstra.GetDistancesFrom(new BasicNode(start))[0]);
}
if (min == Inf)
{
yield return(-1);
}
else
{
yield return(min);
}
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
const long startYen = 1_000_000_000_000_000;
var(citiesCount, trainsCount, start, terminal) = inputStream.ReadValue <int, int, int, int>();
start--;
terminal--;
var yenGraph = new WeightedGraph(citiesCount);
var snuukGraph = new WeightedGraph(citiesCount);
for (int i = 0; i < trainsCount; i++)
{
var(from, to, yen, snuuk) = inputStream.ReadValue <int, int, long, long>();
from--;
to--;
yenGraph.AddEdge(new WeightedEdge(from, to, yen));
yenGraph.AddEdge(new WeightedEdge(to, from, yen));
snuukGraph.AddEdge(new WeightedEdge(from, to, snuuk));
snuukGraph.AddEdge(new WeightedEdge(to, from, snuuk));
}
var yenFares = new Dijkstra <BasicNode, WeightedEdge>(yenGraph).GetDistancesFrom(new BasicNode(start));
var snuukFares = new Dijkstra <BasicNode, WeightedEdge>(snuukGraph).GetDistancesFrom(new BasicNode(terminal));
var remainedSnuuks = new Stack <long>(citiesCount);
for (int exchange = citiesCount - 1; exchange >= 0; exchange--)
{
var best = remainedSnuuks.Count > 0 ? remainedSnuuks.Peek() : int.MinValue;
var next = startYen - (yenFares[exchange] + snuukFares[exchange]);
remainedSnuuks.Push(Math.Max(best, next));
}
foreach (var remainedSnuuk in remainedSnuuks)
{
yield return(remainedSnuuk);
}
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var(citiesCount, roadsCount, tankCapacity) = inputStream.ReadValue <int, int, int>();
var roadGraph = new WeightedGraph(citiesCount);
for (int i = 0; i < roadsCount; i++)
{
var(a, b, fuel) = inputStream.ReadValue <int, int, int>();
a--;
b--;
roadGraph.AddEdge(new WeightedEdge(a, b, fuel));
roadGraph.AddEdge(new WeightedEdge(b, a, fuel));
}
var distanceWarshallFloyd = new WarshallFloyd <BasicNode, WeightedEdge>(roadGraph);
var distances = distanceWarshallFloyd.GetDistances();
// こっちの初期化手法はあまり使わないか……
var refuelEdges = Enumerable.Range(0, citiesCount)
.SelectMany(from => Enumerable.Range(0, citiesCount)
.Select(to => new { from, to })
.Where(pair => distances[pair.from, pair.to] <= tankCapacity)
.Select(pair => new WeightedEdge(pair.from, pair.to)));
var refuelGraph = new WeightedGraph(citiesCount, refuelEdges);
var refuelWarshallFloyd = new WarshallFloyd <BasicNode, WeightedEdge>(refuelGraph);
var refuelCounts = refuelWarshallFloyd.GetDistances();
var queries = inputStream.ReadInt();
for (int q = 0; q < queries; q++)
{
var(from, to) = inputStream.ReadValue <int, int>();
from--;
to--;
var refuelCount = refuelCounts[from, to];
var output = refuelCount < long.MaxValue ? (refuelCount - 1).ToString() : (-1).ToString();
}
yield return(string.Empty);
}
public void GivenTwoKeys_WhenBothExists_ShouldAddRelationship()
{
// Arrange
var graph = new WeightedGraph <string>();
graph.AddNode("test1");
graph.AddNode("test2");
graph.AddEdge("test1", "test2", 10);
// Act
var values = graph.GetAll();
// Assert
values.Should().NotBeNull().And.HaveCount(2);
values.GetValueOrDefault("test1").Should().ContainSingle("test2");
values.GetValueOrDefault("test2").Should().ContainSingle("test1");
}
public void _Sequence_ReadWrite()
{
var graph = new WeightedGraph <object, int>(false, Round);
var random = new Random(DateTime.Now.Millisecond);
for (int i = 0; i < Round; i++)
{
graph.Set(i, i);
}
for (int i = 0; i < Round * 4.5; i++)
{
graph.AddEdge(random.Next(0, Round - 1), random.Next(0, Round - 1));
}
for (int i = 0; i < Round; i++)
{
Assert.True(i == (int)graph[i].Value);
}
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var(nodeCount, edgeCount, penalty) = inputStream.ReadValue <int, int, int>();
var graph = new WeightedGraph(nodeCount);
for (int i = 0; i < edgeCount; i++)
{
var(from, to, coin) = inputStream.ReadValue <int, int, int>();
from--;
to--;
graph.AddEdge(new WeightedEdge(from, to, penalty - coin));
}
var bf = new BellmanFord <BasicNode, WeightedEdge>(graph);
var(distances, negativeCycles) = bf.GetDistancesFrom(new BasicNode(0));
if (negativeCycles[^ 1])
public static WeightedGraph ParseGraphFromFile(string relativePath)
{
var basePath = AppDomain.CurrentDomain.BaseDirectory; // The path from which the program is run from
var p = Path.Combine(basePath, relativePath);
var text = File.ReadAllLines(p);
var graph = new WeightedGraph(Convert.ToInt32(text[0]));
for (var i = 2; i < text.Length; ++i)
{
var v1 = CharToInt(text[i][0]);
var v2 = CharToInt(text[i][2]);
var w = CharToInt(text[i][4]);
graph.AddEdge(v1, v2, w);
}
return(graph);
}
public void ABC137Test_FromGraph(string testCaseName)
{
ABC137Test_Core(testCaseName, (nodesCount, edgesCount, penalty, io) =>
{
var graph = new WeightedGraph(nodesCount);
for (int i = 0; i < edgesCount; i++)
{
var abc = io.ReadIntArray(3);
var a = abc[0] - 1;
var b = abc[1] - 1;
var c = abc[2];
graph.AddEdge(a, b, penalty - c);
}
var bellmanFord = new BellmanFord(graph);
return(bellmanFord);
});
}
private static WeightedGraph generateGraphFromFile()
{
bool head = true; int edges = -1;
foreach (var line in System.IO.File.ReadLines(@"Resources\ShortestPath01.txt"))
{
string[] nums = line.Split(' ');
if (head)
{
graph = new SparseGraph(Convert.ToInt32(nums[0]), false);
// graph = new DenseGraph(Convert.ToInt32(nums[0]), false);
edges = Convert.ToInt32(nums[1]);
head = false;
}
else
{
graph.AddEdge(Convert.ToInt32(nums[0]), Convert.ToInt32(nums[1]), Convert.ToDouble(nums[2]));
}
}
Assert.IsTrue(graph.E() == edges);
return(graph);
}
public void WeightedGraph_Smoke_Test()
{
var graph = new WeightedGraph <int, int>();
graph.AddVertex(1);
graph.AddVertex(2);
graph.AddVertex(3);
graph.AddVertex(4);
graph.AddVertex(5);
graph.AddEdge(1, 2, 1);
graph.AddEdge(2, 3, 2);
graph.AddEdge(3, 4, 4);
graph.AddEdge(4, 5, 5);
graph.AddEdge(4, 1, 1);
graph.AddEdge(3, 5, 0);
Assert.AreEqual(3, graph.GetAllEdges(4).Count);
Assert.AreEqual(2, graph.GetAllEdges(5).Count);
Assert.AreEqual(5, graph.VerticesCount);
Assert.IsTrue(graph.HasEdge(1, 2));
graph.RemoveEdge(1, 2);
Assert.IsFalse(graph.HasEdge(1, 2));
graph.RemoveEdge(2, 3);
graph.RemoveEdge(3, 4);
graph.RemoveEdge(4, 5);
graph.RemoveEdge(4, 1);
Assert.IsTrue(graph.HasEdge(3, 5));
graph.RemoveEdge(3, 5);
Assert.IsFalse(graph.HasEdge(3, 5));
graph.RemoveVertex(1);
graph.RemoveVertex(2);
graph.RemoveVertex(3);
graph.RemoveVertex(4);
graph.RemoveVertex(5);
Assert.AreEqual(0, graph.VerticesCount);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var(townCount, pathCount, timeLimit) = inputStream.ReadValue <int, int, int>();
var gainRates = inputStream.ReadLongArray();
var goingGraph = new WeightedGraph(townCount);
var backingGraph = new WeightedGraph(townCount);
for (int i = 0; i < pathCount; i++)
{
var(from, to, distance) = inputStream.ReadValue <int, int, int>();
from--;
to--;
goingGraph.AddEdge(new WeightedEdge(from, to, distance));
backingGraph.AddEdge(new WeightedEdge(to, from, distance));
}
var goingDijkstra = new Dijkstra <BasicNode, WeightedEdge>(goingGraph);
var backingDijkstra = new Dijkstra <BasicNode, WeightedEdge>(backingGraph);
var goingDistances = goingDijkstra.GetDistancesFrom(new BasicNode(0));
var backingDistances = backingDijkstra.GetDistancesFrom(new BasicNode(0));
const long inf = 1L << 50;
long max = 0;
for (int i = 0; i < townCount; i++)
{
if (goingDistances[i] > inf || backingDistances[i] > inf)
{
continue;
}
var earned = gainRates[i] * (timeLimit - goingDistances[i] - backingDistances[i]);
max = Math.Max(max, earned);
}
yield return(max);
}
public HyperloopTests(ITestOutputHelper output)
{
_output = output;
var cities = new[]
{
"Boston", "NewYork", "Philadelphia", "Washington", "Miami", "Atlanta", "Detroit", "Chicago",
"Dallas", "Huston", "Phoenix", "Riverside", "LosAngeles", "SanFrancisco", "Seattle"
};
_cityGraph = new UnweightedGraph <string>(cities);
_cityGraph.AddEdge("Boston", "NewYork");
_cityGraph.AddEdge("Boston", "Detroit");
_cityGraph.AddEdge("NewYork", "Detroit");
_cityGraph.AddEdge("NewYork", "Philadelphia");
_cityGraph.AddEdge("Washington", "Philadelphia");
_cityGraph.AddEdge("Washington", "Detroit");
_cityGraph.AddEdge("Washington", "Miami");
_cityGraph.AddEdge("Washington", "Atlanta");
_cityGraph.AddEdge("Miami", "Atlanta");
_cityGraph.AddEdge("Miami", "Huston");
_cityGraph.AddEdge("Atlanta", "Chicago");
_cityGraph.AddEdge("Atlanta", "Huston");
_cityGraph.AddEdge("Atlanta", "Dallas");
_cityGraph.AddEdge("Huston", "Dallas");
_cityGraph.AddEdge("Huston", "Phoenix");
_cityGraph.AddEdge("Dallas", "Phoenix");
_cityGraph.AddEdge("Dallas", "Chicago");
_cityGraph.AddEdge("Detroit", "Chicago");
_cityGraph.AddEdge("Riverside", "Chicago");
_cityGraph.AddEdge("Riverside", "Phoenix");
_cityGraph.AddEdge("Riverside", "LosAngeles");
_cityGraph.AddEdge("Riverside", "SanFrancisco");
_cityGraph.AddEdge("Phoenix", "LosAngeles");
_cityGraph.AddEdge("SanFrancisco", "LosAngeles");
_cityGraph.AddEdge("SanFrancisco", "Seattle");
_cityGraph.AddEdge("Chicago", "Seattle");
_weightedCityGraph = new WeightedGraph <string>(cities);
_weightedCityGraph.AddEdge("Boston", "NewYork", 190);
_weightedCityGraph.AddEdge("Boston", "Detroit", 613);
_weightedCityGraph.AddEdge("NewYork", "Detroit", 482);
_weightedCityGraph.AddEdge("NewYork", "Philadelphia", 81);
_weightedCityGraph.AddEdge("Washington", "Philadelphia", 123);
_weightedCityGraph.AddEdge("Washington", "Detroit", 396);
_weightedCityGraph.AddEdge("Washington", "Miami", 923);
_weightedCityGraph.AddEdge("Washington", "Atlanta", 543);
_weightedCityGraph.AddEdge("Miami", "Atlanta", 604);
_weightedCityGraph.AddEdge("Miami", "Huston", 968);
_weightedCityGraph.AddEdge("Atlanta", "Chicago", 588);
_weightedCityGraph.AddEdge("Atlanta", "Huston", 702);
_weightedCityGraph.AddEdge("Atlanta", "Dallas", 721);
_weightedCityGraph.AddEdge("Huston", "Dallas", 225);
_weightedCityGraph.AddEdge("Huston", "Phoenix", 1015);
_weightedCityGraph.AddEdge("Dallas", "Phoenix", 887);
_weightedCityGraph.AddEdge("Dallas", "Chicago", 805);
_weightedCityGraph.AddEdge("Detroit", "Chicago", 238);
_weightedCityGraph.AddEdge("Riverside", "Chicago", 1704);
_weightedCityGraph.AddEdge("Riverside", "Phoenix", 307);
_weightedCityGraph.AddEdge("Riverside", "LosAngeles", 50);
_weightedCityGraph.AddEdge("Riverside", "SanFrancisco", 386);
_weightedCityGraph.AddEdge("Phoenix", "LosAngeles", 357);
_weightedCityGraph.AddEdge("SanFrancisco", "LosAngeles", 348);
_weightedCityGraph.AddEdge("SanFrancisco", "Seattle", 678);
_weightedCityGraph.AddEdge("Chicago", "Seattle", 1737);
}
public void DijkstraPathFinder_FindShortestPath_Success()
{
// Arrange
var graph = new WeightedGraph <char>();
graph.AddEdge('A', 'B', 3);
graph.AddEdge('A', 'C', 2);
graph.AddEdge('A', 'D', 1);
graph.AddEdge('D', 'C', 4);
graph.AddEdge('D', 'G', 5);
graph.AddEdge('C', 'G', 2);
graph.AddEdge('B', 'E', 3);
graph.AddEdge('E', 'F', 1);
graph.AddEdge('E', 'H', 4);
graph.AddEdge('F', 'G', 1);
graph.AddEdge('F', 'H', 2);
graph.AddEdge('G', 'H', 2);
var pathFinder = new DijkstraPathFinder <char>();
var result = pathFinder.FindShortestPath(graph, 'A', 'H');
Assert.AreEqual(6, result.TotalCost);
Assert.AreEqual(4, result.Path.Count());
Assert.AreEqual('A', result.Path.ElementAt(0));
Assert.AreEqual('C', result.Path.ElementAt(1));
Assert.AreEqual('G', result.Path.ElementAt(2));
Assert.AreEqual('H', result.Path.ElementAt(3));
}
public void Run()
{
var weightedGraphA = new WeightedGraph();
weightedGraphA.AddNode("A");
weightedGraphA.AddNode("B");
weightedGraphA.AddNode("C");
weightedGraphA.AddNode("D");
weightedGraphA.AddNode("E");
weightedGraphA.AddEdge("A", "B", 1);
weightedGraphA.AddEdge("B", "C", 1);
weightedGraphA.AddEdge("B", "E", 12);
weightedGraphA.AddEdge("C", "D", 1);
weightedGraphA.AddEdge("D", "E", 1);
weightedGraphA.AddEdge("A", "E", 10);
weightedGraphA.Print();
Console.WriteLine($"Shortest path from A to E: {string.Join(",", weightedGraphA.GetShortestPath("A", "E"))}");
Console.WriteLine("");
Console.WriteLine($"Does graph A have a cycle?: {weightedGraphA.HasCycle()}");
Console.WriteLine("");
Console.WriteLine("Creating Graph B");
var weightedGraphB = new WeightedGraph();
weightedGraphB.AddNode("A");
weightedGraphB.AddNode("B");
weightedGraphB.AddNode("C");
weightedGraphB.AddEdge("A", "B", 1);
weightedGraphB.AddEdge("B", "C", 1);
weightedGraphB.Print();
Console.WriteLine("");
Console.WriteLine($"Does graph B have a cycle?: {weightedGraphB.HasCycle()}");
Console.WriteLine("");
Console.WriteLine("Creating Graph C");
var weightedGraphC = new WeightedGraph();
weightedGraphC.AddNode("A");
weightedGraphC.AddNode("B");
weightedGraphC.AddNode("C");
weightedGraphC.AddNode("D");
weightedGraphC.AddEdge("A", "B", 3);
weightedGraphC.AddEdge("B", "D", 4);
weightedGraphC.AddEdge("C", "D", 5);
weightedGraphC.AddEdge("A", "C", 1);
weightedGraphC.AddEdge("B", "C", 2);
weightedGraphC.Print();
Console.WriteLine("");
Console.WriteLine($"Minimum Spanning Tree for Graph C: ");
var minimumSpanningTreeC = weightedGraphC.GetMinimumSpanningTree();
minimumSpanningTreeC.Print();
}
public Parser()
{
xMin = double.PositiveInfinity;
xMax = double.NegativeInfinity;
yMin = double.PositiveInfinity;
yMax = double.NegativeInfinity;
nodes = new List <Node>();
ciudades = new List <City>();
ways = new List <Way>();
G = new WeightedGraph <Node>();
nodeById = new Dictionary <long, Node>();
waysByNode = new Dictionary <Node, List <Way> >();
string[] nodeLines = File.ReadAllLines(NODOS);
for (int i = 0; i < nodeLines.Length; i++)
{
string[] tok = nodeLines[i].Split('|');
long id = long.Parse(tok[0]);
double lat = double.Parse(tok[1]);
double lon = double.Parse(tok[2]);
Node n = new Node(id, lat, lon);
nodes.Add(n);
nodeById.Add(id, n);
yMin = Math.Min(yMin, lat);
yMax = Math.Max(yMax, lat);
xMin = Math.Min(xMin, lon);
xMax = Math.Max(xMax, lon);
}
// Coordenadas del mapa en caso de haber descargado una imagen
// ya que en algunos casos el mapa descargado viene con nodos
// fuera de los limites establecidos
xMin = -102.8018;
xMax = -100.6073;
yMin = 18.9505;
yMax = 20.4476;
nodeLines = null;
GC.Collect();
string[] cityLines = File.ReadAllLines(CIUDADES);
for (int i = 0; i < cityLines.Length; i++)
{
string[] tok = cityLines[i].Split('|');
long id = long.Parse(tok[0]);
double lat = double.Parse(tok[1]);
double lon = double.Parse(tok[2]);
string name = tok[3];
Node n = new Node(id, lat, lon);
ciudades.Add(new City(name, n));
}
cityLines = null;
GC.Collect();
string[] wayLines = File.ReadAllLines(CARRETERAS);
for (int i = 0; i < wayLines.Length; i++)
{
string[] tok = wayLines[i].Split('|');
long id = long.Parse(tok[0]);
string name = tok[tok.Length - 1];
Way w = new Way(name, id);
for (int j = 1; j < tok.Length - 1; j++)
{
long idA = long.Parse(tok[j]);
w.Add(idA);
Node n = nodeById[idA];
if (!waysByNode.ContainsKey(n))
{
waysByNode.Add(n, new List <Way>());
}
waysByNode[n].Add(w);
}
ways.Add(w);
}
wayLines = null;
GC.Collect();
string[] graphLines = File.ReadAllLines(GRAFO);
for (int i = 0; i < graphLines.Length; i++)
{
string[] tok = graphLines[i].Split('|');
long id = long.Parse(tok[0]);
Node a = nodeById[id];
for (int j = 1; j < tok.Length; j++)
{
long idA = long.Parse(tok[j]);
Node b = nodeById[idA];
G.AddEdge(a, b, a.Distance(b));
}
}
graphLines = null;
GC.Collect();
}
