Блог пользователя yaro

Автор yaro, 13 лет назад, По-русски
А. Зеркальные числа.
Во-первых, заметим, что если интервал содержит число, состоящее из a цифр, а также число из b цифр (где a > b), то нет смысла рассматривать число из b цифр (так как вес числа 10k больше весов чисел, меньших 10k).
Если же рассмотреть числа с фиксированным числом цифр (s + 1), то для них сумма числа и его отражения — константа. Таким образом, учитывая что произведение чисел с фиксированной суммой растет при их сближении, картина у нас следующая: вес числа растет от 10s до 5· 10s -  1, затем он такой же у 5· 10s, затем он убывает и достигает своего минимального значения в 10s + 1 - 1.
Это доказательство, решение же такое: максимальный вес достигается либо в l, либо в r, либо в числах вида 5· 10s (можно, например, проверить все s, такие, что 5· 10s лежит в интервале).


B. И снова тетрис.
Легко видеть, что поле можно замостить фигурками всегда, когда на нем нет изолированных клеток.
Есть множество различных способов сделать это, мы приведем лишь некоторые из них.

1. Замощение доминошками.
Будем строить жадное паросочетание на клетках нашей фигуры объединяя их в доминошки. Идя слева-направо и сверху-вниз по нашей фигуре будем объединять все еще свободные пары соседних горизонтальных клеток, потом проделаем то же самое со все еще свободными клетками и вертикальными доминошками. Естественно, некоторые клетки не попали ни в какую из вертикальных или горизонтальных доминошек. Тем не менее, если клетка не была изолированной, то она прилегает к какой-нибудь из доминошек. Каждую из этих клеток можно отнести к любой из прилегающих к ним доминошек. Так как оставшиеся клетки не могут быть соседними и не могут прилегать к доминошкам слева (в силу порядка нашего обхода) все получающиеся фигурки будут состоять из не более 5 клеток.

Последнее, что осталось сделать — раскрасить наши фигурки указанным в условии образом. Это можно сделать, например так: раскрасим всю плоскость в 9 цветов, клетку (i ,j) в цвет (i % 3) * 3 + j % 3 (красим 3 × 3 в 9 цветов и замощаем им плоскость). Затем красим каждую доминошку в цвет ее черной (при шахматном раскрашивании) клетки. Каждую фигурку красим в цвет
доминошки вокруг которой она образована.

2. Жадность.
Будем снова пробегать массив содержащий поле слева-направо, сверху-вниз и жадно подбирать для каждой все еще свободной клетки фигурку. При этом будем выбирать ее так, чтобы никакая из свободных клеток, после этого не становилась изолированной. А именно будем докидывать к нашей фигуре каждую клетку, которая оказывается изолированной. Сделав это в правильном порядке получим фигурку из не более 5 клеток.

Красить фигурки можно прямо по ходу их образования. Будем просто поочередно выбирать цвет для каждой фигурки, проверяя какие из цветов уже заняты соседними раскрашенными фигурками и выбирая любой из оставшихся. Легко видеть, что 10 цветов хватит.


C. Генная инженерия.
Предположим, мы построили строку wp длины k < n и хотим узнать, сколько существует способов продолжить эту строку до строки длины n, удовлетворяющей условию фильтрации.
Какие параметры нам понадобятся, чтобы строить строку дальше?
Во-первых, нам необходимо знать, до какого места строка уже покрыта (обозначим этот индекс ci и назовем индексом покрытия). Кроме того, на необоходима какая-то информация о том, что находится на конце нашей строки.
Тут на помощь приходит довольно общеизвестная идея: найдем все префиксы ALLP строк \{si\} и добавим к текущему состоянию следующий параметр: наибольший префикс , такой что wp оканчивается строкой pk (в качестве альтернативы, можно рассматривать вершину бора, построенного по строкам из коллекции).
Теперь попробуем понять, почему этого достаточно. Во-первых, когда мы дописываем к wp какой-либо символ c мы можем легко найти pk + 1. pk + 1 будет равно наибольшей строке из ALLP, такой, что pk + c оканчивается на нее (мы можем предподсчитать все такие переходы заранее). Таким образом, единственная вещь, которую нам осталось научиться пересчитывать (чтобы использовать динамическое программирование) — это индекс покрытия. Но мы заметим, что он может измениться лишь какой-либо строкой коллекции, которая стоит на конце wp + c. Теперь заметим, что достаточно рассмотреть только самую длинную из таких строк (обозначим ее fs), и что fs обязательно содержится в pk + 1 (и поэтому тоже легко предвычисляется для всех строк из ALLP). Далее замечаем, что новый индекс покрытия зависит только он длины fs: он либо совпадает со старым, если fs не накрываем символ ci + 1, либо становится равным k + 1, если fs накрывает этот символ.

