Сохранение неизвестного количества целых чисел, не занимая слишком много времени / памяти

Question

Сохранение неизвестного количества целых чисел, не занимая слишком много времени / памяти

0

#include <iostream>

using namespace std;

unsigned long long divsum(unsigned long long x);

int main()
{
    unsigned long long x;
    cin >> x;
    unsigned long long y[200000];
    for (unsigned int i = 0; i < x; i++)
        cin >> y[i];
    for (unsigned int i = 0; i < x; i++){
        cout << divsum(y[i]) << endl;
    }
    return 0;
}

unsigned long long divsum(unsigned long long x){
    int sum = 0;
    for(unsigned int i = 1; i <= x/2; i++){
        if(x % i == 0)
            sum += i;
    }
    return sum;
}

Я делаю онлайн-упражнение, и он говорит, что в первой строке есть 2000000 дел, поэтому я сделал массив этой суммы, однако, когда я отправляю решение, оно превышает время. Поэтому мне было интересно, что такое альтернатива и более быстрый способ сделать это? Программа работает отлично сейчас, за исключением того, что она превышает срок действия веб-сайта.

user3002211 20 нояб. 2013, в 21:07

Источник

1

Вы должны сказать, что должен делать алгоритм, чтобы дать вам лучшие способы его реализации ...
Daniel Conde Marin 20 нояб. 2013, в 19:54
0

Простой вызов std::transform должен работать нормально. Конечно, он также не может иметь побочных эффектов, поэтому он может не зависеть от того, как вы определяете divsum .
chris 20 нояб. 2013, в 19:55
1

Если ваше решение превышает время, проблема обычно заключается в сложности алгоритма, а не в используемой памяти. Однако вы можете использовать std::vector<unsigned long long> y(x) чтобы уменьшить использование памяти.
Nemanja Boric 20 нояб. 2013, в 19:56
0

Вы выделяете массив 1,5 Мб в стеке - он может быть длинным и может привести к сбою.
Nazar554 20 нояб. 2013, в 19:58
0

Поскольку речь идет только о времени, а не о памяти ..... попробуйте const & в divsum, т.е. const unsigned long long divsum & (const unsigned long long & x) Также в цикле for .... предварительно вычислите x/2 Вы можете использовать Векторы для памяти, но они имеют перегрузку push_back, а также для копирования всего вектора, когда он должен изменить размер
theAlias 20 нояб. 2013, в 19:59
0

Попробуйте тривиальное divsum которое всегда возвращает 12 , и посмотрите, отклоняется ли оно из-за того, что оно занимает слишком много времени. Если так, то проблема не в divsum .
Beta 20 нояб. 2013, в 20:01
1

Вы, вероятно, также должны заметить, что с 2000000 (двумя миллионами) наблюдений и массивом из 200000 (двести тысяч) элементов вы вполне можете вызывать неопределенное поведение, если x превышает размер вашего массива (и вам не нужен независимо от массива, поэтому я не вижу, что вы надеетесь получить от него).
WhozCraig 20 нояб. 2013, в 20:01
0

Алогирт должен найти сумму делителей определенного числа. В первой строке мы вводим число 0 <= 200000 от того, сколько чисел последует за ним. И мы выводим каждую сумму в новой строке после ввода всех чисел.
user3002211 20 нояб. 2013, в 20:01
0

Возможно, вам следует рассмотреть, что на самом деле делает алгоритм. Например, нет необходимости перечислять в x/2 . Вам нужно только перечислить в sqrt(x) . У каждого найденного вами делителя есть соответствующий аналог на другой стороне квадратного корня. Т.е. если вы знаете, что 2 является фактором, то вы также знаете, что x/2 является фактором. Если 3 является фактором, то будет x/3 и т. Д. У каждого найденного вами фактора будет аналог, и, возможно, включая sqrt(x) (но только если x является идеальным квадратом), по одному фактору по обе стороны от корень. Я предлагаю вам пересмотреть этот алгоритм.
WhozCraig 20 нояб. 2013, в 20:08
0

