Уявіть сіткою W від H квадратів, які обгортаються тороїдно. Елементи розміщуються на сітці наступним чином.

Перший елемент може бути розміщений на будь-якому квадраті, але наступні елементи не повинні знаходитися в межах Манхеттенської відстані R від будь-якого попереднього елемента (також відомого як околиці Фон-Неймана діапазону R ). Ретельний вибір позицій дозволяє помістити велику кількість предметів на сітку до того, як немає більше дійсних позицій. Однак замість цього врахуйте протилежну мету: яка найменша кількість предметів, які можна розмістити, і не залишати більше дійсних позицій?

Ось радіус 5 зони відчуження:

Ось ще одна зона відчуження радіусом 5, на цей раз біля країв, тому поведінка загортання очевидна:

Вхідні дані

Три цілих числа:

• W : ширина сітки (натуральне число)
• H : висота сітки (натуральне число)
• R : радіус зони відчуження (невід'ємне ціле число)

Вихідні дані

Ціле число N - це найменша кількість елементів, які можна розмістити, запобігаючи подальшим дійсним розміщенням.

Деталі

• Радіус нуля дає зону виключення в 1 квадрат (ту, на яку був розміщений предмет).
• Радіус N виключає зону, до якої можна дійти N ортогональних кроків (пам'ятайте, що краї обертаються тороїдально).

Ваш код повинен працювати для тривіального випадку R = 0, але не потрібно працювати для W = 0 або H = 0.

Ваш код повинен також мати справу з випадком , коли R > W або R > H .

Ліміт часу та тестові випадки

Ваш код повинен мати можливість вирішувати всі тестові справи, і кожен тестовий випадок повинен завершитися протягом 5 хвилин. Це повинно бути простим (приклад рішення JavaScript займає кілька секунд для кожного тестового випадку). Час обмеження полягає в основному, щоб виключити екстремальний підхід. Приклад підходу все ще є досить грубою силою.

Якщо ваш код заповниться протягом 5 хвилин на одній машині, а не на іншій, це буде досить близько.

Тестові приклади у формі входів: вивести якW H R : N

5 4 4 : 1
5 4 3 : 2
5 4 2 : 2
5 4 1 : 5

7 5 5 : 1
7 5 4 : 2
7 5 3 : 2
7 5 2 : 4

8 8 8 : 1
8 8 7 : 2
8 8 6 : 2
8 8 5 : 2
8 8 4 : 2
8 8 3 : 4

 7  6  4 : 2
 7  6  2 : 4
11  7  4 : 3
11  9  4 : 4
13 13  6 : 3
11 11  5 : 3
15 14  7 : 2
16 16  8 : 2

Фрагмент, щоб допомогти візуалізувати та пограти з ідеями

canvas = document.getElementById('gridCanvas');ctx = canvas.getContext('2d');widthSelector = document.getElementById('width');heightSelector = document.getElementById('height');radiusSelector = document.getElementById('radius');itemCount = document.getElementById('itemCount');canvasMaxWidth = canvas.width;canvasMaxHeight = canvas.height;gridlineColour = '#888';emptyColour = '#ddd';itemColour = '#420';hoverCellColour = '#840';exclusionColour = '#d22';validColour = '#8f7';invalidColour = '#fbb';overlapColour = '#600';resetGrid();x = -1;y = -1;function resetGrid() {gridWidth = widthSelector.value;gridHeight = heightSelector.value;radius = radiusSelector.value;numberOfItems = 0;itemCount.value = numberOfItems + ' items placed.';cells = [gridWidth * gridHeight];for (i=0; i<gridWidth*gridHeight; i++) {cells[i] = '#ddd';}cellSize = Math.min(Math.floor(canvasMaxWidth/gridWidth), Math.floor(canvasMaxHeight/gridHeight));pixelWidth = gridWidth * cellSize + 1;canvas.width = pixelWidth;pixelHeight = gridHeight * cellSize + 1;canvas.height = pixelHeight;leaveCanvas();}function checkPosition(event) {bound = canvas.getBoundingClientRect();canvasX = event.clientX - bound.left;canvasY = event.clientY - bound.top;newX = Math.min(Math.floor(canvasX / cellSize), gridWidth-1);newY = Math.min(Math.floor(canvasY / cellSize), gridHeight-1);if (newX != x || newY != y) {x = newX;y = newY;drawGrid();}}function leaveCanvas() {x = -1;y = -1;drawGrid();}function drawGrid() {ctx.fillStyle = gridlineColour;ctx.fillRect(0, 0, pixelWidth, pixelHeight);cellColour = cells[x + gridWidth * y];if (cellColour == itemColour || cellColour == exclusionColour) {zoneColour = invalidColour;} else {zoneColour = validColour;}for (gridX=0; gridX<gridWidth; gridX++) {for (gridY=0; gridY<gridHeight; gridY++) {colour = (cells[gridX + gridWidth * gridY]);if (x >= 0 && y >= 0) {if (x == gridX && y == gridY) {colour = hoverCellColour;} else if (manhattanDistance(x, y, gridX, gridY) <= radius) {if (colour == exclusionColour) {colour = overlapColour;} else if (colour != itemColour) {colour = zoneColour;}}}ctx.fillStyle = colour;ctx.fillRect(gridX * cellSize + 1, gridY * cellSize + 1, cellSize - 1, cellSize - 1);}}}function manhattanDistance(a, b, c, d) {horizontal = Math.min(Math.abs((gridWidth + c - a) % gridWidth), Math.abs((gridWidth + a - c) % gridWidth));vertical = Math.min(Math.abs((gridHeight + d - b) % gridHeight), Math.abs((gridHeight + b - d) % gridHeight));return vertical + horizontal;}function placeItem(event) {bound = canvas.getBoundingClientRect();canvasX = event.clientX - bound.left;canvasY = event.clientY - bound.top;attemptX = Math.min(Math.floor(canvasX / cellSize), gridWidth-1);attemptY = Math.min(Math.floor(canvasY / cellSize), gridHeight-1);colour = cells[attemptX + gridWidth * attemptY];if (colour != itemColour && colour != exclusionColour) {for (a=0; a<gridWidth; a++) {for (b=0; b<gridHeight; b++) {if (manhattanDistance(a, b, attemptX, attemptY) <= radius) {cells[a + gridWidth * b] = exclusionColour;}}}cells[attemptX + gridWidth * attemptY] = itemColour;drawGrid();numberOfItems++;itemCount.value = numberOfItems + ' items placed.';}}

<canvas id='gridCanvas' width='500' height='300' style='border:none' onmousemove='checkPosition(event)' onmouseleave='leaveCanvas()' onclick='placeItem(event)'></canvas><br><textarea id='itemCount' readonly></textarea><br><button id='reset' onclick='resetGrid()'>Reset</button> with the following values:<br>Width:<input id='width' type='number' value='20' min='1' max='50' maxlength='2' step='1'><br>Height:<input id='height' type='number' value='13' min='1' max='30' maxlength='2' step='1'><br>Radius:<input id='radius' type='number' value='5' min='0' max='60' maxlength='2' step='1'>

Приклад (необолочений) розчин

Просто приклад для невеликих виходів (в результаті радіус не набагато менший за ширину та висоту). Може працювати з будь-яким із тестових випадків, але час вичерпається та відмовиться від більшості великих випадків.

itemCount = document.getElementById('itemCount')
calculateButton = document.getElementById('calculate')
widthSelector = document.getElementById('width')
heightSelector = document.getElementById('height')
radiusSelector = document.getElementById('radius')

function calculate() {
    calculateButton.disabled = true
    widthSelector.disabled = true
    heightSelector.disabled = true
    radiusSelector.disabled = true
    itemCount.value = 'Calculating...'
    setTimeout(delayedCalculate, 100)
}

function delayedCalculate() {
    gridWidth = widthSelector.value
    gridHeight = heightSelector.value
    radius = radiusSelector.value
    startingMin = gridWidth*gridHeight + 1
    var cells = [gridWidth * gridHeight]
    for (i=0; i<gridWidth*gridHeight; i++) {
        cells[i] = 0
    }
    var gridState = gridWithItemAdded(cells, 0, 0)
    var minimum = minFromHere(gridState) + 1
    itemCount.value = 'Minimum ' + minimum + ' items required.'
    calculateButton.disabled = false
    widthSelector.disabled = false
    heightSelector.disabled = false
    radiusSelector.disabled = false
}

function minFromHere(gridState) {
    var x
    var y
    var newGridState
    var noCells = true
    var min = startingMin
    for (x=0; x<gridWidth; x++) {
        for (y=0; y<gridHeight; y++) {
            if (gridState[x + gridWidth * y] == 0) {
                noCells = false
                newGridState = gridWithItemAdded(gridState, x, y)
                m = minFromHere(newGridState)
                if (m < min) {
                    min = m
                }
            }
        }
    }
    if (noCells) return 0
    return min + 1
}

function gridWithItemAdded(gridState, x, y) {
    var a
    var b
    var grid = gridState.slice()
    for (a=0; a<gridWidth; a++) {
        for (b=0; b<gridHeight; b++) {
            if (manhattanDistance(a, b, x, y) <= radius) {
                grid[a + gridWidth * b] = 1
            }
        }
    }    
    return grid
}

function manhattanDistance(a, b, c, d) {
    horizontal = Math.min(Math.abs((gridWidth + c - a) % gridWidth), Math.abs((gridWidth + a - c) % gridWidth))
    vertical = Math.min(Math.abs((gridHeight + d - b) % gridHeight), Math.abs((gridHeight + b - d) % gridHeight))
    return vertical + horizontal
}

<textarea id='itemCount' readonly></textarea>
<br>
<button id='calculate' onclick='calculate()'>Calculate</button> with the following values:
<br>
Width:<input id='width' type='number' value='5' min='1' max='50' maxlength='2' step='1'>
<br>
Height:<input id='height' type='number' value='4' min='1' max='30' maxlength='2' step='1'>
<br>
Radius:<input id='radius' type='number' value='1' min='0' max='60' maxlength='2' step='1'>

Python 2, 216 182 байт

def f(W,H,R):L={(i%W,i/W)for i in range(W*H)};M={(x,y)for x,y in L if min(x,W-x)+min(y,H-y)>R};g=lambda s:min([1+g(s-{((a+x)%W,(b+y)%H)for x,y in L-M})for a,b in s]or[1]);return g(M)

Вхід як f(16,16,8). Використовує такий же алгоритм, як і зразок @ trichoplax , але з наборами. Спочатку я не розміщував перший предмет (0, 0), але це змусило задихнутися в останніх кількох випадках.

Усі вищезазначені справи закінчуються протягом 10 секунд, що знаходиться під обмеженням. Насправді випадки досить малі, що у мене було мало місця, щоб бути менш ефективним, що дозволило мені зняти чек, який перевіряв на наявність дублікатів станів.

(Дякуємо @trichoplax за допомогу в гольфі)

Розширено:

def f(W,H,R):
  # All cells
  L={(i%W,i/W)for i in range(W*H)}                 

  # Mask: Complement of exclusion zone around (0, 0) 
  M={(x,y)for x,y in L if min(x,W-x)+min(y,H-y)>R}

  # Place recursively
  g=lambda s:min([1+g(s-{((a+x)%W,(b+y)%H)for x,y in L-M})for a,b in s]or[1])
  return g(M)

Пітон 3, 270 262 260 251 246 226

(Завдяки Sp3000 за:

• -~ замість цього +1 , що дозволяє мені втратити пробіл після return останнього рядка.
• втрачаючи зайві дужки навколо W*H .
• лямбда ...
• ставлячи все в одну лінію.
• модуль python %дає позитивний результат для негативних чисел, щоб зберегти ще 20 байт)

Це відповідь на приклад JavaScript у запитанні, яке було подано на Python 3.

Щоб уникнути необхідності передавати стільки аргументів функції, я перемістив дві підтримуючі функції всередині функції обчислення, щоб вони поділили її сферу застосування. Я також конденсував кожну з цих функцій в один рядок, щоб уникнути витрат на відступ.

Пояснення

Цей досить жорстокий підхід ставить перший елемент у (0, 0), а потім позначає всі виключені квадрати. Потім рекурсивно розміщує елемент на всіх реальних квадратиках, поки всі квадрати не виключені, і повертає необхідну мінімальну кількість елементів.

Код для гольфу:

def C(W,H,R):r=range;M=lambda g:min([M(G(g,x,y))for x in r(W)for y in r(H)if g[x+W*y]]or[-1])+1;G=lambda g,x,y:[g[a+W*b]if min((x-a)%W,(a-x)%W)+min((y-b)%H,(b-y)%H)>R else 0for b in r(H)for a in r(W)];return-~M(G([1]*W*H,0,0))

Невикористаний код:

def calculate(W, H, R):
    starting_min = W * H + 1
    cells = [0] * (W * H)
    grid_state = grid_with_item_added(cells, 0, 0, W, H, R)
    return min_from_here(grid_state, starting_min, W, H, R) + 1

def min_from_here(grid_state, starting_min, W, H, R):
    no_cells = True
    min = starting_min
    for x in range(W):
        for y in range(H):
            if grid_state[x + W * y] == 0:
                no_cells = False
                new_grid_state = grid_with_item_added(grid_state, x, y, W, H, R)
                m = min_from_here(new_grid_state, starting_min, W, H, R)
                if m < min:
                    min = m

    if no_cells:
        return 0
    else:
        return min + 1

def grid_with_item_added(grid_state, x, y, W, H, R):
    grid = grid_state[:]
    for a in range(W):
        for b in range(H):
            if manhattan_distance(a, b, x, y, W, H) <= R:
                grid[a + W * b] = 1

    return grid

def manhattan_distance(a, b, c, d, W, H):
    horizontal = min(abs(W + c - a) % W, abs(W + a - c) % W)
    vertical = min(abs(H + d - b) % H, abs(H + b - d) % H)
    return horizontal + vertical


if __name__ == '__main__':
    import sys
    arguments = sys.argv[1:]
    if len(arguments) < 3:
        print('3 arguments required: width, height and radius')
    else:
        print(calculate(int(arguments[0]), int(arguments[1]), int(arguments[2])))

Невикольований код визначає функцію, а також включає код, щоб дозволити її викликати з командного рядка. Код для гольфу просто визначає функцію, якої достатньо для стандартних питань гольфу з кодом .

Якщо ви хочете перевірити код golfed з командного рядка, ось він включає в себе обробку командного рядка (але не гольф):

Код командного рядка, який можна перевірити для гольфу

def C(W,H,R):r=range;M=lambda g:min([M(G(g,x,y))for x in r(W)for y in r(H)if g[x+W*y]]or[-1])+1;G=lambda g,x,y:[g[a+W*b]if min((x-a)%W,(a-x)%W)+min((y-b)%H,(b-y)%H)>R else 0for b in r(H)for a in r(W)];return-~M(G([1]*W*H,0,0))

if __name__ == '__main__':
    import sys
    arguments = sys.argv[1:]
    if len(arguments) < 3:
        print('3 arguments required: width, height and radius')
    else:
        print(C(int(arguments[0]), int(arguments[1]), int(arguments[2])))