Wataru

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

Можно в тестах требовать совпадение с некоторой абсолютной или относительной погрешностью.

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

Еще можно использовать более устойчивые к ошибкам округления методы. Метод гаусса не лучший выбор.

Перепишите этот ужас с нуля. Там невозможно найти ошибку.

Советую воспользоваться тем, что условные операторы вычисляются лениво: Если написать A && B и A окажется false, то B даже не будет вычисляться.

Так, проверка на клетку сверху может быть написана так:
if (i > 0 && a[i-1][j] - мина)

Так вся ваша простыня выродится в 8 последовательных проверок. Если меняются обе координаты, то надо через && объединить 3 условия - 2 на проверку невыхода за границы массива, и последнее - проверка значения массива.

Еще можно завести массив на SIZE+2 x SIZE+2 и заполнять его с (1, 1). Фактически, создается каемка вокруг исходного массива. И пробегаться по нему надо от 1 до SIZE. Так, вокруг всегда будут все 8 соседей. В этом подходе не придется проверять на выход за границы массива.

А еще можно вместо 8 if-ов сделать цикл на 8 итераций, если завести константы для приращений:

const int kDx[] = {1, 1, 1, 0, -1, -1, -1, 0};
const int kDy[] = {1, 0, -1, -1, -1, 0, 1, 1};

Теперь всех соседей можно перебрать как (i + kDx[k], j + kDy[k])

В смысле, как читать? Слева направо, соблюдая порядок операций.

Вот первая формула r= ... - это значит, что значение переменной r вычисляется по выражению справа. Там участвуют переменные p, g, значения которых вам даны.

Там дробь, в числителе стоит сумма p и g. В знаменателе один плюс значение логарифма в квадрате от суммы корня pg+p и g^2. Расставьте скобки и получите (p+g)/(1+log(...)*log(...))

Аналогично вторая формула для y через p,g,r и z ( три из них вам даны, r вычисляется в предыдущем действии).

Возведение в квадрат - зависит от языка программирования. Или функция sqr(), или **2, или просто написать (выражение)*(выражение). lg() - вызов встроенной функции логарифма. Опять же, зависит от языка, как именно она называется у вас. Квадратный корень - функция sqrt().

Возможно там переполнение. Убедитесь, что у вас все хеши везде считаются только с участием unsigned типов. Переполнение в signed - это Undefined behavior.

Скорее всего, тип User нельзя вот так вот читать и писать в файл. Подозреваю, что там содержатся std::string, которые сами в себе хранят лишь указатели на символы в строке. Поэтому, если std::string записать в файл как набор байт, то вы запишете в файл указатели. Прочитав их назад из файла, вы получите случайне адреса, не указывающие ни на что.

Вам придется писать руками ввод и вывод типа из файла.

Вы поняли, что это динамическое программирование. Опишите, что у вас за функция ДП, дайте формулу пересчета, базу и где ответ.

Вам поможет std::bind.

Передавайте в partition

std::bind(predicate, item.first, std::placeholders::_1)

в качестве предиката.

Edit:

Но тут у вас будет другая проблема. set - не vector. Вы не сможете его передать stable_partition. Вместо ручного применения stable_partition, используйте erase_if. Предикат туда также через std::bind передавайте.

Похоже практически все встроенные функции ожидают '\0' на конце входного буфера, что не ваш случай.

Единственное исключение, которое я нашел - std::from_chars. Только оно далеко не везде доступно и надо подключать charconv.

Еще можно руками, если точно известно, что никаких ошибок в числе нет:

unsigned int vtoi(const std::vector<char> &a) {
  unsigned int res = 0;
  for (const auto& c: a) {
    res = 10*res + static_cast<unsigned int>(c) - static_cast<unsigned int>('0');
  }
  return res;
}

Проверки на переполнение и левые символы добавьте сами, если надо.

Странное задание. Какая польза от этого сокращения сравнений, если всего в результате вставки переместится до O(log n) элементов?

Но, если так надо, то вам нужно для каждого числа сначала узнать номер старшего ненулевого бита (most significat bit - MSB), и потом сдвинуть верхнее число вправо на половину разницы в позициях старших битов.

1 = 0000001b, msb = 0
18 = 0010010b, msb = 4

Разность - 4 разряда. Значит, надо сдвигать на 2 разряда вправо:
18 >> 2= 0010010b >> 2 = 00100b = 4

Еще пример: для 4 и 18 msb были бы 2 и 4, разность -2. Сдвинув 18 на 2/2=1 разряд вправо, вы бы получили 9.

Чтобы эта оптимизация давала хоть какую-то пользу, надо находить msb очень быстро. Или предподсчитайте их для всех возможных индексов, или надейтесь, что в вашем языке есть встроенная функция, которая вызывает нужную инструкцию процессора, типа __builtin_clz.

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

Для предподсчета просто в цикле задавайте msb[i] = msb[i/2] + 1;