Распределение памяти, независимо от размера, должно быть одноразовым событием в вашей программе. Выделение памяти не является причиной снижения производительности. Каков был результат вашего профилирования?
Thomas Matthews 20 нояб. 2013, в 20:24
0

Вам нужно хранить все результаты или вы можете выводить их по ходу дела?
Thomas Matthews 20 нояб. 2013, в 20:26
0

@ThomasMatthews Сохраните их все и затем выведите.
user3002211 20 нояб. 2013, в 20:26
0

Я прошу прощения за то, что настаивал на этом, но серьезно, прочитайте мой предыдущий комментарий и проверьте ваш алгоритм. Смотрите это в прямом эфире .
WhozCraig 20 нояб. 2013, в 20:37
0

@WhozCraig На самом деле, я думаю, что это неправильно, потому что, например, число 20, sqrt (20) равно 4.4721, поэтому он находит только делители 2 и 4?
user3002211 20 нояб. 2013, в 20:40
0

@user3002211 user3002211 Вы не правы, он находит делители 2, 20/2, 4 и 20/4. сложив их все вместе, получим 21 всего. Что-то, что я пытался сделать. Вам нужно только проверить через корень квира, а не до X/2 . Я обновил тестовые данные в размещенной ссылке, чтобы продемонстрировать ваш результат 20 (то есть 21, если я не понимаю ваш алгоритм). Если целью является сложение простого дерева факторизации , то рекурсивное решение может быть расширено. В любом случае, нет смысла выходить за рамки sqrt(x)
WhozCraig 20 нояб. 2013, в 23:05

Показать ещё 13 комментариев

Теги:

c++

arrays

memory

2 ответа

Ещё вопросы

Вы должны сказать, что должен делать алгоритм, чтобы дать вам лучшие способы его реализации ...
Простой вызов std::transform должен работать нормально. Конечно, он также не может иметь побочных эффектов, поэтому он может не зависеть от того, как вы определяете divsum .
Если ваше решение превышает время, проблема обычно заключается в сложности алгоритма, а не в используемой памяти. Однако вы можете использовать std::vector<unsigned long long> y(x) чтобы уменьшить использование памяти.
Вы выделяете массив 1,5 Мб в стеке - он может быть длинным и может привести к сбою.
Поскольку речь идет только о времени, а не о памяти ..... попробуйте const & в divsum, т.е. const unsigned long long divsum & (const unsigned long long & x) Также в цикле for .... предварительно вычислите x/2 Вы можете использовать Векторы для памяти, но они имеют перегрузку push_back, а также для копирования всего вектора, когда он должен изменить размер
Попробуйте тривиальное divsum которое всегда возвращает 12 , и посмотрите, отклоняется ли оно из-за того, что оно занимает слишком много времени. Если так, то проблема не в divsum .
Вы, вероятно, также должны заметить, что с 2000000 (двумя миллионами) наблюдений и массивом из 200000 (двести тысяч) элементов вы вполне можете вызывать неопределенное поведение, если x превышает размер вашего массива (и вам не нужен независимо от массива, поэтому я не вижу, что вы надеетесь получить от него).
Алогирт должен найти сумму делителей определенного числа. В первой строке мы вводим число 0 <= 200000 от того, сколько чисел последует за ним. И мы выводим каждую сумму в новой строке после ввода всех чисел.
Возможно, вам следует рассмотреть, что на самом деле делает алгоритм. Например, нет необходимости перечислять в x/2 . Вам нужно только перечислить в sqrt(x) . У каждого найденного вами делителя есть соответствующий аналог на другой стороне квадратного корня. Т.е. если вы знаете, что 2 является фактором, то вы также знаете, что x/2 является фактором. Если 3 является фактором, то будет x/3 и т. Д. У каждого найденного вами фактора будет аналог, и, возможно, включая sqrt(x) (но только если x является идеальным квадратом), по одному фактору по обе стороны от корень. Я предлагаю вам пересмотреть этот алгоритм.
Распределение памяти, независимо от размера, должно быть одноразовым событием в вашей программе. Выделение памяти не является причиной снижения производительности. Каков был результат вашего профилирования?
Вам нужно хранить все результаты или вы можете выводить их по ходу дела?
@ThomasMatthews Сохраните их все и затем выведите.
Я прошу прощения за то, что настаивал на этом, но серьезно, прочитайте мой предыдущий комментарий и проверьте ваш алгоритм. Смотрите это в прямом эфире .
@WhozCraig На самом деле, я думаю, что это неправильно, потому что, например, число 20, sqrt (20) равно 4.4721, поэтому он находит только делители 2 и 4?
@user3002211 user3002211 Вы не правы, он находит делители 2, 20/2, 4 и 20/4. сложив их все вместе, получим 21 всего. Что-то, что я пытался сделать. Вам нужно только проверить через корень квира, а не до X/2 . Я обновил тестовые данные в размещенной ссылке, чтобы продемонстрировать ваш результат 20 (то есть 21, если я не понимаю ваш алгоритм). Если целью является сложение простого дерева факторизации , то рекурсивное решение может быть расширено. В любом случае, нет смысла выходить за рамки sqrt(x)

