From 0a8f6242ab7491fcb4d0620d3848c24b6fcb647c Mon Sep 17 00:00:00 2001
From: Jack Halford <jack@crans.org>
Date: Sun, 11 Sep 2016 01:48:15 +0200
Subject: [PATCH] blobs down to 500ms, validate 400ms in this branch

---
 fillit/includes/fillit.h     |   9 ++-
 fillit/src/fillit_blobs.c    |  46 ++++++++++++---
 fillit/src/fillit_legacy.c   | 110 +++++++++++++++++------------------
 fillit/src/fillit_solver.c   |  20 +++++--
 fillit/src/fillit_validate.c | 108 ++++++++++++++++++++++++++++++++++
 fillit/src/fillit_waste.c    |  50 ++++++++++++----
 6 files changed, 259 insertions(+), 84 deletions(-)
 create mode 100644 fillit/src/fillit_validate.c

diff --git a/fillit/includes/fillit.h b/fillit/includes/fillit.h
index 7a581273..001a6ae5 100644
--- a/fillit/includes/fillit.h
+++ b/fillit/includes/fillit.h
@@ -36,11 +36,16 @@ int		ft_solved(char **board);
 
 int		ft_check_blobs(char **board, t_list **amap, t_list *lblob, t_list *lttmn, int space);
 int		ft_get_blobs(char **board, t_list **amap, t_list *lttmn, int space);
+int		ft_fit_blob(char **board, t_list **amap, t_list *blob, t_list *lttmn, int space);
 
-t_list	*ft_empty_around(char **board, t_list **amap, int size, int i);
-t_list	*ft_empty_here(char **board, t_list **amap, int size, int i);
+t_list	*ft_empty_around(char **board, int size, int i);
+t_list	*ft_empty_here(char **board, int size, int i);
+int		ft_empty_around2(char **board, int size, int i);
+int		ft_empty_here2(char **board, int size, int i);
 
 void	ft_map_delttmn(t_list **amap, int anchor, int pos[4][2], int size);
 void	ft_map_addttmn(t_list **amap, int anchor, int pos[4][2], int size);
 
+void	ft_board_replace(char **board, char a, char b);
+int		ft_validate_waste(char **board, t_list **amap, t_list *lttmn, int space);
 #endif
diff --git a/fillit/src/fillit_blobs.c b/fillit/src/fillit_blobs.c
index 6d145918..f703372b 100644
--- a/fillit/src/fillit_blobs.c
+++ b/fillit/src/fillit_blobs.c
@@ -45,31 +45,59 @@ int		ft_get_blobs(char **board, t_list **amap, t_list *lttmn, int space)
 	t_list	*new_map;
 	int		sup_space = 0;
 	int		size;
+	int		blob_size;
 	int		i;
 
 	if (!lttmn)
 		return (ft_solved(board));
 	size = ft_strlen(*board);
