Uniform cost search in clojure - clojure

Question

there seems to be a bug in this program I appreciate if someone could help
(defn findmincostindex [frontier]
(loop [i 0 n 0]
(if (< i (count frontier))
(if (< (:cost (get frontier i)) (:cost (get frontier n)))
(recur (inc i) i)
(recur (inc i) n))
n)))
(defn uniformcostsearch [graph start end]
((fn [frontier explored]
(if (empty? frontier)
"Failure"
(let [pathwithmincost (findmincostindex (into [] frontier))
;(let [pathwithmincost (findmincostindex frontier)
path (:path (get frontier pathwithmincost))
cost (:cost (get frontier pathwithmincost))
node (peek path)
childs (keys (graph node))]
(if (= node end)
path
(recur
(concat (subvec frontier 0 pathwithmincost) (subvec frontier (inc pathwithmincost))
(map (fn [c] {:path (conj path c) :cost (+ cost ((graph node) c))})
(filter #(not (contains? explored %)) childs)))
(conj explored node))))))
[{:path [start] :cost 0}] #{}))
(def graph {
"Oradea" {
"Zerind" 71,
"Sibiu" 151
},
"Zerind" {
"Oradea" 71,
"Arad" 75
},
"Arad" {
"Zerind" 75,
"Sibiu" 140,
"Timisoara" 118
},
"Sibiu" {
"Oradea" 151,
"Arad" 140,
"Fagaras" 99,
"Rimnicu Vilcea" 80
},
"Fagaras" {
"Sibiu" 99,
"Bucharest" 211
},
"Rimnicu Vilcea" {
"Sibiu" 80,
"Pitesti" 97,
"Craiova" 146
},
"Timisoara" {
"Arad" 118,
"Lugoj" 111
},
"Lugoj" {
"Timisoara" 111,
"Mehadia" 70
},
"Pitesti" {
"Rimnicu Vilcea" 97,
"Craiova" 138,
"Bucharest" 101
},
"Mehadia" {
"Lugoj" 70,
"Drobeta" 75
},
"Drobeta" {
"Mehadia" 75,
"Craiova" 120
},
"Craiova" {
"Drobeta" 120,
"Rimnicu Vilcea" 146,
"Pitesti" 138
},
"Bucharest" {
"Pitesti" 101,
"Fagaras" 211,
"Giurgiu" 90,
"Urziceni" 85
},
"Giurgiu" {
"Bucharest" 90
},
"Urziceni" {
"Bucharest" 85,
"Vaslui" 142,
"Hirsova" 98
},
"Hirsova" {
"Urziceni" 98,
"Eforie" 86
},
"Eforie" {
"Hirsova" 86
},
"Vaslui" {
"Iasi" 92,
"Urziceni" 142
},
"Iasi" {
"Neamt" 87,
"Vaslui" 92
},
"Neamt" {
"Iasi" 87
}})
(println (uniformcostsearch graph "Neamt" "Iasi"))
(println (uniformcostsearch graph "Neamt" "Vaslui"))
(println (uniformcostsearch graph "Bucharest" "Arad"))
it should output these lines
['Neamt', 'Iasi']
['Neamt', 'Iasi', 'Vaslui']
['Bucharest', 'Pitesti', 'Rimnicu Vilcea', 'Sibiu', 'Arad']
but instead it says:
clojure.lang.LazySeq cannot be cast to
clojure.lang.IPersistentVector
when I use
(into [] frontier)
if I use frontier alone it says
java.lang.NullPointerException

Answer 1

The exception happens in the first subvec in your recur. You're recurring with the result of concat, which is a lazy sequence, and you can't take a subvector of a lazy sequence. A quick fix is to just wrap it in vec:
(vec (concat (subvec frontier 0 pathwithmincost) (subvec frontier (inc pathwithmincost))
(map (fn [c] {:path (conj path c) :cost (+ cost ((graph node) c))})
(remove explored childs))))
A few other tips:
findmincostindex is essentially a reimplementation of min-key which is less general, and you could probably make this cleaner by using that.
Sets are functions too, and return the argument (truthy values) if it is a member of the set. You can use this to improve a little on (filter #(not (contains? explored %)) childs))) - for instance (remove explored childs)
Your let could be made a bit shorter by using destructuring.
Here's my attempt:
(let [[idx {:keys [path cost]}] (apply min-key (comp :cost second) (map-indexed vector frontier))
node (peek path)
childs (keys (graph node))]
The process here is
(map-indexed vector frontier) makes the frontier into pairs of index and node.
min-key finds the pair which has the lowest value for (:cost (second pair)).
let binds the name idx to the index of that pair, and path and cost to the :path and :cost keys of the node.