После вычисления всех величин d[k][k-индекс покрытия][макс. префикс] требуемое количество строк равно сумме d[n][0][mp] по всем префиксам mp.


D. Мощный массив.
Будем решать задачу оффлайн за время O(n sqrt(t)) и O(n) памяти. Для простоты рассуждений будем считать, что запросов n.

Пусть мы знаем ответ к задаче для какого-либо интервала и хотим узнать для другого. Будем двигать левый конец первого к левому концу второго, аналогично поступим с правыми концами. Сдвигая конец на один и поддерживая для каждого числа в массиве количество его вхождений в текущий интервал, мы сможет пересчитывать как нужную нам величину, так и поддерживать вхождения чисел за O(1). Назовем процедуру сдвига на один шагом.

Обход запросов в произвольном порядке, разумеется, обойдется нам в O(nt) шагов.
Пусть p = sqrt(n). Разобьем массив на p равных частей Q_1, ... Q_p. Теперь рассмотрим запросы вида (Q_i, Q_j) по всем i и j (их будет приблизительно n). Очевидно, никакой порядок обхода не даст нам количество шагов, меньшее O(n sqrt(n)), так как на переход от одного интервала к другому в
любом случае потребуется хотя бы sqrt(n) шагов.

Тем не менее, порядок обхода, гарантирующий O(n sqrt(n)) ходов в худшем случае, существует.
Отсортируем интервалы запросов по следующему правилу: сначала идут те, левый конец которых лежит в Q_1, затем те, левый конец которых лежит во Q_2 и так далее до Q_p. Если же левые концы запросов лежат в одной части, то раньше идет тот запрос, у которого правый конец меньше.

Проследим за шагами левых и правых концов при таком подходе. Левые концы в одной группе Q_i совершают <= n / p шагов, при переходе к Q_{i+1} <= 2 * n / p шагов. Поэтому всего левые концы совершают <= n / p * n + 2*n шагов (второе слагаемое порядка O(n), оно неинтересно).
Правые концы в одной группе движутся только вправо, это дает <= n * p шагов в ходе всего процесса, при переходе же к следующему Q_i грубо оценим переход n шагами, поэтому в итоге имеем <= 2 * n * p шагов.
Итого количество шагов <= n/p * n + 2 * n * p. Выбирая p, равное sqrt(n), получаем нужную асимптотику.

Решение: сортируем запросы по описанному правилу, затем в лоб переходим от одного запроса к другому в этом порядке.

Замечание 1. Никакой особенности, кроме неаддитивности, у функций из условия не было.

Замечание 2. В случае n, не равного t, получается оценка 2 * n * sqrt(t), и она точна (если внимательно проследить за доказательством, легко построить подпирающий оценку тест).



E. Длинная последовательность.

Для начала заметим, что есть только 49 вариантов входных данных.
Поэтому решения, которое предподсчитает все ответы за конечное время (даже если оно будет превышать лимит) будет вполне достаточно.

Для начала решим чуть более частную задачу. Предположим, что c1, c2, ..., ck и a0, a1, ..., ak - 1 нам уже даны и мы хотим проверить является ли последовательность {ai} построенная по ним длинной. Если она периодична, то среди k-кортежей as, as + 1, ..., as + k - 1 встречаются все ненулевые k-кортежи. Поэтому нет разницы с какого из них начинать последовательность. Поэтому свойство последовательности <<быть длинной>> зависит только от ci, и a0, a1, ..., ak - 1 мы можем выбрать любыми удобными. Будем теперь считать, что a0, a1, ..., ak - 2 --- нули и ak - 1 = 1.