-	new_map = ft_lstmap(*amap, &ft_id);
+	/* new_map = ft_lstmap(*amap, &ft_id); */
+	new_map = *amap;
 	while (new_map)
 	{
 		i = *(int *)(new_map)->content;
-		blob = ft_empty_here(board, &new_map, size, i);
-		ft_board_remove(board, '*');
-		if (ft_lstsize(blob) / 4 <= 1)
+		/* ft_show_board(board); */
+		/* ft_lst_print(new_map, &ft_putnbr); */
+
+		blob = ft_empty_here(board, size, i);
+		if (!blob)
 		{
-			space -= ft_lstsize(blob) % 4;
-			ft_lst_delsub(amap, blob, &ft_diff, &ft_lst_cfree);
+			new_map = new_map->next;
+			continue ;
 		}
-		else
-			sup_space -= ft_lstsize(blob) % 4;
-		if (ft_lstsize(blob) / 4 == 1)
+		new_map = new_map->next;
+		blob_size = ft_lstsize(blob);
+		if (blob_size / 4 == 0)
 		{
+			space -= blob_size % 4;
+			/* ft_putendl("delsub"); */
+			/* ft_lst_print(*amap, &ft_putnbr); */
+			ft_lst_delsub(amap, blob, &ft_diff, &ft_lst_cfree);
+			/* ft_lst_print(blob, &ft_putnbr); */
+			/* ft_lst_print(*amap, &ft_putnbr); */
+			new_map = *amap;
+			/* ft_debug(); */
+			if (space + sup_space < 0)
+			{
+				ft_board_remove(board, '*');
+				return (0);
+			}
+		}
+		else if (blob_size / 4 == 1)
+		{
+			space -= blob_size % 4;
+			ft_lst_delsub(amap, blob, &ft_diff, &ft_lst_cfree);
+			new_map = *amap;
 			if (ft_fit_blob(board, amap, blob, lttmn, space))
+			{
+				ft_board_remove(board, '*');
 				return (1);
+			}
 			else
 				space -= 4;
 		}
+		else
+			sup_space -= blob_size % 4;
 		if (space + sup_space < 0)
 		{
 			ft_board_remove(board, '*');
diff --git a/fillit/src/fillit_legacy.c b/fillit/src/fillit_legacy.c
index 3aea5476..9ac49f6d 100644
--- a/fillit/src/fillit_legacy.c
+++ b/fillit/src/fillit_legacy.c
@@ -1,58 +1,61 @@
-/* void	ft_grow_board(char **board) */
-/* { */
-/* 	int	i; */
-/* 	int	size; */
+/*
+void	ft_grow_board(char **board)
+{
+	int	i;
+	int	size;
 
-/* 	size = ft_strlen(*board); */
-/* 	i = 0; */
-/* 	while (++i <= size) */
-/* 	{ */
-/* 		board[i][size] = '.'; */
-/* 		board[size][i] = '.'; */
-/* 	} */
-/* } */
+	size = ft_strlen(*board);
+	i = 0;
+	while (++i <= size)
+	{
+		board[i][size] = '.';
+		board[size][i] = '.';
+	}
+}
 
-/* void	ft_shrink_board(char **board) */
-/* { */
-/* 	int	i; */
-/* 	int	size; */
+void	ft_shrink_board(char **board)
+{
+	int	i;
+	int	size;
 
-/* 	size = ft_strlen(*board); */
-/* 	i = -1; */
-/* 	while (++i < size) */
-/* 	{ */
-/* 		board[i][size - 1] = '\0'; */
-/* 		board[size - 1][i] = '\0'; */
-/* 	} */
-/* } */
+	size = ft_strlen(*board);
+	i = -1;
+	while (++i < size)
+	{
+		board[i][size - 1] = '\0';
+		board[size - 1][i] = '\0';
+	}
+}
 
-/* int		ft_test_fit(char **board, t_ttmn block, int i, int j) */
-/* { */
-/* 	size_t	k; */
-/* 	int		new_size; */
-/* 	int		size; */
-/* 	int		x; */
-/* 	int		y; */
+int		ft_test_fit(char **board, t_ttmn block, int i, int j)
+{
+	size_t	k;
+	int		new_size;
+	int		size;
+	int		x;
+	int		y;
 
-/* 	size = ft_strlen(*board); */
-/* 	new_size = size; */
-/* 	k = -1; */
-/* 	while (++k < 4) */
-/* 	{ */
-/* 		x = (int)j + block.pos[k][1]; */
-/* 		y = (int)i + block.pos[k][0]; */
-/* 		if (x < 0 || x < 0) */
-/* 			return (0); */
-/* 		if (x > size - 1 || y > size - 1) */
-/* 		{ */
-/* 			new_size = MAX(new_size, MAX(x + 1, y + 1)); */
-/* 			continue ; */
-/* 		} */
-/* 		if (board[y][x] != '.' && board[y][x] != '*') */
-/* 			return (0); */
-/* 	} */
-/* 	return (0); */
-/* } */
+	size = ft_strlen(*board);
+	new_size = size;
+	k = -1;
+	while (++k < 4)
+	{
+		x = (int)j + block.pos[k][1];
+		y = (int)i + block.pos[k][0];
+		if (x < 0 || x < 0)
+			return (0);
+		if (x > size - 1 || y > size - 1)
+		{
+			new_size = MAX(new_size, MAX(x + 1, y + 1));
+			continue ;
+		}
+		if (board[y][x] != '.' && board[y][x] != '*')
+			return (0);
+	}
+	return (0);
+}
+
+*/
 
 /* int		ft_check_blobs(char **board, t_list **amap, t_list *lblob, t_list *lttmn, int space) */
 /* { */
@@ -60,7 +63,6 @@
 /* 	t_list	*new_map; */
 /* 	int		size; */
 
-/* 	/1* ft_putendl("at start of check_blobs"); *1/ */
 /* 	if (!lttmn) */
 /* 		return (ft_solved(board)); */
 /* 	if (((t_ttmn *)lttmn->content)->placed) */
@@ -68,17 +70,11 @@
 /* 	fflush(stdout); */
 /* 	if (!lblob) */
 /* 	{ */
-/* 		/1* printf("calling solver, no more blobs\n"); *1/ */
-/* 		/1* fflush(stdout); *1/ */
-/* 		/1* new_map = ft_lstmap(*amap, &ft_id); *1/ */
 /* 		return (ft_solver(board, amap, lttmn, space)); */
 /* 	} */
 /* 	size = ft_strlen(*board); */
 /* 	blob = *(t_list **)lblob->content; */
 
-/* 	/1* ft_show_board(board); *1/ */
-/* 	/1* ft_lst_print(*amap, &ft_putnbr); *1/ */
-/* 	/1* ft_lst_print2(lblob, &ft_putnbr); *1/ */
 /* 	if (ft_lstsize(blob) / 4 == 1) */
 /* 	{ */
 /* 		/1* new_map = ft_lstmap(*amap, &ft_id); *1/ */
diff --git a/fillit/src/fillit_solver.c b/fillit/src/fillit_solver.c
index d3176700..22b07481 100644
--- a/fillit/src/fillit_solver.c
+++ b/fillit/src/fillit_solver.c
@@ -2,6 +2,7 @@
 
 int		ft_solved(char **board)
 {
+	ft_board_remove(board, '*');
 	g_sol = ft_copy_board(board);
 	return (1);
 }
@@ -12,7 +13,6 @@ int		ft_solver(char **board, t_list **amap, t_list *lttmn, int space)
 	int		i;
 	t_ttmn	*ttmn;
 	t_list	*map;
-	t_list	*valmap;
 
 	if (!lttmn)
 		return (ft_solved(board));
@@ -21,6 +21,8 @@ int		ft_solver(char **board, t_list **amap, t_list *lttmn, int space)
 		return (ft_solver(board, amap, lttmn->next, space));
 	size = ft_strlen(*board);
 	map = *amap;
+	/* ft_show_board(board); */
+	/* ft_lst_print(*amap, &ft_putnbr); */
 	while (map)
 	{
 		i = *(int *)map->content;
@@ -29,10 +31,20 @@ int		ft_solver(char **board, t_list **amap, t_list *lttmn, int space)
 			map = map->next;
 			continue ;
 		}
-		valmap = ft_lstmap(*amap, &ft_id);
-		ft_map_delttmn(&valmap, i, ttmn->pos, size);
-		if (ft_get_blobs(board, &valmap, lttmn->next, space))
+
+		t_list	*n_map = ft_lstmap(*amap, &ft_id);
+		ft_map_delttmn(&n_map, i, ttmn->pos, size);
+		if (ft_get_blobs(board, &n_map, lttmn->next, space))
 			return (1);
+
+		/* ft_map_delttmn(amap, i, ttmn->pos, size); */
+		/* if (ft_validate_waste(board, &n_map, lttmn->next, space)) */
+		/* 	return (1); */
+		if (ft_solver(board, amap, lttmn->next, space))
+			return (1);
+		/* ft_map_addttmn(amap, i, ttmn->pos, size); */
+		/* map = *amap; */
+
 		ft_board_remove(board, ttmn->id);
 		map = map->next;
 	}
