за избора на индекси и аз си го мислех. Според мен не може да стане без рекурсии.
обяснявам защо:

0    0    0    0     K    0    0    0    0

0    0    0    0     0    0    0    0    0

0    0    0    0     0    K    0    0    0

0    0    0    0     0    0    0    0    0 

K    0    0    0     K    0    0    0    K

0    0    K    0     0    0    K    0    0

При използването на индексиЗаОпасност кодът ще махне рицаря на ред  с индекс за ред: 4-ри и индекс за колона: 4. Неговият индексЗаОпасност е 3-ри. Така обаче ще останат три двойки рицари под взаимен удар. Тоест общият брой махнати рицари трябва да 1 + 3 = 4-ри рицаря.

В действителност трябва да се махнат рицарите, които са посочени с черта под линия. Така ще останат трите рицария по краищата и рицарят в средата. Общият брой махнати рицари при втория вариант ще е само три. 
Този втори вариант обаче изисква логика не по събиране на индексиЗаОпасност, а преглеждане на всички възможни пермутации (с изрязване на вариантите, в които рекурсията води до махане на повече коне от досегашен изчислен вариант).

Опитах се да потърся още някои игри, свързани с тази тема.

По темата за безплатните игри, потребителите, които се интересуват от версията за отключване на играта 2021, вижте among us mod apk

Колега заповядаи моето решение дано ти е полезно да схванеш задачата .

https://pastebin.com/n1Lvc7mp

100/100

Здравейте,

След доста мъдрене, измъдрих следното:

за всяко К има максимум 8 позиции, които може да "удари", тоест 8 позиици, които трябва да се проверят и резултата да се сравни с останалите, за да се премахне това К с максимален резултат. Това нещо в цикъл до 0 удара решава проблема с минималния брой, тъй като премахваме един вид в Descending order.

А, тъй като около всяко К  се проверява на 2 елемента разстояние, за да си спестя описване на крайни случаи, просто правя матрицата по-голяма с 2 нулеви клетки от всяка страна (2 реда отгоре, 2 реда отдолу, 2 колони отляво, 2 колони отдясно). По този начин 1 метод, който проверява 8те възможни ударни точки, върши работа за всички позиции в зададената матрица, без Out of range exeption.

Ето и кода, за мазохистите:

https://pastebin.com/tU29hxCg

Привет. Предлагам и моето решение, макар на Python, логиката може лесно да се проследи.

1. Намирам "най-силния" кон, тоест този, който достъпва най-много други коне.

2. Отстранявам най-силния кон, като замествам "К" с "0"

3. Проверявам отново за "най-силен" кон или въобще за кон, който достига поне до 1 друг. Ако няма играта свършва.

n = int(input())
matrix = []

for _ in range(n):
    matrix.append(list(input()))


def look_around(k, matrix):
    power = 0
    # Right down:
    if 0 <= (k[1] + 2) < n and 0 <= (k[0] + 1) < n:
        right_d = (k[0] + 1, k[1] + 2)
        if matrix[right_d[0]][right_d[1]] == 'K':
            power += 1
    # Right up:
    if 0 <= (k[1] + 2) < n and 0 <= (k[0] - 1) < n:
        right_u = (k[0] - 1, k[1] + 2)
        if matrix[right_u[0]][right_u[1]] == 'K':
            power += 1
    # Left down:
    if 0 <= (k[1] - 2) < n and 0 <= (k[0] + 1) < n:
        left_d = (k[0] + 1, k[1] - 2)
        if matrix[left_d[0]][left_d[1]] == 'K':
            power += 1
    # Left up:
    if 0 <= (k[1] - 2) < n and 0 <= (k[0] - 1) < n:
        left_u = (k[0] - 1, k[1] - 2)
        if matrix[left_u[0]][left_u[1]] == 'K':
            power += 1
    # Up left:
    if 0 <= (k[0] - 2) < n and 0 <= (k[1] - 1) < n:
        up_l = (k[0] - 2, k[1] - 1)
        if matrix[up_l[0]][up_l[1]] == 'K':
            power += 1
    # Up right:
    if 0 <= (k[0] - 2) < n and 0 <= (k[1] + 1) < n:
        up_r = (k[0] - 2, k[1] + 1)
        if matrix[up_r[0]][up_r[1]] == 'K':
            power += 1
    # Down left:
    if 0 <= (k[0] + 2) < n and 0 <= (k[1] - 1) < n:
        down_l = (k[0] + 2, k[1] - 1)
        if matrix[down_l[0]][down_l[1]] == 'K':
            power += 1
    # Down right:
    if 0 <= (k[0] + 2) < n and 0 <= (k[1] + 1) < n:
        down_r = (k[0] + 2, k[1] + 1)
        if matrix[down_r[0]][down_r[1]] == 'K':
            power += 1

    return power



