Информатика: Расстановка шахматных фигур — различия между версиями

Материал из Department of Theoretical and Applied Mechanics
Перейти к: навигация, поиск
 
(не показаны 22 промежуточные версии 9 участников)
Строка 1: Строка 1:
'''[[Лебедев Станислав]]'''
+
'''[[Абрамов Игорь]]'''
 +
 
 +
'''Алгоритм''': в зависимости от выбранного режима работы, после ввода пользователем необходимой информации о размере поля а также типе расставляемых фигур, запускается основная рекурсивная функция, которая либо подсчитывает все возможные расстановки для заданного числа фигур и выводит их в файл, либо рассчитывает максимально возможное расставляемое число фигур. В первом режиме это происходит путём установки фигуры в свободную клетку и отметки клеток, которые бьются данной фигурой, затем запускается эта же функция для оставшихся клеток и т.д., пока число поставленных фигур не дойдёт до числа, заданного пользователем. Тогда эта расстановка выводится в файл и счётчик числа расстановок увеличивается на единицу. Во втором режиме как только находится расстановка для данного количества фигур, функция завершает свою работу, увеличивается счётчик количества фигур и функция вызывается уже для большего количества фигур, пока не будет найдено максимально возможное расставляемое на данной доске число фигур. 
 +
 
 +
'''Инструкция''': В меню пользователю предлагается указать размеры доски, тип расставляемых фигур и режим работы программы. После этого, если был выбран режим вывода всех расстановок, необходимо ввести количество расставляемых фигур, после чего программа выведет на экран количество расстановок, а в файле "output.txt" появятся изображения всех расстановок. При выборе второго режима, на экран будет выведено максимальное число фигур заданного типа, которые можно расставить на данной доске.
 +
 
 +
Ссылка для скачивания:[http://tm.spbstu.ru/File:Chess_Abramov.rar]
  
'''Функционал программы''': получение всевозможных расстановок n однотипных шахматных фигур первой линии на поле n на n,таких,чтобы фигуры не били друг друга(считается,что фигуры одного цвета также могут бить друг друга) или получения максимального количества фигур первой линии,которые могут стоять на доске n*n;
+
'''[[Андреева Полина]]'''
  
'''Идея алгоритма''': рекурсивно вызывается функция,которая ставит фигуру в пустую и небитую клетку, а также отмечает клетки,которые эта фигура бьет. Рекурсия продолжается до тех пор,пока либо не будет достигнуто нужное количество, либо не будет возможности поставить фигуру. После выхода из рекурсии начинается "обратный ход", в котором отмеченные как битые на этом шаге,"размечаются"(снимается отметка,что эта клетка бьется),а место,занятое самой фигурой, запоминается.
+
'''Краткое описание алгоритма''':если шахматную доску представить в виде одной строчки(вторую поставить следом за первой, третью за второй и тд), то получится двоичное число. Максимальное число которое может получиться если 111...111 перевести в десятичное ,это число М*М. Тогда абсолютно ВСЕ варианты расстановки фигур это двоичные записи чисел от 0 до М*М. В программе есть цикл, который рассматривает каждый вариант для числа от 0 до М*М, переводит его в двоичную форму. Программа рассматривает каждую клетку, где стоит фигура. Если эта фигура бьет других, то цикл прерывается, нам такой вариант не подходит. Если никакая фигура не бьет никакую другую, то идет подсчет количества фигур на доске. Если фигур столько, сколько нужно, то вывод на экран.
  
Скачать можно  [http://tm.spbstu.ru/Файл:Шахматы.rar тут].
+
'''Инструкция''': На экране показано соответствие каждому номеру типа фигуры. Пользователь выбирает тип фигуры, испольуя номер. Дальше нужно ввести размер доски. Затем на экране появляется два варианта количества фигур на доске: максимальное или введенное пользователем. Пользователь выбирает вариант. Если второй, то затем надо будет ввести количество фигур.
 +
[http://tm.spbstu.ru/Файл:ШахматыАП.rar Программа]
  
 
<div class="mw-collapsible mw-collapsed" style="width:100%" >
 
<div class="mw-collapsible mw-collapsed" style="width:100%" >
<syntaxhighlight lang="cpp" line start="1" enclose="div">
+
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 +
#include <cstring>
 
#include <iostream>
 
#include <iostream>
#include <math.h>
+
#include"math.h"
#include <cmath>
+
#include <fstream>
 
 
 
using namespace std;
 
using namespace std;
  
int n,type, *a, *stak, variant, maxst = 0;
+
int M, N;  // M-размер доски, N-коичество шахмат.
 +
int    sum;//нужно в процессе для подсчета количества шахмат
 +
int **ChessBoard= new int* [M];
  
void king(int x, int &top)                     //отметить битые клетки королем
+
void ChessBoards(int k) //создание доски, k-число, которое переводим в двоичную запись, чтобы отобразить на доске расстановку фигур, 1-фигура есть, 0-нет.
 
{
 
{
     // 012
+
     for (int i=0; i<M; i++) //создание массива
    // 345
+
     {
     // 678
+
        ChessBoard[i] = new int[M];
 
+
     }
     //0
+
     for (int x=(M-1); x>=0; x=x-1)//заполнение массива фигурами (переводя k в двоичную форму)
     if (((x % n) > 1) && ((x / n) > 1))
 
 
     {
 
     {
         int ii = x - n - 1;
+
         for (int y=(M-1); y>=0; y=y-1)
        if (a[ii] != -2)
 
 
         {
 
         {
             a[ii]++;
+
             ChessBoard[x][y]=(k%2);
            stak[top] = ii;
+
             k=k/2;
             top++;
 
 
         }
 
         }
 
     }
 
     }
 +
}
 +
void print (char filename[] ) ///создание функции вывода массива в файл
 +
    {
 +
        ofstream fout(filename, ios::app);
  
    //1
+
        for (int x=0; x<M; ++x)
    if ((x / n) > 0)
 
    {
 
        int ii = x - n;
 
        if (a[ii] != -2)
 
 
         {
 
         {
             a[ii]++;
+
             for(int y=0; y<M; ++y)
             stak[top] = ii;
+
             {
             top++;
+
                fout << ChessBoard[x][y]<<" "; ///вывод массива в файл
 +
            }
 +
             fout <<'\n';
 +
 
 
         }
 
         }
 +
        fout <<"\n\n";
 +
 +
        fout.close();
 
     }
 
     }
  
    //2
+
 
     if (((x % n) < (n - 1)) && ((x / n) > 0))
+
 
 +
bool CheckHorse(int x, int y)//проверка для коня в клетке с номером x, y
 +
{
 +
 
 +
     if (((x+1)<M) && ((y+2)<M) && (ChessBoard[x+1][y+2]==1))//если в клетке, куда может сходить конь (х+1,у+2) уже есть фигура, то этот вариант не подходит, так как один конь бьет другого.
 
     {
 
     {
         int ii = x - n + 1;
+
         return false;
        if (a[ii] != -2)
+
 
        {
 
            a[ii]++;
 
            stak[top] = ii;
 
            top++;
 
        }
 
 
     }
 
     }
 +
    else if (((x+1)<M ) && ((y-2)>=0) && (ChessBoard[x+1][y-2]==1))//то же самое и в остальных случаях проверяем бьет ли один конь другого.
 +
    {
 +
        return false;
  
     //3
+
     }
     if ((x % n) > 0)
+
     else if (((x-1)>=0) && ((y+2)<M) && (ChessBoard[x-1][y+2]==1))
 
     {
 
     {
         int ii = x - 1;
+
         return false;
        if (a[ii] != -2)
 
        {
 
            a[ii]++;
 
            stak[top] = ii;
 
            top++;
 
        }
 
 
     }
 
     }
 
+
     else if (((x-1)>=0) && ((y-2)>=0) && (ChessBoard[x-1][y-2]==1))
    //5
 
     if ((x % n) < (n - 1))
 
 
     {
 
     {
         int ii = x + 1;
+
         return false;
        if (a[ii] != -2)
 
        {
 
            a[ii]++;
 
            stak[top] = ii;
 
            top++;
 
        }
 
 
     }
 
     }
 
+
     else if (((x+2)<M) && ((y+1)<M) && (ChessBoard[x+2][y+1]==1))
    //6
 
     if (((x % n ) > 0) && ((x / n) < (n - 1)))
 
 
     {
 
     {
         int ii = x + n - 1;
+
         return false;
        if (a[ii] != -2)
 
        {
 
            a[ii]++;
 
            stak[top] = ii;
 
            top++;
 
        }
 
 
     }
 
     }
 
+
     else if (((x+2)<M ) && ((y-1)>=0) && (ChessBoard[x+2][y-1]==1))
    //7
 
     if ((x / n ) < (n - 1))
 
 
     {
 
     {
         int ii = x + n;
+
         return false;
        if (a[ii] != -2)
+
    }
         {
+
    else if (((x-2)>=0 ) && ((y+1)<M) && (ChessBoard[x-2][y+1]==1))
            a[ii]++;
+
    {
            stak[top] = ii;
+
         return false;
            top++;
+
    }
         }
+
    else if (((x-2)>=0 ) && ((y-1)>=0) && (ChessBoard[x-2][y-1]==1))
 +
    {
 +
         return false;
 
     }
 
     }
 
+
     else //в итоге, если конь, стоящий в данной клетке никого не бьет, то этот вариант подходит
     //8
 
    if (((x % n ) < (n - 1)) && ((x / n) < (n - 1)))
 
 
     {
 
     {
         int ii = x + n + 1;
+
         return true;
    if (a[ii] != -2)
 
        {
 
            a[ii]++;
 
            stak[top] = ii;
 
            top++;
 
        }
 
 
     }
 
     }
 
}
 
}
  
void bishop(int x, int &top)                                                              //отметить битые клетки слоном
+
int Horse(int k)//k-то число которое нужно будет перевести в двоичную форму, это делается в main'е
 +
//в этой функции считаем количество фигур, если он равно введенному  или максимальному,то доска подходит и выводится в файл (все это в main'е)
 
{
 
{
    //вверх влево
+
     for (int x=0; x<M; x++)
     for (int i = (x - (n + 1)); ((i >= 0) && ((i%n) != (n-1))); i -= (n+1))
 
 
     {
 
     {
         if (a[i] != -2)
+
         int y;
 +
        for (y=0; y<M; y++)
 
         {
 
         {
             a[i]++;
+
             if (ChessBoard[x][y]==1)//если в данной клетке стоит конь, то нужно проверить,
            stak[top] = i;
+
            // бьет оно кого-то или нет...
            top++;
+
            //если в клетке нет коня, то ее проверять не нужно
        }
+
            {
    }
+
                if (CheckHorse(x,y))//...делаем это с помощью этой функции,если конь в данной клетке х;у 
 
+
                //никого не бьет, то прибавляем 1 к количеству шахмат на доске и считаем дальше 
    //вниз вправо
+
                {
    for (int i = (x + (n + 1)); ((i < n*n) && ((i%n) != 0)); i += (n+1))
+
                    sum=sum+1;
    {
+
                }
         if (a[i] != -2)
+
                else //а если бьет, то выходим из цикла, на данной этапе выйдем только из внуреннего
 +
                {
 +
                    sum=0;//количество фигур обнуляем
 +
                    break;
 +
                }
 +
            }
 +
        }
 +
         if (y<M)//если из внутреннего цикла вышли раньше, значит у досчитался не до конца,
 +
        //то есть он меньше своего максимального значения М
 
         {
 
         {
             a[i]++;
+
              
            stak[top] = i;
+
             break;//тогда выходим и из внешнего цикла
             top++;
 
 
         }
 
         }
 
     }
 
     }
 +
    return sum; //возвращаем количество фигур
 +
}
  
    //вверх вправо
+
bool CheckKing(int x, int y) //все то же самое для проверки короля, стоящего в клетке х,у
     for (int i = x - (n - 1); ((i >= 0) && ((i%n) != 0)); i -= (n-1))
+
{
 +
 
 +
     if (((x+1)<M) && ((y+1)<M) && (ChessBoard[x+1][y+1])==1)//если в клетке куда может сходить король
 +
    //уже есть фигура, то клетка не подходит и т.д
 
     {
 
     {
         if (a[i] != -2)
+
         return false;
        {
+
 
            a[i]++;
 
            stak[top] = i;
 
            top++;
 
        }
 
 
     }
 
     }
 +
    else if (((x+1)<M ) && (ChessBoard[x+1][y]==1))
 +
    {
 +
        return false;
  
     //вниз влево
+
     }
     for (int i = x + (n - 1); ((i < n*n) && ((i%n) != (n-1))); i += (n-1))
+
     else if (((x+1)<M) && ((y-1)>=0) && (ChessBoard[x+1][y-1]==1))
 
     {
 
     {
         if (a[i] != -2)
+
         return false;
        {
 
            a[i]++;
 
            stak[top] = i;
 
            top++;
 
        }
 
 
     }
 
     }
}
+
     else if (((x-1)>=0) && ((y-1)>=0) && (ChessBoard[x-1][y-1]==1))
 
 
void knight(int x, int &top)                                            //отметить битые клетки конем
 
{
 
     if (((x%n) > 0) && (x/n) > 1)
 
 
     {
 
     {
         int ii = x - 2*n - 1;
+
         return false;
        if (a[ii] != -2)
 
        {
 
            a[ii]++;
 
            stak[top] = ii;
 
            top++;
 
        }
 
 
     }
 
     }
 
+
     else if (((x-1)>=0) && ((y+1)<M) && (ChessBoard[x-1][y+1]==1))
     if (((x%n) > 1) && (x/n) > 0)
 
 
     {
 
     {
         int ii = x - n - 2;
+
         return false;
        if (a[ii] != -2)
 
        {
 
            a[ii]++;
 
            stak[top] = ii;
 
            top++;
 
        }
 
 
     }
 
     }
 
+
     else if (((x-1)>=0) && (ChessBoard[x-1][y]==1))
     if (((x%n) > 1) && (x/n) < (n - 1))
 
 
     {
 
     {
         int ii = x + n - 2;
+
         return false;
        if (a[ii] != -2)
 
        {
 
            a[ii]++;
 
            stak[top] = ii;
 
            top++;
 
        }
 
 
     }
 
     }
 
+
     else if (((y+1)<M) && (ChessBoard[x][y+1]==1))
     if (((x%n) > 0) && (x/n) < (n - 2))
 
 
     {
 
     {
         int ii = x + 2*n - 1;
+
         return false;
        if (a[ii] != -2)
 
        {
 
            a[ii]++;
 
            stak[top] = ii;
 
            top++;
 
        }
 
 
     }
 
     }
 
+
     else if (((y-1)>=0) && (ChessBoard[x][y-1]==1))
     if (((x%n) < (n - 1)) && (x/n) < (n - 2))
 
 
     {
 
     {
         int ii = x + 2*n + 1;
+
         return false;
        if (a[ii] != -2)
 
        {
 
            a[ii]++;
 
            stak[top] = ii;
 
            top++;
 
        }
 
 
     }
 
     }
 
+
     else
     if (((x%n) < (n - 2)) && (x/n) < (n - 1))
 
 
     {
 
     {
         int ii = x + n + 2;
+
         return true;
        if (a[ii] != -2)
 
        {
 
            a[ii]++;
 
            stak[top] = ii;
 
            top++;
 
        }
 
 
     }
 
     }
 +
}
  
    if (((x%n) < (n - 2)) && (x/n) < 0)
+
int King(int k) //так же как и для коня, проверяем каждую клетку
 +
//подходит-прибавляем к количеству фигур sum единичку, нет-обнуляем сумму и выходим из цикла
 +
{
 +
    for (int x=0; x<M; x++)
 
     {
 
     {
         int ii = x - n + 2;
+
         int y;
         if (a[ii] != -2)
+
         for (y=0; y<M; y++)
 
         {
 
         {
             a[ii]++;
+
             if (ChessBoard[x][y]==1)
            stak[top] = ii;
+
            {
             top++;
+
                if (CheckKing(x,y))
 +
                {
 +
                    sum=sum+1;
 +
                }
 +
                else
 +
                {
 +
                    sum=0;
 +
                    break;
 +
                }
 +
             }
 
         }
 
         }
    }
+
        if (y<M)
 
 
    if (((x%n) < (n - 1)) && (x/n) < 1)
 
    {
 
        int ii = x - 2*n + 1;
 
        if (a[ii] != -2)
 
 
         {
 
         {
             a[ii]++;
+
             break;
            stak[top] = ii;
 
            top++;
 
 
         }
 
         }
 
     }
 
     }
 +
    return sum;
 
}
 
}
  
void rook(int x, int &top)                                                     //отметить битые клетки ладьей
+
int CheckQueen(int x, int y)///проверка для королевы, принцип тот же, королева стит в клеке x,y
{
+
///1 значит как true в bool (как в коне или короле), 0 - false
     int k = x - (x % n);
+
{ int returnn=1;//начала true, дальше если будет false, то return примет значение 0, а если все пдходит
    while ((k/n) == (x/n))
+
///то так и стается 1
    {
+
int m;
 
+
     for (m=1; m<M; m++)
         if ((k != x) && (a[k] != -2))
+
  { //проверяем для диагоналей
         {
+
    ///если по диагонале клетки х,у стоит еще королва, то такой вариант не подходит, выходим из цикла
             a[k]++;
+
    ///разбито на 4 услвия, так как если не разбивать, то клетка в кторой стоит данная королева
             stak[top] = k;
+
    ///тоже будет считаться и выходить из цикла
             top++;
+
      if (((x+m)<M)&&((y+m)<M))
 +
      {
 +
          if (ChessBoard[x+m][y+m]==1)
 +
          {returnn=0;
 +
          break;
 +
          }
 +
      }
 +
      if (((x-m)>=0)&&((y+m)<M))
 +
      {
 +
          if (ChessBoard[x-m][y+m]==1)
 +
          {returnn=0;
 +
          break;}
 +
      }
 +
      if (((x+m)<M)&&((y-m)>=0))
 +
      {
 +
          if (ChessBoard[x+m][y-m]==1)
 +
         {returnn=0;
 +
          break;}
 +
      }
 +
      if (((x-m)>=0)&&((y-m)>=0))
 +
      { if (ChessBoard[x-m][y-m]==1)
 +
          {returnn=0;
 +
          break;}
 +
      }
 +
      if (m!=x) ///тут считаем по вертикали и горизонтали, так как длаем в цикле для m, то m меняется
 +
        ///и в какой-то момент может стать х, и тогда роверятьбуде клетку в которой стоит ДАННАЯ и выходить
 +
         ///это не нужно так что выходим только если m не равен x
 +
        {
 +
             if (ChessBoard[m][y]==1) //если по горизонтали есть какая-о клетка, где стоит королева, то выходим
 +
             {
 +
                returnn=0;
 +
                break;
 +
             }
 
         }
 
         }
        k ++;
+
         if (m!=y)//то же по вертикали
    }
 
 
 
    k = (x % n);
 
    while (((k/n)) != n)
 
    {
 
         if ((k != x) && (a[k] != -2))
 
 
         {
 
         {
            a[k]++;
+
          if (ChessBoard[x][m]==1)
             stak[top] = k;
+
             {
             top++;
+
                returnn=0;
 +
                break;
 +
             }
 
         }
 
         }
        k += n;
+
  }
    }
+
  return returnn;
 +
}
  
}
+
int Queen(int k)//тут также как и для коня и короля
void set_figure(int x, int &top)                                   //ставим фигуры на доску
 
 
{
 
{
    //отмечаем "битые" клетки
+
for (int x=0; x<M; x++)
    switch (type)
 
 
     {
 
     {
//король
+
        int y;
         case 1:
+
        for (y=0; y<M; y++)
 +
        {
 +
            if (ChessBoard[x][y]==1)//если в клетке королева, проверяем подходи ли она нам
 +
            {
 +
                if (CheckQueen(x,y))
 +
                {
 +
                    sum=sum+1;
 +
                }
 +
                else
 +
                {
 +
                    sum=0;
 +
                    break;
 +
                }
 +
            }
 +
         }
 +
        if (y<M)
 
         {
 
         {
            king(x,top);
 
 
             break;
 
             break;
 
         }
 
         }
 +
    }
 +
    return sum;
 +
}
  
//слон
+
int CheckRook(int x, int y)///ладья, просто берем ту часть из проверки королевы, где проверка по горизонтали и вертикали
case 2:
+
{ int returnn=1;
{
+
int m;
    bishop(x,top);
+
    for (m=0; m<M; m++)
            break;
+
 
}
+
    {
 
+
         if (m!=x)
//конь
 
case 3:
 
{
 
    knight(x,top);
 
break;
 
}
 
//ладья
 
         case 4:
 
 
         {
 
         {
             rook(x,top);
+
             if (ChessBoard[m][y]==1)
            break;
+
            {
 +
                returnn=0;
 +
                break;
 +
            }
 
         }
 
         }
         //ферзь
+
         if (m!=y)
        case 5:
 
 
         {
 
         {
            rook(x,top);
+
          if (ChessBoard[x][m]==1)
             bishop(x,top);
+
             {
            break;
+
                returnn=0;
 +
                break;
 +
            }
 
         }
 
         }
 
     }
 
     }
  
    //отмечаем,что в данной клетке стоит фигура
+
 
a[x] = -1;
+
      return returnn;
    stak[top] = x;
 
    top++;
 
 
}
 
}
  
void step(int top,int x,int st)
+
int Rook(int k)//все то же самое, количество фигур на доске
 
{
 
{
int xtop = top;
+
    for (int x=0; x<M; x++)
switch (variant)
+
    {
{
+
        int y;
case 1:
+
        for (y=0; y<M; y++)
{
+
        {
if (st != (n - 1))
+
            if (ChessBoard[x][y]==1)
{
+
            {
set_figure(x,top);
+
                if (CheckRook(x,y)==1)
for (int i = 0; i < (n*n); i++)
+
                {
if (a[i] == 0)
+
                    sum=sum+1;
step(top,i,st + 1);
 
}
 
else[[:File:Шахматы.rar]]
 
{
 
set_figure(x,top);
 
                cout << endl;
 
for (int i = 0; i < (n*n); i++)
 
{
 
cout.width(3);
 
if (((i % n) == 0) && (i != 0))
 
cout << endl;
 
if (a[i] == -1)
 
cout << 1;
 
else
 
cout << 0;
 
}
 
cout << endl;
 
}
 
break;
 
}
 
case 2:
 
{
 
set_figure(x,top);
 
if ((st+1) > maxst)
 
maxst = st + 1;
 
for (int i = 0; i < (n*n); i++)
 
if (a[i] == 0)
 
step(top,i,st+1);
 
break;
 
}
 
}
 
  
 +
                }
 +
                else
 +
                {
 +
                    sum=0;
 +
                    break;
 +
                }
 +
            }
 +
        }
 +
        if (y<M)
 +
        {
 +
            break;
 +
        }
 +
    }
  
 
+
     return sum;
// обратный ход
 
     for (int i = xtop; i < top; i++)
 
    {
 
        if ((a[stak[i]] != -1) && (a[stak[i]] != -2))
 
            a[stak[i]]--;
 
        else
 
            //не забываем отметить,что фигура уже здесь стояла(чтобы избежать повторов)
 
            if (a[stak[i]] == -1)
 
                a[stak[i]] = -2;
 
//      cerr << " Back "  << stak[i] << endl;
 
    }
 
 
}
 
}
  
int main()
+
int CheckElephant(int x, int y)//для слона берем ту часть прроверки королевы, где по диагонали
{
+
{ int returnn=1;
 
+
  for (int i=1; i<M; i++)
    //cin >> n >> type >> variant;
+
  {
    n = 5;
+
      if (((x+i)<M)&&((y+i)<M))
    type = 4;
+
      {
variant = 1;
+
          if (ChessBoard[x+i][y+i]==1)
    a    = new int[n*n];
+
          {returnn=0;
    stak = new int[n*n*4];
+
          break;
 +
          }
 +
      }
 +
      if (((x-i)>=0)&&((y+i)<M))
 +
      {
 +
          if (ChessBoard[x-i][y+i]==1)
 +
          {returnn=0;
 +
          break;}
 +
      }
 +
      if (((x+i)<M)&&((y-i)>=0))
 +
      {if (ChessBoard[x+i][y-i]==1)
 +
        {returnn=0;
 +
          break;}
 +
      }
 +
      if (((x-i)>=0)&&((y-i)>=0))
 +
      { if (ChessBoard[x-i][y-i]==1)
 +
          {returnn=0;
 +
          break;}
 +
      }
 +
  }
 +
  return returnn;
 +
}
  
    for (int i = 0; i < (n*n); i++)
+
int Elephant(int k)///считаем кличесво фигур
 +
{
 +
for (int x=0; x<M; x++)
 
     {
 
     {
         for (int j = 0; j < (n*n); j++)
+
        int y;
             a[j] = 0;
+
         for (y=0; y<M; y++)
        if (variant == 1)
+
        {
             cout << "__________________________________" << endl;
+
             if (ChessBoard[x][y]==1)
        step(0,i,0);
+
             {
    }
+
                if (CheckElephant(x,y))
if (variant == 2)
+
                {
  cout << maxst;
+
                    sum=sum+1;
     return 0;
+
                }
}
+
                else
</syntaxhighlight>
+
                {
</div>
+
                    sum=0;
 +
                    break;
 +
                }
 +
            }
 +
        }
 +
        if (y<M)
 +
        {
 +
            break;
 +
        }
 +
    }
 +
     return sum;
 +
}
  
 +
int main ()
 +
{
 +
    ofstream MyFile("MyFile", ios::trunc);
 +
    MyFile.close(); // очищаем файл, чтоб при новой записи не было из рошлого запуска
  
 +
int figure, z;
 +
    cout<<"enter a figure 1-queen, 2-king, 3-rook , 4-horse or 5-elephant ";
 +
    cin>>figure;///тип фигуры, 1 - королевА, 2-король,3-ладья,4-конь,6-слон
 +
      cout << "\n enter a size of a board M - even number ";///ввести ЧЕТНЫЙ размер доски М
 +
    cin >> M;
 +
    if ( M%2 != 0)///проверка М на четность, с помощью остатка от деления на 2
 +
    {
 +
        while (M%2 != 0)
 +
        {
 +
            cout<<" you need EVEN number, enter one more time ";
 +
            cin>>M;
 +
        }
 +
    }
  
'''[[Иванова Яна]]'''
+
    cout<<"\n choose  1- max amount or 2 - your amount of figures ";
 +
    cin>>z;///z-один из вариантов 1-максимаьное число фигур на доске,2-пользователь сам вводит
  
'''Краткое описание алгоритма''': Функция, которая выполняет поиск расстановок, пытается поставить фигуру в каждую клетку. В случае неудачи программа отмечает клетки, в которых фигура уже побывала, но постановка не удалась, отрицательной величиной, равной по модулю шагу, на котором эта постановка была испробована. В случае пустой клетки она отмечается нулем, в случае успеха клетка отмечается положительным числом, равным шагу, соответствующему попытке постановки.
+
    switch (figure)///выбираем фигуру
Также программа аналитически просчитывает максимальное количество фигур для каждого размера доски.
+
    {
 
+
    case 1:///королева
'''Инструкция''': В меню указывается два варианта развития событий. Пользователь должен выбрать один из путей. Он вводит размер доски и тип фигуры.
+
    {
Если он выбирает максимальное число расстановок, то программа выводит их количество, а также предлагает вывести все расстановки на экран. Другой вариант работы программы - вывод расстановок N фигур.
+
        if (z==2)///пользоватеь сам вводит количество
 +
        {
 +
            cout<<"\n enter an amount of figures ";
 +
            cin >> N;///ввести количество
 +
            if (N>M)///проверка на то, сможет ли такое количество уместиться на доске в правильном виде
 +
            {
 +
                while (N>M)
 +
                {
 +
                    cout<<" too many figures, enter one more time ";
 +
                    cin>>N;
 +
                }
 +
            }
 +
            ///вот ниже i- те числа которые нужно перевести в двоичную форму
 +
            for (int i=0; i<=pow(2,(M*M)); i++)///каждый i-новый вариант расстановик фигур
 +
            {
 +
                sum=0;
 +
                int k=i;
 +
                ChessBoards(k);
 +
                if (Queen(k)==N)///если в данной варианте фигур столько. сколько ввел пользователь, то выводим
 +
                {
 +
                    print("MyFile");
 +
                }
 +
            }
 +
        }
 +
        else ///вариант максимального числа фигур на доске
 +
        {  ///так же как и в предыдущем пункте, только количество фигур N максимально,
 +
            /// в случае королевы оно равно размеру доски 
 +
            N=M;
 +
            for (int i=0; i<=pow(2,(M*M)); i++)
 +
            {
 +
                sum=0;
 +
                int k=i;
 +
                ChessBoards(k);
 +
                if (Queen(k)==N)
 +
                {
 +
                    print("MyFile");
 +
                }
 +
            }
 +
        }
  
Посмотреть программу можно [http://tm.spbstu.ru/Файл:chess(1).zip здесь]
+
        break;
 
+
    }
<div class="mw-collapsible mw-collapsed" style="width:100%" >
+
    case 2:///то же самое для короля
<syntaxhighlight lang="cpp" line start="1" enclose="div">
+
     {
 
+
         if (z==2)
#include <iostream>
 
#include <algorithm>
 
#include <exception>
 
#include <string>
 
#include <algorithm>
 
 
 
//пусть для определенности максимальный размер доски - 128 клеток
 
#define MAX_SIZE 128
 
 
 
// перечисление для определения типа фигуры
 
enum figure_type
 
{
 
    KING,
 
    QUEEN,
 
    ROOK,
 
    BISHOP,
 
    KNIGHT
 
};
 
 
 
// класс для создания доски и расстановки фигур
 
class chess_board
 
{
 
public:
 
    // конструктор (принимает только размеры)
 
    chess_board(const int &size)
 
     {
 
         if (size >= 0 && size <= MAX_SIZE)
 
 
         {
 
         {
             size_ = size;
+
             cout<<"\n enter an amount of figures ";
             clean_board();
+
             cin >> N;
        }
+
              if ( N>(M*M)/4)
 
+
            {
        else
+
                while (N>(M*M)/4)
        {
+
                {
            std::cout << "wrong size" << std::endl;
+
                    cout<<" too many figures, enter one more time ";
             throw std::string("wrong size");
+
                    cin>>N;
 +
                }
 +
            }
 +
            for (int i=0; i<=pow(2,(M*M)); i++)
 +
             {
 +
                sum=0;
 +
                int k=i;
 +
                ChessBoards(k);
 +
                if (King(k)==N)
 +
                {
 +
                    print("MyFile");
 +
                }
 +
            }
 
         }
 
         }
    }
+
else
 
 
 
 
    // функция очистки доски (занулить все клетки)
 
    void clean_board()
 
    {
 
        //обнулить счетчик количества фигур на доске
 
        figures_on_board_ = 0;
 
        //присвоить всем клеткам значение 0
 
        for (int i = 0; i < size_; ++i)
 
 
         {
 
         {
             for (int j = 0; j < size_; ++j)
+
            N=(M*M)/4;
 +
             for (int i=0; i<=pow(2,(M*M)); i++)
 
             {
 
             {
                 board_[i][j] = 0;
+
                 sum=0;
 +
                int k=i;
 +
                ChessBoards(k);
 +
                if (King(k)==N)
 +
                {
 +
                    print("MyFile");
 +
                }
 
             }
 
             }
 
         }
 
         }
 +
        break;
 
     }
 
     }
 
+
     case 3:///для ладьи
     // функция, принимающая размер доски
 
    int get_size()
 
 
     {
 
     {
         return size_;
+
         if (z==2)
    }
+
        {
    // функция, обновляющая количество фигур на доске
+
            cout<<"\n enter an amount of figures ";
    int get_figures_number()
+
            cin >> N;
    {
+
              if (N>M)
        return figures_on_board_;
+
            {
    }
+
                while (N>M)
 +
                {
 +
                    cout<<" too many figures, enter one more time ";
 +
                    cin>>N;
 +
                }
 +
            }
  
    //функция, пытающаяся поставить фигуру на свободное место и возвращающая
+
            for (int i=0; i<=pow(2,(M*M)); i++)
    //истину в случае успеха и ложь в случае неудачи
+
            {
    bool put_figure (const figure_type& figure, const int& x, const int& y, const int& step)
+
                sum=0;
    {
+
                int k=i;
        if (board_[x][y] > 0 || board_[x][y] < -step)
+
                ChessBoards(k);
        {
+
                if (Rook(k)==N)
          //если здесь уже стоит фигура или мы когда-то пытались ее сюда поставить, вернуть ложь
+
                {
            return false;
+
                    print("MyFile");
        }
+
                }
 
+
             }
        if (check_figure(figure, x, y))
 
        {
 
            board_[x][y] = step;
 
            ++figures_on_board_;
 
             return true;
 
 
         }
 
         }
 
         else
 
         else
 
         {
 
         {
             return false;
+
             N=M;
        }
+
            for (int i=0; i<=pow(2,(M*M)); i++)
    }
+
            {
 
+
                sum=0;
    //отметить клетку как ранее пройденную функцией
+
                int k=i;
    //вычесть единицу из количества фигур на доске
+
                ChessBoards(k);
    void remove_figure(const int& x, const int& y)
+
                if (Rook(k)==N)
    {
+
                {
         board_[x][y] *= -1;
+
                    print("MyFile");
         --figures_on_board_;
+
                }
 +
            }
 +
         }
 +
         break;
 
     }
 
     }
 
+
     case 4:///конь
     //функция печати доски на экран
 
    void print() const
 
 
     {
 
     {
         using namespace std;
+
         if (z==2)
        cout << "==========================================" << endl;
 
        for (int i = 0; i < size_; ++i)
 
 
         {
 
         {
             for (int j = 0; j < size_; ++j)
+
             cout<<"\n enter an amount of figures ";
 +
            cin >> N;
 +
              if (N>(M*M)/2)
 
             {
 
             {
                 //если фигура стоит в клетке, то вывести "*", если нет - вывести "-"
+
                 while (N>(M*M)/2)
                 cout << (board_[i][j] > 0?"*":"-") << " ";
+
                 {
 +
                    cout<<" too many figures, enter one more time ";
 +
                    cin>>N;
 +
                }
 
             }
 
             }
            cout << endl;
 
        }
 
        cout << "==========================================" << endl;
 
    }
 
  
private:
+
            for (int i=0; i<=pow(2,(M*M)); i++)
 
+
             {
    //функция, проверяющая возможность или невозможность постановки фигуры на данную клетку
+
                 sum=0;
    bool check_figure(const figure_type& figure, const int& x, const int& y)
+
                int k=i;
    {
+
                ChessBoards(k);
        //выбор следующего действия в зависимости от типа фигуры
+
                if (Horse(k)==N)
        switch (figure)
 
        {
 
            case KING:
 
                return check_king(x, y);
 
            case QUEEN:
 
                return check_queen(x, y);
 
            case ROOK:
 
                return check_rook(x, y);
 
            case BISHOP:
 
                return check_bishop(x, y);
 
            case KNIGHT:
 
                return check_knight(x, y);
 
                //в случае ошибки ввода вернуть ложь
 
             default:
 
                 return false;
 
        }
 
    }
 
 
 
    //поиск расстановок короля
 
    bool check_king(const int& x, const int& y)
 
    {
 
        int min_x = std::max(x - 1, 0);
 
        int max_x = std::min(x + 1, size_ - 1);
 
        int min_y = std::max(y - 1, 0);
 
        int max_y = std::min(y + 1, size_ - 1);
 
 
 
        for (int i = min_x; i <= max_x; ++i)
 
        {
 
            for (int j = min_y; j <= max_y; ++j)
 
            {
 
                if (board_[i][j] > 0)
 
 
                 {
 
                 {
                     return false;
+
                     print("MyFile");
 
                 }
 
                 }
 
             }
 
             }
 
         }
 
         }
         return true;
+
         else
 +
        {
 +
            N=(M*M)/2;
 +
            for (int i=0; i<=pow(2,(M*M)); i++)
 +
            {
 +
                sum=0;
 +
                int k=i;
 +
                ChessBoards(k);
 +
                if (Horse(k)==N)
 +
                {
 +
                    print("MyFile");
 +
                }
 +
            }
 +
        }
 +
        break;
 
     }
 
     }
 
+
     case 5:///слон
     //поиск расстановок ладьи
 
    bool check_rook(const int& x, const int& y)
 
 
     {
 
     {
         for (int i = 0; i < size_; ++i)
+
         if (z==2)
 
         {
 
         {
             if (board_[i][y] > 0)
+
             cout<<"\n enter an amount of figures ";
 +
            cin >> N;
 +
                if (N>2*M-2)
 +
            {
 +
                while (N>2*M-2)
 +
                {
 +
                    cout<<" too many figures, enter one more time ";
 +
                    cin>>N;
 +
                }
 +
            }
 +
            for (int i=0; i<=pow(2,(M*M)); i++)
 
             {
 
             {
                 return false;
+
                 sum=0;
 +
                int k=i;
 +
                ChessBoards(k);
 +
                if (Elephant(k)==N)
 +
                {
 +
                    print("MyFile");
 +
                }
 
             }
 
             }
 
         }
 
         }
         for (int j = 0; j < size_; ++j)
+
         else
 
         {
 
         {
             if (board_[x][j] > 0)
+
             N=2*M-2;
 +
            for (int i=0; i<=pow(2,(M*M)); i++)
 
             {
 
             {
                 return false;
+
                 sum=0;
             }
+
                int k=i;
         }
+
                ChessBoards(k);
         return true;
+
                if (Elephant(k)==N)
 +
                {
 +
                    print("MyFile");
 +
                }
 +
             }
 +
         }
 +
         break;
 
     }
 
     }
 +
    default : ///а это еси пользоватеь ввел цифру, которая не соответстует ни одной фигуре
 +
    {
 +
        cout<<"NOOOOO";
 +
        break;
 +
    }
 +
    };
  
    //поиск расстановок слона
 
    bool check_bishop(const int& x, const int& y)
 
    {
 
        bool check = true;
 
  
        int k_start_1 = -std::min(x, y);
+
    return 0;
        int k_end_1 = std::min( size_ - x, size_ - y) - 1;
+
    }
 +
</syntaxhighlight>
 +
</div>
  
        int k_start_2 = -std::min( x, size_ - y - 1);
+
'''[[Бальцер Анастасия]]'''
        int k_end_2 = std::min( y, size_ - x - 1);
 
  
 +
'''Краткое описание алгоритма''': Для каждой фигуры написана отдельная функция, выполняющая поиск расстановок. После выбора типа фигуры, соответствующая функция выполняет поиск возможных расстановок. Она проходя по строкам двумерного массива пытается поставить фигуру в каждую клетку. Проходя по массиву она маркирует клетки, ставит 0 (если клетка свободна), 1 (если клетка находится под ударом), 2 (если клетка занята). Программа аналитически считает максимальное количество фигур для заданного размера доски, возможное число расстановок для заданных типа фигуры, размера доски и количества фигур.
  
        for (int k = k_start_1; k <= k_end_1; ++k)
+
'''Инструкция''': При запуске программы появляется меню, в котором каждому типу фигуры сопоставлен номер, с помощью которого пользователь и выбирает тип фигуры. Затем пользователю на выбор предлагается 2 режима работы программы: первый выводит число возможных расстановок на экран, а список возможных расстановок в отдельный файл (при этом пользователь дополнительно выбирает число фигур); второй выводит на экран максимальное число фигур выбранного типа, которые можно расставить на заданной доске.
        {
 
            check = check_coord(x + k, y + k) && check ;
 
        }
 
        for (int k = k_start_2; k <= k_end_2; ++k)
 
        {
 
            check = check_coord(x + k, y - k) && check;
 
        }
 
  
        return check;
+
Посмотреть программу можно [http://tm.spbstu.ru/Файл:Расстановка.zip тут]
    }
 
  
 +
'''[[Белоусова Екатерина]]'''
  
    //поиск расстановок коня
+
'''Краткое описание алгоритма''': доска представлена в виде динамического массива, заполненного 1 и 0. 1-стоит фигура, 0-пустое место. Программа при помощи рекурсии вызывает функцию, которая ставит фигуру в пустую клетку и проверяет, находится ли эта фигура под ударом других.
    bool check_knight(const int& x, const int& y)
 
    {
 
        bool check =
 
            check_coord(x - 2, y - 1) &&
 
            check_coord(x - 2, y + 1) &&
 
            check_coord(x - 1, y - 2) &&
 
            check_coord(x - 1, y + 2) &&
 
            check_coord(x + 1, y - 2) &&
 
            check_coord(x + 1, y + 2) &&
 
            check_coord(x + 2, y - 1) &&
 
            check_coord(x + 2, y + 1);
 
        return check;
 
    }
 
  
    //поиск расстановок королевы
+
'''Инструкция''': пользователь вводит четный размер доски М*М, затем выбирает, какую фигуру он хочет расставить на этой доске, после чего ему предлагается выбрать количество фигур(в скобках указывается максимальное количество фигур, которые можно расставить на доске М*М).Программа выводит на экран всевозможные расстановки, пронумеровывая каждую, и сохраняет их в файл.
    bool check_queen(const int& x, const int& y)
 
    {
 
        return check_rook(x, y) && check_bishop(x, y);
 
    }
 
  
  //функция поиска расстановок, в случае, когда на доске что-то стоит, вернуть ложь
+
Скачать можно  [http://tm.spbstu.ru/Файл:задача_1.zip тут].
  //иначе поставить вернуть истину
 
    bool check_coord(const int& x, const int& y)
 
    {
 
        if (x >= 0 && x < size_ && y >= 0 && y < size_)
 
        {
 
            if (board_[x][y] > 0)
 
            {
 
                return false;
 
            }
 
        }
 
        return true;
 
    }
 
  
    // if board_[x][y] == 0
+
<div class="mw-collapsible mw-collapsed" style="width:100%" >
    //    клетка свободна
+
<syntaxhighlight lang="cpp" line start="1" enclose="div">
    // if board_[x][y] == s
+
#include <iostream>
    //    фигура была поставлена на шаге S
+
#include <stdlib.h>
    // if board_[x][y] == -s
+
#include <stdio.h>
    //    клетка свободна, но была попытка поставить фигуру на шаге S
+
#include <string>
    int board_[MAX_SIZE][MAX_SIZE];
+
#include <cstring>
    int size_;
+
#include <fstream>
    int figures_on_board_;
+
#include <locale.h>
};
+
#include<iomanip>
 +
#include<math.h>
 +
 
 +
using namespace std;
 +
 
 +
 
 +
int n, figureID, figura, maxCount; /// n - размер доски, figureID - номер фигуры, figura - колическтво фигур, maxCount - максимальное возможное количество фигур
 +
int results_count = 0; /// определяем тип и задаем начальное значение results_count(номер результата)
 +
int **mass; /// определяем двумерный массив
  
//функция расчета максимума для любой доски в зависимости от типа фигуры
+
///создаем массив размером n*n
int get_max_figures (const figure_type& figure, const int& size)
+
int** create_mass(int n)
 
{
 
{
     switch (figure)
+
 
 +
     int **mass = new int* [n];
 +
    for (int a=0; a<n; ++a)
 
     {
 
     {
         case KING:
+
         mass[a] = new int [n];
            return (size + 1) / 2;
+
         memset((char*)mass[a],0,n*sizeof(int)); ///зануление массива
         case QUEEN:
+
    }
            if (size <= 2)
+
 
            {
+
        return mass;
                return 1;
+
 
            }
+
}
            else if (size == 3)
+
 
            {
+
///функция вывода массива
                return 2;
+
void output_mass ()
            }
+
{
            else
+
 
            {
+
    for (int a=0; a<n; ++a)///заполнение ячеек массива от 0 до n по горизонтали
                return size;
+
    {
            }
+
 
        case ROOK:
+
         for(int b=0; b<n; ++b)///заполнение ячеек массива от 0 до n по вертикали
            return size;
+
        {
        case BISHOP:
+
            cout << mass[a][b]<<" "; ///вывод массива на экран
            if (size == 1)
+
        }
            {
+
 
                return size;
+
        cout << '\n';
            }
+
 
            else
 
            {
 
                return 2 * (size - 1);
 
            }
 
         case KNIGHT:
 
            if (size <= 2)
 
            {
 
                return size * size;
 
            }
 
            else
 
            {
 
                return (size * size + 1) / 2;
 
            }
 
        default:
 
            return 1;
 
 
     }
 
     }
 +
 +
    cout << "Result #" << ++results_count <<"\n\n"; /// вывод номера результата
 +
 
}
 
}
  
//функция для расстановки максимального числа фигур на доске
+
void zapis (char Zapis[] ) ///функции записи решений в файл
void place_figures_for_max(chess_board &board, const figure_type& figure, const int& max_figures, int step)
 
 
{
 
{
     ++step;
+
     ofstream fout(Zapis, ios::app);///запись в фаил "Zapis"
    const int size = board.get_size();
+
 
     for (int i = 0; i < size; ++i)
+
     for (int x=0; x<n; ++x)///заполнение ячеек массива от 0 до n по горизонтали
 
     {
 
     {
         for (int j = 0; j < size; ++j)
+
         for(int y=0; y<n; ++y)///заполнение ячеек массива от 0 до n по вертикали
 
         {
 
         {
             //если мы можем поставить фигуру, то добавляем к максимуму единицу и запускаем цикл снова
+
             fout<< mass[x][y]<<" "; ///вывод решений в файл
            if (board.put_figure(figure, i, j, step))
 
            {
 
                //если число фигур на доске достигло максимума, то вывести доску
 
                if (board.get_figures_number() == max_figures)
 
                {
 
                    board.print();
 
                }
 
                //если число фигур не достигло максимума, продолжить выполнение функции
 
                else
 
                {
 
                    place_figures_for_max(board, figure, max_figures, step);
 
                }
 
                board.remove_figure(i, j);
 
            }
 
 
         }
 
         }
 +
        fout<<'\n';
 
     }
 
     }
 +
    fout<<"\n\n";
 +
    fout.close();
 
}
 
}
  
//функция, принимающая ввод с клавиатуры как строковый тип данных
+
///проверяем наличие фигуры в строке а
figure_type get_figure_type(const std::string& str)
+
bool isEmptyHorisontal(int a)
 
{
 
{
    using namespace std;
 
  
     figure_type figure;
+
     for(int i=0; i<n; ++i)///создаем цикл от 0 до n
    if (str == string("king"))
 
 
     {
 
     {
         figure = KING;}
+
         if(mass[a][i])///в каждой ячейке массива [a][i]
    else if (str == string("queen"))
+
         {
    {
+
            return false;///неверно
         figure = QUEEN;}
+
         }
    else if (str == string("rook"))
 
    {
 
        figure = ROOK;
 
    }
 
    else if (str == string("bishop"))
 
    {
 
        figure = BISHOP;
 
    }
 
    else if (str == string("knight"))
 
    {
 
      figure = KNIGHT;
 
    }
 
    //вывести ошибку в случае неверного ввода
 
    else
 
    {
 
         cout << "wrong figure type" << endl;
 
        throw string("wrong figure type");
 
 
     }
 
     }
  
     return figure;
+
     return true;///в остальных случаях верно
 +
 
 
}
 
}
  
int main()
+
///проверяем наличие фигур в столбце b
 +
bool isEmptyVertical(int b)
 
{
 
{
    //использовать стандартное пространств имен
 
    using namespace std;
 
  
     int size;
+
     for(int i=0; i<n; ++i)///создаем цикл от 0 до n
     string type_of_figure;
+
     {
    string type_of_action;
+
        if(mass[i][b])///в каждой ячейке массива [i][b]
     figure_type figure;
+
        {
 +
            return false;///неверно
 +
        }
 +
     }
  
     cout << "Возможные фигуры: king, queen, rook, bishop, knight" << endl;
+
     return true;///в остальных случаях верно
    cout << "Возможные действия: max, placing" << endl;
 
    cout << "----------------------------------------------------" << endl;
 
  
    cout <<"Введите размер доски: ";
+
}
    cin >> size;
 
    chess_board board(size);
 
  
    cout << "Введите тип фигуры: ";
+
///проверяем наличие фигур на диагоналях
    cin >> type_of_figure;
+
bool isEmptyDiagonales(int a, int b)
    figure = get_figure_type(type_of_figure);
+
{
  
     cout << "Введите необходимое действие: ";
+
     for(int i=1; a-i>=0 && b-i>=0; ++i)///диагональ влево-вверх
     cin >> type_of_action;
+
     {
 +
        if(mass[a-i][b-i])///в каждой ячейке массива [a-i][b-i]
 +
        {
 +
            return false;///неверно
 +
        }
 +
    }
  
     if (type_of_action == string("max"))
+
     for(int i=1; a+i<n && b+i<n; ++i)///диагональ вправо-вниз
 
     {
 
     {
 
+
         if(mass[a+i][b+i])///в каждой ячейке массива [a+i][b+i]
         int max_figures = get_max_figures(figure, size);
 
        cout << "Max figures: " << max_figures << endl;
 
 
 
        cout << "Хотите ли вы просмотреть все варианты? (yes/no) ";
 
        string answer;
 
        cin >> answer;
 
        //если нужно вывести все расстановки, то применить непосредственно функцию поиска расстановок максимума
 
        if (answer == string("yes"))
 
 
         {
 
         {
             int step = 0;
+
             return false;///неверно
            place_figures_for_max(board, figure, max_figures, step);
 
 
         }
 
         }
 
     }
 
     }
    //иначе если нужно расставить определенное количество фигур, то применить функцию поиска расстановок
 
    //относительно введенного числа
 
    else if (type_of_action == string("placing"))
 
    {
 
        int figures_to_place;
 
        cout << "Сколько фигур нужно расставить: ";
 
        cin >> figures_to_place;
 
  
        int step = 0;
+
    for(int i=1; a+i<n && b-i>=0; ++i)///диагональ влево-вниз
        place_figures_for_max(board, figure, figures_to_place, step);
 
    }
 
    //иначе вывести ошибку действия
 
    else
 
 
     {
 
     {
         cout << "wrong type of action" << endl;
+
         if(mass[a+i][b-i])///в каждой ячейке массива [a+i][b-i]
         throw string("wrong type of action");
+
        {
 +
            return false;///неверно
 +
         }
 
     }
 
     }
  
     return 0;
+
     for(int i=1; a-i>=0 && b+i<n; ++i)///диагональ вправо-вверх
}
+
    {
 +
        if(mass[a-i][b+i])///в каждой ячейке массива [a-i][b+i]
 +
        {
 +
            return false;///неверно
 +
        }
 +
    }
  
 +
        return true;///в остальных случаях верно
  
</syntaxhighlight>
+
}
</div>
 
  
'''[[Андреева Полина]]'''
+
///проверяем наличие фигур по горизонтали, вертикали и диагоналям
 +
bool tryQueen(int a, int b)
 +
{
  
'''Краткое описание алгоритма''':если шахматную доску представить в виде одной строчки(вторую поставить следом за первой, третью за второй и тд), то получится двоичное число. Максимальное число которое может получиться если 111...111 перевести в десятичное ,это число М*М. Тогда абсолютно ВСЕ варианты расстановки фигур это двоичные записи чисел от 0 до М*М. В программе есть цикл, который рассматривает каждый вариант для числа от 0 до М*М, переводит его в двоичную форму. Программа рассматривает каждую клетку, где стоит фигура. Если эта фигура бьет других, то цикл прерывается, нам такой вариант не подходит. Если никакая фигура не бьет никакую другую, то идет подсчет количества фигур на доске. Если фигур столько, сколько нужно, то вывод на экран.
+
    if (!isEmptyHorisontal(a) || !isEmptyVertical(b) || !isEmptyDiagonales(a,b))///если не выполняются эти условия,
 +
                                                                                ///т.е. постановка фигуры не удовлетворяет расстановке
 +
                                                                                ///по горизонтали, или по вертикали, или по диагонали
 +
    return false;///неверно
  
'''Инструкция''': На экране показано соответствие каждому номеру типа фигуры. Пользователь выбирает тип фигуры, испольуя номер. Дальше нужно ввести размер доски. Затем на экране появляется два варианта количества фигур на доске: максимальное или введенное пользователем. Пользователь выбирает вариант. Если второй, то затем надо будет ввести количество фигур.
+
    return true;///в остальных случаях верно
[http://tm.spbstu.ru/Файл:ШахматыАП.rar Программа]
 
  
<div class="mw-collapsible mw-collapsed" style="width:100%" >
+
}
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 
#include <cstring>
 
#include <iostream>
 
#include"math.h"
 
#include <fstream>
 
using namespace std;
 
  
int M, N;  // M-размер доски, N-коичество шахмат.
+
/// функция поиска результатов решений.
int    sum;//нужно в процессе для подсчета количества шахмат
+
/// row - номер очередной строки в которую нужно поставить очередного ферзя.
int **ChessBoard= new int* [M];
+
/// count - количество фигур, поставленое к данному моменту
 +
void setQueen(int row, int count)
 +
{
  
void ChessBoards(int k) //создание доски, k-число, которое переводим в двоичную запись, чтобы отобразить на доске расстановку фигур, 1-фигура есть, 0-нет.
+
     for(int column=0; column<n; ++column)///двигаемся по столбцу сверху вниз
{
 
     for (int i=0; i<M; i++) //создание массива
 
 
     {
 
     {
         ChessBoard[i] = new int[M];
+
 
    }
+
         if(tryQueen(row, column))/// проверка, если поставить ферзя в ячейку [row][column],
    for (int x=(M-1); x>=0; x=x-1)//заполнение массива фигурами (переводя k в двоичную форму)
+
                                ///будет ли он единственным в этих строке, столбце и диагоналях
    {
 
        for (int y=(M-1); y>=0; y=y-1)
 
 
         {
 
         {
             ChessBoard[x][y]=(k%2);
+
             mass[row][column]=1;
             k=k/2;
+
 
        }
+
             if(count+1==figura) /// нужное количество фигур поставлено
    }
+
            {
}
+
                output_mass(); /// вызов функции вывода массива на экран
void print (char filename[] ) ///создание функции вывода массива в файл
+
                zapis("Zapis");///записываем в файл
    {
+
            }
        ofstream fout(filename, ios::app);
 
  
        for (int x=0; x<M; ++x)
+
             else
        {
 
             for(int y=0; y<M; ++y)
 
 
             {
 
             {
                 fout << ChessBoard[x][y]<<" "; ///вывод массива в файл
+
                 for(int i = row + 1; i<n; i++)/// ставим следующего ферзя в одну из следующих строк
 +
                setQueen(i,count+1);///и повторяем цикл
 
             }
 
             }
             fout <<'\n';
+
 
 +
             mass[row][column]=0;
  
 
         }
 
         }
        fout <<"\n\n";
 
  
        fout.close();
 
 
     }
 
     }
  
 +
}
  
 
+
bool tryRook(int a, int b)///проверка на наличие фигур по вертикали и горизонтали
bool CheckHorse(int x, int y)//проверка для коня в клетке с номером x, y
 
 
{
 
{
  
     if (((x+1)<M) && ((y+2)<M) && (ChessBoard[x+1][y+2]==1))//если в клетке, куда может сходить конь (х+1,у+2) уже есть фигура, то этот вариант не подходит, так как один конь бьет другого.
+
     if (!isEmptyHorisontal(a) || !isEmptyVertical(b))///если не выполняются эти условия,
     {
+
                                                    ///т.е. постановка фигуры не удовлетворяет расстановке
        return false;
+
                                                    ///по горизонтали, или по вертикали
 +
     return false;///неверно
  
     }
+
     return true;///в остальных случаях верно
    else if (((x+1)<M ) && ((y-2)>=0) && (ChessBoard[x+1][y-2]==1))//то же самое и в остальных случаях проверяем бьет ли один конь другого.
 
    {
 
        return false;
 
  
    }
 
    else if (((x-1)>=0) && ((y+2)<M) && (ChessBoard[x-1][y+2]==1))
 
    {
 
        return false;
 
    }
 
    else if (((x-1)>=0) && ((y-2)>=0) && (ChessBoard[x-1][y-2]==1))
 
    {
 
        return false;
 
    }
 
    else if (((x+2)<M) && ((y+1)<M) && (ChessBoard[x+2][y+1]==1))
 
    {
 
        return false;
 
    }
 
    else if (((x+2)<M ) && ((y-1)>=0) && (ChessBoard[x+2][y-1]==1))
 
    {
 
        return false;
 
    }
 
    else if (((x-2)>=0 ) && ((y+1)<M) && (ChessBoard[x-2][y+1]==1))
 
    {
 
        return false;
 
    }
 
    else if (((x-2)>=0 ) && ((y-1)>=0) && (ChessBoard[x-2][y-1]==1))
 
    {
 
        return false;
 
    }
 
    else //в итоге, если конь, стоящий в данной клетке никого не бьет, то этот вариант подходит
 
    {
 
        return true;
 
    }
 
 
}
 
}
  
int Horse(int k)//k-то число которое нужно будет перевести в двоичную форму, это делается в main'е
+
/// функция поиска результатов решений.
//в этой функции считаем количество фигур, если он равно введенному  или максимальному,то доска подходит и выводится в файл (все это в main'е)
+
/// row - номер очередной строки в которую нужно поставить очередную ладью
 +
/// count - количество фигур, поставленое к данному моменту
 +
void setRook(int row, int count)
 
{
 
{
     for (int x=0; x<M; x++)
+
 
 +
     for(int column=0; column<n; ++column)///двигаемся по столбцу сверху вниз
 
     {
 
     {
        int y;
+
 
         for (y=0; y<M; y++)
+
         if(tryRook(row, column))/// проверка, если поставить ладью в A[row][column], будет ли она единственной в этих строке и столбце
 
         {
 
         {
             if (ChessBoard[x][y]==1)//если в данной клетке стоит конь, то нужно проверить,
+
 
            // бьет оно кого-то или нет...
+
             mass[row][column]=1;
            //если в клетке нет коня, то ее проверять не нужно
+
 
 +
            if(count+1==figura) /// нужное количество фигур поставлено
 +
            {
 +
                output_mass(); /// вызов функции вывода массива на экран
 +
                zapis("Zapis");///записываем в файл
 +
            }
 +
 
 +
            else
 
             {
 
             {
                 if (CheckHorse(x,y))//...делаем это с помощью этой функции,если конь в данной клетке х;у 
+
                 for(int i = row + 1; i<n; i++)/// ставим следующую ладью в одну из следующих строк
                 //никого не бьет, то прибавляем 1 к количеству шахмат на доске и считаем дальше 
+
                 setRook(i,count+1);///и повторяем цикл
                {
 
                    sum=sum+1;
 
                }
 
                else //а если бьет, то выходим из цикла, на данной этапе выйдем только из внуреннего
 
                {
 
                    sum=0;//количество фигур обнуляем
 
                    break;
 
                }
 
 
             }
 
             }
 +
 +
            mass[row][column]=0;
 +
 
         }
 
         }
        if (y<M)//если из внутреннего цикла вышли раньше, значит у досчитался не до конца,
+
 
        //то есть он меньше своего максимального значения М
 
        {
 
           
 
            break;//тогда выходим и из внешнего цикла
 
        }
 
 
     }
 
     }
    return sum; //возвращаем количество фигур
+
 
 
}
 
}
  
bool CheckKing(int x, int y) //все то же самое для проверки короля, стоящего в клетке х,у
+
bool tryElephant(int a, int b) ///проверка на наличие фигур по диагоналям.
 
{
 
{
  
     if (((x+1)<M) && ((y+1)<M) && (ChessBoard[x+1][y+1])==1)//если в клетке куда может сходить король
+
     if (!isEmptyDiagonales(a,b))///если не выполняется это условие,
    //уже есть фигура, то клетка не подходит и т.д
+
                                ///т.е. постановка фигуры не удовлетворяет расстановке по диагоналям
     {
+
     return false;
        return false;
+
 
 +
    return true;
 +
 
 +
}
 +
 
 +
/// функция поиска результатов решений.
 +
/// diagonale - номер диагонали в которую нужно поставить очередного слона
 +
/// count - количество фигур, поставленое к данному моменту
 +
void setElephant(int diagonale, int count)
 +
{
  
     }
+
     int a, b; /// опорная точка диагонали (крайняя левая)
    else if (((x+1)<M ) && (ChessBoard[x+1][y]==1))
 
    {
 
        return false;
 
  
     }
+
     if (diagonale < n)///если номер диагонали меньше n
    else if (((x+1)<M) && ((y-1)>=0) && (ChessBoard[x+1][y-1]==1))
 
 
     {
 
     {
         return false;
+
         a = diagonale;///значению а присвоить значенье номера диагонали
 +
        b = 0;///значению b присвоить значение 0
 
     }
 
     }
     else if (((x-1)>=0) && ((y-1)>=0) && (ChessBoard[x-1][y-1]==1))
+
 
 +
     else///иначе
 
     {
 
     {
         return false;
+
         a = n-1;///значению а присвоить значение n-1
 +
        b =(diagonale % n)+1;///значению b присвоить значение целого частного от деления номера диагонали на n прибавив к нему 1
 
     }
 
     }
     else if (((x-1)>=0) && ((y+1)<M) && (ChessBoard[x-1][y+1]==1))
+
 
 +
     /// перебираем все "столбцы" текущей диагонали
 +
    for(int dcolumn=0; a-dcolumn>=0 && b+dcolumn < n; ++dcolumn)
 
     {
 
     {
         return false;
+
 
    }
+
        /// рассчёт координат клетки по координатам крайней точки диагонали и "столбца" в диагонали
    else if (((x-1)>=0) &&  (ChessBoard[x-1][y]==1))
+
        int x = a-dcolumn;
    {
+
         int y = b+dcolumn;
        return false;
+
 
    }
+
        if(tryElephant(x, y))/// проверка, если поставить слона в A[row][column], будет ли он единственным по диагоналям
    else if (((y+1)<M) && (ChessBoard[x][y+1]==1))
+
        {
    {
+
 
        return false;
+
            mass[x][y]=1;
    }
+
 
    else if (((y-1)>=0) && (ChessBoard[x][y-1]==1))
+
            if(count+1==figura) /// нужное количество фигур поставлено
    {
+
            {
         return false;
+
                output_mass(); /// вызов функции вывода массива на экран
    }
+
                zapis("Zapis");///запись в файл
    else
+
            }
    {
+
 
        return true;
+
            else
 +
            {
 +
                for(int i = diagonale + 1; i<2*n-1; i++)/// ставим следующего слона в одну из следующих диагоналей
 +
                setElephant(i,count+1);///и повторяем цикл
 +
            }
 +
 
 +
            mass[x][y]=0;
 +
 
 +
         }
 +
 
 
     }
 
     }
 +
 
}
 
}
  
int King(int k) //так же как и для коня, проверяем каждую клетку
+
/// проверка на наличие фигуры на позиции x,y
//подходит-прибавляем к количеству фигур sum единичку, нет-обнуляем сумму и выходим из цикла
+
bool isFigure(int x, int y)
 
{
 
{
     for (int x=0; x<M; x++)
+
    return 0 <= x && x < n && 0 <= y && y < n && mass[x][y];
     {
+
}
        int y;
+
 
         for (y=0; y<M; y++)
+
///проверка на наличие короля в квадрате 3 на 3
 +
bool tryKing(int a, int b)
 +
{
 +
 
 +
     for(int i = a-1; i <= a+1; i++)///для ячеек находящихся слева и справа от поставленного короля
 +
     {
 +
         for(int j = b-1; j <= b+1; j++)///для ячеек находящихся снизу и сверху от поставленного короля
 
         {
 
         {
             if (ChessBoard[x][y]==1)
+
             if (isFigure(i,j))///если выполняется это условие
            {
+
             return false;///неверно
                if (CheckKing(x,y))
 
                {
 
                    sum=sum+1;
 
                }
 
                else
 
                {
 
                    sum=0;
 
                    break;
 
                }
 
            }
 
        }
 
        if (y<M)
 
        {
 
             break;
 
 
         }
 
         }
 
     }
 
     }
     return sum;
+
 
 +
     return true;///в остальных случаях верно
 +
 
 
}
 
}
  
int CheckQueen(int x, int y)///проверка для королевы, принцип тот же, королева стит в клеке x,y
+
///функция поиска результатов решений
///1 значит как true в bool (как в коне или короле), 0 - false
+
/// count - количество фигур, поставленое к данному моменту
{ int returnn=1;//начала true, дальше если будет false, то return примет значение 0, а если все пдходит
+
///x,y - позиция, начиная с которой разрешено ставить фигуры (все предшествующие позиции уже точно определены)
///то так и стается 1
+
void setKing(int count, int x, int y)
int m;
+
{
     for (m=1; m<M; m++)
+
 
  { //проверяем для диагоналей
+
     if(count==figura)///figura - количество фигур, вводимых пользователями.
    ///если по диагонале клетки х,у стоит еще королва, то такой вариант не подходит, выходим из цикла
+
     {
     ///разбито на 4 услвия, так как если не разбивать, то клетка в кторой стоит данная королева
+
        output_mass();/// вызов функции вывода массива на экран
    ///тоже будет считаться и выходить из цикла
+
        zapis("Zapis");///записываем в файл
      if (((x+m)<M)&&((y+m)<M))
+
        return;
      {
+
    }
          if (ChessBoard[x+m][y+m]==1)
+
 
          {returnn=0;
+
    if (x == n) /// строки закончились
          break;
+
        return;
          }
+
 
      }
+
    /// обрабатываем текущую строку
      if (((x-m)>=0)&&((y+m)<M))
+
    for (int j=y; j<n; ++j)
      {
+
    {
          if (ChessBoard[x-m][y+m]==1)
+
 
          {returnn=0;
+
        if(tryKing(x, j))
          break;}
+
        {
      }
+
            mass[x][j]=1;
      if (((x+m)<M)&&((y-m)>=0))
+
            /// смещаем разрешённую позицию на 1 вправо или в начало следующей строки
      {
+
            int nextX = x, nextY = j+1;
          if (ChessBoard[x+m][y-m]==1)
+
 
        {returnn=0;
+
            if (nextY == n)///если столбец последний
          break;}
+
            {
      }
+
                nextY = 0;///идем сначала по столбцам
      if (((x-m)>=0)&&((y-m)>=0))
+
                nextX++;///к строке прибавляем 1
      { if (ChessBoard[x-m][y-m]==1)
+
            }
          {returnn=0;
+
 
          break;}
+
            /// ставим следующего короля
      }
+
             setKing(count+1,nextX,nextY);
      if (m!=x) ///тут считаем по вертикали и горизонтали, так как длаем в цикле для m, то m меняется
+
             mass[x][j]=0;
        ///и в какой-то момент может стать х, и тогда роверятьбуде клетку в которой стоит ДАННАЯ и выходить
+
 
        ///это не нужно так что выходим только если m не равен x
 
        {
 
             if (ChessBoard[m][y]==1) //если по горизонтали есть какая-о клетка, где стоит королева, то выходим
 
             {
 
                returnn=0;
 
                break;
 
            }
 
 
         }
 
         }
        if (m!=y)//то же по вертикали
 
        {
 
          if (ChessBoard[x][m]==1)
 
            {
 
                returnn=0;
 
                break;
 
            }
 
        }
 
  }
 
  return returnn;
 
}
 
  
int Queen(int k)//тут также как и для коня и короля
+
    }
{
+
 
for (int x=0; x<M; x++)
+
    /// обрабатываем прямоугольник ниже текущей строки
 +
    for(int i=x+1; i<n; ++i)
 
     {
 
     {
        int y;
+
 
         for (y=0; y<M; y++)
+
         for (int j=0; j<n; ++j)
 
         {
 
         {
             if (ChessBoard[x][y]==1)//если в клетке королева, проверяем подходи ли она нам
+
 
 +
             if(tryKing(i, j))
 
             {
 
             {
                 if (CheckQueen(x,y))
+
                mass[i][j]=1;
 +
                /// смещаем разрешённую позицию на 1 вправо или в начало следующей строки
 +
                int nextX = i, nextY = j+1;
 +
 
 +
                 if (nextY == n)///если столбец последний
 
                 {
 
                 {
                     sum=sum+1;
+
                     nextY = 0;///идем сначала по столбцам
                }
+
                     nextX++;///к строке прибавляем 1
                else
 
                {
 
                    sum=0;
 
                     break;
 
 
                 }
 
                 }
 +
 +
                /// ставим следующего короля
 +
                setKing(count+1,nextX,nextY);
 +
                mass[i][j]=0;
 +
 
             }
 
             }
 +
 
         }
 
         }
        if (y<M)
+
 
        {
 
            break;
 
        }
 
 
     }
 
     }
    return sum;
+
 
 
}
 
}
  
int CheckRook(int x, int y)///ладья, просто берем ту часть из проверки королевы, где проверка по горизонтали и вертикали
+
bool tryHorse(int a, int b) ///проверка на коней по всем направлениям
{ int returnn=1;
+
{
int m;
+
 
     for (m=0; m<M; m++)
+
     if (isFigure(a-1,b-2) || isFigure(a-1,b+2) || isFigure(a+1,b-2) || isFigure(a+1,b+2) || isFigure(a-2,b-1) || isFigure(a-2,b+1) || isFigure(a+2,b-1) || isFigure(a+2,b+1))
 +
                                                        ///если выполняются эти условия,
 +
                                                        ///т.е. фигара стоит на одной из этих позиций
 +
        return false;///неверно
 +
 
 +
    return true;///в остальных случаях верно
  
    {
+
}
        if (m!=x)
+
 
        {
+
///функция поиска результатов решений
            if (ChessBoard[m][y]==1)
+
/// count - количество фигур, поставленое к данному моменту.
            {
+
void setHorse(int count, int x, int y)
                returnn=0;
+
{
                break;
+
 
            }
+
    if(count==figura)///figura - количество фигур, вводимых пользователями.
         }
+
    {
         if (m!=y)
+
        output_mass();/// вызов функции вывода массива на экран
 +
        zapis("Zapis");///записываем в файл
 +
        return;
 +
    }
 +
 
 +
    if (x == n)/// строки закончились
 +
         return;
 +
 
 +
    /// обрабатываем текущую строку
 +
    for (int j=y; j<n; ++j)
 +
    {
 +
 
 +
         if(tryHorse(x, j))
 
         {
 
         {
          if (ChessBoard[x][m]==1)
+
 
 +
            mass[x][j]=1;
 +
            /// смещаем разрешённую позицию на 1 вправо или в начало следующей строки
 +
            int nextX = x, nextY = j+1;
 +
 
 +
            if (nextY == n)///если столбец последний
 
             {
 
             {
                 returnn=0;
+
                 nextY = 0;///идем сначала по столбцам
                 break;
+
                 nextX++;///к строке прибавляем 1
 
             }
 
             }
 +
 +
            /// ставим следующего коня
 +
            setHorse(count+1,nextX,nextY);
 +
            mass[x][j]=0;
 +
 
         }
 
         }
 +
 
     }
 
     }
  
 +
    /// обрабатываем прямоугольник ниже текущей строки
 +
    for(int i=x+1; i<n; ++i)
 +
    {
  
      return returnn;
+
        for (int j=0; j<n; ++j)
}
+
        {
  
int Rook(int k)//все то же самое, количество фигур на доске
+
            if(tryHorse(i, j))
{
 
    for (int x=0; x<M; x++)
 
    {
 
        int y;
 
        for (y=0; y<M; y++)
 
        {
 
            if (ChessBoard[x][y]==1)
 
 
             {
 
             {
                if (CheckRook(x,y)==1)
 
                {
 
                    sum=sum+1;
 
  
                 }
+
                 mass[i][j]=1;
                 else
+
                 /// смещаем разрешённую позицию на 1 вправо или в начало следующей строки
 +
                int nextX = i, nextY = j+1;
 +
 
 +
                if (nextY == n)///если столбец последний
 
                 {
 
                 {
                     sum=0;
+
                     nextY = 0;///идем сначала по столбцам
                     break;
+
                     nextX++;///к строке прибавляем 1
 
                 }
 
                 }
 +
 +
                setHorse(count+1,nextX,nextY);
 +
                mass[i][j]=0;
 +
 
             }
 
             }
 +
 
         }
 
         }
        if (y<M)
+
 
        {
 
            break;
 
        }
 
 
     }
 
     }
  
    return sum;
 
 
}
 
}
  
int CheckElephant(int x, int y)//для слона берем ту часть прроверки королевы, где по диагонали
+
int main()
{ int returnn=1;
+
{
  for (int i=1; i<M; i++)
+
    setlocale(LC_ALL,"RUS");
  {
+
 
      if (((x+i)<M)&&((y+i)<M))
+
  ofstream Zapis("Zapis", ios::trunc);///сохраняем в файл
      {
+
  Zapis.close();
          if (ChessBoard[x+i][y+i]==1)
 
          {returnn=0;
 
          break;
 
          }
 
      }
 
      if (((x-i)>=0)&&((y+i)<M))
 
      {
 
          if (ChessBoard[x-i][y+i]==1)
 
          {returnn=0;
 
          break;}
 
      }
 
      if (((x+i)<M)&&((y-i)>=0))
 
      {if (ChessBoard[x+i][y-i]==1)
 
        {returnn=0;
 
          break;}
 
      }
 
      if (((x-i)>=0)&&((y-i)>=0))
 
      { if (ChessBoard[x-i][y-i]==1)
 
          {returnn=0;
 
          break;}
 
      }
 
  }
 
  return returnn;
 
}
 
  
int Elephant(int k)///считаем кличесво фигур
+
    do
{
 
for (int x=0; x<M; x++)
 
 
     {
 
     {
         int y;
+
         cout << "Введите размер доски (четный): ";
         for (y=0; y<M; y++)
+
         cin >> n; ///ввод пользователем размера доски
        {
+
    }while (n%2 != 0);
            if (ChessBoard[x][y]==1)
+
 
            {
+
    mass=create_mass(n); ///создаём двумерный массив
                if (CheckElephant(x,y))
+
 
                {
+
     cout<<"Queen-1, Rook-2, Elephant-3, King-4, Horse-5"<< endl;
                    sum=sum+1;
+
     cin >> figureID; ///выбор пользователем фигуры
                }
 
                else
 
                {
 
                    sum=0;
 
                    break;
 
                }
 
            }
 
        }
 
        if (y<M)
 
        {
 
            break;
 
        }
 
     }
 
     return sum;
 
}
 
  
int main ()
+
    /// устанавливаем максимальное количество в зависимости от фигуры
{
+
    if (figureID==1)
     ofstream MyFile("MyFile", ios::trunc);
+
    maxCount=n;
     MyFile.close(); // очищаем файл, чтоб при новой записи не было из рошлого запуска
+
     if (figureID==2)
 +
    maxCount=n;
 +
     if (figureID==3)
 +
    maxCount=2*n-2;
 +
    if (figureID==4)
 +
    maxCount=(n*n)/4;
 +
    if (figureID==5)
 +
    maxCount=(n*n)/2;
  
int figure, z;
+
     /// запрашиваем количество фигур
    cout<<"enter a figure 1-queen, 2-king, 3-rook , 4-horse or 5-elephant ";
+
     do
     cin>>figure;///тип фигуры, 1 - королевА, 2-король,3-ладья,4-конь,6-слон
 
      cout << "\n enter a size of a board M - even number ";///ввести ЧЕТНЫЙ размер доски М
 
    cin >> M;
 
     if ( M%2 != 0)///проверка М на четность, с помощью остатка от деления на 2
 
 
     {
 
     {
         while (M%2 != 0)
+
         cout << "Введите количество фигур (максимальное количество - " << maxCount << "): ";
         {
+
        cin >> figura;
            cout<<" you need EVEN number, enter one more time ";
+
    }while (figura>maxCount);
            cin>>M;
+
 
         }
+
    /// запускаем перебор
 +
    if (figureID==1)
 +
    {
 +
        for(int i = 0; i<n; i++)
 +
         setQueen(i,0);
 +
        zapis("Zapis");
 +
    }
 +
    if (figureID==2)
 +
    {
 +
        for(int i = 0; i<n; i++)
 +
        setRook(i,0);
 +
         zapis("Zapis");
 
     }
 
     }
 
+
     if (figureID==3)
     cout<<"\n choose  1- max amount or 2 - your amount of figures ";
 
    cin>>z;///z-один из вариантов 1-максимаьное число фигур на доске,2-пользователь сам вводит
 
 
 
    switch (figure)///выбираем фигуру
 
 
     {
 
     {
     case 1:///королева
+
        for(int i = 0; i<2*n-1; i++)
 +
        setElephant(i,0);
 +
        zapis("Zapis");
 +
     }
 +
    if (figureID==4)
 
     {
 
     {
        if (z==2)///пользоватеь сам вводит количество
+
        setKing(0,0,0);
        {
+
        zapis("Zapis");
            cout<<"\n enter an amount of figures ";
+
    }
            cin >> N;///ввести количество
+
    if (figureID==5)
            if (N>M)///проверка на то, сможет ли такое количество уместиться на доске в правильном виде
+
    {
            {
+
        setHorse(0,0,0);
                while (N>M)
+
        zapis("Zapis");
                {
+
    }
                    cout<<" too many figures, enter one more time ";
+
    system("PAUSE");
                    cin>>N;
+
}
                }
+
</syntaxhighlight>
            }
+
</div>
            ///вот ниже i- те числа которые нужно перевести в двоичную форму
 
            for (int i=0; i<=pow(2,(M*M)); i++)///каждый i-новый вариант расстановик фигур
 
            {
 
                sum=0;
 
                int k=i;
 
                ChessBoards(k);
 
                if (Queen(k)==N)///если в данной варианте фигур столько. сколько ввел пользователь, то выводим
 
                {
 
                    print("MyFile");
 
                }
 
            }
 
        }
 
        else ///вариант максимального числа фигур на доске
 
        {  ///так же как и в предыдущем пункте, только количество фигур N максимально,
 
            /// в случае королевы оно равно размеру доски 
 
            N=M;
 
            for (int i=0; i<=pow(2,(M*M)); i++)
 
            {
 
                sum=0;
 
                int k=i;
 
                ChessBoards(k);
 
                if (Queen(k)==N)
 
                {
 
                    print("MyFile");
 
                }
 
            }
 
        }
 
  
        break;
+
'''[[Васильева Анастасия]]'''
    }
+
 
    case 2:///то же самое для короля
+
'''Краткое описание алгоритма''': Доска представлена в виде динамического массива, по ходу программы, в зависимости от алгоритмов для разных фигур, функции заполняют доску числами  0-место свободно, 1-находится под ударом и 2-занято фигурой, потом массив преобразовывается к нормальному виду 0 и 1-фигура. Так программа прогоняет все возможные варианты расстановок. Также программа аналитически просчитывает максимальное количество фигур для каждого размера доски.
    {
+
 
        if (z==2)
+
'''Инструкция''': Сначала программа просит выбрать фигуру, с которой будем работать. Затем 2 варианта развития событий: 1 - вывод в файл всех расстановок, 2 - максимальное количество фигур. В зависимости от выбора, в первом случае еще нужно ввести количество фигур, и программа запишет в файл все возможные варианты и выведет на экран число расстановок, а во втором - на экране появится максимальное кол-во фигур.
        {
+
Скачать можно [http://tm.spbstu.ru/Файл:Задача1.zip тут].
            cout<<"\n enter an amount of figures ";
+
 
            cin >> N;
+
 
              if ( N>(M*M)/4)
+
'''[[Гильманов Илья]]'''
            {
+
 
                while (N>(M*M)/4)
+
'''Основная идея программы''': пользователь вводит размер доски MxM , тип фигур, их количество. Программа рассчитывает максимально возможное количество фигур , которые можно расположить на доске, чтобы они не били друг друга.
                {
+
 
                    cout<<" too many figures, enter one more time ";
+
'''Инструкция к программе''': Пользователь вводит размер доски M(size*size).А затем предоставляется выбор между нахождением максимально возможного числа фигур , и их расстановкой.Также пользователь выбирает тип фигуры , и количество(если интересует расстановка).
                    cin>>N;
+
 
                }
+
Скачать можно [http://mech.spbstu.ru/File:CheEeeSss.rar здесь]
            }
+
 
            for (int i=0; i<=pow(2,(M*M)); i++)
+
'''[[Демченко Артём]]'''
            {
+
 
                sum=0;
+
'''Основная идея программы''': Программа подсчитывает и выводит расстановку указанного кол-ва фигур на указанном поле и второй опицей выводит максимальную расстановку на поле размером size*size.
                int k=i;
+
 
                ChessBoards(k);
+
'''Инструкция''': Запустите программу и следуйте инструкциям. Сначала идет выбор алгоритма, после чего идет выбор фигуры и размер доски для подсчета максимальной расстановки на поле size*size. Результат будет выведен на экран.
                if (King(k)==N)
+
 
                {
+
Скачать можно [http://tm.spbstu.ru/File:Chessss.zip тут].
                    print("MyFile");
+
 
                }
+
'''[[Иванова Яна]]'''
            }
+
 
        }
+
'''Краткое описание алгоритма''': Функция, которая выполняет поиск расстановок, пытается поставить фигуру в каждую клетку. В случае неудачи программа отмечает клетки, в которых фигура уже побывала, но постановка не удалась, отрицательной величиной, равной по модулю шагу, на котором эта постановка была испробована. В случае пустой клетки она отмечается нулем, в случае успеха клетка отмечается положительным числом, равным шагу, соответствующему попытке постановки.
else
+
Также программа аналитически просчитывает максимальное количество фигур для каждого размера доски.
        {
+
 
            N=(M*M)/4;
+
'''Инструкция''': В меню указывается два варианта развития событий. Пользователь должен выбрать один из путей. Он вводит размер доски и тип фигуры.
            for (int i=0; i<=pow(2,(M*M)); i++)
+
Если он выбирает максимальное число расстановок, то программа выводит их количество, а также предлагает вывести все расстановки на экран. Другой вариант работы программы - вывод расстановок N фигур.
            {
+
 
                sum=0;
+
Посмотреть программу можно [http://tm.spbstu.ru/Файл:chess(1).zip здесь]
                int k=i;
+
 
                ChessBoards(k);
+
<div class="mw-collapsible mw-collapsed" style="width:100%" >
                if (King(k)==N)
+
<syntaxhighlight lang="cpp" line start="1" enclose="div">
                {
+
 
                    print("MyFile");
+
#include <iostream>
                }
+
#include <algorithm>
            }
+
#include <exception>
        }
+
#include <string>
        break;
+
#include <algorithm>
    }
 
    case 3:///для ладьи
 
    {
 
        if (z==2)
 
        {
 
            cout<<"\n enter an amount of figures ";
 
            cin >> N;
 
              if (N>M)
 
            {
 
                while (N>M)
 
                {
 
                    cout<<" too many figures, enter one more time ";
 
                    cin>>N;
 
                }
 
            }
 
  
            for (int i=0; i<=pow(2,(M*M)); i++)
+
//пусть для определенности максимальный размер доски - 128 клеток
            {
+
#define MAX_SIZE 128
                sum=0;
+
 
                int k=i;
+
// перечисление для определения типа фигуры
                ChessBoards(k);
+
enum figure_type
                if (Rook(k)==N)
+
{
                {
+
    KING,
                    print("MyFile");
+
    QUEEN,
                }
+
    ROOK,
            }
+
    BISHOP,
 +
    KNIGHT
 +
};
 +
 
 +
// класс для создания доски и расстановки фигур
 +
class chess_board
 +
{
 +
public:
 +
    // конструктор (принимает только размеры)
 +
    chess_board(const int &size)
 +
    {
 +
        if (size >= 0 && size <= MAX_SIZE)
 +
        {
 +
            size_ = size;
 +
            clean_board();
 
         }
 
         }
 +
 
         else
 
         else
 
         {
 
         {
             N=M;
+
             std::cout << "wrong size" << std::endl;
            for (int i=0; i<=pow(2,(M*M)); i++)
+
             throw std::string("wrong size");
             {
 
                sum=0;
 
                int k=i;
 
                ChessBoards(k);
 
                if (Rook(k)==N)
 
                {
 
                    print("MyFile");
 
                }
 
            }
 
 
         }
 
         }
        break;
 
 
     }
 
     }
     case 4:///конь
+
 
     {
+
 
         if (z==2)
+
     // функция очистки доски (занулить все клетки)
 +
    void clean_board()
 +
     {
 +
         //обнулить счетчик количества фигур на доске
 +
        figures_on_board_ = 0;
 +
        //присвоить всем клеткам значение 0
 +
        for (int i = 0; i < size_; ++i)
 
         {
 
         {
             cout<<"\n enter an amount of figures ";
+
             for (int j = 0; j < size_; ++j)
            cin >> N;
 
              if (N>(M*M)/2)
 
 
             {
 
             {
                 while (N>(M*M)/2)
+
                 board_[i][j] = 0;
                {
 
                    cout<<" too many figures, enter one more time ";
 
                    cin>>N;
 
                }
 
            }
 
 
 
            for (int i=0; i<=pow(2,(M*M)); i++)
 
            {
 
                sum=0;
 
                int k=i;
 
                ChessBoards(k);
 
                if (Horse(k)==N)
 
                {
 
                    print("MyFile");
 
                }
 
            }
 
        }
 
        else
 
        {
 
            N=(M*M)/2;
 
            for (int i=0; i<=pow(2,(M*M)); i++)
 
            {
 
                sum=0;
 
                int k=i;
 
                ChessBoards(k);
 
                if (Horse(k)==N)
 
                {
 
                    print("MyFile");
 
                }
 
 
             }
 
             }
 
         }
 
         }
        break;
 
 
     }
 
     }
     case 5:///слон
+
 
 +
     // функция, принимающая размер доски
 +
    int get_size()
 +
    {
 +
        return size_;
 +
    }
 +
    // функция, обновляющая количество фигур на доске
 +
    int get_figures_number()
 +
    {
 +
        return figures_on_board_;
 +
    }
 +
 
 +
    //функция, пытающаяся поставить фигуру на свободное место и возвращающая
 +
    //истину в случае успеха и ложь в случае неудачи
 +
    bool put_figure (const figure_type& figure, const int& x, const int& y, const int& step)
 
     {
 
     {
         if (z==2)
+
         if (board_[x][y] > 0 || board_[x][y] < -step)
 
         {
 
         {
            cout<<"\n enter an amount of figures ";
+
          //если здесь уже стоит фигура или мы когда-то пытались ее сюда поставить, вернуть ложь
            cin >> N;
+
             return false;
                if (N>2*M-2)
 
            {
 
                while (N>2*M-2)
 
                {
 
                    cout<<" too many figures, enter one more time ";
 
                    cin>>N;
 
                }
 
            }
 
             for (int i=0; i<=pow(2,(M*M)); i++)
 
            {
 
                sum=0;
 
                int k=i;
 
                ChessBoards(k);
 
                if (Elephant(k)==N)
 
                {
 
                    print("MyFile");
 
                }
 
            }
 
 
         }
 
         }
         else
+
 
 +
         if (check_figure(figure, x, y))
 
         {
 
         {
             N=2*M-2;
+
             board_[x][y] = step;
             for (int i=0; i<=pow(2,(M*M)); i++)
+
             ++figures_on_board_;
             {
+
             return true;
                sum=0;
+
        }
                int k=i;
+
        else
                ChessBoards(k);
+
        {
                if (Elephant(k)==N)
+
            return false;
                {
 
                    print("MyFile");
 
                }
 
            }
 
 
         }
 
         }
        break;
 
 
     }
 
     }
     default : ///а это еси пользоватеь ввел цифру, которая не соответстует ни одной фигуре
+
 
 +
     //отметить клетку как ранее пройденную функцией
 +
    //вычесть единицу из количества фигур на доске
 +
    void remove_figure(const int& x, const int& y)
 
     {
 
     {
         cout<<"NOOOOO";
+
         board_[x][y] *= -1;
         break;
+
         --figures_on_board_;
 
     }
 
     }
    };
 
  
 
+
    //функция печати доски на экран
     return 0;
+
     void print() const
 +
    {
 +
        using namespace std;
 +
        cout << "==========================================" << endl;
 +
        for (int i = 0; i < size_; ++i)
 +
        {
 +
            for (int j = 0; j < size_; ++j)
 +
            {
 +
                //если фигура стоит в клетке, то вывести "*", если нет - вывести "-"
 +
                cout << (board_[i][j] > 0?"*":"-") << " ";
 +
            }
 +
            cout << endl;
 +
        }
 +
        cout << "==========================================" << endl;
 
     }
 
     }
</syntaxhighlight>
 
</div>
 
  
'''[[Бальцер Анастасия]]'''
+
private:
  
'''Краткое описание алгоритма''': Для каждой фигуры написана отдельная функция, выполняющая поиск расстановок. После выбора типа фигуры, соответствующая функция выполняет поиск возможных расстановок. Она проходя по строкам двумерного массива пытается поставить фигуру в каждую клетку. Проходя по массиву она маркирует клетки, ставит 0 (если клетка свободна), 1 (если клетка находится под ударом), 2 (если клетка занята). Программа аналитически считает максимальное количество фигур для заданного размера доски, возможное число расстановок для заданных типа фигуры, размера доски и количества фигур.
+
    //функция, проверяющая возможность или невозможность постановки фигуры на данную клетку
 +
    bool check_figure(const figure_type& figure, const int& x, const int& y)
 +
    {
 +
        //выбор следующего действия в зависимости от типа фигуры
 +
        switch (figure)
 +
        {
 +
            case KING:
 +
                return check_king(x, y);
 +
            case QUEEN:
 +
                return check_queen(x, y);
 +
            case ROOK:
 +
                return check_rook(x, y);
 +
            case BISHOP:
 +
                return check_bishop(x, y);
 +
            case KNIGHT:
 +
                return check_knight(x, y);
 +
                //в случае ошибки ввода вернуть ложь
 +
            default:
 +
                return false;
 +
        }
 +
    }
  
'''Инструкция''': При запуске программы появляется меню, в котором каждому типу фигуры сопоставлен номер, с помощью которого пользователь и выбирает тип фигуры. Затем пользователю на выбор предлагается 2 режима работы программы: первый выводит число возможных расстановок на экран, а список возможных расстановок в отдельный файл (при этом пользователь дополнительно выбирает число фигур); второй выводит на экран максимальное число фигур выбранного типа, которые можно расставить на заданной доске.
+
    //поиск расстановок короля
 +
    bool check_king(const int& x, const int& y)
 +
    {
 +
        int min_x = std::max(x - 1, 0);
 +
        int max_x = std::min(x + 1, size_ - 1);
 +
        int min_y = std::max(y - 1, 0);
 +
        int max_y = std::min(y + 1, size_ - 1);
  
Посмотреть программу можно [http://tm.spbstu.ru/Файл:Расстановка.zip тут]
+
        for (int i = min_x; i <= max_x; ++i)
 +
        {
 +
            for (int j = min_y; j <= max_y; ++j)
 +
            {
 +
                if (board_[i][j] > 0)
 +
                {
 +
                    return false;
 +
                }
 +
            }
 +
        }
 +
        return true;
 +
    }
  
 +
    //поиск расстановок ладьи
 +
    bool check_rook(const int& x, const int& y)
 +
    {
 +
        for (int i = 0; i < size_; ++i)
 +
        {
 +
            if (board_[i][y] > 0)
 +
            {
 +
                return false;
 +
            }
 +
        }
 +
        for (int j = 0; j < size_; ++j)
 +
        {
 +
            if (board_[x][j] > 0)
 +
            {
 +
                return false;
 +
            }
 +
        }
 +
        return true;
 +
    }
  
 +
    //поиск расстановок слона
 +
    bool check_bishop(const int& x, const int& y)
 +
    {
 +
        bool check = true;
  
'''[[Васильева Анастасия]]'''
+
        int k_start_1 = -std::min(x, y);
 +
        int k_end_1 = std::min( size_ - x, size_ - y) - 1;
  
'''Краткое описание алгоритма''': Доска представлена в виде динамического массива, по ходу программы, в зависимости от алгоритмов для разных фигур, функции заполняют доску числами  0-место свободно, 1-находится под ударом и 2-занято фигурой, потом массив преобразовывается к нормальному виду 0 и 1-фигура. Так программа прогоняет все возможные варианты расстановок. Также программа аналитически просчитывает максимальное количество фигур для каждого размера доски.
+
        int k_start_2 = -std::min( x, size_ - y - 1);
 +
        int k_end_2 = std::min( y, size_ - x - 1);
  
'''Инструкция''': Сначала программа просит выбрать фигуру, с которой будем работать. Затем 2 варианта развития событий: 1 - вывод в файл всех расстановок, 2 - максимальное количество фигур. В зависимости от выбора, в первом случае еще нужно ввести количество фигур, и программа запишет в файл все возможные варианты и выведет на экран число расстановок, а во втором - на экране появится максимальное кол-во фигур.
 
Скачать можно [http://tm.spbstu.ru/Файл:Задача1.zip тут].
 
  
'''[[Белоусова Екатерина]]'''
+
        for (int k = k_start_1; k <= k_end_1; ++k)
 +
        {
 +
            check = check_coord(x + k, y + k) && check ;
 +
        }
 +
        for (int k = k_start_2; k <= k_end_2; ++k)
 +
        {
 +
            check = check_coord(x + k, y - k) && check;
 +
        }
  
'''Краткое описание алгоритма''': доска представлена в виде динамического массива, заполненного 1 и 0. 1-стоит фигура, 0-пустое место. Программа при помощи рекурсии вызывает функцию, которая ставит фигуру в пустую клетку и проверяет, находится ли эта фигура под ударом других.
+
        return check;
 +
    }
  
'''Инструкция''': пользователь вводит четный размер доски М*М, затем выбирает, какую фигуру он хочет расставить на этой доске, после чего ему предлагается выбрать количество фигур(в скобках указывается максимальное количество фигур, которые можно расставить на доске М*М).Программа выводит на экран всевозможные расстановки, пронумеровывая каждую, и сохраняет их в файл.
 
  
Скачать можно  [http://tm.spbstu.ru/Файл:задача_1.zip тут].
+
    //поиск расстановок коня
 +
    bool check_knight(const int& x, const int& y)
 +
    {
 +
        bool check =
 +
            check_coord(x - 2, y - 1) &&
 +
            check_coord(x - 2, y + 1) &&
 +
            check_coord(x - 1, y - 2) &&
 +
            check_coord(x - 1, y + 2) &&
 +
            check_coord(x + 1, y - 2) &&
 +
            check_coord(x + 1, y + 2) &&
 +
            check_coord(x + 2, y - 1) &&
 +
            check_coord(x + 2, y + 1);
 +
        return check;
 +
    }
  
<div class="mw-collapsible mw-collapsed" style="width:100%" >
+
    //поиск расстановок королевы
<syntaxhighlight lang="cpp" line start="1" enclose="div">
+
    bool check_queen(const int& x, const int& y)
#include <iostream>
 
#include <stdlib.h>
 
#include <stdio.h>
 
#include <string>
 
#include <cstring>
 
#include <fstream>
 
#include <locale.h>
 
#include<iomanip>
 
#include<math.h>
 
 
 
using namespace std;
 
 
 
 
 
int n, figureID, figura, maxCount; /// n - размер доски, figureID - номер фигуры, figura - колическтво фигур, maxCount - максимальное возможное количество фигур
 
int results_count = 0; /// определяем тип и задаем начальное значение results_count(номер результата)
 
int **mass; /// определяем двумерный массив
 
 
 
///создаем массив размером n*n
 
int** create_mass(int n)
 
{
 
 
 
    int **mass = new int* [n];
 
    for (int a=0; a<n; ++a)
 
 
     {
 
     {
         mass[a] = new int [n];
+
         return check_rook(x, y) && check_bishop(x, y);
        memset((char*)mass[a],0,n*sizeof(int)); ///зануление массива
 
 
     }
 
     }
  
        return mass;
+
  //функция поиска расстановок, в случае, когда на доске что-то стоит, вернуть ложь
 
+
  //иначе поставить вернуть истину
}
+
     bool check_coord(const int& x, const int& y)
 
 
///функция вывода массива
 
void output_mass ()
 
{
 
 
 
     for (int a=0; a<n; ++a)///заполнение ячеек массива от 0 до n по горизонтали
 
 
     {
 
     {
 
+
         if (x >= 0 && x < size_ && y >= 0 && y < size_)
         for(int b=0; b<n; ++b)///заполнение ячеек массива от 0 до n по вертикали
 
 
         {
 
         {
             cout << mass[a][b]<<" "; ///вывод массива на экран
+
             if (board_[x][y] > 0)
 +
            {
 +
                return false;
 +
            }
 
         }
 
         }
 
+
         return true;
         cout << '\n';
 
 
 
 
     }
 
     }
  
     cout << "Result #" << ++results_count <<"\n\n"; /// вывод номера результата
+
     // if board_[x][y] == 0
 +
    //    клетка свободна
 +
    // if board_[x][y] == s
 +
    //    фигура была поставлена на шаге S
 +
    // if board_[x][y] == -s
 +
    //     клетка свободна, но была попытка поставить фигуру на шаге S
 +
    int board_[MAX_SIZE][MAX_SIZE];
 +
    int size_;
 +
    int figures_on_board_;
 +
};
  
}
+
//функция расчета максимума для любой доски в зависимости от типа фигуры
 
+
int get_max_figures (const figure_type& figure, const int& size)
void zapis (char Zapis[] ) ///функции записи решений в файл
 
 
{
 
{
     ofstream fout(Zapis, ios::app);///запись в фаил "Zapis"
+
     switch (figure)
 
 
    for (int x=0; x<n; ++x)///заполнение ячеек массива от 0 до n по горизонтали
 
 
     {
 
     {
         for(int y=0; y<n; ++y)///заполнение ячеек массива от 0 до n по вертикали
+
         case KING:
         {
+
            return (size + 1) / 2;
             fout<< mass[x][y]<<" "; ///вывод решений в файл
+
        case QUEEN:
        }
+
            if (size <= 2)
         fout<<'\n';
+
            {
 +
                return 1;
 +
            }
 +
            else if (size == 3)
 +
            {
 +
                return 2;
 +
            }
 +
            else
 +
            {
 +
                return size;
 +
            }
 +
        case ROOK:
 +
            return size;
 +
         case BISHOP:
 +
            if (size == 1)
 +
            {
 +
                return size;
 +
            }
 +
            else
 +
            {
 +
                return 2 * (size - 1);
 +
            }
 +
        case KNIGHT:
 +
             if (size <= 2)
 +
            {
 +
                return size * size;
 +
            }
 +
            else
 +
            {
 +
                return (size * size + 1) / 2;
 +
            }
 +
         default:
 +
            return 1;
 
     }
 
     }
    fout<<"\n\n";
 
    fout.close();
 
 
}
 
}
  
///проверяем наличие фигуры в строке а
+
//функция для расстановки максимального числа фигур на доске
bool isEmptyHorisontal(int a)
+
void place_figures_for_max(chess_board &board, const figure_type& figure, const int& max_figures, int step)
 
{
 
{
 
+
    ++step;
     for(int i=0; i<n; ++i)///создаем цикл от 0 до n
+
    const int size = board.get_size();
 +
     for (int i = 0; i < size; ++i)
 
     {
 
     {
         if(mass[a][i])///в каждой ячейке массива [a][i]
+
         for (int j = 0; j < size; ++j)
 
         {
 
         {
             return false;///неверно
+
             //если мы можем поставить фигуру, то добавляем к максимуму единицу и запускаем цикл снова
 +
            if (board.put_figure(figure, i, j, step))
 +
            {
 +
                //если число фигур на доске достигло максимума, то вывести доску
 +
                if (board.get_figures_number() == max_figures)
 +
                {
 +
                    board.print();
 +
                }
 +
                //если число фигур не достигло максимума, продолжить выполнение функции
 +
                else
 +
                {
 +
                    place_figures_for_max(board, figure, max_figures, step);
 +
                }
 +
                board.remove_figure(i, j);
 +
            }
 
         }
 
         }
 
     }
 
     }
 
    return true;///в остальных случаях верно
 
 
 
}
 
}
  
///проверяем наличие фигур в столбце b
+
//функция, принимающая ввод с клавиатуры как строковый тип данных
bool isEmptyVertical(int b)
+
figure_type get_figure_type(const std::string& str)
 
{
 
{
 +
    using namespace std;
  
     for(int i=0; i<n; ++i)///создаем цикл от 0 до n
+
     figure_type figure;
 +
    if (str == string("king"))
 +
    {
 +
        figure = KING;}
 +
    else if (str == string("queen"))
 
     {
 
     {
         if(mass[i][b])///в каждой ячейке массива [i][b]
+
         figure = QUEEN;}
        {
+
     else if (str == string("rook"))
            return false;///неверно
 
        }
 
     }
 
 
 
    return true;///в остальных случаях верно
 
 
 
}
 
 
 
///проверяем наличие фигур на диагоналях
 
bool isEmptyDiagonales(int a, int b)
 
{
 
 
 
    for(int i=1; a-i>=0 && b-i>=0; ++i)///диагональ влево-вверх
 
 
     {
 
     {
         if(mass[a-i][b-i])///в каждой ячейке массива [a-i][b-i]
+
         figure = ROOK;
        {
 
            return false;///неверно
 
        }
 
 
     }
 
     }
 
+
     else if (str == string("bishop"))
     for(int i=1; a+i<n && b+i<n; ++i)///диагональ вправо-вниз
 
 
     {
 
     {
         if(mass[a+i][b+i])///в каждой ячейке массива [a+i][b+i]
+
         figure = BISHOP;
        {
 
            return false;///неверно
 
        }
 
 
     }
 
     }
 
+
     else if (str == string("knight"))
     for(int i=1; a+i<n && b-i>=0; ++i)///диагональ влево-вниз
 
 
     {
 
     {
        if(mass[a+i][b-i])///в каждой ячейке массива [a+i][b-i]
+
      figure = KNIGHT;
        {
 
            return false;///неверно
 
        }
 
 
     }
 
     }
 
+
     //вывести ошибку в случае неверного ввода
     for(int i=1; a-i>=0 && b+i<n; ++i)///диагональ вправо-вверх
+
    else
 
     {
 
     {
         if(mass[a-i][b+i])///в каждой ячейке массива [a-i][b+i]
+
         cout << "wrong figure type" << endl;
        {
+
        throw string("wrong figure type");
            return false;///неверно
 
        }
 
 
     }
 
     }
  
        return true;///в остальных случаях верно
+
    return figure;
 
 
 
}
 
}
  
///проверяем наличие фигур по горизонтали, вертикали и диагоналям
+
int main()
bool tryQueen(int a, int b)
 
 
{
 
{
 +
    //использовать стандартное пространств имен
 +
    using namespace std;
 +
 +
    int size;
 +
    string type_of_figure;
 +
    string type_of_action;
 +
    figure_type figure;
  
     if (!isEmptyHorisontal(a) || !isEmptyVertical(b) || !isEmptyDiagonales(a,b))///если не выполняются эти условия,
+
     cout << "Возможные фигуры: king, queen, rook, bishop, knight" << endl;
                                                                                ///т.е. постановка фигуры не удовлетворяет расстановке
+
    cout << "Возможные действия: max, placing" << endl;
                                                                                ///по горизонтали, или по вертикали, или по диагонали
+
     cout << "----------------------------------------------------" << endl;
     return false;///неверно
 
  
     return true;///в остальных случаях верно
+
     cout <<"Введите размер доски: ";
 +
    cin >> size;
 +
    chess_board board(size);
  
}
+
    cout << "Введите тип фигуры: ";
 +
    cin >> type_of_figure;
 +
    figure = get_figure_type(type_of_figure);
  
/// функция поиска результатов решений.
+
    cout << "Введите необходимое действие: ";
/// row - номер очередной строки в которую нужно поставить очередного ферзя.
+
    cin >> type_of_action;
/// count - количество фигур, поставленое к данному моменту
 
void setQueen(int row, int count)
 
{
 
  
     for(int column=0; column<n; ++column)///двигаемся по столбцу сверху вниз
+
     if (type_of_action == string("max"))
 
     {
 
     {
  
         if(tryQueen(row, column))/// проверка, если поставить ферзя в ячейку [row][column],
+
         int max_figures = get_max_figures(figure, size);
                                ///будет ли он единственным в этих строке, столбце и диагоналях
+
         cout << "Max figures: " << max_figures << endl;
         {
 
            mass[row][column]=1;
 
 
 
            if(count+1==figura) /// нужное количество фигур поставлено
 
            {
 
                output_mass(); /// вызов функции вывода массива на экран
 
                zapis("Zapis");///записываем в файл
 
            }
 
 
 
            else
 
            {
 
                for(int i = row + 1; i<n; i++)/// ставим следующего ферзя в одну из следующих строк
 
                setQueen(i,count+1);///и повторяем цикл
 
            }
 
 
 
            mass[row][column]=0;
 
  
 +
        cout << "Хотите ли вы просмотреть все варианты? (yes/no) ";
 +
        string answer;
 +
        cin >> answer;
 +
        //если нужно вывести все расстановки, то применить непосредственно функцию поиска расстановок максимума
 +
        if (answer == string("yes"))
 +
        {
 +
            int step = 0;
 +
            place_figures_for_max(board, figure, max_figures, step);
 
         }
 
         }
 +
    }
 +
    //иначе если нужно расставить определенное количество фигур, то применить функцию поиска расстановок
 +
    //относительно введенного числа
 +
    else if (type_of_action == string("placing"))
 +
    {
 +
        int figures_to_place;
 +
        cout << "Сколько фигур нужно расставить: ";
 +
        cin >> figures_to_place;
  
 +
        int step = 0;
 +
        place_figures_for_max(board, figure, figures_to_place, step);
 +
    }
 +
    //иначе вывести ошибку действия
 +
    else
 +
    {
 +
        cout << "wrong type of action" << endl;
 +
        throw string("wrong type of action");
 
     }
 
     }
  
 +
    return 0;
 
}
 
}
  
bool tryRook(int a, int b)///проверка на наличие фигур по вертикали и горизонтали
 
{
 
  
    if (!isEmptyHorisontal(a) || !isEmptyVertical(b))///если не выполняются эти условия,
+
</syntaxhighlight>
                                                    ///т.е. постановка фигуры не удовлетворяет расстановке
+
</div>
                                                    ///по горизонтали, или по вертикали
 
    return false;///неверно
 
  
    return true;///в остальных случаях верно
 
  
}
 
  
/// функция поиска результатов решений.
+
'''[[Капитанюк Светлана]]'''
/// row - номер очередной строки в которую нужно поставить очередную ладью
 
/// count - количество фигур, поставленое к данному моменту
 
void setRook(int row, int count)
 
{
 
  
    for(int column=0; column<n; ++column)///двигаемся по столбцу сверху вниз
+
'''Краткое описание алгоритма''': Доска представлена в виде динамического массива. Если в клетке присутствует фигура, то тогада она обозначается '+', если же клетка осталась путсая, то тогда '0'.
    {
 
  
        if(tryRook(row, column))/// проверка, если поставить ладью в A[row][column], будет ли она единственной в этих строке и столбце
+
'''Инструкция''': Инструкция: при запуске программа предлагает пользователю ввести размер доски, при этом число должно быть четным (если же пользователь вводит нечетное число, программа предлагает ввести размер еще раз, и так до тех пор, пока не будет введено четное число). Далее пользователь выбирает режим работы программы - либо расстановка фигур, либо расчет максимального количества фигур. В режиме расстановки фигур программа предлагает выбрать тип фигуры, выводит максимальное число фигур для доски заданного размера и предлагает ввести желаемое число фигур для расстановки (если оно больше максимального, предлагается повторная попытка ввода). В режиме расчета максимального числа программа предлагает выбрать тип фигуры, выводит рассчитанное число и задает вопрос о необходимости вывода всех возможных расстановок максимального количества для данной фигуры. Оба режима работают (т.е. все запросы повторяются) до тех пор, пока пользователь не даст команду на завершение цикла. Кроме того, в программе есть возможность изменения размера доски после выхода из всех циклов. При положительном ответе пользователя и изменении размера доступны оба режима работы.
        {
 
  
            mass[row][column]=1;
+
Скачать можно  [http://tm.spbstu.ru/File:Chess_03.zip тут].
  
            if(count+1==figura) /// нужное количество фигур поставлено
+
'''[[Киселёв Лев]]'''
            {
 
                output_mass(); /// вызов функции вывода массива на экран
 
                zapis("Zapis");///записываем в файл
 
            }
 
  
            else
+
'''Основная идея программы''': реализация задачи о расстановке фигур одинакового типа на произвольной доске MxM
            {
+
Скачать можно [http://mech.spbstu.ru/File:main.rar здесь]
                for(int i = row + 1; i<n; i++)/// ставим следующую ладью в одну из следующих строк
 
                setRook(i,count+1);///и повторяем цикл
 
            }
 
  
            mass[row][column]=0;
+
'''[[Козловская Анна]]'''
  
        }
+
'''Краткое описание алгоритма:''' Доска представлена в виде динамического массива[m;m], при выводе на экран пустые клетки обозначаются звездочками,а клетки, заполненные фигурами-буквами(каждая буква соответствует первой букве названия фигуры на английском языке). Для всех фигур написаны алгоритмы проверки на возможность расстановки фигуры. После выбора типа фигуры,используется рекурсивная функция,которая проверяет возможные расстановки через данную функцию проверки ,для данного типа фигуры. Во втором варианте работы программы,она аналитически высчитывает максимально возможное количество заданных фигур на доске.В программу встроена функция,проверяющая доску на повторные и симметричные относительно всех осей симметрии способы расстановки фигур.
  
    }
+
'''Инструкция:''' В меню указывается два варианта развития событий. Пользователь должен выбрать один из путей. Он вводит размер доски и тип фигуры и кол-во фигур(для первого типа работы программы).Если он выбирает первый вариант работы программы  - вывод всех различных расстановок N фигур.Другой вариант работы программы максимальное число расстановок- программа выводит их количество.
  
}
+
Скачать можно  [http://tm.spbstu.ru/File:Chess3.rar тут].
  
bool tryElephant(int a, int b) ///проверка на наличие фигур по диагоналям.
+
'''[[Лебедев Станислав]]'''
{
 
  
    if (!isEmptyDiagonales(a,b))///если не выполняется это условие,
+
'''Функционал программы''': получение всевозможных расстановок n однотипных шахматных фигур первой линии на поле n на n,таких,чтобы фигуры не били друг друга(считается,что фигуры одного цвета также могут бить друг друга) или получения максимального количества фигур первой линии,которые могут стоять на доске n*n;
                                ///т.е. постановка фигуры не удовлетворяет расстановке по диагоналям
 
    return false;
 
  
    return true;
+
'''Идея алгоритма''': рекурсивно вызывается функция,которая ставит фигуру в пустую и небитую клетку, а также отмечает клетки,которые эта фигура бьет. Рекурсия продолжается до тех пор,пока либо не будет достигнуто нужное количество, либо не будет возможности поставить фигуру. После выхода из рекурсии начинается "обратный ход", в котором отмеченные как битые на этом шаге,"размечаются"(снимается отметка,что эта клетка бьется),а место,занятое самой фигурой, запоминается.
  
}
+
Скачать можно  [http://tm.spbstu.ru/Файл:Шахматы.rar тут].
  
/// функция поиска результатов решений.
+
<div class="mw-collapsible mw-collapsed" style="width:100%" >
/// diagonale - номер диагонали в которую нужно поставить очередного слона
+
<syntaxhighlight lang="cpp" line start="1" enclose="div">
/// count - количество фигур, поставленое к данному моменту
+
#include <iostream>
void setElephant(int diagonale, int count)
+
#include <math.h>
 +
#include <cmath>
 +
 
 +
using namespace std;
 +
 
 +
int n,type, *a, *stak, variant, maxst = 0;
 +
 
 +
void king(int x, int &top)                     //отметить битые клетки королем
 
{
 
{
 +
    // 012
 +
    // 345
 +
    // 678
  
     int a, b; /// опорная точка диагонали (крайняя левая)
+
     //0
 
+
     if (((x % n) > 1) && ((x / n) > 1))
     if (diagonale < n)///если номер диагонали меньше n
 
 
     {
 
     {
         a = diagonale;///значению а присвоить значенье номера диагонали
+
         int ii = x - n - 1;
        b = 0;///значению b присвоить значение 0
+
        if (a[ii] != -2)
 +
        {
 +
            a[ii]++;
 +
            stak[top] = ii;
 +
            top++;
 +
        }
 
     }
 
     }
  
     else///иначе
+
     //1
 +
    if ((x / n) > 0)
 
     {
 
     {
         a = n-1;///значению а присвоить значение n-1
+
         int ii = x - n;
         b =(diagonale % n)+1;///значению b присвоить значение целого частного от деления номера диагонали на n прибавив к нему 1
+
        if (a[ii] != -2)
 +
         {
 +
            a[ii]++;
 +
            stak[top] = ii;
 +
            top++;
 +
        }
 
     }
 
     }
  
     /// перебираем все "столбцы" текущей диагонали
+
     //2
     for(int dcolumn=0; a-dcolumn>=0 && b+dcolumn < n; ++dcolumn)
+
     if (((x % n) < (n - 1)) && ((x / n) > 0))
 
     {
 
     {
 
+
         int ii = x - n + 1;
        /// рассчёт координат клетки по координатам крайней точки диагонали и "столбца" в диагонали
+
         if (a[ii] != -2)
         int x = a-dcolumn;
 
        int y = b+dcolumn;
 
 
 
         if(tryElephant(x, y))/// проверка, если поставить слона в A[row][column], будет ли он единственным по диагоналям
 
 
         {
 
         {
 
+
             a[ii]++;
             mass[x][y]=1;
+
             stak[top] = ii;
 
+
             top++;
             if(count+1==figura) /// нужное количество фигур поставлено
 
            {
 
                output_mass(); /// вызов функции вывода массива на экран
 
                zapis("Zapis");///запись в файл
 
            }
 
 
 
            else
 
             {
 
                for(int i = diagonale + 1; i<2*n-1; i++)/// ставим следующего слона в одну из следующих диагоналей
 
                setElephant(i,count+1);///и повторяем цикл
 
            }
 
 
 
            mass[x][y]=0;
 
 
 
 
         }
 
         }
 
 
     }
 
     }
  
}
+
    //3
 
+
    if ((x % n) > 0)
/// проверка на наличие фигуры на позиции x,y
 
bool isFigure(int x, int y)
 
{
 
    return 0 <= x && x < n && 0 <= y && y < n && mass[x][y];
 
}
 
 
 
///проверка на наличие короля в квадрате 3 на 3
 
bool tryKing(int a, int b)
 
{
 
 
 
    for(int i = a-1; i <= a+1; i++)///для ячеек находящихся слева и справа от поставленного короля
 
 
     {
 
     {
         for(int j = b-1; j <= b+1; j++)///для ячеек находящихся снизу и сверху от поставленного короля
+
         int ii = x - 1;
 +
        if (a[ii] != -2)
 
         {
 
         {
             if (isFigure(i,j))///если выполняется это условие
+
             a[ii]++;
             return false;///неверно
+
            stak[top] = ii;
 +
             top++;
 
         }
 
         }
 
     }
 
     }
  
     return true;///в остальных случаях верно
+
     //5
 
+
    if ((x % n) < (n - 1))
}
 
 
 
///функция поиска результатов решений
 
/// count - количество фигур, поставленое к данному моменту
 
///x,y - позиция, начиная с которой разрешено ставить фигуры (все предшествующие позиции уже точно определены)
 
void setKing(int count, int x, int y)
 
{
 
 
 
    if(count==figura)///figura - количество фигур, вводимых пользователями.
 
 
     {
 
     {
         output_mass();/// вызов функции вывода массива на экран
+
         int ii = x + 1;
         zapis("Zapis");///записываем в файл
+
         if (a[ii] != -2)
         return;
+
        {
 +
            a[ii]++;
 +
            stak[top] = ii;
 +
            top++;
 +
         }
 
     }
 
     }
  
     if (x == n) /// строки закончились
+
    //6
        return;
+
     if (((x % n ) > 0) && ((x / n) < (n - 1)))
 
 
    /// обрабатываем текущую строку
 
    for (int j=y; j<n; ++j)
 
 
     {
 
     {
 
+
        int ii = x + n - 1;
         if(tryKing(x, j))
+
         if (a[ii] != -2)
 
         {
 
         {
             mass[x][j]=1;
+
             a[ii]++;
             /// смещаем разрешённую позицию на 1 вправо или в начало следующей строки
+
             stak[top] = ii;
            int nextX = x, nextY = j+1;
+
             top++;
 
+
        }
             if (nextY == n)///если столбец последний
+
    }
            {
 
                nextY = 0;///идем сначала по столбцам
 
                nextX++;///к строке прибавляем 1
 
            }
 
 
 
            /// ставим следующего короля
 
            setKing(count+1,nextX,nextY);
 
            mass[x][j]=0;
 
  
 +
    //7
 +
    if ((x / n ) < (n - 1))
 +
    {
 +
        int ii = x + n;
 +
        if (a[ii] != -2)
 +
        {
 +
            a[ii]++;
 +
            stak[top] = ii;
 +
            top++;
 
         }
 
         }
 
 
     }
 
     }
  
     /// обрабатываем прямоугольник ниже текущей строки
+
     //8
     for(int i=x+1; i<n; ++i)
+
     if (((x % n ) < (n - 1)) && ((x / n) < (n - 1)))
 
     {
 
     {
 
+
         int ii = x + n + 1;
         for (int j=0; j<n; ++j)
+
    if (a[ii] != -2)
 
         {
 
         {
 +
            a[ii]++;
 +
            stak[top] = ii;
 +
            top++;
 +
        }
 +
    }
 +
}
  
            if(tryKing(i, j))
+
void bishop(int x, int &top)                                                              //отметить битые клетки слоном
            {
+
{
                mass[i][j]=1;
+
    //вверх влево
                /// смещаем разрешённую позицию на 1 вправо или в начало следующей строки
+
    for (int i = (x - (n + 1)); ((i >= 0) && ((i%n) != (n-1))); i -= (n+1))
                int nextX = i, nextY = j+1;
+
    {
 +
        if (a[i] != -2)
 +
        {
 +
            a[i]++;
 +
            stak[top] = i;
 +
            top++;
 +
        }
 +
    }
  
                if (nextY == n)///если столбец последний
+
    //вниз вправо
                {
+
    for (int i = (x + (n + 1)); ((i < n*n) && ((i%n) != 0)); i += (n+1))
                    nextY = 0;///идем сначала по столбцам
+
    {
                    nextX++;///к строке прибавляем 1
+
        if (a[i] != -2)
                }
+
        {
 
+
            a[i]++;
                /// ставим следующего короля
+
            stak[top] = i;
                setKing(count+1,nextX,nextY);
+
            top++;
                mass[i][j]=0;
+
        }
 
+
    }
            }
 
  
 +
    //вверх вправо
 +
    for (int i = x - (n - 1); ((i >= 0) && ((i%n) != 0)); i -= (n-1))
 +
    {
 +
        if (a[i] != -2)
 +
        {
 +
            a[i]++;
 +
            stak[top] = i;
 +
            top++;
 
         }
 
         }
 
 
     }
 
     }
  
 +
    //вниз влево
 +
    for (int i = x + (n - 1); ((i < n*n) && ((i%n) != (n-1))); i += (n-1))
 +
    {
 +
        if (a[i] != -2)
 +
        {
 +
            a[i]++;
 +
            stak[top] = i;
 +
            top++;
 +
        }
 +
    }
 
}
 
}
  
bool tryHorse(int a, int b) ///проверка на коней по всем направлениям
+
void knight(int x, int &top)                                           //отметить битые клетки конем
{
 
 
 
    if (isFigure(a-1,b-2) || isFigure(a-1,b+2) || isFigure(a+1,b-2) || isFigure(a+1,b+2) || isFigure(a-2,b-1) || isFigure(a-2,b+1) || isFigure(a+2,b-1) || isFigure(a+2,b+1))
 
                                                        ///если выполняются эти условия,
 
                                                        ///т.е. фигара стоит на одной из этих позиций
 
        return false;///неверно
 
 
 
    return true;///в остальных случаях верно
 
 
 
}
 
 
 
///функция поиска результатов решений
 
/// count - количество фигур, поставленое к данному моменту.
 
void setHorse(int count, int x, int y)
 
 
{
 
{
 
+
     if (((x%n) > 0) && (x/n) > 1)
     if(count==figura)///figura - количество фигур, вводимых пользователями.
 
 
     {
 
     {
         output_mass();/// вызов функции вывода массива на экран
+
         int ii = x - 2*n - 1;
         zapis("Zapis");///записываем в файл
+
         if (a[ii] != -2)
         return;
+
        {
 +
            a[ii]++;
 +
            stak[top] = ii;
 +
            top++;
 +
         }
 
     }
 
     }
  
     if (x == n)/// строки закончились
+
     if (((x%n) > 1) && (x/n) > 0)
        return;
 
 
 
    /// обрабатываем текущую строку
 
    for (int j=y; j<n; ++j)
 
 
     {
 
     {
 
+
        int ii = x - n - 2;
         if(tryHorse(x, j))
+
         if (a[ii] != -2)
 
         {
 
         {
 +
            a[ii]++;
 +
            stak[top] = ii;
 +
            top++;
 +
        }
 +
    }
  
            mass[x][j]=1;
+
    if (((x%n) > 1) && (x/n) < (n - 1))
            /// смещаем разрешённую позицию на 1 вправо или в начало следующей строки
+
    {
            int nextX = x, nextY = j+1;
+
        int ii = x + n - 2;
 
+
        if (a[ii] != -2)
            if (nextY == n)///если столбец последний
+
        {
            {
+
            a[ii]++;
                nextY = 0;///идем сначала по столбцам
+
             stak[top] = ii;
                nextX++;///к строке прибавляем 1
+
             top++;
             }
+
        }
 
+
    }
             /// ставим следующего коня
 
            setHorse(count+1,nextX,nextY);
 
            mass[x][j]=0;
 
  
 +
    if (((x%n) > 0) && (x/n) < (n - 2))
 +
    {
 +
        int ii = x + 2*n - 1;
 +
        if (a[ii] != -2)
 +
        {
 +
            a[ii]++;
 +
            stak[top] = ii;
 +
            top++;
 
         }
 
         }
 
 
     }
 
     }
  
     /// обрабатываем прямоугольник ниже текущей строки
+
     if (((x%n) < (n - 1)) && (x/n) < (n - 2))
    for(int i=x+1; i<n; ++i)
 
 
     {
 
     {
 
+
         int ii = x + 2*n + 1;
         for (int j=0; j<n; ++j)
+
        if (a[ii] != -2)
 
         {
 
         {
 +
            a[ii]++;
 +
            stak[top] = ii;
 +
            top++;
 +
        }
 +
    }
  
            if(tryHorse(i, j))
+
    if (((x%n) < (n - 2)) && (x/n) < (n - 1))
            {
+
    {
 
+
        int ii = x + n + 2;
                mass[i][j]=1;
+
        if (a[ii] != -2)
                /// смещаем разрешённую позицию на 1 вправо или в начало следующей строки
+
        {
                int nextX = i, nextY = j+1;
+
            a[ii]++;
 
+
            stak[top] = ii;
                if (nextY == n)///если столбец последний
+
            top++;
                {
+
        }
                    nextY = 0;///идем сначала по столбцам
+
    }
                    nextX++;///к строке прибавляем 1
 
                }
 
 
 
                setHorse(count+1,nextX,nextY);
 
                mass[i][j]=0;
 
 
 
            }
 
  
 +
    if (((x%n) < (n - 2)) && (x/n) < 0)
 +
    {
 +
        int ii = x - n + 2;
 +
        if (a[ii] != -2)
 +
        {
 +
            a[ii]++;
 +
            stak[top] = ii;
 +
            top++;
 
         }
 
         }
 
 
     }
 
     }
  
}
+
    if (((x%n) < (n - 1)) && (x/n) < 1)
 
+
    {
int main()
+
        int ii = x - 2*n + 1;
{
+
        if (a[ii] != -2)
    setlocale(LC_ALL,"RUS");
+
        {
 
+
            a[ii]++;
  ofstream Zapis("Zapis", ios::trunc);///сохраняем в файл
+
            stak[top] = ii;
  Zapis.close();
+
            top++;
 +
        }
 +
    }
 +
}
  
     do
+
void rook(int x, int &top)                                                      //отметить битые клетки ладьей
 +
{
 +
     int k = x - (x % n);
 +
    while ((k/n) == (x/n))
 
     {
 
     {
        cout << "Введите размер доски (четный): ";
 
        cin >> n; ///ввод пользователем размера доски
 
    }while (n%2 != 0);
 
  
    mass=create_mass(n); ///создаём двумерный массив
+
        if ((k != x) && (a[k] != -2))
 +
        {
 +
            a[k]++;
 +
            stak[top] = k;
 +
            top++;
 +
        }
 +
        k ++;
 +
    }
  
     cout<<"Queen-1, Rook-2, Elephant-3, King-4, Horse-5"<< endl;
+
     k = (x % n);
     cin >> figureID; ///выбор пользователем фигуры
+
    while (((k/n)) != n)
 +
    {
 +
        if ((k != x) && (a[k] != -2))
 +
        {
 +
            a[k]++;
 +
            stak[top] = k;
 +
            top++;
 +
        }
 +
        k += n;
 +
     }
  
    /// устанавливаем максимальное количество в зависимости от фигуры
+
}
    if (figureID==1)
+
void set_figure(int x, int &top)                                    //ставим фигуры на доску
     maxCount=n;
+
{
     if (figureID==2)
+
     //отмечаем "битые" клетки
     maxCount=n;
+
     switch (type)
    if (figureID==3)
+
     {
    maxCount=2*n-2;
+
//король
    if (figureID==4)
+
        case 1:
    maxCount=(n*n)/4;
+
        {
    if (figureID==5)
+
            king(x,top);
    maxCount=(n*n)/2;
+
            break;
 +
        }
  
    /// запрашиваем количество фигур
+
//слон
    do
+
case 2:
    {
+
{
        cout << "Введите количество фигур (максимальное количество - " << maxCount << "): ";
+
    bishop(x,top);
        cin >> figura;
+
            break;
    }while (figura>maxCount);
+
}
  
    /// запускаем перебор
+
//конь
    if (figureID==1)
+
case 3:
    {
+
{
        for(int i = 0; i<n; i++)
+
    knight(x,top);
         setQueen(i,0);
+
break;
        zapis("Zapis");
+
}
    }
+
//ладья
    if (figureID==2)
+
        case 4:
    {
+
         {
        for(int i = 0; i<n; i++)
+
            rook(x,top);
        setRook(i,0);
+
            break;
         zapis("Zapis");
+
        }
 +
        //ферзь
 +
        case 5:
 +
        {
 +
            rook(x,top);
 +
            bishop(x,top);
 +
            break;
 +
         }
 
     }
 
     }
    if (figureID==3)
+
 
     {
+
     //отмечаем,что в данной клетке стоит фигура
        for(int i = 0; i<2*n-1; i++)
+
a[x] = -1;
        setElephant(i,0);
+
     stak[top] = x;
        zapis("Zapis");
+
     top++;
    }
 
    if (figureID==4)
 
    {
 
        setKing(0,0,0);
 
        zapis("Zapis");
 
     }
 
    if (figureID==5)
 
    {
 
        setHorse(0,0,0);
 
        zapis("Zapis");
 
     }
 
    system("PAUSE");
 
 
}
 
}
</syntaxhighlight>
 
</div>
 
  
'''[[Тимошенко Валентина]]'''
+
void step(int top,int x,int st)
 
+
{
'''Краткое описание алгоритма''': доска представлена в виде динамического массива, при выводе на экран пустые клетки обозначаются точками, а клетки, заполненные фигурами, обозначаются буквами (каждая буква соответствует первой букве названия фигуры на английском языке). Для каждой фигуры написаны функции проверки на возможность установки фигуры и функции расстановки. Кроме того, программа аналитически считает максимальное количество фигур для доски заданного пользователем размера и, при наличии команды пользователя, выводит все возможные расстановки рассчитанного максимального количества фигур на экран.
+
int xtop = top;
 +
switch (variant)
 +
{
 +
case 1:
 +
{
 +
if (st != (n - 1))
 +
{
 +
set_figure(x,top);
 +
for (int i = 0; i < (n*n); i++)
 +
if (a[i] == 0)
 +
step(top,i,st + 1);
 +
}
 +
else[[:File:Шахматы.rar]]
 +
{
 +
set_figure(x,top);
 +
                cout << endl;
 +
for (int i = 0; i < (n*n); i++)
 +
{
 +
cout.width(3);
 +
if (((i % n) == 0) && (i != 0))
 +
cout << endl;
 +
if (a[i] == -1)
 +
cout << 1;
 +
else
 +
cout << 0;
 +
}
 +
cout << endl;
 +
}
 +
break;
 +
}
 +
case 2:
 +
{
 +
set_figure(x,top);
 +
if ((st+1) > maxst)
 +
maxst = st + 1;
 +
for (int i = 0; i < (n*n); i++)
 +
if (a[i] == 0)
 +
step(top,i,st+1);
 +
break;
 +
}
 +
}
  
'''Инструкция''': при запуске программа предлагает пользователю ввести размер доски, при этом число должно быть четным (если же пользователь вводит нечетное число, программа предлагает ввести размер еще раз, и так до тех пор, пока не будет введено четное число). Далее пользователь выбирает режим работы программы - либо расстановка фигур, либо расчет максимального количества фигур. В режиме расстановки фигур программа предлагает выбрать тип фигуры, выводит максимальное число фигур для доски заданного размера и предлагает ввести желаемое число фигур для расстановки (если оно больше максимального, предлагается повторная попытка ввода). В режиме расчета максимального числа программа предлагает выбрать тип фигуры, выводит рассчитанное число и задает вопрос о необходимости вывода всех возможных расстановок максимального количества для данной фигуры. Оба режима работают (т.е. все запросы повторяются) до тех пор, пока пользователь не даст команду на завершение цикла. Кроме того, в программе есть возможность изменения размера доски после выхода из всех циклов. При положительном ответе пользователя и изменении размера доступны оба режима работы.
 
  
Скачать можно  [http://tm.spbstu.ru/Файл:Chessboard.zip здесь].
 
  
<div class="mw-collapsible mw-collapsed" style="width:100%" >
+
// обратный ход
<syntaxhighlight lang="cpp" line start="1" enclose="div">
+
     for (int i = xtop; i < top; i++)
 
 
#include <iostream> ///расстановка одинаковых шахматных фигур одного цвета на доске произвольного размера так, чтобы они друг друга не били
 
#include <cstring>
 
#include <cstdlib>
 
#include <ctime>
 
 
 
using namespace std;
 
int result_count = 0; ///переменная, в которую закладывается номер варианта расстановки фигур
 
int N; ///то количество фигур для расстановки, которое задает пользователь
 
int **Board; ///двумерный массив для отображения шахматной доски
 
int M; /// размер шахматной доски
 
 
 
///Функция вывода доски
 
void showBoard(string F) ///данная функция отображает доску
 
{
 
     for(int i = 0; i < M; ++i) /// цикл, прогоняющий значения по строкам
 
 
     {
 
     {
         for(int j = 0; j < M; ++j)  /// цикл, прогоняющий значения по столбцам
+
         if ((a[stak[i]] != -1) && (a[stak[i]] != -2))
             cout << ((Board[i][j]) ? F : "."); ///заполнение как строки, так и столбца символом, который обозначает позицию на шахматной доске
+
            a[stak[i]]--;
        cout << endl;                         ///точка - если данная клетка пустая, буква - если в клетке стоит соответствующая фигура
+
        else
 +
            //не забываем отметить,что фигура уже здесь стояла(чтобы избежать повторов)
 +
             if (a[stak[i]] == -1)
 +
                a[stak[i]] = -2;
 +
//       cerr << " Back "  << stak[i] << endl;
 
     }
 
     }
    cout << "Result # " << ++result_count << "\n\n"; ///вывод номера варианта расположения с последующим переходом на новую строку
 
    return;
 
 
}
 
}
  
///Функции проверки и установки для ферзя
+
int main()
 
 
bool tryQueen(int a, int b) /// проверка на возможность поставить фигуру в данную клетку, a- очередная строка, b- очередной столбец
 
 
{
 
{
    for (int i = 0; i < M; ++i) ///проверка единственности ферзя в строке
 
    {
 
        if(Board[a][i])
 
            return false;
 
    }
 
  
     for(int i = 0; i < M; ++i) ///проверка единственности ферзя в столбце
+
     //cin >> n >> type >> variant;
     {
+
    n = 5;
        if(Board[i][b])
+
    type = 4;
            return false;
+
variant = 1;
    }
+
     a    = new int[n*n];
 +
    stak = new int[n*n*4];
  
     for(int i = 1; a-i >= 0 && b-i >= 0; ++i)///проверка единственности ферзя по диагонали влево-вверх
+
     for (int i = 0; i < (n*n); i++)
 
     {
 
     {
         if(Board[a-i][b-i])
+
         for (int j = 0; j < (n*n); j++)
             return false;
+
            a[j] = 0;
 +
        if (variant == 1)
 +
             cout << "__________________________________" << endl;
 +
        step(0,i,0);
 
     }
 
     }
 +
if (variant == 2)
 +
  cout << maxst;
 +
    return 0;
 +
}
 +
</syntaxhighlight>
 +
</div>
  
    for(int i = 1; a+i < M && b+i < M; ++i)///проверка единственности ферзя по диагонали вправо-вниз
+
'''[[Лобанов Илья]]'''
    {
 
        if(Board[a+i][b+i])
 
            return false;
 
    }
 
  
    for(int i = 1; a+i < M && b-i >= 0; ++i)///проверка единственности ферзя по диагонали влево-вниз
+
'''Описание алгоритма''':
    {
 
        if(Board[a+i][b-i])
 
            return false;
 
    }
 
  
    for(int i = 1; a-i >= 0 && b+i < M; ++i)///проверка единственности ферзя по диагонали вправо-вверх
+
Программа проверяет возможность расстановки фигур на доске M*M . При выводе на экран на экран клетки,занятые фигурами ,помечаются буквами,соответствующими первой букве типа фигуры. Также программа считает максимальное число фигур определенного типа,которые можно расставить на доске.
    {
 
        if(Board[a-i][b+i])
 
            return false;
 
    }
 
  
    return true; ///если в ходе проверки ферзей и угроз не обнаружилось, в данную клетку можно поставить фигуру
+
'''Инструкция''':
}
 
  
void setQueen(int a, int count) ///функция расстановки ферзей; a - очередная строка, count - счетчик количества фигур, которое необходимо расставить
+
В окне консоли пользователю предлагается выбрать 2 типа работы программы, затем пользователь вводит размер доски(четный),тип и количество фигур,которые необходимо разместить на доске.В зависимости от режима работы программы ,будет выведено либо максимально возможное число расстановок фигур,либо максимальное число фигур.
{
+
Скачать можно [[http://tm.spbstu.ru/File:ConsoleApplication54.rar тут]]
    for(int b = 0; b < M; ++b) ///b - очередной столбец, расстановка идет по строкам
+
<div class="mw-collapsible mw-collapsed" style="width:100%" >
    {
+
<syntaxhighlight lang="cpp" line start="1" enclose="div">
        if(tryQueen(a, b)) ///проверка данной клетки на возможность установки фигуры
+
#include <iostream>
        {
+
#include <windows.h>
            Board[a][b] = 1; ///установка ферзя в первую клетку поля, присваивание ей значения 1 (true)
+
using namespace std;
  
            for(int i = a + 1; i < M; ++i) ///расстановка указанного пользователем количества фигур
+
enum type{peshka, king, kon, ladya, slon, queen}; // все возможные типы фигур
                setQueen(i,count+1);
+
const char symbols[] = "pKklsQ"; // буквенное обозначение каждой фигуры:p - пешка, K - король, k - конь, l- ладья, s - слон, Q - ферзь
 +
const int NONE = INT_MAX;//константа для обозначения пустой клетки
 +
int M, **desk, *colons, *rows, *diag_1, *diag_2;
  
            if(count+1 == N) /// если нужное количество фигур поставлено, то
+
// структура для описания клектки доски
                showBoard("Q"); /// вызов функции вывода шахматной доски на экран
+
struct point
 
 
            Board[a][b]=0; ///обнуление переменной для установки следующей фигуры в следующую клетку
 
        }
 
    }
 
}
 
 
 
///Функции проверки и установки для ладьи
 
 
 
bool tryRook(int a, int b) /// проверка на возможность поставить фигуру в данную клетку, a- очередная строка, b- очередной столбец
 
 
{
 
{
    for (int i = 0; i < M; ++i) ///проверка единственности ладьи в строке
+
int x, y;
    {
+
point(int x = 0, int y = 0): x(x), y(y) {}
        if(Board[a][i])
+
point &operator++()
            return false;
+
{
    }
+
if (y == M - 1)
 +
{
 +
++x;
 +
y = 0;
 +
}
 +
else
 +
++y;
 +
return *this;
 +
}
 +
point operator+(const point &p) const
 +
{
 +
return point(x + p.x, y + p.y);
 +
}
 +
point next() const
 +
{
 +
point r = *this;
 +
return ++r;
 +
}
 +
};
  
    for(int i = 0; i < M; ++i) ///проверка единственности ладьи в столбце
 
    {
 
        if(Board[i][b])
 
            return false;
 
    }
 
  
    return true; ///если в ходе проверки ладей и угроз не обнаружилось, в данную клетку можно поставить фигуру
+
int *new_array(int n)
 +
{
 +
int *a = new int[n];
 +
fill(a, a + n, NONE);
 +
return a;
 
}
 
}
  
void setRook(int a, int count) ///функция расстановки ладей; a - очередная строка, count - счетчик количества фигур, которое необходимо расставить
+
// Количество свободных клеток от клетки p до конца доски
 +
int rest(const point &p, type t)
 
{
 
{
    for(int b = 0; b < M; ++b) ///b - очередной столбец, расстановка идет по строкам
+
int r0 = (M - p.x) * M - p.y, r,
    {
+
m = M - p.x,
        if(tryRook(a, b)) ///проверка данной клетки на возможность установки фигуры
+
s_2 = (m + 1) / 2 * M;
        {
+
switch (t)
            Board[a][b] = 1; ///установка ладьи в первую клетку, присваивание ей значения 1 (true)
+
{
 
+
case peshka:
            for(int i = a + 1; i < M; ++i) ///расстановка указанного пользователем количества фигур
+
case kon:
                setRook(i,count+1);
+
r = s_2; break;
 
+
case king:
            if(count+1 == N) /// если нужное количество фигур поставлено, то
+
r = s_2 / 2; break;
                showBoard("R"); /// вызов функции вывода шахматной доски на экран
+
case ladya:
 +
case queen:
 +
return m;
 +
case slon:
 +
r = m + M - 1;
 +
}
 +
return min(r0, r);
 +
}
  
            Board[a][b]=0; ///обнуление переменной для установки следующей фигуры в следующую клетку
+
// Помечает клетку доски номером i
        }
+
void set(const point &p, type t, int i)
    }
+
{
 +
if (t == peshka || t == king || t == kon)
 +
desk[p.x][p.y] = i;
 +
else
 +
{
 +
if (t == ladya || t == queen)
 +
colons[p.y] = rows[p.x] = i;
 +
if (t == slon || t == queen)
 +
diag_1[p.x+p.y] = diag_2[p.x-p.y+M-1] = i;
 +
}
 
}
 
}
  
///Функции проверки и установки для слона
+
// Можно ли поставить фигуру номер i на клетку p
 
+
bool empty(const point &p, type t, int i)
bool tryEl(int a, int b) /// проверка на возможность поставить фигуру в данную клетку, a- очередная строка, b- очередной столбец
 
 
{
 
{
    for(int i = 1; a-i >= 0 && b-i >= 0; ++i)///проверка единственности слона по диагонали влево-вверх
+
const int n_attack[3] = {4, 8, 8};
    {
+
const point attack[3][8] = {{point(1, 1), point(1, -1), point(-1, 1), point(-1, -1)}, //кол-во вариантов атаки для пешки
        if(Board[a-i][b-i])
+
{point(1, 1), point(1, -1), point(-1, 1), point(-1, -1), point(1, 0), point(-1, 0), point(0, 1), point(0, -1)}, // кол-во вариантов атаки для короля
            return false;
+
{point(1, 2),point(-1, 2),point(1, -2), point (-1,-2), point (2, 1), point (2,-1), point (-2, 1),point (-2,-1)}};  //количество вариантов атаки для коня
    }
+
switch(t)
 
+
{
    for(int i = 1; a+i < M && b+i < M; ++i)///проверка единственности слона по диагонали вправо-вниз
+
case peshka:
    {
+
case king:
        if(Board[a+i][b+i])
+
case kon:
            return false;
+
for (int k = 0; k < n_attack[t]; k++)
    }
+
{
 +
point q = p + attack[t][k];
 +
if (q.x >= 0 && q.x < M && q.y >= 0 && q.y < M && desk[q.x][q.y] < i)
 +
return false;
 +
}
 +
return true;
 +
case ladya:
 +
return colons[p.y] > i && rows[p.x] > i;
 +
case slon:
 +
return diag_1[p.x+p.y] > i && diag_2[p.x-p.y+M-1] > i;
 +
case queen:
 +
return colons[p.y] > i && rows[p.x] > i && diag_1[p.x+p.y] > i && diag_2[p.x-p.y+M-1] > i;
 +
}
 +
}
  
    for(int i = 1; a+i < M && b-i >= 0; ++i)///проверка единственности слона по диагонали влево-вниз
+
//печатает заданное количество досок на экране
    {
+
void print(point **figures, int n_desks, int N, type t, ostream &out = cout)
        if(Board[a+i][b-i])
 
            return false;
 
    }
 
 
 
    for(int i = 1; a-i >= 0 && b+i < M; ++i)///проверка единственности слона по диагонали вправо-вверх
 
    {
 
        if(Board[a-i][b+i])
 
            return false;
 
    }
 
 
 
    return true; ///если в ходе проверки слонов и угроз не обнаружилось, в данную клетку можно поставить фигуру
 
}
 
void setEl(int dia, int count) ///функция расстановки слонов; line - очередная строка, count - счетчик количества фигур, которое необходимо расставить
 
 
{
 
{
    ///dia - очередная диагональ, которую нужно исследовать на наличие фигуры и угрозы
+
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
    int a, b; ///клетка, с которой начинается расстановка, a- очередная строка, b- очередной столбец
+
for (int n = 0; n < n_desks; n++)
 +
{
 +
out << " \xdb";
 +
for (int i = 0; i < M * 2 + 2; i++)
 +
out << "\xdf";
 +
out << "\xdb";
 +
}
 +
out << endl;
  
    if (dia < M) ///условие, что клеткa данной диагонали лежат на доске
+
int *K = new int[n_desks];
    {
+
fill(K, K + n_desks, 0);
        a = dia; ///начало отсчёта диагоналей, цикл движется по строке
+
for (int i = 0; i < M; i++)
        b = 0; ///обнуление переменной для столбца, цикл движется по столбцу
+
{
    }
+
for (int n = 0; n < n_desks; n++)
  else ///если клеткa данной диагонали выходит за размер доски (когда цикл по строке доберется до конца
+
{
    {
+
int &k = K[n];
        a = M-1; ///самая последняя диагональ
+
out << " \xdb ";
        b =(dia % M)+1; ///соответственно расчёт переменной для столбца этой диагонали
+
for (int j = 0; j < M; j++)
    }
+
{
 +
SetConsoleTextAttribute(hConsole, (i + j) % 2 == 0 ? 0xf0 : 0xf);
 +
if (k < N && i == figures[n][k].x && j == figures[n][k].y)
 +
{
 +
out << ' ' << symbols[t];
 +
k++;
 +
}
 +
else
 +
out << "  ";
 +
}
 +
SetConsoleTextAttribute(hConsole, 0x70);
 +
out << " \xdb";
 +
}
 +
out << endl;
 +
}
 +
delete[] K;
  
    for(int i=0; a-i>=0 && b+i < M; ++i)/// цикл движется по строкам и столбцам снизу слева вправо вверх
+
for (int n = 0; n < n_desks; n++)
    {
+
{
        int line = a-i; ///строковая координата данной клетки диагонали
+
out << " \xdb";
        int column = b+i; ///столбцовая координата данной клетки диагонали
+
for (int i = 0; i < M * 2 + 2; i++)
 
+
out << "\xdc";
        if(tryEl(line, column))/// проверка на единственность слона по диагоналям
+
out << "\xdb";
        {
+
}
            Board[line][column]=1; ///установка слона в первую клетку, присваивание ей значения 1 (true)
+
out << endl << endl;
 
 
            for(int i = dia + 1; i<2*M-1; ++i) ///расстановка указанного пользователем количества фигур
 
                setEl(i,count+1);
 
 
 
            if(count+1 == N) /// если нужное количество фигур поставлено, то
 
                showBoard("E"); /// вызов функции вывода шахматной доски на экран
 
 
 
            Board[line][column]=0; ///обнуление переменной для установки следующей фигуры в следующую клетку
 
        }
 
    }
 
 
}
 
}
  
///Функции проверки и установки для коня
+
// Вывести все возможные расположения на доске N фигур
 
+
void all_placements(int N, type t)
bool tryHorse(int a, int b) /// проверка на возможность поставить фигуру в данную клетку, a- очередная строка, b- очередной столбец
 
 
{
 
{
    ///проверка на наличие фигур и угроз во всех 8 точках, которые могут быть под ударом в квадрате 5х5 вокруг установленной фигуры
+
desk = NULL;
 
+
colons = rows = diag_1 = diag_2 = NULL;
    if ((a-1) >=0 && (b-2)>=0 && Board[a-1][b-2])
+
// создание необходимых массивов, отмечающих занятость клеток, в зависимости от вида фигуры
        return false;
+
if (t == peshka || t == king || t == kon)
 
+
{
    if ((a-1)>=0 && (b+2) < M && Board[a-1][b+2])
+
desk = new int*[M];
        return false;
+
for (int j = 0; j < M; j++)
 
+
desk[j] = new_array(M);
    if ((a+1) < M && (b-2) >=0 && Board[a+1][b-2])
+
}
        return false;
+
else
 +
{
 +
if (t == ladya || t == queen)
 +
{
 +
colons = new_array(M);
 +
rows = new_array(M);
 +
}
 +
if (t == slon || t == queen)
 +
{
 +
diag_1 = new_array(2*M-1);
 +
diag_2 = new_array(2*M-1);
 +
}
 +
}
 +
 +
const int W = 80 / (2 * M + 5);//количество досок,помещающихся на экране
 +
point **figures = new point*[W];//массив фигур
 +
for (int j = 0; j < W; j++)
 +
figures[j] = new point[N];
  
    if ((a+1) < M && (b+2) < M && Board[a+1][b+2])
+
int i = 0, // номер фигуры
        return false;
+
k = 0; //номер комбинации
 
+
while (true)
    if ((a-2) >=0 && (b-1) >=0 && Board[a-2][b-1])
+
{
        return false;
+
if (rest(figures[k%W][i], t) < N - i) // если оставшиеся фигуры не помещаются на доске
 
+
{
    if ((a-2) >=0 && (b+1) < M && Board[a-2][b+1])
+
if (i == 0) // если все комбинации закончились
        return false;
+
{
 
+
// вывод оставшихся досок
    if ((a+2) < M && (b-1) >= 0 && Board[a+2][b-1])
+
if (k % W)
        return false;
+
print(figures, k % W, N, t);
 
+
cout << "Amount of combinations: " << k << endl;
    if ((a+2) < M && (b+1) < M && Board[a+2][b+1])
+
break;
        return false;
+
}
 +
// переходим к предыдущей фигуре и помечаем клетку пустой
 +
set(figures[k%W][--i], t, NONE);
 +
// сдвигаем фигуру на шаг вперёд
 +
++figures[k%W][i];
 +
}
 +
else if (!empty(figures[k%W][i], t, i)) // если фигуры помещаются, но текущая клетка под ударом
 +
// сдвигаем текущую фигуру на шаг вперёд
 +
++figures[k%W][i];
 +
else if (i == N - 1) // если ставим последнюю фигуру
 +
{
 +
// если текущая доска - последняя на строке экрана, выводим W досок
 +
if ((k + 1) % W == 0)
 +
print(figures, W, N, t);
 +
// копирование комбинаций фигур на следующую доску
 +
for (int j = 0; j < N; j++)
 +
figures[(k+1)%W][j] = figures[k%W][j];
 +
// переход к следующей доске
 +
k++;
 +
//сдвигаем текущую фигуру на шаг вперёд
 +
++figures[k%W][i];
 +
}
 +
else // если ставим не последнюю фигуру
 +
{
 +
// помечаем текущую клетку номером i
 +
set(figures[k%W][i], t, i);
 +
//ставим следующую фигуру на клетку после текущей
 +
figures[k%W][i+1] = figures[k%W][i].next();
 +
// переходим к следующей фигуре
 +
i++;
 +
}
 +
}
  
    return true; ///если в ходе проверки коней и угроз не обнаружилось, в данную клетку можно поставить фигуру
+
//освобождение памяти
}
+
for (int j = 0; j < W; j++)
 
+
delete[] figures[j];
void setHorse(int count, int a, int b) ///функция расстановки коней; a - очередная строка, b - очередной столбец, count - счетчик количества фигур, которое необходимо расставить
+
delete[] figures;
{
+
if (desk)
    if(count==N) /// если нужное количество фигур поставлено, то
+
{
    {
+
for (int j = 0; j < M; j++)
        showBoard("H"); /// вызов функции вывода шахматной доски на экран
+
delete[] desk[j];
    }
+
delete[] desk;
 +
}
 +
if (colons)
 +
{
 +
delete[] colons;
 +
delete[] rows;
 +
}
 +
if (diag_1)
 +
{
 +
delete[] diag_1;
 +
delete[] diag_2;
 +
}
 +
}
  
    if (a == M) ///условие необходимо; прогоняет алгоритм по всем строкам
 
        return;
 
  
    for (int j=b; j<M; ++j) ///установка коней в первой строке
+
int main()
    {
+
{
        if(tryHorse(a, j)) ///проверка данной клетки на возможность установки фигуры
+
system("color 70"); // Установка серого фона и чёрного текста
        {
+
while (true)
            Board[a][j]=1; ///установка коня в первую клетку, присваивание ей значения 1 (true)
+
{
            int line = a, b = j+1; ///смещение в строке на одну позицию вправо, переобозначение строки на line
+
cout << "Choose the mode:\n1 - all possible variants of figures' placement\n2 - maximum number of figures which can be placed on the desk\nq - quit\n\n";
 
+
char c;
            if (b == M) ///если данный столбец - самый крайний
+
cin >> c;
            {
+
cin.ignore(100, '\n');
                b = 0; ///обнуление переменной, чтобы использовать ее при заполнении следующей строки
+
switch (c)
                line++;     ///то переход на следующую строку и дальнейшее ее заполнение
+
{
            }
+
case '1':
            setHorse(count+1,line,b); ///установка фигуры, увеличение счетчика
+
case '2':
            Board[a][j]=0; ///обнуление переменной для установки следующей фигуры в следующую клетку
+
cout << "Enter the desk size please. (The number must be even and not more than 37.)\n";
        }
+
cin >> M;
    }
+
while (!cin || M % 2 != 0 || M > 37 || M <= 0)
 
+
{
    for(int i=a+1; i<M; ++i) ///дальнейшее заполнение оставшихся строк
+
cout << "Error: wrong desk size. Try again please.\n";
    {
+
cin.clear();
        for (int j=0; j<M; ++j)
+
cin.ignore(100, '\n');
        {
+
cin >> M;
            if(tryHorse(i, j)) ///проверка данной клетки на возможность установки фигуры
+
}
            {
+
cin.ignore(100, '\n');
                Board[i][j]=1; ///установка коня в первую клетку, присваивание ей значения 1 (true)
+
cout << "Choose a figure, please.\n p - peshka, k - kon, l - ladya, s - slon, Q - Queen, K - King\n";
                int line = i, b = j+1; ///смещение в строке на одну позицию вправо
+
char f;
 
+
cin >> f;
                if (b == M) ///если данный столбец - самый крайний
+
cin.ignore(100, '\n');
                {
+
type t;
                    b = 0;
+
int i;
                    line++; ///то переход на следующую строку и дальнейшее ее заполнение
+
do
                }
+
{
                setHorse(count+1,line,b); ///установка фигуры, увеличение счетчика
+
for (i = 0; i < 6; i++)
                Board[i][j]=0; ///обнуление переменной для установки следующей фигуры в следующую клетку
+
{
            }
+
if (symbols[i] == f)
        }
+
{
    }
+
t = type(i);
}
+
break;
 
+
}
///для короля
+
}
 
+
if (i == 6)
bool tryKing(int a, int b) /// проверка на возможность поставить фигуру в квадрате 3х3, a- очередная строка, b- очередной столбец
+
{
{
+
cout << "Enter the right letter, you've chosen the wrong one.\n";
///проверка на наличие фигур и угроз во всех 8 точках, которые могут быть под ударом в квадрате 3х3 вокруг установленной фигуры
+
cin >> f;
 
+
cin.ignore(100, '\n');
    for(int i = a-1; i <= a+1; ++i) ///проверка по строкам
+
}
    {
+
} while (i == 6);
        for(int j = b-1; j <= b+1; ++j) ///проверка по столбцам
+
if (c == '1')
        {
+
{
            if (a>=0 && a < M && b>=0 && b < M && Board[a][b]) ///условие наличия клетки в пределах доски
+
cout << "Enter the number of figures please.\n";
                return false;
+
int N;
 
+
cin >> N;
            if ((a+1) < M && (b-1) >=0 && Board[a+1][b-1])
+
while (!cin || N <= 0)
                return false;
+
{
 
+
cout << "Error: wrong argument. Try again please.\n";
            if ((a+1) < M && Board[a+1][b])
+
cin.clear();
                return false;
+
cin.ignore(100, '\n');
 
+
cin >> N;
            if ((a+1) < M && (b+1) < M && Board[a+1][b+1])
+
}
                return false;
+
cin.ignore(100, '\n');
 +
all_placements(N, t);
 +
}
 +
else
 +
{
 +
cout << "The maximal number of figures is ";
 +
switch (t)
 +
{
 +
case peshka:
 +
cout << M*M/2; break;
 +
case king:
 +
cout << M*M/4; break;
 +
case kon:
 +
cout << (M == 2 ? 4 : M*M/2); break;
 +
case ladya:
 +
cout << M; break;
 +
case slon:
 +
cout << 2*M - 2; break;
 +
case queen:
 +
cout << (M == 2 ? 1 : M);
 +
}
 +
cout << ".\n";
 +
}
 +
break;
 +
case 'q':
 +
cout << endl;
 +
return 0;
 +
default:
 +
cout << "You've chosen the wrong command, try again please.\n";
 +
}
 +
cout << endl << endl;
 +
}
 +
}
 +
</syntaxhighlight>
 +
</div>
  
            if ((b+1) < M && Board[a][b+1])
+
'''[[Лосева Татьяна]]'''
                return false;
 
  
            if ((a-1)>=0 && (b+1) < M && Board[a-1][b+1])
+
'''Краткое описание алгоритма :'''
                return false;
+
Доска представлена в виде динамического массива;Для каждой фигуры написана отдельная функция проверки на возможность установки фигуры,проверяющая, находится ли эта фигура под ударом других.
 +
После выбора типа фигуры,используется  рекурсивная функция,которая проверяет возможные  расстановки через данную функцию проверки ,для данного типа фигуры.
 +
Для поиска максимального значения мы проверяем расстановку начиная с 0 количество фигур ,каждый раз увеличивая на 1,если количество расстановок станет равно нулю,то предыдущее количество фигур было максимальным.
  
            if ((a-1) >=0 && Board[a-1][b])
+
'''Инструкция''' : Пользователя попросят ввести размер доски,затем выбрать один из вариантов работы программы:1.поиск возможных расстановок для M фигур или 2.поиск максимального количества расстановок для данного поля,затем попросят выбрать тип фигуры и в первом случае количество фигур.При выводе на экран выводится номер расстановки и доска,на доске F- обозначены занятые клетки,0-пуская клетка.
                return false;
+
Для 2 пункта выводится лишь число: максимальное количество фигур,которое можно расставить.
 +
 
 +
Скачать можно : [http://tm.spbstu.ru/Файл:Шахматы_Лосева.rar тут]
  
            if ((a-1) >=0 && (b-1)>=0 && Board[a-1][b-1])
 
                return false;
 
  
            if ((b-1) >= 0 && Board[a][b-1])
+
<div class="mw-collapsible mw-collapsed" style="width:100%" >
                return false;
+
<syntaxhighlight lang="cpp" line start="1" enclose="div">
        }
+
#include<iostream>
    }
+
using namespace std;
 +
int N;//размер доски NxN
 +
int **a;
 +
int *ax;
 +
int *by;
 +
int l = 0;//L-номер пункта в меню
 +
int M;//количество фигур
 +
bool isPrint = false;//переменная для вывода на экран,когда требуется,для удобства обозначим в начале false
  
    return true; ///если в ходе проверки королей и угроз не обнаружилось, в данную клетку можно поставить фигуру
 
}
 
  
void setKing (int count, int a, int b) ///функция расстановки коней; a - очередная строка, b - очередной столбец, count -  счетчик количества фигур, которое необходимо расставить
+
void print()//функция вывода на экран
 
{
 
{
    for (int j=b; j<M; ++j) ///установка королей в первой строке
+
for (int i = N - 1; i >= 0; --i)
    {
+
{
        if(tryKing(a, j)) ///проверка данной клетки на возможность установки фигуры
+
for (int j = 0; j < N; ++j)
        {
+
{
            Board[a][j]=1; ///проверка данной клетки на возможность установки фигуры
+
cout << ((a[j][i]) ? "F " : "0 ");//если (a[j][i]) истина,то есть клетка занята,ставим F,в другом случае,т.е.свободна,ставим 0
            setKing(count+1,a,j); ///расстановка фигур в первой строке
+
}
            Board[a][j]=0; ///обнуление переменной для установки следующей фигуры в следующую клетку
+
cout << '\n';
        }
+
}
    }
+
cout << '\n';
  
    for(int i=a+1; i<M; ++i) ///установка фигур в оставшуюся часть шахматной доски по строкам
+
}
    {
+
bool Lad(int x, int y)//Ладья
        for (int j=0; j<M; ++j)
+
{
        {
+
for (int i = 0; i < N; ++i)
            if(tryKing(i, j)) ///проверка данной клетки на возможность установки фигуры
+
{
            {
+
if (a[i][y] == 1 )//проверяем горизонталь:если клетка занята
                Board[i][j]=1; ///проверка данной клетки на возможность установки фигуры
+
{
                setKing(count+1,i,j); ///расстановка фигур
+
return false;//возвращаем false
                Board[i][j]=0; ///обнуление переменной для установки следующей фигуры в следующую клетку
+
}
            }
+
if (a[x][i] == 1)//проверяем вертикаль : если хотя бы одна клетка занята,то
        }
+
{
    }
+
return false;//возврашаем false
 +
}
 +
}
 +
return true;//ничего выше не выполняется,значит возвращаем правду:вертикаль и горизонталь свободна
  
    if(count==N) /// если нужное количество фигур поставлено, то
 
    {
 
        showBoard("K");/// вызов функции вывода шахматной доски на экран
 
        return;
 
    }
 
 
}
 
}
  
int main()
+
bool Kon(int x, int y)//Коняша
 
{
 
{
    char s; ///переменная, будет использована в цикле
+
int i[8] = {-2, -2, -1, -1, 1, 1, 2, 2};//координаты клеток,на которые может ходить конь,относительно текущей (8 вариантов)
    do      /// цикл, выводящий на экран данные в зависимости от введенных пользователем значений переменных
+
int j[8] = {-1, 1, -2, 2, -2, 2, -1, 1};
    {
+
        do ///цикл для считывания введенного пользователем размера доски
+
for (int k = 0; k < 8; k++)//8 вариантов хода
        {
+
            cout << "Input the size of the board: " << endl; ///ввод размера доски
+
{
            cin >> M;
+
if (x + i[k] >= 0 && x + i[k] < N && y + j[k] >= 0 && y + j[k] < N)//проверка выхода за границы массива
 +
{
 +
if (a[x + i[k]][y + j[k]] != 0)//клетка занята
 +
{
 +
return false;//возвращем false
 +
}
 +
}
 +
}
 +
return true;////ничего выше не выполняется,значит возвращаем правду:все варианты ходов  свободны и конь никого не перебивает,тогда можно занять клетку
 +
 
 +
}
  
            if ( (M%2) == 1) ///цикл, работающий только в том случае, если пользователь введет нечетное число
 
            {
 
                cout << '\n' << "The number must be even, so try to input the size again" << '\n' << endl;
 
            }
 
  
        }
 
        while (M%2 !=0); ///пока пользователь не введет допуcтимое число, цикл не прерывается
 
  
        Board = new int*[M];  ///создание двумерного массива для отображения шахматной доски
 
        for (int i = 0; i<M; i++)
 
            Board[i] = new int[M]; ///создание первую строку доски
 
        for (int i = 0; i<M; i++)
 
            for (int j = 0; j<M; j++)
 
                Board[i][j] = 0;  ///зануление массива
 
  
        int V; ///пользователь выбирает один из двух вариантов работы программы
+
bool Korol(int x, int y)//Король
        cout << '\n' << "Input your choice: 1=placing of figures, 2=for max amount of figures" << endl;
+
{
        cin >> V;
 
  
        if (V==1) ///цикл, расставляющий фигуры по введенным пользователем данным
+
int i[8] = { -1, -1, -1, 0, 0, 1, 1, 1 };//координаты клеток,на которые может ходить король,относительно текущей
        {
+
    int j[8] = { -1, 0, 1, -1, 1, -1, 0, 1 };
            char k; ///переменная, будет использована в цикле
 
            do      /// цикл, выводящий на экран данные в зависимости от введенных пользователем значений переменных
 
            {
 
                int T; ///пользователь выбирает фигуру
 
                cout << '\n' << "Input type of figure: 1-queen, 2-king, 3-horse, 4-rook, 5-elephant"<< endl;
 
                cin >> T;
 
  
                int maximum; ///переменная, хранящая максимальное количество фигур, которое можно расставить на заданной доске
+
for(int k = 0; k < 8; k++)//8 вариантов хода
                if (T==1) ///максимальное количество фигур на заданной доске для ферзя
+
{
                {
+
if (x + i[k] >= 0 && x + i[k] < N && y + j[k] >= 0 && y + j[k] < N)//прроверяем не выходит ли фигура за границы массива
                    maximum=M;
+
{
                    cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
+
if (a[x + i[k]][y + j[k]] != 0)//если какой нибудь из вариантов хода занят
                }
+
{
                if (T==2) ///максимальное количество фигур на заданной доске для короля
+
return false;//то false
                {
+
}
                    maximum=0.25*M*M;
+
}
                    cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
+
}
                }
+
return true;//свободно,можно занимать
                if (T==3) ///максимальное количество фигур на заданной доске для коня
+
}
                {
 
                    maximum=0.5*M*M;
 
                    cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
 
                }
 
                if (T==4) ///максимальное количество фигур на заданной доске для ладьи
 
                {
 
                    maximum=M;
 
                    cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
 
                }
 
                if (T==5) ///максимальное количество фигур на заданной доске для слона
 
                {
 
                    maximum=2*M-2;
 
                    cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
 
                }
 
  
                do ///цикл, считывающий количество фигур, заданное пользователем
+
bool Slon(int x, int y)
                {
+
{
                    cout << "Input the amount of figures, it must be less than max amount or equals that" << endl;
+
int p1 = y - x;//номер диагонали слева направо
                    cin >> N;
+
int p2 = y + x;//номер диагонали с права налево
                }
+
for (int i = 0; i < N; i++)//проверяем левую диагональ
                while (N>maximum);   ///пока пользователь не введет допуcтимое число, цикл не прерывается
+
{
 +
if (i + p1 >= 0 && i + p1 < N)//проверка на выход за границы массива
 +
{
 +
if (a[i][i + p1] == 1) //проверяем диагональ
 +
{
 +
return false;//диагональ занята
 +
}
 +
}
 +
if (-i + p2 >= 0 && -i + p2 < N)//вторая диагональ
 +
{
 +
if (a[i][-i + p2] == 1)
 +
{
 +
return false;//вторая диагональ занята
 +
}
 +
}
 +
}
 +
return true;//обе диагонали свободны,ура!
 +
}
  
                cout << '\n' << "All possible variants for this amount of figures on this board:" << '\n' << endl;
+
bool Check(int x, int y)//Ферзь=Ладья+Слон
 
+
{
                if (T==1) ///цикл, вызывающий на экран все варианты расстановки заданного пользователем числа фигур для ферзя
+
int p1 = y - x;//диагональ 1
                {
+
int p2 = y + x;//диагональ 2
                    result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
+
for (int i = 0; i < N; ++i)
                    for (int i=0; i <M; ++i)
+
{
                        setQueen(i,0);
+
if (a[i][y] == 1 )//проверяем горизонталь
                }
+
{
                if (T==2) ///цикл, вызывающий на экран все варианты расстановки заданного пользователем числа фигур для короля
+
return false;//занято
                {
+
}
                    result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
+
if (a[x][i] == 1)//проверяем вертикаль
                    setKing(0,0,0);
+
{
                }
+
return false;//занято
                if (T==3) ///цикл, вызывающий на экран все варианты расстановки заданного пользователем числа фигур для коня
+
}
                {
+
                    result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
+
if (i + p1 >= 0 && i + p1 < N)//выход за границы массива
                    setHorse(0,0,0);
+
{
                }
+
if (a[i][i + p1] == 1) //проверяем 1 диагональ
                if (T==4) ///цикл, вызывающий на экран все варианты расстановки заданного пользователем числа фигур для ладьи
+
{
                {
+
return false;//занято
                    result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
+
}
                    for (int i=0; i <M; ++i)
+
}
                        setRook(i,0);
+
if (-i + p2 >= 0 && -i + p2 < N)//выход за границы массива
                }
+
{
                if (T==5) ///цикл, вызывающий на экран все варианты расстановки заданного пользователем числа фигур для слона
+
if (a[i][-i + p2] == 1)//проверяем 2ую диагональ
                {
+
{
                    result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
+
return false;//занято
                    for(int i = 0; i<2*M-1; ++i)
+
}
                        setEl(i,0);
+
}
                }
+
}
 +
return true;//свободно!
 +
}
  
                cout << '\n' << "If you want continue placing figures, input +, if not, input -" << endl;
+
int  menu1()
                cin >> k;
+
{
            }
+
cout << "Type of figure:" << endl << "1 - Ferz" << endl << "2 - Ladya" << endl << "3 - Slon" << endl << "4 - Kon" << endl << "5 - Korol" << endl;
            while (k != '-'); ///цикл работает до тех пор, пока пользователь не даст команду на его завершение
+
cin >> l;
        }
+
return l;
 +
}
  
        else if (V==2) ///цикл, вычисляющий максимальное количество фигур по введенным пользователем данным
+
int num = 0;//номер расстановки
        {
+
//пробует найти результаты решений.
            char z; ///переменная, будет использована в цикле
 
            do      /// цикл, выводящий на экран данные в зависимости от введенных пользователем значений переменных
 
            {
 
                int T; ///переменная для выбора фигуры пользователем
 
                cout << '\n' << "Input type of figure: 1-queen, 2-king, 3-horse, 4-rook, 5-elephant"<< endl;
 
                cin >> T;
 
                char d;  ///переменная, будет использована в циклах
 
                int maximum; ///переменная, хранящая максимальное количество фигур, которое можно расставить на заданной доске
 
                if (T==1) ///максимальное количество фигур на заданной доске для ферзя
 
                {
 
                    maximum=M; ///формула расчёта максимального количества фигур для заданной доски
 
                    cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
 
                    cout << "If you want to see all locations of max amount, input +, if not, input -" << endl;
 
                    cin >> d;
 
                    cout << '\n' << "All possible variants for this amount of figures on this board:" << '\n' << endl;
 
                    if (d=='+') ///по выбору пользователя вывод всех возможных расстановок для максимального количества для данной фигуры
 
                    {
 
                        result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
 
                        N=maximum; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
 
                        for (int i=0; i < M; ++i)
 
                            setQueen(i,0);
 
                    }
 
  
                }
+
void Func(int d,int K) //d-глубина рекурсии;K-сколько фигур нужно расставить
                if (T==2) ///максимальное количество фигур на заданной доске для короля
+
{
                {
+
if (d == K)//когда расставили нужное количество
                    maximum=0.25*M*M; ///формула расчёта максимального количества фигур для заданной доски
+
{
                    cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
+
if (isPrint)//если true,то печатаем(в случае с MAX количеством доску печатать не нужно)
                    cout << "If you want to see all locations of max amount, input +, if not, input -" << endl;
+
{
                    cin >> d;
+
cout << "Result: " << num + 1 << '\n';//выводим нормер расстановки
                    cout << '\n' << "All possible variants for this amount of figures on this board:" << '\n' << endl;
+
print();//печатаем доску
                    if (d=='+') ///по выбору пользователя вывод всех возможных расстановок для максимального количества для данной фигуры
+
}
                    {
+
num++;//номер расстановки увеличивается
                        result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
+
return;
                        N=maximum; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
+
}
                        setKing(0,0,0);
+
 
                    }
+
int minX = d != 0 ? ax[d - 1] : 0;//исходя из того куда быда поставлена предыдущая фигура
                }
+
//,накладываются ограничения для выбора места новой,чтобы избежать поторений
                if (T==3) ///максимальное количество фигур на заданной доске для коня
+
int minY = d != 0 ? by[d - 1] + 1 : 0;
                {
+
 
                    maximum=0.5*M*M; ///формула расчёта максимального количества фигур для заданной доски
+
 
                    cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
+
bool isPossible = false;//Проверяет,возможно ли занять клетку
                    cout << "If you want to see all locations of max amount, input +, if not, input -" << endl;
+
for (int i = minX; i < N; ++i)
                    cin >> d;
+
{
                    cout << '\n' << "All possible variants for this amount of figures on this board:" << '\n' << endl;
+
 
                    if (d=='+') ///по выбору пользователя вывод всех возможных расстановок для максимального количества для данной фигуры
+
for (int j = (i != minX) ? 0 : minY; j < N; ++j)
                    {
+
{
                        result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
+
switch (l)//l- номер пункта в меню с фигурами
                        N=maximum; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
+
{
                        setHorse(0,0,0);
+
case 1://ферзь
                    }
+
isPossible = Check(i, j);
                }
+
break;
                if (T==4) ///максимальное количество фигур на заданной доске для ладьи
+
case 2://Ладья
                {
+
isPossible = Lad(i, j);
                    maximum=M; ///формула расчёта максимального количества фигур для заданной доски
+
break;
                    cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
+
case 3://Слон
                    cout << "If you want to see all locations of max amount, input +, if not, input -" << endl;
+
                    cin >> d;
+
isPossible = Slon(i, j);
                    cout << '\n' << "All possible variants for this amount of figures on this board:" << '\n' << endl;
+
break;
                    if (d=='+') ///по выбору пользователя вывод всех возможных расстановок для максимального количества для данной фигуры
+
case 4://Конь
                    {
+
isPossible = Kon(i, j);
                        result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
+
break;
                        N=maximum; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
+
case 5://Король
                        for (int i=0; i <M; ++i)
+
isPossible = Korol(i, j);
                            setRook(i,0);
+
break;
                    }
+
}
                }
+
if (isPossible)//если клетку занять возмоно(функция вернула true)
                if (T==5) ///максимальное количество фигур на заданной доске для слона
+
{
                {
+
  a[i][j] = 1;//занимаем клетку
                    maximum=2*M-2; ///формула расчёта максимального количества фигур для заданной доски
+
ax[d] = i;//запоминаем куда была поставлена фигура
                    cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
+
by[d] = j;//запоминаем куда была поставлена фигура
                    cout << "If you want to see all locations of max amount, input +, if not, input -" << endl;
+
Func(d + 1, K);//вызываем рекурсивно
                    cin >> d;
+
a[i][j] = 0;
                    cout << '\n' << "All possible variants for this amount of figures on this board:" << '\n' << endl;
+
}
                    if (d=='+') ///по выбору пользователя вывод всех возможных расстановок для максимального количества для данной фигуры
+
}
                    {
+
}
                        result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
+
 
                        N=maximum; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
+
return;
                        for(int i = 0; i<2*M-1; ++i)
+
}
                            setEl(i,0);
 
                    }
 
                }
 
  
                cout << '\n' << "If you want continue counting, input +, if not, input -" << '\n' << endl;
+
int main()
                cin >> z;
+
{
            }
 
            while (z != '-'); ///цикл работает до тех пор, пока пользователь не даст команду на его завершение
 
        }
 
        cout << '\n' << "If you want to change the size of board, input +, if not, input -" << endl;
 
        cin >> s;
 
        if (s=='-')
 
        {
 
            cout << '\n' << "The program is finished." << '\n' << endl; ///вывод на экран сообщения о завершении работы программы
 
        }
 
    }
 
    while (s != '-'); ///цикл работает до тех пор, пока пользователь не даст команду на его завершение, а также на завершение всей программы
 
}
 
  
</syntaxhighlight>
+
cout << "Enter size: ";//нужно ввести размер доски
</div>
+
cin >> N;//считываем размер доски
  
 +
a = new int*[N];//создаём двумерный массив,т.е.нашу доску
 +
for (int i = 0; i < N; i++)
 +
{
 +
a[i] = new int[N];
 +
for (int j = 0; j < N; j++)
 +
a[i][j] = 0;//заполняем нулями
 +
}
 +
 +
ax = new int[N];//массивы для сохранения координаты каждой фигуры,чтобы избежать повторений
 +
by = new int[N];
  
 +
int d;//пункт в меню
 +
cout<<"1 - Rasstanovka figur"<<endl<<"2 - MAX znachenie"<<endl;//два варианта работы программы
 +
cin>>d;//считываем выбор пользователя
 +
if(d==1)//если выбирает расстановку
 +
 +
menu1();//то спрашиваем для какой фигуры
 +
cout<<"How many figures?"<<endl;//и как много будет фигур
 +
    cin>>M;//считываем количество фигур
 +
isPrint = true;//в этом случае будем выводить на экран
 +
Func(0,M);//запуск рекурсивной функции
 +
}
  
 +
if (d == 2)//случай подсчёта максимального значения
 +
{
 +
int n = 0;//изачально max=0
 +
menu1();//выбираем фигуру
 +
 +
do//начало цикла
 +
{
 +
num = 0;
 +
Func(0, ++n);//запускаем каждый раз увеличивая значение фигур и считаем количество расстановок
 +
} while (num != 0);//количество вариантов не должно быть равно нулю
 +
cout <<"MAX ="<< n - 1 << endl;//если количество вариантов = 0,то выходим из цикла и предыдущее значение  максимальное
 +
}
 +
 +
 +
int z;
 +
cin >> z;
  
 +
return 0;
 +
}
 +
</syntaxhighlight>
 +
</div>
  
 +
'''[[Сергей Ляжков]]'''
 +
Инструкция:
 +
Вводите необходимые данные(кол-во строк, столбцов, фигуры, тип расстановки) согласно последовательности выполнения программы
 +
Краткое описание алгоритма:
 +
1)Выделяет память под доску(динамическая матрица)
 +
2)Устанавливает каждую следующую фигуру на n-е свободное место которое он нашел после последней установленной фигуры, где n изменяется от 1 до бесконечности(установка заканчивается тогда, когда программа не может установить очередную фигуру).
 +
3)Счетчик количества фигур, которые необходимо установить, уменьшается на 1 после каждой установки.
 +
4)После того, как фигура установлена, программа рекурсивно вызывает функцию установки очередной фигуры(возвращается в пункт 2)
 +
5)В рекурсивную функцию отправляется только копия доски. Таким образом, возвращаясь из рекурсии, мы получаем доску без последующих установленных фигур. Когда счетчик фигур, которые необходимо установить, уменьшается до нуля, данное поле сохраняется в списке.
 +
6)Вывод списка.
 +
Скачать можно [http://tm.spbstu.ru/File:Шахматы.zip тут]
  
'''[[Александр Сюрис]]'''
+
<br>'''[[Нарядчиков Александр]]'''<br>
 
+
'''Инструкция:''' Запустить программу, следовать указаниям, полученным в меню программы.<br>
Программа работает в двух режимах: поиск максимального числа фигур для заданного поля и количество возможных расстановок заданного числа фигур для заданного поля.
+
'''Описание программы:''' Шахматное поле представлено в виде двумерного массив N на M, значения N и M пользователь вводит самостоятельно, память выделяется динамически. Также пользователь выбирает тип и количество фигур на поле. В меню можно выбрать между поиском максимально возможного числа фигур на столе и поиском всех расстановок с дальнейшей записью полей в файл.<br>
 
+
'''Описание алгоритма:''' При поиске всех расстановок происходит установка выбранной фигуры в свободную клетку, далее происходит маркирование тех клеток, в которые уже невозможно поставить фигуру данного типа, затем процесс происходит снова(рекурсия) пока на поле не окажется выбранное пользователем число фигур. Под конец данное поле записывается в файл и происходит поиск других возможных расстановок данного типа. В конце получаем файл со всеми вариантами расстановок и их количеством. При поиске наибольшего числа фигур на доске программа ищет расстановку для одной фигуры, затем для двух, если это возможно и т.д. С каждым разом происходит увеличение счетчика количества фигур на поле, тем самым в конце данного алгоритма мы получаем максимально возможное число данного типа фигур на доске данного размера.<br>
'''Алгоритм:'''
 
 
 
#Для поиска количества возможных расстановок заданного числа фигур для заданного поля – Проверяется, возможно ли поставить фигуру в данную клетку, рекурсивно перебирает для каждой клетки поля, как начальной клетки, все варианты расстановки заданного количества  фигур относительно нее и выводит на экран все расстановки, которые подходят условиям.
 
#Для поиска максимального числа фигур для заданного поля –  Проверяется, можно ли поставить одну фигуру, две, три и так далее, пока фигур больше поставить будет нельзя.
 
 
 
Скачать можно  [http://mech.spbstu.ru/File:%D0%A8%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D1%8B(%D0%90%D0%BB%D0%B5%D0%BA%D1%81%D0%B0%D0%BD%D0%B4%D1%80%D0%A1%D1%8E%D1%80%D0%B8%D1%81).zip  тут].
 
 
<div class="mw-collapsible mw-collapsed" style="width:100%" >
 
<div class="mw-collapsible mw-collapsed" style="width:100%" >
 +
"'''T04CHESS.CPP'''"
 
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 
<syntaxhighlight lang="cpp" line start="1" enclose="div">
#include <vector>
+
/* FILENAME: T04CHESS.CPP
#include <iostream>
+
* LAST UPDATE: 17.01.2016
#include <algorithm>
+
*/
  
 +
#include "CHESS.h"
  
using namespace std;
+
/* Main function */
 +
int main( void )
 +
{
 +
// Переменная, отвечающая за выход из меню
 +
int IsReady = 1;
 +
// Количество строк поля; количество столбцов поля
 +
int N, M;
 +
// Если идет поиск всех расстановок - 0; если идет поиск максимального числа фигур на доске - 1
 +
int IsCount;
 +
// Количество фигур на поле
 +
int Number;
 +
// Тип фигуры; количество разных расстановок; максимальное число фигур на доске
 +
int tmp, count, max_value = 1;
 +
// Создание указателя на тип FILE
 +
FILE *F;
  
int n,k, o, m, l, g, maxi, a, sum=0,y, mozno=1;//mozno=1 если можно поставить n фигур
+
// Консольное меню
vector<vector<int> > matrix;// двухмерный вектор
+
while (IsReady == 1)
 +
{
 +
cout << "Input figure type:\n1 - castle\n2 - bishop\n3 - knight\n4 - queen\n5 - king\n";
 +
cin >> tmp;
 +
 
 +
cout << "Input number of rows on the field:\n";
 +
cin >> N;
  
bool ladia(int x, int y) {      //проверка, можно ли в эту клетку поставить ладью
+
cout << "Input number of columns on the field:\n";
    for(int i = 0; i<n; i++)
+
cin >> M;
        if(matrix[x][i] == 1)
 
            return false;
 
    for(int j=0; j<n; j++)
 
        if(matrix[j][y]==1)
 
            return false;
 
    return true;
 
}
 
  
bool slon(int x, int y) {  //    --//-- слона
+
// Поле шахмат
 +
chess desk(N, M);
  
  for (int i=x, j=y;i<n && j>=0; i++, j--)
+
// Обнуление поля
      if(matrix[i][j] == 1)
+
desk.Clear();
            return false;
 
  for (int i=x, j=y;i>=0 && j>=0; i--, j--)
 
      if(matrix[i][j] == 1)
 
            return false;
 
  for (int i=x, j=y;i>=0 && j<n; i--, j++)
 
      if(matrix[i][j] == 1)
 
            return false;
 
  for (int i=x, j=y;i<n && j<n; i++, j++)
 
      if(matrix[i][j] == 1)
 
            return false;
 
  
    return true;
+
cout << "Input in what mode do you want to work:\n0 - Searching for all fields variants\n1 - Searching for the maximum number of chessmen\n";
 +
cin >> IsCount;
  
}
+
// Если идет поиск всех расстановок
 +
if (IsCount == 0)
 +
{
 +
cout << "Input number of chessmen on the field:\n";
 +
cin >> Number;
  
bool fruz(int x, int y){      //    --//-- ферзя
+
// Создание файла и его открытие
    if(slon(x,y) && ladia(x,y))
+
fopen_s(&F, "chess.txt", "wt");
        return true;
+
if ((type)(tmp + 1) == 2)
 +
fputs("Castles' fields:\n", F);
 +
else if ((type)(tmp + 1) == 3)
 +
fputs("Bishops' fields:\n", F);
 +
else if ((type)(tmp + 1) == 4)
 +
fputs("Knights' fields:\n", F);
 +
else if ((type)(tmp + 1) == 5)
 +
fputs("Quenns' fields:\n", F);
 +
else if ((type)(tmp + 1) == 6)
 +
fputs("Kings' fields:\n", F);
 +
else
 +
{
 +
fputs("Error\n", F);
 +
return 0;
 +
}
 +
// Закрытие файла
 +
fclose(F);
  
    return false;
+
// Количество разных расстановок
 +
count = desk.FillField(IsCount, (type)(tmp + 1), 0, 0, Number, 0);
  
 +
// Открытие файла в режиме повторной записи
 +
fopen_s(&F, "chess.txt", "at");
 +
fprintf(F, "\nNumber of fields: %i", count);
 +
// Закрытие файла
 +
fclose(F);
 +
 +
cout << "Done!\nCheck 'chess.txt' to see results\n";
 +
}
  
}
+
// Если идет поиск максимального числа фигур на доске
 
+
else if (IsCount == 1)
bool kon(int x, int y) {  // --//-- коня
+
{
 +
while (desk.FillField(IsCount, (type)(tmp + 1), 0, 0, max_value, 0))
 +
max_value++;
 +
cout << "The maximum number of chessmen on the board is " << (max_value - 1) << endl;
 +
max_value = 1;
 +
}
  
  if (x-1>=0 && y-2>=0 && matrix[x-1][y-2]==1)
+
// Если было введено некорректное значение для IsCount
        return false;
+
else
  if (y-2>=0 && x+1<n && matrix[x+1][y-2]==1)
+
cout << "Error\n";
        return false;
 
  if (x-2>=0 && y-1>=0 && matrix[x-2][y-1]==1)
 
        return false;
 
  if (x+2<n && y-1>=0 && matrix[x+2][y-1]==1)
 
        return false;
 
  if (x-2>=0 && y+1<n && matrix[x-2][y+1]==1)
 
        return false;
 
  if (x+2<n && y+1<n && matrix[x+2][y+1]==1)
 
        return false;
 
  if (x-1>=0 && y+2<n && matrix[x-1][y+2]==1)
 
        return false;
 
  if (x+1<n && y+2<n && matrix[x+1][y+2]==1)
 
        return false;
 
return true;
 
}
 
  
bool king(int x, int y) {  // --//--  короля
+
// Продолжение работы с программой
 +
cout << "Press '1' if you want to continue\nPress another number if you want to exit\n";
 +
cin >> IsReady;
  
    if (x-1>=0 && y-1>=0 && matrix[x-1][y-1]==1)
+
if (IsReady == 1)
        return false;
+
continue;
    if (x-1>=0 && matrix[x-1][y]==1)
+
else
        return false;
+
exit(0);
    if (y+1<n && x-1>=0 && matrix[x-1][y+1]==1)
+
}
        return false;
 
    if (y+1<n && matrix[x][y+1]==1)
 
        return false;
 
    if (y+1<n && x+1>n && matrix[x+1][y+1]==1)
 
        return false;
 
    if (x+1<n && matrix[x+1][y]==1)
 
        return false;
 
    if (x+1<n && y-1>=0 && matrix[x+1][y-1]==1)
 
        return false;
 
    if (y-1>=0 && matrix[x][y-1]==1)
 
        return false;
 
    return true;
 
  
}
+
return 0;
 +
} // End of 'main' function
  
int mass() { // вывод доски на экран
+
// END OF 'T04CHESS.CPP' FILE
 +
</syntaxhighlight>
 +
"'''CHESS.CPP'''"
 +
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 +
/* FILENAME: CHESS.CPP
 +
  * LAST UPDATE: 17.01.2016
 +
*/
  
for(int i = 0; i<n; i++)
+
#include "CHESS.H"
  {
 
  
    for(int j = 0; j<n; j++)
+
// Количество расстановок
        cout<<matrix[i][j]<<" ";
+
int Result_count = 0;
  
        cout<<endl;
+
/* Clear field function */
    }
+
// Обнуление поля
 
+
void chess::Clear( void )
}
+
{
 
+
// Все клетки свободны
int del() // очистка доски(все нули)
+
for (int i = 0; i < N; i++)
 +
for (int j = 0; j < M; j++)
 +
Field[i][j] = Free;
 +
} // End of 'Clear' function
  
for (int i=0; i<n; i++) {
+
/* Check if the cell is available that function */
 +
// Проверка, свободна и существует ли данная клетка
 +
int chess::IsAvailable( int x, int y )
 +
{
 +
if (x >= 0 && y >= 0 && x < M && y < N)
 +
if (Field[y][x] == Free)
 +
  return 1;
 +
 +
return 0;
 +
} // End of 'IsAvailable' function
  
    for (int j=0; j<n; j++)
+
/* Output field in file function */
        matrix[i][j]=0;
+
// Запись одного поля в файл
}
+
void chess::OutputInFile( void )
 +
{
 +
// Создание указателя на тип FILE
 +
FILE *F;
  
}
+
// Открытие файла в режиме повторной записи
 +
fopen_s(&F, "chess.txt", "at");
  
 +
// Переход на следующую строку файла
 +
fputc('\n', F);
  
 +
// Заполнение файла текущем полем
 +
for (int i = 0; i < N; ++i)
 +
{
 +
// '*' - свободная клетка; '#' - клетка, которая уже занята
 +
for (int j = 0; j < M; ++j)
 +
(Field[i][j] == Free || Field[i][j] == busy) ? fputc('*', F) : fputc('#', F);
 +
// Переход на следующую строку файла
 +
fputc('\n', F);
 +
}
  
void vsevarintyrasstavitnfigur(int x,int y){  // рекурсивный поиск всех вараинтов расстановок заданнного количества фигур (x - номер фигуры в доске, если ее растянуть в линию, y - кол-во фигур)
+
// Закрытие файла
    if(y==0) {
+
fclose(F);
        if (a==1){
+
} /* End of 'OutputInFile' function */
            mass();
 
            cout<<'\n';
 
        }
 
        if(a==2) {
 
                mozno = 1;  //mozno=1 если можно поставить n фигур
 
  
        }
+
/* Copy desks function */
 +
// Копирование поля
 +
void chess::Copy( chess &desk2 )
 +
{
 +
  for (int i = 0; i < N; i++)
 +
for (int j = 0; j < M; j++)
 +
desk2.Field[i][j] = Field[i][j];
 +
} // End of 'Copy' function
  
        return;
+
/* Fill field function */
    }
+
// Заполнение полей и поиск максимального числа расстановок
 +
// Chessmen_num - количество фигур, которое нужно поставить; Already_stood - количество, которое уже стоит
 +
int chess::FillField( int IsCount, type set, int x, int y, int Chessmen_num, int Already_stood )
 +
{
 +
int i, j, k, l;
 +
chess desk2(N, M);
  
    for(int i=x;i<n*n;i++){
+
// Обнуление поля
 +
desk2.Clear();
  
        if (o==1)
+
// Пробег по всем оставшимся клеткам поля, начиная с той, на которой мы закончили предыдущую итерацию
        if(fruz(i/n,i%n) && y>0) {matrix[i/n][i%n]=1; y--;}
+
for (i = y; i < N; i++)
 
+
for (j = ((i == y) ? x : 0); j < M; j++)
        if (o==2)
+
{
        if(ladia(i/n,i%n) && y>0) {matrix[i/n][i%n]=1; y--;}
+
// Если клетка свободна
 
+
if (Field[i][j] == Free)
        if (o==3)
+
{
        if(slon(i/n,i%n) && y>0) {matrix[i/n][i%n]=1; y--;}
+
// Копируем доску
 
+
Copy(desk2);
        if (o==4)
+
        if(kon(i/n,i%n) && y>0) {matrix[i/n][i%n]=1; y--;}
+
// Множественный выбор типа фигуры
 
+
switch (set)
        if (o==5)
+
{
        if(king(i/n,i%n) && y>0) {matrix[i/n][i%n]=1; y--;}
+
// Ладья
 
+
case castle:
 
+
for (k = 0; k < N; k++)
        vsevarintyrasstavitnfigur(i+1, y);
+
{
        matrix[i/n][i%n]=0;//удаление фигуры из прошлой клетки для проверки других вариантов
+
// Движение по столбцу
        y++;
+
if (desk2.Field[k][j] == Free)
 
+
  desk2.Field[k][j] = busy;
    }
+
// Движение по строке
 
+
if (desk2.Field[i][k] == Free)
}
+
  desk2.Field[i][k] = busy;  
 
+
}
void maxfig(){  //поиск максимального количества фигур
+
break;
    int i=0;
+
// Слон
while(mozno==1){ //проверяет для данной доски возможность расставить 1,2... фигуры, пока не доходит до количества, которое расставить невозхможно. Тогда это количество фигур -1 - искомая величина
+
case bishop:
        i++;
+
// Выбор и поиск наибольшей существующей на поле диагонали
        mozno=0;
+
for (k = 1 - (N < M ? N : M); k < (N < M ? N : M); k++)
        vsevarintyrasstavitnfigur(0,i);
+
{
    }
+
// Проход из левого верхнего угла до правого нижнего
    setlocale(LC_ALL, "Russian");
+
if (IsAvailable(j + k, i + k))
    cout<<"Максимальное количество фигур = "<<i-1<<endl;
+
desk2.Field[i + k][j + k] = busy;
}
+
// Проход из левого нижнего до правого верхнего
 
+
if (IsAvailable(j + k, i - k))
 
+
desk2.Field[i - k][j + k] = busy;
int main() {
+
}
setlocale(LC_ALL, "Russian");
+
break;
    g=0;
+
// Конь
    cout<<"Введите размер доски:"<<endl;
+
case knight:
    cin >>n;
+
// Ходы коня, k - приращение по X, l - по Y
        for(int i=0; i<n; i++) {
+
k = -2, l = 1;
            vector<int> z;
+
// Проверка возможности хода в данную клетку
            for(int j=0; j<n; j++){
+
if (IsAvailable(j + k, i + l))
                    z.push_back(0);   //создание вектора z  из n нулей и добавление его к двухмерному вектору
+
desk2.Field[i + l][j + k] = busy;
            }
+
            matrix.push_back(z);
+
k = -2, l = -1;  
        }
+
// Проверка возможности хода в данную клетку
 
+
if (IsAvailable(j + k, i + l))
        cout<<"1 - расстановки фигур на доске n*n"<<endl<<"2 - максимум фигур на доске n*n"<<endl;
+
desk2.Field[i + l][j + k] = busy;
          cin>>a;
+
 
+
k = -1, l = 2;
        while(2>1){
+
// Проверка возможности хода в данную клетку
            cout<<" 1 - ферзь"<<endl;
+
if (IsAvailable(j + k, i + l))
            cout<<" 2 - ладья"<<endl;
+
desk2.Field[i + l][j + k] = busy;
            cout<<" 3 - слон"<<endl;
+
            cout<<" 4 - конь"<<endl;
+
k = -1, l = -2;  
            cout<<" 5 - король"<<endl;
+
// Проверка возможности хода в данную клетку
            cout<<" 6 - выход"<<endl;
+
if (IsAvailable(j + k, i + l))
 
+
desk2.Field[i + l][j + k] = busy;
          cout<<"Введите число от 1 до 6:"<<endl;
+
          cin>>o;
+
k = 1, l = 2;  
            mozno=1;
+
// Проверка возможности хода в данную клетку
            if(o==6) break;
+
if (IsAvailable(j + k, i + l))
 
+
desk2.Field[i + l][j + k] = busy;
 
+
 
+
k = 1, l = -2;
 
+
// Проверка возможности хода в данную клетку
 
+
if (IsAvailable(j + k, i + l))
 
+
desk2.Field[i + l][j + k] = busy;
    if (o==1)   {
+
                cout<<"Ферзь"<<endl;
+
k = 2, l = 1;  
 
+
// Проверка возможности хода в данную клетку
            if(a==1)
+
if (IsAvailable(j + k, i + l))
                {
+
desk2.Field[i + l][j + k] = busy;
                    cin>>y;
+
                    vsevarintyrasstavitnfigur(0,y);
+
k = 2, l = -1;  
                }
+
// Проверка возможности хода в данную клетку
 
+
if (IsAvailable(j + k, i + l))
 
+
desk2.Field[i + l][j + k] = busy;
            if (a==2)
+
break;
                maxfig();
+
// Ферзь
 
+
case queen:
                }
+
for (k = 0; k < N; k++)
 
+
{
 
+
// Движение по столбцу
 
+
if (desk2.Field[k][j] == Free)
 
+
desk2.Field[k][j] = busy;
 
+
// Движение по строке
 
+
if (desk2.Field[i][k] == Free)
    if (o==2)  {
+
desk2.Field[i][k] = busy;
                cout<<endl<<"Ладья"<<endl;
+
}
 
+
                    if(a==1)
+
// Выбор и поиск наибольшей существующей на поле диагонали
                    {
+
for (k = 1 - (N < M ? N : M); k < (N < M ? N : M); k++)
 
+
{
                        cin>>y;
+
// Проход из левого верхнего угла до правого нижнего
                        vsevarintyrasstavitnfigur(0,y);
+
if (IsAvailable(j + k, i + k))
                    }
+
desk2.Field[i + k][j + k] = busy;
 +
// Проход из левого нижнего до правого верхнего
 +
if (IsAvailable(j + k, i - k))
 +
desk2.Field[i - k][j + k] = busy;
 +
}
 +
break;
 +
// Король
 +
case king:
 +
  // Проход по квадрату 3 на 3, построенному центром на клетке, в которой стоит король
 +
for (k = -1; k < 2; k++)
 +
for (l = -1; l < 2; l++)
 +
if (IsAvailable(j + k, i + l))
 +
desk2.Field[i + l][j + k] = busy;
 +
break;
 +
}
 +
// Установка фигуры в данную клетку
 +
desk2.Field[i][j] = set;
 +
       
 +
// Проверяем, что количество поставленных фигур, которое равно номеру итерации, меньше чем необходимое число фигур
 +
if ((Already_stood + 1) < Chessmen_num)
 +
{
 +
// Если идет поиск всех расстановок, то запускаем следующий шаг
 +
if (IsCount == 0)
 +
desk2.FillField(IsCount, set, j, i, Chessmen_num, Already_stood + 1);
 +
// Если идет поиск максимального числа фигур на доске и была найдена хотя бы одна расстоновка, то возвращаем 1
 +
else if ((IsCount == 1) && desk2.FillField(IsCount, set, j, i, Chessmen_num, Already_stood + 1))
 +
return 1;
 +
}
  
                    if (a==2)
+
// Если количество поставленных фигур равно необходимому числу фигур
                        maxfig();
+
else if ((Already_stood + 1) == Chessmen_num)
 
+
{
                }
+
// Если идет поиск всех расстановок, то увеличиваем количество расстоновок на одну и записываем поле в файл 
 
+
if (IsCount == 0)
 
+
{
    if (o==3)   {
+
Result_count++;
                cout<<endl<<"Слон"<<endl;
+
  desk2.OutputInFile();
 
+
}
                if(a==1)
+
// Если идет поиск максимального числа фигур на доске, значит расстановка существует, возвращаем 1
                    {
+
else if (IsCount == 1)
                    cin>>y;
+
return 1;
                    vsevarintyrasstavitnfigur(0,y);
+
  }
                    }
+
}
 +
}
 +
// Если идет поиск всех расстановок, то возвращаем количество расстановок
 +
if (IsCount == 0)
 +
  return Result_count;
 +
// Если идет поиск максимального числа фигур на доске, то возвращаем 0
 +
else if (IsCount == 1)
 +
  return 0;
 +
} // End of 'FillField' function
  
                    if (a==2)
+
// END OF 'CHESS.CPP' FILE
                    maxfig();
+
</syntaxhighlight>
 +
"'''CHESS.H'''"
 +
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 +
/* FILENAME: CHESS.H
 +
* LAST UPDATE: 17.01.2016
 +
*/
  
                }
+
#ifndef __CHESS_H_
 +
#define __CHESS_H_
  
 +
#include <iostream>
 +
#include <conio.h>
  
    if (o==4)  {
+
using namespace std;
                cout<<endl<<"Конь"<<endl;
 
  
                if(a==1)
+
// свободен, занят, ладья, слон, конь, ферзь, король
                    {
+
enum type { Free, busy, castle, bishop, knight, queen, king };
                    cin>>y;
 
                    vsevarintyrasstavitnfigur(0,y);
 
                    }
 
                    if (a==2)
 
                    maxfig();
 
  
              }
+
/* Chess class */
 +
class chess
 +
{
 +
private:
 +
// Поле данных фигур
 +
type **Field;
 +
// Количество строк поля; количество столбцов поля
 +
int N, M;
 +
public:
 +
/* Default constructor */
 +
chess( void )
 +
{
 +
N = 8, M = 8;
 +
 +
// Выделение памяти под массив поля
 +
Field = new type*[N];
 +
for (int i = 0; i < N; i++)
 +
Field[i] = new type[M];
 +
}
 +
 +
/* Class constructor */
 +
chess( int _N, int _M ) : N(_N), M(_M)
 +
{
 +
// Выделение памяти под массив поля
 +
Field = new type* [N];
 +
for (int i = 0; i < N; i++)
 +
Field[i] = new type [M];
 +
}
  
    if (o==5)   {
+
/* Class destructor */
                cout<<"Король"<<endl;
+
~chess( void )
 +
{
 +
// Чистка памяти
 +
for (int i = 0; i < N; i++)
 +
delete[] Field[i];
 +
delete[] Field;
 +
}
  
                if(a==1)
+
/* Clear field function */
                {
+
void Clear( void );
                    cin>>y;
+
                    vsevarintyrasstavitnfigur(0,y);
+
/* Check if the cell is available that function */
 +
int IsAvailable( int x, int y );
 +
 +
/* Output field in file function */
 +
void OutputInFile( void );
 +
 +
/* Copy desks function */
 +
void Copy( chess& desk2 );
 +
 +
/* Fill field function */
 +
int FillField ( int IsCount, type set, int x, int y, int Chessmen_num, int Already_stood);
 +
}; // end of 'chess' class
  
                }
+
#endif /*__CHESS_H_ */
                if (a==2)
 
  
                      maxfig();
+
// END OF 'CHESS.H' FILE
 +
</syntaxhighlight>
 +
</div>
 +
[http://tm.spbstu.ru/File:T04CHESS.7z Скачать архив]
 +
<br>
  
                }
 
  
            }
+
'''[[Рубинова Раиса]]'''
  
 +
'''Основная идея программы''': программа позволяет выводить на экран всевозможные расстановки n однотипных фигур на шахматной доске размером n*n так, чтобы ни одна из фигур не била другую.
  
 +
Скачать можно [http://tm.spbstu.ru/File:nmk.rar тут.]
  
}
+
<div class="mw-collapsible mw-collapsed" style="width:100%" >
 +
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 +
#include <iostream>
 +
#include <cstring>
 +
#include <cstdlib>
 +
#include <ctime>
  
 +
using namespace std;
 +
int R = 0; ///переменная, отвечающая за количество вариантов расстановок
 +
int N; ///количество фигур для расстановки, которое задает пользователь
 +
int **B; ///двумерный массив, отображающий шахматную доску
 +
int M; /// размер шахматной доски
  
  
 +
void showBoard() ///функция, выводящая доску на экран
 +
{
 +
    for(int i=0; i<M; ++i) /// строки
 +
    {
 +
        for(int j=0; j<M; ++j)  /// столбцы
 +
            {cout << B[i][j] << " ";} ///заполнение клетки с координатами i;j
 +
        cout << endl;
 +
    }
 +
    cout << "Variant " << ++R << "\n\n"; ///вывод номера варианта расположения с последующим переходом на новую строку
 +
    return;
 +
}
  
</syntaxhighlight>
+
bool checkQueen(int a, int b) /// функция, проверяющая, не бьется ли ферзь другим ферзем
</div>
+
{
 +
    for (int i = 0; i < M; ++i) ///проверка строки
 +
    {
 +
        if(B[a][i])
 +
            return false;
 +
    }
  
 +
    for(int i = 0; i < M; ++i) ///проверка столбца
 +
    {
 +
        if(B[i][b])
 +
            return false;
 +
    }
  
 +
    for(int i = 1; a-i >= 0 && b-i >= 0; ++i)///по диагонали влево-вверх
 +
    {
 +
        if(B[a-i][b-i])
 +
            return false;
 +
    }
  
 +
    for(int i = 1; a+i < M && b+i < M; ++i)///по диагонали вправо-вниз
 +
    {
 +
        if(B[a+i][b+i])
 +
            return false;
 +
    }
  
'''[[Лосева Татьяна]]'''
+
    for(int i = 1; a+i < M && b-i >= 0; ++i)///по диагонали влево-вниз
 +
    {
 +
        if(B[a+i][b-i])
 +
            return false;
 +
    }
  
'''Краткое описание алгоритма :'''
+
    for(int i = 1; a-i >= 0 && b+i < M; ++i)///по диагонали вправо-вверх
Доска представлена в виде динамического массива;Для каждой фигуры написана отдельная функция проверки на возможность установки фигуры,проверяющая, находится ли эта фигура под ударом других.
+
    {
После выбора типа фигуры,используется  рекурсивная функция,которая проверяет возможные  расстановки через данную функцию проверки ,для данного типа фигуры.
+
        if(B[a-i][b+i])
Для поиска максимального значения мы проверяем расстановку начиная с 0 количество фигур ,каждый раз увеличивая на 1,если количество расстановок станет равно нулю,то предыдущее количество фигур было максимальным.
+
            return false;
 +
    }
  
'''Инструкция''' : Пользователя попросят ввести размер доски,затем выбрать один из вариантов работы программы:1.поиск возможных расстановок для M фигур или 2.поиск максимального количества расстановок для данного поля,затем попросят выбрать тип фигуры и в первом случае количество фигур.При выводе на экран выводится номер расстановки и доска,на доске F- обозначены занятые клетки,0-пуская клетка.
+
    return true;
Для 2 пункта выводится лишь число: максимальное количество фигур,которое можно расставить.
+
}
  
Скачать можно : [http://tm.spbstu.ru/Файл:Шахматы_Лосева.rar тут]
+
void Queen(int a, int count) ///функция, расстанавливающая ферзи
 +
{
 +
    for(int b = 0; b < M; ++b) /// расстановка по изменению номера столбца
 +
    {
 +
        if(checkQueen(a, b)) ///проверка, бьется ли данная клетка ферзем
 +
        {
 +
            B[a][b] = 1; ///заполнение первой клетки
 +
            for(int i = a+1; i < M; ++i) ///расстановка указанного пользователем количества фигур
 +
                Queen(i,count+1);
 +
            if(count+1==N) /// проверка, расставили ли мы нужное количество фигур
 +
                showBoard();
 +
            B[a][b]=0; ///обнуление переменной
 +
        }
 +
    }
 +
}
  
 +
bool checkRook(int a, int b) /// функция, проверяющая ли данную клетку ладья
 +
{
 +
    for (int i = 0; i < M; ++i) ///проверка строки
 +
    {
 +
        if(B[a][i])
 +
            return false;
 +
    }
  
<div class="mw-collapsible mw-collapsed" style="width:100%" >
+
    for(int i = 0; i < M; ++i) ///проверка столбца
<syntaxhighlight lang="cpp" line start="1" enclose="div">
+
    {
#include<iostream>
+
        if(B[i][b])
using namespace std;
+
            return false;
int N;//размер доски NxN
+
    }
int **a;
 
int *ax;
 
int *by;
 
int l = 0;//L-номер пункта в меню
 
int M;//количество фигур
 
bool isPrint = false;//переменная для вывода на экран,когда требуется,для удобства обозначим в начале false
 
  
 +
    return true;
 +
}
  
void print()//функция вывода на экран
+
void Rook(int a, int count) ///функция, расстанавливающая ладьи
 
{
 
{
for (int i = N - 1; i >= 0; --i)
+
    for(int b = 0; b < M; ++b) /// расстановка по строкам с изменением номера столбца
{
+
    {
for (int j = 0; j < N; ++j)
+
        if(checkRook(a, b)) ///проверка, бьется ли данная клетка ладьей
{
+
        {
cout << ((a[j][i]) ? "F " : "0 ");//если (a[j][i]) истина,то есть клетка занята,ставим F,в другом случае,т.е.свободна,ставим 0
+
            B[a][b] = 1; ///установка ладьи
}
+
            for(int i =a+1; i<M; ++i)
cout << '\n';
+
                Rook(i,count+1);
}
+
            if(count+1 == N) /// проверка, расставили ли мы нужное количество элементов
cout << '\n';
+
                showBoard();
  
 +
            B[a][b]=0; ///обнуление переменной
 +
        }
 +
    }
 
}
 
}
bool Lad(int x, int y)//Ладья
+
 
 +
bool checkElephant(int a, int b) /// функция, проверяющая, бьется ли данная клетка слоном
 
{
 
{
for (int i = 0; i < N; ++i)
+
    for(int i = 1; a-i >= 0 && b-i >= 0; ++i)///проверка по диагонали влево-вверх
{
+
    {
if (a[i][y] == 1 )//проверяем горизонталь:если клетка занята
+
        if(B[a-i][b-i])
{
+
            return false;
return false;//возвращаем false
+
    }
}
 
if (a[x][i] == 1)//проверяем вертикаль : если хотя бы одна клетка занята,то
 
{
 
return false;//возврашаем false
 
}
 
}
 
return true;//ничего выше не выполняется,значит возвращаем правду:вертикаль и горизонталь свободна
 
  
}
+
    for(int i = 1; a+i < M && b+i < M; ++i)///проверка по диагонали вправо-вниз
 +
    {
 +
        if(B[a+i][b+i])
 +
            return false;
 +
    }
  
bool Kon(int x, int y)//Коняша
+
    for(int i = 1; a+i < M && b-i >= 0; ++i)///проверка по диагонали влево-вниз
{
+
    {
int i[8] = {-2, -2, -1, -1, 1, 1, 2, 2};//координаты клеток,на которые может ходить конь,относительно текущей (8 вариантов)
+
        if(B[a+i][b-i])
int j[8] = {-1, 1, -2, 2, -2, 2, -1, 1};
+
            return false;
+
    }
for (int k = 0; k < 8; k++)//8 вариантов хода
+
 
+
    for(int i = 1; a-i >= 0 && b+i < M; ++i) ///проверка по диагонали вправо-вверх
{
+
    {
if (x + i[k] >= 0 && x + i[k] < N && y + j[k] >= 0 && y + j[k] < N)//проверка выхода за границы массива
+
        if(B[a-i][b+i])
{
+
            return false;
if (a[x + i[k]][y + j[k]] != 0)//клетка занята
+
    }
{
 
return false;//возвращем false
 
}
 
}
 
}
 
return true;////ничего выше не выполняется,значит возвращаем правду:все варианты ходов  свободны и конь никого не перебивает,тогда можно занять клетку
 
  
 +
    return true;
 
}
 
}
 +
void Elephant(int dia, int count) ///функция, расстанавливающая слоны
 +
{
 +
    int a, b; /// задача клетки, соответствующекй данной диагонали
 +
    if (dia < M) /// проверка диагонали
 +
    {
 +
        a = dia; /// номер строки - номер диагонали
 +
        b = 0; ///обнуление переменной для столбца, цикл движется по столбцу
 +
    }
 +
  else ///если все диагонали рассмотрены
 +
    {
 +
        a = M-1; /// рассматриваем самую последнюю диагональ
 +
        b =(dia % M)+1; ///рассчитываем координату столбца для данной диагонали
 +
    }
  
 +
    for(int i=0; a-i>=0 && b+i < M; ++i)/// цикл движется по строкам и столбцам из нижнего левого угла в правый верхний
 +
    {
 +
        int line=a-i; ///координата строки (мы уменьшаем координату строки)
 +
        int column=b+i; ///координата столбца  (но увеличиваем координату столбца)
  
 +
        if(checkElephant(line, column))/// проверка, бьется ли слон по диагонали
 +
        {
 +
            B[line][column]=1; ///установка слона
  
 +
            for(int i=dia+1; i<2*M-1; ++i) ///расстановка фигур, основанная на изменении параметров (номера диагонали и количества рсставленных фигур)
 +
                Elephant(i,count+1);
  
bool Korol(int x, int y)//Король
+
            if(count+1 == N) /// проверка количества расставленных фигур
{
+
                showBoard();
  
int i[8] = { -1, -1, -1, 0, 0, 1, 1, 1 };//координаты клеток,на которые может ходить король,относительно текущей
+
            B[line][column]=0; ///обнуление переменной
     int j[8] = { -1, 0, 1, -1, 1, -1, 0, 1 };
+
        }
 +
     }
 +
}
  
for(int k = 0; k < 8; k++)//8 вариантов хода
+
bool checkHorse(int a, int b) /// функция, проверяющая, бьется ли данная клетка конями
{
+
{
if (x + i[k] >= 0 && x + i[k] < N && y + j[k] >= 0 && y + j[k] < N)//прроверяем не выходит ли фигура за границы массива
+
    if ((a-1) >=0 && (b-2)>=0 && B[a-1][b-2])
{
+
        return false;
if (a[x + i[k]][y + j[k]] != 0)//если какой нибудь из вариантов хода занят
+
 
{
+
    if ((a-1)>=0 && (b+2) < M && B[a-1][b+2])
return false;//то false
+
        return false;
}
+
 
}
+
    if ((a+1) < M && (b-2) >=0 && B[a+1][b-2])
}
+
        return false;
return true;//свободно,можно занимать
+
 
 +
    if ((a+1) < M && (b+2) < M && B[a+1][b+2])
 +
        return false;
 +
 
 +
    if ((a-2) >=0 && (b-1) >=0 && B[a-2][b-1])
 +
        return false;
 +
 
 +
    if ((a-2) >=0 && (b+1) < M && B[a-2][b+1])
 +
        return false;
 +
 
 +
    if ((a+2) < M && (b-1) >= 0 && B[a+2][b-1])
 +
        return false;
 +
 
 +
    if ((a+2) < M && (b+1) < M && B[a+2][b+1])
 +
        return false;
 +
 
 +
    return true;
 
}
 
}
  
bool Slon(int x, int y)
+
void Horse(int count, int a, int b) ///функция расстановки коней; a - очередная строка, b - очередной столбец, count - счетчик количества фигур, которое необходимо расставить
 
{
 
{
int p1 = y - x;//номер диагонали слева направо
+
    if(count==N) /// проверка количества расставленных фигур
int p2 = y + x;//номер диагонали с права налево
+
    {
for (int i = 0; i < N; i++)//проверяем левую диагональ
+
        showBoard();
{
+
    }
if (i + p1 >= 0 && i + p1 < N)//проверка на выход за границы массива
+
    if (a == M) /// не выходит ли за предел доски
{
+
        return;
if (a[i][i + p1] == 1) //проверяем диагональ
+
    for (int j=b; j<M; ++j) ///рассматриваем первую строку
{
+
    {
return false;//диагональ занята
+
        if(checkHorse(a, j)) ///проверка
}
+
        {
}
+
            B[a][j]=1; ///установка коня
if (-i + p2 >= 0 && -i + p2 < N)//вторая диагональ
+
            int l = a, b = j+1; ///смещение в другой столбец
{
+
 
if (a[i][-i + p2] == 1)  
+
            if (b == M) ///проверка, не крайний ли это столбец, так как тогда мы не можем продолжать расстановку (мы ее завершили)
{
+
            {
return false;//вторая диагональ занята
+
                b=0; ///обнуление переменной
}
+
                l++;    ///переход на следующую
}
+
            }
}
+
            Horse(count+1,l,b); ///установка фигуры, увеличение счетчика
return true;//обе диагонали свободны,ура!
+
            B[a][j]=0; ///обнуление переменной для установки следующей фигуры в следующую клетку
 +
        }
 +
    }
 +
    for(int i=a+1; i<M; ++i) ///заполнение строк
 +
    {
 +
        for (int j=0; j<M; ++j)
 +
        {
 +
            if(checkHorse(i, j)) ///проверка клетки, не бьется ли она другими конями
 +
            {
 +
                B[i][j]=1; ///установка коня
 +
                int l = i, b = j+1; ///смещаемся на другой столбец
 +
                if (b == M)
 +
                {
 +
                    b = 0;
 +
                    l++;
 +
                }
 +
                Horse(count+1,l,b); ///установка фигуры с увеличением счетчика
 +
                B[i][j]=0; ///обнуление переменной
 +
            }
 +
        }
 +
    }
 
}
 
}
  
bool Check(int x, int y)//Ферзь=Ладья+Слон
+
bool checkKing(int a, int b) /// функция, проверяющая, бьет ли данную клетку король
 
{
 
{
int p1 = y - x;//диагональ 1
+
    for(int i = a-1; i <= a+1; ++i)
int p2 = y + x;//диагональ 2
+
    {
for (int i = 0; i < N; ++i)
+
        for(int j = b-1; j <= b+1; ++j)
{
+
        {
if (a[i][y] == 1 )//проверяем горизонталь
+
            if (a>=0 && a < M && b>=0 && b < M && B[a][b])
{
+
                return false;
return false;//занято
+
 
}
+
            if ((a+1) < M && (b-1) >=0 && B[a+1][b-1])
if (a[x][i] == 1)//проверяем вертикаль
+
                return false;
{
+
 
return false;//занято
+
            if ((a+1) < M && B[a+1][b])
}
+
                return false;
+
 
if (i + p1 >= 0 && i + p1 < N)//выход за границы массива
+
            if ((a+1) < M && (b+1) < M && B[a+1][b+1])
{
+
                return false;
if (a[i][i + p1] == 1) //проверяем 1 диагональ
+
 
{
+
            if ((b+1) < M && B[a][b+1])
return false;//занято
+
                return false;
}
+
 
}
+
            if ((a-1)>=0 && (b+1) < M && B[a-1][b+1])
if (-i + p2 >= 0 && -i + p2 < N)//выход за границы массива
+
                return false;
{
+
 
if (a[i][-i + p2] == 1)//проверяем 2ую диагональ
+
            if ((a-1) >=0 && B[a-1][b])
{
+
                return false;
return false;//занято
+
 
}
+
            if ((a-1) >=0 && (b-1)>=0 && B[a-1][b-1])
}
+
                return false;
}
+
 
return true;//свободно!
+
            if ((b-1) >= 0 && B[a][b-1])
}
+
                return false;
 +
        }
 +
    }
  
int  menu1()
+
    return true;
{
 
cout << "Type of figure:" << endl << "1 - Ferz" << endl << "2 - Ladya" << endl << "3 - Slon" << endl << "4 - Kon" << endl << "5 - Korol" << endl;
 
cin >> l;
 
return l;
 
 
}
 
}
  
int num = 0;//номер расстановки
+
void King (int count, int a, int b) ///функция, расставляющая коней
//пробует найти результаты решений.
 
 
 
void Func(int d,int K) //d-глубина рекурсии;K-сколько фигур нужно расставить
 
 
{
 
{
if (d == K)//когда расставили нужное количество
+
    for (int j=b; j<M; ++j) ///установка королей в первой строке
{
+
    {
if (isPrint)//если true,то печатаем(в случае с MAX количеством доску печатать не нужно)
+
        if(checkKing(a, j)) ///проверка данной клетки на возможность установки фигуры
{
+
        {
cout << "Result: " << num + 1 << '\n';//выводим нормер расстановки
+
            B[a][j]=1; ///если по результатам проверки можно поставить фигуру, то мы ее ставим
print();//печатаем доску
+
            King(count+1,a,j); ///расстановка фигур для первой доски
}
+
            B[a][j]=0; ///обнуление переменной
num++;//номер расстановки увеличивается
+
        }
return;
+
    }
}
 
  
int minX = d != 0 ? ax[d - 1] : 0;//исходя из того куда быда поставлена предыдущая фигура
+
    for(int i=a+1; i<M; ++i) ///расстановка фигур
//,накладываются ограничения для выбора места новой,чтобы избежать поторений
+
    {
int minY = d != 0 ? by[d - 1] + 1 : 0;
+
        for (int j=0; j<M; ++j)
 +
        {
 +
            if(checkKing(i, j)) ///проверка данной клетки на возможность установки фигуры
 +
            {
 +
                B[i][j]=1; /// если короля можно поставить, то ставим его в данную клетку
 +
                King(count+1,i,j);
 +
                B[i][j]=0; ///обнуление переменной
 +
            }
 +
        }
 +
    }
  
 +
    if(count==N)
 +
    {
 +
        showBoard();/// вывод шахмат на экран
 +
        return;
 +
    }
 +
}
  
bool isPossible = false;//Проверяет,возможно ли занять клетку
+
int main()
for (int i = minX; i < N; ++i)
+
{
{
+
        cout << "Enter the size of the board: " << endl; ///ввод размера доски
 
+
        cin >> M;
for (int j = (i != minX) ? 0 : minY; j < N; ++j)
+
        B = new int*[M];
{
+
        for (int i=0; i<M; i++)
switch (l)//l- номер пункта в меню с фигурами
+
            B[i] = new int[M];
{
+
        for (int i = 0; i<M; i++)
case 1://ферзь
+
            for (int j = 0; j<M; j++)
isPossible = Check(i, j);
+
                B[i][j] = 0;
break;
+
        int Var;
case 2://Ладья
+
        cout << '\n' << "1=your number of figures, 2=max number of figures" << endl;
isPossible = Lad(i, j);
+
        cin >> Var;
break;
+
        int F;
case 3://Слон
+
                cout << '\n' << "Input type of figure: 1-queen, 2-king, 3-horse, 4-rook, 5-elephant"<< endl;
+
                cin >> F;
isPossible = Slon(i, j);
+
        if (Var==1) /// если пользователь выбрал свое количество фигур, то мы выполняем следующие действия:
break;
+
        {
case 4://Конь
+
                int mn;
isPossible = Kon(i, j);
+
                    cout << "Input the number of figures" << endl;
break;
+
                    cin >> N;
case 5://Король
+
                if (F==1)
isPossible = Korol(i, j);
+
                {
break;
+
                    for (int i=0; i <M; ++i)
}
+
                        Queen(i,0);
if (isPossible)//если клетку занять возмоно(функция вернула true)
+
                }
{
+
                if (F==2)
  a[i][j] = 1;//занимаем клетку
+
                {
ax[d] = i;//запоминаем куда была поставлена фигура
+
                    King(0,0,0);
by[d] = j;//запоминаем куда была поставлена фигура
+
                }
Func(d + 1, K);//вызываем рекурсивно
+
                if (F==3)
a[i][j] = 0;
+
                {
}
+
                    Horse(0,0,0);
}
+
                }
}
+
                if (F==4)
 +
                {
 +
                    for (int i=0; i <M; ++i)
 +
                        Rook(i,0);
 +
                }
 +
                if (F==5)
 +
                {
 +
                    for(int i = 0; i<2*M-1; ++i)
 +
                        Elephant(i,0);
 +
                }
 +
            }
 +
        else if (Var==2)       /// если пользователь выбрал максимальное количество фигур
 +
        {
 +
                int mn;
 +
                if (F==1)
 +
                {
 +
                    mn=M;
 +
                    cout <<  "Max number " << mn  << endl; /// выводим максимальное количество фигур
 +
                    N=mn; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
 +
                        for (int i=0; i < M; ++i)
 +
                            Queen(i,0);
 +
                    }
  
return;
+
                if (F==2)
}
+
                {
 
+
                    mn=0.25*M*M;
int main()
+
                    cout << '\n' << "Max number " << mn <<  endl;
{
+
                    N=mn; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
 +
                    King(0,0,0);
 +
                    }
 +
                if (F==3)
 +
                {
 +
                    mn=0.5*M*M;
 +
                    cout <<  "Max number " << mn  << endl;
 +
                    N=mn; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
 +
                    Horse(0,0,0);
 +
                    }
 +
                if (F==4)
 +
                {
 +
                    mn=M;
 +
                    cout <<  "Max number " << mn  << endl;
 +
                    N=mn; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
 +
                        for (int i=0; i <M; ++i)
 +
                            Rook(i,0);
 +
                    }
 +
                if (F==5)
 +
                {
 +
                    mn=2*M-2;
 +
                    cout <<  "Max number " << mn  << endl;
 +
                    N=mn; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
 +
                        for(int i = 0; i<2*M-1; ++i)
 +
                            Elephant(i,0);
 +
                    }
 +
                }
 +
    }
 +
 
 +
 
 +
 
 +
</syntaxhighlight>
 +
</div>
  
cout << "Enter size: ";//нужно ввести размер доски
+
'''[[Савельева Ольга]]'''
cin >> N;//считываем размер доски
 
  
a = new int*[N];//создаём двумерный массив,т.е.нашу доску
 
for (int i = 0; i < N; i++)
 
{
 
a[i] = new int[N];
 
for (int j = 0; j < N; j++)
 
a[i][j] = 0;//заполняем нулями
 
}
 
 
ax = new int[N];//массивы для сохранения координаты каждой фигуры,чтобы избежать повторений
 
by = new int[N];
 
  
int d;//пункт в меню
+
'''Инструкция''': В меню указывается два варианта развития событий. Пользователь должен выбрать один из путей: либо максимальное число вариантов, либо посмотреть наглядно на варианты. Человек вводит размер доски и тип фигуры.
cout<<"1 - Rasstanovka figur"<<endl<<"2 - MAX znachenie"<<endl;//два варианта работы программы
 
cin>>d;//считываем выбор пользователя
 
if(d==1)//если выбирает расстановку
 
 
menu1();//то спрашиваем для какой фигуры
 
cout<<"How many figures?"<<endl;//и как много будет фигур
 
    cin>>M;//считываем количество фигур
 
isPrint = true;//в этом случае будем выводить на экран
 
Func(0,M);//запуск рекурсивной функции
 
}
 
  
if (d == 2)//случай подсчёта максимального значения
+
Скачать программу можно  [http://tm.spbstu.ru/:File:Шахматы0001.zip    ]
{
 
int n = 0;//изачально max=0
 
menu1();//выбираем фигуру
 
 
do//начало цикла
 
{
 
num = 0;
 
Func(0, ++n);//запускаем каждый раз увеличивая значение фигур и считаем количество расстановок
 
} while (num != 0);//количество вариантов не должно быть равно нулю
 
cout <<"MAX ="<< n - 1 << endl;//если количество вариантов = 0,то выходим из цикла и предыдущее значение  максимальное
 
}
 
 
  
int z;
+
<div class="mw-collapsible mw-collapsed" style="width:100%" >
cin >> z;
+
<syntaxhighlight lang="cpp" line start="1" enclose="div">
  
return 0;
+
#define windows
}
 
</syntaxhighlight>
 
</div>
 
  
'''[[Степанянц Степан]]'''
+
#include <stdio.h>
 +
#include <vector>
  
'''Программа''': 1)Программа получает все возможные варианты расстановок одинаковых фигур на поле боя(шахматной доске) так, чтобы они не смогли бить друг друга.2)Программа выводит максимальное число фигур, которые можно поставить на шахматную доску nxn так, чтобы они не смогли бить друг друга.
+
#ifdef windows
 
+
#include <windows.h>
'''Идея алгоритма''': Функция вызывает саму себя(рекурсия) в рекурсии фигура ставится на небьющуюся клетку и помечаются клетки, которые бьются этой фигурой.Если дальше ставить нельзя, то начинается обратный ход:фигура убирается, и запоминается место, где она стояла, и вновь вызывается функция.
+
#endif  // windows
 
 
Скачать можно  [http://tm.spbstu.ru/Файл:Шахматы.rar тут].
 
 
 
<div class="mw-collapsible mw-collapsed" style="width:100%" >
 
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 
#include <iostream>
 
#include <vector>
 
  
 
using namespace std;
 
using namespace std;
  
 +
#ifdef windows
 +
HANDLE hCon;
 +
#endif // windows
  
 +
unsigned fact(int n)  //factorial of a number
 +
{
 +
    unsigned long long ret = 1;
 +
    for(int i = 2; i <= n; i++)
 +
        ret *= i;
 +
    return ret;
 +
}
  
//задаю массивы в которых изображены все ходы определенных фигур
+
struct desk
int d = 0;
+
{
int d_knight[2][8] = {{1, 1, -1, -1, 2, 2, -2, -2},
+
     char **deskFigures, **deskOccupy;   //desk with figures, desk with occupation counter for each cell
     {2, -2, 2, -2, 1, -1, 1, -1}};
+
    int x, y, size, a, f;   //pointer position(x, y), size of the desk, amount of prints, amount of figures
int d_bish[4][2] = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
+
     vector<pair<int, int> > *s; //stack of placed figures
int d_king[8][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}, {1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
+
     bool stackIsUsed;   //if stack is needed
//Проверяем, не выходим ли мы за поле
+
    desk(int size, bool stackIsUsed = true):x(0), y(0), size(size), a(0), f(0), stackIsUsed(stackIsUsed)
bool ok(int x, int y, int n) {
+
    {
     if (x < 0 || y < 0 || x >= n || y >= n)
+
        deskFigures = new char*[size];
        return false;
+
        for(int i = 0; i < size; i++)
     return true;
+
            deskFigures[i] = new char[size];
}
+
        deskOccupy = new char*[size];
 
+
         for(int i = 0; i < size; i++)
void print(int n, vector<vector<pair<bool, int> > > board) {
+
             deskOccupy[i] = new char[size];
    for (int i = 0; i < n; i++) {
+
         if(stackIsUsed)
         for (int j = 0; j < n; j++) {
+
            s = new vector<pair<int, int> >;
             cout << ((board[i][j].first) ? " X " : " 0 ");
+
        clear();
         }
 
        cout << '\n';
 
 
     }
 
     }
     cout << "-------------------------------------\n";
+
     ~desk()
}
+
    {
//Рекурсивная функция
+
        for(int i = 0; i < size; i++)
int func(int n, int k, int count, vector<vector<pair<bool, int> > > board, int ii, int jj, int fig, int task) {
+
            delete deskFigures[i];
    int ans = 0;
+
        delete deskFigures;
    if (count == k && !task) {
+
        for(int i = 0; i < size; i++)
         print(n, board);
+
            delete deskOccupy[i];
        return 1;
+
        delete deskOccupy;
 +
         if(stackIsUsed)
 +
            delete s;
 
     }
 
     }
     else if(task) {
+
     void setKnight(int x, int y, int z) //increase all cells occupied by knight at (x, y) on z
         ans = max(ans, count);
+
    {
 +
        if(x + 2 < size)
 +
        {
 +
            if(y - 1 >= 0)
 +
                deskOccupy[x + 2][y - 1] += z;
 +
            if(y + 1 < size)
 +
                deskOccupy[x + 2][y + 1] += z;
 +
        }
 +
        if(y + 2 < size)
 +
        {
 +
            if(x - 1 >= 0)
 +
                deskOccupy[x - 1][y + 2] += z;
 +
            if(x + 1 < size)
 +
                deskOccupy[x + 1][y + 2] += z;
 +
        }
 +
        if(x - 2 >= 0)
 +
        {
 +
            if(y - 1 >= 0)
 +
                deskOccupy[x - 2][y - 1] += z;
 +
            if(y + 1 < size)
 +
                deskOccupy[x - 2][y + 1] += z;
 +
        }
 +
         if(y - 2 >= 0)
 +
        {
 +
            if(x - 1 >= 0)
 +
                deskOccupy[x - 1][y - 2] += z;
 +
            if(x + 1 < size)
 +
                deskOccupy[x + 1][y - 2] += z;
 +
        }
 
     }
 
     }
     for (int i = ii + jj / n; i < n; i++) {
+
     void setBishop(int x, int y, int z) //increase all cells occupied by bishop at (x, y) on z
         for (int j = jj % n; j < n; j++) {
+
    {
             if (!board[i][j].first && !board[i][j].second) {
+
         for(int ix = 0, iy1 = y - x, iy2 = y + x; ix < size; ix++, iy1++, iy2--)
                 switch (fig) {
+
             if(ix != x)
                    case 1://конь
+
            {
                        for (int k = 0; k < 8; k++) {
+
                 if((iy1 >= 0)and(iy1 < size))
                            if (ok(i + d_knight[0][k], j + d_knight[1][k], n))
+
                    deskOccupy[ix][iy1] += z;
                                board[i + d_knight[0][k]][j + d_knight[1][k]].second++;
+
                if((iy2 >= 0)and(iy2 < size))
                        }
+
                    deskOccupy[ix][iy2] += z;
                        break;
+
            }
                    case 2://слон
+
    }
                        for (int k = 0; k < n; k++) {
+
    void setRook(int x, int y, int z)  //increase all cells occupied by rook at (x, y) on z
                            for (int l = 0; l < 4; l++) {
+
    {
                                if (ok(i + k * d_bish[l][0], j + k * d_bish[l][1], n))
+
        for(int i = 0; i < size; i++)
                                    board[i + k * d_bish[l][0]][j + k * d_bish[l][1]].second++;
+
        {
                            }
+
            if(i != x)
                        }
+
                deskOccupy[i][y] += z;
                        break;
+
            if(i != y)
                    case 3: // ладья
+
                deskOccupy[x][i] += z;
                        for (int k = 0; k < n; k++)
+
        }
                            board[i][k].second++, board[k][j].second++;
+
    }
                        break;
+
    void setKing(int x, int y, int z)  //increase all cells occupied by king at (x, y) on z
                    case 4: // король
+
    {
                        for (int k = 0; k < 8; k++)
+
        for(int ix = x - 1; ix <= x + 1; ix++)
                            if (ok(i + d_king[k][0], j + d_king[k][1], n))
+
            for(int iy = y - 1; iy <= y + 1; iy++)
                                board[i + d_king[k][0]][j + d_king[k][1]].second++;
+
                if((ix >= 0)and(ix < size)and(iy >= 0)and(iy < size)and((ix != 0)or(iy != 0)))
                        break;
+
                    deskOccupy[ix][iy] += z;
                    case 5: // ферзь
+
    }
                        for (int k = 0; k < 8; k++)
+
    void setFigure(int x, int y, int z, char figure)   //increase all cells occupied by figure
                            for (int l = 0; l < n; l++)
+
                                                        //and (x, y) on z
                                if (ok(i + l * d_king[k][0], j + l * d_king[k][1], n))
+
    {
                                    board[i + l * d_king[k][0]][j + l * d_king[k][1]].second++;
+
        deskOccupy[x][y] += z;
                        break;
+
        switch(figure)
                       
+
        {
                }
+
            case 'N':
                //Рекурсия
+
                setKnight(x, y, z);
                board[i][j].first = true;
+
                break;
                if (!task)
+
            case 'B':
                    ans += func(n, k, count + 1, board, i, j + 1, fig, task);
+
                setBishop(x, y, z);
              //обратный ход
+
                break;
                else
+
            case 'R':
                    ans = max(ans, func(n, k, count + 1, board, i, j + 1, fig, task));
+
                setRook(x, y, z);
                board[i][j].first = false;
+
                break;
                switch (fig) {
+
            case 'Q':
                    case 1:
+
                setBishop(x, y, z);
                        for (int k = 0; k < 8; k++) {
+
                setRook(x, y, z);
                            if (ok(i + d_knight[0][k], j + d_knight[1][k], n))
+
                break;
                                board[i + d_knight[0][k]][j + d_knight[1][k]].second--;
+
            case 'K':
                        }
+
                setKing(x, y, z);
                        break;
+
                break;
                    case 2:
 
                        for (int k = 0; k < n; k++) {
 
                            for (int l = 0; l < 4; l++) {
 
                                if (ok(i + k * d_bish[l][0], j + k * d_bish[l][1], n))
 
                                    board[i + k * d_bish[l][0]][j + k * d_bish[l][1]].second--;
 
                            }
 
                        }
 
                        break;
 
                    case 3:
 
                        for (int k = 0; k < n; k++)
 
                            board[i][k].second--, board[k][j].second--;
 
                        break;
 
                    case 4:
 
                        for (int k = 0; k < 8; k++)
 
                            if (ok(i + d_king[k][0], j + d_king[k][1], n))
 
                                board[i + d_king[k][0]][j + d_king[k][1]].second--;
 
                        break;
 
                    case 5:
 
                        for (int k = 0; k < 8; k++)
 
                            for (int l = 0; l < n; l++)
 
                                if (ok(i + l * d_king[k][0], j + l * d_king[k][1], n))
 
                                    board[i + l * d_king[k][0]][j + l * d_king[k][1]].second--;
 
                        break;
 
                }
 
            }
 
 
         }
 
         }
        jj = 0;
 
 
     }
 
     }
     return ans;
+
     bool putFigure(int x, int y, char figure)  //place figure on desk and update occupied cells
}
+
     {
//меню
+
        if(deskFigures[x][y] > 0)
int main() {
+
            return false;
    int fig, task;
+
        deskFigures[x][y] = figure;
    int n, k;
+
        if(stackIsUsed)
     cout << "Please, input the task number: 1 - amount of solutions, 2 - maximum of figures\n";
+
            s -> push_back(make_pair(x, y));
    cin >> task;
+
        setFigure(x, y, 1, figure);
    task--;
+
        f++;
    cout << "Please, input figure type: 1 - knight, 2 - bishop, 3 - castle, 4 - king, 5 - queen\n";
+
        return true;
    cin >> fig;
+
     }
    cout << "Please, input the size of the board\n";
+
     int cellsLeft() //amount of cells after pointer
     cin >> n;
+
    {
     if (!task) {
+
         return (size - y) * size - x;
         cout << "Please, input number of figures\n";
 
        cin >> k;
 
 
     }
 
     }
     vector<vector<pair<bool, int> > > v = vector<vector<pair<bool, int> > >(n, vector <pair<bool, int> >(n, {false, 0}));
+
     bool putNextFree(char figure)  //attempt to put figure on the next free(and not occupied) place
     cout << func(n, k, 0, v, 0, 0, fig, task);
+
     {
}
+
        if(y >= size)
</syntaxhighlight>
+
            return false;
</div>
+
        while(deskOccupy[x][y] > 0)
 
+
        {
'''[[Лобанов Илья]]'''
+
            if(++x == size)
 
+
            {
'''Описание алгоритма''':
+
                if(++y == size)
 
+
                    return false;
Программа проверяет возможность расстановки фигур на доске M*M . При выводе на экран на экран клетки,занятые фигурами ,помечаются буквами,соответствующими первой букве типа фигуры. Также программа считает максимальное число фигур определенного типа,которые можно расставить на доске.
+
                x = 0;
 
+
            }
'''Инструкция''':
+
        }
 
+
        return putFigure(x, y, figure);
В окне консоли пользователю предлагается выбрать 2 типа работы программы, затем пользователь вводит размер доски(четный),тип и количество фигур,которые необходимо разместить на доске.В зависимости от режима работы программы ,будет выведено либо максимально возможное число расстановок фигур,либо максимальное число фигур.
+
    }
Скачать можно [[http://tm.spbstu.ru/File:ConsoleApplication54.rar тут]]
+
    void removeFigure(int x, int y) //remove figure from (x, y)
<div class="mw-collapsible mw-collapsed" style="width:100%" >
+
    {
<syntaxhighlight lang="cpp" line start="1" enclose="div">
+
        if(deskFigures[x][y]!=0)
#include <iostream>
+
            setFigure(x, y, -1, deskFigures[x][y]);
#include <windows.h>
+
        deskFigures[x][y] = 0;
using namespace std;
+
        f--;
 
+
    }
enum type{peshka, king, kon, ladya, slon, queen}; // все возможные типы фигур
+
    void removeBishop(int diag, bool color, bool left) //remove bishop
const char symbols[] = "pKklsQ"; // буквенное обозначение каждой фигуры:p - пешка, K - король, k - конь, l- ладья, s - слон, Q - ферзь
+
    {
const int NONE = INT_MAX;//константа для обозначения пустой клетки
+
        if(color)  //true - white, false - black
int M, **desk, *colons, *rows, *diag_1, *diag_2;
+
        {
 
+
            if(diag > 0)   //diag - number of diagonal
// структура для описания клектки доски
+
            {
struct point
+
                int diff = left ? 0 : diag * 2;
{
+
                removeFigure(diff, diag * 2 - diff);
int x, y;
+
                removeFigure(size - diff - 1, size - diag * 2 + diff - 1);
point(int x = 0, int y = 0): x(x), y(y) {}
+
            }
point &operator++()
+
            else
{
+
            if(left)    //determine position of the bishop on the diagonal
if (y == M - 1)
+
                removeFigure(0, 0);
{
+
            else
++x;
+
                removeFigure(size - 1, size - 1);
y = 0;
+
        }
}
+
        else
else
+
        {
++y;
+
            if(diag > 0)
return *this;
+
            {
}
+
                int diff = left ? 0 : diag * 2;
point operator+(const point &p) const
+
                removeFigure(size - diff - 1, diag * 2 - diff);
{
+
                removeFigure(diff, size - diag * 2 + diff - 1);
return point(x + p.x, y + p.y);
+
            }
}
+
            else
point next() const
+
            if(left)
{
+
                removeFigure(0, size - 1);
point r = *this;
+
            else
return ++r;
+
                removeFigure(size - 1, 0);
}
+
        }
};
+
    }
 
+
    void putBishop(int diag, bool color, bool left) //place bishop
 
+
    {
int *new_array(int n)
+
        if(color)
{
+
        {
int *a = new int[n];
+
            if(diag > 0)
fill(a, a + n, NONE);
+
            {
return a;
+
                int diff = left ? 0 : diag * 2;
}
+
                putFigure(diff, diag * 2 - diff, 'B');
 
+
                putFigure(size - diff - 1, size - diag * 2 + diff - 1, 'B');
// Количество свободных клеток от клетки p до конца доски
+
            }
int rest(const point &p, type t)
+
            else
{
+
            if(left)
int r0 = (M - p.x) * M - p.y, r,
+
                putFigure(0, 0, 'B');
m = M - p.x,
+
            else
s_2 = (m + 1) / 2 * M;
+
                putFigure(size - 1, size - 1, 'B');
switch (t)
+
        }
{
+
        else
case peshka:
+
        {
case kon:
+
            if(diag > 0)
r = s_2; break;
+
            {
case king:
+
                int diff = left ? 0 : diag * 2;
r = s_2 / 2; break;
+
                putFigure(size - diff - 1, diag * 2 - diff, 'B');
case ladya:
+
                putFigure(diff, size - diag * 2 + diff - 1, 'B');
case queen:
+
            }
return m;
+
            else
case slon:
+
            if(left)
r = m + M - 1;
+
                putFigure(0, size - 1, 'B');
}
+
            else
return min(r0, r);
+
                putFigure(size - 1, 0, 'B');
}
+
        }
 
+
    }
// Помечает клетку доски номером i
+
    void swapBishops(int diag, bool color, bool left)   //move pair bishops to another borders
void set(const point &p, type t, int i)
+
    {
{
+
        removeBishop(diag, color, left);
if (t == peshka || t == king || t == kon)
+
        putBishop(diag, color, not(left));
desk[p.x][p.y] = i;
+
    }
else
+
    void figureBefore() //remove one figure from stack and change pointer to the next position after figure was placed
{
+
    {
if (t == ladya || t == queen)
+
        pair<int, int> c = s -> back();
colons[p.y] = rows[p.x] = i;
+
        s -> pop_back();
if (t == slon || t == queen)
+
        x = c.first;
diag_1[p.x+p.y] = diag_2[p.x-p.y+M-1] = i;
+
        y = c.second;
}
+
        removeFigure(x, y);
}
+
        if(++x == size)
 
+
        {
// Можно ли поставить фигуру номер i на клетку p
+
            x = 0;
bool empty(const point &p, type t, int i)
+
            y++;
{
+
        }
const int n_attack[3] = {4, 8, 8};
+
    }
const point attack[3][8] = {{point(1, 1), point(1, -1), point(-1, 1), point(-1, -1)}, //кол-во вариантов атаки для пешки
+
    void clear()   //clear the desk
{point(1, 1), point(1, -1), point(-1, 1), point(-1, -1), point(1, 0), point(-1, 0), point(0, 1), point(0, -1)}, // кол-во вариантов атаки для короля
+
    {
{point(1, 2),point(-1, 2),point(1, -2), point (-1,-2), point (2, 1), point (2,-1), point (-2, 1),point (-2,-1)}};  //количество вариантов атаки для коня
+
        for(int ix = 0; ix < size; ix++)
switch(t)
+
            for(int iy = 0; iy < size; iy++)
{
+
            {
case peshka:
+
                deskFigures[ix][iy] = 0;
case king:
+
                deskOccupy[ix][iy] = 0;
case kon:
+
            }
for (int k = 0; k < n_attack[t]; k++)
+
        x = 0;
{
+
        y = 0;
point q = p + attack[t][k];
+
        if(stackIsUsed)
if (q.x >= 0 && q.x < M && q.y >= 0 && q.y < M && desk[q.x][q.y] < i)
+
            s -> empty();
return false;
+
        f = 0;
}
+
    }
return true;
+
    void show() //show the desk
case ladya:
+
    {
return colons[p.y] > i && rows[p.x] > i;
+
        a++;
case slon:
+
        printf("%i:\n", a);
return diag_1[p.x+p.y] > i && diag_2[p.x-p.y+M-1] > i;
+
        #ifdef windows
case queen:
+
        unsigned background = 4;
return colons[p.y] > i && rows[p.x] > i && diag_1[p.x+p.y] > i && diag_2[p.x-p.y+M-1] > i;
+
        #else
}
+
        printf("\x1b[31m");
}
+
        char background = 47;
 
+
        #endif  //windows
//печатает заданное количество досок на экране
+
        for(int y = 0; y < size; y++)
void print(point **figures, int n_desks, int N, type t, ostream &out = cout)
+
            for(int x = 0; x < size; x++)
 +
            {
 +
                #ifdef windows
 +
                SetConsoleTextAttribute(hCon, background);
 +
                #else
 +
                printf("\x1b[%dm", background);
 +
                #endif  //windows
 +
                if(deskFigures[x][y] == 0)
 +
                    putchar(' ');
 +
                else
 +
                    putchar(deskFigures[x][y]);
 +
                #ifdef windows
 +
                if(x < size - 1)
 +
                    background = background == 4 ? 116 : 4;
 +
                else
 +
                {
 +
                    SetConsoleTextAttribute(hCon, 7);
 +
                    putchar('\n');
 +
                }
 +
                #else
 +
                if(x < size - 1)
 +
                    background = background == 47 ? 40 : 47;
 +
                else
 +
                {
 +
                    printf("\x1b[0m\n");
 +
                    if(y < size - 1)
 +
                        printf("\x1b[31m");
 +
                }
 +
                #endif // windows
 +
            }
 +
    }
 +
};
 +
 
 +
int m = -1; //0 for number of arrangements, 1 for all variants
 +
 
 +
unsigned lookForFigure(int size, int amount, char figure, bool show = true) //brute-force
 
{
 
{
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
+
    desk *d  = new desk(size);
for (int n = 0; n < n_desks; n++)
+
    unsigned ret = 0;
{
+
    while((d -> f > 0)or(d -> cellsLeft() >= amount))
out << " \xdb";
+
        if(not(d -> putNextFree(figure)))
for (int i = 0; i < M * 2 + 2; i++)
+
        {
out << "\xdf";
+
            if(d -> f == amount)
out << "\xdb";
+
            {
}
+
                if(show)
out << endl;
+
                    d -> show();
 +
                ret++;
 +
            }
 +
            d -> figureBefore();
 +
        }
 +
    delete d;
 +
    return ret;
 +
}
  
int *K = new int[n_desks];
+
void lookForKnight(int size, int amount)    //arrangements of knights
fill(K, K + n_desks, 0);
+
{
for (int i = 0; i < M; i++)
+
    if(m == 0)
{
+
    {
for (int n = 0; n < n_desks; n++)
+
        printf("Amount of arrangements: ");
{
+
        if(size == 2)
int &k = K[n];
+
            printf("1\n");
out << " \xdb ";
+
        else
for (int j = 0; j < M; j++)
+
        if(size == 4)
{
+
            printf("6\n");
SetConsoleTextAttribute(hConsole, (i + j) % 2 == 0 ? 0xf0 : 0xf);
+
        else
if (k < N && i == figures[n][k].x && j == figures[n][k].y)
+
            printf("2\n");
{
+
    }
out << ' ' << symbols[t];
+
    else
k++;
+
    {
}
+
        desk *d = new desk(size);
else
+
        if(size == 2)
out << "  ";
+
        {
}
+
            d -> putFigure(0, 0, 'N');
SetConsoleTextAttribute(hConsole, 0x70);
+
            d -> putFigure(0, 1, 'N');
out << " \xdb";
+
            d -> putFigure(1, 0, 'N');
}
+
            d -> putFigure(1, 1, 'N');
out << endl;
+
            d -> show();
}
+
        }
delete[] K;
+
        else
 +
        if(size==4)
 +
            lookForFigure(size, amount, 'N');
 +
        else
 +
        {
 +
            for(int x = 0; x < size; x++)
 +
                for(int y = 0;y < size; y++)
 +
                    if(x + y % 2 == 0)
 +
                        d -> putFigure(x, y, 'N');
 +
            d -> show();
 +
            d -> clear();
 +
            for(int x = 0; x < size; x++)
 +
                for(int y = 0;y < size; y++)
 +
                    if(x + y % 2 == 1)
 +
                        d -> putFigure(x, y, 'N');
 +
            d -> show();
 +
        }
 +
    }
 +
}
  
for (int n = 0; n < n_desks; n++)
+
void lookForBishop(int size, int amount)    //arrangements of bishops
{
+
{
out << " \xdb";
+
    if(m == 0)
for (int i = 0; i < M * 2 + 2; i++)
+
        printf("Amount of arrangements: %u", (unsigned) 1 << size);
out << "\xdc";
+
    else
out << "\xdb";
+
    {
}
+
        desk *d = new desk(size, false);
out << endl << endl;
+
        bool *b = new bool[size];
 +
        for(int dw = 0; dw < size/2; dw++)
 +
        {
 +
            d -> putBishop(dw, true, false);
 +
            d -> putBishop(dw, false, false);
 +
        }
 +
        int p = size - 1;
 +
        for(;;)
 +
        {
 +
            d -> show();
 +
            while(b[p])
 +
            {
 +
                d -> swapBishops(p % (size / 2), p < size / 2, true);
 +
                b[p--] = false;
 +
                if(p < 0)
 +
                    return;
 +
            }
 +
            b[p] = true;
 +
            d -> swapBishops(p % (size / 2), p < size / 2, false);
 +
            p = size - 1;
 +
        }
 +
    }
 
}
 
}
  
// Вывести все возможные расположения на доске N фигур
+
void lookForRook(int size, int amount) //arrangements of rooks
void all_placements(int N, type t)
 
 
{
 
{
desk = NULL;
+
    if(m == 0)
colons = rows = diag_1 = diag_2 = NULL;
+
        printf("Amount of arrangements: %u", fact(size));
// создание необходимых массивов, отмечающих занятость клеток, в зависимости от вида фигуры
+
    else
if (t == peshka || t == king || t == kon)
+
        lookForFigure(size, amount, 'R');
{
+
}
desk = new int*[M];
+
 
for (int j = 0; j < M; j++)
+
void lookForQueen(int size, int amount) //arrangements of queens
desk[j] = new_array(M);
+
{
}
+
    if(m == 0)
else
+
        printf("Amount of arrangements: %u", lookForFigure(size, amount, 'Q', false));
{
+
    else
if (t == ladya || t == queen)
+
        lookForFigure(size, amount, 'Q');
{
+
}
colons = new_array(M);
 
rows = new_array(M);
 
}
 
if (t == slon || t == queen)
 
{
 
diag_1 = new_array(2*M-1);
 
diag_2 = new_array(2*M-1);
 
}
 
}
 
 
const int W = 80 / (2 * M + 5);//количество досок,помещающихся на экране
 
point **figures = new point*[W];//массив фигур
 
for (int j = 0; j < W; j++)
 
figures[j] = new point[N];
 
  
int i = 0, // номер фигуры
+
void lookForKing(int size, int amount) //arrangements of kings
k = 0; //номер комбинации
+
{
while (true)
+
    if(m == 0)
{
+
        printf("Amount of arrangements: %u", lookForFigure(size, amount, 'K', false));
if (rest(figures[k%W][i], t) < N - i) // если оставшиеся фигуры не помещаются на доске
+
    else
{
+
        lookForFigure(size, amount, 'K');
if (i == 0) // если все комбинации закончились
+
}
{
 
// вывод оставшихся досок
 
if (k % W)
 
print(figures, k % W, N, t);
 
cout << "Amount of combinations: " << k << endl;
 
break;
 
}
 
// переходим к предыдущей фигуре и помечаем клетку пустой
 
set(figures[k%W][--i], t, NONE);
 
// сдвигаем фигуру на шаг вперёд
 
++figures[k%W][i];
 
}
 
else if (!empty(figures[k%W][i], t, i)) // если фигуры помещаются, но текущая клетка под ударом
 
// сдвигаем текущую фигуру на шаг вперёд
 
++figures[k%W][i];
 
else if (i == N - 1) // если ставим последнюю фигуру
 
{
 
// если текущая доска - последняя на строке экрана, выводим W досок
 
if ((k + 1) % W == 0)
 
print(figures, W, N, t);
 
// копирование комбинаций фигур на следующую доску
 
for (int j = 0; j < N; j++)
 
figures[(k+1)%W][j] = figures[k%W][j];
 
// переход к следующей доске
 
k++;
 
//сдвигаем текущую фигуру на шаг вперёд
 
++figures[k%W][i];
 
}
 
else // если ставим не последнюю фигуру
 
{
 
// помечаем текущую клетку номером i
 
set(figures[k%W][i], t, i);
 
//ставим следующую фигуру на клетку после текущей
 
figures[k%W][i+1] = figures[k%W][i].next();
 
// переходим к следующей фигуре
 
i++;
 
}
 
}
 
  
//освобождение памяти
+
int main()
for (int j = 0; j < W; j++)
+
{
delete[] figures[j];
+
    int s = -1, f = -1; //s - size, f - figure
delete[] figures;
+
    #ifdef windows
if (desk)
+
    hCon = GetStdHandle(STD_OUTPUT_HANDLE);
{
+
    #endif // windows
for (int j = 0; j < M; j++)
+
    sizeInput:
delete[] desk[j];
+
    printf("Enter size of the desk:\n");
delete[] desk;
+
    scanf("%i", &s);
}
+
    if((s<=0)or(s%2!=0))
if (colons)
+
    {
{
+
        printf("Size must be above 0 and even\n");
delete[] colons;
+
        goto sizeInput;
delete[] rows;
+
    }
}
+
    modeInput:
if (diag_1)
+
    printf("Enter mode:\n\t0: Print amount of results\n\t1: Print all results\n");
{
+
    scanf("%i", &m);
delete[] diag_1;
+
    if((m<0)or(m>1))
delete[] diag_2;
+
    {
}
+
        printf("Mode can be 0 or 1\n");
}
+
        goto modeInput;
 
+
    }
 
+
    figureInput:
int main()
+
    printf("Enter figures to be placed\n\t0: Knight (N)\n\t1: Bishop (B)\n\t2: Rook (R)\n\t3: Queen (Q)\n\t4: King (K)\n");
{
+
    scanf("%i", &f);
system("color 70"); // Установка серого фона и чёрного текста
+
    if((f<0)or(f>4))
while (true)
+
    {
{
+
        printf("Figure number ranges from 0 to 4\n");
cout << "Choose the mode:\n1 - all possible variants of figures' placement\n2 - maximum number of figures which can be placed on the desk\nq - quit\n\n";
+
        goto figureInput;
char c;
+
    }
cin >> c;
+
    switch(f)
cin.ignore(100, '\n');
+
    {
switch (c)
+
        case 0:
{
+
            if(s==2)
case '1':
+
                lookForKnight(s, 4);
case '2':
+
            else
cout << "Enter the desk size please. (The number must be even and not more than 37.)\n";
+
                lookForKnight(s, s *s / 2);
cin >> M;
+
            break;
while (!cin || M % 2 != 0 || M > 37 || M <= 0)
+
        case 1:
{
+
            lookForBishop(s, 2 * s - 2);
cout << "Error: wrong desk size. Try again please.\n";
+
            break;
cin.clear();
+
        case 2:
cin.ignore(100, '\n');
+
            lookForRook(s, s);
cin >> M;
+
            break;
}
+
        case 3:
cin.ignore(100, '\n');
+
            if(s==2)
cout << "Choose a figure, please.\n p - peshka, k - kon, l - ladya, s - slon, Q - Queen, K - King\n";
+
                lookForQueen(s, 1);
char f;
+
            else
cin >> f;
+
                lookForQueen(s, s);
cin.ignore(100, '\n');
+
            break;
type t;
+
        case 4:
int i;
+
            lookForKing(s, (s / 2) * (s / 2));
do
+
            break;
{
+
    }
for (i = 0; i < 6; i++)
+
    return 0;
{
+
}
if (symbols[i] == f)
+
 
{
+
 
t = type(i);
+
 
break;
+
</syntaxhighlight>
}
+
</div>
}
+
 
if (i == 6)
+
 
{
+
'''[[Сенников Иван]]'''
cout << "Enter the right letter, you've chosen the wrong one.\n";
+
 
cin >> f;
+
'''Суть программы:''' Программа позволяет на шахматной доске MxM расставить N фигур K типа всевозможными способами, причем при этом производится расчет максимального количества фигур K типа, которые можно расставить на данной доске MxM.
cin.ignore(100, '\n');
+
 
}
+
'''Идея:''' Шахматная доска представляет собой двумерный динамический массив. С помощью рекурсивного метода программа пробегает по массиву, проверяя клетки доски по всем направлениям на то, атакованы ли они другими фигурами этого типа. В зависимости от количества поставленных фигур изменяется количество итераций. В новую клетку ставиться новая фигура и так до тех пор, пока не выполнится написанное выше условие, после чего начнется обратный ход.
} while (i == 6);
+
 
if (c == '1')
+
'''Инструкция:''' Программа написана в виде меню на английском языке: пользователю будет предоставлена возможность сначала обозначить размер доски, а после выбрать тип фигур и их количество для дальнейшей работы с ними. Комментарии к программе написаны также на английском языке.
{
+
 
cout << "Enter the number of figures please.\n";
+
Ссылка для скачиваний: [http://tm.spbstu.ru/Файлы:Chess_v2.0.zip здесь].
int N;
+
 
cin >> N;
+
'''[[Степанянц Степан]]'''
while (!cin || N <= 0)
+
 
{
+
'''Программа''': 1)Программа получает все возможные варианты расстановок одинаковых фигур на поле боя(шахматной доске) так, чтобы они не смогли бить друг друга.2)Программа выводит максимальное число фигур, которые можно поставить на шахматную доску nxn так, чтобы они не смогли бить друг друга.
cout << "Error: wrong argument. Try again please.\n";
+
 
cin.clear();
+
'''Идея алгоритма''': Функция вызывает саму себя(рекурсия) в рекурсии фигура ставится на небьющуюся клетку и помечаются клетки, которые бьются этой фигурой.Если дальше ставить нельзя, то начинается обратный ход:фигура убирается, и запоминается место, где она стояла, и вновь вызывается функция.
cin.ignore(100, '\n');
+
 
cin >> N;
+
Скачать можно  [http://tm.spbstu.ru/Файл:Шахматы.rar тут].
}
+
 
cin.ignore(100, '\n');
+
<div class="mw-collapsible mw-collapsed" style="width:100%" >
all_placements(N, t);
+
<syntaxhighlight lang="cpp" line start="1" enclose="div">
}
+
#include <iostream>
else
+
#include <vector>
{
+
 
cout << "The maximal number of figures is ";
+
using namespace std;
switch (t)
+
 
{
+
 
case peshka:
+
 
cout << M*M/2; break;
+
//задаю массивы в которых изображены все ходы определенных фигур
case king:
+
int d = 0;
cout << M*M/4; break;
+
int d_knight[2][8] = {{1, 1, -1, -1, 2, 2, -2, -2},
case kon:  
+
    {2, -2, 2, -2, 1, -1, 1, -1}};
cout << (M == 2 ? 4 : M*M/2); break;
+
int d_bish[4][2] = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
case ladya:
+
int d_king[8][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}, {1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
cout << M; break;
+
//Проверяем, не выходим ли мы за поле
case slon:
+
bool ok(int x, int y, int n) {
cout << 2*M - 2; break;
+
    if (x < 0 || y < 0 || x >= n || y >= n)
case queen:
+
        return false;
cout << (M == 2 ? 1 : M);
+
    return true;
}
 
cout << ".\n";
 
}
 
break;
 
case 'q':
 
cout << endl;
 
return 0;
 
default:
 
cout << "You've chosen the wrong command, try again please.\n";
 
}
 
cout << endl << endl;
 
}
 
 
}
 
}
</syntaxhighlight>
 
</div>
 
  
'''[[Савельева Ольга]]'''
+
void print(int n, vector<vector<pair<bool, int> > > board) {
 
+
     for (int i = 0; i < n; i++) {
 
+
         for (int j = 0; j < n; j++) {
'''Инструкция''': В меню указывается два варианта развития событий. Пользователь должен выбрать один из путей: либо максимальное число вариантов, либо посмотреть наглядно на варианты. Человек вводит размер доски и тип фигуры.
+
            cout << ((board[i][j].first) ? " X " : " 0 ");
 
+
        }
Скачать программу можно  [http://tm.spbstu.ru/:File:Шахматы0001.zip    ]
+
        cout << '\n';
 
+
    }
<div class="mw-collapsible mw-collapsed" style="width:100%" >
+
     cout << "-------------------------------------\n";
<syntaxhighlight lang="cpp" line start="1" enclose="div">
+
}
 
+
//Рекурсивная функция
#define windows
+
int func(int n, int k, int count, vector<vector<pair<bool, int> > > board, int ii, int jj, int fig, int task) {
 
+
     int ans = 0;
#include <stdio.h>
+
    if (count == k && !task) {
#include <vector>
+
         print(n, board);
 
+
         return 1;
#ifdef windows
 
#include <windows.h>
 
#endif  // windows
 
 
 
using namespace std;
 
 
 
#ifdef windows
 
HANDLE hCon;
 
#endif // windows
 
 
 
unsigned fact(int n) //factorial of a number
 
{
 
    unsigned long long ret = 1;
 
     for(int i = 2; i <= n; i++)
 
         ret *= i;
 
    return ret;
 
}
 
 
 
struct desk
 
{
 
     char **deskFigures, **deskOccupy;   //desk with figures, desk with occupation counter for each cell
 
    int x, y, size, a, f;  //pointer position(x, y), size of the desk, amount of prints, amount of figures
 
    vector<pair<int, int> > *s; //stack of placed figures
 
    bool stackIsUsed;  //if stack is needed
 
    desk(int size, bool stackIsUsed = true):x(0), y(0), size(size), a(0), f(0), stackIsUsed(stackIsUsed)
 
     {
 
        deskFigures = new char*[size];
 
        for(int i = 0; i < size; i++)
 
            deskFigures[i] = new char[size];
 
        deskOccupy = new char*[size];
 
        for(int i = 0; i < size; i++)
 
            deskOccupy[i] = new char[size];
 
         if(stackIsUsed)
 
            s = new vector<pair<int, int> >;
 
         clear();
 
 
     }
 
     }
     ~desk()
+
     else if(task) {
    {
+
         ans = max(ans, count);
         for(int i = 0; i < size; i++)
 
            delete deskFigures[i];
 
        delete deskFigures;
 
        for(int i = 0; i < size; i++)
 
            delete deskOccupy[i];
 
        delete deskOccupy;
 
        if(stackIsUsed)
 
            delete s;
 
 
     }
 
     }
     void setKnight(int x, int y, int z) //increase all cells occupied by knight at (x, y) on z
+
     for (int i = ii + jj / n; i < n; i++) {
    {
+
         for (int j = jj % n; j < n; j++) {
         if(x + 2 < size)
+
             if (!board[i][j].first && !board[i][j].second) {
        {
+
                switch (fig) {
             if(y - 1 >= 0)
+
                    case 1://конь
                deskOccupy[x + 2][y - 1] += z;
+
                        for (int k = 0; k < 8; k++) {
            if(y + 1 < size)
+
                            if (ok(i + d_knight[0][k], j + d_knight[1][k], n))
                deskOccupy[x + 2][y + 1] += z;
+
                                board[i + d_knight[0][k]][j + d_knight[1][k]].second++;
        }
+
                        }
        if(y + 2 < size)
+
                        break;
        {
+
                    case 2://слон
            if(x - 1 >= 0)
+
                        for (int k = 0; k < n; k++) {
                deskOccupy[x - 1][y + 2] += z;
+
                            for (int l = 0; l < 4; l++) {
            if(x + 1 < size)
+
                                if (ok(i + k * d_bish[l][0], j + k * d_bish[l][1], n))
                deskOccupy[x + 1][y + 2] += z;
+
                                    board[i + k * d_bish[l][0]][j + k * d_bish[l][1]].second++;
        }
+
                            }
        if(x - 2 >= 0)
+
                        }
        {
+
                        break;
            if(y - 1 >= 0)
+
                    case 3: // ладья
                deskOccupy[x - 2][y - 1] += z;
+
                        for (int k = 0; k < n; k++)
            if(y + 1 < size)
+
                            board[i][k].second++, board[k][j].second++;
                 deskOccupy[x - 2][y + 1] += z;
+
                        break;
        }
+
                    case 4: // король
        if(y - 2 >= 0)
+
                        for (int k = 0; k < 8; k++)
        {
+
                            if (ok(i + d_king[k][0], j + d_king[k][1], n))
            if(x - 1 >= 0)
+
                                board[i + d_king[k][0]][j + d_king[k][1]].second++;
                deskOccupy[x - 1][y - 2] += z;
+
                        break;
            if(x + 1 < size)
+
                    case 5: // ферзь
                deskOccupy[x + 1][y - 2] += z;
+
                        for (int k = 0; k < 8; k++)
        }
+
                            for (int l = 0; l < n; l++)
    }
+
                                if (ok(i + l * d_king[k][0], j + l * d_king[k][1], n))
    void setBishop(int x, int y, int z) //increase all cells occupied by bishop at (x, y) on z
+
                                    board[i + l * d_king[k][0]][j + l * d_king[k][1]].second++;
    {
+
                        break;
        for(int ix = 0, iy1 = y - x, iy2 = y + x; ix < size; ix++, iy1++, iy2--)
+
                       
            if(ix != x)
+
                }
            {
+
                //Рекурсия
                if((iy1 >= 0)and(iy1 < size))
+
                board[i][j].first = true;
                    deskOccupy[ix][iy1] += z;
+
                if (!task)
                if((iy2 >= 0)and(iy2 < size))
+
                    ans += func(n, k, count + 1, board, i, j + 1, fig, task);
                    deskOccupy[ix][iy2] += z;
+
              //обратный ход
 +
                else
 +
                    ans = max(ans, func(n, k, count + 1, board, i, j + 1, fig, task));
 +
                 board[i][j].first = false;
 +
                switch (fig) {
 +
                    case 1:
 +
                        for (int k = 0; k < 8; k++) {
 +
                            if (ok(i + d_knight[0][k], j + d_knight[1][k], n))
 +
                                board[i + d_knight[0][k]][j + d_knight[1][k]].second--;
 +
                        }
 +
                        break;
 +
                    case 2:
 +
                        for (int k = 0; k < n; k++) {
 +
                            for (int l = 0; l < 4; l++) {
 +
                                if (ok(i + k * d_bish[l][0], j + k * d_bish[l][1], n))
 +
                                    board[i + k * d_bish[l][0]][j + k * d_bish[l][1]].second--;
 +
                            }
 +
                        }
 +
                        break;
 +
                    case 3:
 +
                        for (int k = 0; k < n; k++)
 +
                            board[i][k].second--, board[k][j].second--;
 +
                        break;
 +
                    case 4:
 +
                        for (int k = 0; k < 8; k++)
 +
                            if (ok(i + d_king[k][0], j + d_king[k][1], n))
 +
                                board[i + d_king[k][0]][j + d_king[k][1]].second--;
 +
                        break;
 +
                    case 5:
 +
                        for (int k = 0; k < 8; k++)
 +
                            for (int l = 0; l < n; l++)
 +
                                if (ok(i + l * d_king[k][0], j + l * d_king[k][1], n))
 +
                                    board[i + l * d_king[k][0]][j + l * d_king[k][1]].second--;
 +
                        break;
 +
                }
 
             }
 
             }
    }
 
    void setRook(int x, int y, int z)  //increase all cells occupied by rook at (x, y) on z
 
    {
 
        for(int i = 0; i < size; i++)
 
        {
 
            if(i != x)
 
                deskOccupy[i][y] += z;
 
            if(i != y)
 
                deskOccupy[x][i] += z;
 
 
         }
 
         }
 +
        jj = 0;
 
     }
 
     }
     void setKing(int x, int y, int z)  //increase all cells occupied by king at (x, y) on z
+
     return ans;
     {
+
}
        for(int ix = x - 1; ix <= x + 1; ix++)
+
//меню
            for(int iy = y - 1; iy <= y + 1; iy++)
+
int main() {
                if((ix >= 0)and(ix < size)and(iy >= 0)and(iy < size)and((ix != 0)or(iy != 0)))
+
     int fig, task;
                    deskOccupy[ix][iy] += z;
+
    int n, k;
 +
    cout << "Please, input the task number: 1 - amount of solutions, 2 - maximum of figures\n";
 +
    cin >> task;
 +
    task--;
 +
    cout << "Please, input figure type: 1 - knight, 2 - bishop, 3 - castle, 4 - king, 5 - queen\n";
 +
    cin >> fig;
 +
    cout << "Please, input the size of the board\n";
 +
    cin >> n;
 +
    if (!task) {
 +
        cout << "Please, input number of figures\n";
 +
        cin >> k;
 
     }
 
     }
     void setFigure(int x, int y, int z, char figure)   //increase all cells occupied by figure
+
     vector<vector<pair<bool, int> > > v = vector<vector<pair<bool, int> > >(n, vector <pair<bool, int> >(n, {false, 0}));
                                                        //and (x, y) on z
+
    cout << func(n, k, 0, v, 0, 0, fig, task);
    {
+
}
        deskOccupy[x][y] += z;
+
</syntaxhighlight>
        switch(figure)
+
</div>
        {
+
 
            case 'N':
+
'''[[Александр Сюрис]]'''
                setKnight(x, y, z);
+
 
                break;
+
Программа работает в двух режимах: поиск максимального числа фигур для заданного поля и количество возможных расстановок заданного числа фигур для заданного поля.
            case 'B':
+
 
                setBishop(x, y, z);
+
'''Алгоритм:''' 
                break;
+
 
            case 'R':
+
#Для поиска количества возможных расстановок заданного числа фигур для заданного поля – Проверяется, возможно ли поставить фигуру в данную клетку, рекурсивно перебирает для каждой клетки поля, как начальной клетки, все варианты расстановки заданного количества  фигур относительно нее и выводит на экран все расстановки, которые подходят условиям.
                setRook(x, y, z);
+
#Для поиска максимального числа фигур для заданного поля –  Проверяется, можно ли поставить одну фигуру, две, три и так далее, пока фигур больше поставить будет нельзя.
                break;
+
 
            case 'Q':
+
Скачать можно  [http://mech.spbstu.ru/File:%D0%A8%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D1%8B(%D0%90%D0%BB%D0%B5%D0%BA%D1%81%D0%B0%D0%BD%D0%B4%D1%80%D0%A1%D1%8E%D1%80%D0%B8%D1%81).zip  тут].
                setBishop(x, y, z);
+
<div class="mw-collapsible mw-collapsed" style="width:100%" >
                setRook(x, y, z);
+
<syntaxhighlight lang="cpp" line start="1" enclose="div">
                break;
+
#include <vector>
            case 'K':
+
#include <iostream>
                setKing(x, y, z);
+
#include <algorithm>
                break;
+
 
        }
+
 
     }
+
using namespace std;
    bool putFigure(int x, int y, char figure)   //place figure on desk and update occupied cells
+
 
    {
+
int n,k, o, m, l, g, maxi, a, sum=0,y, mozno=1;//mozno=1 если можно поставить n фигур
         if(deskFigures[x][y] > 0)
+
vector<vector<int> > matrix;// двухмерный вектор
 +
 
 +
bool ladia(int x, int y) {      //проверка, можно ли в эту клетку поставить ладью
 +
    for(int i = 0; i<n; i++)
 +
        if(matrix[x][i] == 1)
 +
            return false;
 +
     for(int j=0; j<n; j++)
 +
         if(matrix[j][y]==1)
 
             return false;
 
             return false;
        deskFigures[x][y] = figure;
+
    return true;
        if(stackIsUsed)
+
}
             s -> push_back(make_pair(x, y));
+
 
        setFigure(x, y, 1, figure);
+
bool slon(int x, int y) {  //    --//-- слона
        f++;
+
 
 +
  for (int i=x, j=y;i<n && j>=0; i++, j--)
 +
      if(matrix[i][j] == 1)
 +
            return false;
 +
  for (int i=x, j=y;i>=0 && j>=0; i--, j--)
 +
      if(matrix[i][j] == 1)
 +
             return false;
 +
  for (int i=x, j=y;i>=0 && j<n; i--, j++)
 +
      if(matrix[i][j] == 1)
 +
            return false;
 +
  for (int i=x, j=y;i<n && j<n; i++, j++)
 +
      if(matrix[i][j] == 1)
 +
            return false;
 +
 
 +
    return true;
 +
 
 +
}
 +
 
 +
bool fruz(int x, int y){      //    --//-- ферзя
 +
    if(slon(x,y) && ladia(x,y))
 
         return true;
 
         return true;
 +
 +
    return false;
 +
 +
 +
}
 +
 +
bool kon(int x, int y) {  // --//-- коня
 +
 +
  if (x-1>=0 && y-2>=0 && matrix[x-1][y-2]==1)
 +
        return false;
 +
  if (y-2>=0 && x+1<n && matrix[x+1][y-2]==1)
 +
        return false;
 +
  if (x-2>=0 && y-1>=0 && matrix[x-2][y-1]==1)
 +
        return false;
 +
  if (x+2<n && y-1>=0 && matrix[x+2][y-1]==1)
 +
        return false;
 +
  if (x-2>=0 && y+1<n && matrix[x-2][y+1]==1)
 +
        return false;
 +
  if (x+2<n && y+1<n && matrix[x+2][y+1]==1)
 +
        return false;
 +
  if (x-1>=0 && y+2<n && matrix[x-1][y+2]==1)
 +
        return false;
 +
  if (x+1<n && y+2<n && matrix[x+1][y+2]==1)
 +
        return false;
 +
return true;
 +
}
 +
 +
bool king(int x, int y) {  // --//--  короля
 +
 +
    if (x-1>=0 && y-1>=0 && matrix[x-1][y-1]==1)
 +
        return false;
 +
    if (x-1>=0 && matrix[x-1][y]==1)
 +
        return false;
 +
    if (y+1<n && x-1>=0 && matrix[x-1][y+1]==1)
 +
        return false;
 +
    if (y+1<n && matrix[x][y+1]==1)
 +
        return false;
 +
    if (y+1<n && x+1>n && matrix[x+1][y+1]==1)
 +
        return false;
 +
    if (x+1<n && matrix[x+1][y]==1)
 +
        return false;
 +
    if (x+1<n && y-1>=0 && matrix[x+1][y-1]==1)
 +
        return false;
 +
    if (y-1>=0 && matrix[x][y-1]==1)
 +
        return false;
 +
    return true;
 +
 +
}
 +
 +
int mass() {  // вывод доски на экран
 +
 +
for(int i = 0; i<n; i++)
 +
  {
 +
 +
    for(int j = 0; j<n; j++)
 +
        cout<<matrix[i][j]<<" ";
 +
 +
        cout<<endl;
 
     }
 
     }
    int cellsLeft() //amount of cells after pointer
+
 
    {
+
}
        return (size - y) * size - x;
+
 
    }
+
int del() // очистка доски(все нули)
    bool putNextFree(char figure)   //attempt to put figure on the next free(and not occupied) place
+
 
    {
+
for (int i=0; i<n; i++) {
        if(y >= size)
+
 
            return false;
+
    for (int j=0; j<n; j++)
        while(deskOccupy[x][y] > 0)
+
        matrix[i][j]=0;
        {
+
}
            if(++x == size)
+
 
            {
+
}
                if(++y == size)
+
 
                    return false;
+
 
                x = 0;
+
 
            }
+
void vsevarintyrasstavitnfigur(int x,int y)// рекурсивный поиск всех вараинтов расстановок заданнного количества фигур (x - номер фигуры в доске, если ее растянуть в линию, y - кол-во фигур)
        }
+
     if(y==0) {
        return putFigure(x, y, figure);
+
         if (a==1){
    }
+
             mass();
    void removeFigure(int x, int y) //remove figure from (x, y)
+
             cout<<'\n';
     {
+
         }
        if(deskFigures[x][y]!=0)
+
         if(a==2) {
            setFigure(x, y, -1, deskFigures[x][y]);
+
                 mozno = 1; //mozno=1 если можно поставить n фигур
        deskFigures[x][y] = 0;
+
 
        f--;
 
    }
 
    void removeBishop(int diag, bool color, bool left) //remove bishop
 
    {
 
         if(color)  //true - white, false - black
 
        {
 
            if(diag > 0)    //diag - number of diagonal
 
            {
 
                int diff = left ? 0 : diag * 2;
 
                removeFigure(diff, diag * 2 - diff);
 
                removeFigure(size - diff - 1, size - diag * 2 + diff - 1);
 
            }
 
            else
 
            if(left)    //determine position of the bishop on the diagonal
 
                removeFigure(0, 0);
 
            else
 
                removeFigure(size - 1, size - 1);
 
        }
 
        else
 
        {
 
            if(diag > 0)
 
            {
 
                int diff = left ? 0 : diag * 2;
 
                removeFigure(size - diff - 1, diag * 2 - diff);
 
                removeFigure(diff, size - diag * 2 + diff - 1);
 
            }
 
            else
 
            if(left)
 
                removeFigure(0, size - 1);
 
            else
 
                removeFigure(size - 1, 0);
 
        }
 
    }
 
    void putBishop(int diag, bool color, bool left) //place bishop
 
    {
 
        if(color)
 
        {
 
             if(diag > 0)
 
            {
 
                int diff = left ? 0 : diag * 2;
 
                putFigure(diff, diag * 2 - diff, 'B');
 
                putFigure(size - diff - 1, size - diag * 2 + diff - 1, 'B');
 
             }
 
            else
 
            if(left)
 
                putFigure(0, 0, 'B');
 
            else
 
                putFigure(size - 1, size - 1, 'B');
 
         }
 
         else
 
        {
 
            if(diag > 0)
 
            {
 
                 int diff = left ? 0 : diag * 2;
 
                putFigure(size - diff - 1, diag * 2 - diff, 'B');
 
                putFigure(diff, size - diag * 2 + diff - 1, 'B');
 
            }
 
            else
 
            if(left)
 
                putFigure(0, size - 1, 'B');
 
            else
 
                putFigure(size - 1, 0, 'B');
 
        }
 
    }
 
    void swapBishops(int diag, bool color, bool left)  //move pair bishops to another borders
 
    {
 
        removeBishop(diag, color, left);
 
        putBishop(diag, color, not(left));
 
    }
 
    void figureBefore() //remove one figure from stack and change pointer to the next position after figure was placed
 
    {
 
        pair<int, int> c = s -> back();
 
        s -> pop_back();
 
        x = c.first;
 
        y = c.second;
 
        removeFigure(x, y);
 
        if(++x == size)
 
        {
 
            x = 0;
 
            y++;
 
 
         }
 
         }
 +
 +
        return;
 
     }
 
     }
    void clear()    //clear the desk
+
 
     {
+
     for(int i=x;i<n*n;i++){
        for(int ix = 0; ix < size; ix++)
+
 
            for(int iy = 0; iy < size; iy++)
+
        if (o==1)
            {
+
        if(fruz(i/n,i%n) && y>0) {matrix[i/n][i%n]=1; y--;}
                deskFigures[ix][iy] = 0;
+
 
                deskOccupy[ix][iy] = 0;
+
        if (o==2)
            }
+
        if(ladia(i/n,i%n) && y>0) {matrix[i/n][i%n]=1; y--;}
         x = 0;
+
 
         y = 0;
+
        if (o==3)
         if(stackIsUsed)
+
        if(slon(i/n,i%n) && y>0) {matrix[i/n][i%n]=1; y--;}
            s -> empty();
+
 
         f = 0;
+
        if (o==4)
 +
        if(kon(i/n,i%n) && y>0) {matrix[i/n][i%n]=1; y--;}
 +
 
 +
         if (o==5)
 +
        if(king(i/n,i%n) && y>0) {matrix[i/n][i%n]=1; y--;}
 +
 
 +
 
 +
         vsevarintyrasstavitnfigur(i+1, y);
 +
        matrix[i/n][i%n]=0;//удаление фигуры из прошлой клетки для проверки других вариантов
 +
         y++;
 +
 
 +
    }
 +
 
 +
}
 +
 
 +
void maxfig(){  //поиск максимального количества фигур
 +
    int i=0;
 +
while(mozno==1){ //проверяет для данной доски возможность расставить 1,2... фигуры, пока не доходит до количества, которое расставить невозхможно. Тогда это количество фигур -1 - искомая величина
 +
        i++;
 +
         mozno=0;
 +
        vsevarintyrasstavitnfigur(0,i);
 
     }
 
     }
     void show() //show the desk
+
     setlocale(LC_ALL, "Russian");
    {
+
    cout<<"Максимальное количество фигур = "<<i-1<<endl;
        a++;
+
}
        printf("%i:\n", a);
 
        #ifdef windows
 
        unsigned background = 4;
 
        #else
 
        printf("\x1b[31m");
 
        char background = 47;
 
        #endif  //windows
 
        for(int y = 0; y < size; y++)
 
            for(int x = 0; x < size; x++)
 
            {
 
                #ifdef windows
 
                SetConsoleTextAttribute(hCon, background);
 
                #else
 
                printf("\x1b[%dm", background);
 
                #endif  //windows
 
                if(deskFigures[x][y] == 0)
 
                    putchar(' ');
 
                else
 
                    putchar(deskFigures[x][y]);
 
                #ifdef windows
 
                if(x < size - 1)
 
                    background = background == 4 ? 116 : 4;
 
                else
 
                {
 
                    SetConsoleTextAttribute(hCon, 7);
 
                    putchar('\n');
 
                }
 
                #else
 
                if(x < size - 1)
 
                    background = background == 47 ? 40 : 47;
 
                else
 
                {
 
                    printf("\x1b[0m\n");
 
                    if(y < size - 1)
 
                        printf("\x1b[31m");
 
                }
 
                #endif // windows
 
            }
 
    }
 
};
 
  
int m = -1; //0 for number of arrangements, 1 for all variants
 
  
unsigned lookForFigure(int size, int amount, char figure, bool show = true) //brute-force
+
int main() {
{
+
setlocale(LC_ALL, "Russian");
    desk *d  = new desk(size);
+
     g=0;
     unsigned ret = 0;
+
     cout<<"Введите размер доски:"<<endl;
     while((d -> f > 0)or(d -> cellsLeft() >= amount))
+
    cin >>n;
         if(not(d -> putNextFree(figure)))
+
         for(int i=0; i<n; i++) {
        {
+
             vector<int> z;
             if(d -> f == amount)
+
             for(int j=0; j<n; j++){
             {
+
                     z.push_back(0);   //создание вектора z  из n нулей и добавление его к двухмерному вектору
                if(show)
 
                     d -> show();
 
                ret++;
 
 
             }
 
             }
             d -> figureBefore();
+
             matrix.push_back(z);
 
         }
 
         }
    delete d;
 
    return ret;
 
}
 
  
void lookForKnight(int size, int amount)    //arrangements of knights
+
         cout<<"1 - расстановки фигур на доске n*n"<<endl<<"2 - максимум фигур на доске n*n"<<endl;
{
+
          cin>>a;
    if(m == 0)
+
 
    {
+
         while(2>1){
         printf("Amount of arrangements: ");
+
             cout<<" 1 - ферзь"<<endl;
        if(size == 2)
+
             cout<<" 2 - ладья"<<endl;
            printf("1\n");
+
             cout<<" 3 - слон"<<endl;
        else
+
             cout<<" 4 - конь"<<endl;
        if(size == 4)
+
             cout<<" 5 - король"<<endl;
            printf("6\n");
+
             cout<<" 6 - выход"<<endl;
        else
+
 
            printf("2\n");
+
          cout<<"Введите число от 1 до 6:"<<endl;
    }
+
          cin>>o;
    else
+
            mozno=1;
    {
+
            if(o==6) break;
        desk *d = new desk(size);
+
 
         if(size == 2)
+
 
        {
+
 
             d -> putFigure(0, 0, 'N');
+
 
             d -> putFigure(0, 1, 'N');
+
 
             d -> putFigure(1, 0, 'N');
+
 
             d -> putFigure(1, 1, 'N');
+
    if (o==1)   {
             d -> show();
+
                cout<<"Ферзь"<<endl;
        }
 
        else
 
        if(size==4)
 
             lookForFigure(size, amount, 'N');
 
        else
 
        {
 
            for(int x = 0; x < size; x++)
 
                for(int y = 0;y < size; y++)
 
                    if(x + y % 2 == 0)
 
                        d -> putFigure(x, y, 'N');
 
            d -> show();
 
            d -> clear();
 
            for(int x = 0; x < size; x++)
 
                for(int y = 0;y < size; y++)
 
                    if(x + y % 2 == 1)
 
                        d -> putFigure(x, y, 'N');
 
            d -> show();
 
        }
 
    }
 
}
 
  
void lookForBishop(int size, int amount)    //arrangements of bishops
+
            if(a==1)
{
+
                {
    if(m == 0)
+
                    cin>>y;
        printf("Amount of arrangements: %u", (unsigned) 1 << size);
+
                    vsevarintyrasstavitnfigur(0,y);
    else
+
                }
    {
+
 
        desk *d = new desk(size, false);
+
 
        bool *b = new bool[size];
+
             if (a==2)
        for(int dw = 0; dw < size/2; dw++)
+
                 maxfig();
        {
 
            d -> putBishop(dw, true, false);
 
            d -> putBishop(dw, false, false);
 
        }
 
        int p = size - 1;
 
        for(;;)
 
        {
 
             d -> show();
 
            while(b[p])
 
            {
 
                d -> swapBishops(p % (size / 2), p < size / 2, true);
 
                 b[p--] = false;
 
                if(p < 0)
 
                    return;
 
            }
 
            b[p] = true;
 
            d -> swapBishops(p % (size / 2), p < size / 2, false);
 
            p = size - 1;
 
        }
 
    }
 
}
 
  
void lookForRook(int size, int amount)  //arrangements of rooks
+
                }
{
 
    if(m == 0)
 
        printf("Amount of arrangements: %u", fact(size));
 
    else
 
        lookForFigure(size, amount, 'R');
 
}
 
  
void lookForQueen(int size, int amount) //arrangements of queens
 
{
 
    if(m == 0)
 
        printf("Amount of arrangements: %u", lookForFigure(size, amount, 'Q', false));
 
    else
 
        lookForFigure(size, amount, 'Q');
 
}
 
  
void lookForKing(int size, int amount)  //arrangements of kings
 
{
 
    if(m == 0)
 
        printf("Amount of arrangements: %u", lookForFigure(size, amount, 'K', false));
 
    else
 
        lookForFigure(size, amount, 'K');
 
}
 
  
int main()
 
{
 
    int s = -1, f = -1; //s - size, f - figure
 
    #ifdef windows
 
    hCon = GetStdHandle(STD_OUTPUT_HANDLE);
 
    #endif // windows
 
    sizeInput:
 
    printf("Enter size of the desk:\n");
 
    scanf("%i", &s);
 
    if((s<=0)or(s%2!=0))
 
    {
 
        printf("Size must be above 0 and even\n");
 
        goto sizeInput;
 
    }
 
    modeInput:
 
    printf("Enter mode:\n\t0: Print amount of results\n\t1: Print all results\n");
 
    scanf("%i", &m);
 
    if((m<0)or(m>1))
 
    {
 
        printf("Mode can be 0 or 1\n");
 
        goto modeInput;
 
    }
 
    figureInput:
 
    printf("Enter figures to be placed\n\t0: Knight (N)\n\t1: Bishop (B)\n\t2: Rook (R)\n\t3: Queen (Q)\n\t4: King (K)\n");
 
    scanf("%i", &f);
 
    if((f<0)or(f>4))
 
    {
 
        printf("Figure number ranges from 0 to 4\n");
 
        goto figureInput;
 
    }
 
    switch(f)
 
    {
 
        case 0:
 
            if(s==2)
 
                lookForKnight(s, 4);
 
            else
 
                lookForKnight(s, s *s / 2);
 
            break;
 
        case 1:
 
            lookForBishop(s, 2 * s - 2);
 
            break;
 
        case 2:
 
            lookForRook(s, s);
 
            break;
 
        case 3:
 
            if(s==2)
 
                lookForQueen(s, 1);
 
            else
 
                lookForQueen(s, s);
 
            break;
 
        case 4:
 
            lookForKing(s, (s / 2) * (s / 2));
 
            break;
 
    }
 
    return 0;
 
}
 
  
  
  
</syntaxhighlight>
+
    if (o==2)  {
</div>
+
                cout<<endl<<"Ладья"<<endl;
 +
 
 +
                    if(a==1)
 +
                    {
 +
 
 +
                        cin>>y;
 +
                        vsevarintyrasstavitnfigur(0,y);
 +
                    }
 +
 
 +
                    if (a==2)
 +
                        maxfig();
 +
 
 +
                }
 +
 
 +
 
 +
    if (o==3)  {
 +
                cout<<endl<<"Слон"<<endl;
 +
 
 +
                if(a==1)
 +
                    {
 +
                    cin>>y;
 +
                    vsevarintyrasstavitnfigur(0,y);
 +
                    }
 +
 
 +
                    if (a==2)
 +
                    maxfig();
 +
 
 +
                }
  
  
'''[[Козловская Анна]]'''
+
    if (o==4)  {
 +
                cout<<endl<<"Конь"<<endl;
  
'''Краткое описание алгоритма:''' Доска представлена в виде динамического массива[m;m], при выводе на экран пустые клетки обозначаются звездочками,а клетки, заполненные фигурами-буквами(каждая буква соответствует первой букве названия фигуры на английском языке). Для всех фигур написаны алгоритмы проверки на возможность расстановки фигуры. После выбора типа фигуры,используется рекурсивная функция,которая проверяет возможные расстановки через данную функцию проверки ,для данного типа фигуры. Во втором варианте работы программы,она аналитически высчитывает максимально возможное количество заданных фигур на доске.В программу встроена функция,проверяющая доску на повторные и симметричные относительно всех осей симметрии способы расстановки фигур.
+
                if(a==1)
 +
                    {
 +
                    cin>>y;
 +
                    vsevarintyrasstavitnfigur(0,y);
 +
                    }
 +
                    if (a==2)
 +
                    maxfig();
  
'''Инструкция:''' В меню указывается два варианта развития событий. Пользователь должен выбрать один из путей. Он вводит размер доски и тип фигуры и кол-во фигур(для первого типа работы программы).Если он выбирает первый вариант работы программы  - вывод всех различных расстановок N фигур.Другой вариант работы программы максимальное число расстановок- программа выводит их количество.
+
              }
  
Скачать можно  [http://tm.spbstu.ru/File:Chess3.rar тут].
+
    if (o==5)  {
 +
                cout<<"Король"<<endl;
  
 +
                if(a==1)
 +
                {
 +
                    cin>>y;
 +
                    vsevarintyrasstavitnfigur(0,y);
  
'''[[Абрамов Игорь]]'''
+
                }
 +
                if (a==2)
  
'''Алгоритм''': в зависимости от выбранного режима работы, после ввода пользователем необходимой информации о размере поля а также типе расставляемых фигур, запускается основная рекурсивная функция, которая либо подсчитывает все возможные расстановки для заданного числа фигур и выводит их в файл, либо рассчитывает максимально возможное расставляемое число фигур. В первом режиме это происходит путём установки фигуры в свободную клетку и отметки клеток, которые бьются данной фигурой, затем запускается эта же функция для оставшихся клеток и т.д., пока число поставленных фигур не дойдёт до числа, заданного пользователем. Тогда эта расстановка выводится в файл и счётчик числа расстановок увеличивается на единицу. Во втором режиме как только находится расстановка для данного количества фигур, функция завершает свою работу, увеличивается счётчик количества фигур и функция вызывается уже для большего количества фигур, пока не будет найдено максимально возможное расставляемое на данной доске число фигур. 
+
                      maxfig();
  
'''Инструкция''': В меню пользователю предлагается указать размеры доски, тип расставляемых фигур и режим работы программы. После этого, если был выбран режим вывода всех расстановок, необходимо ввести количество расставляемых фигур, после чего программа выведет на экран количество расстановок, а в файле "output.txt" появятся изображения всех расстановок. При выборе второго режима, на экран будет выведено максимальное число фигур заданного типа, которые можно расставить на данной доске.
+
                }
  
Ссылка для скачивания:[http://tm.spbstu.ru/File:Chess_Abramov.rar]
+
            }
 +
}
  
<br>'''[[Нарядчиков Александр]]'''<br>
 
'''Инструкция:''' Запустить программу, следовать указаниям, полученным в меню программы.<br>
 
'''Описание программы:''' Шахматное поле представлено в виде двумерного массив N на M, значения N и M пользователь вводит самостоятельно, память выделяется динамически. Также пользователь выбирает тип и количество фигур на поле. В меню можно выбрать между поиском максимально возможного числа фигур на столе и поиском всех расстановок с дальнейшей записью полей в файл.<br>
 
'''Описание алгоритма:''' При поиске всех расстановок происходит установка выбранной фигуры в свободную клетку, далее происходит маркирование тех клеток, в которые уже невозможно поставить фигуру данного типа, затем процесс происходит снова(рекурсия) пока на поле не окажется выбранное пользователем число фигур. Под конец данное поле записывается в файл и происходит поиск других возможных расстановок данного типа. В конце получаем файл со всеми вариантами расстановок и их количеством. При поиске наибольшего числа фигур на доске программа ищет расстановку для одной фигуры, затем для двух, если это возможно и т.д. С каждым разом происходит увеличение счетчика количества фигур на поле, тем самым в конце данного алгоритма мы получаем максимально возможное число данного типа фигур на доске данного размера.<br>
 
<div class="mw-collapsible mw-collapsed" style="width:100%" >
 
"'''T04CHESS.CPP'''"
 
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 
/* FILENAME: T04CHESS.CPP
 
* LAST UPDATE: 17.01.2016
 
*/
 
  
#include "CHESS.h"
+
</syntaxhighlight>
 +
</div>
  
/* Main function */
+
'''[[Тимошенко Валентина]]'''
int main( void )
 
{
 
// Переменная, отвечающая за выход из меню
 
int IsReady = 1;
 
// Количество строк поля; количество столбцов поля
 
int N, M;
 
// Если идет поиск всех расстановок - 0; если идет поиск максимального числа фигур на доске - 1
 
int IsCount;
 
// Количество фигур на поле
 
int Number;
 
// Тип фигуры; количество разных расстановок; максимальное число фигур на доске
 
int tmp, count, max_value = 1;
 
// Создание указателя на тип FILE
 
FILE *F;
 
  
// Консольное меню
+
'''Краткое описание алгоритма''': доска представлена в виде динамического массива, при выводе на экран пустые клетки обозначаются точками, а клетки, заполненные фигурами, обозначаются буквами (каждая буква соответствует первой букве названия фигуры на английском языке). Для каждой фигуры написаны функции проверки на возможность установки фигуры и функции расстановки. Кроме того, программа аналитически считает максимальное количество фигур для доски заданного пользователем размера и, при наличии команды пользователя, выводит все возможные расстановки рассчитанного максимального количества фигур на экран.
while (IsReady == 1)
 
{
 
cout << "Input figure type:\n1 - castle\n2 - bishop\n3 - knight\n4 - queen\n5 - king\n";
 
cin >> tmp;
 
  
cout << "Input number of rows on the field:\n";
+
'''Инструкция''': при запуске программа предлагает пользователю ввести размер доски, при этом число должно быть четным (если же пользователь вводит нечетное число, программа предлагает ввести размер еще раз, и так до тех пор, пока не будет введено четное число). Далее пользователь выбирает режим работы программы - либо расстановка фигур, либо расчет максимального количества фигур. В режиме расстановки фигур программа предлагает выбрать тип фигуры, выводит максимальное число фигур для доски заданного размера и предлагает ввести желаемое число фигур для расстановки (если оно больше максимального, предлагается повторная попытка ввода). В режиме расчета максимального числа программа предлагает выбрать тип фигуры, выводит рассчитанное число и задает вопрос о необходимости вывода всех возможных расстановок максимального количества для данной фигуры. Оба режима работают (т.е. все запросы повторяются) до тех пор, пока пользователь не даст команду на завершение цикла. Кроме того, в программе есть возможность изменения размера доски после выхода из всех циклов. При положительном ответе пользователя и изменении размера доступны оба режима работы.
cin >> N;
 
  
cout << "Input number of columns on the field:\n";
+
Скачать можно  [http://tm.spbstu.ru/Файл:Chessboard.zip здесь].
cin >> M;
 
  
// Поле шахмат
+
<div class="mw-collapsible mw-collapsed" style="width:100%" >
chess desk(N, M);
+
<syntaxhighlight lang="cpp" line start="1" enclose="div">
  
// Обнуление поля
+
#include <iostream> ///расстановка одинаковых шахматных фигур одного цвета на доске произвольного размера так, чтобы они друг друга не били
desk.Clear();
+
#include <cstring>
 +
#include <cstdlib>
 +
#include <ctime>
  
cout << "Input in what mode do you want to work:\n0 - Searching for all fields variants\n1 - Searching for the maximum number of chessmen\n";
+
using namespace std;
cin >> IsCount;
+
int result_count = 0; ///переменная, в которую закладывается номер варианта расстановки фигур
 +
int N; ///то количество фигур для расстановки, которое задает пользователь
 +
int **Board; ///двумерный массив для отображения шахматной доски
 +
int M; /// размер шахматной доски
  
// Если идет поиск всех расстановок
+
///Функция вывода доски
if (IsCount == 0)
+
void showBoard(string F) ///данная функция отображает доску
{
+
{
cout << "Input number of chessmen on the field:\n";
+
    for(int i = 0; i < M; ++i) /// цикл, прогоняющий значения по строкам
cin >> Number;
+
    {
 +
        for(int j = 0; j < M; ++j)  /// цикл, прогоняющий значения по столбцам
 +
            cout << ((Board[i][j]) ? F : "."); ///заполнение как строки, так и столбца символом, который обозначает позицию на шахматной доске
 +
        cout << endl;                          ///точка - если данная клетка пустая, буква - если в клетке стоит соответствующая фигура
 +
    }
 +
    cout << "Result # " << ++result_count << "\n\n"; ///вывод номера варианта расположения с последующим переходом на новую строку
 +
    return;
 +
}
  
// Создание файла и его открытие
+
///Функции проверки и установки для ферзя
fopen_s(&F, "chess.txt", "wt");
 
if ((type)(tmp + 1) == 2)
 
fputs("Castles' fields:\n", F);
 
else if ((type)(tmp + 1) == 3)
 
fputs("Bishops' fields:\n", F);
 
else if ((type)(tmp + 1) == 4)
 
fputs("Knights' fields:\n", F);
 
else if ((type)(tmp + 1) == 5)
 
fputs("Quenns' fields:\n", F);
 
else if ((type)(tmp + 1) == 6)
 
fputs("Kings' fields:\n", F);
 
else
 
{
 
fputs("Error\n", F);
 
return 0;
 
}
 
// Закрытие файла
 
fclose(F);
 
  
// Количество разных расстановок
+
bool tryQueen(int a, int b) /// проверка на возможность поставить фигуру в данную клетку, a- очередная строка, b- очередной столбец
count = desk.FillField(IsCount, (type)(tmp + 1), 0, 0, Number, 0);
+
{
 
+
    for (int i = 0; i < M; ++i) ///проверка единственности ферзя в строке
// Открытие файла в режиме повторной записи
+
    {
fopen_s(&F, "chess.txt", "at");
+
        if(Board[a][i])
fprintf(F, "\nNumber of fields: %i", count);
+
            return false;
// Закрытие файла
+
    }
fclose(F);
 
  
cout << "Done!\nCheck 'chess.txt' to see results\n";
+
    for(int i = 0; i < M; ++i) ///проверка единственности ферзя в столбце
}
+
    {
 +
        if(Board[i][b])
 +
            return false;
 +
    }
  
// Если идет поиск максимального числа фигур на доске
+
    for(int i = 1; a-i >= 0 && b-i >= 0; ++i)///проверка единственности ферзя по диагонали влево-вверх
else if (IsCount == 1)
+
    {
{
+
        if(Board[a-i][b-i])
while (desk.FillField(IsCount, (type)(tmp + 1), 0, 0, max_value, 0))
+
            return false;
max_value++;
+
    }
cout << "The maximum number of chessmen on the board is " << (max_value - 1) << endl;
 
max_value = 1;
 
}
 
  
// Если было введено некорректное значение для IsCount
+
    for(int i = 1; a+i < M && b+i < M; ++i)///проверка единственности ферзя по диагонали вправо-вниз
else
+
    {
cout << "Error\n";
+
        if(Board[a+i][b+i])
 +
            return false;
 +
    }
  
// Продолжение работы с программой
+
    for(int i = 1; a+i < M && b-i >= 0; ++i)///проверка единственности ферзя по диагонали влево-вниз
cout << "Press '1' if you want to continue\nPress another number if you want to exit\n";
+
    {
cin >> IsReady;
+
        if(Board[a+i][b-i])
 +
            return false;
 +
    }
  
if (IsReady == 1)
+
    for(int i = 1; a-i >= 0 && b+i < M; ++i)///проверка единственности ферзя по диагонали вправо-вверх
continue;
+
    {
else
+
        if(Board[a-i][b+i])
exit(0);
+
            return false;
}
+
    }
 +
 
 +
    return true; ///если в ходе проверки ферзей и угроз не обнаружилось, в данную клетку можно поставить фигуру
 +
}
 +
 
 +
void setQueen(int a, int count) ///функция расстановки ферзей; a - очередная строка, count - счетчик количества фигур, которое необходимо расставить
 +
{
 +
    for(int b = 0; b < M; ++b) ///b - очередной столбец, расстановка идет по строкам
 +
    {
 +
        if(tryQueen(a, b)) ///проверка данной клетки на возможность установки фигуры
 +
        {
 +
            Board[a][b] = 1; ///установка ферзя в первую клетку поля, присваивание ей значения 1 (true)
  
return 0;
+
            for(int i = a + 1; i < M; ++i) ///расстановка указанного пользователем количества фигур
} // End of 'main' function
+
                setQueen(i,count+1);
  
// END OF 'T04CHESS.CPP' FILE
+
            if(count+1 == N) /// если нужное количество фигур поставлено, то
</syntaxhighlight>
+
                showBoard("Q"); /// вызов функции вывода шахматной доски на экран
"'''CHESS.CPP'''"
 
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 
/* FILENAME: CHESS.CPP
 
* LAST UPDATE: 17.01.2016
 
*/
 
  
#include "CHESS.H"
+
            Board[a][b]=0; ///обнуление переменной для установки следующей фигуры в следующую клетку
 +
        }
 +
    }
 +
}
  
// Количество расстановок
+
///Функции проверки и установки для ладьи
int Result_count = 0;
 
  
/* Clear field function */
+
bool tryRook(int a, int b) /// проверка на возможность поставить фигуру в данную клетку, a- очередная строка, b- очередной столбец
// Обнуление поля
 
void chess::Clear( void )
 
 
{
 
{
// Все клетки свободны
+
    for (int i = 0; i < M; ++i) ///проверка единственности ладьи в строке
for (int i = 0; i < N; i++)
+
    {
for (int j = 0; j < M; j++)
+
        if(Board[a][i])
Field[i][j] = Free;
+
            return false;
} // End of 'Clear' function
+
    }
 +
 
 +
    for(int i = 0; i < M; ++i) ///проверка единственности ладьи в столбце
 +
    {
 +
        if(Board[i][b])
 +
            return false;
 +
    }
  
/* Check if the cell is available that function */
+
    return true; ///если в ходе проверки ладей и угроз не обнаружилось, в данную клетку можно поставить фигуру
// Проверка, свободна и существует ли данная клетка
+
}
int chess::IsAvailable( int x, int y )
 
{
 
if (x >= 0 && y >= 0 && x < M && y < N)
 
if (Field[y][x] == Free)
 
  return 1;
 
 
return 0;
 
} // End of 'IsAvailable' function
 
  
/* Output field in file function */
+
void setRook(int a, int count) ///функция расстановки ладей; a - очередная строка, count - счетчик количества фигур, которое необходимо расставить
// Запись одного поля в файл
 
void chess::OutputInFile( void )
 
 
{
 
{
// Создание указателя на тип FILE
+
    for(int b = 0; b < M; ++b) ///b - очередной столбец, расстановка идет по строкам
FILE *F;
+
    {
 +
        if(tryRook(a, b)) ///проверка данной клетки на возможность установки фигуры
 +
        {
 +
            Board[a][b] = 1; ///установка ладьи в первую клетку, присваивание ей значения 1 (true)
  
// Открытие файла в режиме повторной записи
+
            for(int i = a + 1; i < M; ++i) ///расстановка указанного пользователем количества фигур
fopen_s(&F, "chess.txt", "at");
+
                setRook(i,count+1);
  
// Переход на следующую строку файла
+
            if(count+1 == N) /// если нужное количество фигур поставлено, то
fputc('\n', F);
+
                showBoard("R"); /// вызов функции вывода шахматной доски на экран
  
// Заполнение файла текущем полем
+
            Board[a][b]=0; ///обнуление переменной для установки следующей фигуры в следующую клетку
for (int i = 0; i < N; ++i)
+
        }
{
+
    }
// '*' - свободная клетка; '#' - клетка, которая уже занята
+
}
for (int j = 0; j < M; ++j)
 
(Field[i][j] == Free || Field[i][j] == busy) ? fputc('*', F) : fputc('#', F);
 
// Переход на следующую строку файла
 
fputc('\n', F);
 
}
 
  
// Закрытие файла
+
///Функции проверки и установки для слона
fclose(F);
 
} /* End of 'OutputInFile' function */
 
  
/* Copy desks function */
+
bool tryEl(int a, int b) /// проверка на возможность поставить фигуру в данную клетку, a- очередная строка, b- очередной столбец
// Копирование поля
 
void chess::Copy( chess &desk2 )
 
 
{
 
{
  for (int i = 0; i < N; i++)
+
    for(int i = 1; a-i >= 0 && b-i >= 0; ++i)///проверка единственности слона по диагонали влево-вверх
for (int j = 0; j < M; j++)
+
    {
desk2.Field[i][j] = Field[i][j];
+
        if(Board[a-i][b-i])
} // End of 'Copy' function
+
            return false;
 +
    }
  
/* Fill field function */
+
    for(int i = 1; a+i < M && b+i < M; ++i)///проверка единственности слона по диагонали вправо-вниз
// Заполнение полей и поиск максимального числа расстановок
+
    {
// Chessmen_num - количество фигур, которое нужно поставить; Already_stood - количество, которое уже стоит
+
        if(Board[a+i][b+i])
int chess::FillField( int IsCount, type set, int x, int y, int Chessmen_num, int Already_stood )
+
            return false;
{
+
    }
int i, j, k, l;
 
chess desk2(N, M);
 
  
// Обнуление поля
+
    for(int i = 1; a+i < M && b-i >= 0; ++i)///проверка единственности слона по диагонали влево-вниз
desk2.Clear();
+
    {
 +
        if(Board[a+i][b-i])
 +
            return false;
 +
    }
 +
 
 +
    for(int i = 1; a-i >= 0 && b+i < M; ++i)///проверка единственности слона по диагонали вправо-вверх
 +
    {
 +
        if(Board[a-i][b+i])
 +
            return false;
 +
    }
 +
 
 +
    return true; ///если в ходе проверки слонов и угроз не обнаружилось, в данную клетку можно поставить фигуру
 +
}
 +
void setEl(int dia, int count) ///функция расстановки слонов; line - очередная строка, count - счетчик количества фигур, которое необходимо расставить
 +
{
 +
    ///dia - очередная диагональ, которую нужно исследовать на наличие фигуры и угрозы
 +
    int a, b; ///клетка, с которой начинается расстановка, a- очередная строка, b- очередной столбец
  
// Пробег по всем оставшимся клеткам поля, начиная с той, на которой мы закончили предыдущую итерацию
+
    if (dia < M) ///условие, что клеткa данной диагонали лежат на доске
for (i = y; i < N; i++)
+
    {
for (j = ((i == y) ? x : 0); j < M; j++)
+
        a = dia; ///начало отсчёта диагоналей, цикл движется по строке
{
+
        b = 0; ///обнуление переменной для столбца, цикл движется по столбцу
// Если клетка свободна
+
    }
if (Field[i][j] == Free)
+
  else ///если клеткa данной диагонали выходит за размер доски (когда цикл по строке доберется до конца
{
+
    {
// Копируем доску
+
        a = M-1; ///самая последняя диагональ
Copy(desk2);
+
        b =(dia % M)+1; ///соответственно расчёт переменной для столбца этой диагонали
+
    }
// Множественный выбор типа фигуры
+
 
switch (set)
+
    for(int i=0; a-i>=0 && b+i < M; ++i)/// цикл движется по строкам и столбцам снизу слева вправо вверх
{
+
    {
// Ладья
+
        int line = a-i; ///строковая координата данной клетки диагонали
case castle:
+
        int column = b+i; ///столбцовая координата данной клетки диагонали
for (k = 0; k < N; k++)  
+
 
{  
+
        if(tryEl(line, column))/// проверка на единственность слона по диагоналям
// Движение по столбцу
+
        {
if (desk2.Field[k][j] == Free)
+
            Board[line][column]=1; ///установка слона в первую клетку, присваивание ей значения 1 (true)
  desk2.Field[k][j] = busy;  
+
 
// Движение по строке
+
            for(int i = dia + 1; i<2*M-1; ++i) ///расстановка указанного пользователем количества фигур
if (desk2.Field[i][k] == Free)
+
                setEl(i,count+1);
  desk2.Field[i][k] = busy;  
+
 
}
+
            if(count+1 == N) /// если нужное количество фигур поставлено, то
break;
+
                showBoard("E"); /// вызов функции вывода шахматной доски на экран
// Слон
+
 
case bishop:
+
            Board[line][column]=0; ///обнуление переменной для установки следующей фигуры в следующую клетку
// Выбор и поиск наибольшей существующей на поле диагонали
+
        }
for (k = 1 - (N < M ? N : M); k < (N < M ? N : M); k++)
+
    }
{
+
}
// Проход из левого верхнего угла до правого нижнего
+
 
if (IsAvailable(j + k, i + k))
+
///Функции проверки и установки для коня
desk2.Field[i + k][j + k] = busy;
+
 
// Проход из левого нижнего до правого верхнего
+
bool tryHorse(int a, int b) /// проверка на возможность поставить фигуру в данную клетку, a- очередная строка, b- очередной столбец
if (IsAvailable(j + k, i - k))
+
{
desk2.Field[i - k][j + k] = busy;
+
    ///проверка на наличие фигур и угроз во всех 8 точках, которые могут быть под ударом в квадрате 5х5 вокруг установленной фигуры
}
+
 
break;
+
    if ((a-1) >=0 && (b-2)>=0 && Board[a-1][b-2])
// Конь
+
        return false;
case knight:
+
 
// Ходы коня, k - приращение по X, l - по Y
+
    if ((a-1)>=0 && (b+2) < M && Board[a-1][b+2])
k = -2, l = 1;
+
        return false;
// Проверка возможности хода в данную клетку
+
 
if (IsAvailable(j + k, i + l))
+
    if ((a+1) < M && (b-2) >=0 && Board[a+1][b-2])
desk2.Field[i + l][j + k] = busy;
+
        return false;
+
 
k = -2, l = -1;  
+
    if ((a+1) < M && (b+2) < M && Board[a+1][b+2])
// Проверка возможности хода в данную клетку
+
        return false;
if (IsAvailable(j + k, i + l))
+
 
desk2.Field[i + l][j + k] = busy;
+
    if ((a-2) >=0 && (b-1) >=0 && Board[a-2][b-1])
+
        return false;
k = -1, l = 2;  
+
 
// Проверка возможности хода в данную клетку
+
    if ((a-2) >=0 && (b+1) < M && Board[a-2][b+1])
if (IsAvailable(j + k, i + l))
+
        return false;
desk2.Field[i + l][j + k] = busy;
+
 
+
    if ((a+2) < M && (b-1) >= 0 && Board[a+2][b-1])
k = -1, l = -2;  
+
        return false;
// Проверка возможности хода в данную клетку
+
 
if (IsAvailable(j + k, i + l))
+
    if ((a+2) < M && (b+1) < M && Board[a+2][b+1])
desk2.Field[i + l][j + k] = busy;
+
        return false;
+
 
k = 1, l = 2;  
+
    return true; ///если в ходе проверки коней и угроз не обнаружилось, в данную клетку можно поставить фигуру
// Проверка возможности хода в данную клетку
+
}
if (IsAvailable(j + k, i + l))
+
 
desk2.Field[i + l][j + k] = busy;
+
void setHorse(int count, int a, int b) ///функция расстановки коней; a - очередная строка, b - очередной столбец, count - счетчик количества фигур, которое необходимо расставить
+
{
k = 1, l = -2;  
+
    if(count==N) /// если нужное количество фигур поставлено, то
// Проверка возможности хода в данную клетку
+
    {
if (IsAvailable(j + k, i + l))
+
        showBoard("H");  /// вызов функции вывода шахматной доски на экран
desk2.Field[i + l][j + k] = busy;
+
    }
+
 
k = 2, l = 1;  
+
    if (a == M) ///условие необходимо; прогоняет алгоритм по всем строкам
// Проверка возможности хода в данную клетку
+
        return;
if (IsAvailable(j + k, i + l))
+
 
desk2.Field[i + l][j + k] = busy;
+
    for (int j=b; j<M; ++j) ///установка коней в первой строке
+
    {
k = 2, l = -1;  
+
        if(tryHorse(a, j)) ///проверка данной клетки на возможность установки фигуры
// Проверка возможности хода в данную клетку
+
        {
if (IsAvailable(j + k, i + l))
+
            Board[a][j]=1; ///установка коня в первую клетку, присваивание ей значения 1 (true)
desk2.Field[i + l][j + k] = busy;
+
            int line = a, b = j+1; ///смещение в строке на одну позицию вправо, переобозначение строки на line
break;
 
// Ферзь
 
case queen:
 
for (k = 0; k < N; k++)
 
{
 
// Движение по столбцу
 
if (desk2.Field[k][j] == Free)
 
desk2.Field[k][j] = busy;
 
// Движение по строке
 
if (desk2.Field[i][k] == Free)
 
desk2.Field[i][k] = busy;
 
}
 
 
// Выбор и поиск наибольшей существующей на поле диагонали
 
for (k = 1 - (N < M ? N : M); k < (N < M ? N : M); k++)
 
{
 
// Проход из левого верхнего угла до правого нижнего
 
if (IsAvailable(j + k, i + k))
 
desk2.Field[i + k][j + k] = busy;
 
// Проход из левого нижнего до правого верхнего
 
if (IsAvailable(j + k, i - k))
 
desk2.Field[i - k][j + k] = busy;
 
}
 
break;
 
// Король
 
case king:
 
  // Проход по квадрату 3 на 3, построенному центром на клетке, в которой стоит король
 
for (k = -1; k < 2; k++)
 
for (l = -1; l < 2; l++)
 
if (IsAvailable(j + k, i + l))
 
desk2.Field[i + l][j + k] = busy;
 
break;
 
}
 
// Установка фигуры в данную клетку
 
desk2.Field[i][j] = set;
 
       
 
// Проверяем, что количество поставленных фигур, которое равно номеру итерации, меньше чем необходимое число фигур
 
if ((Already_stood + 1) < Chessmen_num)
 
{
 
// Если идет поиск всех расстановок, то запускаем следующий шаг
 
if (IsCount == 0)
 
desk2.FillField(IsCount, set, j, i, Chessmen_num, Already_stood + 1);
 
// Если идет поиск максимального числа фигур на доске и была найдена хотя бы одна расстоновка, то возвращаем 1
 
else if ((IsCount == 1) && desk2.FillField(IsCount, set, j, i, Chessmen_num, Already_stood + 1))
 
return 1;
 
}
 
  
// Если количество поставленных фигур равно необходимому числу фигур
+
            if (b == M) ///если данный столбец - самый крайний
else if ((Already_stood + 1) == Chessmen_num)
+
            {
{
+
                b = 0; ///обнуление переменной, чтобы использовать ее при заполнении следующей строки
// Если идет поиск всех расстановок, то увеличиваем количество расстоновок на одну и записываем поле в файл 
+
                line++;     ///то переход на следующую строку и дальнейшее ее заполнение
if (IsCount == 0)
+
            }
{
+
            setHorse(count+1,line,b); ///установка фигуры, увеличение счетчика
Result_count++;
+
            Board[a][j]=0; ///обнуление переменной для установки следующей фигуры в следующую клетку
  desk2.OutputInFile();
+
        }
}
+
    }
// Если идет поиск максимального числа фигур на доске, значит расстановка существует, возвращаем 1
 
else if (IsCount == 1)
 
return 1;
 
  }
 
}
 
}
 
// Если идет поиск всех расстановок, то возвращаем количество расстановок
 
if (IsCount == 0)
 
  return Result_count;
 
// Если идет поиск максимального числа фигур на доске, то возвращаем 0
 
else if (IsCount == 1)
 
  return 0;
 
} // End of 'FillField' function
 
  
// END OF 'CHESS.CPP' FILE
+
    for(int i=a+1; i<M; ++i) ///дальнейшее заполнение оставшихся строк
</syntaxhighlight>
+
    {
"'''CHESS.H'''"
+
        for (int j=0; j<M; ++j)
<syntaxhighlight lang="cpp" line start="1" enclose="div">
+
        {
/* FILENAME: CHESS.H
+
            if(tryHorse(i, j)) ///проверка данной клетки на возможность установки фигуры
* LAST UPDATE: 17.01.2016
+
            {
*/
+
                Board[i][j]=1; ///установка коня в первую клетку, присваивание ей значения 1 (true)
 +
                int line = i, b = j+1; ///смещение в строке на одну позицию вправо
  
#ifndef __CHESS_H_
+
                if (b == M) ///если данный столбец - самый крайний
#define __CHESS_H_
+
                {
 +
                    b = 0;
 +
                    line++;  ///то переход на следующую строку и дальнейшее ее заполнение
 +
                }
 +
                setHorse(count+1,line,b); ///установка фигуры, увеличение счетчика
 +
                Board[i][j]=0;  ///обнуление переменной для установки следующей фигуры в следующую клетку
 +
            }
 +
        }
 +
    }
 +
}
 +
 
 +
///для короля
 +
 
 +
bool tryKing(int a, int b) /// проверка на возможность поставить фигуру в квадрате 3х3, a- очередная строка, b- очередной столбец
 +
{
 +
///проверка на наличие фигур и угроз во всех 8 точках, которые могут быть под ударом в квадрате 3х3 вокруг установленной фигуры
 +
 
 +
    for(int i = a-1; i <= a+1; ++i) ///проверка по строкам
 +
    {
 +
        for(int j = b-1; j <= b+1; ++j) ///проверка по столбцам
 +
        {
 +
            if (a>=0 && a < M && b>=0 && b < M && Board[a][b]) ///условие наличия клетки в пределах доски
 +
                return false;
  
#include <iostream>
+
            if ((a+1) < M && (b-1) >=0 && Board[a+1][b-1])
#include <conio.h>
+
                return false;
  
using namespace std;
+
            if ((a+1) < M && Board[a+1][b])
 +
                return false;
  
// свободен, занят, ладья, слон, конь, ферзь, король
+
            if ((a+1) < M && (b+1) < M && Board[a+1][b+1])
enum type { Free, busy, castle, bishop, knight, queen, king };
+
                return false;
  
/* Chess class */
+
            if ((b+1) < M && Board[a][b+1])
class chess
+
                return false;
{
+
 
private:
+
            if ((a-1)>=0 && (b+1) < M && Board[a-1][b+1])
// Поле данных фигур
+
                return false;
type **Field;
+
 
// Количество строк поля; количество столбцов поля
+
            if ((a-1) >=0 && Board[a-1][b])
int N, M;
+
                return false;
public:
 
/* Default constructor */
 
chess( void )
 
{
 
N = 8, M = 8;
 
 
// Выделение памяти под массив поля
 
Field = new type*[N];
 
for (int i = 0; i < N; i++)
 
Field[i] = new type[M];
 
}
 
 
/* Class constructor */
 
chess( int _N, int _M ) : N(_N), M(_M)
 
{
 
// Выделение памяти под массив поля
 
Field = new type* [N];
 
for (int i = 0; i < N; i++)
 
Field[i] = new type [M];
 
}
 
  
/* Class destructor */
+
            if ((a-1) >=0 && (b-1)>=0 && Board[a-1][b-1])
~chess( void )
+
                return false;
{
 
// Чистка памяти
 
for (int i = 0; i < N; i++)
 
delete[] Field[i];
 
delete[] Field;
 
}
 
  
/* Clear field function */
+
            if ((b-1) >= 0 && Board[a][b-1])
void Clear( void );
+
                return false;
+
        }
/* Check if the cell is available that function */
+
    }
int IsAvailable( int x, int y );
 
 
/* Output field in file function */
 
void OutputInFile( void );
 
 
/* Copy desks function */
 
void Copy( chess& desk2 );
 
 
/* Fill field function */
 
int FillField ( int IsCount, type set, int x, int y, int Chessmen_num, int Already_stood);
 
}; // end of 'chess' class
 
  
#endif /*__CHESS_H_ */
+
    return true; ///если в ходе проверки королей и угроз не обнаружилось, в данную клетку можно поставить фигуру
 +
}
  
// END OF 'CHESS.H' FILE
+
void setKing (int count, int a, int b) ///функция расстановки коней; a - очередная строка, b - очередной столбец, count - счетчик количества фигур, которое необходимо расставить
</syntaxhighlight>
 
</div>
 
[http://tm.spbstu.ru/File:T04CHESS.7z Скачать архив]
 
<br>
 
 
 
 
 
'''[[Рубинова Раиса]]'''
 
 
 
'''Основная идея программы''': программа позволяет выводить на экран всевозможные расстановки n однотипных фигур на шахматной доске размером n*n так, чтобы ни одна из фигур не била другую.
 
 
 
Скачать можно  [http://tm.spbstu.ru/File:Mode.rar тут].
 
 
 
<div class="mw-collapsible mw-collapsed" style="width:100%" >
 
<syntaxhighlight lang="cpp" line start="1" enclose="div">
 
#include <iostream>
 
 
 
int S; /// Переменная отвечающая за размер доски.
 
 
 
int **B; /// Двумерный массив, отображающий шахматную доску.
 
int R = 0; /// Количество решений.
 
int var, varf, Number,n,l=0; /// Переменные, отвечающие за выбор пользователя и за количество фигур, которые нужно расставить.
 
 
 
using namespace std;
 
 
 
 
 
void NewMas()
 
 
{
 
{
    B = new int *[S];
+
     for (int j=b; j<M; ++j) ///установка королей в первой строке
     for (int i=0; i<S; ++i)
 
 
     {
 
     {
         B[i]= new int [S];
+
         if(tryKing(a, j)) ///проверка данной клетки на возможность установки фигуры
    }
 
    for (int i=0; i<S; ++i)
 
    {
 
        for (int k=0; k<S; ++k)
 
 
         {
 
         {
             B[i][k]=0;
+
             Board[a][j]=1; ///проверка данной клетки на возможность установки фигуры
 +
            setKing(count+1,a,j); ///расстановка фигур в первой строке
 +
            Board[a][j]=0; ///обнуление переменной для установки следующей фигуры в следующую клетку
 
         }
 
         }
 
     }
 
     }
}
 
  
void showBoard() /// Функция, которая выводит на экран доску с.
+
     for(int i=a+1; i<M; ++i) ///установка фигур в оставшуюся часть шахматной доски по строкам
{
 
     for (int a=0; a<S; ++a)
 
 
     {
 
     {
         for (int b=0; b<S; ++b)
+
         for (int j=0; j<M; ++j)
 
         {
 
         {
             cout << B[a][b] << " ";
+
             if(tryKing(i, j)) ///проверка данной клетки на возможность установки фигуры
 +
            {
 +
                Board[i][j]=1; ///проверка данной клетки на возможность установки фигуры
 +
                setKing(count+1,i,j); ///расстановка фигур
 +
                Board[i][j]=0;  ///обнуление переменной для установки следующей фигуры в следующую клетку
 +
            }
 
         }
 
         }
        cout << '\n';
 
 
     }
 
     }
}
 
  
bool checkQ (int a, int b)
+
     if(count==N) /// если нужное количество фигур поставлено, то
{
 
     for(int i=0; i<a; ++i)     /// Проверка столбца, в который мы хотим поставить ферзя;
 
 
     {
 
     {
         if(B[i][b])
+
         showBoard("K");/// вызов функции вывода шахматной доски на экран
         {
+
         return;
            return false;
 
        }
 
 
     }
 
     }
    for(int i=1; i<=a&&b-i>=0; ++i)    /// Проверка диагонали влево-вверх;
 
    {
 
        if(B[a-i][b-i])
 
        {
 
            return false;
 
        }
 
    }
 
 
    for(int i=1; i<=a&&b+i<S; i++)      /// Проверка диагонали вправо-вверх;
 
    {
 
        if(B[a-i][b+i])
 
        {
 
            return false;
 
        }
 
    }
 
    return true;
 
 
}
 
}
  
bool checkR (int a, int b)
+
int main()
 
{
 
{
     for(int i=0; i<a; ++i)     /// Проверка столбца, в который мы хотим поставить ладью;
+
     char s; ///переменная, будет использована в цикле
 +
    do     /// цикл, выводящий на экран данные в зависимости от введенных пользователем значений переменных
 
     {
 
     {
         if(B[i][b])
+
         do ///цикл для считывания введенного пользователем размера доски
 
         {
 
         {
             return false;
+
             cout << "Input the size of the board: " << endl; ///ввод размера доски
        }
+
            cin >> M;
    }
+
 
    return true;
+
            if ( (M%2) == 1) ///цикл, работающий только в том случае, если пользователь введет нечетное число
}
+
            {
 +
                cout << '\n' << "The number must be even, so try to input the size again" << '\n' << endl;
 +
            }
  
bool checkE (int a, int b)
 
{
 
    for(int i=1; i<=a&&b-i>=0; ++i)    /// Проверка диагонали влево-вверх;
 
    {
 
        if(B[a-i][b-i])
 
        {
 
            return false;
 
 
         }
 
         }
    }
+
        while (M%2 !=0); ///пока пользователь не введет допуcтимое число, цикл не прерывается
 +
 
 +
        Board = new int*[M];  ///создание двумерного массива для отображения шахматной доски
 +
        for (int i = 0; i<M; i++)
 +
            Board[i] = new int[M]; ///создание первую строку доски
 +
        for (int i = 0; i<M; i++)
 +
            for (int j = 0; j<M; j++)
 +
                Board[i][j] = 0;  ///зануление массива
 +
 
 +
        int V; ///пользователь выбирает один из двух вариантов работы программы
 +
        cout << '\n' << "Input your choice: 1=placing of figures, 2=for max amount of figures" << endl;
 +
        cin >> V;
  
    for(int i=1; i<=a&&b+i<S; i++)       /// Проверка диагонали вправо-вверх;
+
        if (V==1) ///цикл, расставляющий фигуры по введенным пользователем данным
    {
 
        if(B[a-i][b+i])
 
 
         {
 
         {
             return false;
+
             char k; ///переменная, будет использована в цикле
        }
+
            do      /// цикл, выводящий на экран данные в зависимости от введенных пользователем значений переменных
    }
+
            {
    return true;
+
                int T; ///пользователь выбирает фигуру
}
+
                cout << '\n' << "Input type of figure: 1-queen, 2-king, 3-horse, 4-rook, 5-elephant"<< endl;
 +
                cin >> T;
  
bool checkH (int a, int b)
+
                int maximum; ///переменная, хранящая максимальное количество фигур, которое можно расставить на заданной доске
{
+
                if (T==1) ///максимальное количество фигур на заданной доске для ферзя
if (((b+2)<S)&&((a+1)<S)&&(B[a+1][b+2]))
+
                {
    {
+
                    maximum=M;
        return false;
+
                    cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
    }
+
                }
if (((b-2)>=0)&&((a+1)<S)&&(B[a+1][b-2]))
+
                if (T==2) ///максимальное количество фигур на заданной доске для короля
    {
+
                {
        return false;
+
                    maximum=0.25*M*M;
    }
+
                    cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
if (((a-1)>=0)&&((b+2)<S)&&(B[a-1][b+2]))
+
                }
    {
+
                if (T==3) ///максимальное количество фигур на заданной доске для коня
        return false;
+
                {
    }
+
                    maximum=0.5*M*M;
if (((a-1)>=0)&&((b-2)>=0)&&(B[a-1][b-2]))
+
                    cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
    {
+
                }
        return false;
+
                if (T==4) ///максимальное количество фигур на заданной доске для ладьи
    }
+
                {
if (((a+2)<S)&&((b+1)<S)&&(B[a+2][b+1]))
+
                    maximum=M;
    {
+
                    cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
        return false;
+
                }
    }
+
                if (T==5) ///максимальное количество фигур на заданной доске для слона
if (((a+2)<S)&&((b-1)>=0)&&(B[a+2][b-1]))
+
                {
    {
+
                    maximum=2*M-2;
        return false;
+
                    cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
    }
+
                }
if (((a-2)>=0)&&((b+1)<S)&&(B[a-2][b+1]))
 
    {
 
        return false;
 
    }
 
if (((a-2)>=0)&&((b-1)>=0)&&(B[a-2][b-1]))
 
    {
 
        return false;
 
    }
 
        return true;
 
}
 
  
bool checkK (int a, int b)
+
                do ///цикл, считывающий количество фигур, заданное пользователем
{
+
                {
    if (((a+1)<S)&&((b+1)<S)&&(B[a+1][b+1]))
+
                    cout << "Input the amount of figures, it must be less than max amount or equals that" << endl;
    {
+
                    cin >> N;
        return false;
+
                }
    }
+
                while (N>maximum);   ///пока пользователь не введет допуcтимое число, цикл не прерывается
if (((a+1)<S)&&(B[a+1][b]))
 
    {
 
        return false;
 
    }
 
if (((a+1)<S)&&((b-1)>=0)&&(B[a+1][b-1]))
 
    {
 
        return false;
 
    }
 
if (((a-1)>=0)&&((b-1)>=0)&&(B[a-1][b-1]))
 
    {
 
        return false;
 
    }
 
if (((a-1)>=0)&&((b+1)<S)&&(B[a-1][b+1]))
 
    {
 
        return false;
 
    }
 
if (((a-1)>=0)&& (B[a-1][b]))
 
    {
 
        return false;
 
    }
 
if (((a+1)<S)&&(B[a][b+1]))
 
    {
 
        return false;
 
    }
 
if (((a-1)>=0)&&(B[a][b-1]))
 
    {
 
        return false;
 
    }
 
        return true;
 
}
 
  
 +
                cout << '\n' << "All possible variants for this amount of figures on this board:" << '\n' << endl;
  
void Queen(int a) /// a - номер очередной строки в которую нужно поставить очередного ферзя.
+
                if (T==1) ///цикл, вызывающий на экран все варианты расстановки заданного пользователем числа фигур для ферзя
{
+
                {
    if(a==S)
+
                    result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
    {
+
                    for (int i=0; i <M; ++i)
        showBoard();
+
                        setQueen(i,0);
        std::cout << ++R << "\n\n";
+
                }
        return;
+
                if (T==2) ///цикл, вызывающий на экран все варианты расстановки заданного пользователем числа фигур для короля
    }
+
                {
    for(int i=0; i<Number; ++i)
+
                    result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
    {
+
                    setKing(0,0,0);
        if(checkQ(a, i))
+
                }
        {
+
                if (T==3) ///цикл, вызывающий на экран все варианты расстановки заданного пользователем числа фигур для коня
            B[a][i] = 1;
+
                {
            Queen(a+1);
+
                    result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
             B[a][i] = 0;
+
                    setHorse(0,0,0);
 +
                }
 +
                if (T==4) ///цикл, вызывающий на экран все варианты расстановки заданного пользователем числа фигур для ладьи
 +
                {
 +
                    result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
 +
                    for (int i=0; i <M; ++i)
 +
                        setRook(i,0);
 +
                }
 +
                if (T==5) ///цикл, вызывающий на экран все варианты расстановки заданного пользователем числа фигур для слона
 +
                {
 +
                    result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
 +
                    for(int i = 0; i<2*M-1; ++i)
 +
                        setEl(i,0);
 +
                }
 +
 
 +
                cout << '\n' << "If you want continue placing figures, input +, if not, input -" << endl;
 +
                cin >> k;
 +
             }
 +
            while (k != '-'); ///цикл работает до тех пор, пока пользователь не даст команду на его завершение
 
         }
 
         }
    }
 
    return;
 
}
 
  
void Rook (int a)
+
        else if (V==2) ///цикл, вычисляющий максимальное количество фигур по введенным пользователем данным
{
 
    if(a==S)
 
    {
 
        showBoard();
 
        std::cout << ++R << "\n\n";
 
        return;
 
    }
 
    for(int i=0; i<Number; ++i)
 
    {
 
        if(checkR(a, i))
 
 
         {
 
         {
             B[a][i] = 1;
+
             char z; ///переменная, будет использована в цикле
            Rook(a+1);
+
            do      /// цикл, выводящий на экран данные в зависимости от введенных пользователем значений переменных
            B[a][i] = 0;
+
            {
        }
+
                int T; ///переменная для выбора фигуры пользователем
    }
+
                cout << '\n' << "Input type of figure: 1-queen, 2-king, 3-horse, 4-rook, 5-elephant"<< endl;
    return;
+
                cin >> T;
}
+
                char d;  ///переменная, будет использована в циклах
 +
                int maximum; ///переменная, хранящая максимальное количество фигур, которое можно расставить на заданной доске
 +
                if (T==1) ///максимальное количество фигур на заданной доске для ферзя
 +
                {
 +
                    maximum=M; ///формула расчёта максимального количества фигур для заданной доски
 +
                    cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
 +
                    cout << "If you want to see all locations of max amount, input +, if not, input -" << endl;
 +
                    cin >> d;
 +
                    cout << '\n' << "All possible variants for this amount of figures on this board:" << '\n' << endl;
 +
                    if (d=='+') ///по выбору пользователя вывод всех возможных расстановок для максимального количества для данной фигуры
 +
                    {
 +
                        result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
 +
                        N=maximum; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
 +
                        for (int i=0; i < M; ++i)
 +
                            setQueen(i,0);
 +
                    }
  
void Elephant (int a)
+
                }
{
+
                if (T==2) ///максимальное количество фигур на заданной доске для короля
    if(a==S)
+
                {
    {
+
                    maximum=0.25*M*M; ///формула расчёта максимального количества фигур для заданной доски
        showBoard();
+
                    cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
        std::cout << ++R << "\n\n";
+
                    cout << "If you want to see all locations of max amount, input +, if not, input -" << endl;
        return;
+
                    cin >> d;
    }
+
                    cout << '\n' << "All possible variants for this amount of figures on this board:" << '\n' << endl;
    for(int i=0; i<Number; ++i)
+
                    if (d=='+') ///по выбору пользователя вывод всех возможных расстановок для максимального количества для данной фигуры
    {
+
                    {
        if(checkE(a, i))
+
                        result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
        {
+
                        N=maximum; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
            B[a][i] = 1;
+
                        setKing(0,0,0);
            Elephant(a+1);
+
                    }
            B[a][i] = 0;
+
                }
        }
+
                if (T==3) ///максимальное количество фигур на заданной доске для коня
    }
+
                {
    return;
+
                    maximum=0.5*M*M; ///формула расчёта максимального количества фигур для заданной доски
}
+
                    cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
 
+
                    cout << "If you want to see all locations of max amount, input +, if not, input -" << endl;
void Horse (int a, int i)
+
                    cin >> d;
{
+
                    cout << '\n' << "All possible variants for this amount of figures on this board:" << '\n' << endl;
    if(a==S)
+
                    if (d=='+') ///по выбору пользователя вывод всех возможных расстановок для максимального количества для данной фигуры
    {
+
                    {
        showBoard();
+
                        result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
        std::cout << ++R << "\n\n";
+
                        N=maximum; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
        return;
+
                        setHorse(0,0,0);
    }
+
                    }
    for(int i=0; i<Number; ++i)
+
                }
    {
+
                if (T==4) ///максимальное количество фигур на заданной доске для ладьи
         if(checkH(a, i))
+
                {
 +
                    maximum=M; ///формула расчёта максимального количества фигур для заданной доски
 +
                    cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
 +
                    cout << "If you want to see all locations of max amount, input +, if not, input -" << endl;
 +
                    cin >> d;
 +
                    cout << '\n' << "All possible variants for this amount of figures on this board:" << '\n' << endl;
 +
                    if (d=='+') ///по выбору пользователя вывод всех возможных расстановок для максимального количества для данной фигуры
 +
                    {
 +
                        result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
 +
                        N=maximum; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
 +
                        for (int i=0; i <M; ++i)
 +
                            setRook(i,0);
 +
                    }
 +
                }
 +
                if (T==5) ///максимальное количество фигур на заданной доске для слона
 +
                {
 +
                    maximum=2*M-2; ///формула расчёта максимального количества фигур для заданной доски
 +
                    cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
 +
                    cout << "If you want to see all locations of max amount, input +, if not, input -" << endl;
 +
                    cin >> d;
 +
                    cout << '\n' << "All possible variants for this amount of figures on this board:" << '\n' << endl;
 +
                    if (d=='+') ///по выбору пользователя вывод всех возможных расстановок для максимального количества для данной фигуры
 +
                    {
 +
                        result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
 +
                        N=maximum; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
 +
                        for(int i = 0; i<2*M-1; ++i)
 +
                            setEl(i,0);
 +
                    }
 +
                }
 +
 
 +
                cout << '\n' << "If you want continue counting, input +, if not, input -" << '\n' << endl;
 +
                cin >> z;
 +
            }
 +
            while (z != '-'); ///цикл работает до тех пор, пока пользователь не даст команду на его завершение
 +
        }
 +
        cout << '\n' << "If you want to change the size of board, input +, if not, input -" << endl;
 +
        cin >> s;
 +
         if (s=='-')
 
         {
 
         {
             B[a][i] = 1;
+
             cout << '\n' << "The program is finished." << '\n' << endl; ///вывод на экран сообщения о завершении работы программы
            Horse(a+1, i);
 
            B[a][i] = 0;
 
 
         }
 
         }
 
     }
 
     }
     return;
+
     while (s != '-'); ///цикл работает до тех пор, пока пользователь не даст команду на его завершение, а также на завершение всей программы
}
 
 
 
void King (int a, int i)
 
{
 
    if(i==S)
 
    {
 
        showBoard();
 
        std::cout << ++R << "\n\n";
 
        return;
 
    }
 
    if(a==S)
 
    {
 
        showBoard();
 
        std::cout << ++R << "\n\n";
 
        return;
 
    }
 
    for(int a=0; a<Number; ++a)
 
    {
 
        if(checkK(a, i))
 
        {
 
            B[a][i] = 1;
 
            King(a, i+1);
 
            B[a][i] = 0;
 
        }
 
    }
 
    return;
 
}
 
int main()
 
{
 
    cout << "Welcome! Enter the size of the board" << endl;
 
    cin >> S;
 
    NewMas();
 
    cout << "What do you want to do: see all variants for max number (enter 1) or for your number (enter 2)" << endl;
 
    cin >> var;
 
    cout << "Choose the figure (1-queen; 2-rook; 3-elephant; 4-horse; 5-king)" << endl;
 
    cin >> varf;
 
    if ((var==1)&&(varf==1))
 
    {
 
        Number=S;
 
        Queen(0);
 
        return 0;
 
    }
 
    if ((var==1)&&(varf==2))
 
    {
 
        Number=S;
 
        Rook(0);
 
        return 0;
 
    }
 
    if ((var==1)&&(varf==3))
 
    {
 
        Number=S;
 
        Elephant(0);
 
        return 0;
 
    }
 
    if ((var==1)&&(varf==4))
 
    {
 
        Number=S;
 
        Horse(0,0);
 
        return 0;
 
    }
 
    if ((var==1)&&(varf==5))
 
    {
 
        Number=S;
 
        King(0,0);
 
        return 0;
 
    }
 
    if (var==2)
 
    {
 
        cout << "Enter the number of figures" << endl;
 
        cin >> n;
 
        if (varf==1)
 
        {
 
            Number=n;
 
            Queen(0);
 
            //if (i==n) {showBoard();}
 
            return 0;
 
        }
 
        if (varf==2)
 
        {
 
            Number=n;
 
            Rook(0);
 
            return 0;
 
        }
 
        if (varf==3)
 
        {
 
            Number=n;
 
            Elephant(0);
 
            return 0;
 
        }
 
        if (varf==4)
 
        {
 
            Number=n;
 
            Horse(0,0);
 
            return 0;
 
        }
 
        if (varf==5)
 
        {
 
            Number=n;
 
            King(0,0);
 
            return 0;
 
        }
 
    }
 
    return 0;
 
 
}
 
}
 
  
 
</syntaxhighlight>
 
</syntaxhighlight>
 
</div>
 
</div>
 
  
 
'''[[Уманский Александр]]'''
 
'''[[Уманский Александр]]'''
Строка 5068: Строка 5158:
  
 
Скачать можно  [http://mech.spbstu.ru/File:Ch.rar тут].
 
Скачать можно  [http://mech.spbstu.ru/File:Ch.rar тут].
 
 
 
'''[[Капитанюк Светлана]]'''
 
 
'''Краткое описание алгоритма''': Доска представлена в виде динамического массива. Если в клетке присутствует фигура, то тогада она обозначается '+', если же клетка осталась путсая, то тогда '0'.
 
 
'''Инструкция''': пользователь вводит размер доски, далее он выбирает то действие, которое он хотел бы выполнить: посчитать максимальное число возможных фигур на данной доске, или же расставить фигуры так, чтобы они не били друг друга.
 
 
Скачать можно  [http://tm.spbstu.ru/File:Chess_03.zip тут].
 
 
'''[[Рубинова Раиса]]'''
 
 
'''Основная идея программы''': Программа подсчитывает и выводит расстановку указанного кол-ва фигур на указанном поле и второй опицей выводит максимальную расстановку на поле размером size*size
 
 
Скачать можно  [[:File:Chess.zip]]
 

Текущая версия на 06:09, 17 июня 2016

Абрамов Игорь

Алгоритм: в зависимости от выбранного режима работы, после ввода пользователем необходимой информации о размере поля а также типе расставляемых фигур, запускается основная рекурсивная функция, которая либо подсчитывает все возможные расстановки для заданного числа фигур и выводит их в файл, либо рассчитывает максимально возможное расставляемое число фигур. В первом режиме это происходит путём установки фигуры в свободную клетку и отметки клеток, которые бьются данной фигурой, затем запускается эта же функция для оставшихся клеток и т.д., пока число поставленных фигур не дойдёт до числа, заданного пользователем. Тогда эта расстановка выводится в файл и счётчик числа расстановок увеличивается на единицу. Во втором режиме как только находится расстановка для данного количества фигур, функция завершает свою работу, увеличивается счётчик количества фигур и функция вызывается уже для большего количества фигур, пока не будет найдено максимально возможное расставляемое на данной доске число фигур.

Инструкция: В меню пользователю предлагается указать размеры доски, тип расставляемых фигур и режим работы программы. После этого, если был выбран режим вывода всех расстановок, необходимо ввести количество расставляемых фигур, после чего программа выведет на экран количество расстановок, а в файле "output.txt" появятся изображения всех расстановок. При выборе второго режима, на экран будет выведено максимальное число фигур заданного типа, которые можно расставить на данной доске.

Ссылка для скачивания:[1]

Андреева Полина

Краткое описание алгоритма:если шахматную доску представить в виде одной строчки(вторую поставить следом за первой, третью за второй и тд), то получится двоичное число. Максимальное число которое может получиться если 111...111 перевести в десятичное ,это число М*М. Тогда абсолютно ВСЕ варианты расстановки фигур это двоичные записи чисел от 0 до М*М. В программе есть цикл, который рассматривает каждый вариант для числа от 0 до М*М, переводит его в двоичную форму. Программа рассматривает каждую клетку, где стоит фигура. Если эта фигура бьет других, то цикл прерывается, нам такой вариант не подходит. Если никакая фигура не бьет никакую другую, то идет подсчет количества фигур на доске. Если фигур столько, сколько нужно, то вывод на экран.

Инструкция: На экране показано соответствие каждому номеру типа фигуры. Пользователь выбирает тип фигуры, испольуя номер. Дальше нужно ввести размер доски. Затем на экране появляется два варианта количества фигур на доске: максимальное или введенное пользователем. Пользователь выбирает вариант. Если второй, то затем надо будет ввести количество фигур. Программа

  1  
  2 #include <cstring>
  3 #include <iostream>
  4 #include"math.h"
  5 #include <fstream>
  6 using namespace std;
  7 
  8 int M, N;  // M-размер доски, N-коичество шахмат.
  9 int    sum;//нужно в процессе для подсчета количества шахмат
 10 int **ChessBoard= new int* [M];
 11 
 12 void ChessBoards(int k) //создание доски, k-число, которое переводим в двоичную запись, чтобы отобразить на доске расстановку фигур, 1-фигура есть, 0-нет.
 13 {
 14     for (int i=0; i<M; i++) //создание массива
 15     {
 16         ChessBoard[i] = new int[M];
 17     }
 18     for (int x=(M-1); x>=0; x=x-1)//заполнение массива фигурами (переводя k в двоичную форму)
 19     {
 20         for (int y=(M-1); y>=0; y=y-1)
 21         {
 22             ChessBoard[x][y]=(k%2);
 23             k=k/2;
 24         }
 25     }
 26 }
 27 void print (char filename[] ) ///создание функции вывода массива в файл
 28     {
 29         ofstream fout(filename, ios::app);
 30 
 31         for (int x=0; x<M; ++x)
 32         {
 33             for(int y=0; y<M; ++y)
 34             {
 35                 fout << ChessBoard[x][y]<<" "; ///вывод массива в файл
 36             }
 37             fout <<'\n';
 38 
 39         }
 40         fout <<"\n\n";
 41 
 42         fout.close();
 43     }
 44 
 45 
 46 
 47 bool CheckHorse(int x, int y)//проверка для коня в клетке с номером x, y
 48 {
 49 
 50     if (((x+1)<M) && ((y+2)<M) && (ChessBoard[x+1][y+2]==1))//если в клетке, куда может сходить конь (х+1,у+2) уже есть фигура, то этот вариант не подходит, так как один конь бьет другого.
 51     {
 52         return false;
 53 
 54     }
 55     else if (((x+1)<M ) && ((y-2)>=0) && (ChessBoard[x+1][y-2]==1))//то же самое и в остальных случаях проверяем бьет ли один конь другого.
 56     {
 57         return false;
 58 
 59     }
 60     else if (((x-1)>=0) && ((y+2)<M) && (ChessBoard[x-1][y+2]==1))
 61     {
 62         return false;
 63     }
 64     else if (((x-1)>=0) && ((y-2)>=0) && (ChessBoard[x-1][y-2]==1))
 65     {
 66         return false;
 67     }
 68     else if (((x+2)<M) && ((y+1)<M) && (ChessBoard[x+2][y+1]==1))
 69     {
 70         return false;
 71     }
 72     else if (((x+2)<M ) && ((y-1)>=0) && (ChessBoard[x+2][y-1]==1))
 73     {
 74         return false;
 75     }
 76     else if (((x-2)>=0 ) && ((y+1)<M) && (ChessBoard[x-2][y+1]==1))
 77     {
 78         return false;
 79     }
 80     else if (((x-2)>=0 ) && ((y-1)>=0) && (ChessBoard[x-2][y-1]==1))
 81     {
 82         return false;
 83     }
 84     else //в итоге, если конь, стоящий в данной клетке никого не бьет, то этот вариант подходит
 85     {
 86         return true;
 87     }
 88 }
 89 
 90 int Horse(int k)//k-то число которое нужно будет перевести в двоичную форму, это делается в main'е
 91 //в этой функции считаем количество фигур, если он равно введенному  или максимальному,то доска подходит и выводится в файл (все это в main'е)
 92 {
 93     for (int x=0; x<M; x++)
 94     {
 95         int y;
 96         for (y=0; y<M; y++)
 97         {
 98             if (ChessBoard[x][y]==1)//если в данной клетке стоит конь, то нужно проверить,
 99              // бьет оно кого-то или нет...
100              //если в клетке нет коня, то ее проверять не нужно
101             {
102                 if (CheckHorse(x,y))//...делаем это с помощью этой функции,если конь в данной клетке х;у   
103                 //никого не бьет, то прибавляем 1 к количеству шахмат на доске и считаем дальше   
104                 {
105                     sum=sum+1;
106                 }
107                 else //а если бьет, то выходим из цикла, на данной этапе выйдем только из внуреннего
108                 {
109                     sum=0;//количество фигур обнуляем
110                     break;
111                 }
112             }
113         }
114         if (y<M)//если из внутреннего цикла вышли раньше, значит у досчитался не до конца, 
115         //то есть он меньше своего максимального значения М
116         {
117             
118             break;//тогда выходим и из внешнего цикла
119         }
120     }
121     return sum; //возвращаем количество фигур
122 }
123 
124 bool CheckKing(int x, int y) //все то же самое для проверки короля, стоящего в клетке х,у
125 {
126 
127     if (((x+1)<M) && ((y+1)<M) && (ChessBoard[x+1][y+1])==1)//если в клетке куда может сходить король
128     //уже есть фигура, то клетка не подходит и т.д
129     {
130         return false;
131 
132     }
133     else if (((x+1)<M ) && (ChessBoard[x+1][y]==1))
134     {
135         return false;
136 
137     }
138     else if (((x+1)<M) && ((y-1)>=0) && (ChessBoard[x+1][y-1]==1))
139     {
140         return false;
141     }
142     else if (((x-1)>=0) && ((y-1)>=0) && (ChessBoard[x-1][y-1]==1))
143     {
144         return false;
145     }
146     else if (((x-1)>=0) && ((y+1)<M) && (ChessBoard[x-1][y+1]==1))
147     {
148         return false;
149     }
150     else if (((x-1)>=0) &&  (ChessBoard[x-1][y]==1))
151     {
152         return false;
153     }
154     else if (((y+1)<M) && (ChessBoard[x][y+1]==1))
155     {
156         return false;
157     }
158     else if (((y-1)>=0) && (ChessBoard[x][y-1]==1))
159     {
160         return false;
161     }
162     else
163     {
164         return true;
165     }
166 }
167 
168 int King(int k) //так же как и для коня, проверяем каждую клетку
169 //подходит-прибавляем к количеству фигур sum единичку, нет-обнуляем сумму и выходим из цикла
170 {
171     for (int x=0; x<M; x++)
172     {
173         int y;
174         for (y=0; y<M; y++)
175         {
176             if (ChessBoard[x][y]==1)
177             {
178                 if (CheckKing(x,y))
179                 {
180                     sum=sum+1;
181                 }
182                 else
183                 {
184                     sum=0;
185                     break;
186                 }
187             }
188         }
189         if (y<M)
190         {
191             break;
192         }
193     }
194     return sum;
195 }
196 
197 int CheckQueen(int x, int y)///проверка для королевы, принцип тот же, королева стит в клеке x,y 
198 ///1 значит как true в bool (как в коне или короле), 0 - false
199 { int returnn=1;//начала true, дальше если будет false, то return примет значение 0, а если все пдходит
200 ///то так и стается 1
201  int m;
202     for (m=1; m<M; m++)
203   { //проверяем для диагоналей
204     ///если по диагонале клетки х,у стоит еще королва, то такой вариант не подходит, выходим из цикла
205     ///разбито на 4 услвия, так как если не разбивать, то клетка в кторой стоит данная королева
206     ///тоже будет считаться и выходить из цикла
207       if (((x+m)<M)&&((y+m)<M))
208       {
209           if (ChessBoard[x+m][y+m]==1)
210           {returnn=0;
211           break;
212           }
213       }
214        if (((x-m)>=0)&&((y+m)<M))
215       {
216           if (ChessBoard[x-m][y+m]==1)
217           {returnn=0;
218           break;}
219       }
220       if (((x+m)<M)&&((y-m)>=0))
221       {
222           if (ChessBoard[x+m][y-m]==1)
223         {returnn=0;
224           break;}
225       }
226       if (((x-m)>=0)&&((y-m)>=0))
227       { if (ChessBoard[x-m][y-m]==1)
228           {returnn=0;
229           break;}
230       }
231        if (m!=x) ///тут считаем по вертикали и горизонтали, так как длаем в цикле для m, то m меняется 
232         ///и в какой-то момент может стать х, и тогда роверятьбуде клетку в которой стоит ДАННАЯ и выходить
233         ///это не нужно так что выходим только если m не равен x
234          {
235             if (ChessBoard[m][y]==1) //если по горизонтали есть какая-о клетка, где стоит королева, то выходим
236             {
237                 returnn=0;
238                 break;
239             }
240         }
241         if (m!=y)//то же по вертикали
242         {
243            if (ChessBoard[x][m]==1)
244             {
245                 returnn=0;
246                 break;
247             }
248         }
249   }
250   return returnn;
251 }
252 
253 int Queen(int k)//тут также как и для коня и короля
254 {
255  for (int x=0; x<M; x++)
256     {
257         int y;
258         for (y=0; y<M; y++)
259         {
260             if (ChessBoard[x][y]==1)//если в клетке королева, проверяем подходи ли она нам
261             {
262                 if (CheckQueen(x,y))
263                 {
264                     sum=sum+1;
265                 }
266                 else
267                 {
268                     sum=0;
269                     break;
270                 }
271             }
272         }
273         if (y<M)
274         {
275             break;
276         }
277     }
278     return sum;
279 }
280 
281 int CheckRook(int x, int y)///ладья, просто берем ту часть из проверки королевы, где проверка по горизонтали и вертикали
282 { int returnn=1;
283 int m;
284     for (m=0; m<M; m++)
285 
286     {
287         if (m!=x)
288         {
289             if (ChessBoard[m][y]==1)
290             {
291                 returnn=0;
292                 break;
293             }
294         }
295         if (m!=y)
296         {
297            if (ChessBoard[x][m]==1)
298             {
299                 returnn=0;
300                 break;
301             }
302         }
303     }
304 
305 
306       return returnn;
307 }
308 
309 int Rook(int k)//все то же самое, количество фигур на доске
310 {
311     for (int x=0; x<M; x++)
312     {
313         int y;
314         for (y=0; y<M; y++)
315         {
316             if (ChessBoard[x][y]==1)
317             {
318                 if (CheckRook(x,y)==1)
319                 {
320                     sum=sum+1;
321 
322                 }
323                 else
324                 {
325                     sum=0;
326                     break;
327                 }
328             }
329         }
330         if (y<M)
331         {
332             break;
333         }
334     }
335 
336     return sum;
337 }
338 
339 int CheckElephant(int x, int y)//для слона берем ту часть прроверки королевы, где по диагонали
340 { int returnn=1;
341   for (int i=1; i<M; i++)
342   {
343       if (((x+i)<M)&&((y+i)<M))
344       {
345           if (ChessBoard[x+i][y+i]==1)
346           {returnn=0;
347           break;
348           }
349       }
350        if (((x-i)>=0)&&((y+i)<M))
351       {
352           if (ChessBoard[x-i][y+i]==1)
353           {returnn=0;
354           break;}
355       }
356       if (((x+i)<M)&&((y-i)>=0))
357       {if (ChessBoard[x+i][y-i]==1)
358         {returnn=0;
359           break;}
360       }
361       if (((x-i)>=0)&&((y-i)>=0))
362       { if (ChessBoard[x-i][y-i]==1)
363           {returnn=0;
364           break;}
365       }
366   }
367   return returnn;
368 }
369 
370 int Elephant(int k)///считаем кличесво фигур 
371 {
372  for (int x=0; x<M; x++)
373     {
374         int y;
375         for (y=0; y<M; y++)
376         {
377             if (ChessBoard[x][y]==1)
378             {
379                 if (CheckElephant(x,y))
380                 {
381                     sum=sum+1;
382                 }
383                 else
384                 {
385                     sum=0;
386                     break;
387                 }
388             }
389         }
390         if (y<M)
391         {
392             break;
393         }
394     }
395     return sum;
396 }
397 
398 int main ()
399 {
400     ofstream MyFile("MyFile", ios::trunc);
401     MyFile.close(); // очищаем файл, чтоб при новой записи не было из рошлого запуска
402 
403 int figure, z; 
404     cout<<"enter a figure 1-queen, 2-king, 3-rook , 4-horse or 5-elephant ";
405     cin>>figure;///тип фигуры, 1 - королевА, 2-король,3-ладья,4-конь,6-слон
406       cout << "\n enter a size of a board M - even number ";///ввести ЧЕТНЫЙ размер доски М
407     cin >> M;
408     if ( M%2 != 0)///проверка М на четность, с помощью остатка от деления на 2
409     {
410         while (M%2 != 0)
411         {
412             cout<<" you need EVEN number, enter one more time ";
413             cin>>M;
414         }
415     }
416 
417     cout<<"\n choose  1- max amount or 2 - your amount of figures ";
418     cin>>z;///z-один из вариантов 1-максимаьное число фигур на доске,2-пользователь сам вводит
419 
420     switch (figure)///выбираем фигуру
421     {
422     case 1:///королева
423     {
424         if (z==2)///пользоватеь сам вводит количество
425         {
426             cout<<"\n enter an amount of figures ";
427             cin >> N;///ввести количество 
428             if (N>M)///проверка на то, сможет ли такое количество уместиться на доске в правильном виде
429             {
430                 while (N>M)
431                 {
432                     cout<<" too many figures, enter one more time ";
433                     cin>>N;
434                 }
435             }
436             ///вот ниже i- те числа которые нужно перевести в двоичную форму
437             for (int i=0; i<=pow(2,(M*M)); i++)///каждый i-новый вариант расстановик фигур
438             {
439                 sum=0;
440                 int k=i;
441                 ChessBoards(k);
442                 if (Queen(k)==N)///если в данной варианте фигур столько. сколько ввел пользователь, то выводим
443                 {
444                     print("MyFile");
445                 }
446             }
447         }
448         else ///вариант максимального числа фигур на доске
449         {   ///так же как и в предыдущем пункте, только количество фигур N максимально,
450             /// в случае королевы оно равно размеру доски   
451             N=M;
452             for (int i=0; i<=pow(2,(M*M)); i++)
453             {
454                 sum=0;
455                 int k=i;
456                 ChessBoards(k);
457                 if (Queen(k)==N)
458                 {
459                     print("MyFile");
460                 }
461             }
462         }
463 
464         break;
465     }
466     case 2:///то же самое для короля
467     {
468         if (z==2)
469         {
470             cout<<"\n enter an amount of figures ";
471             cin >> N;
472               if ( N>(M*M)/4)
473             {
474                 while (N>(M*M)/4)
475                 {
476                     cout<<" too many figures, enter one more time ";
477                     cin>>N;
478                 }
479             }
480             for (int i=0; i<=pow(2,(M*M)); i++)
481             {
482                 sum=0;
483                 int k=i;
484                 ChessBoards(k);
485                 if (King(k)==N)
486                 {
487                     print("MyFile");
488                 }
489             }
490         }
491 else
492         {
493             N=(M*M)/4;
494             for (int i=0; i<=pow(2,(M*M)); i++)
495             {
496                 sum=0;
497                 int k=i;
498                 ChessBoards(k);
499                 if (King(k)==N)
500                 {
501                     print("MyFile");
502                 }
503             }
504         }
505         break;
506     }
507     case 3:///для ладьи
508     {
509         if (z==2)
510         {
511             cout<<"\n enter an amount of figures ";
512             cin >> N;
513               if (N>M)
514             {
515                 while (N>M)
516                 {
517                     cout<<" too many figures, enter one more time ";
518                     cin>>N;
519                 }
520             }
521 
522             for (int i=0; i<=pow(2,(M*M)); i++)
523             {
524                 sum=0;
525                 int k=i;
526                 ChessBoards(k);
527                 if (Rook(k)==N)
528                 {
529                     print("MyFile");
530                 }
531             }
532         }
533         else
534         {
535             N=M;
536             for (int i=0; i<=pow(2,(M*M)); i++)
537             {
538                 sum=0;
539                 int k=i;
540                 ChessBoards(k);
541                 if (Rook(k)==N)
542                 {
543                     print("MyFile");
544                 }
545             }
546         }
547         break;
548     }
549     case 4:///конь
550     {
551         if (z==2)
552         {
553             cout<<"\n enter an amount of figures ";
554             cin >> N;
555               if (N>(M*M)/2)
556             {
557                 while (N>(M*M)/2)
558                 {
559                     cout<<" too many figures, enter one more time ";
560                     cin>>N;
561                 }
562             }
563 
564             for (int i=0; i<=pow(2,(M*M)); i++)
565             {
566                 sum=0;
567                 int k=i;
568                 ChessBoards(k);
569                 if (Horse(k)==N)
570                 {
571                     print("MyFile");
572                 }
573             }
574         }
575         else
576         {
577             N=(M*M)/2;
578             for (int i=0; i<=pow(2,(M*M)); i++)
579             {
580                 sum=0;
581                 int k=i;
582                 ChessBoards(k);
583                 if (Horse(k)==N)
584                 {
585                     print("MyFile");
586                 }
587             }
588         }
589         break;
590     }
591     case 5:///слон
592     {
593         if (z==2)
594         {
595             cout<<"\n enter an amount of figures ";
596             cin >> N;
597                  if (N>2*M-2)
598             {
599                 while (N>2*M-2)
600                 {
601                     cout<<" too many figures, enter one more time ";
602                     cin>>N;
603                 }
604             }
605             for (int i=0; i<=pow(2,(M*M)); i++)
606             {
607                 sum=0;
608                 int k=i;
609                 ChessBoards(k);
610                 if (Elephant(k)==N)
611                 {
612                     print("MyFile");
613                 }
614             }
615         }
616         else
617         {
618             N=2*M-2;
619             for (int i=0; i<=pow(2,(M*M)); i++)
620             {
621                 sum=0;
622                 int k=i;
623                 ChessBoards(k);
624                 if (Elephant(k)==N)
625                 {
626                     print("MyFile");
627                 }
628             }
629         }
630         break;
631     }
632     default : ///а это еси пользоватеь ввел цифру, которая не соответстует ни одной фигуре
633     {
634         cout<<"NOOOOO";
635         break;
636     }
637     };
638 
639 
640     return 0;
641     }

Бальцер Анастасия

Краткое описание алгоритма: Для каждой фигуры написана отдельная функция, выполняющая поиск расстановок. После выбора типа фигуры, соответствующая функция выполняет поиск возможных расстановок. Она проходя по строкам двумерного массива пытается поставить фигуру в каждую клетку. Проходя по массиву она маркирует клетки, ставит 0 (если клетка свободна), 1 (если клетка находится под ударом), 2 (если клетка занята). Программа аналитически считает максимальное количество фигур для заданного размера доски, возможное число расстановок для заданных типа фигуры, размера доски и количества фигур.

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

Посмотреть программу можно тут

Белоусова Екатерина

Краткое описание алгоритма: доска представлена в виде динамического массива, заполненного 1 и 0. 1-стоит фигура, 0-пустое место. Программа при помощи рекурсии вызывает функцию, которая ставит фигуру в пустую клетку и проверяет, находится ли эта фигура под ударом других.

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

Скачать можно тут.

  1 #include <iostream>
  2 #include <stdlib.h>
  3 #include <stdio.h>
  4 #include <string>
  5 #include <cstring>
  6 #include <fstream>
  7 #include <locale.h>
  8 #include<iomanip>
  9 #include<math.h>
 10 
 11 using namespace std;
 12 
 13 
 14 int n, figureID, figura, maxCount; /// n - размер доски, figureID - номер фигуры, figura - колическтво фигур, maxCount - максимальное возможное количество фигур
 15 int results_count = 0; /// определяем тип и задаем начальное значение results_count(номер результата)
 16 int **mass; /// определяем двумерный массив
 17 
 18 ///создаем массив размером n*n
 19 int** create_mass(int n)
 20 {
 21 
 22     int **mass = new int* [n];
 23     for (int a=0; a<n; ++a)
 24     {
 25         mass[a] = new int [n];
 26         memset((char*)mass[a],0,n*sizeof(int)); ///зануление массива
 27     }
 28 
 29         return mass;
 30 
 31 }
 32 
 33 ///функция вывода массива
 34 void output_mass ()
 35 {
 36 
 37     for (int a=0; a<n; ++a)///заполнение ячеек массива от 0 до n по горизонтали
 38     {
 39 
 40         for(int b=0; b<n; ++b)///заполнение ячеек массива от 0 до n по вертикали
 41         {
 42             cout << mass[a][b]<<" "; ///вывод массива на экран
 43         }
 44 
 45         cout << '\n';
 46 
 47     }
 48 
 49     cout << "Result #" << ++results_count <<"\n\n"; /// вывод номера результата
 50 
 51 }
 52 
 53 void zapis (char Zapis[] ) ///функции записи решений в файл
 54 {
 55     ofstream fout(Zapis, ios::app);///запись в фаил "Zapis"
 56 
 57     for (int x=0; x<n; ++x)///заполнение ячеек массива от 0 до n по горизонтали
 58     {
 59         for(int y=0; y<n; ++y)///заполнение ячеек массива от 0 до n по вертикали
 60         {
 61             fout<< mass[x][y]<<" "; ///вывод решений в файл
 62         }
 63         fout<<'\n';
 64     }
 65     fout<<"\n\n";
 66     fout.close();
 67 }
 68 
 69 ///проверяем наличие фигуры в строке а
 70 bool isEmptyHorisontal(int a)
 71 {
 72 
 73     for(int i=0; i<n; ++i)///создаем цикл от 0 до n
 74     {
 75         if(mass[a][i])///в каждой ячейке массива [a][i]
 76         {
 77             return false;///неверно
 78         }
 79     }
 80 
 81     return true;///в остальных случаях верно
 82 
 83 }
 84 
 85 ///проверяем наличие фигур в столбце b
 86 bool isEmptyVertical(int b)
 87 {
 88 
 89     for(int i=0; i<n; ++i)///создаем цикл от 0 до n
 90     {
 91         if(mass[i][b])///в каждой ячейке массива [i][b]
 92         {
 93             return false;///неверно
 94         }
 95     }
 96 
 97     return true;///в остальных случаях верно
 98 
 99 }
100 
101 ///проверяем наличие фигур на диагоналях
102 bool isEmptyDiagonales(int a, int b)
103 {
104 
105     for(int i=1; a-i>=0 && b-i>=0; ++i)///диагональ влево-вверх
106     {
107         if(mass[a-i][b-i])///в каждой ячейке массива [a-i][b-i]
108         {
109             return false;///неверно
110         }
111     }
112 
113     for(int i=1; a+i<n && b+i<n; ++i)///диагональ вправо-вниз
114     {
115         if(mass[a+i][b+i])///в каждой ячейке массива [a+i][b+i]
116         {
117             return false;///неверно
118         }
119     }
120 
121     for(int i=1; a+i<n && b-i>=0; ++i)///диагональ влево-вниз
122     {
123         if(mass[a+i][b-i])///в каждой ячейке массива [a+i][b-i]
124         {
125             return false;///неверно
126         }
127     }
128 
129     for(int i=1; a-i>=0 && b+i<n; ++i)///диагональ вправо-вверх
130     {
131         if(mass[a-i][b+i])///в каждой ячейке массива [a-i][b+i]
132         {
133             return false;///неверно
134         }
135     }
136 
137         return true;///в остальных случаях верно
138 
139 }
140 
141 ///проверяем наличие фигур по горизонтали, вертикали и диагоналям
142 bool tryQueen(int a, int b)
143 {
144 
145     if (!isEmptyHorisontal(a) || !isEmptyVertical(b) || !isEmptyDiagonales(a,b))///если не выполняются эти условия,
146                                                                                 ///т.е. постановка фигуры не удовлетворяет расстановке
147                                                                                 ///по горизонтали, или по вертикали, или по диагонали
148     return false;///неверно
149 
150     return true;///в остальных случаях верно
151 
152 }
153 
154 /// функция поиска результатов решений.
155 /// row - номер очередной строки в которую нужно поставить очередного ферзя.
156 /// count - количество фигур, поставленое к данному моменту
157 void setQueen(int row, int count)
158 {
159 
160     for(int column=0; column<n; ++column)///двигаемся по столбцу сверху вниз
161     {
162 
163         if(tryQueen(row, column))/// проверка, если поставить ферзя в ячейку [row][column],
164                                  ///будет ли он единственным в этих строке, столбце и диагоналях
165         {
166             mass[row][column]=1;
167 
168             if(count+1==figura) /// нужное количество фигур поставлено
169             {
170                 output_mass(); /// вызов функции вывода массива на экран
171                 zapis("Zapis");///записываем в файл
172             }
173 
174             else
175             {
176                 for(int i = row + 1; i<n; i++)/// ставим следующего ферзя в одну из следующих строк
177                 setQueen(i,count+1);///и повторяем цикл
178             }
179 
180             mass[row][column]=0;
181 
182         }
183 
184     }
185 
186 }
187 
188 bool tryRook(int a, int b)///проверка на наличие фигур по вертикали и горизонтали
189 {
190 
191     if (!isEmptyHorisontal(a) || !isEmptyVertical(b))///если не выполняются эти условия,
192                                                      ///т.е. постановка фигуры не удовлетворяет расстановке
193                                                      ///по горизонтали, или по вертикали
194     return false;///неверно
195 
196     return true;///в остальных случаях верно
197 
198 }
199 
200 /// функция поиска результатов решений.
201 /// row - номер очередной строки в которую нужно поставить очередную ладью
202 /// count - количество фигур, поставленое к данному моменту
203 void setRook(int row, int count)
204 {
205 
206     for(int column=0; column<n; ++column)///двигаемся по столбцу сверху вниз
207     {
208 
209         if(tryRook(row, column))/// проверка, если поставить ладью в A[row][column], будет ли она единственной в этих строке и столбце
210         {
211 
212             mass[row][column]=1;
213 
214             if(count+1==figura) /// нужное количество фигур поставлено
215             {
216                 output_mass(); /// вызов функции вывода массива на экран
217                 zapis("Zapis");///записываем в файл
218             }
219 
220             else
221             {
222                 for(int i = row + 1; i<n; i++)/// ставим следующую ладью в одну из следующих строк
223                 setRook(i,count+1);///и повторяем цикл
224             }
225 
226             mass[row][column]=0;
227 
228         }
229 
230     }
231 
232 }
233 
234 bool tryElephant(int a, int b) ///проверка на наличие фигур по диагоналям.
235 {
236 
237     if (!isEmptyDiagonales(a,b))///если не выполняется это условие,
238                                 ///т.е. постановка фигуры не удовлетворяет расстановке по диагоналям
239     return false;
240 
241     return true;
242 
243 }
244 
245 /// функция поиска результатов решений.
246 /// diagonale - номер диагонали в которую нужно поставить очередного слона
247 /// count - количество фигур, поставленое к данному моменту
248 void setElephant(int diagonale, int count)
249 {
250 
251     int a, b; /// опорная точка диагонали (крайняя левая)
252 
253     if (diagonale < n)///если номер диагонали меньше n
254     {
255         a = diagonale;///значению а присвоить значенье номера диагонали
256         b = 0;///значению b присвоить значение 0
257     }
258 
259     else///иначе
260     {
261         a = n-1;///значению а присвоить значение n-1
262         b =(diagonale % n)+1;///значению b присвоить значение целого частного от деления номера диагонали на n прибавив к нему 1
263     }
264 
265     /// перебираем все "столбцы" текущей диагонали
266     for(int dcolumn=0; a-dcolumn>=0 && b+dcolumn < n; ++dcolumn)
267     {
268 
269         /// рассчёт координат клетки по координатам крайней точки диагонали и "столбца" в диагонали
270         int x = a-dcolumn;
271         int y = b+dcolumn;
272 
273         if(tryElephant(x, y))/// проверка, если поставить слона в A[row][column], будет ли он единственным по диагоналям
274         {
275 
276             mass[x][y]=1;
277 
278             if(count+1==figura) /// нужное количество фигур поставлено
279             {
280                 output_mass(); /// вызов функции вывода массива на экран
281                 zapis("Zapis");///запись в файл
282             }
283 
284             else
285             {
286                 for(int i = diagonale + 1; i<2*n-1; i++)/// ставим следующего слона в одну из следующих диагоналей
287                 setElephant(i,count+1);///и повторяем цикл
288             }
289 
290             mass[x][y]=0;
291 
292         }
293 
294     }
295 
296 }
297 
298 /// проверка на наличие фигуры на позиции x,y
299 bool isFigure(int x, int y)
300 {
301     return 0 <= x && x < n && 0 <= y && y < n && mass[x][y];
302 }
303 
304 ///проверка на наличие короля в квадрате 3 на 3
305 bool tryKing(int a, int b)
306 {
307 
308     for(int i = a-1; i <= a+1; i++)///для ячеек находящихся слева и справа от поставленного короля
309     {
310         for(int j = b-1; j <= b+1; j++)///для ячеек находящихся снизу и сверху от поставленного короля
311         {
312             if (isFigure(i,j))///если выполняется это условие
313             return false;///неверно
314         }
315     }
316 
317     return true;///в остальных случаях верно
318 
319 }
320 
321 ///функция поиска результатов решений
322 /// count - количество фигур, поставленое к данному моменту
323 ///x,y - позиция, начиная с которой разрешено ставить фигуры (все предшествующие позиции уже точно определены)
324 void setKing(int count, int x, int y)
325 {
326 
327     if(count==figura)///figura - количество фигур, вводимых пользователями.
328     {
329         output_mass();/// вызов функции вывода массива на экран
330         zapis("Zapis");///записываем в файл
331         return;
332     }
333 
334     if (x == n) /// строки закончились
335         return;
336 
337     /// обрабатываем текущую строку
338     for (int j=y; j<n; ++j)
339     {
340 
341         if(tryKing(x, j))
342         {
343             mass[x][j]=1;
344             /// смещаем разрешённую позицию на 1 вправо или в начало следующей строки
345             int nextX = x, nextY = j+1;
346 
347             if (nextY == n)///если столбец последний
348             {
349                 nextY = 0;///идем сначала по столбцам
350                 nextX++;///к строке прибавляем 1
351             }
352 
353             /// ставим следующего короля
354             setKing(count+1,nextX,nextY);
355             mass[x][j]=0;
356 
357         }
358 
359     }
360 
361     /// обрабатываем прямоугольник ниже текущей строки
362     for(int i=x+1; i<n; ++i)
363     {
364 
365         for (int j=0; j<n; ++j)
366         {
367 
368             if(tryKing(i, j))
369             {
370                 mass[i][j]=1;
371                 /// смещаем разрешённую позицию на 1 вправо или в начало следующей строки
372                 int nextX = i, nextY = j+1;
373 
374                 if (nextY == n)///если столбец последний
375                 {
376                     nextY = 0;///идем сначала по столбцам
377                     nextX++;///к строке прибавляем 1
378                 }
379 
380                 /// ставим следующего короля
381                 setKing(count+1,nextX,nextY);
382                 mass[i][j]=0;
383 
384             }
385 
386         }
387 
388     }
389 
390 }
391 
392 bool tryHorse(int a, int b) ///проверка на коней по всем направлениям
393 {
394 
395     if (isFigure(a-1,b-2) || isFigure(a-1,b+2) || isFigure(a+1,b-2) || isFigure(a+1,b+2) || isFigure(a-2,b-1) || isFigure(a-2,b+1) || isFigure(a+2,b-1) || isFigure(a+2,b+1))
396                                                         ///если выполняются эти условия,
397                                                         ///т.е. фигара стоит на одной из этих позиций
398         return false;///неверно
399 
400     return true;///в остальных случаях верно
401 
402 }
403 
404 ///функция поиска результатов решений
405 /// count - количество фигур, поставленое к данному моменту.
406 void setHorse(int count, int x, int y)
407 {
408 
409     if(count==figura)///figura - количество фигур, вводимых пользователями.
410     {
411         output_mass();/// вызов функции вывода массива на экран
412         zapis("Zapis");///записываем в файл
413         return;
414     }
415 
416     if (x == n)/// строки закончились
417         return;
418 
419     /// обрабатываем текущую строку
420     for (int j=y; j<n; ++j)
421     {
422 
423         if(tryHorse(x, j))
424         {
425 
426             mass[x][j]=1;
427             /// смещаем разрешённую позицию на 1 вправо или в начало следующей строки
428             int nextX = x, nextY = j+1;
429 
430             if (nextY == n)///если столбец последний
431             {
432                 nextY = 0;///идем сначала по столбцам
433                 nextX++;///к строке прибавляем 1
434             }
435 
436             /// ставим следующего коня
437             setHorse(count+1,nextX,nextY);
438             mass[x][j]=0;
439 
440         }
441 
442     }
443 
444     /// обрабатываем прямоугольник ниже текущей строки
445     for(int i=x+1; i<n; ++i)
446     {
447 
448         for (int j=0; j<n; ++j)
449         {
450 
451             if(tryHorse(i, j))
452             {
453 
454                 mass[i][j]=1;
455                 /// смещаем разрешённую позицию на 1 вправо или в начало следующей строки
456                 int nextX = i, nextY = j+1;
457 
458                 if (nextY == n)///если столбец последний
459                 {
460                     nextY = 0;///идем сначала по столбцам
461                     nextX++;///к строке прибавляем 1
462                 }
463 
464                 setHorse(count+1,nextX,nextY);
465                 mass[i][j]=0;
466 
467             }
468 
469         }
470 
471     }
472 
473 }
474 
475 int main()
476 {
477     setlocale(LC_ALL,"RUS");
478 
479    ofstream Zapis("Zapis", ios::trunc);///сохраняем в файл
480    Zapis.close();
481 
482     do
483     {
484         cout << "Введите размер доски (четный): ";
485         cin >> n; ///ввод пользователем размера доски
486     }while (n%2 != 0);
487 
488     mass=create_mass(n); ///создаём двумерный массив
489 
490     cout<<"Queen-1, Rook-2, Elephant-3, King-4, Horse-5"<< endl;
491     cin >> figureID; ///выбор пользователем фигуры
492 
493     /// устанавливаем максимальное количество в зависимости от фигуры
494     if (figureID==1)
495     maxCount=n;
496     if (figureID==2)
497     maxCount=n;
498     if (figureID==3)
499     maxCount=2*n-2;
500     if (figureID==4)
501     maxCount=(n*n)/4;
502     if (figureID==5)
503     maxCount=(n*n)/2;
504 
505     /// запрашиваем количество фигур
506     do
507     {
508         cout << "Введите количество фигур (максимальное количество - " << maxCount << "): ";
509         cin >> figura;
510     }while (figura>maxCount);
511 
512     /// запускаем перебор
513     if (figureID==1)
514     {
515         for(int i = 0; i<n; i++)
516         setQueen(i,0);
517         zapis("Zapis");
518     }
519     if (figureID==2)
520     {
521         for(int i = 0; i<n; i++)
522         setRook(i,0);
523         zapis("Zapis");
524     }
525     if (figureID==3)
526     {
527         for(int i = 0; i<2*n-1; i++)
528         setElephant(i,0);
529         zapis("Zapis");
530     }
531     if (figureID==4)
532     {
533          setKing(0,0,0);
534          zapis("Zapis");
535     }
536     if (figureID==5)
537     {
538         setHorse(0,0,0);
539         zapis("Zapis");
540     }
541     system("PAUSE");
542 }

Васильева Анастасия

Краткое описание алгоритма: Доска представлена в виде динамического массива, по ходу программы, в зависимости от алгоритмов для разных фигур, функции заполняют доску числами 0-место свободно, 1-находится под ударом и 2-занято фигурой, потом массив преобразовывается к нормальному виду 0 и 1-фигура. Так программа прогоняет все возможные варианты расстановок. Также программа аналитически просчитывает максимальное количество фигур для каждого размера доски.

Инструкция: Сначала программа просит выбрать фигуру, с которой будем работать. Затем 2 варианта развития событий: 1 - вывод в файл всех расстановок, 2 - максимальное количество фигур. В зависимости от выбора, в первом случае еще нужно ввести количество фигур, и программа запишет в файл все возможные варианты и выведет на экран число расстановок, а во втором - на экране появится максимальное кол-во фигур. Скачать можно тут.


Гильманов Илья

Основная идея программы: пользователь вводит размер доски MxM , тип фигур, их количество. Программа рассчитывает максимально возможное количество фигур , которые можно расположить на доске, чтобы они не били друг друга.

Инструкция к программе: Пользователь вводит размер доски M(size*size).А затем предоставляется выбор между нахождением максимально возможного числа фигур , и их расстановкой.Также пользователь выбирает тип фигуры , и количество(если интересует расстановка).

Скачать можно здесь

Демченко Артём

Основная идея программы: Программа подсчитывает и выводит расстановку указанного кол-ва фигур на указанном поле и второй опицей выводит максимальную расстановку на поле размером size*size.

Инструкция: Запустите программу и следуйте инструкциям. Сначала идет выбор алгоритма, после чего идет выбор фигуры и размер доски для подсчета максимальной расстановки на поле size*size. Результат будет выведен на экран.

Скачать можно тут.

Иванова Яна

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

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

Посмотреть программу можно здесь

  1 #include <iostream>
  2 #include <algorithm>
  3 #include <exception>
  4 #include <string>
  5 #include <algorithm>
  6 
  7 //пусть для определенности максимальный размер доски - 128 клеток
  8 #define MAX_SIZE 128
  9 
 10 // перечисление для определения типа фигуры
 11 enum figure_type
 12 {
 13     KING,
 14     QUEEN,
 15     ROOK,
 16     BISHOP,
 17     KNIGHT
 18 };
 19 
 20 // класс для создания доски и расстановки фигур
 21 class chess_board
 22 {
 23 public:
 24     // конструктор (принимает только размеры)
 25     chess_board(const int &size)
 26     {
 27         if (size >= 0 && size <= MAX_SIZE)
 28         {
 29             size_ = size;
 30             clean_board();
 31         }
 32 
 33         else
 34         {
 35             std::cout << "wrong size" << std::endl;
 36             throw std::string("wrong size");
 37         }
 38     }
 39 
 40 
 41     // функция очистки доски (занулить все клетки)
 42     void clean_board()
 43     {
 44         //обнулить счетчик количества фигур на доске
 45         figures_on_board_ = 0;
 46         //присвоить всем клеткам значение 0
 47         for (int i = 0; i < size_; ++i)
 48         {
 49             for (int j = 0; j < size_; ++j)
 50             {
 51                 board_[i][j] = 0;
 52             }
 53         }
 54     }
 55 
 56     // функция, принимающая размер доски
 57     int get_size()
 58     {
 59         return size_;
 60     }
 61     // функция, обновляющая количество фигур на доске
 62     int get_figures_number()
 63     {
 64         return figures_on_board_;
 65     }
 66 
 67     //функция, пытающаяся поставить фигуру на свободное место и возвращающая
 68     //истину в случае успеха и ложь в случае неудачи
 69     bool put_figure (const figure_type& figure, const int& x, const int& y, const int& step)
 70     {
 71         if (board_[x][y] > 0 || board_[x][y] < -step)
 72         {
 73            //если здесь уже стоит фигура или мы когда-то пытались ее сюда поставить, вернуть ложь
 74             return false;
 75         }
 76 
 77         if (check_figure(figure, x, y))
 78         {
 79             board_[x][y] = step;
 80             ++figures_on_board_;
 81             return true;
 82         }
 83         else
 84         {
 85             return false;
 86         }
 87     }
 88 
 89     //отметить клетку как ранее пройденную функцией
 90     //вычесть единицу из количества фигур на доске
 91     void remove_figure(const int& x, const int& y)
 92     {
 93         board_[x][y] *= -1;
 94         --figures_on_board_;
 95     }
 96 
 97     //функция печати доски на экран
 98     void print() const
 99     {
100         using namespace std;
101         cout << "==========================================" << endl;
102         for (int i = 0; i < size_; ++i)
103         {
104             for (int j = 0; j < size_; ++j)
105             {
106                 //если фигура стоит в клетке, то вывести "*", если нет - вывести "-"
107                 cout << (board_[i][j] > 0?"*":"-") << " ";
108             }
109             cout << endl;
110         }
111         cout << "==========================================" << endl;
112     }
113 
114 private:
115 
116     //функция, проверяющая возможность или невозможность постановки фигуры на данную клетку
117     bool check_figure(const figure_type& figure, const int& x, const int& y)
118     {
119         //выбор следующего действия в зависимости от типа фигуры
120         switch (figure)
121         {
122             case KING:
123                 return check_king(x, y);
124             case QUEEN:
125                 return check_queen(x, y);
126             case ROOK:
127                 return check_rook(x, y);
128             case BISHOP:
129                 return check_bishop(x, y);
130             case KNIGHT:
131                 return check_knight(x, y);
132                 //в случае ошибки ввода вернуть ложь
133             default:
134                 return false;
135         }
136     }
137 
138     //поиск расстановок короля
139     bool check_king(const int& x, const int& y)
140     {
141         int min_x = std::max(x - 1, 0);
142         int max_x = std::min(x + 1, size_ - 1);
143         int min_y = std::max(y - 1, 0);
144         int max_y = std::min(y + 1, size_ - 1);
145 
146         for (int i = min_x; i <= max_x; ++i)
147         {
148             for (int j = min_y; j <= max_y; ++j)
149             {
150                 if (board_[i][j] > 0)
151                 {
152                     return false;
153                 }
154             }
155         }
156         return true;
157     }
158 
159     //поиск расстановок ладьи
160     bool check_rook(const int& x, const int& y)
161     {
162         for (int i = 0; i < size_; ++i)
163         {
164             if (board_[i][y] > 0)
165             {
166                 return false;
167             }
168         }
169         for (int j = 0; j < size_; ++j)
170         {
171             if (board_[x][j] > 0)
172             {
173                 return false;
174             }
175         }
176         return true;
177     }
178 
179     //поиск расстановок слона
180     bool check_bishop(const int& x, const int& y)
181     {
182         bool check = true;
183 
184         int k_start_1 = -std::min(x, y);
185         int k_end_1 = std::min( size_ - x, size_ - y) - 1;
186 
187         int k_start_2 = -std::min( x, size_ - y - 1);
188         int k_end_2 = std::min( y, size_ - x - 1);
189 
190 
191         for (int k = k_start_1; k <= k_end_1; ++k)
192         {
193             check = check_coord(x + k, y + k) && check ;
194         }
195         for (int k = k_start_2; k <= k_end_2; ++k)
196         {
197             check = check_coord(x + k, y - k) && check;
198         }
199 
200         return check;
201     }
202 
203 
204     //поиск расстановок коня
205     bool check_knight(const int& x, const int& y)
206     {
207         bool check =
208             check_coord(x - 2, y - 1) &&
209             check_coord(x - 2, y + 1) &&
210             check_coord(x - 1, y - 2) &&
211             check_coord(x - 1, y + 2) &&
212             check_coord(x + 1, y - 2) &&
213             check_coord(x + 1, y + 2) &&
214             check_coord(x + 2, y - 1) &&
215             check_coord(x + 2, y + 1);
216         return check;
217     }
218 
219     //поиск расстановок королевы
220     bool check_queen(const int& x, const int& y)
221     {
222         return check_rook(x, y) && check_bishop(x, y);
223     }
224 
225    //функция поиска расстановок, в случае, когда на доске что-то стоит, вернуть ложь
226    //иначе поставить вернуть истину
227     bool check_coord(const int& x, const int& y)
228     {
229         if (x >= 0 && x < size_ && y >= 0 && y < size_)
230         {
231             if (board_[x][y] > 0)
232             {
233                 return false;
234             }
235         }
236         return true;
237     }
238 
239     // if board_[x][y] == 0
240     //     клетка свободна
241     // if board_[x][y] == s
242     //     фигура была поставлена на шаге S
243     // if board_[x][y] == -s
244     //     клетка свободна, но была попытка поставить фигуру на шаге S
245     int board_[MAX_SIZE][MAX_SIZE];
246     int size_;
247     int figures_on_board_;
248 };
249 
250 //функция расчета максимума для любой доски в зависимости от типа фигуры
251 int get_max_figures (const figure_type& figure, const int& size)
252 {
253     switch (figure)
254     {
255         case KING:
256             return (size + 1) / 2;
257         case QUEEN:
258             if (size <= 2)
259             {
260                 return 1;
261             }
262             else if (size == 3)
263             {
264                 return 2;
265             }
266             else
267             {
268                 return size;
269             }
270         case ROOK:
271             return size;
272         case BISHOP:
273             if (size == 1)
274             {
275                 return size;
276             }
277             else
278             {
279                 return 2 * (size - 1);
280             }
281         case KNIGHT:
282             if (size <= 2)
283             {
284                 return size * size;
285             }
286             else
287             {
288                 return (size * size + 1) / 2;
289             }
290         default:
291             return 1;
292     }
293 }
294 
295 //функция для расстановки максимального числа фигур на доске
296 void place_figures_for_max(chess_board &board, const figure_type& figure, const int& max_figures, int step)
297 {
298     ++step;
299     const int size = board.get_size();
300     for (int i = 0; i < size; ++i)
301     {
302         for (int j = 0; j < size; ++j)
303         {
304             //если мы можем поставить фигуру, то добавляем к максимуму единицу и запускаем цикл снова
305             if (board.put_figure(figure, i, j, step))
306             {
307                 //если число фигур на доске достигло максимума, то вывести доску
308                 if (board.get_figures_number() == max_figures)
309                 {
310                     board.print();
311                 }
312                 //если число фигур не достигло максимума, продолжить выполнение функции
313                 else
314                 {
315                     place_figures_for_max(board, figure, max_figures, step);
316                 }
317                 board.remove_figure(i, j);
318             }
319         }
320     }
321 }
322 
323 //функция, принимающая ввод с клавиатуры как строковый тип данных
324 figure_type get_figure_type(const std::string& str)
325 {
326     using namespace std;
327 
328     figure_type figure;
329     if (str == string("king"))
330     {
331         figure = KING;}
332     else if (str == string("queen"))
333     {
334         figure = QUEEN;}
335     else if (str == string("rook"))
336     {
337         figure = ROOK;
338     }
339     else if (str == string("bishop"))
340     {
341         figure = BISHOP;
342     }
343     else if (str == string("knight"))
344     {
345        figure = KNIGHT;
346     }
347     //вывести ошибку в случае неверного ввода
348     else
349     {
350         cout << "wrong figure type" << endl;
351         throw string("wrong figure type");
352     }
353 
354     return figure;
355 }
356 
357 int main()
358 {
359     //использовать стандартное пространств имен
360     using namespace std;
361 
362     int size;
363     string type_of_figure;
364     string type_of_action;
365     figure_type figure;
366 
367     cout << "Возможные фигуры: king, queen, rook, bishop, knight" << endl;
368     cout << "Возможные действия: max, placing" << endl;
369     cout << "----------------------------------------------------" << endl;
370 
371     cout <<"Введите размер доски: ";
372     cin >> size;
373     chess_board board(size);
374 
375     cout << "Введите тип фигуры: ";
376     cin >> type_of_figure;
377     figure = get_figure_type(type_of_figure);
378 
379     cout << "Введите необходимое действие: ";
380     cin >> type_of_action;
381 
382     if (type_of_action == string("max"))
383     {
384 
385         int max_figures = get_max_figures(figure, size);
386         cout << "Max figures: " << max_figures << endl;
387 
388         cout << "Хотите ли вы просмотреть все варианты? (yes/no) ";
389         string answer;
390         cin >> answer;
391         //если нужно вывести все расстановки, то применить непосредственно функцию поиска расстановок максимума
392         if (answer == string("yes"))
393         {
394             int step = 0;
395             place_figures_for_max(board, figure, max_figures, step);
396         }
397     }
398     //иначе если нужно расставить определенное количество фигур, то применить функцию поиска расстановок
399     //относительно введенного числа
400     else if (type_of_action == string("placing"))
401     {
402         int figures_to_place;
403         cout << "Сколько фигур нужно расставить: ";
404         cin >> figures_to_place;
405 
406         int step = 0;
407         place_figures_for_max(board, figure, figures_to_place, step);
408     }
409     //иначе вывести ошибку действия
410     else
411     {
412         cout << "wrong type of action" << endl;
413         throw string("wrong type of action");
414     }
415 
416     return 0;
417 }


Капитанюк Светлана

Краткое описание алгоритма: Доска представлена в виде динамического массива. Если в клетке присутствует фигура, то тогада она обозначается '+', если же клетка осталась путсая, то тогда '0'.

Инструкция: Инструкция: при запуске программа предлагает пользователю ввести размер доски, при этом число должно быть четным (если же пользователь вводит нечетное число, программа предлагает ввести размер еще раз, и так до тех пор, пока не будет введено четное число). Далее пользователь выбирает режим работы программы - либо расстановка фигур, либо расчет максимального количества фигур. В режиме расстановки фигур программа предлагает выбрать тип фигуры, выводит максимальное число фигур для доски заданного размера и предлагает ввести желаемое число фигур для расстановки (если оно больше максимального, предлагается повторная попытка ввода). В режиме расчета максимального числа программа предлагает выбрать тип фигуры, выводит рассчитанное число и задает вопрос о необходимости вывода всех возможных расстановок максимального количества для данной фигуры. Оба режима работают (т.е. все запросы повторяются) до тех пор, пока пользователь не даст команду на завершение цикла. Кроме того, в программе есть возможность изменения размера доски после выхода из всех циклов. При положительном ответе пользователя и изменении размера доступны оба режима работы.

Скачать можно тут.

Киселёв Лев

Основная идея программы: реализация задачи о расстановке фигур одинакового типа на произвольной доске MxM Скачать можно здесь

Козловская Анна

Краткое описание алгоритма: Доска представлена в виде динамического массива[m;m], при выводе на экран пустые клетки обозначаются звездочками,а клетки, заполненные фигурами-буквами(каждая буква соответствует первой букве названия фигуры на английском языке). Для всех фигур написаны алгоритмы проверки на возможность расстановки фигуры. После выбора типа фигуры,используется рекурсивная функция,которая проверяет возможные расстановки через данную функцию проверки ,для данного типа фигуры. Во втором варианте работы программы,она аналитически высчитывает максимально возможное количество заданных фигур на доске.В программу встроена функция,проверяющая доску на повторные и симметричные относительно всех осей симметрии способы расстановки фигур.

Инструкция: В меню указывается два варианта развития событий. Пользователь должен выбрать один из путей. Он вводит размер доски и тип фигуры и кол-во фигур(для первого типа работы программы).Если он выбирает первый вариант работы программы - вывод всех различных расстановок N фигур.Другой вариант работы программы максимальное число расстановок- программа выводит их количество.

Скачать можно тут.

Лебедев Станислав

Функционал программы: получение всевозможных расстановок n однотипных шахматных фигур первой линии на поле n на n,таких,чтобы фигуры не били друг друга(считается,что фигуры одного цвета также могут бить друг друга) или получения максимального количества фигур первой линии,которые могут стоять на доске n*n;

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

Скачать можно тут.

  1 #include <iostream>
  2 #include <math.h>
  3 #include <cmath>
  4 
  5 using namespace std;
  6 
  7 int n,type, *a, *stak, variant, maxst = 0;
  8 
  9 void king(int x, int &top)                      //отметить битые клетки королем
 10 {
 11     // 012
 12     // 345
 13     // 678
 14 
 15     //0
 16     if (((x % n) > 1) && ((x / n) > 1))
 17     {
 18         int ii = x - n - 1;
 19         if (a[ii] != -2)
 20         {
 21             a[ii]++;
 22             stak[top] = ii;
 23             top++;
 24         }
 25     }
 26 
 27     //1
 28     if ((x / n) > 0)
 29     {
 30         int ii = x - n;
 31         if (a[ii] != -2)
 32         {
 33             a[ii]++;
 34             stak[top] = ii;
 35             top++;
 36         }
 37     }
 38 
 39     //2
 40     if (((x % n) < (n - 1)) && ((x / n) > 0))
 41     {
 42         int ii = x - n + 1;
 43         if (a[ii] != -2)
 44         {
 45             a[ii]++;
 46             stak[top] = ii;
 47             top++;
 48         }
 49     }
 50 
 51     //3
 52     if ((x % n) > 0)
 53     {
 54         int ii = x - 1;
 55         if (a[ii] != -2)
 56         {
 57             a[ii]++;
 58             stak[top] = ii;
 59             top++;
 60         }
 61     }
 62 
 63     //5
 64     if ((x % n) < (n - 1))
 65     {
 66         int ii = x + 1;
 67         if (a[ii] != -2)
 68         {
 69             a[ii]++;
 70             stak[top] = ii;
 71             top++;
 72         }
 73     }
 74 
 75     //6
 76     if (((x % n ) > 0) && ((x / n) < (n - 1)))
 77     {
 78         int ii = x + n - 1;
 79         if (a[ii] != -2)
 80         {
 81             a[ii]++;
 82             stak[top] = ii;
 83             top++;
 84         }
 85     }
 86 
 87     //7
 88     if ((x / n ) < (n - 1))
 89     {
 90         int ii = x + n;
 91         if (a[ii] != -2)
 92         {
 93             a[ii]++;
 94             stak[top] = ii;
 95             top++;
 96         }
 97     }
 98 
 99     //8
100     if (((x % n ) < (n - 1)) && ((x / n) < (n - 1)))
101     {
102         int ii = x + n + 1;
103     if (a[ii] != -2)
104         {
105             a[ii]++;
106             stak[top] = ii;
107             top++;
108         }
109     }
110 }
111 
112 void bishop(int x, int &top)                                                              //отметить битые клетки слоном
113 {
114     //вверх влево
115     for (int i = (x - (n + 1)); ((i >= 0) && ((i%n) != (n-1))); i -= (n+1))
116     {
117         if (a[i] != -2)
118         {
119             a[i]++;
120             stak[top] = i;
121             top++;
122         }
123     }
124 
125     //вниз вправо
126     for (int i = (x + (n + 1)); ((i < n*n) && ((i%n) != 0)); i += (n+1))
127     {
128         if (a[i] != -2)
129         {
130             a[i]++;
131             stak[top] = i;
132             top++;
133         }
134     }
135 
136     //вверх вправо
137     for (int i = x - (n - 1); ((i >= 0) && ((i%n) != 0)); i -= (n-1))
138     {
139         if (a[i] != -2)
140         {
141             a[i]++;
142             stak[top] = i;
143             top++;
144         }
145     }
146 
147     //вниз влево
148     for (int i = x + (n - 1); ((i < n*n) && ((i%n) != (n-1))); i += (n-1))
149     {
150         if (a[i] != -2)
151         {
152             a[i]++;
153             stak[top] = i;
154             top++;
155         }
156     }
157 }
158 
159 void knight(int x, int &top)                                            //отметить битые клетки конем
160 {
161     if (((x%n) > 0) && (x/n) > 1)
162     {
163         int ii = x - 2*n - 1;
164         if (a[ii] != -2)
165         {
166             a[ii]++;
167             stak[top] = ii;
168             top++;
169         }
170     }
171 
172     if (((x%n) > 1) && (x/n) > 0)
173     {
174         int ii = x - n - 2;
175         if (a[ii] != -2)
176         {
177             a[ii]++;
178             stak[top] = ii;
179             top++;
180         }
181     }
182 
183     if (((x%n) > 1) && (x/n) < (n - 1))
184     {
185         int ii = x + n - 2;
186         if (a[ii] != -2)
187         {
188             a[ii]++;
189             stak[top] = ii;
190             top++;
191         }
192     }
193 
194     if (((x%n) > 0) && (x/n) < (n - 2))
195     {
196         int ii = x + 2*n - 1;
197         if (a[ii] != -2)
198         {
199             a[ii]++;
200             stak[top] = ii;
201             top++;
202         }
203     }
204 
205     if (((x%n) < (n - 1)) && (x/n) < (n - 2))
206     {
207         int ii = x + 2*n + 1;
208         if (a[ii] != -2)
209         {
210             a[ii]++;
211             stak[top] = ii;
212             top++;
213         }
214     }
215 
216     if (((x%n) < (n - 2)) && (x/n) < (n - 1))
217     {
218         int ii = x + n + 2;
219         if (a[ii] != -2)
220         {
221             a[ii]++;
222             stak[top] = ii;
223             top++;
224         }
225     }
226 
227     if (((x%n) < (n - 2)) && (x/n) < 0)
228     {
229         int ii = x - n + 2;
230         if (a[ii] != -2)
231         {
232             a[ii]++;
233             stak[top] = ii;
234             top++;
235         }
236     }
237 
238     if (((x%n) < (n - 1)) && (x/n) < 1)
239     {
240         int ii = x - 2*n + 1;
241         if (a[ii] != -2)
242         {
243             a[ii]++;
244             stak[top] = ii;
245             top++;
246         }
247     }
248 }
249 
250 void rook(int x, int &top)                                                      //отметить битые клетки ладьей
251 {
252     int k = x - (x % n);
253     while ((k/n) == (x/n))
254     {
255 
256         if ((k != x) && (a[k] != -2))
257         {
258             a[k]++;
259             stak[top] = k;
260             top++;
261         }
262         k ++;
263     }
264 
265     k = (x % n);
266     while (((k/n)) != n)
267     {
268         if ((k != x) && (a[k] != -2))
269         {
270             a[k]++;
271             stak[top] = k;
272             top++;
273         }
274         k += n;
275     }
276 
277 }
278 void set_figure(int x, int &top)                                    //ставим фигуры на доску
279 {
280     //отмечаем "битые" клетки
281     switch (type)
282     {
283 		//король
284         case 1:
285         {
286             king(x,top);
287             break;
288         }
289 
290 		//слон
291 		case 2:
292 		{
293 		    bishop(x,top);
294             break;
295 		}
296 
297 		//конь
298 		case 3:
299 		{
300 		    knight(x,top);
301 			break;
302 		}
303 		//ладья
304         case 4:
305         {
306             rook(x,top);
307             break;
308         }
309         //ферзь
310         case 5:
311         {
312             rook(x,top);
313             bishop(x,top);
314             break;
315         }
316     }
317 
318     //отмечаем,что в данной клетке стоит фигура
319 	a[x] = -1;
320     stak[top] = x;
321     top++;
322 }
323 
324 void step(int top,int x,int st)
325 {
326 	int xtop = top;
327 	switch (variant)
328 	{
329 		case 1:
330 		{
331 			if (st != (n - 1))
332 			{
333 				set_figure(x,top);
334 				for (int i = 0; i < (n*n); i++)
335 					if (a[i] == 0)
336 						step(top,i,st + 1);
337 			}
338 			else[[:File:Шахматы.rar]]
339 			{
340 				set_figure(x,top);
341                 cout << endl;
342 				for (int i = 0; i < (n*n); i++)
343 				{
344 					cout.width(3);
345 					if (((i % n) == 0) && (i != 0))
346 						cout << endl;
347 					if (a[i] == -1)
348 						cout << 1;
349 					else
350 						cout << 0;
351 				}
352 				cout << endl;
353 			}
354 			break;
355 		}
356 		case 2:
357 		{
358 			set_figure(x,top);
359 			if ((st+1) > maxst)
360 				maxst = st + 1;
361 			for (int i = 0; i < (n*n); i++)
362 				if (a[i] == 0)
363 					step(top,i,st+1);
364 			break;
365 		}
366 	}
367 
368 
369 
370 // обратный ход
371     for (int i = xtop; i < top; i++)
372     {
373         if ((a[stak[i]] != -1) && (a[stak[i]] != -2))
374             a[stak[i]]--;
375         else
376             //не забываем отметить,что фигура уже здесь стояла(чтобы избежать повторов)
377             if (a[stak[i]] == -1)
378                 a[stak[i]] = -2;
379  //       cerr << " Back "  << stak[i] << endl;
380     }
381 }
382 
383 int main()
384 {
385 
386     //cin >> n >> type >> variant;
387     n = 5;
388     type = 4;
389 	variant = 1;
390     a    = new int[n*n];
391     stak = new int[n*n*4];
392 
393     for (int i = 0; i < (n*n); i++)
394     {
395         for (int j = 0; j < (n*n); j++)
396             a[j] = 0;
397         if (variant == 1)
398             cout << "__________________________________" << endl;
399         step(0,i,0);
400     }
401 	if (variant == 2)
402 	  cout << maxst;
403     return 0;
404 }

Лобанов Илья

Описание алгоритма:

Программа проверяет возможность расстановки фигур на доске M*M . При выводе на экран на экран клетки,занятые фигурами ,помечаются буквами,соответствующими первой букве типа фигуры. Также программа считает максимальное число фигур определенного типа,которые можно расставить на доске.

Инструкция:

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

  1 #include <iostream>
  2 #include <windows.h>
  3 using namespace std;
  4 
  5 enum type{peshka, king, kon, ladya, slon, queen}; // все возможные типы фигур
  6 const char symbols[] = "pKklsQ"; // буквенное обозначение каждой фигуры:p - пешка, K - король, k - конь, l- ладья, s - слон, Q - ферзь
  7 const int NONE = INT_MAX;//константа для обозначения пустой клетки
  8 int M, **desk, *colons, *rows, *diag_1, *diag_2;
  9 
 10 // структура для описания клектки доски
 11 struct point 
 12 {
 13 	int x, y;
 14 	point(int x = 0, int y = 0): x(x), y(y) {}
 15 	point &operator++()
 16 	{
 17 		if (y == M - 1)
 18 		{
 19 			++x;
 20 			y = 0;
 21 		}
 22 		else 
 23 			++y;
 24 		return *this;
 25 	}
 26 	point operator+(const point &p) const
 27 	{
 28 		return point(x + p.x, y + p.y);
 29 	}
 30 	point next() const
 31 	{
 32 		point r = *this;
 33 		return ++r;
 34 	}
 35 };
 36 
 37 
 38 int *new_array(int n)
 39 {
 40 	int *a = new int[n];
 41 	fill(a, a + n, NONE);
 42 	return a;
 43 }
 44 
 45 // Количество свободных клеток от клетки p до конца доски
 46 int rest(const point &p, type t)
 47 {
 48 	int r0 = (M - p.x) * M - p.y, r,
 49 		m = M - p.x,
 50 		s_2 = (m + 1) / 2 * M;
 51 	switch (t)
 52 	{
 53 	case peshka:
 54 	case kon:
 55 		r = s_2; break;
 56 	case king:
 57 		r = s_2 / 2; break;
 58 	case ladya:
 59 	case queen:
 60 		return m;
 61 	case slon:
 62 		r = m + M - 1;
 63 	}
 64 	return min(r0, r);
 65 }
 66 
 67 // Помечает клетку доски номером i
 68 void set(const point &p, type t, int i)
 69 {
 70 	if (t == peshka || t == king || t == kon)
 71 		desk[p.x][p.y] = i;
 72 	else
 73 	{
 74 		if (t == ladya || t == queen)
 75 			colons[p.y] = rows[p.x] = i;
 76 		if (t == slon || t == queen)
 77 			diag_1[p.x+p.y] = diag_2[p.x-p.y+M-1] = i;
 78 	}
 79 }
 80 
 81 // Можно ли поставить фигуру номер i на клетку p
 82 bool empty(const point &p, type t, int i)
 83 {
 84 	const int n_attack[3] = {4, 8, 8};
 85 	const point attack[3][8] = {{point(1, 1), point(1, -1), point(-1, 1), point(-1, -1)}, //кол-во вариантов атаки для пешки
 86 	{point(1, 1), point(1, -1), point(-1, 1), point(-1, -1), point(1, 0), point(-1, 0), point(0, 1), point(0, -1)}, // кол-во вариантов атаки для короля
 87 	{point(1, 2),point(-1, 2),point(1, -2), point (-1,-2), point (2, 1), point (2,-1), point (-2, 1),point (-2,-1)}};  //количество вариантов атаки для коня
 88 	switch(t)
 89 	{
 90 	case peshka:
 91 	case king:
 92 	case kon:
 93 		for (int k = 0; k < n_attack[t]; k++)
 94 		{
 95 			point q = p + attack[t][k];
 96 			if (q.x >= 0 && q.x < M && q.y >= 0 && q.y < M && desk[q.x][q.y] < i)
 97 				return false;
 98 		}
 99 		return true;
100 	case ladya:
101 		return colons[p.y] > i && rows[p.x] > i;
102 	case slon:
103 		return diag_1[p.x+p.y] > i && diag_2[p.x-p.y+M-1] > i;
104 	case queen:
105 		return colons[p.y] > i && rows[p.x] > i && diag_1[p.x+p.y] > i && diag_2[p.x-p.y+M-1] > i;
106 	}
107 }
108 
109 //печатает заданное количество досок на экране
110 void print(point **figures, int n_desks, int N, type t, ostream &out = cout)
111 {
112 	HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
113 	for (int n = 0; n < n_desks; n++)
114 	{
115 		out << " \xdb";
116 		for (int i = 0; i < M * 2 + 2; i++)
117 			out << "\xdf";
118 		out << "\xdb";
119 	}
120 	out << endl;
121 
122 	int *K = new int[n_desks];
123 	fill(K, K + n_desks, 0);
124 	for (int i = 0; i < M; i++)
125 	{
126 		for (int n = 0; n < n_desks; n++)
127 		{
128 			int &k = K[n];
129 			out << " \xdb ";
130 			for (int j = 0; j < M; j++)
131 			{
132 				SetConsoleTextAttribute(hConsole, (i + j) % 2 == 0 ? 0xf0 : 0xf);
133 				if (k < N && i == figures[n][k].x && j == figures[n][k].y)
134 				{			
135 					out << ' ' << symbols[t];
136 					k++;
137 				}
138 				else
139 					out << "  ";
140 			}
141 			SetConsoleTextAttribute(hConsole, 0x70);
142 			out << " \xdb";
143 		}
144 		out << endl;
145 	}
146 	delete[] K;
147 
148 	for (int n = 0; n < n_desks; n++)
149 	{
150 		out << " \xdb";
151 		for (int i = 0; i < M * 2 + 2; i++)
152 			out << "\xdc";
153 		out << "\xdb";
154 	}
155 	out << endl << endl;
156 }
157 
158 // Вывести все возможные расположения на доске N фигур
159 void all_placements(int N, type t)
160 {
161 	desk = NULL;
162 	colons = rows = diag_1 = diag_2 = NULL;
163 	// создание необходимых массивов, отмечающих занятость клеток, в зависимости от вида фигуры
164 	if (t == peshka || t == king || t == kon)
165 	{
166 		desk = new int*[M];
167 		for (int j = 0; j < M; j++)
168 			desk[j] = new_array(M);
169 	}
170 	else
171 	{
172 		if (t == ladya || t == queen)
173 		{
174 			colons = new_array(M);
175 			rows = new_array(M);
176 		}
177 		if (t == slon || t == queen)
178 		{
179 			diag_1 = new_array(2*M-1);
180 			diag_2 = new_array(2*M-1);
181 		}
182 	}
183 	
184 	const int W = 80 / (2 * M + 5);//количество досок,помещающихся на экране
185 	point **figures = new point*[W];//массив фигур
186 	for (int j = 0; j < W; j++)
187 		figures[j] = new point[N];
188 
189 	int i = 0, // номер фигуры
190 		k = 0; //номер комбинации
191 	while (true)
192 	{
193 		if (rest(figures[k%W][i], t) < N - i) // если оставшиеся фигуры не помещаются на доске
194 		{
195 			if (i == 0) // если все комбинации закончились
196 			{
197 				// вывод оставшихся досок
198 				if (k % W)
199 					print(figures, k % W, N, t);
200 				cout << "Amount of combinations: " << k << endl;
201 				break;
202 			}
203 			// переходим к предыдущей фигуре и помечаем клетку пустой
204 			set(figures[k%W][--i], t, NONE);
205 			// сдвигаем фигуру на шаг вперёд
206 			++figures[k%W][i];
207 		}
208 		else if (!empty(figures[k%W][i], t, i)) // если фигуры помещаются, но текущая клетка под ударом
209 			// сдвигаем текущую фигуру на шаг вперёд
210 			++figures[k%W][i];
211 		else if (i == N - 1) // если ставим последнюю фигуру
212 		{
213 			// если текущая доска - последняя на строке экрана, выводим W досок
214 			if ((k + 1) % W == 0)
215 				print(figures, W, N, t);
216 			// копирование комбинаций фигур на следующую доску
217 			for (int j = 0; j < N; j++)
218 				figures[(k+1)%W][j] = figures[k%W][j];
219 			// переход к следующей доске
220 			k++;
221 			//сдвигаем текущую фигуру на шаг вперёд
222 			++figures[k%W][i];
223 		}
224 		else // если ставим не последнюю фигуру
225 		{
226 			// помечаем текущую клетку номером i
227 			set(figures[k%W][i], t, i);
228 			//ставим следующую фигуру на клетку после текущей
229 			figures[k%W][i+1] = figures[k%W][i].next();
230 			// переходим к следующей фигуре
231 			i++;
232 		}
233 	}
234 
235 	//освобождение памяти
236 	for (int j = 0; j < W; j++)
237 		delete[] figures[j];
238 	delete[] figures;
239 	if (desk)
240 	{
241 		for (int j = 0; j < M; j++)
242 			delete[] desk[j];
243 		delete[] desk;
244 	}
245 	if (colons)
246 	{
247 		delete[] colons;
248 		delete[] rows;
249 	}
250 	if (diag_1)
251 	{
252 		delete[] diag_1;
253 		delete[] diag_2;
254 	}
255 }
256 
257 
258 int main()
259 {
260 	system("color 70"); // Установка серого фона и чёрного текста
261 	while (true)
262 	{
263 		cout << "Choose the mode:\n1 - all possible variants of figures' placement\n2 - maximum number of figures which can be placed on the desk\nq - quit\n\n";
264 		char c;
265 		cin >> c;
266 		cin.ignore(100, '\n');
267 		switch (c)
268 		{
269 		case '1':
270 		case '2':
271 			cout << "Enter the desk size please. (The number must be even and not more than 37.)\n";
272 			cin >> M;
273 			while (!cin || M % 2 != 0 || M > 37 || M <= 0)
274 			{
275 				cout << "Error: wrong desk size. Try again please.\n";
276 				cin.clear();
277 				cin.ignore(100, '\n');
278 				cin >> M;
279 			}
280 			cin.ignore(100, '\n');
281 			cout << "Choose a figure, please.\n p - peshka, k - kon, l - ladya, s - slon, Q - Queen, K - King\n";
282 			char f;
283 			cin >> f;
284 			cin.ignore(100, '\n');
285 			type t;
286 			int i;
287 			do
288 			{
289 				for (i = 0; i < 6; i++)
290 				{
291 					if (symbols[i] == f)
292 					{
293 						t = type(i);
294 						break;
295 					}
296 				}
297 				if (i == 6)
298 				{
299 					cout << "Enter the right letter, you've chosen the wrong one.\n";
300 					cin >> f;
301 					cin.ignore(100, '\n');
302 				}
303 			} while (i == 6);
304 			if (c == '1')
305 			{
306 				cout << "Enter the number of figures please.\n";
307 				int N;
308 				cin >> N;
309 				while (!cin || N <= 0)
310 				{
311 					cout << "Error: wrong argument. Try again please.\n";
312 					cin.clear();
313 					cin.ignore(100, '\n');
314 					cin >> N;
315 				}
316 				cin.ignore(100, '\n');
317 				all_placements(N, t);
318 			}
319 			else
320 			{
321 				cout << "The maximal number of figures is ";
322 				switch (t)
323 				{
324 				case peshka:
325 					cout << M*M/2; break;
326 				case king:
327 					cout << M*M/4; break;
328 				case kon: 
329 					cout << (M == 2 ? 4 : M*M/2); break;
330 				case ladya:
331 					cout << M; break;
332 				case slon:
333 					cout << 2*M - 2; break;
334 				case queen:
335 					cout << (M == 2 ? 1 : M);
336 				}
337 				cout << ".\n";
338 			}
339 			break;
340 		case 'q':
341 			cout << endl;
342 			return 0;
343 		default:
344 			cout << "You've chosen the wrong command, try again please.\n";
345 		}
346 		cout << endl << endl;
347 	}
348 }

Лосева Татьяна

Краткое описание алгоритма : Доска представлена в виде динамического массива;Для каждой фигуры написана отдельная функция проверки на возможность установки фигуры,проверяющая, находится ли эта фигура под ударом других. После выбора типа фигуры,используется рекурсивная функция,которая проверяет возможные расстановки через данную функцию проверки ,для данного типа фигуры. Для поиска максимального значения мы проверяем расстановку начиная с 0 количество фигур ,каждый раз увеличивая на 1,если количество расстановок станет равно нулю,то предыдущее количество фигур было максимальным.

Инструкция : Пользователя попросят ввести размер доски,затем выбрать один из вариантов работы программы:1.поиск возможных расстановок для M фигур или 2.поиск максимального количества расстановок для данного поля,затем попросят выбрать тип фигуры и в первом случае количество фигур.При выводе на экран выводится номер расстановки и доска,на доске F- обозначены занятые клетки,0-пуская клетка. Для 2 пункта выводится лишь число: максимальное количество фигур,которое можно расставить.

Скачать можно : тут


  1 #include<iostream>
  2 using namespace std;
  3 int N;//размер доски NxN
  4 int **a;
  5 int *ax;
  6 int *by;
  7 int l = 0;//L-номер пункта в меню
  8 int M;//количество фигур
  9 bool isPrint = false;//переменная для вывода на экран,когда требуется,для удобства обозначим в начале false
 10 
 11 
 12 void print()//функция вывода на экран
 13 {
 14 	for (int i = N - 1; i >= 0; --i)
 15 	{
 16 		for (int j = 0; j < N; ++j)
 17 		{
 18 			cout << ((a[j][i]) ? "F " : "0 ");//если (a[j][i]) истина,то есть клетка занята,ставим F,в другом случае,т.е.свободна,ставим 0
 19 		}
 20 		cout << '\n';
 21 	}
 22 	cout << '\n';
 23 
 24 }
 25 bool Lad(int x, int y)//Ладья
 26 {
 27 	for (int i = 0; i < N; ++i)
 28 	{
 29 		if (a[i][y] == 1 )//проверяем горизонталь:если клетка занята
 30 		{
 31 			return false;//возвращаем false
 32 		}
 33 		if (a[x][i] == 1)//проверяем вертикаль : если хотя бы одна клетка занята,то
 34 		{
 35 			return false;//возврашаем false
 36 		}
 37 	}
 38 	return true;//ничего выше не выполняется,значит возвращаем правду:вертикаль и горизонталь свободна
 39 
 40 }
 41 
 42 bool Kon(int x, int y)//Коняша
 43 {
 44 	int i[8] = {-2, -2, -1, -1, 1, 1, 2, 2};//координаты клеток,на которые может ходить конь,относительно текущей (8 вариантов)
 45 	int j[8] = {-1, 1, -2, 2, -2, 2, -1, 1};
 46 	
 47 	for (int k = 0; k < 8; k++)//8 вариантов хода
 48 	
 49 	{
 50 		if (x + i[k] >= 0 && x + i[k] < N && y + j[k] >= 0 && y + j[k] < N)//проверка выхода за границы массива
 51 		{
 52 			if (a[x + i[k]][y + j[k]] != 0)//клетка занята 
 53 			{
 54 				return false;//возвращем false
 55 			}
 56 		}
 57 	}
 58 	return true;////ничего выше не выполняется,значит возвращаем правду:все варианты ходов  свободны и конь никого не перебивает,тогда можно занять клетку
 59 
 60 }
 61 
 62 
 63 
 64 
 65 bool Korol(int x, int y)//Король
 66 	{
 67 
 68 	int i[8] = { -1, -1, -1, 0, 0, 1, 1, 1 };//координаты клеток,на которые может ходить король,относительно текущей 
 69     int j[8] = { -1, 0, 1, -1, 1, -1, 0, 1 };
 70 
 71 	for(int k = 0; k < 8; k++)//8 вариантов хода
 72 	{
 73 		if (x + i[k] >= 0 && x + i[k] < N && y + j[k] >= 0 && y + j[k] < N)//прроверяем не выходит ли фигура за границы массива
 74 		{
 75 			if (a[x + i[k]][y + j[k]] != 0)//если какой нибудь из вариантов хода занят
 76 			{
 77 				return false;//то false
 78 			}
 79 		}
 80 	}
 81 	return true;//свободно,можно занимать
 82 }
 83 
 84 bool Slon(int x, int y)
 85 {
 86 	int p1 = y - x;//номер диагонали слева направо
 87 	int p2 = y + x;//номер диагонали с права налево
 88 	for (int i = 0; i < N; i++)//проверяем левую диагональ
 89 	{
 90 		if (i + p1 >= 0 && i + p1 < N)//проверка на выход за границы массива
 91 		{
 92 			if (a[i][i + p1] == 1) //проверяем диагональ
 93 			{
 94 				return false;//диагональ занята
 95 			}
 96 		}
 97 		if (-i + p2 >= 0 && -i + p2 < N)//вторая диагональ
 98 		{
 99 			if (a[i][-i + p2] == 1) 
100 			{
101 				return false;//вторая диагональ занята
102 			}
103 		}
104 	}
105 	return true;//обе диагонали свободны,ура!
106 }
107 
108 bool Check(int x, int y)//Ферзь=Ладья+Слон
109 {
110 	int p1 = y - x;//диагональ 1
111 	int p2 = y + x;//диагональ 2
112 	for (int i = 0; i < N; ++i)
113 	{
114 		if (a[i][y] == 1 )//проверяем горизонталь
115 		{
116 			return false;//занято
117 		}
118 		if (a[x][i] == 1)//проверяем вертикаль
119 		{
120 			return false;//занято
121 		}
122 		
123 		if (i + p1 >= 0 && i + p1 < N)//выход за границы массива
124 		{
125 			if (a[i][i + p1] == 1) //проверяем 1 диагональ
126 			{
127 				return false;//занято
128 			}
129 		}
130 		if (-i + p2 >= 0 && -i + p2 < N)//выход за границы массива
131 		{
132 			if (a[i][-i + p2] == 1)//проверяем 2ую диагональ
133 			{
134 				return false;//занято
135 			}
136 		}
137 	}
138 	return true;//свободно!
139 }
140 
141 int  menu1()
142 {
143 	cout << "Type of figure:" << endl << "1 - Ferz" << endl << "2 - Ladya" << endl << "3 - Slon" << endl << "4 - Kon" << endl << "5 - Korol" << endl;
144 	cin >> l;
145 	return l;
146 }
147 
148 int num = 0;//номер расстановки
149 			//пробует найти результаты решений.
150 
151 void Func(int d,int K) //d-глубина рекурсии;K-сколько фигур нужно расставить
152 {
153 	if (d == K)//когда расставили нужное количество
154 	{
155 		if (isPrint)//если true,то печатаем(в случае с MAX количеством доску печатать не нужно)
156 		{
157 			cout << "Result: " << num + 1 << '\n';//выводим нормер расстановки
158 			print();//печатаем доску
159 		}
160 		num++;//номер расстановки увеличивается
161 		return;
162 	}
163 
164 	int minX = d != 0 ? ax[d - 1] : 0;//исходя из того куда быда поставлена предыдущая фигура
165 	//,накладываются ограничения для выбора места новой,чтобы избежать поторений
166 	int minY = d != 0 ? by[d - 1] + 1 : 0;
167 
168 
169 	bool isPossible = false;//Проверяет,возможно ли занять клетку
170 	for (int i = minX; i < N; ++i)
171 	{
172 
173 		for (int j = (i != minX) ? 0 : minY; j < N; ++j)
174 		{
175 			switch (l)//l- номер пункта в меню с фигурами
176 			{
177 			case 1://ферзь
178 				isPossible = Check(i, j);
179 				break;
180 			case 2://Ладья
181 				isPossible = Lad(i, j);
182 				break;
183 			case 3://Слон
184 				
185 				isPossible = Slon(i, j);
186 				break;
187 			case 4://Конь
188 				isPossible = Kon(i, j);
189 				break;
190 			case 5://Король
191 				isPossible = Korol(i, j);
192 				break;
193 			}
194 			if (isPossible)//если клетку занять возмоно(функция вернула true)
195 			{
196 			   a[i][j] = 1;//занимаем клетку
197 				ax[d] = i;//запоминаем куда была поставлена фигура
198 				by[d] = j;//запоминаем куда была поставлена фигура
199 				Func(d + 1, K);//вызываем рекурсивно
200 				a[i][j] = 0;
201 			}
202 		}
203 	}
204 
205 	return;
206 }
207 
208 int main()
209 {
210 
211 	cout << "Enter size: ";//нужно ввести размер доски
212 	cin >> N;//считываем размер доски
213 
214 	a = new int*[N];//создаём двумерный массив,т.е.нашу доску
215 	for (int i = 0; i < N; i++)
216 	{
217 		a[i] = new int[N];
218 		for (int j = 0; j < N; j++)
219 			a[i][j] = 0;//заполняем нулями
220 	}
221 	
222 	ax = new int[N];//массивы для сохранения координаты каждой фигуры,чтобы избежать повторений
223 	by = new int[N];
224 
225 	int d;//пункт в меню
226 	cout<<"1 - Rasstanovka figur"<<endl<<"2 - MAX znachenie"<<endl;//два варианта работы программы
227 	cin>>d;//считываем выбор пользователя
228 	if(d==1)//если выбирает расстановку
229 	{   
230 		menu1();//то спрашиваем для какой фигуры
231 		cout<<"How many figures?"<<endl;//и как много будет фигур
232 	    cin>>M;//считываем количество фигур
233 		isPrint = true;//в этом случае будем выводить на экран
234 		Func(0,M);//запуск рекурсивной функции
235 	}
236 
237 	if (d == 2)//случай подсчёта максимального значения
238 	{
239 		int n = 0;//изачально max=0
240 		menu1();//выбираем фигуру
241 		
242 		do//начало цикла 
243 		{
244 			num = 0;
245 			Func(0, ++n);//запускаем каждый раз увеличивая значение фигур и считаем количество расстановок
246 		} while (num != 0);//количество вариантов не должно быть равно нулю
247 		cout <<"MAX ="<< n - 1 << endl;//если количество вариантов = 0,то выходим из цикла и предыдущее значение  максимальное
248 	}
249 	
250 
251 	int z;
252 	cin >> z;
253 
254 	return 0;
255 }

Сергей Ляжков Инструкция: Вводите необходимые данные(кол-во строк, столбцов, фигуры, тип расстановки) согласно последовательности выполнения программы Краткое описание алгоритма: 1)Выделяет память под доску(динамическая матрица) 2)Устанавливает каждую следующую фигуру на n-е свободное место которое он нашел после последней установленной фигуры, где n изменяется от 1 до бесконечности(установка заканчивается тогда, когда программа не может установить очередную фигуру). 3)Счетчик количества фигур, которые необходимо установить, уменьшается на 1 после каждой установки. 4)После того, как фигура установлена, программа рекурсивно вызывает функцию установки очередной фигуры(возвращается в пункт 2) 5)В рекурсивную функцию отправляется только копия доски. Таким образом, возвращаясь из рекурсии, мы получаем доску без последующих установленных фигур. Когда счетчик фигур, которые необходимо установить, уменьшается до нуля, данное поле сохраняется в списке. 6)Вывод списка. Скачать можно тут


Нарядчиков Александр
Инструкция: Запустить программу, следовать указаниям, полученным в меню программы.
Описание программы: Шахматное поле представлено в виде двумерного массив N на M, значения N и M пользователь вводит самостоятельно, память выделяется динамически. Также пользователь выбирает тип и количество фигур на поле. В меню можно выбрать между поиском максимально возможного числа фигур на столе и поиском всех расстановок с дальнейшей записью полей в файл.
Описание алгоритма: При поиске всех расстановок происходит установка выбранной фигуры в свободную клетку, далее происходит маркирование тех клеток, в которые уже невозможно поставить фигуру данного типа, затем процесс происходит снова(рекурсия) пока на поле не окажется выбранное пользователем число фигур. Под конец данное поле записывается в файл и происходит поиск других возможных расстановок данного типа. В конце получаем файл со всеми вариантами расстановок и их количеством. При поиске наибольшего числа фигур на доске программа ищет расстановку для одной фигуры, затем для двух, если это возможно и т.д. С каждым разом происходит увеличение счетчика количества фигур на поле, тем самым в конце данного алгоритма мы получаем максимально возможное число данного типа фигур на доске данного размера.

"T04CHESS.CPP"

  1 /* FILENAME: T04CHESS.CPP
  2  * LAST UPDATE: 17.01.2016
  3  */
  4 
  5 #include "CHESS.h"
  6 
  7 /* Main function */
  8 int main( void )
  9 {
 10 	// Переменная, отвечающая за выход из меню
 11 	int IsReady = 1;
 12 	// Количество строк поля; количество столбцов поля
 13 	int N, M;
 14 	// Если идет поиск всех расстановок - 0; если идет поиск максимального числа фигур на доске - 1
 15 	int IsCount;
 16 	// Количество фигур на поле
 17 	int Number;
 18 	// Тип фигуры; количество разных расстановок; максимальное число фигур на доске
 19 	int tmp, count, max_value = 1;
 20 	// Создание указателя на тип FILE
 21 	FILE *F;
 22 
 23 	// Консольное меню
 24 	while (IsReady == 1)
 25 	{
 26 		cout << "Input figure type:\n1 - castle\n2 - bishop\n3 - knight\n4 - queen\n5 - king\n";
 27 		cin >> tmp;
 28 
 29 		cout << "Input number of rows on the field:\n";
 30 		cin >> N;
 31 
 32 		cout << "Input number of columns on the field:\n";
 33 		cin >> M;
 34 
 35 		// Поле шахмат
 36 		chess desk(N, M);
 37 
 38 		// Обнуление поля
 39 		desk.Clear();
 40 
 41 		cout << "Input in what mode do you want to work:\n0 - Searching for all fields variants\n1 - Searching for the maximum number of chessmen\n";
 42 		cin >> IsCount;
 43 
 44 		// Если идет поиск всех расстановок
 45 		if (IsCount == 0)
 46 		{
 47 			cout << "Input number of chessmen on the field:\n";
 48 			cin >> Number;
 49 
 50 			// Создание файла и его открытие
 51 			fopen_s(&F, "chess.txt", "wt");
 52 			if ((type)(tmp + 1) == 2)
 53 				fputs("Castles' fields:\n", F);
 54 			else if ((type)(tmp + 1) == 3)
 55 				fputs("Bishops' fields:\n", F);
 56 			else if ((type)(tmp + 1) == 4)
 57 				fputs("Knights' fields:\n", F);
 58 			else if ((type)(tmp + 1) == 5)
 59 				fputs("Quenns' fields:\n", F);
 60 			else if ((type)(tmp + 1) == 6)
 61 				fputs("Kings' fields:\n", F);
 62 			else
 63 			{
 64 				fputs("Error\n", F);
 65 				return 0;
 66 			}
 67 			// Закрытие файла
 68 			fclose(F);
 69 
 70 			// Количество разных расстановок
 71 			count = desk.FillField(IsCount, (type)(tmp + 1), 0, 0, Number, 0);
 72 
 73 			// Открытие файла в режиме повторной записи
 74 			fopen_s(&F, "chess.txt", "at");
 75 			fprintf(F, "\nNumber of fields: %i", count);
 76 			// Закрытие файла
 77 			fclose(F);
 78 
 79 			cout << "Done!\nCheck 'chess.txt' to see results\n";
 80 		}
 81 
 82 		// Если идет поиск максимального числа фигур на доске
 83 		else if (IsCount == 1)
 84 		{
 85 			while (desk.FillField(IsCount, (type)(tmp + 1), 0, 0, max_value, 0))
 86 				max_value++;
 87 			cout << "The maximum number of chessmen on the board is " << (max_value - 1) << endl;
 88 			max_value = 1;
 89 		}
 90 
 91 		// Если было введено некорректное значение для IsCount
 92 		else
 93 			cout << "Error\n";
 94 
 95 		// Продолжение работы с программой
 96 		cout << "Press '1' if you want to continue\nPress another number if you want to exit\n";
 97 		cin >> IsReady;
 98 
 99 		if (IsReady == 1)
100 			continue;
101 		else
102 			exit(0);
103 	}
104 
105 	return 0;
106 } // End of 'main' function
107 
108 // END OF 'T04CHESS.CPP' FILE

"CHESS.CPP"

  1 /* FILENAME: CHESS.CPP
  2  * LAST UPDATE: 17.01.2016
  3  */
  4 
  5 #include "CHESS.H"
  6 
  7 // Количество расстановок
  8 int Result_count = 0;
  9 
 10 /* Clear field function */
 11 // Обнуление поля
 12 void chess::Clear( void )
 13 {
 14 	// Все клетки свободны
 15 	for (int i = 0; i < N; i++)
 16 		for (int j = 0; j < M; j++)
 17 			Field[i][j] = Free;
 18 } // End of 'Clear' function
 19 
 20 /* Check if the cell is available that function */
 21 // Проверка, свободна и существует ли данная клетка
 22 int chess::IsAvailable( int x, int y )
 23 {
 24 	if (x >= 0 && y >= 0 && x < M && y < N)
 25 		if (Field[y][x] == Free)
 26 		  return 1;
 27 	
 28 	return 0;
 29 } // End of 'IsAvailable' function
 30 
 31 /* Output field in file function */
 32 // Запись одного поля в файл
 33 void chess::OutputInFile( void )
 34 {
 35 	// Создание указателя на тип FILE
 36 	FILE *F;
 37 
 38 	// Открытие файла в режиме повторной записи
 39 	fopen_s(&F, "chess.txt", "at");
 40 
 41 	// Переход на следующую строку файла
 42 	fputc('\n', F);
 43 
 44 	// Заполнение файла текущем полем
 45 	for (int i = 0; i < N; ++i)
 46 	{
 47 		// '*' - свободная клетка; '#' - клетка, которая уже занята
 48 		for (int j = 0; j < M; ++j)
 49 			(Field[i][j] == Free || Field[i][j] == busy) ? fputc('*', F) : fputc('#', F);
 50 		// Переход на следующую строку файла
 51 		fputc('\n', F);
 52 	}
 53 
 54 	// Закрытие файла
 55 	fclose(F);
 56 } /* End of 'OutputInFile' function */
 57 
 58 /* Copy desks function */
 59 // Копирование поля
 60 void chess::Copy( chess &desk2 )
 61 {
 62   for (int i = 0; i < N; i++)
 63 		for (int j = 0; j < M; j++)
 64 			desk2.Field[i][j] = Field[i][j];
 65 } // End of 'Copy' function
 66 
 67 /* Fill field function */
 68 // Заполнение полей и поиск максимального числа расстановок
 69 // Chessmen_num - количество фигур, которое нужно поставить; Already_stood - количество, которое уже стоит
 70 int chess::FillField( int IsCount, type set, int x, int y, int Chessmen_num, int Already_stood )
 71 {
 72 	int i, j, k, l;
 73 	chess desk2(N, M);
 74 
 75 	// Обнуление поля
 76 	desk2.Clear();
 77 
 78 	// Пробег по всем оставшимся клеткам поля, начиная с той, на которой мы закончили предыдущую итерацию
 79 	for (i = y; i < N; i++)
 80 		for (j = ((i == y) ? x : 0); j < M; j++)
 81 		{
 82 			// Если клетка свободна
 83 			if (Field[i][j] == Free)
 84 			{
 85 				// Копируем доску
 86 				Copy(desk2);
 87 				
 88 				// Множественный выбор типа фигуры
 89 				switch (set)
 90 				{
 91 				// Ладья
 92 				case castle:
 93 					for (k = 0; k < N; k++) 
 94 					{ 
 95 						// Движение по столбцу
 96 						if (desk2.Field[k][j] == Free)
 97 						  desk2.Field[k][j] = busy; 
 98 						// Движение по строке
 99 						if (desk2.Field[i][k] == Free)
100 						  desk2.Field[i][k] = busy; 
101 					}
102 					break;
103 				// Слон
104 				case bishop:
105 					// Выбор и поиск наибольшей существующей на поле диагонали
106 					for (k = 1 - (N < M ? N : M); k < (N < M ? N : M); k++)
107 					{ 
108 						// Проход из левого верхнего угла до правого нижнего 
109 						if (IsAvailable(j + k, i + k))
110 							desk2.Field[i + k][j + k] = busy;
111 						// Проход из левого нижнего до правого верхнего
112 						if (IsAvailable(j + k, i - k))
113 							desk2.Field[i - k][j + k] = busy;
114 					}
115 					break;
116 				// Конь
117 				case knight:
118 					// Ходы коня, k - приращение по X, l - по Y
119 					k = -2, l = 1; 
120 					// Проверка возможности хода в данную клетку
121 					if (IsAvailable(j + k, i + l))
122 						desk2.Field[i + l][j + k] = busy;
123 					
124 					k = -2, l = -1; 
125 					// Проверка возможности хода в данную клетку
126 					if (IsAvailable(j + k, i + l))
127 						desk2.Field[i + l][j + k] = busy;
128 					
129 					k = -1, l = 2; 
130 					// Проверка возможности хода в данную клетку
131 					if (IsAvailable(j + k, i + l))
132 						desk2.Field[i + l][j + k] = busy;
133 					
134 					k = -1, l = -2; 
135 					// Проверка возможности хода в данную клетку
136 					if (IsAvailable(j + k, i + l))
137 						desk2.Field[i + l][j + k] = busy;
138 					
139 					k = 1, l = 2; 
140 					// Проверка возможности хода в данную клетку
141 					if (IsAvailable(j + k, i + l))
142 						desk2.Field[i + l][j + k] = busy;
143 					
144 					k = 1, l = -2; 
145 					// Проверка возможности хода в данную клетку
146 					if (IsAvailable(j + k, i + l))
147 						desk2.Field[i + l][j + k] = busy;
148 					
149 					k = 2, l = 1; 
150 					// Проверка возможности хода в данную клетку
151 					if (IsAvailable(j + k, i + l))
152 						desk2.Field[i + l][j + k] = busy;
153 					
154 					k = 2, l = -1; 
155 					// Проверка возможности хода в данную клетку
156 					if (IsAvailable(j + k, i + l))
157 						desk2.Field[i + l][j + k] = busy;
158 					break;
159 				// Ферзь
160 				case queen:
161 					for (k = 0; k < N; k++)
162 					{
163 						// Движение по столбцу
164 						if (desk2.Field[k][j] == Free)
165 							desk2.Field[k][j] = busy;
166 						// Движение по строке
167 						if (desk2.Field[i][k] == Free)
168 							desk2.Field[i][k] = busy;
169 					}
170 					
171 					// Выбор и поиск наибольшей существующей на поле диагонали
172 					for (k = 1 - (N < M ? N : M); k < (N < M ? N : M); k++)
173 					{
174 						// Проход из левого верхнего угла до правого нижнего 
175 						if (IsAvailable(j + k, i + k))
176 							desk2.Field[i + k][j + k] = busy;
177 						// Проход из левого нижнего до правого верхнего
178 						if (IsAvailable(j + k, i - k))
179 							desk2.Field[i - k][j + k] = busy;
180 					}
181 					break;
182 				// Король
183 				case king:
184 				  // Проход по квадрату 3 на 3, построенному центром на клетке, в которой стоит король
185 					for (k = -1; k < 2; k++)
186 						for (l = -1; l < 2; l++)
187 							if (IsAvailable(j + k, i + l))
188 								desk2.Field[i + l][j + k] = busy;
189 					break;
190 				}
191 				// Установка фигуры в данную клетку
192 				desk2.Field[i][j] = set;
193         
194 				// Проверяем, что количество поставленных фигур, которое равно номеру итерации, меньше чем необходимое число фигур
195 				if ((Already_stood + 1) < Chessmen_num)
196 				{
197 					// Если идет поиск всех расстановок, то запускаем следующий шаг
198 					if (IsCount == 0)
199 						desk2.FillField(IsCount, set, j, i, Chessmen_num, Already_stood + 1);
200 					// Если идет поиск максимального числа фигур на доске и была найдена хотя бы одна расстоновка, то возвращаем 1
201 					else if ((IsCount == 1) && desk2.FillField(IsCount, set, j, i, Chessmen_num, Already_stood + 1))
202 						return 1;
203 				}
204 
205 				// Если количество поставленных фигур равно необходимому числу фигур
206 				else if ((Already_stood + 1) == Chessmen_num)
207 				{
208 					// Если идет поиск всех расстановок, то увеличиваем количество расстоновок на одну и записываем поле в файл  
209 					if (IsCount == 0)
210 					{
211 						Result_count++;
212 					  desk2.OutputInFile();
213 					}
214 					// Если идет поиск максимального числа фигур на доске, значит расстановка существует, возвращаем 1
215 					else if (IsCount == 1)
216 						return 1;
217 			  }
218 			}
219 		}
220 		// Если идет поиск всех расстановок, то возвращаем количество расстановок
221 		if (IsCount == 0)
222 		  return Result_count;
223 		// Если идет поиск максимального числа фигур на доске, то возвращаем 0
224 		else if (IsCount == 1)
225 		  return 0;
226 } // End of 'FillField' function
227 
228 // END OF 'CHESS.CPP' FILE

"CHESS.H"

 1 /* FILENAME: CHESS.H
 2  * LAST UPDATE: 17.01.2016
 3  */
 4 
 5 #ifndef __CHESS_H_ 
 6 #define __CHESS_H_
 7 
 8 #include <iostream>
 9 #include <conio.h>
10 
11 using namespace std;
12 
13 // свободен, занят, ладья, слон, конь, ферзь, король
14 enum type { Free, busy, castle, bishop, knight, queen, king };
15 
16 /* Chess class */
17 class chess
18 {
19 private:
20 	// Поле данных фигур
21 	type **Field;
22 	// Количество строк поля; количество столбцов поля
23 	int N, M;
24 public:
25 	/* Default constructor */
26 	chess( void )
27 	{
28 		N = 8, M = 8;
29 		
30 		// Выделение памяти под массив поля
31 		Field = new type*[N];
32 		for (int i = 0; i < N; i++)
33 			Field[i] = new type[M];
34 	}
35 	
36 	/* Class constructor */
37 	chess( int _N, int _M ) : N(_N), M(_M)
38 	{
39 		// Выделение памяти под массив поля
40 		Field = new type* [N];
41 		for (int i = 0; i < N; i++)
42 			Field[i] = new type [M];
43 	}
44 
45 	/* Class destructor */
46 	~chess( void )
47 	{
48 		// Чистка памяти
49 		for (int i = 0; i < N; i++)
50 			delete[] Field[i];
51 		delete[] Field;
52 	}
53 
54 	/* Clear field function */
55 	void Clear( void );
56 	
57 	/* Check if the cell is available that function */
58 	int IsAvailable( int x, int y );
59 		
60 	/* Output field in file function */
61 	void OutputInFile( void );
62 	
63 	/* Copy desks function */
64 	void Copy( chess& desk2 );
65 	
66 	/* Fill field function */
67 	int FillField ( int IsCount, type set, int x, int y, int Chessmen_num, int Already_stood);
68 }; // end of 'chess' class
69 
70 #endif /*__CHESS_H_ */
71 
72 // END OF 'CHESS.H' FILE

Скачать архив


Рубинова Раиса

Основная идея программы: программа позволяет выводить на экран всевозможные расстановки n однотипных фигур на шахматной доске размером n*n так, чтобы ни одна из фигур не била другую.

Скачать можно тут.

  1 #include <iostream>
  2 #include <cstring>
  3 #include <cstdlib>
  4 #include <ctime>
  5 
  6 using namespace std;
  7 int R = 0; ///переменная, отвечающая за количество вариантов расстановок
  8 int N; ///количество фигур для расстановки, которое задает пользователь
  9 int **B; ///двумерный массив, отображающий шахматную доску
 10 int M; /// размер шахматной доски
 11 
 12 
 13 void showBoard() ///функция, выводящая доску на экран
 14 {
 15     for(int i=0; i<M; ++i) /// строки
 16     {
 17         for(int j=0; j<M; ++j)  /// столбцы
 18             {cout << B[i][j] << " ";} ///заполнение клетки с координатами i;j
 19         cout << endl;
 20     }
 21     cout << "Variant " << ++R << "\n\n"; ///вывод номера варианта расположения с последующим переходом на новую строку
 22     return;
 23 }
 24 
 25 bool checkQueen(int a, int b) /// функция, проверяющая, не бьется ли ферзь другим ферзем
 26 {
 27     for (int i = 0; i < M; ++i) ///проверка строки
 28     {
 29         if(B[a][i])
 30             return false;
 31     }
 32 
 33     for(int i = 0; i < M; ++i) ///проверка столбца
 34     {
 35         if(B[i][b])
 36             return false;
 37     }
 38 
 39     for(int i = 1; a-i >= 0 && b-i >= 0; ++i)///по диагонали влево-вверх
 40     {
 41         if(B[a-i][b-i])
 42             return false;
 43     }
 44 
 45     for(int i = 1; a+i < M && b+i < M; ++i)///по диагонали вправо-вниз
 46     {
 47         if(B[a+i][b+i])
 48             return false;
 49     }
 50 
 51     for(int i = 1; a+i < M && b-i >= 0; ++i)///по диагонали влево-вниз
 52     {
 53         if(B[a+i][b-i])
 54             return false;
 55     }
 56 
 57     for(int i = 1; a-i >= 0 && b+i < M; ++i)///по диагонали вправо-вверх
 58     {
 59         if(B[a-i][b+i])
 60             return false;
 61     }
 62 
 63     return true;
 64 }
 65 
 66 void Queen(int a, int count) ///функция, расстанавливающая ферзи
 67 {
 68     for(int b = 0; b < M; ++b) /// расстановка по изменению номера столбца
 69     {
 70         if(checkQueen(a, b)) ///проверка, бьется ли данная клетка ферзем
 71         {
 72             B[a][b] = 1; ///заполнение первой клетки
 73             for(int i = a+1; i < M; ++i) ///расстановка указанного пользователем количества фигур
 74                 Queen(i,count+1);
 75             if(count+1==N) /// проверка, расставили ли мы нужное количество фигур
 76                 showBoard();
 77             B[a][b]=0; ///обнуление переменной
 78         }
 79     }
 80 }
 81 
 82 bool checkRook(int a, int b) /// функция, проверяющая ли данную клетку ладья
 83 {
 84     for (int i = 0; i < M; ++i) ///проверка строки
 85     {
 86         if(B[a][i])
 87             return false;
 88     }
 89 
 90     for(int i = 0; i < M; ++i) ///проверка столбца
 91     {
 92         if(B[i][b])
 93             return false;
 94     }
 95 
 96     return true;
 97 }
 98 
 99 void Rook(int a, int count) ///функция, расстанавливающая ладьи
100 {
101     for(int b = 0; b < M; ++b) /// расстановка по строкам с изменением номера столбца
102     {
103         if(checkRook(a, b)) ///проверка, бьется ли данная клетка ладьей
104         {
105             B[a][b] = 1; ///установка ладьи
106             for(int i =a+1; i<M; ++i)
107                 Rook(i,count+1);
108             if(count+1 == N) /// проверка, расставили ли мы нужное количество элементов
109                 showBoard();
110 
111             B[a][b]=0; ///обнуление переменной
112         }
113     }
114 }
115 
116 bool checkElephant(int a, int b) /// функция, проверяющая, бьется ли данная клетка слоном
117 {
118     for(int i = 1; a-i >= 0 && b-i >= 0; ++i)///проверка по диагонали влево-вверх
119     {
120         if(B[a-i][b-i])
121             return false;
122     }
123 
124     for(int i = 1; a+i < M && b+i < M; ++i)///проверка по диагонали вправо-вниз
125     {
126         if(B[a+i][b+i])
127             return false;
128     }
129 
130     for(int i = 1; a+i < M && b-i >= 0; ++i)///проверка по диагонали влево-вниз
131     {
132         if(B[a+i][b-i])
133             return false;
134     }
135 
136     for(int i = 1; a-i >= 0 && b+i < M; ++i) ///проверка по диагонали вправо-вверх
137     {
138         if(B[a-i][b+i])
139             return false;
140     }
141 
142     return true;
143 }
144 void Elephant(int dia, int count) ///функция, расстанавливающая слоны
145 {
146     int a, b; /// задача клетки, соответствующекй данной диагонали
147     if (dia < M) /// проверка диагонали
148     {
149         a = dia; /// номер строки - номер диагонали
150         b = 0; ///обнуление переменной для столбца, цикл движется по столбцу
151     }
152    else ///если все диагонали рассмотрены
153      {
154         a = M-1; /// рассматриваем самую последнюю диагональ
155         b =(dia % M)+1; ///рассчитываем координату столбца для данной диагонали
156      }
157 
158     for(int i=0; a-i>=0 && b+i < M; ++i)/// цикл движется по строкам и столбцам из нижнего левого угла в правый верхний
159     {
160         int line=a-i; ///координата строки (мы уменьшаем координату строки)
161         int column=b+i; ///координата столбца  (но увеличиваем координату столбца)
162 
163         if(checkElephant(line, column))/// проверка, бьется ли слон по диагонали
164         {
165             B[line][column]=1; ///установка слона
166 
167             for(int i=dia+1; i<2*M-1; ++i) ///расстановка фигур, основанная на изменении параметров (номера диагонали и количества рсставленных фигур)
168                 Elephant(i,count+1);
169 
170             if(count+1 == N) /// проверка количества расставленных фигур
171                 showBoard();
172 
173             B[line][column]=0; ///обнуление переменной
174         }
175     }
176 }
177 
178 bool checkHorse(int a, int b) /// функция, проверяющая, бьется ли данная клетка конями
179 {
180     if ((a-1) >=0 && (b-2)>=0 && B[a-1][b-2])
181         return false;
182 
183     if ((a-1)>=0 && (b+2) < M && B[a-1][b+2])
184         return false;
185 
186     if ((a+1) < M && (b-2) >=0 && B[a+1][b-2])
187         return false;
188 
189     if ((a+1) < M && (b+2) < M && B[a+1][b+2])
190         return false;
191 
192     if ((a-2) >=0 && (b-1) >=0 && B[a-2][b-1])
193         return false;
194 
195     if ((a-2) >=0 && (b+1) < M && B[a-2][b+1])
196         return false;
197 
198     if ((a+2) < M && (b-1) >= 0 && B[a+2][b-1])
199         return false;
200 
201     if ((a+2) < M && (b+1) < M && B[a+2][b+1])
202         return false;
203 
204     return true;
205 }
206 
207 void Horse(int count, int a, int b) ///функция расстановки коней; a - очередная строка, b - очередной столбец, count - счетчик количества фигур, которое необходимо расставить
208 {
209     if(count==N) /// проверка количества расставленных фигур
210     {
211         showBoard();
212     }
213     if (a == M) /// не выходит ли за предел доски
214         return;
215     for (int j=b; j<M; ++j) ///рассматриваем первую строку
216     {
217         if(checkHorse(a, j)) ///проверка
218         {
219             B[a][j]=1; ///установка коня
220             int l = a, b = j+1; ///смещение в другой столбец
221 
222             if (b == M) ///проверка, не крайний ли это столбец, так как тогда мы не можем продолжать расстановку (мы ее завершили)
223             {
224                 b=0; ///обнуление переменной
225                 l++;     ///переход на следующую
226             }
227             Horse(count+1,l,b); ///установка фигуры, увеличение счетчика
228             B[a][j]=0; ///обнуление переменной для установки следующей фигуры в следующую клетку
229         }
230     }
231     for(int i=a+1; i<M; ++i) ///заполнение строк
232     {
233         for (int j=0; j<M; ++j)
234         {
235             if(checkHorse(i, j)) ///проверка клетки, не бьется ли она другими конями
236             {
237                 B[i][j]=1; ///установка коня
238                 int l = i, b = j+1; ///смещаемся на другой столбец
239                 if (b == M)
240                 {
241                     b = 0;
242                     l++;
243                 }
244                 Horse(count+1,l,b); ///установка фигуры с увеличением счетчика
245                 B[i][j]=0;  ///обнуление переменной
246             }
247         }
248     }
249 }
250 
251 bool checkKing(int a, int b) /// функция, проверяющая, бьет ли данную клетку король
252 {
253     for(int i = a-1; i <= a+1; ++i)
254     {
255         for(int j = b-1; j <= b+1; ++j)
256         {
257             if (a>=0 && a < M && b>=0 && b < M && B[a][b])
258                 return false;
259 
260             if ((a+1) < M && (b-1) >=0 && B[a+1][b-1])
261                 return false;
262 
263             if ((a+1) < M && B[a+1][b])
264                 return false;
265 
266             if ((a+1) < M && (b+1) < M && B[a+1][b+1])
267                 return false;
268 
269             if ((b+1) < M && B[a][b+1])
270                 return false;
271 
272             if ((a-1)>=0 && (b+1) < M && B[a-1][b+1])
273                 return false;
274 
275             if ((a-1) >=0 && B[a-1][b])
276                 return false;
277 
278             if ((a-1) >=0 && (b-1)>=0 && B[a-1][b-1])
279                 return false;
280 
281             if ((b-1) >= 0 && B[a][b-1])
282                 return false;
283         }
284     }
285 
286     return true;
287 }
288 
289 void King (int count, int a, int b) ///функция, расставляющая коней
290 {
291     for (int j=b; j<M; ++j)  ///установка королей в первой строке
292     {
293         if(checkKing(a, j)) ///проверка данной клетки на возможность установки фигуры
294         {
295             B[a][j]=1; ///если по результатам проверки можно поставить фигуру, то мы ее ставим
296             King(count+1,a,j); ///расстановка фигур для первой доски
297             B[a][j]=0;  ///обнуление переменной
298         }
299     }
300 
301     for(int i=a+1; i<M; ++i) ///расстановка фигур
302     {
303         for (int j=0; j<M; ++j)
304         {
305             if(checkKing(i, j)) ///проверка данной клетки на возможность установки фигуры
306             {
307                 B[i][j]=1;  /// если короля можно поставить, то ставим его в данную клетку
308                 King(count+1,i,j);
309                 B[i][j]=0;  ///обнуление переменной
310             }
311         }
312     }
313 
314     if(count==N)
315     {
316         showBoard();/// вывод шахмат на экран
317         return;
318     }
319 }
320 
321 int main()
322 {
323         cout << "Enter the size of the board: " << endl; ///ввод размера доски
324         cin >> M;
325         B = new int*[M];
326         for (int i=0; i<M; i++)
327             B[i] = new int[M];
328         for (int i = 0; i<M; i++)
329             for (int j = 0; j<M; j++)
330                 B[i][j] = 0;
331         int Var;
332         cout << '\n' << "1=your number of figures, 2=max number of figures" << endl;
333         cin >> Var;
334         int F;
335                 cout << '\n' << "Input type of figure: 1-queen, 2-king, 3-horse, 4-rook, 5-elephant"<< endl;
336                 cin >> F;
337         if (Var==1) /// если пользователь выбрал свое количество фигур, то мы выполняем следующие действия:
338         {
339                 int mn;
340                     cout << "Input the number of figures" << endl;
341                     cin >> N;
342                 if (F==1)
343                 {
344                     for (int i=0; i <M; ++i)
345                         Queen(i,0);
346                 }
347                 if (F==2)
348                 {
349                     King(0,0,0);
350                 }
351                 if (F==3)
352                 {
353                     Horse(0,0,0);
354                 }
355                 if (F==4)
356                 {
357                     for (int i=0; i <M; ++i)
358                         Rook(i,0);
359                 }
360                 if (F==5)
361                 {
362                     for(int i = 0; i<2*M-1; ++i)
363                         Elephant(i,0);
364                 }
365             }
366         else if (Var==2)       /// если пользователь выбрал максимальное количество фигур
367         {
368                 int mn;
369                 if (F==1)
370                 {
371                     mn=M;
372                     cout <<  "Max number " << mn  << endl;  /// выводим максимальное количество фигур
373                     N=mn; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
374                         for (int i=0; i < M; ++i)
375                             Queen(i,0);
376                     }
377 
378                 if (F==2)
379                 {
380                     mn=0.25*M*M;
381                     cout << '\n' << "Max number " << mn <<  endl;
382                     N=mn; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
383                     King(0,0,0);
384                     }
385                 if (F==3)
386                 {
387                     mn=0.5*M*M;
388                     cout <<  "Max number " << mn  << endl;
389                     N=mn; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
390                     Horse(0,0,0);
391                     }
392                 if (F==4)
393                 {
394                     mn=M;
395                     cout <<  "Max number " << mn  << endl;
396                     N=mn; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
397                         for (int i=0; i <M; ++i)
398                             Rook(i,0);
399                     }
400                 if (F==5)
401                 {
402                     mn=2*M-2;
403                     cout <<  "Max number " << mn  << endl;
404                     N=mn; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
405                         for(int i = 0; i<2*M-1; ++i)
406                             Elephant(i,0);
407                     }
408                 }
409     }

Савельева Ольга


Инструкция: В меню указывается два варианта развития событий. Пользователь должен выбрать один из путей: либо максимальное число вариантов, либо посмотреть наглядно на варианты. Человек вводит размер доски и тип фигуры.

Скачать программу можно [2]

  1 #define windows
  2 
  3 #include <stdio.h>
  4 #include <vector>
  5 
  6 #ifdef windows
  7 #include <windows.h>
  8 #endif  // windows
  9 
 10 using namespace std;
 11 
 12 #ifdef windows
 13 HANDLE hCon;
 14 #endif // windows
 15 
 16 unsigned fact(int n)  //factorial of a number
 17 {
 18     unsigned long long ret = 1;
 19     for(int i = 2; i <= n; i++)
 20         ret *= i;
 21     return ret;
 22 }
 23 
 24 struct desk
 25 {
 26     char **deskFigures, **deskOccupy;   //desk with figures, desk with occupation counter for each cell
 27     int x, y, size, a, f;   //pointer position(x, y), size of the desk, amount of prints, amount of figures
 28     vector<pair<int, int> > *s; //stack of placed figures
 29     bool stackIsUsed;   //if stack is needed
 30     desk(int size, bool stackIsUsed = true):x(0), y(0), size(size), a(0), f(0), stackIsUsed(stackIsUsed)
 31     {
 32         deskFigures = new char*[size];
 33         for(int i = 0; i < size; i++)
 34             deskFigures[i] = new char[size];
 35         deskOccupy = new char*[size];
 36         for(int i = 0; i < size; i++)
 37             deskOccupy[i] = new char[size];
 38         if(stackIsUsed)
 39             s = new vector<pair<int, int> >;
 40         clear();
 41     }
 42     ~desk()
 43     {
 44         for(int i = 0; i < size; i++)
 45             delete deskFigures[i];
 46         delete deskFigures;
 47         for(int i = 0; i < size; i++)
 48             delete deskOccupy[i];
 49         delete deskOccupy;
 50         if(stackIsUsed)
 51             delete s;
 52     }
 53     void setKnight(int x, int y, int z) //increase all cells occupied by knight at (x, y) on z
 54     {
 55         if(x + 2 < size)
 56         {
 57             if(y - 1 >= 0)
 58                 deskOccupy[x + 2][y - 1] += z;
 59             if(y + 1 < size)
 60                 deskOccupy[x + 2][y + 1] += z;
 61         }
 62         if(y + 2 < size)
 63         {
 64             if(x - 1 >= 0)
 65                 deskOccupy[x - 1][y + 2] += z;
 66             if(x + 1 < size)
 67                 deskOccupy[x + 1][y + 2] += z;
 68         }
 69         if(x - 2 >= 0)
 70         {
 71             if(y - 1 >= 0)
 72                 deskOccupy[x - 2][y - 1] += z;
 73             if(y + 1 < size)
 74                 deskOccupy[x - 2][y + 1] += z;
 75         }
 76         if(y - 2 >= 0)
 77         {
 78             if(x - 1 >= 0)
 79                 deskOccupy[x - 1][y - 2] += z;
 80             if(x + 1 < size)
 81                 deskOccupy[x + 1][y - 2] += z;
 82         }
 83     }
 84     void setBishop(int x, int y, int z) //increase all cells occupied by bishop at (x, y) on z
 85     {
 86         for(int ix = 0, iy1 = y - x, iy2 = y + x; ix < size; ix++, iy1++, iy2--)
 87             if(ix != x)
 88             {
 89                 if((iy1 >= 0)and(iy1 < size))
 90                     deskOccupy[ix][iy1] += z;
 91                 if((iy2 >= 0)and(iy2 < size))
 92                     deskOccupy[ix][iy2] += z;
 93             }
 94     }
 95     void setRook(int x, int y, int z)   //increase all cells occupied by rook at (x, y) on z
 96     {
 97         for(int i = 0; i < size; i++)
 98         {
 99             if(i != x)
100                 deskOccupy[i][y] += z;
101             if(i != y)
102                 deskOccupy[x][i] += z;
103         }
104     }
105     void setKing(int x, int y, int z)   //increase all cells occupied by king at (x, y) on z
106     {
107         for(int ix = x - 1; ix <= x + 1; ix++)
108             for(int iy = y - 1; iy <= y + 1; iy++)
109                 if((ix >= 0)and(ix < size)and(iy >= 0)and(iy < size)and((ix != 0)or(iy != 0)))
110                     deskOccupy[ix][iy] += z;
111     }
112     void setFigure(int x, int y, int z, char figure)    //increase all cells occupied by figure
113                                                         //and (x, y) on z
114     {
115         deskOccupy[x][y] += z;
116         switch(figure)
117         {
118             case 'N':
119                 setKnight(x, y, z);
120                 break;
121             case 'B':
122                 setBishop(x, y, z);
123                 break;
124             case 'R':
125                 setRook(x, y, z);
126                 break;
127             case 'Q':
128                 setBishop(x, y, z);
129                 setRook(x, y, z);
130                 break;
131             case 'K':
132                 setKing(x, y, z);
133                 break;
134         }
135     }
136     bool putFigure(int x, int y, char figure)   //place figure on desk and update occupied cells
137     {
138         if(deskFigures[x][y] > 0)
139             return false;
140         deskFigures[x][y] = figure;
141         if(stackIsUsed)
142             s -> push_back(make_pair(x, y));
143         setFigure(x, y, 1, figure);
144         f++;
145         return true;
146     }
147     int cellsLeft() //amount of cells after pointer
148     {
149         return (size - y) * size - x;
150     }
151     bool putNextFree(char figure)   //attempt to put figure on the next free(and not occupied) place
152     {
153         if(y >= size)
154             return false;
155         while(deskOccupy[x][y] > 0)
156         {
157             if(++x == size)
158             {
159                 if(++y == size)
160                     return false;
161                 x = 0;
162             }
163         }
164         return putFigure(x, y, figure);
165     }
166     void removeFigure(int x, int y) //remove figure from (x, y)
167     {
168         if(deskFigures[x][y]!=0)
169             setFigure(x, y, -1, deskFigures[x][y]);
170         deskFigures[x][y] = 0;
171         f--;
172     }
173     void removeBishop(int diag, bool color, bool left)  //remove bishop
174     {
175         if(color)   //true - white, false - black
176         {
177             if(diag > 0)    //diag - number of diagonal
178             {
179                 int diff = left ? 0 : diag * 2;
180                 removeFigure(diff, diag * 2 - diff);
181                 removeFigure(size - diff - 1, size - diag * 2 + diff - 1);
182             }
183             else
184             if(left)    //determine position of the bishop on the diagonal
185                 removeFigure(0, 0);
186             else
187                 removeFigure(size - 1, size - 1);
188         }
189         else
190         {
191             if(diag > 0)
192             {
193                 int diff = left ? 0 : diag * 2;
194                 removeFigure(size - diff - 1, diag * 2 - diff);
195                 removeFigure(diff, size - diag * 2 + diff - 1);
196             }
197             else
198             if(left)
199                 removeFigure(0, size - 1);
200             else
201                 removeFigure(size - 1, 0);
202         }
203     }
204     void putBishop(int diag, bool color, bool left) //place bishop
205     {
206         if(color)
207         {
208             if(diag > 0)
209             {
210                 int diff = left ? 0 : diag * 2;
211                 putFigure(diff, diag * 2 - diff, 'B');
212                 putFigure(size - diff - 1, size - diag * 2 + diff - 1, 'B');
213             }
214             else
215             if(left)
216                 putFigure(0, 0, 'B');
217             else
218                 putFigure(size - 1, size - 1, 'B');
219         }
220         else
221         {
222             if(diag > 0)
223             {
224                 int diff = left ? 0 : diag * 2;
225                 putFigure(size - diff - 1, diag * 2 - diff, 'B');
226                 putFigure(diff, size - diag * 2 + diff - 1, 'B');
227             }
228             else
229             if(left)
230                 putFigure(0, size - 1, 'B');
231             else
232                 putFigure(size - 1, 0, 'B');
233         }
234     }
235     void swapBishops(int diag, bool color, bool left)   //move pair bishops to another borders
236     {
237         removeBishop(diag, color, left);
238         putBishop(diag, color, not(left));
239     }
240     void figureBefore() //remove one figure from stack and change pointer to the next position after figure was placed
241     {
242         pair<int, int> c = s -> back();
243         s -> pop_back();
244         x = c.first;
245         y = c.second;
246         removeFigure(x, y);
247         if(++x == size)
248         {
249             x = 0;
250             y++;
251         }
252     }
253     void clear()    //clear the desk
254     {
255         for(int ix = 0; ix < size; ix++)
256             for(int iy = 0; iy < size; iy++)
257             {
258                 deskFigures[ix][iy] = 0;
259                 deskOccupy[ix][iy] = 0;
260             }
261         x = 0;
262         y = 0;
263         if(stackIsUsed)
264             s -> empty();
265         f = 0;
266     }
267     void show() //show the desk
268     {
269         a++;
270         printf("%i:\n", a);
271         #ifdef windows
272         unsigned background = 4;
273         #else
274         printf("\x1b[31m");
275         char background = 47;
276         #endif  //windows
277         for(int y = 0; y < size; y++)
278             for(int x = 0; x < size; x++)
279             {
280                 #ifdef windows
281                 SetConsoleTextAttribute(hCon, background);
282                 #else
283                 printf("\x1b[%dm", background);
284                 #endif  //windows
285                 if(deskFigures[x][y] == 0)
286                     putchar(' ');
287                 else
288                     putchar(deskFigures[x][y]);
289                 #ifdef windows
290                 if(x < size - 1)
291                     background = background == 4 ? 116 : 4;
292                 else
293                 {
294                     SetConsoleTextAttribute(hCon, 7);
295                     putchar('\n');
296                 }
297                 #else
298                 if(x < size - 1)
299                     background = background == 47 ? 40 : 47;
300                 else
301                 {
302                     printf("\x1b[0m\n");
303                     if(y < size - 1)
304                         printf("\x1b[31m");
305                 }
306                 #endif // windows
307             }
308     }
309 };
310 
311 int m = -1; //0 for number of arrangements, 1 for all variants
312 
313 unsigned lookForFigure(int size, int amount, char figure, bool show = true) //brute-force
314 {
315     desk *d  = new desk(size);
316     unsigned ret = 0;
317     while((d -> f > 0)or(d -> cellsLeft() >= amount))
318         if(not(d -> putNextFree(figure)))
319         {
320             if(d -> f == amount)
321             {
322                 if(show)
323                     d -> show();
324                 ret++;
325             }
326             d -> figureBefore();
327         }
328     delete d;
329     return ret;
330 }
331 
332 void lookForKnight(int size, int amount)    //arrangements of knights
333 {
334     if(m == 0)
335     {
336         printf("Amount of arrangements: ");
337         if(size == 2)
338             printf("1\n");
339         else
340         if(size == 4)
341             printf("6\n");
342         else
343             printf("2\n");
344     }
345     else
346     {
347         desk *d = new desk(size);
348         if(size == 2)
349         {
350             d -> putFigure(0, 0, 'N');
351             d -> putFigure(0, 1, 'N');
352             d -> putFigure(1, 0, 'N');
353             d -> putFigure(1, 1, 'N');
354             d -> show();
355         }
356         else
357         if(size==4)
358             lookForFigure(size, amount, 'N');
359         else
360         {
361             for(int x = 0; x < size; x++)
362                 for(int y = 0;y < size; y++)
363                     if(x + y % 2 == 0)
364                         d -> putFigure(x, y, 'N');
365             d -> show();
366             d -> clear();
367             for(int x = 0; x < size; x++)
368                 for(int y = 0;y < size; y++)
369                     if(x + y % 2 == 1)
370                         d -> putFigure(x, y, 'N');
371             d -> show();
372         }
373     }
374 }
375 
376 void lookForBishop(int size, int amount)    //arrangements of bishops
377 {
378     if(m == 0)
379         printf("Amount of arrangements: %u", (unsigned) 1 << size);
380     else
381     {
382         desk *d = new desk(size, false);
383         bool *b = new bool[size];
384         for(int dw = 0; dw < size/2; dw++)
385         {
386             d -> putBishop(dw, true, false);
387             d -> putBishop(dw, false, false);
388         }
389         int p = size - 1;
390         for(;;)
391         {
392             d -> show();
393             while(b[p])
394             {
395                 d -> swapBishops(p % (size / 2), p < size / 2, true);
396                 b[p--] = false;
397                 if(p < 0)
398                     return;
399             }
400             b[p] = true;
401             d -> swapBishops(p % (size / 2), p < size / 2, false);
402             p = size - 1;
403         }
404     }
405 }
406 
407 void lookForRook(int size, int amount)  //arrangements of rooks
408 {
409     if(m == 0)
410         printf("Amount of arrangements: %u", fact(size));
411     else
412         lookForFigure(size, amount, 'R');
413 }
414 
415 void lookForQueen(int size, int amount) //arrangements of queens
416 {
417     if(m == 0)
418         printf("Amount of arrangements: %u", lookForFigure(size, amount, 'Q', false));
419     else
420         lookForFigure(size, amount, 'Q');
421 }
422 
423 void lookForKing(int size, int amount)  //arrangements of kings
424 {
425     if(m == 0)
426         printf("Amount of arrangements: %u", lookForFigure(size, amount, 'K', false));
427     else
428         lookForFigure(size, amount, 'K');
429 }
430 
431 int main()
432 {
433     int s = -1, f = -1; //s - size, f - figure
434     #ifdef windows
435     hCon = GetStdHandle(STD_OUTPUT_HANDLE);
436     #endif // windows
437     sizeInput:
438     printf("Enter size of the desk:\n");
439     scanf("%i", &s);
440     if((s<=0)or(s%2!=0))
441     {
442         printf("Size must be above 0 and even\n");
443         goto sizeInput;
444     }
445     modeInput:
446     printf("Enter mode:\n\t0: Print amount of results\n\t1: Print all results\n");
447     scanf("%i", &m);
448     if((m<0)or(m>1))
449     {
450         printf("Mode can be 0 or 1\n");
451         goto modeInput;
452     }
453     figureInput:
454     printf("Enter figures to be placed\n\t0: Knight (N)\n\t1: Bishop (B)\n\t2: Rook (R)\n\t3: Queen (Q)\n\t4: King (K)\n");
455     scanf("%i", &f);
456     if((f<0)or(f>4))
457     {
458         printf("Figure number ranges from 0 to 4\n");
459         goto figureInput;
460     }
461     switch(f)
462     {
463         case 0:
464             if(s==2)
465                 lookForKnight(s, 4);
466             else
467                 lookForKnight(s, s *s / 2);
468             break;
469         case 1:
470             lookForBishop(s, 2 * s - 2);
471             break;
472         case 2:
473             lookForRook(s, s);
474             break;
475         case 3:
476             if(s==2)
477                 lookForQueen(s, 1);
478             else
479                 lookForQueen(s, s);
480             break;
481         case 4:
482             lookForKing(s, (s / 2) * (s / 2));
483             break;
484     }
485     return 0;
486 }


Сенников Иван

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

Идея: Шахматная доска представляет собой двумерный динамический массив. С помощью рекурсивного метода программа пробегает по массиву, проверяя клетки доски по всем направлениям на то, атакованы ли они другими фигурами этого типа. В зависимости от количества поставленных фигур изменяется количество итераций. В новую клетку ставиться новая фигура и так до тех пор, пока не выполнится написанное выше условие, после чего начнется обратный ход.

Инструкция: Программа написана в виде меню на английском языке: пользователю будет предоставлена возможность сначала обозначить размер доски, а после выбрать тип фигур и их количество для дальнейшей работы с ними. Комментарии к программе написаны также на английском языке.

Ссылка для скачиваний: здесь.

Степанянц Степан

Программа: 1)Программа получает все возможные варианты расстановок одинаковых фигур на поле боя(шахматной доске) так, чтобы они не смогли бить друг друга.2)Программа выводит максимальное число фигур, которые можно поставить на шахматную доску nxn так, чтобы они не смогли бить друг друга.

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

Скачать можно тут.

  1 #include <iostream>
  2 #include <vector>
  3 
  4 using namespace std;
  5 
  6 
  7 
  8 //задаю массивы в которых изображены все ходы определенных фигур
  9 int d = 0;
 10 int d_knight[2][8] = {{1, 1, -1, -1, 2, 2, -2, -2},
 11     {2, -2, 2, -2, 1, -1, 1, -1}};
 12 int d_bish[4][2] = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
 13 int d_king[8][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}, {1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
 14 //Проверяем, не выходим ли мы за поле
 15 bool ok(int x, int y, int n) {
 16     if (x < 0 || y < 0 || x >= n || y >= n)
 17         return false;
 18     return true;
 19 }
 20 
 21 void print(int n, vector<vector<pair<bool, int> > > board) {
 22     for (int i = 0; i < n; i++) {
 23         for (int j = 0; j < n; j++) {
 24             cout << ((board[i][j].first) ? " X " : " 0 ");
 25         }
 26         cout << '\n';
 27     }
 28     cout << "-------------------------------------\n";
 29 }
 30 //Рекурсивная функция
 31 int func(int n, int k, int count, vector<vector<pair<bool, int> > > board, int ii, int jj, int fig, int task) {
 32     int ans = 0;
 33     if (count == k && !task) {
 34         print(n, board);
 35         return 1;
 36     }
 37     else if(task) {
 38         ans = max(ans, count);
 39     }
 40     for (int i = ii + jj / n; i < n; i++) {
 41         for (int j = jj % n; j < n; j++) {
 42             if (!board[i][j].first && !board[i][j].second) {
 43                 switch (fig) {
 44                     case 1://конь
 45                         for (int k = 0; k < 8; k++) {
 46                             if (ok(i + d_knight[0][k], j + d_knight[1][k], n))
 47                                 board[i + d_knight[0][k]][j + d_knight[1][k]].second++;
 48                         }
 49                         break;
 50                     case 2://слон
 51                         for (int k = 0; k < n; k++) {
 52                             for (int l = 0; l < 4; l++) {
 53                                 if (ok(i + k * d_bish[l][0], j + k * d_bish[l][1], n))
 54                                     board[i + k * d_bish[l][0]][j + k * d_bish[l][1]].second++;
 55                             }
 56                         }
 57                         break;
 58                     case 3: // ладья
 59                         for (int k = 0; k < n; k++)
 60                             board[i][k].second++, board[k][j].second++;
 61                         break;
 62                     case 4: // король
 63                         for (int k = 0; k < 8; k++)
 64                             if (ok(i + d_king[k][0], j + d_king[k][1], n))
 65                                 board[i + d_king[k][0]][j + d_king[k][1]].second++;
 66                         break;
 67                     case 5: // ферзь
 68                         for (int k = 0; k < 8; k++)
 69                             for (int l = 0; l < n; l++)
 70                                 if (ok(i + l * d_king[k][0], j + l * d_king[k][1], n))
 71                                     board[i + l * d_king[k][0]][j + l * d_king[k][1]].second++;
 72                         break;
 73                         
 74                 }
 75                 //Рекурсия
 76                 board[i][j].first = true;
 77                 if (!task)
 78                     ans += func(n, k, count + 1, board, i, j + 1, fig, task);
 79                //обратный ход
 80                 else
 81                     ans = max(ans, func(n, k, count + 1, board, i, j + 1, fig, task));
 82                 board[i][j].first = false;
 83                 switch (fig) {
 84                     case 1:
 85                         for (int k = 0; k < 8; k++) {
 86                             if (ok(i + d_knight[0][k], j + d_knight[1][k], n))
 87                                 board[i + d_knight[0][k]][j + d_knight[1][k]].second--;
 88                         }
 89                         break;
 90                     case 2:
 91                         for (int k = 0; k < n; k++) {
 92                             for (int l = 0; l < 4; l++) {
 93                                 if (ok(i + k * d_bish[l][0], j + k * d_bish[l][1], n))
 94                                     board[i + k * d_bish[l][0]][j + k * d_bish[l][1]].second--;
 95                             }
 96                         }
 97                         break;
 98                     case 3:
 99                         for (int k = 0; k < n; k++)
100                             board[i][k].second--, board[k][j].second--;
101                         break;
102                     case 4:
103                         for (int k = 0; k < 8; k++)
104                             if (ok(i + d_king[k][0], j + d_king[k][1], n))
105                                 board[i + d_king[k][0]][j + d_king[k][1]].second--;
106                         break;
107                     case 5:
108                         for (int k = 0; k < 8; k++)
109                             for (int l = 0; l < n; l++)
110                                 if (ok(i + l * d_king[k][0], j + l * d_king[k][1], n))
111                                     board[i + l * d_king[k][0]][j + l * d_king[k][1]].second--;
112                         break;
113                 }
114             }
115         }
116         jj = 0;
117     }
118     return ans;
119 }
120 //меню
121 int main() {
122     int fig, task;
123     int n, k;
124     cout << "Please, input the task number: 1 - amount of solutions, 2 - maximum of figures\n";
125     cin >> task;
126     task--;
127     cout << "Please, input figure type: 1 - knight, 2 - bishop, 3 - castle, 4 - king, 5 - queen\n";
128     cin >> fig;
129     cout << "Please, input the size of the board\n";
130     cin >> n;
131     if (!task) {
132         cout << "Please, input number of figures\n";
133         cin >> k;
134     }
135     vector<vector<pair<bool, int> > > v = vector<vector<pair<bool, int> > >(n, vector <pair<bool, int> >(n, {false, 0}));
136     cout << func(n, k, 0, v, 0, 0, fig, task);
137 }

Александр Сюрис

Программа работает в двух режимах: поиск максимального числа фигур для заданного поля и количество возможных расстановок заданного числа фигур для заданного поля.

Алгоритм:

  1. Для поиска количества возможных расстановок заданного числа фигур для заданного поля – Проверяется, возможно ли поставить фигуру в данную клетку, рекурсивно перебирает для каждой клетки поля, как начальной клетки, все варианты расстановки заданного количества фигур относительно нее и выводит на экран все расстановки, которые подходят условиям.
  2. Для поиска максимального числа фигур для заданного поля – Проверяется, можно ли поставить одну фигуру, две, три и так далее, пока фигур больше поставить будет нельзя.

Скачать можно тут.

  1 #include <vector>
  2 #include <iostream>
  3 #include <algorithm>
  4 
  5 
  6 using namespace std;
  7 
  8 int n,k, o, m, l, g, maxi, a, sum=0,y, mozno=1;//mozno=1 если можно поставить n фигур
  9 vector<vector<int> > matrix;// двухмерный вектор
 10 
 11 bool ladia(int x, int y) {      //проверка, можно ли в эту клетку поставить ладью
 12     for(int i = 0; i<n; i++)
 13         if(matrix[x][i] == 1)
 14             return false;
 15     for(int j=0; j<n; j++)
 16         if(matrix[j][y]==1)
 17             return false;
 18     return true;
 19 }
 20 
 21 bool slon(int x, int y) {   //    --//-- слона
 22 
 23    for (int i=x, j=y;i<n && j>=0; i++, j--)
 24        if(matrix[i][j] == 1)
 25             return false;
 26    for (int i=x, j=y;i>=0 && j>=0; i--, j--)
 27        if(matrix[i][j] == 1)
 28             return false;
 29    for (int i=x, j=y;i>=0 && j<n; i--, j++)
 30        if(matrix[i][j] == 1)
 31             return false;
 32    for (int i=x, j=y;i<n && j<n; i++, j++)
 33        if(matrix[i][j] == 1)
 34             return false;
 35 
 36     return true;
 37 
 38 }
 39 
 40 bool fruz(int x, int y){      //    --//-- ферзя
 41     if(slon(x,y) && ladia(x,y))
 42         return true;
 43 
 44     return false;
 45 
 46 
 47 }
 48 
 49 bool kon(int x, int y) {   // --//-- коня
 50 
 51    if (x-1>=0 && y-2>=0 && matrix[x-1][y-2]==1)
 52         return false;
 53    if (y-2>=0 && x+1<n && matrix[x+1][y-2]==1)
 54         return false;
 55    if (x-2>=0 && y-1>=0 && matrix[x-2][y-1]==1)
 56         return false;
 57    if (x+2<n && y-1>=0 && matrix[x+2][y-1]==1)
 58         return false;
 59    if (x-2>=0 && y+1<n && matrix[x-2][y+1]==1)
 60         return false;
 61    if (x+2<n && y+1<n && matrix[x+2][y+1]==1)
 62         return false;
 63    if (x-1>=0 && y+2<n && matrix[x-1][y+2]==1)
 64         return false;
 65    if (x+1<n && y+2<n && matrix[x+1][y+2]==1)
 66         return false;
 67 return true;
 68 }
 69 
 70 bool king(int x, int y) {   // --//--  короля
 71 
 72     if (x-1>=0 && y-1>=0 && matrix[x-1][y-1]==1)
 73         return false;
 74     if (x-1>=0 && matrix[x-1][y]==1)
 75         return false;
 76     if (y+1<n && x-1>=0 && matrix[x-1][y+1]==1)
 77         return false;
 78     if (y+1<n && matrix[x][y+1]==1)
 79         return false;
 80     if (y+1<n && x+1>n && matrix[x+1][y+1]==1)
 81         return false;
 82     if (x+1<n && matrix[x+1][y]==1)
 83         return false;
 84     if (x+1<n && y-1>=0 && matrix[x+1][y-1]==1)
 85         return false;
 86     if (y-1>=0 && matrix[x][y-1]==1)
 87         return false;
 88     return true;
 89 
 90 }
 91 
 92 int mass() {  // вывод доски на экран
 93 
 94 for(int i = 0; i<n; i++)
 95   {
 96 
 97     for(int j = 0; j<n; j++)
 98         cout<<matrix[i][j]<<" ";
 99 
100         cout<<endl;
101     }
102 
103 }
104 
105 int del() {  // очистка доски(все нули)
106 
107 for (int i=0; i<n; i++) {
108 
109     for (int j=0; j<n; j++)
110         matrix[i][j]=0;
111 }
112 
113 }
114 
115 
116 
117 void vsevarintyrasstavitnfigur(int x,int y){  // рекурсивный поиск всех вараинтов расстановок заданнного количества фигур (x - номер фигуры в доске, если ее растянуть в линию, y - кол-во фигур)
118     if(y==0) {
119         if (a==1){
120             mass();
121             cout<<'\n';
122         }
123         if(a==2) {
124                 mozno = 1;  //mozno=1 если можно поставить n фигур
125 
126         }
127 
128         return;
129     }
130 
131     for(int i=x;i<n*n;i++){
132 
133         if (o==1)
134         if(fruz(i/n,i%n) && y>0) {matrix[i/n][i%n]=1; y--;}
135 
136         if (o==2)
137         if(ladia(i/n,i%n) && y>0) {matrix[i/n][i%n]=1; y--;}
138 
139         if (o==3)
140         if(slon(i/n,i%n) && y>0) {matrix[i/n][i%n]=1; y--;}
141 
142         if (o==4)
143         if(kon(i/n,i%n) && y>0) {matrix[i/n][i%n]=1; y--;}
144 
145         if (o==5)
146         if(king(i/n,i%n) && y>0) {matrix[i/n][i%n]=1; y--;}
147 
148 
149         vsevarintyrasstavitnfigur(i+1, y);
150         matrix[i/n][i%n]=0;//удаление фигуры из прошлой клетки для проверки других вариантов
151         y++;
152 
153     }
154 
155 }
156 
157 void maxfig(){  //поиск максимального количества фигур
158     int i=0;
159 while(mozno==1){ //проверяет для данной доски возможность расставить 1,2... фигуры, пока не доходит до количества, которое расставить невозхможно. Тогда это количество фигур -1 - искомая величина
160         i++;
161         mozno=0;
162         vsevarintyrasstavitnfigur(0,i);
163     }
164     setlocale(LC_ALL, "Russian");
165     cout<<"Максимальное количество фигур = "<<i-1<<endl;
166 }
167 
168 
169 int main() {
170 setlocale(LC_ALL, "Russian");
171     g=0;
172     cout<<"Введите размер доски:"<<endl;
173     cin >>n;
174         for(int i=0; i<n; i++) {
175             vector<int> z;
176             for(int j=0; j<n; j++){
177                     z.push_back(0);   //создание вектора z  из n нулей и добавление его к двухмерному вектору
178             }
179             matrix.push_back(z);
180         }
181 
182         cout<<"1 - расстановки фигур на доске n*n"<<endl<<"2 - максимум фигур на доске n*n"<<endl;
183            cin>>a;
184 
185         while(2>1){
186             cout<<" 1 - ферзь"<<endl;
187             cout<<" 2 - ладья"<<endl;
188             cout<<" 3 - слон"<<endl;
189             cout<<" 4 - конь"<<endl;
190             cout<<" 5 - король"<<endl;
191             cout<<" 6 - выход"<<endl;
192 
193            cout<<"Введите число от 1 до 6:"<<endl;
194            cin>>o;
195             mozno=1;
196             if(o==6) break;
197 
198 
199 
200 
201 
202 
203     if (o==1)   {
204                 cout<<"Ферзь"<<endl;
205 
206             if(a==1)
207                 {
208                     cin>>y;
209                     vsevarintyrasstavitnfigur(0,y);
210                 }
211 
212 
213             if (a==2)
214                 maxfig();
215 
216                 }
217 
218 
219 
220 
221 
222 
223     if (o==2)   {
224                 cout<<endl<<"Ладья"<<endl;
225 
226                     if(a==1)
227                     {
228 
229                         cin>>y;
230                         vsevarintyrasstavitnfigur(0,y);
231                     }
232 
233                     if (a==2)
234                         maxfig();
235 
236                 }
237 
238 
239     if (o==3)   {
240                 cout<<endl<<"Слон"<<endl;
241 
242                 if(a==1)
243                     {
244                     cin>>y;
245                     vsevarintyrasstavitnfigur(0,y);
246                     }
247 
248                     if (a==2)
249                     maxfig();
250 
251                 }
252 
253 
254     if (o==4)  {
255                 cout<<endl<<"Конь"<<endl;
256 
257                 if(a==1)
258                     {
259                     cin>>y;
260                     vsevarintyrasstavitnfigur(0,y);
261                     }
262                     if (a==2)
263                     maxfig();
264 
265                }
266 
267     if (o==5)   {
268                 cout<<"Король"<<endl;
269 
270                 if(a==1)
271                 {
272                     cin>>y;
273                     vsevarintyrasstavitnfigur(0,y);
274 
275                 }
276                  if (a==2)
277 
278                        maxfig();
279 
280                 }
281 
282             }
283 }

Тимошенко Валентина

Краткое описание алгоритма: доска представлена в виде динамического массива, при выводе на экран пустые клетки обозначаются точками, а клетки, заполненные фигурами, обозначаются буквами (каждая буква соответствует первой букве названия фигуры на английском языке). Для каждой фигуры написаны функции проверки на возможность установки фигуры и функции расстановки. Кроме того, программа аналитически считает максимальное количество фигур для доски заданного пользователем размера и, при наличии команды пользователя, выводит все возможные расстановки рассчитанного максимального количества фигур на экран.

Инструкция: при запуске программа предлагает пользователю ввести размер доски, при этом число должно быть четным (если же пользователь вводит нечетное число, программа предлагает ввести размер еще раз, и так до тех пор, пока не будет введено четное число). Далее пользователь выбирает режим работы программы - либо расстановка фигур, либо расчет максимального количества фигур. В режиме расстановки фигур программа предлагает выбрать тип фигуры, выводит максимальное число фигур для доски заданного размера и предлагает ввести желаемое число фигур для расстановки (если оно больше максимального, предлагается повторная попытка ввода). В режиме расчета максимального числа программа предлагает выбрать тип фигуры, выводит рассчитанное число и задает вопрос о необходимости вывода всех возможных расстановок максимального количества для данной фигуры. Оба режима работают (т.е. все запросы повторяются) до тех пор, пока пользователь не даст команду на завершение цикла. Кроме того, в программе есть возможность изменения размера доски после выхода из всех циклов. При положительном ответе пользователя и изменении размера доступны оба режима работы.

Скачать можно здесь.

  1 #include <iostream> ///расстановка одинаковых шахматных фигур одного цвета на доске произвольного размера так, чтобы они друг друга не били
  2 #include <cstring> 
  3 #include <cstdlib>
  4 #include <ctime>
  5 
  6 using namespace std;
  7 int result_count = 0; ///переменная, в которую закладывается номер варианта расстановки фигур
  8 int N; ///то количество фигур для расстановки, которое задает пользователь
  9 int **Board; ///двумерный массив для отображения шахматной доски
 10 int M; /// размер шахматной доски
 11 
 12 ///Функция вывода доски
 13 void showBoard(string F) ///данная функция отображает доску
 14 {
 15     for(int i = 0; i < M; ++i) /// цикл, прогоняющий значения по строкам
 16     {
 17         for(int j = 0; j < M; ++j)  /// цикл, прогоняющий значения по столбцам
 18             cout << ((Board[i][j]) ? F : "."); ///заполнение как строки, так и столбца символом, который обозначает позицию на шахматной доске
 19         cout << endl;                          ///точка - если данная клетка пустая, буква - если в клетке стоит соответствующая фигура
 20     }
 21     cout << "Result # " << ++result_count << "\n\n"; ///вывод номера варианта расположения с последующим переходом на новую строку
 22     return;
 23 }
 24 
 25 ///Функции проверки и установки для ферзя
 26 
 27 bool tryQueen(int a, int b) /// проверка на возможность поставить фигуру в данную клетку, a- очередная строка, b- очередной столбец
 28 {
 29     for (int i = 0; i < M; ++i) ///проверка единственности ферзя в строке
 30     {
 31         if(Board[a][i])
 32             return false;
 33     }
 34 
 35     for(int i = 0; i < M; ++i) ///проверка единственности ферзя в столбце
 36     {
 37         if(Board[i][b])
 38             return false;
 39     }
 40 
 41     for(int i = 1; a-i >= 0 && b-i >= 0; ++i)///проверка единственности ферзя по диагонали влево-вверх
 42     {
 43         if(Board[a-i][b-i])
 44             return false;
 45     }
 46 
 47     for(int i = 1; a+i < M && b+i < M; ++i)///проверка единственности ферзя по диагонали вправо-вниз
 48     {
 49         if(Board[a+i][b+i])
 50             return false;
 51     }
 52 
 53     for(int i = 1; a+i < M && b-i >= 0; ++i)///проверка единственности ферзя по диагонали влево-вниз
 54     {
 55         if(Board[a+i][b-i])
 56             return false;
 57     }
 58 
 59     for(int i = 1; a-i >= 0 && b+i < M; ++i)///проверка единственности ферзя по диагонали вправо-вверх
 60     {
 61         if(Board[a-i][b+i])
 62             return false;
 63     }
 64 
 65     return true; ///если в ходе проверки ферзей и угроз не обнаружилось, в данную клетку можно поставить фигуру
 66 }
 67 
 68 void setQueen(int a, int count) ///функция расстановки ферзей; a - очередная строка, count - счетчик количества фигур, которое необходимо расставить
 69 {
 70     for(int b = 0; b < M; ++b) ///b - очередной столбец, расстановка идет по строкам
 71     {
 72         if(tryQueen(a, b)) ///проверка данной клетки на возможность установки фигуры
 73         {
 74             Board[a][b] = 1; ///установка ферзя в первую клетку поля, присваивание ей значения 1 (true)
 75 
 76             for(int i = a + 1; i < M; ++i) ///расстановка указанного пользователем количества фигур
 77                 setQueen(i,count+1);
 78 
 79             if(count+1 == N) /// если нужное количество фигур поставлено, то
 80                 showBoard("Q"); /// вызов функции вывода шахматной доски на экран
 81 
 82             Board[a][b]=0; ///обнуление переменной для установки следующей фигуры в следующую клетку
 83         }
 84     }
 85 }
 86 
 87 ///Функции проверки и установки для ладьи
 88 
 89 bool tryRook(int a, int b) /// проверка на возможность поставить фигуру в данную клетку, a- очередная строка, b- очередной столбец
 90 {
 91     for (int i = 0; i < M; ++i) ///проверка единственности ладьи в строке
 92     {
 93         if(Board[a][i])
 94             return false;
 95     }
 96 
 97     for(int i = 0; i < M; ++i) ///проверка единственности ладьи в столбце
 98     {
 99         if(Board[i][b])
100             return false;
101     }
102 
103     return true; ///если в ходе проверки ладей и угроз не обнаружилось, в данную клетку можно поставить фигуру
104 }
105 
106 void setRook(int a, int count) ///функция расстановки ладей; a - очередная строка, count - счетчик количества фигур, которое необходимо расставить
107 {
108     for(int b = 0; b < M; ++b) ///b - очередной столбец, расстановка идет по строкам
109     {
110         if(tryRook(a, b)) ///проверка данной клетки на возможность установки фигуры
111         {
112             Board[a][b] = 1; ///установка ладьи в первую клетку, присваивание ей значения 1 (true)
113 
114             for(int i = a + 1; i < M; ++i) ///расстановка указанного пользователем количества фигур
115                 setRook(i,count+1);
116 
117             if(count+1 == N) /// если нужное количество фигур поставлено, то
118                 showBoard("R"); /// вызов функции вывода шахматной доски на экран
119 
120             Board[a][b]=0; ///обнуление переменной для установки следующей фигуры в следующую клетку
121         }
122     }
123 }
124 
125 ///Функции проверки и установки для слона
126 
127 bool tryEl(int a, int b) /// проверка на возможность поставить фигуру в данную клетку, a- очередная строка, b- очередной столбец
128 {
129     for(int i = 1; a-i >= 0 && b-i >= 0; ++i)///проверка единственности слона по диагонали влево-вверх
130     {
131         if(Board[a-i][b-i])
132             return false;
133     }
134 
135     for(int i = 1; a+i < M && b+i < M; ++i)///проверка единственности слона по диагонали вправо-вниз
136     {
137         if(Board[a+i][b+i])
138             return false;
139     }
140 
141     for(int i = 1; a+i < M && b-i >= 0; ++i)///проверка единственности слона по диагонали влево-вниз
142     {
143         if(Board[a+i][b-i])
144             return false;
145     }
146 
147     for(int i = 1; a-i >= 0 && b+i < M; ++i)///проверка единственности слона по диагонали вправо-вверх
148     {
149         if(Board[a-i][b+i])
150             return false;
151     }
152 
153     return true; ///если в ходе проверки слонов и угроз не обнаружилось, в данную клетку можно поставить фигуру
154 }
155 void setEl(int dia, int count) ///функция расстановки слонов; line - очередная строка, count - счетчик количества фигур, которое необходимо расставить
156 {
157     ///dia - очередная диагональ, которую нужно исследовать на наличие фигуры и угрозы
158     int a, b; ///клетка, с которой начинается расстановка, a- очередная строка, b- очередной столбец
159 
160     if (dia < M) ///условие, что клеткa данной диагонали лежат на доске
161     {
162         a = dia; ///начало отсчёта диагоналей, цикл движется по строке
163         b = 0; ///обнуление переменной для столбца, цикл движется по столбцу
164     }
165    else ///если клеткa данной диагонали выходит за размер доски (когда цикл по строке доберется до конца
166      {
167         a = M-1; ///самая последняя диагональ
168         b =(dia % M)+1; ///соответственно расчёт переменной для столбца этой диагонали
169      }
170 
171     for(int i=0; a-i>=0 && b+i < M; ++i)/// цикл движется по строкам и столбцам снизу слева вправо вверх
172     {
173         int line = a-i; ///строковая координата данной клетки диагонали
174         int column = b+i; ///столбцовая координата данной клетки диагонали
175 
176         if(tryEl(line, column))/// проверка на единственность слона по диагоналям
177         {
178             Board[line][column]=1; ///установка слона в первую клетку, присваивание ей значения 1 (true)
179 
180             for(int i = dia + 1; i<2*M-1; ++i) ///расстановка указанного пользователем количества фигур
181                 setEl(i,count+1);
182 
183             if(count+1 == N) /// если нужное количество фигур поставлено, то
184                 showBoard("E"); /// вызов функции вывода шахматной доски на экран
185 
186             Board[line][column]=0; ///обнуление переменной для установки следующей фигуры в следующую клетку
187         }
188     }
189 }
190 
191 ///Функции проверки и установки для коня
192 
193 bool tryHorse(int a, int b) /// проверка на возможность поставить фигуру в данную клетку, a- очередная строка, b- очередной столбец
194 {
195     ///проверка на наличие фигур и угроз во всех 8 точках, которые могут быть под ударом в квадрате 5х5 вокруг установленной фигуры
196 
197     if ((a-1) >=0 && (b-2)>=0 && Board[a-1][b-2])
198         return false;
199 
200     if ((a-1)>=0 && (b+2) < M && Board[a-1][b+2])
201         return false;
202 
203     if ((a+1) < M && (b-2) >=0 && Board[a+1][b-2])
204         return false;
205 
206     if ((a+1) < M && (b+2) < M && Board[a+1][b+2])
207         return false;
208 
209     if ((a-2) >=0 && (b-1) >=0 && Board[a-2][b-1])
210         return false;
211 
212     if ((a-2) >=0 && (b+1) < M && Board[a-2][b+1])
213         return false;
214 
215     if ((a+2) < M && (b-1) >= 0 && Board[a+2][b-1])
216         return false;
217 
218     if ((a+2) < M && (b+1) < M && Board[a+2][b+1])
219         return false;
220 
221     return true; ///если в ходе проверки коней и угроз не обнаружилось, в данную клетку можно поставить фигуру
222 }
223 
224 void setHorse(int count, int a, int b) ///функция расстановки коней; a - очередная строка, b - очередной столбец, count - счетчик количества фигур, которое необходимо расставить
225 {
226     if(count==N) /// если нужное количество фигур поставлено, то
227     {
228         showBoard("H");  /// вызов функции вывода шахматной доски на экран
229     }
230 
231     if (a == M) ///условие необходимо; прогоняет алгоритм по всем строкам
232         return;
233 
234     for (int j=b; j<M; ++j) ///установка коней в первой строке
235     {
236         if(tryHorse(a, j)) ///проверка данной клетки на возможность установки фигуры
237         {
238             Board[a][j]=1; ///установка коня в первую клетку, присваивание ей значения 1 (true)
239             int line = a, b = j+1; ///смещение в строке на одну позицию вправо, переобозначение строки на line
240 
241             if (b == M) ///если данный столбец - самый крайний
242             {
243                 b = 0; ///обнуление переменной, чтобы использовать ее при заполнении следующей строки
244                 line++;     ///то переход на следующую строку и дальнейшее ее заполнение
245             }
246             setHorse(count+1,line,b); ///установка фигуры, увеличение счетчика
247             Board[a][j]=0; ///обнуление переменной для установки следующей фигуры в следующую клетку
248         }
249     }
250 
251     for(int i=a+1; i<M; ++i) ///дальнейшее заполнение оставшихся строк
252     {
253         for (int j=0; j<M; ++j)
254         {
255             if(tryHorse(i, j)) ///проверка данной клетки на возможность установки фигуры
256             {
257                 Board[i][j]=1; ///установка коня в первую клетку, присваивание ей значения 1 (true)
258                 int line = i, b = j+1; ///смещение в строке на одну позицию вправо
259 
260                 if (b == M) ///если данный столбец - самый крайний
261                 {
262                     b = 0;
263                     line++;  ///то переход на следующую строку и дальнейшее ее заполнение
264                 }
265                 setHorse(count+1,line,b); ///установка фигуры, увеличение счетчика
266                 Board[i][j]=0;  ///обнуление переменной для установки следующей фигуры в следующую клетку
267             }
268         }
269     }
270 }
271 
272 ///для короля
273 
274 bool tryKing(int a, int b) /// проверка на возможность поставить фигуру в квадрате 3х3, a- очередная строка, b- очередной столбец
275 {
276  ///проверка на наличие фигур и угроз во всех 8 точках, которые могут быть под ударом в квадрате 3х3 вокруг установленной фигуры
277 
278     for(int i = a-1; i <= a+1; ++i) ///проверка по строкам
279     {
280         for(int j = b-1; j <= b+1; ++j) ///проверка по столбцам
281         {
282             if (a>=0 && a < M && b>=0 && b < M && Board[a][b]) ///условие наличия клетки в пределах доски
283                 return false;
284 
285             if ((a+1) < M && (b-1) >=0 && Board[a+1][b-1])
286                 return false;
287 
288             if ((a+1) < M && Board[a+1][b])
289                 return false;
290 
291             if ((a+1) < M && (b+1) < M && Board[a+1][b+1])
292                 return false;
293 
294             if ((b+1) < M && Board[a][b+1])
295                 return false;
296 
297             if ((a-1)>=0 && (b+1) < M && Board[a-1][b+1])
298                 return false;
299 
300             if ((a-1) >=0 && Board[a-1][b])
301                 return false;
302 
303             if ((a-1) >=0 && (b-1)>=0 && Board[a-1][b-1])
304                 return false;
305 
306             if ((b-1) >= 0 && Board[a][b-1])
307                 return false;
308         }
309     }
310 
311     return true; ///если в ходе проверки королей и угроз не обнаружилось, в данную клетку можно поставить фигуру
312 }
313 
314 void setKing (int count, int a, int b) ///функция расстановки коней; a - очередная строка, b - очередной столбец, count -  счетчик количества фигур, которое необходимо расставить
315 {
316     for (int j=b; j<M; ++j)  ///установка королей в первой строке
317     {
318         if(tryKing(a, j)) ///проверка данной клетки на возможность установки фигуры
319         {
320             Board[a][j]=1; ///проверка данной клетки на возможность установки фигуры
321             setKing(count+1,a,j); ///расстановка фигур в первой строке
322             Board[a][j]=0;  ///обнуление переменной для установки следующей фигуры в следующую клетку
323         }
324     }
325 
326     for(int i=a+1; i<M; ++i) ///установка фигур в оставшуюся часть шахматной доски по строкам
327     {
328         for (int j=0; j<M; ++j)
329         {
330             if(tryKing(i, j)) ///проверка данной клетки на возможность установки фигуры
331             {
332                 Board[i][j]=1; ///проверка данной клетки на возможность установки фигуры
333                 setKing(count+1,i,j); ///расстановка фигур
334                 Board[i][j]=0;  ///обнуление переменной для установки следующей фигуры в следующую клетку
335             }
336         }
337     }
338 
339     if(count==N) /// если нужное количество фигур поставлено, то
340     {
341         showBoard("K");/// вызов функции вывода шахматной доски на экран
342         return;
343     }
344 }
345 
346 int main()
347 {
348     char s; ///переменная, будет использована в цикле
349     do      /// цикл, выводящий на экран данные в зависимости от введенных пользователем значений переменных
350     {
351         do ///цикл для считывания введенного пользователем размера доски
352         {
353             cout << "Input the size of the board: " << endl; ///ввод размера доски
354             cin >> M;
355 
356             if ( (M%2) == 1) ///цикл, работающий только в том случае, если пользователь введет нечетное число
357             {
358                 cout << '\n' << "The number must be even, so try to input the size again" << '\n' << endl;
359             }
360 
361         }
362         while (M%2 !=0); ///пока пользователь не введет допуcтимое число, цикл не прерывается
363 
364         Board = new int*[M];  ///создание двумерного массива для отображения шахматной доски
365         for (int i = 0; i<M; i++)
366             Board[i] = new int[M]; ///создание первую строку доски
367         for (int i = 0; i<M; i++)
368             for (int j = 0; j<M; j++)
369                 Board[i][j] = 0;  ///зануление массива
370 
371         int V; ///пользователь выбирает один из двух вариантов работы программы
372         cout << '\n' << "Input your choice: 1=placing of figures, 2=for max amount of figures" << endl;
373         cin >> V;
374 
375         if (V==1) ///цикл, расставляющий фигуры по введенным пользователем данным
376         {
377             char k; ///переменная, будет использована в цикле
378             do      /// цикл, выводящий на экран данные в зависимости от введенных пользователем значений переменных
379             {
380                 int T; ///пользователь выбирает фигуру
381                 cout << '\n' << "Input type of figure: 1-queen, 2-king, 3-horse, 4-rook, 5-elephant"<< endl;
382                 cin >> T;
383 
384                 int maximum; ///переменная, хранящая максимальное количество фигур, которое можно расставить на заданной доске
385                 if (T==1) ///максимальное количество фигур на заданной доске для ферзя
386                 {
387                     maximum=M;
388                     cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
389                 }
390                 if (T==2) ///максимальное количество фигур на заданной доске для короля
391                 {
392                     maximum=0.25*M*M;
393                     cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
394                 }
395                 if (T==3) ///максимальное количество фигур на заданной доске для коня
396                 {
397                     maximum=0.5*M*M;
398                     cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
399                 }
400                 if (T==4) ///максимальное количество фигур на заданной доске для ладьи
401                 {
402                     maximum=M;
403                     cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
404                 }
405                 if (T==5) ///максимальное количество фигур на заданной доске для слона
406                 {
407                     maximum=2*M-2;
408                     cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
409                 }
410 
411                 do ///цикл, считывающий количество фигур, заданное пользователем
412                 {
413                     cout << "Input the amount of figures, it must be less than max amount or equals that" << endl;
414                     cin >> N;
415                 }
416                 while (N>maximum);   ///пока пользователь не введет допуcтимое число, цикл не прерывается
417 
418                 cout << '\n' << "All possible variants for this amount of figures on this board:" << '\n' << endl;
419 
420                 if (T==1) ///цикл, вызывающий на экран все варианты расстановки заданного пользователем числа фигур для ферзя
421                 {
422                     result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
423                     for (int i=0; i <M; ++i)
424                         setQueen(i,0);
425                 }
426                 if (T==2) ///цикл, вызывающий на экран все варианты расстановки заданного пользователем числа фигур для короля
427                 {
428                     result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
429                     setKing(0,0,0);
430                 }
431                 if (T==3) ///цикл, вызывающий на экран все варианты расстановки заданного пользователем числа фигур для коня
432                 {
433                     result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
434                     setHorse(0,0,0);
435                 }
436                 if (T==4) ///цикл, вызывающий на экран все варианты расстановки заданного пользователем числа фигур для ладьи
437                 {
438                     result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
439                     for (int i=0; i <M; ++i)
440                         setRook(i,0);
441                 }
442                 if (T==5) ///цикл, вызывающий на экран все варианты расстановки заданного пользователем числа фигур для слона
443                 {
444                     result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
445                     for(int i = 0; i<2*M-1; ++i)
446                         setEl(i,0);
447                 }
448 
449                 cout << '\n' << "If you want continue placing figures, input +, if not, input -" << endl;
450                 cin >> k;
451             }
452             while (k != '-'); ///цикл работает до тех пор, пока пользователь не даст команду на его завершение
453         }
454 
455         else if (V==2) ///цикл, вычисляющий максимальное количество фигур по введенным пользователем данным
456         {
457             char z; ///переменная, будет использована в цикле
458             do      /// цикл, выводящий на экран данные в зависимости от введенных пользователем значений переменных
459             {
460                 int T; ///переменная для выбора фигуры пользователем
461                 cout << '\n' << "Input type of figure: 1-queen, 2-king, 3-horse, 4-rook, 5-elephant"<< endl;
462                 cin >> T;
463                 char d;  ///переменная, будет использована в циклах
464                 int maximum; ///переменная, хранящая максимальное количество фигур, которое можно расставить на заданной доске
465                 if (T==1) ///максимальное количество фигур на заданной доске для ферзя
466                 {
467                     maximum=M; ///формула расчёта максимального количества фигур для заданной доски
468                     cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
469                     cout << "If you want to see all locations of max amount, input +, if not, input -" << endl;
470                     cin >> d;
471                     cout << '\n' << "All possible variants for this amount of figures on this board:" << '\n' << endl;
472                     if (d=='+') ///по выбору пользователя вывод всех возможных расстановок для максимального количества для данной фигуры
473                     {
474                         result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
475                         N=maximum; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
476                         for (int i=0; i < M; ++i)
477                             setQueen(i,0);
478                     }
479 
480                 }
481                 if (T==2) ///максимальное количество фигур на заданной доске для короля
482                 {
483                     maximum=0.25*M*M; ///формула расчёта максимального количества фигур для заданной доски
484                     cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
485                     cout << "If you want to see all locations of max amount, input +, if not, input -" << endl;
486                     cin >> d;
487                     cout << '\n' << "All possible variants for this amount of figures on this board:" << '\n' << endl;
488                     if (d=='+') ///по выбору пользователя вывод всех возможных расстановок для максимального количества для данной фигуры
489                     {
490                         result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
491                         N=maximum; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
492                         setKing(0,0,0);
493                     }
494                 }
495                 if (T==3) ///максимальное количество фигур на заданной доске для коня
496                 {
497                     maximum=0.5*M*M; ///формула расчёта максимального количества фигур для заданной доски
498                     cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
499                     cout << "If you want to see all locations of max amount, input +, if not, input -" << endl;
500                     cin >> d;
501                     cout << '\n' << "All possible variants for this amount of figures on this board:" << '\n' << endl;
502                     if (d=='+') ///по выбору пользователя вывод всех возможных расстановок для максимального количества для данной фигуры
503                     {
504                         result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
505                         N=maximum; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
506                         setHorse(0,0,0);
507                     }
508                 }
509                 if (T==4) ///максимальное количество фигур на заданной доске для ладьи
510                 {
511                     maximum=M; ///формула расчёта максимального количества фигур для заданной доски
512                     cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
513                     cout << "If you want to see all locations of max amount, input +, if not, input -" << endl;
514                     cin >> d;
515                     cout << '\n' << "All possible variants for this amount of figures on this board:" << '\n' << endl;
516                     if (d=='+') ///по выбору пользователя вывод всех возможных расстановок для максимального количества для данной фигуры
517                     {
518                         result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
519                         N=maximum; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
520                         for (int i=0; i <M; ++i)
521                             setRook(i,0);
522                     }
523                 }
524                 if (T==5) ///максимальное количество фигур на заданной доске для слона
525                 {
526                     maximum=2*M-2; ///формула расчёта максимального количества фигур для заданной доски
527                     cout << '\n' << "Max amount of figures for this board = " << maximum << '\n' << endl;
528                     cout << "If you want to see all locations of max amount, input +, if not, input -" << endl;
529                     cin >> d;
530                     cout << '\n' << "All possible variants for this amount of figures on this board:" << '\n' << endl;
531                     if (d=='+') ///по выбору пользователя вывод всех возможных расстановок для максимального количества для данной фигуры
532                     {
533                         result_count=0; ///обнуление переменной, выводящей номер решения; необходимо при повторной работе цикла
534                         N=maximum; ///приравниваем количество фигур для установки максимально возможному, рассчитанному по формуле выше
535                         for(int i = 0; i<2*M-1; ++i)
536                             setEl(i,0);
537                     }
538                 }
539 
540                 cout << '\n' << "If you want continue counting, input +, if not, input -" << '\n' << endl;
541                 cin >> z;
542             }
543             while (z != '-'); ///цикл работает до тех пор, пока пользователь не даст команду на его завершение
544         }
545         cout << '\n' << "If you want to change the size of board, input +, if not, input -" << endl;
546         cin >> s;
547         if (s=='-')
548         {
549             cout << '\n' << "The program is finished." << '\n' << endl; ///вывод на экран сообщения о завершении работы программы
550         }
551     }
552     while (s != '-'); ///цикл работает до тех пор, пока пользователь не даст команду на его завершение, а также на завершение всей программы
553 }

Уманский Александр

Работа программы: Программа предлагает 2 режима работы 1 режим это нахождение для 1 из 5 фигур таких расстановок L фигур, на доске M*N, что они не бьют друг друга, второй режим возможно найти максимальное число фигур, которое можно расставить на этом поле, чтобы они не били друг друга.

Идея алгоритма: Основная идея заключается в присваиванию клетке 1 из 3 значений, пустая клетка, битая клетка или клетка, в которой стоит фигура. В точку ставится фигура, дальше маркируются поля, в которые уже невозможно поставить фигуру, затем мы ставим следующую фигуру и снова маркируем поля, в которые не можем ничего поставить и так далее до нужного пользователю числа фигур. Поиск максимального числа это попытка поставить на доску как можно больше фигур, он пользуется алгоритмами первого пункта.

Скачать можно тут.