diff --git a/fillit/src/fillit_validate.c b/fillit/src/fillit_validate.c
new file mode 100644
index 00000000..02d5adfb
--- /dev/null
+++ b/fillit/src/fillit_validate.c
@@ -0,0 +1,108 @@
+#include "fillit.h"
+
+int		ft_fit_blob2(char **board, t_list **amap, t_list *lttmn, int i, int blob_size, int space)
+{
+	t_ttmn	*ttmn;
+	t_list	*list;
+	int		y;
+	int		l;
+	int		size;
+	int		n;
+
+	/* printf("going to fit any at %i,%i\n", i, j); */
+	/* fflush(stdout); */
+	/* ft_show_board(board); */
+	y = i;
+	n = blob_size;
+	size = ft_strlen(*board);
+	while (y < size * size)
+	{
+		if (board[y / size][y % size] == '*')
+		{
+			n--;
+			l = -1;
+			/* printf("0 trying all at %i\n", y); */
+			/* fflush(stdout); */
+			list = lttmn;
+			while (list)
+			{
+				ttmn = (t_ttmn *)list->content;
+				if (ttmn->placed)
+				{
+					list = list->next;
+					continue ;
+				}
+				if (ft_board_add(board, *ttmn, i))
+				{
+					list = list->next;
+					continue ;
+				}
+				ttmn->placed = 1;
+				if (ft_solver(board, amap, lttmn, space))
+					return (1);
+				ttmn->placed = 0;
+				ft_board_remove(board, ttmn->id);
+				list = list->next;
+			}
+			/* printf("failed at %i\n", y); */
+			/* fflush(stdout); */
+		}
+		y++;
+	}
+	return (0);
+}
+
+
+
+int		ft_validate_waste(char **board, t_list **amap, t_list *lttmn, int space)
+{
+	t_ttmn	*ttmn;
+	int	waste;
+	int	y;
+	t_list *blob;
+	int	blob_size;
+	int	size;
+
+	if (!lttmn)
+		return (ft_solved(board));
+	ttmn = (t_ttmn *)lttmn->content;
+	if (ttmn->placed)
+		return (ft_solver(board, amap, lttmn->next, space));
+	waste = 0;
+	size = ft_strlen(*board);
+	y = -1;
+	/* ft_show_board(board); */
+	while (++y < size * size)
+	{
+		if (board[y / size][y % size] != '.')
+			continue ;
+		/* blob = ft_empty_here(board, size, y); */
+		/* blob_size = ft_lstsize(blob); */
+		blob_size = ft_empty_here2(board, size, y);
+		/* ft_board_replace(board, '*', '^') */
+		/* printf("found blob=%i at %i\n", blob_size, y); */
+		/* fflush(stdout); */
+		/* ft_show_board(board); */
+		waste += blob_size % 4;
+		if (waste > size * size - 4 * g_ttmn)
+		{
+			ft_board_remove(board, '*');
+			return (0);
+		}
+		if (blob_size / 4 == 1)
+		{
+			ft_board_remove(board, '*');
+			blob = ft_empty_here(board, size, y);
+			if (ft_fit_blob2(board, amap, lttmn, y, blob_size, space))
+				return (1);
+		}
+		waste += (blob_size / 4 == 1) ? 4 : 0;
+		if (waste > size * size - 4 * g_ttmn)
+		{
+			ft_board_remove(board, '*');
+			return (0);
+		}
+	}
+	ft_board_remove(board, '*');
+	return (ft_solver(board, amap, lttmn, space));
+}
diff --git a/fillit/src/fillit_waste.c b/fillit/src/fillit_waste.c
index d0886e67..c9477f18 100644
--- a/fillit/src/fillit_waste.c
+++ b/fillit/src/fillit_waste.c
@@ -1,6 +1,6 @@
 #include "fillit.h"
 
