Wataru

Это самый быстрый способ факторизации одного числа. Если не хватает, то может в задаче можно факторизовать все числа сразу. Каким нибудь решетом можно найти минимальный делитель для всех чисел до n за O(n). Дальше каждое число раскладывается на множители моментально.

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

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

При вставке - просто добавляйте в вектор ключ и вставляйте в дерево значение {значение, последний индекс в векторе}. При удалении по ключу - в известном месте вектора пропишите последний элемент и укоротите вектор на 1. Не забудьте обновить ссылку на вектор у того ключа, который с последнего места переехал.

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

При удалении случайного - берите случайный ключ из вектора и его удаляйте.

Оператор присвоения не проверяет, а были ли какие-то данные выделены уже. Когда вы используете код из вопроса в конструкторе, то numbers все равно создается и инициализируется конструктором по умолчанию, который выделяет память. Уже потом выполняется тело конструктора BigInt и вы затираете выделенный указатель другим указателем.

Но у вас и в SimpleVector(const SimpleVector &other) ошибка - оно просто копирует указатель. После чего два экземпляра SimpleVector будут указывать на одни и те же данные. И оба попытаются удалить их в конце. Так что там у вас и доступ к удаленной памяти и двойное удалиение.

Если результат не должен быть горизонтально-вертикальным по условию, то в оптимальный прямоугольник может быть и наклонен (смотрите замечательный контр-пример от dollar).

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

Но тут слишком много случаев. Это очень сложная задача строк этак на 1000 мозгодробящей геометрии.

Вам надо погуглить, что такое кодировки.

Строка в C++ - это просто набор байт. Что они означают уже определяется кодировкой.

Вам надо, чтобы кодировка строковых констант в этом коде совпадала с тем, что введет пользователь. Возможно, изменение кодировки исходника поможет. Возможно, надо установить локаль в консоли.

Вы бы хоть ошибку-то привели. У меня возникает:

error: ISO C++ forbids declaration of 'call_func' with no type [-fpermissive]

И чтобы ее иcправить, надо лишь дописать тип возвращаемого значения. Например:

template<typename T>
void call_func(T param) {sin(param);}

Если вам не надо чтобы каждый человек одинаково часто работал с каждым другим, то подойдет обощение решения, предложенного в комментариях Alexandroppolus и Сергей Сергей.

Допустим количество работ (N) и количество людей (M) взаимно просты.

Тогда сгенерируйте M строчек беря людей подряд:
1, 2, 3
4, 5, 1
2, 3, 4
5, 1, 2
3, 4, 5

Тут каждый человек одинаковое количество раз (по одному разу) будет на каждой работе. И дни, когда он будет работать будут максимально равномерно распределены (минимальное расстояние и максимальное между соседними работами будут различаться максимум на 1 и равны floor(N/M) и ceil(N/M)). Это идеальное с точки зрения равенства расписание. Но у него минус - частоты пар работников будут не одинаковыми. 1 гораздо чаще будет работать с 2 и 5, чем с 3 и 4.

Теперь, если N и M не взяимно просты. Пусть D = GCD(N,M) - наибольший общий делитель.

Разбейте всех людей на D групп по N'=N/D человек. N' и M взяимно просты, поэтому можно применить алгоритм выше к каждой группе.

Дальше эти D расписаний надо перемешать. Для максимальной равномерности - сначала взять все первые строки всех расписаний, потом все вторые, и т.д.

На i-ом месте будет день i / N' из расписания i % N' (если индексация с 0).

Так, например, решение для 2 работ и 6 людей:

N' = 3. 2 группы.
В первой:
1 2
3 1
2 3

Во второй:
4 5
6 4
5 6

В итоге:
1 2
4 5
3 1
6 4
2 3
5 6

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

Можно запоминать предыдущие поля. Хотя бы в виде хешей для экономия памяти. Чтобы из-за коллизии не заврешаться раньше времени, можно считать несколько принципиально разных хешей (допустим, sha256 и какой-то полиномиальный хеш), и плюс брать "слепок" от поля (какие-то 256 разбросанных по полю клеток).

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