Пример #1
0
        public void Should_find_minimum_path_for_the_graph_7()
        {
            generateGraph1();
            IDictionary <string, decimal> _a;
            IDictionary <string, string>  _b;

            _graph.Dijkstra2("s", "e", out _a, out _b);

            _a["e"].Should().Be(7);
        }
        private static void Test1(string input, string output)
        {
            Console.WriteLine();
            Console.WriteLine("--------------------------------------------");
            Console.WriteLine("Практическое задание #1 (тест): " + input);
            Console.WriteLine("--------------------------------------------");

            var inputFileName = @"Data\test_09\input_" + input + ".txt";
            var inputReader   = new StreamReader((new FileInfo(inputFileName)).OpenRead());

            var outputFileName = @"Data\test_09\output_" + output + ".txt";
            var outputReader   = new StreamReader((new FileInfo(outputFileName)).OpenRead());

            var graph       = new Graph <string>();
            var vertexCount = 0;
            var edgeCount   = 0;

            #region INPUT

            var keys = new List <int>();
            var row  = inputReader.ReadLine();
            var vs   = row.Split(' ');
            vertexCount = Convert.ToInt32(vs[0]);
            edgeCount   = Convert.ToInt32(vs[0]);

            graph._graph = new Dictionary <string, IList <KeyValuePair <string, decimal> > >(vertexCount);

            while (!inputReader.EndOfStream)
            {
                row = inputReader.ReadLine();
                vs  = row.Split(' ');

                var key  = vs[1];
                var cost = Convert.ToDecimal(vs[2]);

                if (!keys.Contains(Convert.ToInt32(key)))
                {
                    keys.Add(Convert.ToInt32(key));
                }

                if (!graph._graph.ContainsKey(vs[0]))
                {
                    graph._graph.Add(new KeyValuePair <string, IList <KeyValuePair <string, decimal> > >(vs[0], new List <KeyValuePair <string, decimal> >()));
                }

                graph._graph[vs[0]].Add(new KeyValuePair <string, decimal>(key, cost));
            }

            //Validate Graph
            var length = graph._graph.Count;
            for (var i = 0; i < length; ++i)
            {
                var v = graph._graph.Keys.ElementAt(i);
                foreach (var u in graph._graph[v])
                {
                    if (!graph._graph.ContainsKey(u.Key))
                    {
                        graph._graph.Add(u.Key, null);
                    }
                }
            }

            #endregion

            #region OUTPUT

            var outPutResults = new int?[vertexCount][];

            Console.WriteLine("OUTPUT:");

            {
                var i = 0;
                while (!outputReader.EndOfStream)
                {
                    row = outputReader.ReadLine();
                    vs  = row.Split(' ');

                    var vsCount = vs.Length;
                    outPutResults[i] = new int?[vertexCount];

                    for (var j = 0; j < vsCount; ++j)
                    {
                        int shortPath;
                        if (int.TryParse(vs[j], out shortPath))
                        {
                            outPutResults[i][j] = shortPath;
                        }
                    }

                    ++i;

                    Console.WriteLine(row);
                }
            }


            Console.WriteLine(new string('.', 50));
            #endregion

            var resultFile = File.AppendText(input + "-result.txt");

            for (var i = 0; i < outPutResults.Length; ++i)
            {
                var outPutResult = outPutResults[i];
                for (var j = 0; j < outPutResult.Length; ++j)
                {
                    var result = outPutResult[j];

                    if (result == null)
                    {
                        continue;
                    }


                    var s = Convert.ToString(i + 1); //keys[i]);
                    var e = Convert.ToString(j + 1); //keys[j]);

                    if (!graph._graph.ContainsKey(s))
                    {
                        Console.Write("----> Начальная вершина: {0}", s);
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine("- НЕ СУЩЕСТВУЕТ.");
                        Console.ResetColor();

                        resultFile.Write("----> Начальная вершина: {0} - НЕ СУЩЕСТВУЕТ.", s);
                        continue;
                    }

                    if (!graph._graph.ContainsKey(e))
                    {
                        Console.Write("----> Конечная вершина: {0}", e);
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine("- НЕ СУЩЕСТВУЕТ.");
                        Console.ResetColor();

                        resultFile.Write("----> Конечная вершина: {0} - НЕ СУЩЕСТВУЕТ.", e);

                        continue;
                    }

                    IDictionary <string, decimal> a;
                    IDictionary <string, string>  b;

                    graph.Dijkstra2(s, e, out a, out b);

                    Console.Write("{0}:{1} --> (Output:{2}, Result:{3}) -- ", s, e, result, a[e]);
                    if (a[e] == result)
                    {
                        Console.ForegroundColor = ConsoleColor.Green;
                        Console.WriteLine("Passed");
                        Console.ResetColor();
                        continue;
                    }

                    resultFile.Write("{0}:{1} --> (Output:{2}, Result:{3}) -- Failed", s, e, result, a[e]);

                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("Failed");
                    Console.ResetColor();
                }
            }
        }