-t_list	*ft_empty_here(char **board, t_list **amap, int size, int i)
+t_list	*ft_empty_here(char **board, int size, int i)
 {
 	t_list	*blob;
 
@@ -8,12 +8,8 @@ t_list	*ft_empty_here(char **board, t_list **amap, int size, int i)
 	if (board[i / size][i % size] == '.')
 	{
 		board[i / size][i % size] = '*';
-		/* ft_lst_print(*amap, &ft_putnbr); */
-		/* printf("removing %i from map\n", i); */
-		/* ft_lst_print(*amap, &ft_putnbr); */
-		ft_lst_delif(amap, &i, &ft_diff, &ft_lst_cfree);
-		blob = ft_empty_around(board, amap, size, i);
-		ft_lst_sorted_insert(&blob, ft_lstnew(&i, sizeof(int)), &ft_diff);
+		blob = ft_empty_around(board, size, i);
+		ft_lstadd(&blob, ft_lstnew(&i, sizeof(int)));
 	}
 	/* printf("list at %i: ", i); */
 	/* fflush(stdout); */
@@ -21,15 +17,45 @@ t_list	*ft_empty_here(char **board, t_list **amap, int size, int i)
 	return (blob);
 }
 
-t_list	*ft_empty_around(char **board, t_list **amap, int size, int i)
+t_list	*ft_empty_around(char **board, int size, int i)
 {
 	t_list	*add;
 
 	add = NULL;
-	i % size < size - 1 ? ft_lst_sorted_merge(&add, ft_empty_here(board, amap, size, i + 1), &ft_diff) : 0;
-	i / size > 0 ? ft_lst_sorted_merge(&add, ft_empty_here(board, amap, size, i - size), &ft_diff) : 0;
-	i % size > 0 ? ft_lst_sorted_merge(&add, ft_empty_here(board, amap, size, i - 1), &ft_diff) : 0;
-	i / size < size - 1 ? ft_lst_sorted_merge(&add, ft_empty_here(board, amap, size, i + size), &ft_diff) : 0;
+	i % size < size - 1 ? ft_lsteadd(&add, ft_empty_here(board, size, i + 1)) : 0;
+	i / size > 0 ? ft_lsteadd(&add, ft_empty_here(board, size, i - size)) : 0;
+	i % size > 0 ? ft_lsteadd(&add, ft_empty_here(board, size, i - 1)) : 0;
+	i / size < size - 1 ? ft_lsteadd(&add, ft_empty_here(board, size, i + size)) : 0;
 	/* ft_lst_print(add, &ft_putnbr); */
 	return (add);
 }
+
+int		ft_empty_here2(char **board, int size, int i)
+{
+	int		n;
+
+	n = 0;
+	if (board[i / size][i % size] == '.')
+	{
+		board[i / size][i % size] = '*';
+		n++;
+		n += ft_empty_around2(board, size, i);
+	}
+	/* printf("list at %i: ", i); */
+	/* fflush(stdout); */
+	/* ft_lst_print(blob, &ft_putnbr); */
+	return (n);
+}
+
+int		ft_empty_around2(char **board, int size, int i)
+{
+	int		n;
+
+	n = 0;
+	n += i % size < size - 1 ? ft_empty_here2(board, size, i + 1) : 0;
+	n += i / size > 0 ? ft_empty_here2(board, size, i - size) : 0;
+	n += i % size > 0 ? ft_empty_here2(board, size, i - 1) : 0;
+	n += i / size < size - 1 ? ft_empty_here2(board, size, i + size) : 0;
+	/* ft_lst_print(add, &ft_putnbr); */
+	return (n);
+}