Рассмотрим матрицу перехода A последовательности: при i < k ее i-ая строка равна (0, 0, ... 0, 1, 0, ..., 0), где 1 стоит на (i + 1)-ой позиции, а последняя строка равна (ck, ck - 1, ..., c2, c1).

Обозначим xs вектор-столбец (as, as + 1, ..., as + k - 1)T.
Тогда для любого целого s: A· xs = xs + 1.
Последнее равенство это просто переформулировка рекуррентного соотношения:

an = c1 * an - 1 + c2 * an - 2 + ... + ck * an - k.


Тогда, применяя A последовательно получаем: Ap· xs = xs + p для любого p ≥ 0. Таким образом p --- период тогда и только тогда, когда для всякого вектора x, появляющегося в нашей последовательности: Ap· x = x. Если последовательность не длинная, то априори не очевидно, что Ap единичная матрица, поскольку x принимает не все возможные значения. 

Но мы выбрали x0 = (0, 0, ..., 0, 1), поэтому ясно, что вектора x0, x1, x2, ..., xk - 1 образуют базис. Отсюда если Ap· xi = xi для всякого i, то Ap --- единичная матрица.

Таким образом, нам достаточно сделать следующее:

1) Построить матрицу A по коэффициентам ci.

2) Проверить, что A2k - 1 --- единичная матрица. (Если нет, то 2k - 1 не период.)
Если 2k - 1 период, то нам осталось проверить, что он минимальный. Любой период делится на минимальный, поэтому нам надо проверить лишь делители 2k - 1.

3) Построить все максимальные делители 2k - 1 и проверить, что они не периоды (снова с помощью A).

(Под максимальным делителем n подразумевается делитель вида n/q, где q --- простое).

Все что нам осталось заметить, так это то, что такие последовательности всегда существуют. Более того, количество подходящих наборов ci довольно велико. Можно показать, что их ровно (так как они соответствуют коэффициентам неприводимых множителей круговых многочленов над ). Поэтому можно просто брать произвольный набор и проверять его, достаточно скоро мы получим подходящий.

  • Проголосовать: нравится
  • +52
  • Проголосовать: не нравится

13 лет назад, # |
  Проголосовать: нравится +2 Проголосовать: не нравится
а можно открыть или как-нибудь получить 11 тест на 2-ую задачу?
  • 13 лет назад, # ^ |
      Проголосовать: нравится 0 Проголосовать: не нравится
    Тест большой, думаю, его можно посмотреть в my submissions.
    • 13 лет назад, # ^ |
        Проголосовать: нравится 0 Проголосовать: не нравится
      Полностью большие тесты смотреть нельзя
    • 13 лет назад, # ^ |
        Проголосовать: нравится 0 Проголосовать: не нравится
      в my submissions есть только его начало..
      а хотелось бы посмотреть весь, потому что в начале ошибочной фигуры нету. (совпадает с авторским ответом)
      • 13 лет назад, # ^ |
          Проголосовать: нравится +6 Проголосовать: не нравится
        я нашел тест на котором моя программа не работает, может и вам поможет:
        5 5
        #.#.#
        ....#
        #.###
        #####
        #####
      • 13 лет назад, # ^ |
        Rev. 2   Проголосовать: нравится +8 Проголосовать: не нравится

        Ага, понятно. Вот этот тест: http://rghost.ru/7464901.
        Если потребуется, в какой-то момент могу сказать проблемную клетку.
        Upd. Ну вот, уже и не надо, наверное...
        • 13 лет назад, # ^ |
            Проголосовать: нравится 0 Проголосовать: не нравится
          Огромное спасибо, тест я все же, гляну. возможно у меня не 1 ошибка.
13 лет назад, # |
  Проголосовать: нравится -17 Проголосовать: не нравится
