2D Waterflow Problem

# additional lists included to allow the output data for water depth and standing water elevations to be imported to an Excel sheet.
# additional lists are srickly for interest and not required for the solution. 

w, h = 100, 100;
hill_elv = [[]]
hill_elv = [[0 for x in range(w)] for y in range (h)]; # array to hold hill elevations from file
drain_elv = [[]]
drain_elv = [[9 for x in range(w)] for y in range (h)]; #array to hold water drain elevations for calculation.  fill list with high elv
water_depth =[[]]
water_depth =[[0 for x in range(w)] for y in range (h)]; #not required- included to produce Excel chart indicating depth of water remaining on the hill
water_elv =[[]]
water_elv =[[0 for x in range(w)] for y in range (h)];  # not required -included to produce Excel chart indicating water levels rmaing on the hill
rline = 0
rchr = 0
chg = True

with open("J:\Brilliant\\rain on hill\\rain on hill bril.txt") as file: # read from file fill python list of lists with hill elevation data
    for line in file:
        rchr = 0
        for chr in line[:100]:
            hill_elv[rline][rchr]= int(chr)
            rchr += 1
        rline += 1

file.close()
for x in range(w):    # fill outside edge cells with starting drain level elevations
    for y in range(h):
        if x == 0 or x == 99 or y == 0 or y == 99:
            drain_elv[x][y]= hill_elv[x][y]

while chg == True:
        chg = False
        for row in range(1,99):
            for col in range(1,99): #increment through all the cells on the hill
                north = max(drain_elv[row-1][col],hill_elv[row-1][col])  # find current drain level to each boarder cell on hill in this pass
                south = max(drain_elv[row+1][col],hill_elv[row+1][col])
                west = max(drain_elv[row][col-1],hill_elv[row][col-1])
                east = max(drain_elv[row][col+1],hill_elv[row][col+1])
                if min(north,south,east,west) != drain_elv[row][col]:  # determine if chage is to be made in this pass
                    drain_elv[row][col] =  min(north,south,east,west)  # make change to drain elevation list
                    chg = True

hold_count =0    
for row in range(1,99):
    for col in range(1,99):   #increment through all the cells on the hill
        if drain_elv [row][col] > hill_elv [row][col]: # if water elevation is above hill elevation in this cell
            hold_count += drain_elv [row][col]-hill_elv [row][col] # add standing water volume to total
            water_depth[row][col] = drain_elv [row][col]-hill_elv [row][col]   #not required -    calculate and store water depth for this call 
        if drain_elv [row][col] > hill_elv [row][col]:   #not required- --   for water elevations above hill elevations
            water_elv[row][col] = drain_elv [row][col]   #not required---    store standing water elevation for this cell
        else:
            water_elv[row][col] = -1  #not required-      if hill elevation is not below water store -1 


print("Total water volume held on the hill is ", hold_count," units")

import csv
csvfile = "J:\\Brilliant\\rain on hill\\water elevation.txt"

with open(csvfile, "w") as output: # write water level elevation list to file for use with Excel chart 
    writer = csv.writer(output, lineterminator='\n')
    writer.writerows(water_elv)
csvfile = "J:\\Brilliant\\rain on hill\\water depth.txt"

with open(csvfile, "w") as output: # write depth list to file for use with Excel chart 
    writer = csv.writer(output, lineterminator='\n')
    writer.writerows(water_depth)    

from functools import reduce
import math

# Open the given map from a txt file
with open('hillmap.txt') as f:
    lines = f.readlines()
    # Create a 2d list of heights
    hillmap = [[int(ch) for ch in line[:] if ch != "\n"] for line in lines]
width, height = len(hillmap), len(hillmap[0])

# The total water amount
watertotal = 0
# Set of hill layers
layers = reduce(lambda a, b: a | b, [{n for n in row} for row in hillmap])
layers = sorted(list(layers))

# Move upwards layer by layer
for k, layer in zip(range(len(layers)), layers):
    # A map of whether there is a hill or not (1 Hill, 0 Water, -1 Empty)
    temp_map = [[n >= layer for n in row] for row in hillmap]
    # Initialize a set of cells connected to the edge directly
    cells_to_check = \
        {(x, 0) for x in range(0, width)
         if not temp_map[x][0]} |\
        {(0, y) for y in range(0, height)
         if not temp_map[0][y]} | \
        {(x, height - 1) for x in range(0, width)
         if not temp_map[x][height - 1]} | \
        {(width - 1, y) for y in range(0, height)
         if not temp_map[width - 1][y]}
    # While there are unprocessed cells left
    while cells_to_check:
        cx, cy = cells_to_check.pop()
        # Mark this cell Empty
        temp_map[cx][cy] = -1
        # Check all adjacent cells
        for dx, dy in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
            # If it is Water and it's within the map bounds
            if cx + dx < width and cx + dx >= 0 and \
                    cy + dy < height and cy + dy >= 0 and \
                    temp_map[cx + dx][cy + dy] == 0:
                # Then add this cell to the set of cell to be emptied.
                cells_to_check.add((cx + dx, cy + dy))
    # Get volume by multiplying the area by the difference between layers
    layertotal = sum([sum([r == 0 for r in row]) for row in temp_map]) * \
        max(0, layers[k] - layers[k - 1])
    # Assume inf * 0 = 0 (we're talking about physical volume after all)
    if not math.isnan(layertotal):
        watertotal += layertotal

