day 16 monstrocity calculated overnight

trying out with smaller example.
AND. before refactoring by BAD BOOLEAN

day16-even-simpler-test.txt

@@ -0,0 +1,2 @@
+Valve AA has flow rate=0; tunnels lead to valves BB
+Valve BB has flow rate=1; tunnels lead to valves AA

day16-input.txt

@@ -0,0 +1,51 @@
+Valve NV has flow rate=5; tunnels lead to valves ZV, CG, YB, HX, OY
+Valve NU has flow rate=6; tunnels lead to valves DA, MA, OA, DK
+Valve VU has flow rate=0; tunnels lead to valves PS, FX
+Valve JW has flow rate=0; tunnels lead to valves AA, MD
+Valve RI has flow rate=0; tunnels lead to valves OY, DG
+Valve DG has flow rate=9; tunnels lead to valves TG, RI, DF, EV, KW
+Valve PH has flow rate=7; tunnels lead to valves KW, OW, LT, LZ
+Valve KZ has flow rate=12; tunnels lead to valves ET, QV, CK, MS
+Valve IX has flow rate=0; tunnels lead to valves TS, DO
+Valve MS has flow rate=0; tunnels lead to valves LZ, KZ
+Valve IL has flow rate=0; tunnels lead to valves DO, ET
+Valve EJ has flow rate=20; tunnels lead to valves AV, JY
+Valve DK has flow rate=0; tunnels lead to valves NU, CG
+Valve YB has flow rate=0; tunnels lead to valves NV, PS
+Valve OA has flow rate=0; tunnels lead to valves YA, NU
+Valve DA has flow rate=0; tunnels lead to valves NU, RG
+Valve KO has flow rate=0; tunnels lead to valves AA, TG
+Valve RG has flow rate=4; tunnels lead to valves DF, DA, ZV, MD, LB
+Valve MA has flow rate=0; tunnels lead to valves AA, NU
+Valve OW has flow rate=0; tunnels lead to valves DO, PH
+Valve KW has flow rate=0; tunnels lead to valves DG, PH
+Valve DO has flow rate=14; tunnels lead to valves IX, IL, CZ, OW
+Valve DF has flow rate=0; tunnels lead to valves RG, DG
+Valve TG has flow rate=0; tunnels lead to valves DG, KO
+Valve LB has flow rate=0; tunnels lead to valves RG, FX
+Valve HX has flow rate=0; tunnels lead to valves AA, NV
+Valve GB has flow rate=0; tunnels lead to valves AV, XK
+Valve CG has flow rate=0; tunnels lead to valves DK, NV
+Valve LT has flow rate=0; tunnels lead to valves AO, PH
+Valve FX has flow rate=23; tunnels lead to valves LB, HY, VU
+Valve ET has flow rate=0; tunnels lead to valves IL, KZ
+Valve CK has flow rate=0; tunnels lead to valves UX, KZ
+Valve LZ has flow rate=0; tunnels lead to valves PH, MS
+Valve YA has flow rate=17; tunnels lead to valves JY, OA
+Valve TS has flow rate=0; tunnels lead to valves NO, IX
+Valve NO has flow rate=8; tunnel leads to valve TS
+Valve XK has flow rate=24; tunnel leads to valve GB
+Valve PS has flow rate=18; tunnels lead to valves EV, VU, YB
+Valve AA has flow rate=0; tunnels lead to valves JW, HX, MA, KO
+Valve MD has flow rate=0; tunnels lead to valves JW, RG
+Valve JM has flow rate=19; tunnels lead to valves QV, HY, AO
+Valve AV has flow rate=0; tunnels lead to valves EJ, GB
+Valve AO has flow rate=0; tunnels lead to valves JM, LT
+Valve JY has flow rate=0; tunnels lead to valves YA, EJ
+Valve OY has flow rate=0; tunnels lead to valves NV, RI
+Valve UX has flow rate=13; tunnels lead to valves CZ, CK
+Valve HY has flow rate=0; tunnels lead to valves JM, FX
+Valve EV has flow rate=0; tunnels lead to valves PS, DG
+Valve CZ has flow rate=0; tunnels lead to valves UX, DO
+Valve ZV has flow rate=0; tunnels lead to valves NV, RG
+Valve QV has flow rate=0; tunnels lead to valves JM, KZ

day16-scratch-cl-graph.lisp