"Легко видеть, что поле можно замостить фигурками всегда, когда на нем нет изолированных клеток."
Это не очень хорошее доказательство для контеста такого уровня.   Можно поподробней? 
  • 13 лет назад, # ^ |
      Проголосовать: нравится +1 Проголосовать: не нравится
    Роман, прежде чем выступать с такими заявлениями, дочитайте до конца. Далее как раз описаны два решения с обоснованием.
  • 13 лет назад, # ^ |
      Проголосовать: нравится 0 Проголосовать: не нравится
    Прочитайте описание первой конструкции, например. Там доказано, что в случае отсутствия изолированных клеток получится верное замощение.
13 лет назад, # |
  Проголосовать: нравится +27 Проголосовать: не нравится
Задачи D и E просто офигенные. Жаль, что я не осилил ни одну на контесте: после разборов они кажутся вполне решаемыми.
13 лет назад, # |
Rev. 3   Проголосовать: нравится +10 Проголосовать: не нравится

Моё асимптотически верное решение D не прошло систесты, завалилось по ТЛ. C++. я конечно сам дурак, можно было пооптимизировать умножения, но все же.

в коде присутствует константа K = 1100, подобранная экспериментально, на рандомных тестах в разделе "запуск". Если взять K из [400...900] то проходит по времени, видимо сервер налажал (может загружен был?), когда показывал мне 6-7 сек при таком малом значении K. 4 сек без ввода-вывода показалось мне приемлемым временем. хуже всего что надо формулы извращать для скорости, убрать умножения лонг лонгов.

  • 13 лет назад, # ^ |
      Проголосовать: нравится +8 Проголосовать: не нравится
    о таких ситуациях уже был пост. может стоит еще раз его глянуть тем кто готовил задачи.
    • 13 лет назад, # ^ |
        Проголосовать: нравится +13 Проголосовать: не нравится
      Замечательный пост, читали его, когда готовили раунд. Понимаю, что Вы можете быть в растроенных чувствах, но выставленные ограничения согласуются с тем, о чем писал Александр. Прохождение систестов асимптотически неправильными решениями равно как и асимптотическими правильными решениями с большой константой было совсем не в наших интересах (учитывая, что они есть и идейно проще). Ограничения были увеличены, TL тоже (см. пост). Далее, авторское решение на java без оптимизации работает 2.5 секунды на макс. тесте, на C++ то же решение работает 1 секунду. Выставленное ограничение в 5 секунд обоснованно.
      Стоит отметить, что в авторском решении нет констант, которые могут повлечь за собой недоказанную верхнюю оценку времени работы.
      • 13 лет назад, # ^ |
        Rev. 4   Проголосовать: нравится +13 Проголосовать: не нравится

        Зачем вы говорите "Стоит отметить, что в авторском решении нет констант, которые могут повлечь за собой недоказанную верхнюю оценку времени работы." это намек на то что у меня она недоказанная? Я даже было собрался писать вам формулы этой оценки, но потом подумал что вы без труда сами это сделаете, вы их так любите что в задаче на структуры данных соптимизировали умножения 64 битных чисел. Думаю без этого авторские решения не обошлись. В упомянутом посте просили писать медленные решения, но вы не сочли это разумным.

        PS: обращение "вы" направлено не к вам лично, а к авторам конечно.
        • 13 лет назад, # ^ |
            Проголосовать: нравится +13 Проголосовать: не нравится
          Хорошо, я даже отвечу на не очень адекватные обвинения. Никаких оптимизаций в авторском решении не было. Среди проверенных решений есть одно крайне плохо написанное, и оно работает 2.5 секунды на C++. Грех жаловаться.
          В упомянутом посте просили писать медленные плохие решения, те, что не должны проходить ("...это существенно снизит вероятность проталкивания всякой ерунды на контесте"). Такая работа была проделана.
          • 13 лет назад, # ^ |
              Проголосовать: нравится 0 Проголосовать: не нравится
            Точно, имелось в виду писать асимптотически медленные решения. Но это не умаляет того факта, что нельзя писать авторские решения с чрезмерными оптимизациями. Как правило лучшее решение в архиве задач во много раз обгоняет ТЛ задачи, но выставленый ТЛ разумен.  
            • 13 лет назад, # ^ |
                Проголосовать: нравится +5 Проголосовать: не нравится
              Про чрезмерные оптимизации я полностью согласен. Тут ведь штука в том, что в описанном в разборе решении они не нужны и непонятно (хотя бы мне), как их проделать. Авторское решение было написано один раз и больше не модифицировалось.
              Чтобы не быть голословным, предлагаю посмотреть, например, решение Petr'a. Могу показать и авторское, если захотите.
              • 13 лет назад, # ^ |
                  Проголосовать: нравится 0 Проголосовать: не нравится
                Хочу, если не сложно покажите.
                • 13 лет назад, # ^ |
                    Проголосовать: нравится 0 Проголосовать: не нравится
                  http://pastie.org/1961351
                  На самом деле, это совсем первый вариант, его еще можно улучшить (но я не стал).
                  Решение Петра, кстати, совсем не использует объекты. У вас вектора, может, в этом дело?
                  • 13 лет назад, # ^ |
                      Проголосовать: нравится 0 Проголосовать: не нравится
                    нет не в этом, на указатлях со статическим выделением памяти работает на 100 мс меньше.
                  • 13 лет назад, # ^ |
                      Проголосовать: нравится 0 Проголосовать: не нравится
                    здесь кстати крутая оптимизация - все числа перенумерованы, что увеличивает преимущества кеша процессора.
                    • 13 лет назад, # ^ |
                      Rev. 2   Проголосовать: нравится 0 Проголосовать: не нравится

                      ———————————————
                      Это делалось из расчета отсутствия ограничений на ai. Без этой перенумерации тоже нормально.
                      Upd. И в L1 все равно не поместится.
              • 13 лет назад, # ^ |
                  Проголосовать: нравится +8 Проголосовать: не нравится
                думаю решение Petr'a не стоит ставить в пример, наверное его решения в среднем лучше среднего, простите за каламбур.
                • 13 лет назад, # ^ |
                    Проголосовать: нравится 0 Проголосовать: не нравится
                  Да, это я зря. У него, кстати, та же идея обхода в "корневом" порядке, но уж очень красиво реализована.
          • 13 лет назад, # ^ |
              Проголосовать: нравится +5 Проголосовать: не нравится

            вот моё решение, где вместо K = 1100, K = sqrt(n)

            решение работает 4920 секунд, и что же там такого плохого, что ваше "крайне плохо написанное", вдвое его обгоняет?

            • 13 лет назад, # ^ |
                Проголосовать: нравится +22 Проголосовать: не нравится
              Конечно, многие со мной не согласятся, но на мой взгляд намного лучше когда не проходят плохо реализованные решения с правильной асимптотикой, чем когда проходят хорошо написанные с неправильной. Все таки если плохо написал - сам виноват, а если не написал то, что не должно проходить, а оно проходит, то сказать что сам виноват сложно.

              Конкретно по поводу вашего случая. Из того почему медленно могу предположить только то, что у вас много мелких векторов, которые еще и постоянно что-то пытаются в себя добавлять и удалять. При этом память постоянно перераспределяется и приходится по ней бегать, что не есть хорошо. еще я когда-то слышал, что clear может убить память как-то очень хитро и вообщем-то не убить ее. Тогда у вас памяти становится еще больше, и все тормозит еще сильнее. И еще, если бы решение авторов действительно было бы слишком соптимизировано, то таких проблем было бы намного больше.

              Кстати не вижу ничего плохого и в том, когда решение надо по оптимизировать, чтобы оно прошло. Но в соревнованиях когда есть больше времени и тестирование он-лайн.
              • 13 лет назад, # ^ |
                Rev. 2   Проголосовать: нравится 0 Проголосовать: не нравится

                так в том то дело, что здесь оффлайн тестирование, понятно я бы смог убрать лишние произведения, еслибы получил ТЛ. А считать все наизнанку в страхе от того что решение получит ТЛ это совсем не правильно, я надеялся на то, что ТЛ выставлен разумно, и такие вещи будут лишними, ну то есть я даже не задумывался чтобы так низкоуровнево оптимизировать. Кстати вектора имеют суммарную длину t, поэтому проблем здесь быть не должно. Списки ускорили на 100 мс.
                • 13 лет назад, # ^ |
                  Rev. 2   Проголосовать: нравится 0 Проголосовать: не нравится

                  Я бы назвал это действие скорее "антиоптимизированием", не обижайтесь. Мне бы в голову не пришло так странно превращать i2 в (i + 1)2.
                  Upd. Если вы имели в виду вектора, то извиняюсь.
                  • 13 лет назад, # ^ |
                    Rev. 2   Проголосовать: нравится 0 Проголосовать: не нравится

                    res -= F(x)

                    x=G(x);

                    res += F(x);

                    не думаю что вы бы стали искать здесь какую-то интерпретацию выражения F(G(x)) - F(x), если она сразу не бросилась вам в глаза, а мне не бросилась, и вы знали что F и G работают O(1), а точнее одна-две команды процессора.

                • 13 лет назад, # ^ |
                    Проголосовать: нравится +8 Проголосовать: не нравится
                  Я верю что решение доводилось до ОКа и более нормальными оптимизациями. И еще немного про слишком оптимизированные авторские решения. Автор может просто не заметить что его решение "слишком оптимизированное" - он просто так пишет всегда. Конечно на это обычно делается поправка при выставлении ТЛ, но мне кажется тут он выставлен разумно.

                  P.S. Вспомнился случай со сборов, когда задачка решалась за Nlog2n двумерным деревом или за  квадрадеревом. В основном пытались сдать в дорешивание второе. Не получалось. Потом пришел Сергей. Первая же его реализация за  работала в два раза быстрее, чем все Nlog2n участников.

                  Кстати, тут становится очень узко, если хочется продолжать диалог, лучше его вывести куда-то еще.
              • 13 лет назад, # ^ |
                  Проголосовать: нравится +13 Проголосовать: не нравится
                Плохо когда надо пооптимизировать то, что потом как грибы после дождя растут гневные треды и топики. И не так уж незаслуженно. Разные языки-компиляторы, разные руки и у авторов, правда:) Но адекватного решения этому не видать. Разве что АСМ резко перейдет на формат GCJ :)
  • 13 лет назад, # ^ |
      Проголосовать: нравится +8 Проголосовать: не нравится
    Дело в том, что как раз самые часто-исполняемые и трудоемкие операции Ваше решение выполняет очень долго. Посмотрите на эту посылку. Она отличается от Вашей, упавшей на контесте, только 2 строчками, считающими разность соседних квадратов и заходит за 3 секунды.
    • 13 лет назад, # ^ |
        Проголосовать: нравится 0 Проголосовать: не нравится
      я такое уже сделал, но считаю это неправильно, разворачивать логичное произведение, в такую штуку, чтобы задача зашла.
