public static void Task7(IGraphAtoFactory graphFactory)
        {
            //var graph = graphFactory.CreateTwoPartsWeighedGraph(new int[,] {
            //                                                { 4,  3,  7,  9,  12, 10 },
            //                                                { 5,  7,  11, 10, 14, 6  },
            //                                                { 3,  8,  12, 11, 4,  9  },
            //                                                { 11, 9,  14, 7,  6,  13 },
            //                                                { 10, 12, 4,  3,  5,  8  },
            //                                                { 12, 4,  3,  8,  7,  12 },
            //                                                },
            //                                                    new[] { "1", "2", "3", "4", "5", "6" },
            //                                                    new[] { "A", "B", "C", "D", "E", "F" });
            var graph = graphFactory.CreateTwoPartsWeighedGraph(new int[, ] {
                { 8, 8, 1, 10, 4, 6, 6, 1 },
                { 6, 8, 8, 10, 3, 3, 3, 10 },
                { 3, 4, 10, 2, 3, 3, 3, 1 },
                { 8, 1, 6, 4, 4, 4, 9, 5 },
                { 2, 4, 9, 4, 5, 3, 3, 4 },
                { 1, 5, 4, 7, 2, 9, 3, 8 },
                { 8, 3, 3, 3, 4, 4, 4, 10 },
                { 8, 5, 1, 1, 1, 9, 8, 3 },
            },
                                                                new[] { "1", "2", "3", "4", "5", "6", "7", "8" },
                                                                new[] { "A", "B", "C", "D", "E", "F", "G", "H" });

            void OnStep(string info) => Console.WriteLine(info);

            var pairs = graph.ApplayHungarian(graphFactory, OnStep);

            Console.WriteLine(pairs.Print());
        }