TL;DR:

S = Pi*sqrt(3 / [ (1/L1+1/L2+1/L3)^2-2*(1/L1^2+1/L2^2+1/L3^2) ])

тут L1, L2, L3 - квадраты трех измерений.

Вывод формул:
Чуть-чуть аналитической геометрии и куча элементарной алгебры помогут вам вывести эти уравнения.
Если ввести систему координат с осями по главным радиусам эллипса, то уравнение эллипса будет:
x^2/a^2+y^2/b^2 = 1

При этом все точки под углом alpha к большой полуоси будут на луче:

x(t, alpha) = t*cos(alpha)
y(t, alpha) = t*sin(alpha)

Обозначим синус и косинус угла для первого измерения как:
s = sin(a1), c = cos(a1)

Пусть квадраты расстояний - L1, L2, L3.

Если пересечь луч и эллипс, то можно составить уравнение для длины вдоль угла a1 (первое измерение), просто подставив известные x(a1, sqrt(L1)) и y(a1, sqrt(L1)).
1/L1 = c^2/a^2+s^2/b^2

Для остальных измерений надо прибавлять 120 градусов к углу под cos и sin. Если раскрыть cos(120+a1) = cos(120)cos(a1)-sin(120)sin(a1) и sin(120+a1) = cos(120)sin(a1)+sin(120)cos(a1), то можно составить еще 2 уравнения:

1/L2 = (-1/2*c-sqrt(3)/2*s)^2/a^2+(sqrt(3)/2*c-1/2*s)^2/b^2
L3 = (-1/2*c+sqrt(3)/2*s)^2/a^2+(-sqrt(3)/2*c-1/2*s)^2/b^2

Всего с учетом тригонометрического тождества s^2+c^2=1 у нас 4 уравнения на 4 неизвестных a, b, c, s.

Но нам не нужны все значения. Площадь эллипса Pi*a*b, а радиусы эллипса - a и b.

Раскрыв квадраты выше и всячески складывая эти уравнения можно получить в итоге

1/a^2+1/b^2 = 2/3*(1/L1+1/L2+1/L3)
1/a^2*b^2 = [ (1/L1+1/L2+1/L3)^2-2*(1/L1^2+1/L2^2+1/L3^2) ]/3

Отсюда площадь:

S = Pi*ab = Pi*sqrt([ (L1+L2+L3)^2-2*(L1^2+L2^2+L3^2 ]/3)

Чтобы найти радиусы эллипса, вам надо найти a и b. Выше уже даны два уравнения для суммы и произведения 1/a^2 и 1/b^2 - можно из них получить квадратное уравнение для t=1/a^2. Два его решения и будут вашими радиусами эллипса (не забудьте взять корни и обратить). Тут надо аккуратно подставить выражения в школьные формулы для квадратного уравнения.

Не совсем. Форма правильная, но пропорции - нет. График должен начинаться в той же точке, что и u_b. Число 0.5 там не верно. Эта точка значительно ниже 0.5. И точка пересечения двух графиков вовсе не x=4.

Нет, все методы класса надо объявить в хедере (тем более публичные): иначе как пользователи класса смогут к нему обращаться? С простыми функциями так можно, если они не используются где-то извне. Или с классном можно, только если он весь целиком объявлен в cpp файле и, соответственно, его нельзя использовать вне этого файла.

Можно еще перенести в cpp файл определение шаблонных классов/методов/функций, но для этого надо в хедере указать через forward declaration все используемые специализации шаблона. Например так:

template <>
int Database::RemoveIf<bool>(bool predicate);

Конечно, там должен быть не bool а тип вашего предиката. И надо такие штуки воткнуть в хедер для ВСЕХ типов, которые в других файлах пихаются в шаблон.

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

Судя по коду, вы хотите, чтобы массив был отсортирован. Но тогда просто менять новый элемент с чем-то в массиве неправильно - его надо туда вставлять, сдвигая все элементы.

Вот пример: уже обновленная и отсортированная часть {1, 2, 3, 5, 6, 7}. Только что обновленный элемент имеет значение 4. lower_bound вернет итератор на 5. Вы поменяете 5 и 4 и получите {1, 2, 3, 4, 6, 7, 5} - не отсортировано уже.

Можно удалить элемент в it и вставить на новое место через insert, но тогда могут быть проблемы с итератором цикла. Можно ручками через swap сдвигать элементы в цикле:

T tmp = it->value;
for (auto cur = std::lower_bound(vector.begin(), it, (*it)); cur < it; ++cur) {
   swap(tmp, cur->value);
}
it->value = tmp;

Это, фактически, будет сортировкой вставкой за O(N^2). lower_bound за логарифм тут на самом деле даже лишнее и только замедляет сортировку. Лучше одним циклом сразу и swap-ать и сравнивать элементы.

Но еще быстрее будет отдельно пройтись по массиву и обновить его целиком и потом вызвать std::sort для сортировки по value.