theAlias · Answer 1 · 2013-11-20T18-15-00.000Z

Поскольку вы знаете размер массива, попробуйте vector и reserve.

 int main()
    {
        unsigned long long x;
        cin >> x;
         unsigned long long var;
         vector<unsigned long long> y;
         y.reserve(x);
         for (unsigned int i = 0; i < x; i++){
          cin >> y[i];
         }for (unsigned int i = 0; i < x; i++){
           cout << divsum(var) << endl;
        }
        return 0;
    }

И дело в const &

const unsigned long long & divsum(const unsigned long long & x){
    int sum = 0;
    unsigned long long x2 = x/2
    for(unsigned int i = 1; i <= x2; i++){
        if(x % i == 0)
            sum += i;
    }
    return sum;
}

Что если упражнение ожидает, что весь ввод из stdin должен быть прочитан перед выводом?
Я знаю, что это возможно, но программа требует сначала ввести все цифры, а затем вывести результаты.
Хорошо. Позвольте мне отредактировать это, чтобы дать лучший ответ, придерживаясь требования
Почему мы должны использовать & здесь? Извините, если это нубский вопрос, я все еще начинающий с указателями.
& в объявлении здесь подразумевается, что я объявляю ссылку, а не указатель. Ссылка указывает на тот же объект, который передается, избегая копирования. Таким образом, в приведенном выше коде вы избегаете другой копии long long краткого обзора: parashift.com/c++-faq/overview-refs.html

Nazar554 · Answer 2 · 2013-11-20T18-06-00.000Z

Вы можете распределить массив динамически, поэтому он будет работать лучше в тех случаях, когда x < 200000

int main()
{
    unsigned long long x;
    cin >> x;
    unsigned long long *y = new unsigned long long[x];
    // you can check if new didn't throw an exception here
    for (unsigned int i = 0; i < x; i++)
        cin >> y[i];
    for (unsigned int i = 0; i < x; i++){
        cout << divsum(y[i]) << endl;
    }
    delete[] y;
    return 0;
}

Как массив в динамической памяти работает лучше, чем массив в стеке или в глобальной памяти? Все должны иметь одинаковую схему адресации, если динамическая память не выгружена на диск или что-то еще.
@ThomasMatthews Программа выделяла массив из 200000 элементов при каждом запуске. Это означает, что даже если x меньше 200000, он по-прежнему выделяет больше памяти, чем нужно, и тратит на это время.
@ Nazar554, что буквально означает не что иное, как изменение размера N в инструкции sub esp, N Это будет иметь нулевой эффект на время. Однако это может оказать значительное влияние на переполнение стека.