private void Process(State givenState, UndirectedGraph graph, bool flag)
 {
     if (givenState.Level == _n)
     {
         var isAllVerticesCovered = CanVerticesBeCovered(givenState);
         if (isAllVerticesCovered)
         {
             if (flag)
             {
                 if (MinDs.First().Count > givenState.TempDs.Count)
                 {
                     MinDs.Clear();
                     MinDs.Add(givenState.TempDs);
                     return;
                 }
                 if (MinDs.First().Count == givenState.TempDs.Count)
                 {
                     MinDs.Add(givenState.TempDs);
                     return;
                 }
             }
             else
             {
                 var checker = new CheckSet();
                 if (checker.IsMinimal(givenState.TempDs, graph))
                 {
                     MinDs.Add(givenState.TempDs);
                 }
             }
         }
     }
     else
     {
         var givenVertex = graph.Vertices[givenState.Level];
         givenState.VertexColor[givenVertex] = StateColor.BLUE;
         BlueVertexRecount(givenState, givenVertex);
         var isVertexCovered = CanVertexBeCovered(givenVertex, givenState);
         if (isVertexCovered)
         {
             var newState = givenState.Clone();
             newState.Level++;
             Process(newState, graph, flag);
         }
         givenState.VertexColor[givenVertex] = StateColor.RED;
         givenState.TempDs.Add(givenVertex);
         RedVertexRecount(givenState, givenVertex);
         if (givenState.NDominated == _n)
         {
             if (flag)
             {
                 if (MinDs.First().Count > givenState.TempDs.Count)
                 {
                     MinDs.Clear();
                     MinDs.Add(givenState.TempDs);
                     return;
                 }
                 if (MinDs.First().Count == givenState.TempDs.Count)
                 {
                     MinDs.Add(givenState.TempDs);
                     return;
                 }
             }
             else
             {
                 var checker = new CheckSet();
                 if (checker.IsMinimal(givenState.TempDs, graph))
                 {
                     MinDs.Add(givenState.TempDs);
                 }
             }
         }
         else
         {
             if (flag)
             {
                 var nExtra = (double)(_n - givenState.NDominated) / (_delta + 1);
                 if ((nExtra + givenState.TempDs.Count) > MinDs.First().Count)
                 {
                     return;
                 }
                 else
                 {
                     var newState = givenState.Clone();
                     newState.Level++;
                     Process(newState, graph, flag);
                     return;
                 }
             }
             else
             {
                 var newState = givenState.Clone();
                 newState.Level++;
                 Process(newState, graph, flag);
                 return;
             }
         }
     }
 }
        /// <summary>
        /// Проверка выбранного множества вершин на соответствие множеству внешней устойчивости
        /// </summary>
        /// <returns></returns>
        private bool ValidateSet()
        {
            var  isAdded    = false;
            var  setChecker = new CheckSet();
            bool isExternal = setChecker.IsExternalStability(DomSet, GivenGraph);
            var  sccStr     = new MdsRowViewModel(DomSet, _dsCount - _countOfSes + 1);
            var  isMinimal  = setChecker.IsMinimal(DomSet, GivenGraph);

            // какое множество проверяем
            UserActionsManager.RegisterInfo("Внешняя устойчивость. Задание 2. На проверку отправлено множество: " + sccStr.VerticesView);
            if (isExternal)
            {
                if (isMinimal)
                {
                    //Поиск выбранного множества в списке всех множеств ???
                    foreach (var sccRow in MdsRows)
                    {
                        if (sccRow.VerticesView == sccStr.VerticesView)
                        {
                            isAdded = true;
                            break;
                        }
                    }
                    //Проверка на уже добавленность выбранного множества
                    if (isAdded)
                    {
                        MessageBox.Show("Множество " + sccStr.VerticesView + " уже добавлено.");
                        if (UserActionsManager.Score > 2)
                        {
                            UserActionsManager.RegisterMistake("Множество " + sccStr.VerticesView + " уже добавлено.", 2);
                        }
                        else if (UserActionsManager.Score > 0)
                        {
                            UserActionsManager.RegisterMistake("Множество " + sccStr.VerticesView + " уже добавлено.",
                                                               (short)UserActionsManager.Score);
                        }
                    }
                    else
                    {
                        MdsRows.Add(sccStr);
                        --_countOfSes;
                        //Выбрано достаточное количество множеств внешней устойчивости
                        if (_countOfSes == 0)
                        {
                            UserActionsManager.RegisterInfo("Внешняя устойчивость. Задание 2 завершено. ");
                            MessageBox.Show("Задание 2 пройдено.\n Вы перешли к заданию 3.\n Ознакомьтесь со справкой.<?>");
                            _task = Task.TaskFindMinDomSets;
                        }
                        if (UserActionsManager.Score > _countOfSes)
                        {
                            UserActionsManager.RegisterInfo(string.Format(@"Множество добавлено. Осталось {0} множеств(о).",
                                                                          _countOfSes));
                        }
                        else if (UserActionsManager.Score > 0)
                        {
                            UserActionsManager.RegisterInfo(string.Format(@"Множество добавлено. Осталось {0} множеств(о).",
                                                                          UserActionsManager.Score));
                        }
                    }

                    //Очищаем текущее множество выбранных вершин
                    DomSet.Clear();

                    //Визуальное изменение выбранных элементов
                    foreach (var vertex in VertVisCol)
                    {
                        vertex.BorderBrush = new SolidColorBrush(_defaultBorderColor);
                        vertex.Background  = new SolidColorBrush(_defaultBackgroundColor);
                        Matrix[Convert.ToInt32(vertex.Name)].Background =
                            new SolidColorBrush(Color.FromArgb(250, 239, 240, 250));
                    }


                    foreach (var edge in EdgeVisCol)
                    {
                        edge.Stroke = new SolidColorBrush(_defaultBorderColor);
                    }
                }
                else
                {
                    if (UserActionsManager.Score > 10)
                    {
                        UserActionsManager.RegisterMistake("Это множество вершин не является минимальным.", 10);
                    }
                    else if (UserActionsManager.Score > 0)
                    {
                        UserActionsManager.RegisterMistake("Это множество вершин не является минимальным.",
                                                           (short)UserActionsManager.Score);
                    }
                }
            }
            else
            {
                if (UserActionsManager.Score > 10)
                {
                    UserActionsManager.RegisterMistake("Это множество вершин не является внешне устойчивым.", 10);
                }
                else if (UserActionsManager.Score > 0)
                {
                    UserActionsManager.RegisterMistake("Это множество вершин не является внешне устойчивым.",
                                                       (short)UserActionsManager.Score);
                }
            }
            return(true);
        }