Alexandroppolus

Этот паззл можно решать вообще без циклов, за О(1)

class Solution {
private:
    int sumAP(int n, int m) {
        int c = n / m;
        return m * c * (c + 1) / 2;
    }
public:
    int sumOfMultiples(int n) {
        return sumAP(n, 3) + sumAP(n, 5) + sumAP(n, 7)
        - sumAP(n, 3 * 5) - sumAP(n, 3 * 7) - sumAP(n, 5 * 7)
        + sumAP(n, 3 * 5 * 7);
    }
};

см. сумму арифметической прогрессии, и "принцип включения-исключения"

Переделай матрицу инцидентности в матрицу смежности

Тут можно заметить вот что.
1) если идем вверх, то обратный путь будет по тем же этажам:
туда 12-23-46, обратно 46-23-12
2) если идем вниз, то обратный путь может пойти по другим этажам:
туда 12-6, обратно 6-11-22-43

итого, решение простое - тебе сначала надо пройти от 12 вверх
потом от 12 спуститься до 6 и пройти вверх
потом от 6 спуститься до 3 и тоже пройти вверх (здесь выходим на предыдущий стартовый этаж 6, завершаем)
от 3 к 2 и тоже вверх
и т.д.
т.е. каждый раз спускаться вниз на одну, после чего идти вверх, если не попали на предыдущий стартовый.

код на js

function floorCount(start, max) {
    let result = 0;
    let prevStart = -1;
    
    while (start > 0) {
        for (let x = start; x <= max && x !== prevStart; x = x % 2 ? 2 * x : 2 * x - 1) {
            result++;
        }
        prevStart = start;
        start = start < 2 ? 0 : start % 2 ? (start + 1) / 2 : start / 2;
    }

    return result;
}

Это совсем частный случай ранее упомянутого поиска в ширину/глубину, где не понадобилось множество ранее посещенных этажей (достаточно проверки на prevStart), а так же очереди/стека. То есть обошлись О(1) памяти.
По скорости выходит O(ln(start) * ln(max)), и в принципе можно сократить до O(ln(start)), если не делать внутренний цикл, а сразу посчитать по формуле, но что-то на ночь глядя не могу эту формулу смекнуть...

Для начала можно построить таблицу простых чисел от 1 до 2N, например с помощью решета Эратосфена. Теперь ты сможешь проверять, что число (или, например, сумма двух чисел) простое, за O(1), то есть быстро.

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

Это переменная на стеке, не в куче. О стеке стоит начинать беспокоиться, если у тебя здоровенная рекурсия, но тогда лучше сразу, от греха подальше, переписать алгоритм на цикл

у тебя миллиард багов внутри цикла. Вот, с поправками:

queue<int> ends; // очередь окончаний
int startTime = 0; // возможный старт

for (int i = 0; i < numPackets; i++) {
        int arrival, duration;
        cin >> arrival >> duration;

       // выясняем, когда на самом деле можно стартовать пакет
       int realStart = max(startTime, arrival);
 
        // Извлекаем из очереди пакеты, которые обработаны на момент старта
        while (!ends.empty() && ends.front() <= arrival) {
            ends.pop();
        }
 
        if (ends.size() < bufferSize) {
            // если на момент старта есть места в очереди, стартуем
            cout << realStart << endl;
            startTime = realStart + duration; // окончание обработки
            ends.push(startTime);
        } else {
            // Очередь полна, пакет не может быть обработан
            cout << -1 << endl;
       }
}

https://qna.habr.com/q/1252656

если итоговое расположение элементов не важно, то самым оптимальным решением будет отсортировать массив, а потом профильтровать на месте вот так:

int i, pos = 0;
for (i = 1; i < y; i++) {
    if (a[i] != a[pos]) {
        a[++pos] = a[i];
    }
}
for (i = pos + 1; i < y; i++) {
    a[i] = 0;
}

так ты получишь асимптотику O(n * ln(n))