Comments on: Project Euler problem 83 – how creeps can help http://eli.thegreenplace.net/2009/06/19/project-euler-problem-83-how-creeps-can-help/ Eli Bendersky's personal website Wed, 28 Jul 2010 12:22:47 +0000 http://wordpress.org/?v=2.9.2 hourly 1 By: Python Coder http://eli.thegreenplace.net/2009/06/19/project-euler-problem-83-how-creeps-can-help/comment-page-1/#comment-181609 Python Coder Thu, 09 Jul 2009 20:28:53 +0000 http://eli.thegreenplace.net/?p=1743#comment-181609 thanks, after changing closedset and openset to sets it runs in a little over 2 seconds, wow! such a difference it makes thanks, after changing closedset and openset to sets it runs in a little over 2 seconds, wow!
such a difference it makes

]]> By: eliben http://eli.thegreenplace.net/2009/06/19/project-euler-problem-83-how-creeps-can-help/comment-page-1/#comment-181393 eliben Thu, 09 Jul 2009 03:46:36 +0000 http://eli.thegreenplace.net/?p=1743#comment-181393 @Python Coder, Perhaps you could use a real 'set' or a dict type for the open and closed sets instead of lists? Removing from a list is O(n). You can download and compare my A* code from the Creeps game link I provided - it's quite short and simple, and well commented. @Python Coder,

Perhaps you could use a real ’set’ or a dict type for the open and closed sets instead of lists? Removing from a list is O(n).

You can download and compare my A* code from the Creeps game link I provided – it’s quite short and simple, and well commented.

]]> By: Python Coder http://eli.thegreenplace.net/2009/06/19/project-euler-problem-83-how-creeps-can-help/comment-page-1/#comment-181167 Python Coder Wed, 08 Jul 2009 05:07:49 +0000 http://eli.thegreenplace.net/?p=1743#comment-181167 Hey i tried using A star to solve this problem and I get the correct answer but it is so AWFULLY sloww (500 secs). My program looks at all 6400 cells, what do you think I am doing wrong? heuristic: [code] def h(n, goal): ....return 11 * (abs(n.col - goal.col) + abs(n.row - goal.row)) [/code] If i change the 11 to a bigger number I get the wrong answer. Any suggestions [code] `<code>def astar(start, goal, matrix): __abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;closedset = [] __abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;openset = [] __abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;start__abENT__#46;hscore = h(start, goal, matrix) __abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;start__abENT__#46;fscore = start__abENT__#46;hscore + start__abENT__#46;gscore __abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;openset__abENT__#46;append(start) __abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;while openset: __abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;x = None # find node with lowest fscore __abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;for n in openset: __abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;if not x or n__abENT__#46;fscore __abENT__lt; x__abENT__#46;fscore: __abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;x = n if x__abENT__#46;row == goal__abENT__#46;row and x__abENT__#46;col == goal__abENT__#46;col: return x__abENT__#46;gscore print x__abENT__#46;row, x__abENT__#46;col, len(closedset), x__abENT__#46;fscore openset__abENT__#46;remove(x) closedset__abENT__#46;append(x) neighbors = [] if x__abENT__#46;row != len(matrix)-1: neighbors__abENT__#46;append(matrix[x__abENT__#46;row+1][x__abENT__#46;col]) if x__abENT__#46;row != 0: neighbors__abENT__#46;append(matrix[x__abENT__#46;row-1][x__abENT__#46;col]) if x__abENT__#46;col != len(matrix[0])-1: neighbors__abENT__#46;append(matrix[x__abENT__#46;row][x__abENT__#46;col+1]) if x__abENT__#46;col != 0: neighbors__abENT__#46;append(matrix[x__abENT__#46;row][x__abENT__#46;col-1]) __abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;for y in neighbors: __abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;if y in closedset: __abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;__abENT__#46;continue gscore = x__abENT__#46;gscore + y__abENT__#46;gscore better = False if not y in openset: openset__abENT__#46;append(y) y__abENT__#46;hscore = h(y, goal, matrix) better = True elif gscore __abENT__lt; y__abENT__#46;gscore: better = True if better: y__abENT__#46;parent = x y__abENT__#46;gscore = gscore y__abENT__#46;fscore = y__abENT__#46;gscore + y__abENT__#46;hscore return None</code>` [/code] Sorry for the long code =/ Hey i tried using A star to solve this problem and I get the correct answer but it is so AWFULLY sloww (500 secs). My program looks at all 6400 cells, what do you think I am doing wrong?
heuristic:
[code]
def h(n, goal):
....return 11 * (abs(n.col - goal.col) + abs(n.row - goal.row))
[/code]
If i change the 11 to a bigger number I get the wrong answer.
Any suggestions
[code]
def astar(start, goal, matrix):
....closedset = []
....openset = []
....start.hscore = h(start, goal, matrix)
....start.fscore = start.hscore + start.gscore
....openset.append(start)

