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

Запоминаем первое и последнее вхождения символов и вычисляем минимальное расстояние между одинаковыми символами как $$$ans = min(i-prev[c],n+first[c]-i)$$$ , где $$$c$$$ — символ, $$$i$$$ — текущее положение символа, $$$prev[c]$$$ — последнее вхождение символа, $$$first[c]$$$ — первое вхождение.

Из всех таких расстояний берем минимум и выводим ответ $$$(ans \cdot 33 +59) \; / \; 60$$$

#include <bits/stdc++.h>

using namespace std;

int main() {
    ios::sync_with_stdio(false);
    int n;
    cin >> n;

    int ans = n;
    vector <int> prev(26, -1), first(26, -1);

    for (int i = 0; i < n; i++) {
        char c;
        cin >> c;

        if (first[c - 'a'] == -1 ) first[c - 'a'] = i;
        else ans = min(ans, min(i - prev[c - 'a'], n + first[c - 'a'] - i));

        prev[c - 'a'] = i;
    }

    cout << (ans * 33 + 59) / 60;
}

Немного преобразуем уравнение

Учитывая ограничения задачи, ответом будем являться количество различных разложений $$$\cfrac{A-Y}{B-X}$$$.

Пусть $$$\cfrac{a}{b}$$$ — сокращенная дробь от $$$\cfrac{A}{B}$$$, тогда $$$\forall k \in [1 \ldots gcd(A,B)] \; \; \; k \cdot \cfrac{a}{b} = \cfrac{A}{B}$$$

Если $$$X=Y=0$$$, то тогда таких значений $$$gcd(A,B)$$$, но такого быть не может, поэтому ответ $$$gcd(A,B)-1$$$.

#include <bits/stdc++.h>

using namespace std;

int main() {
    ios::sync_with_stdio(false);
    int n;
    cin >> n;

    while (n--) {
        long long a, b;
        cin >> a >> b;

        cout << __gcd(a, b) - 1 << endl;
    }
}

Нам не важно в какую сторону идти, поэтому будем двигаться вправо и при $$$0 < x$$$ можно взять $$$x = |x|$$$.

Количество шагов не может быть меньше, чем $$$ step = \sqrt{x}$$$, так как сумма всех шагов равна $$$sum =\cfrac{ (step+1) \cdot step }{2}$$$. Пока $$$ sum < x$$$, будем увеличивать $$$step$$$, как только $$$sum \geq x$$$, продолжаем увеличивать $$$step$$$, пока $$$ ( sum - x) \; mod \; 2 = 1$$$, потому что нам нужно попасть в $$$x$$$, а значит из точки $$$sum$$$ сделать какие-то шаги( которые мы уже делали) влево два раза, то есть $$$step back = (sum - x) \; / \; 2$$$.

#include <bits/stdc++.h>

using namespace std;

int main() {
    ios::sync_with_stdio(false);
    int x;
    cin >> x;
    x = abs(x);
    
    int  step = sqrt(x), sum = (step + 1 ) * step / 2;

    while (sum < x || (sum - x) % 2 == 1) {
        step++;
        sum += step;
    }
    cout << step;
}

Если у героя есть ключ от двери, то можно считать эту дверь как поле, в которое можно пойти, в противном случае можно сказать, что эта дверь — стена.

Таким образом достаточно перебрать всевозможные варианты комбинации ключей (их можно получить рекурсивным полным перебором, всего различных вариантов 16) и выбрать среди них такой, что сумма стоимости ключей будет минимальна. Если из лабиринта никак нельзя выбраться, то вывести $$$Unreal$$$.

Для поиска пути можно воспользоваться поиском в ширину или глубину (почитать о них можно здесь — DFS, BFS)

#include <bits/stdc++.h>

using namespace std;


size_t xS, yS;
size_t xE, yE;
int step[4] = {0, 1, 0, -1};

bool dfs(size_t x, size_t y, const string& s,
         vector<vector<char>>& lab, vector<vector<bool>>& used) {
    if (used.size() <= x || used.size() <= y ||
        used[x][y] || (s.find(lab[x][y]) == string::npos))
        return false;
    used[x][y] = true;

    if (x == xE && y == yE)
        return true;

    size_t next_x, next_y;
    bool path = false;
    for (int i = 0; i < 4; i++) {
        next_x = x + step[i];
        next_y = y + step[(i + 1) % 4];

        path |= dfs(next_x, next_y, s, lab, used);
    }
    return path;
}


int solve(string s, int sum,
          vector<vector<char>>& lab,
          vector<vector<bool>>& used,
          vector<int>& door) {

    used.assign(lab.size(), vector<bool>(lab.size(), false));

    int ans = 5000;
    if (dfs(xS, yS, s, lab, used)) {
        ans = min(ans, sum);
    }

    for (char c = '1'; c <= '4'; c++) {
        if (s[s.size() - 1] < c)
            ans = min(ans, solve(s + c, sum + door[c - '1'], lab, used, door));
    }
    return ans;
}

