Python中的地图颜色算法

Question

I have a 2D array in Python (version 3.2) that looks like this:

...AAA....
...AAABB..
..BBBBBCC.
.....CCCC.
.DDD..CC..
.DDD......

It represents a kind of map with areas painted different colors. The above example shows four distinct regions, A, B, C, and D.

Here's an example of indexing the array: map[1][5] == 'A' would return True.

I'm trying to write a function that takes in an array like this, and a row/col index, and returns the number of adjoining spaces that are of the same "color". So using that example above, here are some return values (the arguments are the array, row, and column number respectively:

6 <-- countArea(map, 5, 2)
8 <-- countArea(map, 2, 8)

I'd like to implement this as a recursive function, but I can't figure it out. Here's what I have so far:

def countArea(map, row, col):

    key = map[row][col]

    if (map[row-1][col] == key):
        return 1 + countArea(map, row-1, col)
    elif (map[row+1][col] == key):
        return 1 + countArea(map, row+1, col)
    elif (map[row][col+1] == key):
        return 1 + countArea(map, row, col+1)
    elif (map[row][col-1] == key):
        return 1 + countArea(map, row, col-1)
    else:
        return 1

I know I'm missing something basic here. I'm basically saying "here is the current character, now look in each direction to see if it has the same character."

My question is, what am I missing in this recursive definition?

Thanks for your help.

Answer 1

My question is, what am I missing in this recursive definition?

Once a grid square has been counted, it must not be counted again (this includes counting by recursive invocations of countArea() !)

Your current algorithm goes as far north as it can, and then keeps taking one step to the south followed by one step to the north. This two-step sequence repeats until you run out of stack space.

If you like, you could read up on algorithms for this problem in Wikipedia .

Answer 2

In your code the algorithm would look one field left of a given input field and in the recursive call would again call the function on the initial field. (What you obviously don't want since it would lead to an infinite recursion)

Approach 1

A method to overcome this problem while still using recursion would be to specify a direction where the recursion should look for more fields of the same type. For example the call to the field directly north (or above ) of the initial one could look recursively farer to the north or east (or right ), the one to the east go south ( below ) and east and so on.

By intelligently choosing the first step you can ensure, that there is no overlap in the scanned regions. However it needs some adaptions to specify the directions the recursive call should scan. BUT: Note that this algorithm would not work if the area is overhanging so if not every field northeast of the starting point can be reached by just moving right and up.

There exist more algorithms like this that are also capable to solve the the mentioned problem. Have a look at Flood Filling on wikipedia .

Approach 2

You can also save the already visited fields in some way and directly return from the recursive call if the field was already visited.

Answer 3

The following implementation should work:

def countArea(map, row, col, key=None, seen=None):
    if key is None:
        key = map[row][col]
    if seen is None:
        seen = set()
    seen.add((row, col))  # mark this location as visited
    n = 1
    for dy, dx in [(0, 1), (1, 0), (-1, 0), (0, -1)]:
         r, c = row + dy, col + dx
         if r < 0 or r >= len(map) or c < 0 or c >= len(map[0]):  # check boundaries
             continue
         # only increment and recurse if key matches and we haven't already visited
         if map[r][c] == key and (r, c) not in seen:
             n += countArea(map, r, c, key, seen)
    return n

Example:

>>> print '\n'.join(''.join(row) for row in map)
...AAA....
...AAABB..
..BBBBBCC.
.....CCCC.
.DDD..CC..
.DDD......
>>> countArea(map, 5, 2)
6
>>> countArea(map, 2, 8)
8

Note that this assumes that areas with the same key that are only touching at a diagonal should be considered separate, for example for the following map countArea(map, 0, 0) and countArea(map, 1, 1) would both return 1:

A.
.A

As a side note, you should not use map as a variable name, as it will mask the builtin map() function.