Exemplo n.º 2
0
        public static IEnumerable <string> ApplayFleury(this IGraph graph, IGraphAtoFactory factory)
        {
            var    cycle   = factory.CreatePoute();
            var    node    = graph.GetFirstNode();
            int    i       = 0;
            string removed = "";

            do
            {
                var edges         = node.GetEdges(graph).ToList();
                var edgesListInfo = string.Join(", ", edges.Select(e => $"{e.Print()} - {(e.IsBrige(node.GetNext(e), graph) ? "Мост" : "Не мост")}"));
                var edge          = edges.FirstOrDefault(e => !e.IsBrige(node.GetNext(e), graph)) ?? edges.FirstOrDefault();
                yield return($"{(removed == "" ? "" : $"\tУдаляем из графа грань {removed}\n")}Шаг {i}\n\tЦикл: {cycle.Print()}\n\tГафф: {graph.Print()}\n\tТекущий узел: {node}, Нерассмотренные грани: {edgesListInfo}\n\tПервая не рассмотренная грань, не являющаяся мостом: {edge}");
        public static void Task8(IGraphAtoFactory graphFactory)
        {
            var graph = graphFactory.CreateGraph(("H", "E"), ("H", "F"), ("H", "D"), ("H", "G"),
                                                 ("E", "A"), ("E", "D"), ("E", "B"),
                                                 ("F", "A"), ("F", "D"), ("F", "G"),
                                                 ("G", "B"), ("G", "C"),
                                                 ("D", "A"),
                                                 ("A", "B"),
                                                 ("B", "C"));

            Console.WriteLine(graph);
            foreach (var step in graph.ApplayFleury(graphFactory))
            {
                Console.WriteLine(step);
            }
        }
        public static void Task9(IGraphAtoFactory graphFactory)
        {
            //var graph = graphFactory.CreateOrgraph(("F", "A"), ("C", "A"), ("A", "B"),
            //                                       ("F", "B"), ("B", "E"), ("B", "C"),
            //                                       ("F", "C"), ("D", "F"),
            //                                       ("E", "C"), ("C", "D"), ("D", "C"),
            //                                       ("E", "D"));
            var graph = graphFactory.CreateOrgraph(new int[, ] {
                { 0, 0, 1, 1 },
                { 0, 0, 1, 1 },
                { 1, 1, 0, 1 },
                { 1, 1, 1, 0 },
            },
                                                   "A", "B", "C", "D");

            Console.WriteLine(graph);
            var result = graph.ApplayRobertsFlores(graphFactory).ToList();

            result.ForEach(Console.WriteLine);
        }
        private static IEnumerable<IPath> GetAllCircuit(INode node, IOrgraph orgraph, HashSet<INode> notAllowed, INode root, IGraphAtoFactory factory, Action<string> OnStep)
        {
            notAllowed.Add(node);
            //OnStep($"{string.Join(", ", notAllowed)}");
            if (notAllowed.Count == orgraph.Nodes.Count && node.GetOutputArcs(orgraph).FirstOrDefault(a => a.To == root) is { } finalArc)
            {
                var circuit = factory.CreatePath();
                OnStep($"Add {finalArc}");
                circuit.Append(finalArc);
                yield return circuit;
                yield break;
            }
            foreach (var arc in node.GetOutputArcs(orgraph).Where(a => a.To.NotIn(notAllowed)))
            {
                var circuits = GetAllCircuit(arc.To, orgraph, new HashSet<INode>(notAllowed), root, factory, OnStep);
                foreach (var circuit in circuits)
                {
                    OnStep($"Add {arc}");
                    circuit.Append(arc);
                    yield return circuit;
                }
            }

            //private static IEnumerable<IPath> GetAllCircuit(INode node, IOrgraph orgraph, HashSet<INode> notAllowed, INode root, IGraphAtoFactory factory, Action<string> OnStep)
            //{
            //    notAllowed.Add(node);
            //    OnStep($"{string.Join(", ", notAllowed)}");
            //    if (notAllowed.Count == orgraph.Nodes.Count && node.GetOutputArcs(orgraph).FirstOrDefault(a => a.To == root) is { } finalArc)
            //    {
            //        var circuit = factory.CreatePath();
            //        circuit.Append(finalArc);
            //        return circuit;
            //    }
            //    foreach (var arc in node.GetOutputArcs(orgraph).Where(a => a.To.NotIn(notAllowed)))
            //    {
            //        var circuit = GetCircuit(arc.To, orgraph, notAllowed, root, factory, OnStep);
            //        if (circuit is null) continue;
            //        circuit.Append(arc);
            //        return circuit;
            //    }
            //    notAllowed.Remove(node);
            //    return null;
            //}
        }
        private static IEnumerable <IPath> GetAllCircuit(INode node, IOrgraph orgraph, HashSet <INode> notAllowed, INode root, IGraphAtoFactory factory, Action <string> OnStep)
        {
            notAllowed.Add(node);
            var step = $"S = {string.Join(", ", notAllowed)}, Current node: {node}, Current arc: ";

            //OnStep($"{string.Join(", ", notAllowed)}");
            if (notAllowed.Count == orgraph.Nodes.Count && node.GetOutputArcs(orgraph).FirstOrDefault(a => a.To == root) is { } finalArc)
            {
                OnStep($"{step} {finalArc}");
                var circuit = factory.CreatePath();
                OnStep($"Add {finalArc}");
                circuit.Append(finalArc);
                yield return(circuit);

                yield break;
            }
            foreach (var arc in node.GetOutputArcs(orgraph).Where(a => a.To.NotIn(notAllowed)))
            {
                OnStep($"{step} {arc}");
                var circuits = GetAllCircuit(arc.To, orgraph, new HashSet <INode>(notAllowed), root, factory, OnStep);
                foreach (var circuit in circuits)
                {
                    OnStep($"Add {arc}");
                    circuit.Append(arc);
                    yield return(circuit);
                }
            }
        }
 private static IPath GetCircuit(INode node, IOrgraph orgraph, HashSet <INode> notAllowed, INode root, IGraphAtoFactory factory, Action <string> OnStep)
 {
     notAllowed.Add(node);
     //OnStep($"{string.Join(", ", notAllowed)}");
     if (notAllowed.Count == orgraph.Nodes.Count && node.GetOutputArcs(orgraph).FirstOrDefault(a => a.To == root) is { } finalArc)
     {
         var circuit = factory.CreatePath();
         OnStep($"Add {finalArc}");
         circuit.Append(finalArc);
         return(circuit);
     }
     foreach (var arc in node.GetOutputArcs(orgraph).Where(a => a.To.NotIn(notAllowed)))
     {
         var circuit = GetCircuit(arc.To, orgraph, notAllowed, root, factory, OnStep);
         if (circuit is null)
         {
             continue;
         }
         OnStep($"Add {arc}");
         circuit.Append(arc);
         return(circuit);
     }
     notAllowed.Remove(node);
     return(null);
 }
Exemplo n.º 8
0
 public Hungarian(IGraphAtoFactory factory, Action <string> onStep)
 {
     _factory = factory;
     _onStep  = onStep;
 }
Exemplo n.º 9
0
        public static IWeighedPairsGraph ApplayHungarian(this ITwoPartsWeighedGraph graph, IGraphAtoFactory factory, Action <string> onStep)
        {
            var hungarian = new Hungarian(factory, onStep);

            return(hungarian.Applay(graph));
        }