public static List <StepPlacementLog> Place(CompositionResult cmp, Matrix <int> R, out string errMsg)
{
// если в методе произошла какая-то критическая ошибка, записывайте её в эту переменную и делайте return null
errMsg = "";
// считываем результат компоновки, в нём хранится список элементов для каждого узла
var boardsElements = cmp.BoardsElements;
// создаём класс для логирования (обязательно)
var log = new List <StepPlacementLog>();
// создаём список с матрицами для каждого узла
var boards = new List <Matrix <int> >();
// тестовый алгоритм просто последовательно размещает все элементы на плату
// запускаем цикл по платам, в каждой плате резмещаем элементы, а потом переходим к следующей
foreach (var boardElements in boardsElements)
{
// определяем размер платы (3х3, 4х4, 5х5) основываясь на количестве элементов, которые необходимо на ней расположить
var size = Convert.ToInt32(Math.Ceiling(Math.Sqrt(boardElements.Count)));
// создаём матрицу просчитанного размера
var boardMatr = new Matrix <int>(size, size);
// заполняем "-1" матрицу
boardMatr.Fill(-1);
// добавляем в общий список плат новую матрицу платы, в которую будем на этом шаге заносить элементы
boards.Add(boardMatr);
// определяет в какую позицию будет поставлен элемент
int pos = 0;
// запускаем цикл по элементам, которые должны быть размещены на плате
foreach (var element in boardElements)
{
// добавляем в последнюю плату элемент на определённую позицию. позиция тут задаётся от 1 до 9. нумерация немного не такая как в идз:
// 1 4 7
// 2 5 8
// 3 6 9 (для платы 3х3)
boards.Last().setValueByPlatePos(pos, element);
pos++;
// записываем результат
string msg = "Поместили элемент D" + element + " на " + boards.Count + " плату"; // пишем сообщение чё произошло на этом шаге
var step = new StepPlacementLog(boards, msg);
log.Add(step);
}
}
// возвращаем список шагов
return(log);
}
public static List <StepPlacementLog> Place(CompositionResult cmp, Matrix <int> R, out string errMsg)
{
matrR = R;
// если в методе произошла какая-то критическая ошибка, записывайте её в эту переменную и делайте return null
errMsg = "";
// считываем результат компоновки, в нём хранится список элементов для каждого узла
var boardsElements = cmp.BoardsElements;
// создаём класс для логирования (обязательно)
var log = new List <StepPlacementLog>();
// создаём список с матрицами для каждого узла
var boards = new List <Matrix <int> >();
// запускаем цикл по платам, в каждой плате резмещаем элементы, а потом переходим к следующей
foreach (var boardElements in boardsElements)
{
// определяем размер платы (3х3, 4х4, 5х5) основываясь на количестве элементов, которые необходимо на ней расположить
var size = Convert.ToInt32(Math.Ceiling(Math.Sqrt(boardElements.Count)));
// создаём матрицу просчитанного размера
var boardMatr = new Matrix <int>(size, size);
// заполняем "-1" матрицу
boardMatr.Fill(-1);
// добавляем в общий список плат новую матрицу платы, в которую будем на этом шаге заносить элементы
boards.Add(boardMatr);
// начальная позиция - условные координаты разъема
var pos = new Position(-1, -1);
// таким способом копируем список всех элементов в список неразмещённых
List <int> unplacedElements = boardElements.Select(x => x).ToList();
// в списке размещённых по умолчанию только разъём
List <int> placedElements = new List <int>();
placedElements.Add(0);
// запускаем цикл, пока не разместим все элементы
while (unplacedElements.Count > 0)
{
// список с количеством связей с ранее размещёнными элементами ещё неразмещённых
// позиция в списке совпадает с позицией в списке неразмещённых номеров элементов
var countRelationWithPlaced = new List <int>();
// с помощью метода получаем список количества связей для каждого неразмещённого элемента
countRelationWithPlaced = countRelations(unplacedElements, placedElements);
// определяем максимальное число связей
var maxRelations = countRelationWithPlaced.Max();
// определяем позицию, в которой находится элемент с максимальным количеством связей
var elementPosMaxRelations = countRelationWithPlaced.IndexOf(maxRelations);
// получаем номер элемента по позиции в списке
var elementNumberMaxRelations = unplacedElements[elementPosMaxRelations];
string msg = "Количество связей с размещёнными элементами неразмещённых: ";
for (int i = 0; i < unplacedElements.Count; i++)
{
msg += $"D{unplacedElements[i]}={countRelationWithPlaced[i]}; ";
}
msg += "\n";
msg += $"Максимальное количество c размещёнными элементами у элемента D{elementNumberMaxRelations}\n";
msg += $"Найдём оптимальную позицию:\n";
// получаем список незанятых соседних ячеек на основе позиции элемента размещённого на предыдущем шаге
var neighbors = getNeigbors(boardMatr, pos);
// начинаем определение оптимальной позиции для размещения элемента
Position minLpos = null;
int minL = int.MaxValue;
// запускаем цикл по всем соседям
foreach (var neighbor in neighbors)
{
msg += $"D{elementNumberMaxRelations} -> {boardMatr.getRelativePosByAbsolute(neighbor)}; L=";
List <string> operations = new List <string>();
int L = 0;
// запускаем цикл по всем элементам
for (int j = 0; j < matrR.ColsCount; j++)
{
// если этот элемент был размещён
if (placedElements.Contains(j))
{
// если у размещаемого элемента есть связи с текущим рассматриваемым
if (matrR[elementNumberMaxRelations, j] != 0)
{
// количество связей определяем по матрице R
int countRelationsWithElement = matrR[elementNumberMaxRelations, j];
// получаем расстояние между элементами
int length = getLength(neighbor, getPosByElementNumber(boardMatr, j));
operations.Add($"{countRelationsWithElement}*{length}");
// суммируем длину умноженную на количество связей в L
L += countRelationsWithElement * length;
}
}
}
msg += String.Join("+", operations);
msg += $"={L}\n";
// если подсчитанное L меньше просчитанного на предыдущих шагах
if (L < minL)
{
minL = L;
// принимаем эту позицию как оптимальную
minLpos = neighbor.Clone();
}
}
int minLposRelative = boardMatr.getRelativePosByAbsolute(minLpos);
msg += $"Минимальное значение L в {minLposRelative} позиции\n";
pos = minLpos.Clone();
// устанавливаем элемент в оптимальную позицию
boards.Last().setValueByPlatePos(minLposRelative, elementNumberMaxRelations);
// начинаем логирование действия
msg += $"Помещаем его в {minLposRelative} позицию на {boards.Count} плату";
var step = new StepPlacementLog(boards, msg);
log.Add(step);
// закончили логирование
// убираем из списка неразмещённых элемент, который только что разместили
unplacedElements.Remove(elementNumberMaxRelations);
// и добавляем в список размещённых
placedElements.Add(elementNumberMaxRelations);
}
}
return(log);
}
public static List <StepPlacementLog> Place(Matrix <int> R, out string errMsg)
{
// если в методе произошла какая-то критическая ошибка, записывайте её в эту переменную и делайте return null
errMsg = "";
var log = new List <StepPlacementLog>();
// так как итерационный метод должен основываться на резульатах последовательного размещения
// считываем результаты размещения
var plc = ApplicationData.ReadPlacement(out errMsg);
if (errMsg != "")
{
return(log);
}
var cmp = ApplicationData.ReadComposition(out errMsg);
// если произошла ошибка при чтении результатов размещения - заканчиваем алгоритм
if (errMsg != "")
{
return(null);
}
// считываем матрицы плат с уже размещёнными элементами
List <Matrix <int> > boardsMatrices = plc.BoardsMatrices;
var st = new StepPlacementLog(boardsMatrices, "Начинаем итерационное разщмещение...");
log.Add(st);
// запускаем цикл по всем платам
for (int boardNum = 0; boardNum < boardsMatrices.Count; boardNum++)
{
// получаем матрицу, в котором хранятся номера элементов текущей платы
var boardMatr = boardsMatrices[boardNum];
// создаем список для пар позиций, элементы в которых нужно попробовать поменять местами
List <PairPos> pairs = new List <PairPos>();
// формируем список пар соседей
// проходим по всем позициям платы
for (int i = 0; i < boardMatr.RowsCount; i++)
{
for (int j = 0; j < boardMatr.ColsCount; j++)
{
// если текущая позиция содержит элемент
if (boardMatr[i, j] != -1)
{
var currentPos = new Position(i, j);
// получаем позиции соседей для текущей позиции, которые содержат элемент
var neighbors = getNeighbors(boardMatr, currentPos);
// если найден хоть 1 сосед
if (neighbors.Count > 0)
{
// для каждого соседа создаём пару с текущим элементом
foreach (var neighbor in neighbors)
{
var currentPair = new PairPos();
currentPair.FirstPos = currentPos.Clone();
currentPair.SecondPos = neighbor.Clone();
// если такой пары нет в уже сформированных, то добавляем её в общий список
if (!pairs.Any(x => x.Equals(currentPair)))
{
pairs.Add(currentPair);
}
}
}
}
}
}
// максимальное приращение
int deltaLMax;
// пара с этим максимальным приращением
PairPos pairMaxDeltaL = new PairPos();
string stepMsg = "";
// запускаем цикл, пока будут положительные приращения
do
{
deltaLMax = 0;
pairMaxDeltaL = null;
stepMsg = "";
// запускаем цикл по всем парам
foreach (var pair in pairs)
{
int firstEl = boardMatr[pair.FirstPos.Row, pair.FirstPos.Column];
int secondEl = boardMatr[pair.SecondPos.Row, pair.SecondPos.Column];
// формируем по кусочкам сообщение
stepMsg += $"\u0394L({firstEl}-{secondEl}) = ";
// формируем список остальных элементов на плате, кроме элоементов текущей пары
var otherElements = cmp.BoardsElements[boardNum].Select(x => x).ToList();
otherElements.Remove(firstEl);
otherElements.Remove(secondEl);
// добавляем элемент разъёма
otherElements.Add(0);
otherElements.Sort();
// текущее приращение
int L = 0;
// это просто 2 списка для формирования сообщения шага
List <string> operationsDef = new List <string>(); // в этом хранится буквенное обозначение операции, например: (r1 - r2)*(d1 - d2)
List <string> operationsValue = new List <string>(); // а тут именно числовое (5 - 8)*(1 - 3)
// начинаем считать приращение для текущей пары
// для этого запускаем цикл по всем остальным элементам
foreach (var otherElement in otherElements)
{
// получаем позицию рассматриваемого элемента
Position currentElPos = getPosByElementNumber(boardMatr, otherElement);
operationsDef.Add($"(r{otherElement}-{firstEl} - r{otherElement}-{secondEl})*" +
$"(d{otherElement}-{firstEl} - d{otherElement}-{secondEl})");
operationsValue.Add($"({R[otherElement, firstEl]}-{R[otherElement, secondEl]})*" +
$"({getLength(currentElPos, pair.FirstPos)}-{getLength(currentElPos, pair.SecondPos)})");
// прибавляем к общему приращению
// (количество связей между текущим и первым из пары + количество связей между текущим и вторым из пары) *
// (длинна между позицией текущего и первого из пары - длинна между позицией текущего и второго из пары)
L += (R[otherElement, firstEl] - R[otherElement, secondEl]) *
(getLength(currentElPos, pair.FirstPos) - getLength(currentElPos, pair.SecondPos));
}
// добавляем к сообщению шага сразу все описания операций
stepMsg += string.Join("+", operationsDef);
stepMsg += "=";
// потом все подставленные значения
stepMsg += string.Join("+", operationsValue);
stepMsg += "=";
stepMsg += L + "\n";
// если у текущей пары L больше чем у уже найденной ранее
if (L > deltaLMax)
{
deltaLMax = L; // запоминаем максимальное приращение
pairMaxDeltaL = pair; // и текущую пару
}
}
// нашли пару с максимальным приращением
// только если это приращение больше 0, нужно поменять элементы на позициях платы местами
if (deltaLMax > 0)
{
// т.к. у нас есть только позиции на плате, элементы в которых нужно поменять местами
// достаём номера элементов по этим позиция из матрицы платы
int firstElement = boardMatr[pairMaxDeltaL.FirstPos.Row, pairMaxDeltaL.FirstPos.Column];
int secondElement = boardMatr[pairMaxDeltaL.SecondPos.Row, pairMaxDeltaL.SecondPos.Column];
// добавляем описание
stepMsg += $" -- Наибольшее \u0394L у пары ({firstElement}-{secondElement}) = {deltaLMax}. Меняем их местами";
// и наконец меняцм местами
boardMatr[pairMaxDeltaL.FirstPos.Row, pairMaxDeltaL.FirstPos.Column] = secondElement;
boardMatr[pairMaxDeltaL.SecondPos.Row, pairMaxDeltaL.SecondPos.Column] = firstElement;
}
else
{
stepMsg += " -- Положительных приращений нет";
}
// логируем изменения
var step = new StepPlacementLog(boardsMatrices, stepMsg);
log.Add(step);
// цикл будет менять местами элементы с максимальным положительным приращением, пока не найдёт
// ни одного положительного приращения между парами
} while (deltaLMax > 0);
}
return(log);
}
public static List <StepPlacementLog> Place(Matrix <int> R, out string errMsg)
{
// если в методе произошла какая-то критическая ошибка, записывайте её в эту переменную и делайте return null
errMsg = "";
var log = new List <StepPlacementLog>();
// так как итерационный метод должен основываться на резульатах последовательного размещения
// считываем результаты размещения
var plc = ApplicationData.ReadPlacement(out errMsg);
// если произошла ошибка при чтении результатов размещения - заканчиваем алгоритм
if (errMsg != "")
{
return(null);
}
// считываем матрицы плат с уже размещёнными элементами
List <Matrix <int> > boardsMatrices = plc.BoardsMatrices;
// переменные для операций с матрицами, списками и прочим
int coloumn, row, coloumn_next, row_next, coef, index, i, j, maxL, exchange_coloumn, exchange_row, buf, boardNum;
string stepMsg;
bool flag;
// номер текущей платы
boardNum = 0;
log.Add(new StepPlacementLog(boardsMatrices, "Начинаем итерационное размещение методом Шаффера..."));
// цикл по платам с уже размещёнными элементами
foreach (var boardMatrix in boardsMatrices)
{
boardNum++;
// если у платы меньше 3 строк или столбцов, то нет смысла переставлять столбцы и строки
if (boardMatrix.ColsCount < 3 || boardMatrix.RowsCount < 3)
{
stepMsg = $" -- Плата №{boardNum} имеет размер менее 3х3. Нет смысла её рассматривать .\n";
var step = new StepPlacementLog(boardsMatrices, stepMsg);
log.Add(step);
continue;
}
// цикл по столбцам платы
flag = true;
// цикл продолжается, пока есть положительные приращения deltaL
while (flag == true)
{
stepMsg = $" -- Рассматриваем столбцы платы №{boardNum}.\n";
// создание матрицы со связями для текущей платы
Matrix <int> n = new Matrix <int>(boardMatrix.RowsCount, boardMatrix.ColsCount);
n.Fill(0);
// цикл по столбцами (слева направо); последний столбец не рассматриваем
for (coloumn = 0; coloumn < boardMatrix.ColsCount - 1; coloumn++)
{
// цикл по элементам столбца (сверху вниз)
for (row = 0; row < boardMatrix.RowsCount; row++)
{
// проверка, размещен ли элемент в этом месте платы
if (boardMatrix[row, coloumn] == -1)
{
continue;
}
// цикл по оставшимся столбцам матрицы для подсчета связей текущего столбца с каждым
for (coloumn_next = coloumn + 1; coloumn_next < boardMatrix.ColsCount; coloumn_next++)
{
// цикл по элементам следующих столбцов для подсчета связей
// текущего элемента текущего столбца с каждым из элементов следующих столбцов
for (row_next = 0; row_next < boardMatrix.RowsCount; row_next++)
{
// проверка, размещен ли элемент в этом месте платы
if (boardMatrix[row_next, coloumn_next] == -1)
{
continue;
}
// добавление к ячейке n очередной связи (из матрицы R) текущего
// элемента текущего столбца с очередным элементом одного из следующих столбцов
n[coloumn, coloumn_next] += R[boardMatrix[row, coloumn], boardMatrix[row_next, coloumn_next]];
// заполняем матрицу зеркально ниже нулевой диагонали
n[coloumn_next, coloumn] += R[boardMatrix[row, coloumn], boardMatrix[row_next, coloumn_next]];
}
}
}
}
// вычисление deltaL для определения пар столбцов, которые надо поменять местами
List <int> deltaL = new List <int>(n.ColsCount - 1);
// цикл для вычисления каждого deltaL
for (index = 0; index < deltaL.Capacity; index++)
{
stepMsg += $"\u0394L{index + 1}-{index + 2} = ";
// это просто 2 списка для формирования сообщения шага
List <string> operationsDef = new List <string>(); // в этом хранится буквенное обозначение операции, например: (r1 - r2)*(d1 - d2)
List <string> operationsValue = new List <string>(); // а тут именно числовое (5 - 8)*(1 - 3)
// список номеров столбцов, кроме двух текущих
List <int> other = new List <int>();
for (i = 0; i < deltaL.Capacity + 1; i++)
{
if (i != index && i != index + 1)
{
other.Add(i);
}
}
// обнуление текущего L для его наращивания в цикле
deltaL.Add(0);
// цикл по списку не текущих столбцов. в каждом проходе реализация формулы k*(l13 - l23) (числа для примера)
for (j = 0; j < other.Count; j++)
{
// расстояние между столбцами
coef = Math.Abs(index - other[j]) - Math.Abs(index + 1 - other[j]);
// формула k*(l13 - l23)
deltaL[index] += coef * (n[index, other[j]] - n[index + 1, other[j]]);
operationsDef.Add($"(r{index + 1}-{other[j] + 1} - r{index + 2}-{other[j] + 1})*" +
$"(d{index + 1}-{other[j] + 1} - d{index + 2}-{other[j] + 1})");
operationsValue.Add($"({n[index, other[j]]}-{n[index + 1, other[j]]})*" +
$"({Math.Abs(index - other[j])}-{Math.Abs(index + 1 - other[j])})");
}
// добавляем к сообщению шага сразу все описания операций
stepMsg += string.Join(" + ", operationsDef);
stepMsg += " = ";
// потом все подставленные значения
stepMsg += string.Join(" + ", operationsValue);
stepMsg += " = ";
stepMsg += deltaL[index] + ".\n";
}
// наибольшее значения из списка deltaL
maxL = 0;
// номер столбца, который нужно поменять местами с его соседом справа
exchange_coloumn = -1;
// цикл для поиска положительных значений в списке deltaL для определения пар столбцов, которые надо поменять местами
for (i = 0; i < deltaL.Count; i++)
{
if (deltaL[i] > maxL)
{
maxL = deltaL[i];
exchange_coloumn = i;
}
}
// проверка необходимости перестановки столбцов
if (maxL > 0)
{
stepMsg += $" -- Наибольшее \u0394L у столбцов {exchange_coloumn + 1} и {exchange_coloumn + 2} = {maxL}. Меняем их местами.";
// перестановка пары столбцов
for (row = 0; row < boardMatrix.RowsCount; row++)
{
buf = boardMatrix[row, exchange_coloumn];
boardMatrix[row, exchange_coloumn] = boardMatrix[row, exchange_coloumn + 1];
boardMatrix[row, exchange_coloumn + 1] = buf;
}
flag = true;
}
else
{
stepMsg += " -- Положительных приращений нет";
flag = false;
}
var step = new StepPlacementLog(boardsMatrices, stepMsg);
log.Add(step);
}
// цикл по строкам платы
flag = true;
// цикл продолжается, пока есть положительные приращения deltaL
while (flag == true)
{
stepMsg = $" -- Рассматриваем строки платы №{boardNum}.\n";
// создание матрицы со связями для текущей платы
Matrix <int> n = new Matrix <int>(boardMatrix.ColsCount, boardMatrix.RowsCount);
n.Fill(0);
// цикл по строкам (сверху вниз); последнюю строку не рассматриваем
for (row = 0; row < boardMatrix.RowsCount - 1; row++)
{
// цикл по элементам строки (слева направо)
for (coloumn = 0; coloumn < boardMatrix.ColsCount; coloumn++)
{
// проверка, размещен ли элемент в этом месте платы
if (boardMatrix[row, coloumn] == -1)
{
continue;
}
// цикл по оставшимся строкам матрицы для подсчета связей текущей строки с каждой
for (row_next = row + 1; row_next < boardMatrix.RowsCount; row_next++)
{
// цикл по элементам следующих строк для подсчета связей
// текущего элемента текущей строки с каждым из элементов следующих строк
for (coloumn_next = 0; coloumn_next < boardMatrix.ColsCount; coloumn_next++)
{
// проверка, размещен ли элемент в этом месте платы
if (boardMatrix[row_next, coloumn_next] == -1)
{
continue;
}
// добавление к ячейке n очередной связи (из матрицы R) текущего
// элемента текущей строки с очередным элементом одной из следующих строк
n[coloumn, coloumn_next] += R[boardMatrix[row, coloumn], boardMatrix[row_next, coloumn_next]];
// заполняем матрицу зеркально ниже нулевой диагонали
n[coloumn_next, coloumn] += R[boardMatrix[row, coloumn], boardMatrix[row_next, coloumn_next]];
}
}
}
}
// вычисление deltaL для определения пар строк, которые надо поменять местами
List <int> deltaL = new List <int>(n.RowsCount - 1);
// цикл для вычисления каждого deltaL
for (index = 0; index < deltaL.Capacity; index++)
{
stepMsg += $"\u0394L{index + 1}-{index + 2} = ";
// это просто 2 списка для формирования сообщения шага
List <string> operationsDef = new List <string>(); // в этом хранится буквенное обозначение операции, например: (r1 - r2)*(d1 - d2)
List <string> operationsValue = new List <string>(); // а тут именно числовое (5 - 8)*(1 - 3)
// список номеров строк, кроме двух текущих
List <int> other = new List <int>();
for (i = 0; i < deltaL.Capacity + 1; i++)
{
if (i != index && i != index + 1)
{
other.Add(i);
}
}
// обнуление текущего L для его наращивания в цикле
deltaL.Add(0);
// цикл по списку не текущих столбцов. в каждом проходе реализация формулы k*(l13 - l23) (числа для примера)
for (j = 0; j < other.Count; j++)
{
// расстояние между строками
coef = Math.Abs(index - other[j]) - Math.Abs(index + 1 - other[j]);
// формула k*(l13 - l23)
deltaL[index] += coef * (n[index, other[j]] - n[index + 1, other[j]]);
operationsDef.Add($"(r{index + 1}-{other[j] + 1} - r{index + 2}-{other[j] + 1})*" +
$"(d{index + 1}-{other[j] + 1} - d{index + 2}-{other[j] + 1})");
operationsValue.Add($"({n[index, other[j]]}-{n[index + 1, other[j]]})*" +
$"({Math.Abs(index - other[j])}-{Math.Abs(index + 1 - other[j])})");
}
// добавляем к сообщению шага сразу все описания операций
stepMsg += string.Join(" + ", operationsDef);
stepMsg += " = ";
// потом все подставленные значения
stepMsg += string.Join(" + ", operationsValue);
stepMsg += " = ";
stepMsg += deltaL[index] + ".\n";
}
// наибольшее значения из списка deltaL
maxL = 0;
// номер строки, которую нужно поменять местами с её соседом снизу
exchange_row = -1;
// цикл для поиска положительных значений в списке deltaL для определения пар строк, которые надо поменять местами
for (i = 0; i < deltaL.Count; i++)
{
if (deltaL[i] > maxL)
{
maxL = deltaL[i];
exchange_row = i;
}
}
// проверка необходимости перестановки строк
if (maxL > 0)
{
stepMsg += $" -- Наибольшее \u0394L у строк {exchange_row + 1} и {exchange_row + 2} = {maxL}. Меняем их местами.";
// перестановка пары столбцов
for (row = 0; row < boardMatrix.RowsCount; row++)
{
buf = boardMatrix[row, exchange_row];
boardMatrix[row, exchange_row] = boardMatrix[row, exchange_row + 1];
boardMatrix[row, exchange_row + 1] = buf;
}
flag = true;
}
else
{
stepMsg += " -- Положительных приращений нет";
flag = false;
}
var step = new StepPlacementLog(boardsMatrices, stepMsg);
log.Add(step);
}
}
return(log);
}
public static List <StepPlacementLog> Place()
{
// создаём класс для логирования (обязательно)
var log = new List <StepPlacementLog>();
// создаём список с матрицами для каждого узла
var boards = new List <Matrix <int> >();
var boardMatr = new Matrix <int>(2, 2);
boardMatr.Fill(-1);
// добавляем в общий список плат новую матрицу платы, в которую будем на этом шаге заносить элементы
boards.Add(boardMatr);
//boardMatr
// начинаем логирование действия
string msg = "r = {4 3 2 1 1 0}\n" +
"d = {1 1 1 1 2 2} \n" +
"r х d = 4 + 3 + 2 + 1 + 2 + 0 = 12. \n" +
"Значение целевой функции F(P) не может быть меньше 12.\n";
var step = new StepPlacementLog(boards, msg);
log.Add(step);
boardMatr[0, 0] = 1;
msg = "Помещаем элемент e1 в позицию р1 \n" +
"Размещен 1 элемент: F(q) = 0. \n" +
"Неразмещенные элементы {e2, e3, e4}, свободные позиции {р2, р3, р4}\n" +
"r1 = {4 3 1} и d1 = {1 1 2}; r1 х d1 = 4 + 3 + 2 = 9 \n" +
"w(P) = 9; \n" +
"r = {2 1 0} и d = {1 1 2}; v(P) = r х d = 2 + 1 + 0 = 3;\n" +
"v(P) = r х d = 2 + 1 + 0 = 3;\n" +
"F(P) = 0 + 9 + 3 = 12.\n\n" +
"Помещаем элемент e1 в позицию р2\n" +
"Размещен 1 элемент: F(q) = 0.\n" +
"Неразмещенные элементы {e2, e3, e4}, свободные позиции {р1, р3, р4}.\n" +
"r1 = {4 3 1} и d2 = {1 1 2}; r1 x d2 = 4 + 3 + 2 = 9; \n" +
"w(P) = 9;\n" +
"r = {2 1 0} и d= {1 1 2}; v(P) = r x d = 2 + 1 + 0 = 3;\n" +
"F(P) = 0 + 9 + 3 = 12.\n\n" +
"Помещаем элемент e1 в позицию р3 \n" +
"Размещен 1 элемент: F(q) = 0.\n" +
"Неразмещенные элементы {e2, e3, e4}, свободные позиции {р1, р2, р4}.\n" +
"r1 = {4 3 1} и d3 = {1 1 2}; r1 х d3 = 4 + 3 + 2 = 9;\n" +
"w(P) = 9; \n" +
"r = {2 1 0} и d = {1 1 2}; v(P) = r х d = 2 + 1 + 0 = 3;\n" +
"v(P) = r х d = 2 + 1 + 0 = 3;\n" +
"F(P) = 0 + 9 + 3 = 12.\n\n" +
"Помещаем элемент e1 в позицию р4\n" +
"Размещен 1 элемент: F(q) = 0.\n" +
"Неразмещенные элементы {e2, e3, e4}, свободные позиции {р1, р2, р3}.\n" +
"r1 = {4 3 1} и d4 = {1 1 2}; r1 x d4 = 4 + 3 + 2 = 9; \n" +
"w(P) = 9;\n" +
"r = {2 1 0} и d= {1 1 2}; v(P) = r x d = 2 + 1 + 0 = 3;\n" +
"F(P) = 0 + 9 + 3 = 12.\n\n" +
"Минимальное значение F(P) в 1 позиции\n" +
"Помещаем его в 1 позицию на 1 плату";
step = new StepPlacementLog(boards, msg);
log.Add(step);
boardMatr[1, 1] = 2;
msg = "Помещаем элемент e2 в позицию р2. \n" +
"Размещены 2 элемента: e1 в р1, e2 в р2, F(q) = r12 d12 = 1.\n" +
"Неразмещенные элементы {e3, e4}, свободные позиции {р3, р4};\n" +
"r1 ={4 3} и d1 ={1 2}; r1 x d1 = 4 + 6 = 10;\n" +
"r2 ={2 0} и d2 ={1 2}; r2 x d2 = 2 + 0 = 2;\n" +
"w(P) = 10 + 2 = 12.\n" +
"r = {1} и d = {1}; v(P) = r х d = 1;\n" +
"F(P) = 1 + 12 + 1 = 14.\n" +
"Помещаем элемент e2 в позицию р3. \n" +
"Размещены 2 элемента: e1 в р1, e2 в р3, F(q) = r12 d13 = 1.\n" +
"Неразмещенные элементы {e3, e4}, свободные позиции {р2, р4};\n" +
"r1 ={4 3} и d1 ={1 2}; r1 x d1 = 4 + 6 = 10;\n" +
"r2 ={2 0} и d3 ={1 2}; r2 x d3 = 2 + 0 = 2;\n" +
"w(P) = 10 + 2 = 12.\n" +
"r = {1} и d = {1}; v(P) = r х d = 1;\n" +
"F(P) = 1 + 12 + 1 = 14.\n" +
"Помещаем элемент e2 в позицию р4. \n" +
"Размещены 2 элемента: e1 в р1, e2 в р4, F(q) = r12 d14 = 2.\n" +
"Неразмещенные элементы {e3, e4}, свободные позиции {р2, р3};\n" +
"r1 ={4 3} и d1 ={1 1}; r1 x d1 = 4 + 3 = 7;\n" +
"r2 ={2 0} и d4 ={1 1}; r2 x d4 = 2 + 0 = 2;\n" +
"w(P) = 7 + 2 = 9.\n" +
"r = {1} и d = {2}; v(P) = r х d = 2;\n" +
"F(P) = 1 + 12 + 1 = 13.\n" +
"Минимальное значение F(P) в 4 позиции\n" +
"Помещаем его в 4 позицию на 1 плату";
step = new StepPlacementLog(boards, msg);
log.Add(step);
boardMatr[0, 1] = 3;
msg = "Помещаем элемент e3 в позицию р2. \n" +
"Размещены 3 элемента: e1 в р1, e2 в р4, e3 в р2, F(q) = r12d14 + r13d12 + r23d42 = 2 + 3 + 2 = 7.\n" +
"Неразмещенный элемент {e4}, свободная позиция {р3};\n" +
"r1 = {4} и d1 = {1}; r1 x d1 = 4;\n" +
"r2 = {0} и d4 = {1}; r2 x d4 = 0;\n" +
"r3 = {1} и d2 = {2}; r3 x d2 = 2;\n" +
"w(P) = 4 + 0 + 2 = 6. \n" +
"Неразмещенный элемент один, v(P) = 0;\n" +
"F(P) = 7 + 6 + 0 = 13.\n" +
"Помещаем элемент e3 в позицию р3. \n" +
"Размещены 3 элемента: e1 в р1, e2 в р4, e3 в р3, F(q) = r12d14 + r13d13 + r23d43 = 2 + 3 + 2 = 7.\n" +
"Неразмещенный элемент {e4}, свободная позиция {р2}; \n" +
"r1 = {4} и d1 = {1}; r1 x d1 = 4;\n" +
"r2 = {0} и d4 = {1}; r2 x d4 = 0;\n" +
"r3 = {1} и d3 = {2}; r3 x d3 = 2;\n" +
"w(P) = 4 + 0 + 2 = 6. \n" +
"Неразмещенный элемент один, v(P) = 0;\n" +
"F(P) = 7 + 6 + 0 = 13.\n" +
"Минимальное значение F(P) в 2 позиции\n" +
"Помещаем его в 2 позицию на 1 плату";
step = new StepPlacementLog(boards, msg);
log.Add(step);
boardMatr[1, 0] = 4;
msg = "Помещаем элемент e4 в позицию р3.\n" +
"Размещены 4 элемента: e1 в р1, e2 в р4, e3 в р2, e4 в 3, F(q) = r12d14 + r13d12 + r23d42 + r14d13 + r24d43 + r34d23 = 2 + 3 + 2 + 4 + 0 + 2 = 13.\n" +
"Неразмещенного элемента нет, свободных позиций нет;\n" +
"w(P) = 0;\n" +
"Неразмещенного элемента нет, v(P) = 0;\n" +
"F(P) = 13 + 0 + 0 = 13.\n" +
"Минимальное значение F(P) в 3 позиции\n" +
"Помещаем его в 3 позицию на 1 плату";
step = new StepPlacementLog(boards, msg);
log.Add(step);
return(log);
}