用特定模式填充矩阵

Question

所以我有一个总是相同维度的矩阵，它的定义如下：

public void InitPositionsGrid()
    {
        int munberOfRows = 6;
        for(int i = 0; i < munberOfRows; i++)
        {
            if( i % 2 == 0)
            {
                GridPositions[i] = new int[15];
            }
            else
            {
                GridPositions[i] = new int[14];
            }
        }
    }

现在，我需要一种方法（递归或迭代 - 随便什么）来填充这个矩阵，但使用特定的模式，以便它在所有方向上均匀填充。该方法应该采用 3 个参数 X 和 Y 定义起始位置，另一个参数是要填充的位置数。应该看起来像这样：

public void FillGridMatrix(int startingRow, int startingColumn, int numberOfPlacesToFill)
{
    //Fill the matrix with the following algorithm but don't go out of bounds
}

这是显示算法示例的图片：

思路是：从当前起始位置开始，勾选“上面”两个空格（应该是x-1,y-1和x-1,y），检查相邻的两个空格（x,y-1和x ,y+1)，最后检查“下面”两个空格（x+1,y-1 和 x+1,y）。坐标可能不完全是那些，但这是一般的想法。请注意，当“向上”或“向下”没有更多空间时，要填充的位置应该在左侧和右侧相等。起始行不能是第一行也不能是最后一行。如果当前正在检查的地点已被标记，请跳过该地点。要填充的最大位置数可以是 87，矩阵本身的最大元素数也是如此。第一轮结束后，如果有超过 7 个位置需要填充，则算法从左上角开始，到右下角从起始位置的“相邻”成员结束（本例中为 2 和 7）。

知道什么是最好的解决方案吗？首选 C#。

编辑：这是最接近我想要实现的解决方案，唯一的问题是这不适合递归，并且迭代解决方案需要太多条件。

public int PopulateMatrixAroundCertainPosition(int[][] matrix, int row, int column, int availableNumbers)
    {
        if(availableNumbers <= 0)
        {
            return 0;
        }
        matrix[row][column] = 1;
        availableNumbers = PopulateSingleMatrixPosition(matrix, row - 1, column - 1, availableNumbers - 1);
        availableNumbers = PopulateSingleMatrixPosition(matrix, row - 1, column, availableNumbers - 1);
        availableNumbers = PopulateSingleMatrixPosition(matrix, row, column - 1, availableNumbers - 1);
        availableNumbers = PopulateSingleMatrixPosition(matrix, row, column + 1, availableNumbers - 1);
        availableNumbers = PopulateSingleMatrixPosition(matrix, row + 1, column - 1, availableNumbers - 1);
        availableNumbers = PopulateSingleMatrixPosition(matrix, row + 1, column, availableNumbers - 1);
        return availableNumbers - 1;
    }

    public int PopulateSingleMatrixPosition(int[][] matrix, int row, int column, int availableNumbers)
    {
        if (availableNumbers <= 0)
        {
            return 0;
        }
        if(matrix[row][column] == 1)
        {
            return availableNumbers + 1;
        }
        matrix[row][column] = 1;
        return availableNumbers;
    }

Answer 1

不需要递归。继续建立内部结构。我创建了一个小状态机来解决难题：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        const int TOTAL_BUTTONS = 61;
        const int BUTTON_SIZE = 40;
        const int SPACE = 10;
        public Form1()
        {
            InitializeComponent();
            BuildMatrix();
        }
        public enum LOCATION
        {
            TOP_ROW,
            LEFT_BUTTON,
            RIGHT_BUTTON,
            BOTTOM_ROW
        }

        List<List<Button>> matrix = new List<List<Button>>();
        int numberButtons = 0;
        public void BuildMatrix()
        {
            int centerX = 0;
            int centerY = 0;

            int loopCounter = 1; //count of number of loops around matrix  

            int numberRows = 0;
            int rowCount = 0;
            int columnCount = 0;
            centerX = this.Width / 2;
            centerY = this.Height / 2;

            LOCATION location = LOCATION.TOP_ROW;
            List<Button> newRow = new List<Button>();
            Button newButton = null;
            Button buttonLeft = null;
            for (int buttonCount = 0; buttonCount < TOTAL_BUTTONS; buttonCount++)
            {
                switch (location)
                {
                    case LOCATION.TOP_ROW :
                        if (columnCount == 0)
                        {
                            newRow = new List<Button>();
                            if (numberRows++ == 0)
                            {
                                matrix.Add(newRow);
                                newButton = AddButton(centerY - (BUTTON_SIZE / 2), centerX - (BUTTON_SIZE / 2));
                                //add first button
                                newRow.Add(newButton);
                                loopCounter++;
                                continue;
                            }
                            else
                            {
                                matrix.Insert(0, newRow);
                                Button buttonDownRight = matrix[1][columnCount];
                                newButton = AddButton(buttonDownRight.Top - SPACE - BUTTON_SIZE, buttonDownRight.Left - ((SPACE + BUTTON_SIZE) / 2));
                            }
                        }
                        else
                        {
                            buttonLeft = matrix[rowCount][columnCount - 1];
                            newButton = AddButton(buttonLeft.Top, buttonLeft.Left + SPACE + BUTTON_SIZE);
                        }
                        //put new button above button below, move up one row, move left half column
                        newRow.Add(newButton);

                        if (++columnCount == loopCounter)
                        {
                            location = LOCATION.LEFT_BUTTON;
                            rowCount++;
                        }
                        break;

                    case LOCATION.LEFT_BUTTON :
                        Button buttonRight = matrix[rowCount][0];
                        newButton = AddButton(buttonRight.Top, buttonRight.Left - SPACE - BUTTON_SIZE);
                        matrix[rowCount].Insert(0, newButton);
                        location = LOCATION.RIGHT_BUTTON;
                        break;

                    case LOCATION.RIGHT_BUTTON :
                        buttonLeft = matrix[rowCount][matrix[rowCount].Count - 1];
                        newButton = AddButton(buttonLeft.Top, buttonLeft.Left + SPACE + BUTTON_SIZE);
                        matrix[rowCount].Add(newButton);
                        rowCount++;
                        if (rowCount >= numberRows)
                        {
                            location = LOCATION.BOTTOM_ROW;
                        }
                        else
                        {
                            location = LOCATION.LEFT_BUTTON;
                        }
                        columnCount = 0;
                        break;

                    case LOCATION.BOTTOM_ROW :
                        if (columnCount == 0)
                        {
                            newRow = new List<Button>();
                            matrix.Add(newRow);
                            numberRows++;
                        }
                        Button buttonTopLeft = matrix[rowCount - 1][columnCount];
                        newButton = AddButton(buttonTopLeft.Top + SPACE + BUTTON_SIZE, buttonTopLeft.Left + ((SPACE + BUTTON_SIZE) / 2));
                        matrix[rowCount].Add(newButton);
                        if (++columnCount == loopCounter)
                        {
                            location = LOCATION.TOP_ROW;
                            columnCount = 0;
                            rowCount = 0;
                            loopCounter++;
                        }


                        break;

                }
            }

        }
        public Button AddButton(int top, int left)
        {
            Button newButton = new Button();
            newButton.Width = BUTTON_SIZE;
            newButton.Height = BUTTON_SIZE;
            newButton.Top = top ;
            newButton.Left = left;
            numberButtons++;
            newButton.Text = numberButtons.ToString();
            this.Controls.Add(newButton);

            return newButton;
        }
    }
}