13 лет назад, # |
  Проголосовать: нравится 0 Проголосовать: не нравится
ответ к комментарию kuniavski, более нормальные оптимизации это просто заменить K = 1100 на K = 700, решение зашло за 4360 мс. Ну уберём вектора, получим 4260. Ладно, а что нужно сделать с моим решением чтобы оно на яве зашло? Согласен с тем что я виноват сам, мог пооптимизировать. Но то, что ограничения и тайм лимит были подобраны хорошо, я не считаю.
  • 13 лет назад, # ^ |
      Проголосовать: нравится 0 Проголосовать: не нравится
    Вывод printf вместо cout, всетаки где-то мегобайт выводить. Можно не брать size 10 миллионов раз. Еще я верю что замена векторов на написанные ручками списки на статической памяти даст сильно большую выгоду. Вообще если действительно интересно что тормозит, то можно попросить тест, на котором медленно работает и скормить код grof'у.
    • 13 лет назад, # ^ |
      Rev. 3   Проголосовать: нравится 0 Проголосовать: не нравится

      про список я уже сказал и скажу снова, раз не увидели - 100 мс экономии,  cout рекомендуют авторы

      UPD: 

      size_type size() const
      { // return length of sequence
      return (_Myfirst == 0 ? 0 : _Mylast - _Myfirst);
      }

      • 13 лет назад, # ^ |
          Проголосовать: нравится 0 Проголосовать: не нравится
        Про список могу предложить посмотреть код. Может мы немного о разных вещах говорим.  Ну это все равно 2 операции, а если она еще и не inline...
        • 13 лет назад, # ^ |
          Rev. 2   Проголосовать: нравится 0 Проголосовать: не нравится

          сисок 4750 мс.
          UPD: printf сэкономил еще 20 мс
          • 13 лет назад, # ^ |
            Rev. 2   Проголосовать: нравится 0 Проголосовать: не нравится

            А hp обнулять между итерациями не надо? Еще end можно делать memset вместо цикла с какими-то проверками.
            Про cout, если я правильно понял о чем речь, то авторы его рекомендуют, чтобы выводить без ошибок а не быстро.Ладно, переоценил тормознутость.
            Еще из оптимизаций кажущихся адекватными: другой язык(MinGw вместо С++), предподсчитать какие запросы, которые годятся в условия с которыми кладете в end и что-то пересчитываете. 
            • 13 лет назад, # ^ |
              Rev. 2   Проголосовать: нравится 0 Проголосовать: не нравится

              язык итак MinGW, такчто вообще чудом задача входит, хотя она без безумств в общем-то написана.
              • 13 лет назад, # ^ |
                  Проголосовать: нравится 0 Проголосовать: не нравится
                Иногда наоборот быстрее, стоит оба попробовать. В прочем, оптимайз с пересчетом квадратов достаточно адекватен.
  • 13 лет назад, # ^ |
      Проголосовать: нравится 0 Проголосовать: не нравится
    Рас уж пошла такая пьянка: http://www.everfall.com/paste/id.php?jsoly5yehvoa без всяких шаманств, на MS VS C++ 3390ms, на GNU 2750.
