Задачи для тренировки и лучшего понимания

//////////////////////////////////////////////////////////////////////////////////////
//Рассмотрим бесконечную вправо и вверх шахматную доску, на которой стоит ферзь. 
//Двое по очереди двигают этого ферзя. Разрешается двигать ферзя только вниз, 
//влево или по диагонали вниз влево. Цель игры – задвинуть ферзя в угол, 
//то есть клетку с координатами (1, 1). На рисунке показаны разрешенные движения ферзя.
//------------------------------------------------------------------------------------
//Требуется написать программу, которая найдет номер игрока, который выиграет 
//при правильной игре.
//Входные данные
//------------------------------------------------------------------------------------
//Входной файл INPUT.TXT содержит координаты ферзя перед первым ходом 
//- два числа M и N, записанные через пробел (1 <= M, N <= 250).
//Выходные данные
//------------------------------------------------------------------------------------
//Выходной файл OUTPUT.TXT должен содержать найденный номер победителя.
//////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <iostream>
#include <set>
//////////////////////////////////////////////////////////////////////////////////////
typedef std::set<int>  T_int_set;
//////////////////////////////////////////////////////////////////////////////////////
const int  M_MIN = 1;
const int  N_MAX = 250;
//////////////////////////////////////////////////////////////////////////////////////
bool  first_is_winner(int  m, int  n)
{
    if(n > m)
    {
        std::swap(m, n);
    }
    //Утверждение: n <= m.
    //По условию фукнция Шпрага-Гранди равна нулю в угловой клетке.
    //Найдем остальные клетки с первой координатой <= n, в которых она равна нулю.
 
    int Y[N_MAX] = {0};
    T_int_set  values;    
    T_int_set  diagonals;    
    for(int i = 0; i < n; ++i)
    {
        if(   i > 0 
           && Y[i] == 0)
        {
            while(   values     .count(Y[i])
                  || diagonals  .count(Y[i] - i))
            {
                ++Y[i];
            }
 
            if(Y[i] < n)
            {
                Y[Y[i]] = i;
            }
        }
        values     .insert(Y[i]);        
        diagonals  .insert(Y[i] - i);
    }
    return Y[n - 1] != m - 1;
}
//////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    std::cout << "Введите координаты ферзя (M_MIN <= M, N <= N_MAX):"
              << std::endl;
    int m = 0;
    do
    {
        std::cout << "M = ";
        std::cin >> m;
    }while(m < M_MIN);
 
    int n = 0;
    do
    {
        std::cout << "N = ";
        std::cin >> n;
    }while(N_MAX < n);
 
    std::cout << "Победит "
              << (first_is_winner(m, n) ? 1 : 2)
              << "-й игрок."
              << std::endl;
}

//////////////////////////////////////////////////////////////////////////////////////
//Петя разгадывает головоломку, которая устроена следующим образом. Дана квадратная 
//таблица размера NxN, в каждой клетке которой записана какая-нибудь латинская буква. 
//Кроме того, дан список ключевых слов. Пете нужно, взяв очередное ключевое слово, 
//найти его в таблице. То есть найти в таблице все буквы этого слова, причем они 
//должны быть расположены так, чтобы клетка, в которой расположена каждая последующая 
//буква слова, была соседней с клеткой, в которой записана предыдущая буква 
//(клетки называются соседними, если они имеют общую сторону — то есть соседствуют 
//по вертикали или по горизонтали). Например, на рисунке показано, как может быть 
//расположено в таблице слово olympiad. 
//
//Когда Петя находит слово, он вычеркивает его из таблицы. Использовать уже вычеркнутые 
//буквы в других ключевых словах нельзя. После того, как найдены и вычеркнуты все 
//ключевые слова, в таблице остаются еще несколько букв, из которых Петя должен 
//составить слово, зашифрованное в головоломке. 
//
//Помогите Пете в решении этой головоломки, написав программу, которая по данной таблице 
//и списку ключевых слов выпишет, из каких букв Петя должен сложить слово, то есть 
//какие буквы останутся в таблице после вычеркивания ключевых слов. 
//------------------------------------------------------------------------------------
//ВХОДНЫЕ ДАННЫЕ
//Во входном файле INPUT.TXT записаны два числа N (1<=N<=10) и M (0<=M<=100). 
//Следующие N строк по N заглавных латинских букв описывают ребус. Следующие M строк 
//содержат слова. Слова состоят только из заглавных латинских букв, каждое слово 
//не длиннее 100 символов. Гарантируется, что в таблице можно найти и вычеркнуть
//по описанным выше правилам все ключевые слова. 
//------------------------------------------------------------------------------------
//ВЫХОДНЫЕ ДАННЫЕ
//В выходной файл OUTPUT.TXT выведите в алфавитном порядке оставшиеся в таблице буквы.
//////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <fstream>
#include <iostream>
#include <set>
#include <string>
//////////////////////////////////////////////////////////////////////////////////////
typedef std::string            T_str;
typedef T_str::value_type      T_symb;
typedef std::multiset<T_symb>  T_symb_multiset;
//////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
 
    const T_str    FILE_IN_NAME("input.txt");    
    std::ifstream  file_in(FILE_IN_NAME.c_str());    
    if (!file_in) 
    {        
        std::cerr << "Невозможно открыть файл \"" 
                  << FILE_IN_NAME << "\""
                  << std::endl;
        exit(EXIT_FAILURE);
    }
 
    int  n = 0;
    file_in >> n;
    int  m = 0;
    file_in >> m;    
 
    T_symb_multiset  rebus_letters;
    for(int i = 0; i < n + 1; ++i)
    {
        T_str  rebus_str_cur;
        getline(file_in, rebus_str_cur);
        if(i)
        {
            rebus_letters.insert(rebus_str_cur.begin(), rebus_str_cur.end());
        }        
    }
    
    T_symb_multiset  words_letters;
    for(int i = 0; i < m; ++i)
    {
        T_str  word_cur;
        getline(file_in, word_cur);
        words_letters.insert(word_cur.begin(), word_cur.end());
    }
 
    T_str  remained_letters_str;
    std::set_difference(rebus_letters.begin(), rebus_letters.end(), 
                        words_letters.begin(), words_letters.end(), 
                        std::back_inserter(remained_letters_str));
 
    const T_str    FILE_OUT_NAME("output.txt");    
    std::ofstream  file_out(FILE_OUT_NAME.c_str());    
    if (!file_out) 
    {        
        std::cerr << "Невозможно открыть файл \"" 
                  << FILE_OUT_NAME << "\""
                  << std::endl;
        exit(EXIT_FAILURE);
    }
 
    file_out << remained_letters_str;  
}

