Уважаемые пользователи сайта , пожалуйста поделитесь хорошим классом Длинки(+,-,/,%,*). Свой писал но вроде медленный. Не получается модернизировать. Хорошим в смысле быстрой роботы .
это да но ведь не в 6 раз ? ... хотя времени на преобразование тратиться гораздо больше . Как вы думаете это существенно влияет на время работы и как лучше это реализовать?
Я обычно юзаю JAVA для этого но бывает мозгов не хватает написать быстрое решение и приходится кодить на С++.По этому хочу у опытных опросить проверенный временем class :)
Задача «A2+...+B2» с последнего гран-при Удмуртии с Опенкапа. Там такие большие числа, что BigInteger не успевает преобразовать их в двоичную систему счисления. Если реализовать свою арифметику, которая пользуется десятичным основанием для внутреннего представления, то все будет ок. Правда эта задача и без длины нормально решается.
Нам рассказывали на лекциях что для Cnk лучше как раз написать свой собственный класс чем в явку загонять. Даже если считаешь умнее чем делением одного факториала на два других.
тут через вектор :) не плохо но как я заметил , даже не знаю почему но по ходу вектор дольше работает чем обычный массив ... (кстати интересно почему? если это правдатак )
Может быть если не делать много push_back'ов, а выделить сразу памяти сколько надо через resize, то вектор будет работать также быстро как и обычный массив.
Хотя я хз, сам бы хотел узнать где вектор и в чем проигрывает, если проигрывает.
Есть догадка что при push_back'ах создается еще один вектор на 1 элемент больше, ну и дальше там идет переадресация. Просто кто-то мне рассказал что на операцию push_back() вектор тратит в два раза больше памяти чем нужно. Этот человек так же рассказал что на операцию pop_back() вектор тратит в 4 раза больше чем нужно(интересно, почему). Но если действительно все делать через resize() то время экономится.
push_back работает так: если выделенной памяти не хватает для очередного элемента, то создается новый вектор в два раза большего размера, куда копируется содержимое старого. Такое удвоение позволяет работать пуш-бэку за амортизированную константу.
Ошибаюсь: в gcc аналогичный результат. Однако, fetertriste по сути прав. ~1.5 - более кошерное значение для памяти и используется в некоторых реализациях.
Оптимизация ДА зависит от конкретного случая Можно сделать крайне быструю длинку со следующими эвристиками: 1. использовать 10^k как основание системы счисления, если результат нужен десятичный. 2. использовать кэширование при умножении на короткое. и т.п.
В Харькове на сборах рассказывался алгоритм Карацубы и Быстрое преобразование Фурье. Эти алгоритмы выполняют умножение за NlogN. При этом как я понял БПФ лучше работает с базой 10, а не 10^9.
В случае если необходимо реализовать операцию сложения, то стоит избавляться от долгой операции %. Были задачи, когда эта оптимизация спасает.
Аналогичный случай с умножением за N^2. Необходимо избавиться от %. Дмитрий Жуков говорил, что подобная оптимизация может помочь, даже в том случа если на первый взгляд решение пройти не может.
В БПФ с базой 10^9 происходят на больших числах(1000 знаков) какие-то странные то ли переполнения, то ли потери точности. Факт в том что несколько(штук 8-10) последних знаков наверняка неправильна. Не знаю, я где-то лажал или еще что, но если ставить основание поменьше(10^4 , например) - то все ок.
http://www.everfall.com/paste/id.php?fhelgcbkw1cf
вот весьма эффективная длинка, битовый подход, основание 2^32
многое можно соптимизировать, но это я писал давно и небыло цели особо извращатся.
реализация деления за n^2 * log(base) = n^2 * 32, можно за n^2 реализовать по кнуту, по моим тестам
в 6 или 12 раз быстрее если цифру брать за 8 или 16 бит соответственно
#include <stdio.h>
#include <vector>
std::vector < int > v;
int main() {
for (int i = 0; i < 100; i++) {
printf("Size and Capacity before push back: %d %d\n", v.size(), v.capacity());
v.push_back(1);
printf("Size and Capacity after push back: %d %d\n", v.size(), v.capacity());
}
return 0;
}
Если не ошибаюсь, это всё ваша студия шалит.Вот, а оттуда по ссылкам
Можно сделать крайне быструю длинку со следующими эвристиками:
1. использовать 10^k как основание системы счисления, если результат нужен десятичный.
2. использовать кэширование при умножении на короткое.
и т.п.
В Харькове на сборах рассказывался алгоритм Карацубы и Быстрое преобразование Фурье. Эти алгоритмы выполняют умножение за NlogN. При этом как я понял БПФ лучше работает с базой 10, а не 10^9.
В случае если необходимо реализовать операцию сложения, то стоит избавляться от долгой операции %. Были задачи, когда эта оптимизация спасает.
Аналогичный случай с умножением за N^2. Необходимо избавиться от %. Дмитрий Жуков говорил, что подобная оптимизация может помочь, даже в том случа если на первый взгляд решение пройти не может.
Как я понял БПФ чем меньше база тем лучше. Карацуба, если я не ошибаюсь, Nlog1.5N
https://acmp.ru/article.asp?id_text=1329