# -*- coding: utf-8 -*-
import copy
from collections import defaultdict
from itertools import product
import heapq
FALL = '|'
RIVER = '~'
POOL = 'N'
SOURCE = 'x'
SOURCE_AND_FALL = '*'
SOURCE_AND_RIVER = 'X'
SOURCE_AND_POOL = '%'
BLOCK = '#'
LRAMP = '/'
RRAMP = '\\'
SPACE = ' '
LRAMP_AND_FALL = 'd'
RRAMP_AND_FALL = 'b'
LRAMP_AND_RIVER = '}'
RRAMP_AND_RIVER = '{'
LRAMP_AND_POOL = ']'
RRAMP_AND_POOL = '['
DOWN = (1,0)
LEFT = (0,-1)
RIGHT = (0,1)
UP = (-1,0)
ORDINALS = [DOWN,LEFT,RIGHT,UP]
gridStr = """\
x
# #
# #
# #
#### #####
#### #####
#### #####
##########"""
gridStr = """\
x
# /
#####
# #
# # /
###\/#"""
gridStr = """\
x
# /
#####"""
gridStr = """\
x
# # #
# # #
# # #
# # #
# # #
#######################"""
gridStr = """\
x #
# # #
# # #
# # #
# #
######"""
# The capacity of a ramp cell.
HALF_CAPACITY = 50
# The capacity of an empty cell.
MAX_CAPACITY = 2*HALF_CAPACITY
# The rate of flow in from a source.
SOURCE_RATE = HALF_CAPACITY
# The maximum rate of flow between two cells.
MAX_FLOW = MAX_CAPACITY
SPACE_THRESHHOLD = HALF_CAPACITY / 2
RIVER_THRESHHOLD = HALF_CAPACITY + HALF_CAPACITY / 2
def isSource(cell):
return cell in [SOURCE, SOURCE_AND_FALL, SOURCE_AND_RIVER, SOURCE_AND_POOL]
def isLRamp(cell):
return cell in [LRAMP, LRAMP_AND_FALL, LRAMP_AND_RIVER, LRAMP_AND_POOL]
def isRRamp(cell):
return cell in [RRAMP, RRAMP_AND_FALL, RRAMP_AND_RIVER, RRAMP_AND_POOL]
def isRamp(cell):
return isLRamp(cell) or isRRamp(cell)
def findBackground(cell):
if cell in [SPACE, FALL, RIVER, POOL, SOURCE]:
return SPACE
elif cell in [BLOCK]:
return BLOCK
elif isLRamp(cell):
return LRAMP
elif isRRamp(cell):
return RRAMP
raise Exception
class WaterType:
FALL = 1
SETTLED = 2
class Cell:
def __init__(self, background, isSource):
self.background = background
self.isSource = isSource
self.water = 0
self.waterType = WaterType.FALL
def getCapacity(self):
return (0 if self.background == BLOCK else (HALF_CAPACITY if isRamp(self.background) else MAX_CAPACITY))
def copyCell(self, cell):
self.background = cell.background
self.isSource = cell.isSource
# Include any water already here
self.water += cell.water
self.waterType = cell.waterType
def updateType(self, cellBelow):
if self.water == 0:
self.waterType = WaterType.SETTLED
elif self.water == self.getCapacity():
# If a completely saturated block of water is falling it should still look full.
self.waterType = WaterType.SETTLED
elif cellBelow.water < cellBelow.getCapacity():
self.waterType = WaterType.FALL
else:
self.waterType = WaterType.SETTLED
def __str__(self):
if self.background == SPACE and not self.isSource and self.water <= SPACE_THRESHHOLD:
return SPACE
elif self.background == SPACE and not self.isSource and self.waterType == WaterType.FALL:
return FALL
elif self.background == SPACE and not self.isSource and self.water <= RIVER_THRESHHOLD:
return RIVER
elif self.background == SPACE and not self.isSource:
return POOL
elif self.background == SPACE and self.water <= SPACE_THRESHHOLD:
return SOURCE
elif self.background == SPACE and self.waterType == WaterType.FALL:
return SOURCE_AND_FALL
elif self.background == SPACE and self.water <= RIVER_THRESHHOLD:
return SOURCE_AND_RIVER
elif self.background == SPACE:
return SOURCE_AND_POOL
elif self.background == BLOCK:
return BLOCK
elif isRamp(self.background) and self.isSource:
raise Exception
elif self.background == LRAMP and self.water <= SPACE_THRESHHOLD / 2:
return LRAMP
elif self.background == LRAMP and self.waterType == WaterType.FALL:
return LRAMP_AND_FALL
elif self.background == LRAMP and self.water <= RIVER_THRESHHOLD / 2:
return LRAMP_AND_RIVER
elif self.background == LRAMP:
return LRAMP_AND_POOL
elif self.water <= SPACE_THRESHHOLD / 2:
return RRAMP
elif self.waterType == WaterType.FALL:
return RRAMP_AND_FALL
elif self.water <= RIVER_THRESHHOLD / 2:
return RRAMP_AND_RIVER
else:
return RRAMP_AND_POOL
gridCells = map(lambda x: list(x), gridStr.split('\n'))
height = len(gridCells)
width = len(gridCells[0])
grid = defaultdict(lambda : Cell(SPACE, False))
for i in range(height):
for j in range(width):
grid[i,j] = Cell(findBackground(gridCells[i][j]), isSource(gridCells[i][j]))
def p(coords, offset):
"""Add two tuples together.
>>> p((2, 3), (-1, 0))
(1, 3)
"""
return tuple(map(sum, zip(coords, offset)))
def adjacent(i,j,includeUp):
ret = []
for offset in (ORDINALS if includeUp else ORDINALS[:-1]):
ret.append(p((i,j), offset))
return ret
CONNECTION_TO_SHAPES = {DOWN: [SPACE, LRAMP, RRAMP], LEFT: [SPACE, RRAMP], RIGHT: [SPACE, LRAMP], UP: [SPACE]}
def adjoint(grid, i, j, includeUp, includeDown):
"""Find all cells connected to this one (if this is a block then nothing connects to it).
>>> grid = defaultdict(lambda : Cell(SPACE, False))
>>> adjoint(grid, 10, 1, True, True)
[(11, 1), (10, 0), (10, 2), (9, 1)]
>>> adjoint(grid, 10, 1, False, True)
[(11, 1), (10, 0), (10, 2)]
>>> adjoint(grid, 10, 1, False, False)
[(10, 0), (10, 2)]
>>> grid[10, 1].background = LRAMP
>>> adjoint(grid, 10, 1, True, True)
[(10, 0), (9, 1)]
>>> grid[10, 0].background = LRAMP
>>> grid[9, 1].background = RRAMP
>>> adjoint(grid, 10, 1, True, True)
[]
"""
ret = []
cell = grid[i, j]
if cell.background == BLOCK:
adj = []
elif cell.background == LRAMP:
adj = [LEFT, UP]
elif cell.background == RRAMP:
adj = [RIGHT, UP]
elif cell.background == SPACE:
adj = list(ORDINALS)
if not includeUp and UP in adj:
adj.remove(UP)
if not includeDown and DOWN in adj:
adj.remove(DOWN)
for offset in adj:
neighbourCoords = p((i,j), offset)
neighbour = grid[neighbourCoords]
if neighbour.background in CONNECTION_TO_SHAPES[offset]:
ret.append(neighbourCoords)
return ret
def distance(loc1, loc2):
"""Calculate the manhatten distance between two locations.
>>> distance((5,2), (3, 1))
3
"""
row1, col1 = loc1
row2, col2 = loc2
d_col = abs(col1 - col2)
d_row = abs(row1 - row2)
return d_row + d_col
def aStarRegion(start, end, region, edge):
"""The AStar algorithm to find the shortest path between two cells using the region as the nodes, and the edges in edge.
>>> grid = defaultdict(lambda : Cell(SPACE, False))
>>> edge = defaultdict(dict)
>>> edge[1,0] = {(1,1): 1}
>>> edge[1,1] = {(2,1): 1}
>>> aStarRegion((1,0), (2,1), [(1,0),(1,1),(2,1)], edge)
[(1, 0), (1, 1), (2, 1)]
"""
openSet = set()
openHeap = []
closedSet = set()
parent = {}
def retracePath(c, edge):
path = [c]
while c in parent:
c = parent[c]
path.append(c)
path.reverse()
return path
current = start
openSet.add(current)
openHeap.append((0,current))
while openSet:
current = heapq.heappop(openHeap)[1]
if current == end:
return retracePath(current, edge)
openSet.remove(current)
closedSet.add(current)
for tile, remainingFlow in edge[current].items():
if tile not in closedSet:
H = distance(tile, end)*10
if tile not in openSet:
openSet.add(tile)
heapq.heappush(openHeap, (H,tile))
parent[tile] = current
return []
def findWaterRegions(grid, height, width):
"""Find water regions. Return a dict keyed on the top left (top then left) cell of each region.
>>> grid = defaultdict(lambda : Cell(SPACE, False))
>>> waterRegions, outlets, edges = findWaterRegions(grid, 4, 5)
>>> waterRegions
{}
>>> outlets
{}
>>> dict(edges)
{}
>>> grid[2,2].water = MAX_CAPACITY
>>> grid[2,3].water = MAX_CAPACITY
>>> grid[3,3].water = MAX_CAPACITY
>>> waterRegions, outlets, edges = findWaterRegions(grid, 4, 5)
>>> waterRegions
{(2, 2): [(2, 2), (2, 3), (3, 3)]}
>>> outlets
{(2, 2): [(3, 2), (2, 1), (1, 2), (2, 4), (1, 3), (4, 3), (3, 2), (3, 4)]}
>>> dict(edges)
{(2, 2): defaultdict(<type 'dict'>, {(2, 3): {(2, 4): 100, (1, 3): 100, (3, 3): 100, (2, 2): 100}, (3, 3): {(2, 3): 100, (3, 2): 100, (3, 4): 100, (4, 3): 100}, (2, 2): {(1, 2): 100, (3, 2): 100, (2, 3): 100, (2, 1): 100}})}
>>> grid[2,3].background = LRAMP
>>> grid[2,3].water = HALF_CAPACITY
>>> waterRegions, outlets, edges = findWaterRegions(grid, 4, 5)
>>> waterRegions
{(3, 3): [(3, 3)], (2, 2): [(2, 2), (2, 3)]}
>>> outlets
{(3, 3): [(4, 3), (3, 2), (3, 4)], (2, 2): [(3, 2), (2, 1), (1, 2), (1, 3)]}
>>> dict(edges)
{(3, 3): defaultdict(<type 'dict'>, {(3, 3): {(3, 2): 100, (3, 4): 100, (4, 3): 100}}), (2, 2): defaultdict(<type 'dict'>, {(2, 3): {(1, 3): 100, (2, 2): 100}, (2, 2): {(1, 2): 100, (3, 2): 100, (2, 3): 100, (2, 1): 100}})}
>>> grid = defaultdict(lambda : Cell(SPACE, False))
>>> grid[2,3].background = LRAMP
>>> grid[2,3].water = HALF_CAPACITY - 1
>>> waterRegions, outlets, edges = findWaterRegions(grid, 4, 5)
>>> waterRegions
{(2, 3): [(2, 3)]}
>>> outlets
{(2, 3): [(2, 3), (2, 2)]}
>>> dict(edges)
{(2, 3): defaultdict(<type 'dict'>, {(2, 3): {(2, 2): 100}})}
>>> grid = defaultdict(lambda : Cell(SPACE, False))
>>> grid[1,0].background = BLOCK
>>> grid[1,4].background = BLOCK
>>> grid[2,0].background = BLOCK
>>> grid[2,4].background = BLOCK
>>> grid[3,1].background = RRAMP
>>> grid[4,2].background = BLOCK
>>> grid[2,2].background = BLOCK
>>> grid[3,3].background = LRAMP
>>> grid[3,1].water = HALF_CAPACITY
>>> grid[3,2].water = MAX_CAPACITY
>>> grid[3,3].water = HALF_CAPACITY
>>> waterRegions, outlets, edges = findWaterRegions(grid, 4, 5)
>>> waterRegions
{(3, 1): [(3, 1), (3, 2), (3, 3)]}
>>> outlets
{(3, 1): [(2, 1), (2, 3)]}
>>> dict(edges)
{(3, 1): defaultdict(<type 'dict'>, {(3, 2): {(3, 1): 100, (3, 3): 100}, (3, 1): {(3, 2): 100, (2, 1): 100}, (3, 3): {(3, 2): 100, (2, 3): 100}})}
>>> grid = defaultdict(lambda : Cell(SPACE, False))
>>> grid[0,0].water = MAX_CAPACITY - 1
>>> grid[1,0].water = MAX_CAPACITY - 1
>>> waterRegions, outlets, edges = findWaterRegions(grid, 4, 5)
>>> waterRegions
{(1, 0): [(1, 0)], (0, 0): [(0, 0)]}
>>> outlets
{(1, 0): [(1, 0), (2, 0), (1, -1), (1, 1)], (0, 0): [(0, 0), (1, 0), (0, -1), (0, 1)]}
>>> dict(edges)
{(1, 0): defaultdict(<type 'dict'>, {(1, 0): {(2, 0): 100, (1, -1): 100, (1, 1): 100}}), (0, 0): defaultdict(<type 'dict'>, {(0, 0): {(0, 1): 100, (0, -1): 100, (1, 0): 100}})}
"""
waterRegions = {}
outlets = {}
edges = defaultdict(lambda : defaultdict(dict))
explored = []
for i, j in product(range(height), range(width)):
if (i,j) not in explored:
cell = grid[i,j]
if cell.water > 0:
waterRegions[i,j] = [(i,j)]
outlets[i,j] = ([] if grid[i,j].water == grid[i,j].getCapacity() else [(i,j)])
toExplore = [(i,j)]
while len(toExplore) > 0:
hereX, hereY = toExplore.pop()
explored.append((hereX, hereY))
includeUp = (grid[hereX,hereY].water == grid[hereX,hereY].getCapacity())
includeDown = (grid[hereX+1,hereY].water == grid[hereX+1,hereY].getCapacity())
for x, y in adjoint(grid, hereX, hereY, includeUp, includeDown):
if grid[x,y].water != 0 and (x,y) not in explored:
toExplore.append((x,y))
waterRegions[i,j].append((x,y))
for x, y in adjoint(grid, hereX, hereY, includeUp, True):
edges[i,j][hereX,hereY][x,y] = MAX_FLOW
if grid[x,y].water != grid[x,y].getCapacity():
outlets[i,j].append((x,y))
return waterRegions, outlets, edges
def findHeight(grid, point):
return (height - point[0]) * MAX_CAPACITY + grid[point].water
def findHighestPoint(grid, region):
highestPoint = region[0]
highestHeight = findHeight(grid, highestPoint)
for point in region:
height = findHeight(grid, point)
if height > highestHeight:
highestHeight = height
highestPoint = point
return highestPoint
def findLowestPoint(grid, region):
lowestPoint = region[0]
lowestHeight = findHeight(grid, lowestPoint)
for point in region:
height = findHeight(grid, point)
if height < lowestHeight:
lowestHeight = height
lowestPoint = point
return lowestPoint
def moveWater(grid, start, end, region, edge):
"""Move a unit of water from start to end. Return True if successful."""
path = aStarRegion(start, end, region, edge)
if len(path) == 0:
return False
grid[start].water -= 1
stepStart = start
for stepEnd in path[1:]:
edge[stepStart][stepEnd] -= 1
if edge[stepStart][stepEnd] == 0:
edge[stepStart].pop(stepEnd)
if len(edge[stepStart]) == 0:
edge.pop(stepStart)
stepStart = stepEnd
grid[end].water += 1
return True
def displayGrid(grid):
print
for i in range(height):
row = ''
for j in range(width):
grid[i,j].updateType(grid[i+1,j])
row += str(grid[i,j])
row += ' '
for j in range(width):
row += ('%x'%(grid[i,j].water / 10) if grid[i,j].water < 160 else '+')
print row
def main(grid):
t = 0
while t < 20:
displayGrid(grid)
newGrid = defaultdict(lambda : Cell(SPACE, False))
for i, j in product(range(height), range(width)):
cell = grid[i,j]
newCell = newGrid[i,j]
newCell.copyCell(cell)
if cell.isSource:
newCell.water += SOURCE_RATE
grid = newGrid
waterRegions, outlets, edges = findWaterRegions(grid, height, width)
movedSomething = True
while movedSomething:
movedSomething = False
for regionKey in waterRegions.keys():
waterRegion = waterRegions[regionKey]
outlet = outlets[regionKey]
edge = edges[regionKey]
start = findHighestPoint(grid, waterRegion)
end = findLowestPoint(grid, outlet)
if findHeight(grid, start) > findHeight(grid, end):
movedSomething = moveWater(grid, start, end, waterRegion + [end], edge)
if grid[start].water == 0:
waterRegion.remove(start)
if len(waterRegion) == 0:
waterRegions.pop(regionKey)
t += 1
if __name__ == '__main__':
import doctest
# Doesn't test inner functions!
failures, passes = doctest.testmod(raise_on_error=False)
if failures == 0:
main(grid)
else:
print 'Stopping with %d failures'%failures
# -*- coding: utf-8 -*-
import copy
from collections import defaultdict
from itertools import product
import heapq

