Bof , bof, je n'ai pas vraiment trouvé par moi-même.

Pour la première partie, j'ai utilisé un bête algo de remplissage de forme par propagation.

Pour la deuxième partie, je connaissais l'algorithme du lacets(Shoelace) pour en avoir entendu parlé récemment.
Je me doutais qu'il fallait retirer le périmètre du polygone.

Par contre, je ne trouvais pas malgré toutes mes investigations ,c'est en lisant le CR de Guillaume que j'ai découvert le théorème de Pick et son usage.

Mon implémtentation en Java.

package aoc2023;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
public class Aoc2023s18v2 {
 public static record Point(long x, long y) {
 public Point createRelative(Point dir, long factor) {
 return new Point(x + dir.x * factor, y + dir.y * factor);
 }
 public double dist(Point p) {
 long dx = p.x - x;
 long dy = p.y - y;
 return Math.sqrt(dx * dx + dy * dy);
 }
 }
 public static List<String> ORDERS = Arrays.asList("R", "D", "L", "U");
 public static Map<String, Point> DIRECTIONS = Map.of("U", new Point(0, -1), "R", new Point(1, 0), "D",
 new Point(0, 1), "L", new Point(-1, 0));
 public static Map<String, String> DIRECTIONS_TRAD = Map.of("3", "U", "0", "R", "1", "D", "2", "L");
 public static long calculateArea2(List<Point> listPoints) {
 Point[] points = listPoints.toArray(new Point[listPoints.size()]);
 double sum = 0.0;
 for (int i = 0; i < points.length - 1; ++i) {
 sum += (points[i].x * points[i + 1].y) - (points[i + 1].x * points[i].y);
 }
 long perimeter = dist(listPoints);
 long s1 = (long) (Math.abs(sum) - perimeter);
 s1 = s1 / 2;
 s1 += 1;
 return s1 + perimeter;
 }
 public static long dist(List<Point> poly) {
 double sum = 0;
 for (int x = 1; x < (poly.size()); x++) {
 sum += poly.get(x - 1).dist(poly.get(x));
 }
 sum += poly.get(poly.size() - 1).dist(poly.get(0));
 return (long) sum;
 }
 public static void main(String[] args) {
 try (Scanner in = new Scanner(Aoc2023s18v2.class.getResourceAsStream("res/t18.txt"))) {
 List<String> rows = new ArrayList<>();
 while (in.hasNext()) {
 String row = in.nextLine();
 rows.add(row);
 }
 List<Point> polyPoints = polygons2(rows);
 System.out.println("found=" + calculateArea2(polyPoints));
 }
 }
 private static List<Point> polygons2(List<String> rows) {
 List<Point> points = new ArrayList<>();
 Point p = new Point(0, 0);
 points.add(p);
 for (String row : rows) {
 String dirKey = row.split(" ")[2];
 long factor = Long.valueOf(dirKey.substring(2, 7), 16);
 String dir = "" + dirKey.charAt(dirKey.length() - 2);
 System.out.println(factor + " " + dir);
 Point np = p.createRelative(DIRECTIONS.get(DIRECTIONS_TRAD.get(dir)), factor);
 points.add(np);
 p = np;
 }
 return points;
 }
}