Example #1
0
        //unnecessary, remove late
        public void BuildEuristic()
        {
            A = DeepClone(mainA) as List <List <int> >;
            int l = FindS(A, 1).Count;

            while (true)  //for l0
            {
                Rez.Clear();
                List <int> index        = new List <int>(); // номера вершин, которые мы занесли в упорядочение на это место hi
                List <int> S0           = new List <int>();
                List <int> fromPrevious = new List <int>();
                List <int> nessesary    = new List <int>();



                for (int i = 0; i < h.Count; i++) //для всех hi
                {
                    if (index.Count > 0)
                    {
                        Rez.Add(DeepClone(index) as List <int>);
                    }
                    A = Remove(index);
                    index.Clear();
                    if (A.Count == 0)
                    {
                        return;
                    }

                    S = FindS(A, 0);
                    s = FindS(A, 1);
                    int k = 0;
                    //находим вершины, которые поставили в упорядочение на прошлом шаге,
                    //и которые еще существуют
                    fromPrevious = fromPreviousLevel(Rez);

                    //вершины, которые ставить необхдимо из-за того, что на этом шаге у них заканчивается мю.
                    nessesary = findNessesary(l, i, A);

                    for (int j = 0; j < h[i]; j++) // не более, чем hi раз             каждый раз добавляем по одной вершине
                    {
                        //остальное как обычно в уровневом

                        //брать из S[0] уже нечего
                        if ((S0.Count == 0) || (j == 0))
                        {
                            if (k < S.Count) //вспомнить бы, зачем на самом деле тут k
                            {
                                //если еще остаслись вершины, которые можно было ставить на прошлом шаге, то ставим их
                                //иначе, т.е. если (S0.Count == 0), ищем новые
                                if (S0.Count == 0)
                                {
                                    S0 = AND(S[k], s[0]);
                                    k++;
                                }
                            }
                            else
                            {
                                break;
                            }
                        }
                        if ((S0.Count > 0) || (nessesary.Count > 0) || (fromPrevious.Count > 0))
                        {
                            int t;
                            if (nessesary.Count > 0)
                            {
                                t = findAny(nessesary);
                                if (index.Contains(nessesary[t])) //TODO find something better
                                {
                                    j--;
                                }
                                //добавляем вершину в упорядочение
                                else
                                {
                                    index.Add(nessesary[t]);
                                }
                                //удаляем вершину с списка вершин-кандидатов
                                nessesary.RemoveAt(t);
                            }
                            else
                            {
                                if (fromPrevious.Count > 0)
                                {
                                    t = findAny(fromPrevious);
                                    if (index.Contains(fromPrevious[t])) //TODO find something better
                                    {
                                        j--;
                                    }

                                    //добавляем вершину в упорядочение
                                    else
                                    {
                                        index.Add(fromPrevious[t]);
                                    }

                                    //удаляем вершину с списка вершин-кандидатов
                                    fromPrevious.RemoveAt(t);
                                }

                                else
                                {
                                    //было в не эвристическом
                                    //берем не рандомные, а те, которые стояли на прошлом шаге.
                                    //это не делает хуже, т.к. можно брать любые.
                                    t = findBestFitEasy(S0, Rez);

                                    //если попалась вершина, которая уже стоит на этом месте - берем следующую.
                                    //в такую ситуацию попадаем из-за того, что вершину с длительностью больше 1
                                    //по сути представляем просто как цепочку независимых вершин.
                                    if (index.Contains(S0[t])) //TODO find something better
                                    {
                                        j--;
                                    }

                                    //добавляем вершину в упорядочение
                                    else
                                    {
                                        index.Add(S0[t]);
                                    }

                                    //удаляем вершину с списка вершин-кандидатов
                                    S0.RemoveAt(t);
                                }
                            }
                        }
                    }
                }

                if (index.Count > 0)
                {
                    Rez.Add(DeepClone(index) as List <int>);
                    A = Remove(index);
                }
                if (A.Count > 1)
                {
                    Rez.Clear();
                }
            }
        }
Example #2
0
        override public void Build()
        {
            A = DeepClone(mainA) as List <List <int> >;
            Rez.Clear();
            List <int> index = new List <int>(); // номера вершин, которые мы занесли в упорядочение на это место hi
            List <int> S0    = new List <int>();

            for (int i = 0; i < h.Count; i++) //для всех hi
            {
                if (index.Count > 0)
                {
                    Rez.Add(DeepClone(index) as List <int>);
                }
                A = Remove(index);
                index.Clear();
                if (A.Count == 0)
                {
                    return;
                }
                S = FindS(A, 0);
                s = FindS(A, 1);
                int k = 0;
                for (int j = 0; j < h[i]; j++) // не более, чем hi раз             каждый раз добавляем по одной вершине
                {
                    //брать из S[0] уже нечего
                    if ((S0.Count == 0) || (j == 0))
                    {
                        if (k < S.Count) //длина искомого упорядочения не может быть больше числа вершин
                        {
                            //если еще остаслись вершины, которые можно было ставить на прошлом шаге, то ставим их
                            //иначе, т.е. если (S0.Count == 0), ищем новые
                            //   if (S0.Count == 0)
                            //   {
                            S0 = AND(S[k], s[0]);
                            k++;
                            //  }
                        }
                        else
                        {
                            break;
                        }
                    }
                    if (S0.Count > 0)
                    {
                        //берем не рандомные, а те, которые стояли на прошлом шаге.
                        //это не делает хуже, т.к. можно брать любые.
                        int t = findBestFitEasy(S0, Rez);

                        //если попалась вершина, которая уже стоит на этом месте - берем следующую.
                        //в такую ситуацию попадаем из-за того, что вершину с длительностью больше 1
                        //по сути представляем просто как цепочку независимых вершин.
                        if (index.Contains(S0[t])) //TODO find something better
                        {
                            j--;
                        }

                        //добавляем вершину в упорядочение
                        else
                        {
                            index.Add(S0[t]);
                        }

                        //удаляем вершину с списка вершин-кандидатов
                        S0.RemoveAt(t);
                    }
                }
            }
            if (index.Count > 0)
            {
                Rez.Add(DeepClone(index) as List <int>);
                A = Remove(index);
            }
            if (A.Count > 1)
            {
                Rez.Clear();
            }
        }