#include <fstream>
#include <string>
 
using namespace std;
 
ifstream cin("input.txt");
ofstream cout("output.txt");
 
int main()
{
    int a[26] = {0}, n, m;
    cin >> n >> m;
    for(int i = 0; i < n; i++)
        for(int j = 0; j < n; j++)
        {
            char ch;
            cin >> ch;
            a[ch-'A']++;
        }
    for(int i = 0; i < m; i++)
    {
        string s;
        cin >> s;
        for(int j = 0; j < s.size(); j++)
            a[s[j]-'A']--;
    }
    for(int i = 0; i < 26; i++)
        for(int j = 0; j < a[i]; j++)
            cout << char(i+'A');
}

//////////////////////////////////////////////////////////////////////////////////////
//БУТЫЛКИ
//(Время: 1 сек. Память: 16 Мб Сложность: 48%)
//Группа программистов собралась в понедельник и на все свои деньги купила «Sprite» 
//в бутылках емкостью по 0.25 л., не забыв взять сдачу. 
//Во вторник они сдали пустую посуду, добавили оставшуюся сдачу и вновь купили столько 
//таких же бутылок «Sprite», сколько могли. 
//Так они действовали до пятницы. В пятницу, сдав посуду и добавив сдачу с четверга, 
//они смогли купить только одну бутылку напитка. При этом денег у них уже не осталось. 
//Требуется написать программу, определяющую минимальную сумму, которой располагали 
//программисты в понедельник.
//------------------------------------------------------------------------------------
//ВХОДНЫЕ ДАННЫЕ
//Входной файл INPUT.TXT состоит из единственной строки, содержащей два целых числа F 
//(стоимость одной бутылки «Sprite») и P (стоимость одной пустой бутылки из под «Sprite»), 
//разделенных пробелом. 
//
//Ограничения: 1 ≤ P < F ≤ 10^9, начальная сумма не превосходит 2*10^9. 
//------------------------------------------------------------------------------------
//ВЫХОДНЫЕ ДАННЫЕ
//В единственную строку выходного файла OUTPUT.TXT нужно вывести одно целое число 
//– минимальную сумму, которой располагали программисты в понедельник.
//Пример:
//INPUT.TXT
//7 3
//OUTPUT.TXT
//83
//////////////////////////////////////////////////////////////////////////////////////
#include <iostream>
//////////////////////////////////////////////////////////////////////////////////////
typedef long long  T_int;
//////////////////////////////////////////////////////////////////////////////////////
T_int  get_prev_sum(T_int  sum, T_int F, T_int P)
{
    return  ((sum - F) / P + 1) * (F - P) + sum;        
}
//////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    const T_int F_MAX = 1000000000;
    const T_int F_MIN = 2;
    const T_int P_MIN = 1;
 
    T_int F = 0;
    do
    {
        std::cout << "Стоимость полной бутылки F ("
                  << F_MIN 
                  << " <= F <= "
                  << F_MAX
                  << "): ";
        
        std::cin >> F;
    
    }while(   F < F_MIN
           || F_MAX < F);
 
    std::cout << std::endl;
 
    T_int P = 0;
    do
    {
        std::cout << "Стоимость пустой бутылки P ("
                  << P_MIN 
                  << " <= P < "
                  << F
                  << ")          : ";
        
        std::cin >> P;
    
    }while(   P < P_MIN
           || F <= P);
 
    T_int min_start_sum = F;
    for(T_int  i = 0; i < 4; ++i)
    {
        min_start_sum = get_prev_sum(min_start_sum, F, P);
    }
 
    std::cout << "Минимальная начальная сумма                      : "
              << min_start_sum
              << std::endl;
}