FALL = '|'
RIVER = '~'
POOL = 'N'
 
SOURCE = 'x'
SOURCE_AND_FALL = '*'
SOURCE_AND_RIVER = 'X'
SOURCE_AND_POOL = '%'
 
BLOCK = '#'
LRAMP = '/'
RRAMP = '\\'
SPACE = ' '
 
LRAMP_AND_FALL = 'd'
RRAMP_AND_FALL = 'b'
LRAMP_AND_RIVER = '}'
RRAMP_AND_RIVER = '{'
LRAMP_AND_POOL = ']'
RRAMP_AND_POOL = '['

DOWN = (1,0)
LEFT = (0,-1)
RIGHT = (0,1)
UP = (-1,0)
ORDINALS = [DOWN,LEFT,RIGHT,UP]

gridStr = """\
   x      
#        #
#        #
#        #
#### #####
#### #####
#### #####
##########"""
gridStr = """\
  x   
#   / 
##### 
#   # 
# #  /
###\/#"""
gridStr = """\
  x  
#  / 
#####"""
gridStr = """\
                    x  
                       
                       
#                   # #
#                   # #
#                   # #
#                   # #
#                   # #
#######################"""
gridStr = """\
 x #  
#  # #
#  # #
#  # #
#    #
######"""

# The capacity of a ramp cell.
HALF_CAPACITY = 50
# The capacity of an empty cell.
MAX_CAPACITY = 2*HALF_CAPACITY
# The rate of flow in from a source.
SOURCE_RATE = HALF_CAPACITY
# The maximum rate of flow between two cells.
MAX_FLOW = MAX_CAPACITY