@@ -0,0 +1,128 @@
+;; https://adventofcode.com/2022/day/16
+
+;; so. only idea i had is to build the graph, and then do random walk? ugh.
+;; we could maybe potentially divide by 2 amount of recursion,
+;;
+;; since possible actions are
+;; - go to next room
+;; - open current valve & go to next room
+;;
+;; and that shared part is almost similar, but is 1 move shorter, but adds some turns of this valve being open
+;; if i return info on which valves were open for how many turns from the recursion,
+;; i could potentially calculate what is more - 1 less turn of all of these and + some amount of current room's valve
+;; or just go to next turn.
+;;
+;; but this is kind of way too much, to wander aimlessly?
+;; maybe I need to build closure, then could choose any desired vertice? and select only those which are not visited.
+;; this seems much more sane
+;;
+;; maybe there's already good \ easy \ powerful graph library?
+;;
+;; i found two libraries for graphs.
+;; https://cl-graph.common-lisp.dev/user-guide.html - this one seem to allow for calculating closures, and filtering.
+;; (repo: https://github.com/gwkkwg/cl-graph )
+;; so i could potentially filter the remaining graph for the walkthrough
+;; https://github.com/kraison/graph-utils - this one visualization and primitives that could allow for writing algos
+;;
+;; i guess i'll try to install first. is it available in quicklisp?
+;; (ql:quickload 'cl-graph)
+
+(push #p"~/quicklisp/local-projects/cl-graph/" asdf:*central-registry*)
+
+;; (ql:quickload "cl-graph")
+(ql:quickload '(:cl-graph :moptilities))
+(defclass my-graph (cl-graph:basic-graph)
+  ())
+(defparameter *test-graph*  nil)
+;;   (:documentation "Stub for matrix based graph. Not implemented.")
+;; OH NO
+
+;; (cl-graph:add-vertex  *test-graph* 6)
+;; (cl-graph:vertex-count *test-graph*)
+
+;; (cl-graph:graph->dot *test-graph* t)
+
+;; (in-package #:cl-graph)
+(in-package cl-user)
+
+(make-graph 'basic-graph)               ; still doesn' work
+;; to allow export to DOT
+;; https://github.com/gwkkwg/cl-graph/issues/12
+;; (defclass* dot-graph (dot-graph-mixin graph-container)
+;;   ()
+;;   (:export-p t))
+(let ((g (make-container 'dot-graph :default-edge-type :directed)))
+  (loop for (a b) in '((a b) (b c) (b d) (d e) (e f) (d f)) do
+        (add-edge-between-vertexes g a b))
+  (graph->dot g nil))
+
+
+(setq *test-graph*
+      (let ((g (cl-graph:make-graph 'cl-graph:dot-graph)))
+        (loop for v in '(a b c d e) do
+          (cl-graph:add-vertex g v))
+        (loop for (v1 . v2) in '((a . b) (a . c) (b . d) (c . e)) do
+          (cl-graph:add-edge-between-vertexes g v1 v2))
+        g))
+
+(setq *test-graph*
+      (let ((g (make-graph 'graph-container)))
+        (loop for v in '(a b c d e) do
+          (add-vertex g v))
+        (loop for (v1 . v2) in '((a . b) (a . c) (b . d) (c . e)) do
+          (add-edge-between-vertexes g v1 v2))
+        g))
+
+(cl-graph:vertex-count *test-graph*)
+(graph->dot *test-graph* nil)
+(vertexes *test-graph*)
+(make-graph-from-vertexes (vertexes *test-graph*))
+
+(identity 1)
+;; graph-container already subclass of basic-graph.
+;; then why doesn't this method is dispatched?
+(make-filtered-graph *test-graph* (lambda (v) t) )
+
+;; maybe quicklisp doens't have a fresh enough version?
+;; ok. how do i make quicklisp use cloned code?
+
+;; well. too bad.
+(cl-graph:make-graph-from-vertexes (cl-graph:vertexes *test-graph*))
+(cl-graph:make-filtered-graph *test-graph* (lambda (v) t) )
+((lambda (v) t) 1)
+
+(ql:where-is-system :cl-graph)
+;; => #P"/home/efim/quicklisp/dists/quicklisp/software/cl-graph-20171227-git/"
+
+(ql:update-client)
+(ql:update-all-dists)
+;; Changes from quicklisp 2022-07-08 to quicklisp 2022-11-07:
+
+(cl-graph:graph->dot *test-graph* nil)
+
+;; required additional dependency
+;; (ql:quickload '(:cl-graph :moptilities))
+;; asdf system connections
+;; https://github.com/gwkkwg/cl-graph/blob/3cb786797b24883d784b7350e7372e8b1e743508/cl-graph.asd#L84-L89
+
+(setq *test-graph*
+      (let ((g (cl-graph:make-graph 'cl-graph:dot-graph)))
+        (loop for v in '(a b c d e) do
+          (cl-graph:add-vertex g v))
+        (loop for (v1 . v2) in '((a . b) (a . c) (b . d) (c . e)) do
+          (cl-graph:add-edge-between-vertexes g v1 v2))
+        g))
+
+(print (cl-graph:graph->dot *test-graph* nil))
+
+(print (cl-graph:graph->dot
+        (cl-graph:make-filtered-graph *test-graph*
+                                      (lambda (v) (not (eq v 'a)))
+                                      :graph-completion-method nil)
+        nil))
+
+;; well, that was all for nothing?
+;; or do i still rather use that library?
+;; because it would allow me to add data to vertices?
+;;
+;; and graph-utils allows for getting hashmap of all paths and lengts?

day16-simpler-test.txt

@@ -0,0 +1,5 @@
+Valve AA has flow rate=0; tunnels lead to valves BB
+Valve BB has flow rate=1; tunnels lead to valves CC, EE
+Valve CC has flow rate=1; tunnels lead to valves DD
+Valve DD has flow rate=1; tunnels lead to valves EE
+Valve EE has flow rate=1; tunnels lead to valves EE

day16-test.txt

@@ -0,0 +1,10 @@
+Valve AA has flow rate=0; tunnels lead to valves DD, II, BB
+Valve BB has flow rate=13; tunnels lead to valves CC, AA
+Valve CC has flow rate=2; tunnels lead to valves DD, BB
+Valve DD has flow rate=20; tunnels lead to valves CC, AA, EE
+Valve EE has flow rate=3; tunnels lead to valves FF, DD
+Valve FF has flow rate=0; tunnels lead to valves EE, GG
+Valve GG has flow rate=0; tunnels lead to valves FF, HH
+Valve HH has flow rate=22; tunnel leads to valve GG
+Valve II has flow rate=0; tunnels lead to valves AA, JJ
+Valve JJ has flow rate=21; tunnel leads to valve II

day16.lisp

@@ -0,0 +1,58 @@
+;; https://github.com/kraison/graph-utils
+
+(ql:quickload 'graph-utils)
+(ql:quickload 'alexandria)
+
+;;; reading in data
+;; graph and hashmap from node name to flow and state
+(defclass verticle-data ()
+  ((flow :reader flow :initarg :flow)
+   (name :reader name :initarg :name)
+   (is-opened-p :accessor is-opened-p :initform t)))
+
+(defmethod print-object ((obj verticle-data) stream)
+  (with-slots (name flow is-opened-p) obj
+    (format stream "~a with flow: ~a; is opened? ~a" name flow is-opened-p)))
+
+(defun parse-integer-or-symbol (str)
+  (let ((maybe-int (parse-integer str :junk-allowed t)))
+    (if maybe-int
+        maybe-int
+        (intern (string-upcase str)))))
+
+(defun parse-input-line (line)
+  (destructuring-bind (-valve source-name -has -flow -rate flow-rate
+                     -tunnels -lead -to -valves &rest to-valve-names)
+    (mapcar #'parse-integer-or-symbol
+            (remove-if (lambda (str) (equal "" str)) (cl-ppcre:split "(,| |=)" line)))
+  (format t "from ~a with ~a; to ~a~%" source-name flow-rate to-valve-names)
+  (list  source-name flow-rate to-valve-names)))
+
+(defun read-file-data (filename graph vertices-data-map)
+  (loop
+    for line-struct in
+                    (mapcar #'parse-input-line (uiop:read-file-lines filename))
+    do (put-struct-into-storages line-struct graph vertices-data-map)))
+
+
+;;; calculations for part 1
+
+(defun get-possible-next-vs (cur-node graph vertices-data-map shortest-paths time-remaining)
+  (loop
+    for (from . to)
+      being the hash-keys in shortest-paths using (hash-value dist)
+    for from-node = (graph-utils:lookup-node graph from)
+    for to-node = (graph-utils:lookup-node graph to)
+    for to-node-data = (gethash to-node vertices-data-map)
+    when (and (equal cur-node from-node)
+              (not (equal cur-node to-node))
+              (not (= 0 (flow to-node-data)))
+              (> time-remaining dist)
+              (is-opened-p to-node-data))
+      do (format t "from ~a to ~a dist: ~a. ~a~%" from-node to-node dist to-node-data)
+    when (and (equal cur-node from-node)
+              (not (equal cur-node to-node))
+              (not (= 0 (flow to-node-data)))
+              (> time-remaining dist)
+              (is-opened-p to-node-data))
+      collect (list to-node dist)))