예제 #1
0
        static void RecursiveSearch(int v, ref List <int> clique, ref List <int> neighbours, MyGraph g)
        {
            //Получить соседей для вершины
            List <int> candidates = g.GetNeighbors(v);

            //Добавим саму вершину в список соседей
            candidates.Add(v);
            //Получить пересечение со списком всех вершин-соседей в клике - это общий список соседей клики при добавлении этой вершины
            candidates = candidates.Intersect(neighbours).ToList <int>();
            clique.Add(v);
            //Получить список вершин из общего списка соседей клики, которые еще не были добавлены в клику
            List <int> cut_n = candidates.Except(clique).ToList <int>();

            //Если есть еще нерассмотренные вершины из общего списка соседей клики
            if (cut_n.Count() != 0)
            {
                //Найдем вершину, максимально связанную с прочими нерассмотренными вершинами
                int node = GetNodeToAdd(g, cut_n, clique);
                if (node.Equals(-1))
                {
                    return;
                }
                RecursiveSearch(node, ref clique, ref candidates, g);
                if (globalClick.Count() < clique.Count())
                {
                    globalClick.Clear();
                    globalClick.AddRange(clique);
                }
            }
            else
            {
                return;
            }
        }
예제 #2
0
        public void CanAddEdgeToGraph()
        {
            MyGraph <int> graph        = new MyGraph <int>();
            Node <int>    nodeA        = graph.AddNode(5);
            Node <int>    nodeB        = graph.AddNode(10);
            Edge <int>    expectedEdge = new Edge <int>(nodeB, 7);

            graph.AddDirectedEdge(nodeA, nodeB, 7);
            List <Edge <int> > edges = graph.GetNeighbors(nodeA);

            Assert.Equal(expectedEdge.Node.Value, edges[0].Node.Value);
            Assert.Equal(expectedEdge.Weight, edges[0].Weight);
        }
예제 #3
0
        /// <summary>
        /// Получить список возможных вершин на добавление к существующей клике
        /// </summary>
        /// <param name="graph">Граф</param>
        /// <param name="clique">Клика</param>
        /// <returns></returns>
        static List <int> MakePossibleAdd(MyGraph graph, List <int> clique)
        {
            List <int> result = new List <int>();

            for (int i = 0; i < graph.NumberNodes; ++i)
            {
                //Если вершина не входит в клику - проверим, связана ли она со свеми вершинами в клике
                if (!clique.Exists(x => x == i))
                {
                    //Если вершина связана со всеми вершинами в клике - добавим ее в список кандидатов
                    bool isLinked = clique.Intersect(graph.GetNeighbors(i)).Count().Equals(clique.Count()) ? true : false;
                    if (isLinked)
                    {
                        result.Add(i);
                    }
                }
            }
            return(result);
        }
예제 #4
0
        private static Dictionary <int, int> colorize(List <int> nodes, MyGraph graph)
        {
            //Раскраска графа
            List <int> colors = new List <int>()
            {
                1
            };
            Dictionary <int, int> colorizedGraph = new Dictionary <int, int>();
            int count = 0;

            nodes.ForEach(n =>
            {
                //Обработаем первую вершину из списка - покрасим ее в 1 цвет
                if (count == 0)
                {
                    colorizedGraph.Add(n, colors[0]);
                    count++;
                }
                else
                {
                    //Получить список соседей для данной вершины
                    List <int> neighbors = graph.GetNeighbors(n).Intersect(nodes).ToList <int>();
                    //Получить минимальный цвет из списка цветов, в который не окрашен ни один из соседей
                    neighbors     = neighbors.Intersect(colorizedGraph.Keys.ToList <int>()).ToList <int>();                                      //Список окрашенных соседей
                    var cols      = (from c in colorizedGraph where neighbors.Exists(t => t == c.Key) select c.Value).Distinct().ToList <int>(); //Список различных цветов окрашенных соседей
                    var avaliable = colors.Except(cols).ToList <int>();
                    //Если такого цвета нет - создать и добавить в список доступных цветов
                    if (avaliable.Count() == 0)
                    {
                        int newColor = colors.Max() + 1;
                        colors.Add(newColor);
                        colorizedGraph.Add(n, newColor);
                    }
                    else
                    {
                        int color = avaliable.Min();
                        colorizedGraph.Add(n, color);
                    }
                }
            });
            return(colorizedGraph);
        }
예제 #5
0
        public void CanGetAllEdgesConnectedToAVertex()
        {
            MyGraph <string> graph = new MyGraph <string>();
            Vertex <string>  v1    = graph.AddNode("Wa");
            Vertex <string>  v2    = graph.AddNode("GA");
            Vertex <string>  v3    = graph.AddNode("CA");
            Vertex <string>  v4    = graph.AddNode("MI");

            graph.AddDirectedEdge(v1, v2, 50);
            graph.AddDirectedEdge(v1, v4, 100);
            List <int> actual   = new List <int>();
            List <int> expected = new List <int>()
            {
                50, 100
            };

            foreach (var item in graph.GetNeighbors(v1))
            {
                actual.Add(item.Weight);
            }
            Assert.Equal(expected, actual);
        }
예제 #6
0
        public void CanRetrieveListOfEdges()
        {
            MyGraph <int> graph = new MyGraph <int>();

            Node <int> nodeA = graph.AddNode(5);
            Node <int> nodeB = graph.AddNode(10);
            Node <int> nodeC = graph.AddNode(1);

            Edge <int>         edgeA         = new Edge <int>(nodeB, 2);
            Edge <int>         edgeB         = new Edge <int>(nodeC, 5);
            List <Edge <int> > expectedEdges = new List <Edge <int> > {
                edgeA, edgeB
            };

            graph.AddDirectedEdge(nodeA, nodeB, 2);
            graph.AddDirectedEdge(nodeA, nodeC, 5);

            List <Edge <int> > actualEdges = graph.GetNeighbors(nodeA);

            Assert.Equal(expectedEdges[0].Node.Value, actualEdges[0].Node.Value);
            Assert.Equal(expectedEdges[0].Weight, actualEdges[0].Weight);
            Assert.Equal(expectedEdges[1].Node.Value, actualEdges[1].Node.Value);
            Assert.Equal(expectedEdges[1].Weight, actualEdges[1].Weight);
        }
예제 #7
0
        /// <summary>
        /// Проверить, что добавление данной вершины формирует клику большего размера
        /// </summary>
        /// <param name="graph">Граф</param>
        /// <param name="clique">Клика</param>
        /// <param name="node">Вершина на добавление</param>
        /// <returns></returns>
        static bool FormsALargerClique(MyGraph graph, List <int> clique, int node)
        {
            bool result = clique.Intersect(graph.GetNeighbors(node)).Count().Equals(clique.Count()) ? true : false;

            return(result);
        }