SPACE_THRESHHOLD = HALF_CAPACITY / 2
RIVER_THRESHHOLD = HALF_CAPACITY + HALF_CAPACITY / 2

def isSource(cell):
    return cell in [SOURCE, SOURCE_AND_FALL, SOURCE_AND_RIVER, SOURCE_AND_POOL]

def isLRamp(cell):
    return cell in [LRAMP, LRAMP_AND_FALL, LRAMP_AND_RIVER, LRAMP_AND_POOL]
def isRRamp(cell):
    return cell in [RRAMP, RRAMP_AND_FALL, RRAMP_AND_RIVER, RRAMP_AND_POOL]
def isRamp(cell):
    return isLRamp(cell) or isRRamp(cell)

def findBackground(cell):
    if cell in [SPACE, FALL, RIVER, POOL, SOURCE]:
        return SPACE
    elif cell in [BLOCK]:
        return BLOCK
    elif isLRamp(cell):
        return LRAMP
    elif isRRamp(cell):
        return RRAMP
    raise Exception

class WaterType:
    FALL = 1
    SETTLED = 2

class Cell:
    def __init__(self, background, isSource):
        self.background = background
        self.isSource = isSource
        self.water = 0
        self.waterType = WaterType.FALL
    def getCapacity(self):
        return (0 if self.background == BLOCK else (HALF_CAPACITY if isRamp(self.background) else MAX_CAPACITY))
    def copyCell(self, cell):
        self.background = cell.background
        self.isSource = cell.isSource
        # Include any water already here
        self.water += cell.water
        self.waterType = cell.waterType
    def updateType(self, cellBelow):
        if self.water == 0:
            self.waterType = WaterType.SETTLED
        elif self.water == self.getCapacity():
            # If a completely saturated block of water is falling it should still look full.
            self.waterType = WaterType.SETTLED
        elif cellBelow.water < cellBelow.getCapacity():
            self.waterType = WaterType.FALL
        else:
            self.waterType = WaterType.SETTLED
    def __str__(self):
        if self.background == SPACE and not self.isSource and self.water <= SPACE_THRESHHOLD:
            return SPACE
        elif self.background == SPACE and not self.isSource and self.waterType == WaterType.FALL:
            return FALL
        elif self.background == SPACE and not self.isSource and self.water <= RIVER_THRESHHOLD:
            return RIVER
        elif self.background == SPACE and not self.isSource:
            return POOL
        elif self.background == SPACE and self.water <= SPACE_THRESHHOLD:
            return SOURCE
        elif self.background == SPACE and self.waterType == WaterType.FALL:
            return SOURCE_AND_FALL
        elif self.background == SPACE and self.water <= RIVER_THRESHHOLD:
            return SOURCE_AND_RIVER
        elif self.background == SPACE:
            return SOURCE_AND_POOL
        elif self.background == BLOCK:
            return BLOCK
        elif isRamp(self.background) and self.isSource:
            raise Exception
        elif self.background == LRAMP and self.water <= SPACE_THRESHHOLD / 2:
            return LRAMP
        elif self.background == LRAMP and self.waterType == WaterType.FALL:
            return LRAMP_AND_FALL
        elif self.background == LRAMP and self.water <= RIVER_THRESHHOLD / 2:
            return LRAMP_AND_RIVER
        elif self.background == LRAMP:
            return LRAMP_AND_POOL
        elif self.water <= SPACE_THRESHHOLD / 2:
            return RRAMP
        elif self.waterType == WaterType.FALL:
            return RRAMP_AND_FALL
        elif self.water <= RIVER_THRESHHOLD / 2:
            return RRAMP_AND_RIVER
        else:
            return RRAMP_AND_POOL

