day23, example second

day23/paths.go

@@ -27,19 +27,94 @@ func ExtendPath(p PathEnd, f Field) (nextPaths []PathEnd) {
 	return
 }
 
+// info on path from start to end
+type PathInfo struct {
+	Visited mapset.Set[Coord]
+}
+
+func RunDFSTingy(f Field) []PathInfo {
+	initialPath := PathEnd{
+		end: Coord{Row: 0, Col: f.StartCol}, visited: mapset.NewSet[Coord](),
+	}
+	initialShared := make(map[Coord][]PathInfo)
+	
+	return DFSScenicPaths(f, initialPath, initialShared)
+}
+
+func DFSScenicPaths(f Field, curPath PathEnd,
+	sharedMem map[Coord][]PathInfo) (pathsFromTheStartToEnd []PathInfo) {
+
+	curCoord := curPath.end
+	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)
+		// i guess return only from current to end?
+		// and on non terminal first time, return copy with self added?
+		return
+	}
+
+	// now for non final point
+	knownPaths, visitedBefore := sharedMem[curCoord]
+
+	// NOTE but this only if we haven't visited this coord before!
+	
+	if !visitedBefore {
+		nextSteps := ExtendPath(curPath, f)
+		suffixesFromCurToEnd := make([]PathInfo, 0)
+		for _, nextPath := range nextSteps {
+			pathsToEndThrough := DFSScenicPaths(f, nextPath, sharedMem)
+			// i guess here deduct the prefix.
+
+			for _, path := range pathsToEndThrough {
+				// will contain this and further
+				suffix := PathInfo{
+					Visited: path.Visited.Difference(curPath.visited).Clone(),
+				}
+				suffixesFromCurToEnd = append(suffixesFromCurToEnd, suffix)
+			}
+
+			pathsFromTheStartToEnd = append(pathsFromTheStartToEnd, pathsToEndThrough...)
+		}
+
+		sharedMem[curCoord] = suffixesFromCurToEnd
+		return
+	} else {
+		// have visited this point before, due to dfs all possible paths to end should already be known
+		// so curPath.visited should contian a detour.
+		// need to figure out if this detour is compatible with any of the known paths to end
+		// from those create 'new' paths to end with that detour
+		// return those and add those to the shared mem
+		for _, knownPathToEnd := range knownPaths {
+			// those are all points through which this known path goes from current to end
+			// if our curPath
+			fromCurToEnd := knownPathToEnd.Visited
+			thisPrefix := curPath.visited
+
+			if thisPrefix.Intersect(fromCurToEnd).Cardinality() == 0 {
+				// then current prefix is compatible with this path.
+				fromCurPrefixToEnd := thisPrefix.Clone()
+				fromCurPrefixToEnd.Union(fromCurToEnd)
+				pathsFromTheStartToEnd = append(pathsFromTheStartToEnd, PathInfo{fromCurPrefixToEnd})
+			}
+		}
+		
+		return
+	}
+
+	panic("should not be reachable")
+}
+
 // return paths that end on End
 func RunAllScenicPaths(f Field) (result []PathEnd) {
 	pathsToFurther := []PathEnd{
 		{end: Coord{Row: 0, Col: f.StartCol}, visited: mapset.NewSet[Coord]()},
 	}
 
-	theEndCoord := Coord{Row: f.MaxRow, Col: f.EndCol}
-
 	for len(pathsToFurther) > 0 {
 		curCheckedPath := pathsToFurther[0]
 		pathsToFurther = pathsToFurther[1:]
 
-		if curCheckedPath.end == theEndCoord {
+		if curCheckedPath.end == f.EndCoord() {
 			result = append(result, curCheckedPath)
 			log.Printf("found end path of len %d . %+v", curCheckedPath.visited.Cardinality(), curCheckedPath)
 			continue