Exemple #1
0
        public List <Point> BruteForceApproach()
        {
            List <List <Point> > cycles = new List <List <Point> >();

            int[]      pointsValues = Points.Select(n => n.Value).ToArray();
            List <int> list         = pointsValues.ToList();

            List <Point> points = Points.OrderBy(n => list.IndexOf(n.Value)).ToList();

            if (IsCycle(points))
            {
                cycles.Add(points);
            }

            while (!PermutationGenerator.NextPermutation(pointsValues))
            {
                list   = pointsValues.ToList();
                points = Points.OrderBy(n => list.IndexOf(n.Value)).ToList();

                if (IsCycle(points))
                {
                    cycles.Add(points);
                }
            }


            return(FindShortestCycle(cycles));
        }
Exemple #2
0
        public List <List <Node> > Hamilton(Graph graph)
        {
            List <List <Node> > hamiltonianCycles = new List <List <Node> >();

            int[]      nodesValues = graph.Nodes.Select(n => n.Value).ToArray();
            List <int> list        = nodesValues.ToList();

            List <Node> nodes = graph.Nodes.OrderBy(n => list.IndexOf(n.Value)).ToList();

            if (graph.IsHamiltonCycle(nodes))
            {
                hamiltonianCycles.Add(nodes);
            }

            while (!PermutationGenerator.NextPermutation(nodesValues))
            {
                list = nodesValues.ToList();

                nodes = graph.Nodes.OrderBy(n => list.IndexOf(n.Value)).ToList();

                if (graph.IsHamiltonCycle(nodes))
                {
                    hamiltonianCycles.Add(nodes);
                }
            }


            return(hamiltonianCycles);
        }
Exemple #3
0
        private static void Main()
        {
            foreach (List <int> ints in SubsetGenerator.BacktrackingGenerator(new List <int> {
                1, 2, 3, 4
            }, 0))
            {
                foreach (int i in ints)
                {
                    Console.Write(i + " ");
                }

                Console.WriteLine();
            }

            foreach (IEnumerable <int> enumerable in SubsetGenerator.LexicalGenerator(new List <int> {
                4, 3, 2, 1
            }))
            {
                foreach (int i in enumerable)
                {
                    Console.Write(i + " ");
                }

                Console.WriteLine();
            }

            Console.WriteLine("---------");


            foreach (int[] ints in KSubsetGenerator.BacktrackingGenerator(5, 4))
            {
                foreach (int i in ints)
                {
                    Console.Write(i + " ");
                }

                Console.WriteLine();
            }

            KSubsetGenerator.LexicalGenerator(5, 4);

            Console.WriteLine("---------");

            new PermutationGenerator().BacktrackingGeneration(new[] { 1, 2, 3, 4 }.ToArray(), 0, 3);

            Console.WriteLine("---------");

            //foreach (int[] subset in new PermutationGenerator().LexicalGeneration(new[] { 1, 2, 3, 4 }))
            //{
            //    foreach (int element in subset)
            //    {
            //        Console.Write(element + " ");
            //    }
            //    Console.WriteLine();
            //}

            var arr = new[] { 1, 2, 3, 4 };

            foreach (int i in arr)
            {
                Console.Write(i + " ");
            }

            Console.WriteLine();

            while (!PermutationGenerator.NextPermutation(arr))
            {
                foreach (int i in arr)
                {
                    Console.Write(i + " ");
                }

                Console.WriteLine();
            }
        }