gridCells = map(lambda x: list(x), gridStr.split('\n'))
height = len(gridCells)
width = len(gridCells[0])
grid = defaultdict(lambda : Cell(SPACE, False))
for i in range(height):
    for j in range(width):
        grid[i,j] = Cell(findBackground(gridCells[i][j]), isSource(gridCells[i][j]))

def p(coords, offset):
    """Add two tuples together.
    
    >>> p((2, 3), (-1, 0))
    (1, 3)
    """
    return tuple(map(sum, zip(coords, offset)))

def adjacent(i,j,includeUp):
    ret = []
    for offset in (ORDINALS if includeUp else ORDINALS[:-1]):
        ret.append(p((i,j), offset))
    return ret

CONNECTION_TO_SHAPES = {DOWN: [SPACE, LRAMP, RRAMP], LEFT: [SPACE, RRAMP], RIGHT: [SPACE, LRAMP], UP: [SPACE]}

def adjoint(grid, i, j, includeUp, includeDown):
    """Find all cells connected to this one (if this is a block then nothing connects to it).
    
    >>> grid = defaultdict(lambda : Cell(SPACE, False))
    >>> adjoint(grid, 10, 1, True, True)
    [(11, 1), (10, 0), (10, 2), (9, 1)]
    
    >>> adjoint(grid, 10, 1, False, True)
    [(11, 1), (10, 0), (10, 2)]
    
    >>> adjoint(grid, 10, 1, False, False)
    [(10, 0), (10, 2)]
    
    >>> grid[10, 1].background = LRAMP
    >>> adjoint(grid, 10, 1, True, True)
    [(10, 0), (9, 1)]
    
    >>> grid[10, 0].background = LRAMP
    >>> grid[9, 1].background = RRAMP
    >>> adjoint(grid, 10, 1, True, True)
    []
    """
    ret = []
    cell = grid[i, j]
    if cell.background == BLOCK:
        adj = []
    elif cell.background == LRAMP:
        adj = [LEFT, UP]
    elif cell.background == RRAMP:
        adj = [RIGHT, UP]
    elif cell.background == SPACE:
        adj = list(ORDINALS)
    if not includeUp and UP in adj:
        adj.remove(UP)
    if not includeDown and DOWN in adj:
        adj.remove(DOWN)
    for offset in adj:
        neighbourCoords = p((i,j), offset)
        neighbour = grid[neighbourCoords]
        if neighbour.background in CONNECTION_TO_SHAPES[offset]:
            ret.append(neighbourCoords)
    return ret