13 лет назад, # |
  Проголосовать: нравится -8 Проголосовать: не нравится
Что значит "wrong output format Token """ в задаче B про тетрис? Тест выше смотрел, проходит, а здесь не пашет...
  • 13 лет назад, # ^ |
      Проголосовать: нравится +8 Проголосовать: не нравится
    посмотрел отсылку...
    в этом посте есть 11 тест, скопал проверил...
    нашел баг вот тут
                   if (ii>=0 && ii<m && j>=0 && jj<n) {
    а надо
                   if (ii>=0 && ii<m && jj>=0 && jj<n) {
13 лет назад, # |
  Проголосовать: нравится +5 Проголосовать: не нравится
It would have been great if you could submit your solution and give the link to your solution. Or atleast we could see through history of submission.
»
8 лет назад, # |
  Проголосовать: нравится 0 Проголосовать: не нравится

86C - Генная инженерия

This 467737 solution from natalia uses a similar approach like the editorial and its easier to understand.

The 3 dp states are:

[computed length]

[corasick state no] //each whole string and all of their possible prefixex gets considered

[unmatched char count from right]

»
3 года назад, # |
  Проголосовать: нравится 0 Проголосовать: не нравится

Can problem D be solved using Segment trees?

  • »
    »
    5 месяцев назад, # ^ |
      Проголосовать: нравится -10 Проголосовать: не нравится

    May be using Freq map at each node ? But how do we merge nodes ? I am not sure of complexity of merging. I can only think of using maps in each node but merging 2 maps takes O(nlogn) ?I dont think this will pass

  • »
    »
    3 недели назад, # ^ |
      Проголосовать: нравится 0 Проголосовать: не нравится

    Can u propose one such solution?

»
5 месяцев назад, # |
  Проголосовать: нравится -10 Проголосовать: не нравится

Nice Editorial for Problem D I learnt a lot from it