Wataru

Да. Потому что локальность памяти и меньше разыменовываний.

в vector<vector> это фактически указатель на массив указателей. Строки раскиданны по памяти как попало и при обращении к ячейке будет лишнее обращение к памяти, чтобы получить адрес строки.

Если же вы этот двумерный массив линеаризируете и будете сами вычислять индекс, то, во-первых, все будет локально и последовательное чтение массива по строкам будет очень дружественно кешу процессора, во-вторых, вместо двух сложений и двух обращений к памяти будет умножение, два сложения и одно чтение из памяти. А умножить два числа будет всяко быстрее чтения из памяти.

Самый простой вариант - поддерживать вектор из указателей на самые правые узлы во всех доступных уровнях.

Сначала читаете первую строку и создаете из нее корень дерева.

А потом в цикле читайте строку и считайте, сколько там пробелов. Их должно быть не больше, чем количество доступных уровней (т.е. элементов в векторе).
Добавляете текущую строку к узлу, который на уровне равном количеству пробелов (-1, потому что индексация с 0). Укорачиваете вектор до этого узла (все с уровенем ниже та вершина, к которой добавили ребенка - уже недоступно). Добавляете в вектор указатель на только что добавленную вершину.

В вашем примере.

Прочитали иван, сделали корень дерева. Вектор будет {"иван"} (указатель на вершину-корень дерева).

Прочитали алексей. 1 проблел - все хорошо, в векторое 1 элемент, значит может быть до 1 пробела. Добавили "алексей" к вершине "иван". Вектор {"иван", "алексей"}

Прочитали игорь. Вектор стал {"иван", "алексей", "игорь"}.

Прочитали андрей. 1 пробел. Может быть до трех пробелов, ведь в векторе 3 элемента. Добавили "андрей" к узлу из вектора по индексу 0 (-1 к количеству пробелов). обрезали вектор до длины 1 и добавили туда новую вершину. Вектор стал {"иван", "андрей"}

И т.д.

Для добавления вершины создайте новый TreeNode с нужной строкой и push_back в список детей для нужного отца.

Я так понял задача в том, а есть ли алгоритм, который для двух входных чисел всегда выводит их сумму, но невозможно доказать, а выводит ли он ее или что-то другое.

Есть такой алгоритм. В общем случае он выглядит так:

Read(a);
Read(b);
DoSomething(a, b);
Write(a+b);

Перед выводом суммы чисел есть какой-то алгоритм, который что-то делает. Если он виснет, то и весь алгоритм виснет. Если он не виснет - то весь алгоритм выдаст сумму. Но вот определить, а виснет ли заданная программа в общем случае - нельзя.

Поэтому 100% существует такой DoSomething, про который формально доказать что он не виснет нельзя. Иначе бы проблема остановки решалась.

Макроссы часто используют для условного включения каких-то функций на этапе компиляции. Например, отладочного логирования. Тогда в зависимости от ключей компиляции можно получить релизный исполняемый файл вообще без этого ненужного кода.

Еще макросы можно использовать для гарантирования инлайнинга кода. Если есть что-то часто повторяющееся, например, это же самое логирование, то можно сделать макросы и избегать дополнительных накладных расходов на вызовы функций.

У вас решение за O(NM), когда как есть решение за O(N+M).

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

Если у вас в строке i символов выведено, а должно суммарно быть N символов, то осталось вывести N-i звездочек.

Можно. Для этого можно, например, пройтись циклом по словам формируя список-ответ. Если текущее слово не содержит символ параграфа, то его надо или добавить к списку ответа, или добавить к последнему слову там. Или проще может быть поддерживать переменную с текущим объединением слов. Если слово в списке не соедржит парагафа - добавляйте к переменной. Если встретили прагараф, то добавляйте в ответ переменную и слово с параграфом и отчищайте переменную.

Код работает ровно так, как написан.

Можете строчка за строчкой объяснить, что происходит в коде? Я начал, вы дополните в остальных строчках. Сразу должно стать понятно, где ошибка в логике:

numbers = input().split()               # получаем в numbers массив из отдельных слов в введенной строке
flag = 0                                # инициализируем счетчик нулем
for i in range(len(numbers)):           # проходимся по всей длине массива (по всем словам)
    if numbers[i].isdigit() == True:    # Если текущее слово состоит только из цифр (т.е. оно число)
        flag += 1                       # Увеличиваем счетчик
if flag == len(numbers):                # если все слова в строке - числа
    for i in range(len(numbers)-1):     # ???
        print(numbers[i], numbers[i+1]) # ???
        if numbers[i] < numbers[i+1]:   # ???
            mx = numbers[i+1]           # ???
print(mx)

Проблема в том, что вот эта вот ваша формула - она работает только на отрезке, где sinx*sgn(cos x) непрерывна. А она имеет разрывы в точках, где косинус меняет знак. Вы ее, видимо, подобрали методом тыка. И действительно, если взять ее производную в каждой точке, то получается |cos x|. Но эту производную не взять в точках, где косинус меняет знак, ведь там разрывы. Это не первообразная, хотя бы потому, что первообразная должна быть непрерывна. поэтому формула определенного интегралла тут и не работает.

Надо или удалять из графа вершину, или помечать ее удаленной и в вашем алгоритме поиска пути просто пропускать такие помеченные вершины во всех циклах по вершинам.

Это очень плохая идея. Теперь пользователю придется искать функцию в 5 файлах, потому что она может быть в любом из них. Если же куски класса можно как-то логически сгруппировать, то надо разбить сам класс на несколько более мелких. Вынести часть функционала в вспомогательные классы или даже тупо функции.

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

Можно сделать так:

template <int a, int b>
class A {
    public:
    template<bool tmp = true>
    typename std::enable_if<a==b && tmp, int>::type F() {
       return 1;   
    }
};

...

A<1,1> a;
std::cout << a.F();  // OK.
A<2,100> b;
std::cout << b.F(); // Ошибка A<2,100> не имеет метода F().

Мне сложно объяснить, чтобы было понятно, почему работает именно это, но я попробую.

Во-первых, метод дложен быть обернут в шаблон, потому что если там будет ошибка, то не инстанцируется шаблон для вашего типа Matrix, а он должен быть даже если размерности не равны.

Далее, хотелось бы что бы просто работало вот это:

template<>
 typename std::enable_if<a==b, int>::type F()

Тут все понятно, enable_if не имеет type, если a неравно b. Шаблон никак не инстанциировать и метод не должен был бы генерироваться. Но это было бы слишком просто.

Вместо этого, надо там завести какой-то вообще ненужный как бы параметр шаблона tmp, и обязательно использовать его в enable_if. Это потому что если в этом шаблоне не будет никак использоваться параметр шаблона, то SFINAE не срабатывает, и вылезает ошибка компиляции.

В общем случае - будет.
std::swap работает за константу:

Complexity
1) Constant.

Присвоение за линию:

Complexity
1) Linear in the size of *this and other.

Edit: это если присваемые штуки - вектора. Или какие-то большие объекты с семантикой перемещения. Если у вас тупо числа, то одно присвоение будет быстрее swap.