def distance(loc1, loc2):
    """Calculate the manhatten distance between two locations.
    
    >>> distance((5,2), (3, 1))
    3
    """
    row1, col1 = loc1
    row2, col2 = loc2
    d_col = abs(col1 - col2)
    d_row = abs(row1 - row2)
    return d_row + d_col

def aStarRegion(start, end, region, edge):
    """The AStar algorithm to find the shortest path between two cells using the region as the nodes, and the edges in edge.
    
    >>> grid = defaultdict(lambda : Cell(SPACE, False))
    >>> edge = defaultdict(dict)
    >>> edge[1,0] = {(1,1): 1}
    >>> edge[1,1] = {(2,1): 1}
    >>> aStarRegion((1,0), (2,1), [(1,0),(1,1),(2,1)], edge)
    [(1, 0), (1, 1), (2, 1)]
    """
    openSet = set()
    openHeap = []
    closedSet = set()
    parent = {}

    def retracePath(c, edge):
        path = [c]
        while c in parent:
            c = parent[c]
            path.append(c)
        path.reverse()
        return path

    current = start
    openSet.add(current)
    openHeap.append((0,current))
    while openSet:
        current = heapq.heappop(openHeap)[1]
        if current == end:
            return retracePath(current, edge)
        openSet.remove(current)
        closedSet.add(current)
        for tile, remainingFlow in edge[current].items():
            if tile not in closedSet:
                H = distance(tile, end)*10
                if tile not in openSet:
                    openSet.add(tile)
                    heapq.heappush(openHeap, (H,tile))
                parent[tile] = current
    return []