....while openset:
........x = None # find node with lowest fscore
........for n in openset:
............if not x or n.fscore < x.fscore:
................x = n

if x.row == goal.row and x.col == goal.col:
return x.gscore

print x.row, x.col, len(closedset), x.fscore

openset.remove(x)
closedset.append(x)

neighbors = []
if x.row != len(matrix)-1:
neighbors.append(matrix[x.row+1][x.col])

if x.row != 0:
neighbors.append(matrix[x.row-1][x.col])

if x.col != len(matrix[0])-1:
neighbors.append(matrix[x.row][x.col+1])

if x.col != 0:
neighbors.append(matrix[x.row][x.col-1])

........for y in neighbors:
............if y in closedset:
................continue

gscore = x.gscore + y.gscore
better = False

if not y in openset:
openset.append(y)
y.hscore = h(y, goal, matrix)
better = True

elif gscore < y.gscore:
better = True

if better:
y.parent = x
y.gscore = gscore
y.fscore = y.gscore + y.hscore

return None
[/code]
Sorry for the long code =/

]]> By: Jack Diederich http://eli.thegreenplace.net/2009/06/19/project-euler-problem-83-how-creeps-can-help/comment-page-1/#comment-177625 Jack Diederich Sun, 21 Jun 2009 02:08:34 +0000 http://eli.thegreenplace.net/?p=1743#comment-177625 Ahh, nevermind. You're saying that A* collapses to Dijkstra. Ahh, nevermind. You’re saying that A* collapses to Dijkstra.

]]> By: Jack Diederich http://eli.thegreenplace.net/2009/06/19/project-euler-problem-83-how-creeps-can-help/comment-page-1/#comment-177622 Jack Diederich Sun, 21 Jun 2009 01:52:47 +0000 http://eli.thegreenplace.net/?p=1743#comment-177622 Oy ye of little faith! A simple A* Heuristic solves this problem in a fraction of a second on my 1GHz laptop. 50 lines of python including comments and vertical whiespace. Some things to remember about A*: - the heapq module is your friend - If you arrive at a node with a cost higher than you've seen at this node before you can toss out the current info, that path was a dead end. - the Heuristic doesn't need to be complicated (that's a hint) Here is the skeleton of my main routine def main(score_function): ..stack = [] ..def push(pos, cost): ....score = score_function(pos, cost) ....heapq.heappush(stack, (score, (pos, cost))) ..def pop(): ....score, (pos, cost) = heapq.heappop(stack) ....return pos, cost ..while stack: ....cur_pos, cur_cost = pop() # lowest 'score' entry to date ....# do stuff The reason the score function is passed in is so you can try new ones easily. Oy ye of little faith! A simple A* Heuristic solves this problem in a fraction of a second on my 1GHz laptop. 50 lines of python including comments and vertical whiespace.

Some things to remember about A*:

- the heapq module is your friend
- If you arrive at a node with a cost higher than you’ve seen at this node before you can toss out the current info, that path was a dead end.
- the Heuristic doesn’t need to be complicated (that’s a hint)

Here is the skeleton of my main routine

def main(score_function):
..stack = []
..def push(pos, cost):
….score = score_function(pos, cost)
….heapq.heappush(stack, (score, (pos, cost)))
..def pop():
….score, (pos, cost) = heapq.heappop(stack)
….return pos, cost

..while stack:
….cur_pos, cur_cost = pop() # lowest ’score’ entry to date
….# do stuff

The reason the score function is passed in is so you can try new ones easily.

]]>