From 0c3159601880f2068c4d1c7d8d54e4dd38eb9616 Mon Sep 17 00:00:00 2001
From: efim <efim.nefedov@nordigy.ru>
Date: Sat, 23 Dec 2023 12:54:55 +0000
Subject: [PATCH] day23, still bad

---
 day23/aLongWalk.go |  5 +++--
 day23/example2     | 10 ++++++++++
 day23/notes.org    |  6 ++++++
 day23/paths.go     | 34 ++++++++++++++++++++++++++++++----
 4 files changed, 49 insertions(+), 6 deletions(-)
 create mode 100644 day23/example2

diff --git a/day23/aLongWalk.go b/day23/aLongWalk.go
index 310ee8b..aa29eb2 100644
--- a/day23/aLongWalk.go
+++ b/day23/aLongWalk.go
@@ -8,14 +8,15 @@ import (
 // length of longest scenic route
 func Run() int {
 	fmt.Println("day 23")
-	filename := "day23/example"
+	filename := "day23/input"
 	field := ReadField(filename)
 	finalPaths := RunDFSTingy(field)
-	log.Println(finalPaths)
+	// log.Println(finalPaths)
 
 	max := 0
 	for _, path := range finalPaths {
 		if path.Visited.Cardinality() > max {
+			log.Println("one path len is ", path.Visited.Cardinality())
 			max = path.Visited.Cardinality()
 		}
 	}
diff --git a/day23/example2 b/day23/example2
new file mode 100644
index 0000000..acd35aa
--- /dev/null
+++ b/day23/example2
@@ -0,0 +1,10 @@
+#.#####################
+#.#####################
+#.##............#######
+#.##.##########.#######
+#....##########.#######
+####..#########.#######
+#####...........#######
+###############.#######
+###############.#######
+###############.#######
diff --git a/day23/notes.org b/day23/notes.org
index d19a051..1f570c8 100644
--- a/day23/notes.org
+++ b/day23/notes.org
@@ -70,3 +70,9 @@ so if i'm in visited, it doesn't mean that stored is shorter and current is a de
 
 but dfs should mean that all paths from this prefix have finished.
 so, sure. there have to be all done?
+** my example2 has fork on row 3 col 10
+so 4,10 and 3,11 should be visited separately.
+
+6,17 is where they join and the point which should have second entry
+** allright, ugh. my new solution is memory hogging.
+maybe i can draw the stuff and it will be several neat thingies
diff --git a/day23/paths.go b/day23/paths.go
index 6ab7a19..7c501d2 100644
--- a/day23/paths.go
+++ b/day23/paths.go
@@ -1,6 +1,7 @@
 package day23
 
 import (
+	"fmt"
 	"log"
 
 	mapset "github.com/deckarep/golang-set/v2"
@@ -10,6 +11,9 @@ type PathEnd struct {
 	end     Coord
 	visited mapset.Set[Coord]
 }
+func (p PathEnd)Sring() string {
+	return fmt.Sprintf("PathEnd[at %+v, visited: %+v]", p.end, p.visited)
+}
 
 func ExtendPath(p PathEnd, f Field) (nextPaths []PathEnd) {
 	endPointNeighbors := f.NeighborsPart2(p.end)
@@ -41,13 +45,27 @@ func RunDFSTingy(f Field) []PathInfo {
 	return DFSScenicPaths(f, initialPath, initialShared)
 }
 
+var knownMax int = 0
+func CheckAndPrintMax(maybeNewMax int) {
+	if maybeNewMax > knownMax {
+		log.Printf("\n\n>>>>found new max: %d\n", maybeNewMax)
+		knownMax = maybeNewMax
+	}
+}
+
 func DFSScenicPaths(f Field, curPath PathEnd,
 	sharedMem map[Coord][]PathInfo) (pathsFromTheStartToEnd []PathInfo) {
-
 	curCoord := curPath.end
+
+	if curCoord == (Coord{ Row: 6, Col: 15 }) {
+		log.Println(">>>>>>>>")
+	}
+	// log.Printf("entering %+v with mem %+v\n", curPath, sharedMem[curCoord])
+
 	if curCoord == f.EndCoord() {
 		pathsFromTheStartToEnd = append(pathsFromTheStartToEnd, PathInfo{curPath.visited.Clone()})
-		log.Printf("got to end. visited %+v . will return %+v\n", curPath.visited, pathsFromTheStartToEnd)
+		log.Printf("got to end. cur len is %d\n", curPath.visited.Cardinality())
+		CheckAndPrintMax(curPath.visited.Cardinality())
 		// i guess return only from current to end?
 		// and on non terminal first time, return copy with self added?
 		return
@@ -70,13 +88,18 @@ func DFSScenicPaths(f Field, curPath PathEnd,
 				suffix := PathInfo{
 					Visited: path.Visited.Difference(curPath.visited).Clone(),
 				}
+				// log.Printf(">> from path \n%+v make suffix \n%+v\n\n", path, suffix)
 				suffixesFromCurToEnd = append(suffixesFromCurToEnd, suffix)
 			}
 
 			pathsFromTheStartToEnd = append(pathsFromTheStartToEnd, pathsToEndThrough...)
+
+			if len(pathsToEndThrough) != 0 {
+				// log.Printf("setting mem for %+v to %+v", curCoord, suffixesFromCurToEnd)
+				sharedMem[curCoord] = suffixesFromCurToEnd
+			}
 		}
 
-		sharedMem[curCoord] = suffixesFromCurToEnd
 		return
 	} else {
 		// have visited this point before, due to dfs all possible paths to end should already be known
@@ -95,8 +118,11 @@ func DFSScenicPaths(f Field, curPath PathEnd,
 				fromCurPrefixToEnd := thisPrefix.Clone()
 				fromCurPrefixToEnd.Union(fromCurToEnd)
 				pathsFromTheStartToEnd = append(pathsFromTheStartToEnd, PathInfo{fromCurPrefixToEnd})
+				log.Printf("additional path to end of len %d\n", fromCurPrefixToEnd.Cardinality())
+				CheckAndPrintMax(fromCurPrefixToEnd.Cardinality())
 			}
 		}
+		log.Printf("having second visit into %+v.\n", curPath)
 		
 		return
 	}
@@ -116,7 +142,7 @@ func RunAllScenicPaths(f Field) (result []PathEnd) {
 
 		if curCheckedPath.end == f.EndCoord() {
 			result = append(result, curCheckedPath)
-			log.Printf("found end path of len %d . %+v", curCheckedPath.visited.Cardinality(), curCheckedPath)
+			// log.Printf("found end path of len %d . %+v", curCheckedPath.visited.Cardinality(), curCheckedPath)
 			continue
 		}