def findWaterRegions(grid, height, width):
    """Find water regions. Return a dict keyed on the top left (top then left) cell of each region.
    
    >>> grid = defaultdict(lambda : Cell(SPACE, False))
    >>> waterRegions, outlets, edges = findWaterRegions(grid, 4, 5)
    >>> waterRegions
    {}
    >>> outlets
    {}
    >>> dict(edges)
    {}
    
    >>> grid[2,2].water = MAX_CAPACITY
    >>> grid[2,3].water = MAX_CAPACITY
    >>> grid[3,3].water = MAX_CAPACITY
    >>> waterRegions, outlets, edges = findWaterRegions(grid, 4, 5)
    >>> waterRegions
    {(2, 2): [(2, 2), (2, 3), (3, 3)]}
    >>> outlets
    {(2, 2): [(3, 2), (2, 1), (1, 2), (2, 4), (1, 3), (4, 3), (3, 2), (3, 4)]}
    >>> dict(edges)
    {(2, 2): defaultdict(<type 'dict'>, {(2, 3): {(2, 4): 100, (1, 3): 100, (3, 3): 100, (2, 2): 100}, (3, 3): {(2, 3): 100, (3, 2): 100, (3, 4): 100, (4, 3): 100}, (2, 2): {(1, 2): 100, (3, 2): 100, (2, 3): 100, (2, 1): 100}})}
    
    >>> grid[2,3].background = LRAMP
    >>> grid[2,3].water = HALF_CAPACITY
    >>> waterRegions, outlets, edges = findWaterRegions(grid, 4, 5)
    >>> waterRegions
    {(3, 3): [(3, 3)], (2, 2): [(2, 2), (2, 3)]}
    >>> outlets
    {(3, 3): [(4, 3), (3, 2), (3, 4)], (2, 2): [(3, 2), (2, 1), (1, 2), (1, 3)]}
    >>> dict(edges)
    {(3, 3): defaultdict(<type 'dict'>, {(3, 3): {(3, 2): 100, (3, 4): 100, (4, 3): 100}}), (2, 2): defaultdict(<type 'dict'>, {(2, 3): {(1, 3): 100, (2, 2): 100}, (2, 2): {(1, 2): 100, (3, 2): 100, (2, 3): 100, (2, 1): 100}})}
    
    >>> grid = defaultdict(lambda : Cell(SPACE, False))
    >>> grid[2,3].background = LRAMP
    >>> grid[2,3].water = HALF_CAPACITY - 1
    >>> waterRegions, outlets, edges = findWaterRegions(grid, 4, 5)
    >>> waterRegions
    {(2, 3): [(2, 3)]}
    >>> outlets
    {(2, 3): [(2, 3), (2, 2)]}
    >>> dict(edges)
    {(2, 3): defaultdict(<type 'dict'>, {(2, 3): {(2, 2): 100}})}
    
    >>> grid = defaultdict(lambda : Cell(SPACE, False))
    >>> grid[1,0].background = BLOCK
    >>> grid[1,4].background = BLOCK
    >>> grid[2,0].background = BLOCK
    >>> grid[2,4].background = BLOCK
    >>> grid[3,1].background = RRAMP
    >>> grid[4,2].background = BLOCK
    >>> grid[2,2].background = BLOCK
    >>> grid[3,3].background = LRAMP
    >>> grid[3,1].water = HALF_CAPACITY
    >>> grid[3,2].water = MAX_CAPACITY
    >>> grid[3,3].water = HALF_CAPACITY
    >>> waterRegions, outlets, edges = findWaterRegions(grid, 4, 5)
    >>> waterRegions
    {(3, 1): [(3, 1), (3, 2), (3, 3)]}
    >>> outlets
    {(3, 1): [(2, 1), (2, 3)]}
    >>> dict(edges)
    {(3, 1): defaultdict(<type 'dict'>, {(3, 2): {(3, 1): 100, (3, 3): 100}, (3, 1): {(3, 2): 100, (2, 1): 100}, (3, 3): {(3, 2): 100, (2, 3): 100}})}
    
    >>> grid = defaultdict(lambda : Cell(SPACE, False))
    >>> grid[0,0].water = MAX_CAPACITY - 1
    >>> grid[1,0].water = MAX_CAPACITY - 1
    >>> waterRegions, outlets, edges = findWaterRegions(grid, 4, 5)
    >>> waterRegions
    {(1, 0): [(1, 0)], (0, 0): [(0, 0)]}
    >>> outlets
    {(1, 0): [(1, 0), (2, 0), (1, -1), (1, 1)], (0, 0): [(0, 0), (1, 0), (0, -1), (0, 1)]}
    >>> dict(edges)
    {(1, 0): defaultdict(<type 'dict'>, {(1, 0): {(2, 0): 100, (1, -1): 100, (1, 1): 100}}), (0, 0): defaultdict(<type 'dict'>, {(0, 0): {(0, 1): 100, (0, -1): 100, (1, 0): 100}})}
    """
    waterRegions = {}
    outlets = {}
    edges = defaultdict(lambda : defaultdict(dict))
    explored = []
    for i, j in product(range(height), range(width)):
        if (i,j) not in explored:
            cell = grid[i,j]
            if cell.water > 0:
                waterRegions[i,j] = [(i,j)]
                outlets[i,j] = ([] if grid[i,j].water == grid[i,j].getCapacity() else [(i,j)])
                toExplore = [(i,j)]
                while len(toExplore) > 0:
                    hereX, hereY = toExplore.pop()
                    explored.append((hereX, hereY))
                    includeUp = (grid[hereX,hereY].water == grid[hereX,hereY].getCapacity())
                    includeDown = (grid[hereX+1,hereY].water == grid[hereX+1,hereY].getCapacity())
                    for x, y in adjoint(grid, hereX, hereY, includeUp, includeDown):
                        if grid[x,y].water != 0 and (x,y) not in explored:
                            toExplore.append((x,y))
                            waterRegions[i,j].append((x,y))
                    for x, y in adjoint(grid, hereX, hereY, includeUp, True):
                        edges[i,j][hereX,hereY][x,y] = MAX_FLOW
                        if grid[x,y].water != grid[x,y].getCapacity():
                            outlets[i,j].append((x,y))
    return waterRegions, outlets, edges