int main() {
    ios::sync_with_stdio(false);
    int n;
    cin >> n;

    vector<int> door(4);
    for (int i = 0; i < 4; i++) {
        cin >> door[i];
    }

    vector<vector<char>> lab(n, vector<char>(n));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cin >> lab[i][j];
            if (lab[i][j] == 'S') {
                xS = i;
                yS = j;
            }
            if (lab[i][j] == 'E') {
                xE = i;
                yE = j;
            }
        }
    }

    vector<vector<bool>> used;
    int ans = solve("SE.", 0, lab, used, door);

    if (ans == 5000)
        cout << "Unreal";
    else
        cout << ans;
}

Пусть $$$a,b$$$ — первое и второе названия организаций. Вычислим $$$Z$$$-функцию ( подробнее о ней можно почитать здесь) для строки $$$a+?+b$$$. Теперь по результаты $$$Z$$$-функции есть 3 варината развития событий:

1. Строка $$$a$$$ является подстрокой $$$b$$$. Ответом будет строка $$$b$$$, где первый символ первого вхождения $$$a$$$ будет заглавным.

2. Объединяем строки, где общей частью будет максимальный суффикс $$$b$$$, который является префиксом $$$a$$$ (первый символ общей части является заглавной буквой).

3. Строка $$$a$$$ не является подстрокой $$$b$$$ и нет такого суффикса $$$b$$$, который являлся бы префиксом $$$a$$$, тогда ответом будет строка $$$b+a$$$.

Аналогичным образом поступаем с $$$Z$$$-функцией строки $$$b+?+a$$$ и среди всех результатов выводим минимальный.

#include <bits/stdc++.h>

using namespace std;

void z_function(string s, vector<size_t>& zf) {
    for_each(s.begin(), s.end(), [](char & c){
                                           c = ::toupper(c);
                                       });

    for (size_t i = 1, l = 0, r = 0; i < s.size(); i++) {
        if (i <= r)
            zf[i] = min(r - i + 1, zf[i - l]);

        while (s[zf[i]] == s[i + zf[i]] && zf[i] + i < zf.size())
            zf[i]++;

        if (zf[i] + i - 1 > r)
            l = i, r = i + zf[i] - 1;
    }
}

void solve(string& a, string& b, string& res) {
    size_t n = a.size() + b.size() + 1;

    vector<size_t> zf(n);
    z_function(a + '?' + b, zf);

    res = b + a;
    for (size_t i = a.size() + 2; i < n; i++) {
        if (n - i == zf[i]) {
            res = b.substr(0, i - a.size() - 1) + a;
            break;
        }
        else if (zf[i] == a.size()) {
            res = b.substr(0, i - a.size() - 1) + a + b.substr(i - 1);
            break;
        }
    }
}

int main() {
    ios::sync_with_stdio(false);
    string a, b;
    cin >> a >> b;

    string res1, res2;
    solve(a, b, res1);
    solve(b, a, res2);

    if (res1.size() == res2.size())
        cout << min(res1, res2);
    else
        cout << (res1.size() > res2.size() ? res2 : res1);
}

Максимальный объем, на который можно уменьшить посылку со сторонами $$$a$$$, $$$b$$$, $$$c$$$ это $$$a \times b \times c$$$. Тогда , чтобы получить минимальный уменьшаемый объём — нужно максимизировать объем, который поместится в устройство с размерами $$$w \times h$$$ и бесконечной длиной.

Для этого можно для каждой пары сторон смотреть помещаются ли они — если нет, то по этим сторонам посылку можно уменьшить, затем получившиеся стороны домножить на третью. И так для всех пар сторон — $$$(a,b)$$$, $$$(b,c)$$$, $$$(a,c)$$$, $$$(b,a)$$$, $$$(c,b)$$$, $$$(c,a)$$$.

И из $$$a \times b \times c$$$ вычесть максимальное получившиеся значение.

Ответ мог превосходить $$$int$$$, но не все участники сразу догадались об этом =(

#include <iostream>

using namespace std;

long long n, w, h, a[3];

long long solve(int x) {
    if (x > 2) return 0 ; else
        return max(max(min(a[x], w) * min(a[(x + 1) % 3], h) * a[(x + 2) % 3],
                       min(a[x], h) * min(a[(x + 1) % 3], w) * a[(x + 2) % 3])
                   , solve(x + 1));
}

int main() {
    
    cin >> n >> w >> h;

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < 3; j++) cin >> a[j];
        
        cout << a[0]*a[1]*a[2] - solve(0) << endl;
    }
}