def get_knights():
    strongest = (0, 0, 0)
    for r in range(n):
        for c in range(n):
            if matrix[r][c] == 'K':
                klock = (r, c)
                power = look_around(klock, matrix)
                if power > 0 and power > strongest[2]:
                    strongest = (r, c, power)

    return strongest


knights = get_knights()
count = 0

while not knights[2] == 0:
    r, c = knights[0], knights[1]
    matrix[r][c] = '0'
    knights = get_knights()
    count += 1

print(count)

Решение с 1 jagged array и 1 матрица която копира клетките на jagged array-я и според проверките пази бройките на конника с най-много възможни атаки, за да можем да го махнем и се върти докато няма възможни атаки

https://pastebin.com/EqeTgfzG

Постът ми е малко закъснял, но бих желал да предложа решение на Python без използването на функции https://pastebin.com/hK86eJCU.

Поздрави !

Здравей, колега. Ще опитам да разясня логиката на задачата, като използвам първия примерен вход:

0 K 0 K 0

K 0 0 0 K

0 0 K 0 0

K 0 0 0 K

0 K 0 K 0

Първо за хората, които не играят шах, нека да разясним движението на коня - всеки кон се движи на буква Г. При конкретния input единствения кон (knight), който може да извърши ход във всяка една посока без да излезе от дъската е коня в средата (на червения фон) - това са 8 възможни хода във всички посоки (допълнително описание на посоките в link с решението от GitHub, който ще откриете в края на коментара). Както червения кон може да атакува всеки един от сините, така и всеки от сините може да атакува червения, но в условието се иска да се премахнат възможно най-малко коне от дъската, така че всеки кон да не е в състояние да атакува някой от другите в случай, че смени позицията си. Следователно ако решим да премахнем някой от сините коне всички останли все още могат да атакуват червения кон и е необходимо да вадим още фигури. В такъв случай трябва да започнем да вадим първо от фигурите, които имат най-голям потенциал да атакуват. До тук по условието, а сега нека да видим алгоритъма, който съм използвал, за да реша задачата.

Задачата е решена единствено с матрица, 3 вложени for цикъла и if проверки:
1. За представянето на шахматната дъска с фигурите съм използвал матрица. Създаваме я с размерите от входа и попълваме позициите с подадения вход, както се запълват матрици.

2. Най-външният цикъл е низходящ от (i = 8; i > 0; i--), където i всъщност е максималния брой застрашени коне, които може да атакува всяка една фигура в случай, че на всяка една от новите позиции има друг кон (всички нови позиции са заети от друга фигура), а на всяка следваща итерация има с по една незаета позиция.
3. Останалите два вложени цикъла са за обхождане на всеки един индекс от матрицата - board[row, column].
4. Проверка дали на конкретния индекс има фигура. Ако няма - преминаваме към следващия индекс докато стигнем до позиция, където разполагаме с фигура, която да местим по дъската.

5. Като достигнем до индекс, на който има фигура изчисляваме индекса на всяка една нова позиция от възможните максимум 8 хода. Не всяка фигура може да извърши всички ходове без да излезе от дъската, следователно е необходимо в тази проверка да направим проверка дали новия индекс не е извън рамките на матрицата ако не искаме да изгърми с IndexOutOfRangeException. За всеки един нов индекс, който е в рамките на матрицата проверяваме дали на него има кон, който да бъде атакуван. Използвам променлива от тип int за брояч, който отчита на колко от новите позиции има кон.
6. Преди да премина към следващата позиция от шахматната дъска проверявам дали брояча е равен на i от най-външния цикъл, т.е. коня е в състояние да атакува максималния възможен брой други фигури за конкретната итерация. Ако условието е изпълнено премахвам коня (променям стойността от К на '0'), с което приключва пълния цикъл от проверката. Естествено използвам и втора променлива от тип int, която пази броя на извадените фигури.

В случая с примерния input за всеки от сините коне при първото обхождане на дъската, брояча ще е равен на 1, тъй като при всеки от възможните им ходове в рамките на дъската могат да атакуват единствено червения кон. За червения кон обаче брояча е равен на 8. Следователно при първата итерация на най-външния цикъл ще се махне червения кон в центъра. При второто и всяко следващо обхождане брояча, който следи на колко от новите позиции има друг кон ще бъде равен на 0, което не изпълнява условията от проверките описани на т. 5 и т. 6. Така не се стига до премахване на други коне. След края на трите вложени цикъла просто се изпринтва на конзолата стойността в брояча, която следи извадения брой коне.

Линк към решението със C# (100/100 в Judge) с коментари коя част от кода точно за кое отговаря:
http://github.com/DDianovMD/SoftUni/blob/main/CSharpAdvanced/MultidimensionalArraysExercise/KnightGame/Program.cs

Успех!