def findHeight(grid, point):
    return (height - point[0]) * MAX_CAPACITY + grid[point].water

def findHighestPoint(grid, region):
    highestPoint = region[0]
    highestHeight = findHeight(grid, highestPoint)
    for point in region:
        height = findHeight(grid, point)
        if height > highestHeight:
            highestHeight = height
            highestPoint = point
    return highestPoint

def findLowestPoint(grid, region):
    lowestPoint = region[0]
    lowestHeight = findHeight(grid, lowestPoint)
    for point in region:
        height = findHeight(grid, point)
        if height < lowestHeight:
            lowestHeight = height
            lowestPoint = point
    return lowestPoint

def moveWater(grid, start, end, region, edge):
    """Move a unit of water from start to end. Return True if successful."""
    path = aStarRegion(start, end, region, edge)
    if len(path) == 0:
        return False

    grid[start].water -= 1
    stepStart = start
    for stepEnd in path[1:]:
        edge[stepStart][stepEnd] -= 1
        if edge[stepStart][stepEnd] == 0:
            edge[stepStart].pop(stepEnd)
            if len(edge[stepStart]) == 0:
                edge.pop(stepStart)
        stepStart = stepEnd
    grid[end].water += 1
    
    return True

def displayGrid(grid):
    print
    for i in range(height):
        row = ''
        for j in range(width):
            grid[i,j].updateType(grid[i+1,j])
            row += str(grid[i,j])
        row += ' '
        for j in range(width):
            row += ('%x'%(grid[i,j].water / 10) if grid[i,j].water < 160 else '+')
        print row