Необходимо реализовать бинпоиск по ответу. А для того, чтобы проверить можно ли достичь значения $$$mid$$$ сделаем ДП:

Возьмем любую пару значений $$$A_i$$$ и $$$A_j$$$, если $$$mid$$$ подходит как ответ, то значит $$$|A_i-A_j| \le |i-j| \times mid$$$ .

А в $$$dp_i$$$ будем считать кол-во необходимых изменений для того, чтобы $$$mid$$$ , был ответом для отрезка $$$[1 \ldots i]$$$, при этом само значение $$$A_i$$$ мы не меняем. Теперь для каждого $$$dp_i$$$ перебираем $$$A_j, j \in [1 \ldots i-1]$$$, это значит что элемент $$$A_j$$$ тоже не трогаем, а все, что между ними можем поменять.

Затем вычисляем $$$ans$$$ — количество необходимых изменений , чтобы $$$mid$$$ был ответом —

#include <iostream>
#include <vector>

using namespace std;

vector <long long> dp, a;
long long n, k;


bool ok(long long mid) {
    long long ans = 100000000;
    
    for (int i = 0; i < n; i++) {
        dp[i] = i;
        for (int j = 0; j < i; j++) {
            if (abs(a[i] - a[j]) <= (i - j) * mid)
                dp[i] = min(dp[i], dp[j] + i - j - 1);
        }
        
        ans = min(ans, dp[i] + n - i - 1);
    }
    
    return (ans <= k);
}

int main() {
    cin >> n >> k;
    
    a.resize(n);
    dp.resize(n);
    
    for (int i = 0; i < n; i++) cin >> a[i];

    long long l, r;
    l = -1;
    r = 2000000001;
    while (l + 1 < r) {
        long long mid = (l + r) / 2;
        if (ok(mid)) r = mid;
            else l = mid;
    }
    
    cout << r;
}

Недочет с моей стороны, поправил условие задачи.

Для каждой пары $$$X$$$, $$$Y$$$ ответ будет равен $$$X$$$ $$$div$$$ $$$gcd(X,Y) - 1$$$

Если $$$X=1$$$, то нельзя разложить дробь на цепного мутанта, а значит ответ 0. Иначе:

Если $$$X,Y$$$ не взаимнопросты, то поделим их на НОД, затем

.

Домножим получившуюся дробь на $$$K$$$, так что $$$(B \times K) mod X = X-1$$$ . Это всегда возможно.

$$$ \cfrac{1}{A + \cfrac{B}{X}} = \cfrac{K}{A \times K + \cfrac{X-1}{X}}$$$ , далее аналогичным образом будем раскладывать $$$\cfrac{X-1}{X} = \cfrac{1}{(\cfrac{X}{X-1})} = \cfrac{1}{1+\cfrac{1}{X-1}}$$$, получили аналогичную дробь, с которой можно проделать точно такие же операции.

Таким образом каждый раз знаменатель будет уменьшаться на 1, пока не достигнет 2. При знаменателе 2 дальнейшее разложение невозможно.

#include <bits/stdc++.h>

using namespace std;

long long gcd(long long a, long long b) {
	if (b == 0) return a;
	return gcd(b, a % b);
}

int main() {
	long long n, x, y;

	cin >> n;

	while (n > 0) {
		--n;
		cin >> x >> y;

		cout << x / gcd(x, y) - 1 << endl;
	}
}

Очевидно, что ученых — конечное количество, а именно 1022.

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

Сложность заключалась в генерации id всех ученых.

id любого ученого имеет не более 10 цифр.

Для генерации можно использовать полный рекурсивный перебор: Начнем генерацию с пустой строки. Первый символ может быть $$$[1 \ldots 9]$$$, второй либо $$$0$$$, либо символ, который больше предыдущего, все следующие символы должны быть больше предыдущих. Таким образом сгенерируем все id ученых.

#include <bits/stdc++.h>
#define all(v) v.begin(),v.end()
using namespace std;

vector<int> idList;

void gen(string id, int dig) {
    if (dig > 10)
        return;

    if (id.size() == 1)
        gen(id + '0', dig);

    for (int i = dig; i < 10; i++)
        gen(id + char('0' + i), i + 1);

    if (id.size())
        idList.push_back(stoi(id));
}

int main() {
    
    gen("", 1);

    sort(all(idList));
    idList.resize(unique(all(idList)) - idList.begin());

    int n;
    cin >> n;
    
    for (int i = 0; i < n; i++) {
        string X;
        cin >> X;
        sort(all(X));
        X.resize(unique(all(X)) - X.begin());
        
        if (X.front() == '0' && X.size() > 1)
            swap(X[0], X[1]);
            
        int num = lower_bound(all(idList), stoi(X)) - idList.begin();
        
        cout << num + 1 << endl;
    }
}