# Print the output
print(watertotal)

import math;
import random;

# Full data omitted so this code isn't 7 pages long, but data is stored as an array of strings, each line being a different string
heights = ["208047978591944048925234813...832872760452687289609809031"];
maxHeight = 10;
queue = [];
shouldQueueArray = [];

def enqueue(x, y, z):
    array = [x, y, z];
    queue.append(array);
    shouldQueueArray[y * maxHeight * len(heights) + x * maxHeight + z] = -1;

def shouldQueue(x, y, z):
    if(x == -1 or x == len(heights) or y == -1 or y == len(heights) or z < 0 or z >= maxHeight):
        return False;
    return shouldQueueArray[y * maxHeight * len(heights) + x * maxHeight + z] == 0;

def splitArray(num):
    array = [];
    for char in num:
        array.insert(len(array), int(char));
    return array;

def getLength():
    i = 0
    for item in shouldQueueArray:
        if(item == 0):
            i += 1;
    return i;

y = 0;
for heights_ in heights:
    x = 0;
    heightsArray = splitArray(heights_);
    for height in heightsArray:
        for h in range(0, height + 1):
            shouldQueueArray.append(-1);
        for h in range(height + 1, maxHeight):
            shouldQueueArray.append(0);
        if((x == 0 or x == len(heights) - 1 or y == 0 or y == len(heights) - 1) and height + 1 != maxHeight):
            enqueue(x, y, height + 1);
        x += 1;
    y += 1;

while(len(queue) != 0):
    pos = queue[0];
    queue.pop(0);
    if(shouldQueue(pos[0] - 1, pos[1], pos[2])):
        enqueue(pos[0] - 1, pos[1], pos[2]);
    if(shouldQueue(pos[0] + 1, pos[1], pos[2])):
        enqueue(pos[0] + 1, pos[1], pos[2]);
    if(shouldQueue(pos[0], pos[1] - 1, pos[2])):
        enqueue(pos[0], pos[1] - 1, pos[2]);
    if(shouldQueue(pos[0], pos[1] + 1, pos[2])):
        enqueue(pos[0], pos[1] + 1, pos[2]);
    if(shouldQueue(pos[0], pos[1], pos[2] + 1)):
        enqueue(pos[0], pos[1], pos[2] + 1);

print(getLength());

import math;
import random;

# Full data omitted so this code isn't 7 pages long, but data is stored as an array of strings, each line being a different string
heights = ["208047978591944048925234813...832872760452687289609809031"];
waterArray = [];
queue = [];
maxHeight = 10;

def enqueue(x, y, z):
    array = [x, y, z];
    queue.append(array);

def splitArray(num):
    array = [];
    for char in num:
        array.insert(len(array), int(char));
    return array;

class Water:
    def __init__(self, x, y, z):
        self.x = x;
        self.y = y;
        self.z = z;

# 0 is hill, 1 is water, -1 is nothing
def getValue(x, y, h):
    if(x == -1 or x == len(heights) or y == -1 or y == len(heights)):
        return -1;
    if(isinstance(waterArray[y * maxHeight * len(heights) + x * maxHeight + h], Water)):
        return 1;
    return waterArray[y * maxHeight * len(heights) + x * maxHeight + h];

def removeValue(x, y, z):
    waterArray[y * maxHeight * len(heights) + x * maxHeight + z] = -1;

def getLength():
    i = 0
    for item in waterArray:
        if(isinstance(item, Water)):
            i += 1;
    return i;

y = 0;
for heights_ in heights:
    x = 0;
    heightsArray = splitArray(heights_);
    for height in heightsArray:
        for h in range(0, height + 1):
            waterArray.append(0);
        for h in range(height + 1, maxHeight):
            waterArray.append(Water(x, y, h));
        enqueue(x, y, height + 1);
        x += 1;
    y += 1;

height = maxHeight - 1;
while(height >= 0):
    updated = True;
    while(updated):
        updated = False;
        for y in range(0, len(heights)):
            for x in range(0, len(heights)):
                if(getValue(x, y, height) == 1 and (getValue(x + 1, y, height) == -1 or getValue(x - 1, y, height) == -1 or getValue(x, y + 1, height) == -1 or getValue(x, y - 1, height) == -1)):
                    removeValue(x, y, height);
                    updated = True;
    height -= 1;

print(getLength());

# CRAZY Inefficient! 
# 0 is water, 1 is hill, 2 is nothing
def getValue(x, y, h):
    if(x == -1 or x == len(heights) or y == -1 or y == len(heights)):
        return 2;
    if(waterArray[y * 10 * len(heights) + x * 10 + h] != 0):
        return 0;
    list = heights[y];
    array = splitArray(list);
    if(array[x] >= h):
        return 1;
    return 2;