def main(grid):
    t = 0
    while t < 20:
        displayGrid(grid)
        newGrid = defaultdict(lambda : Cell(SPACE, False))
        for i, j in product(range(height), range(width)):
            cell = grid[i,j]
            newCell = newGrid[i,j]
            newCell.copyCell(cell)
            if cell.isSource:
                newCell.water += SOURCE_RATE
        grid = newGrid
        
        waterRegions, outlets, edges = findWaterRegions(grid, height, width)
        
        movedSomething = True
        while movedSomething:
            movedSomething = False
            for regionKey in waterRegions.keys():
                waterRegion = waterRegions[regionKey]
                outlet = outlets[regionKey]
                edge = edges[regionKey]
                start = findHighestPoint(grid, waterRegion)
                end = findLowestPoint(grid, outlet)
                if findHeight(grid, start) > findHeight(grid, end):
                    movedSomething = moveWater(grid, start, end, waterRegion + [end], edge)
                    if grid[start].water == 0:
                        waterRegion.remove(start)
                        if len(waterRegion) == 0:
                            waterRegions.pop(regionKey)

        t += 1

if __name__ == '__main__':
    import doctest
    # Doesn't test inner functions!
    failures, passes = doctest.testmod(raise_on_error=False)
    if failures == 0:
        main(grid)
    else:
        print 'Stopping with %d failures'%failures