CodinGame: Let's Go To The Cinema - algorithm

Question

It made already some months, I try to resolve the codingame "Let's Go To The Cinema" of the CodinGame platform, a problem of mid-level difficulty, but I can't still figure out the solution around.
The codingame lays on three concepts of recursion, simulation and stack and consist to fill a cinema where several groups want to sit.
The statement of the problem is as it follows :
There is a cinema with maxRow * maxColumn seats (all rows having same number of seats).
n groups of people are arriving in order and trying to sit down. For each group, you get as input the numPersons number of peoples it consists of, and the row and seat their ticket is issued for. (Meaning they purchased the seats from ( row , seat ) to ( row , seat + numPersons - 1), these seats included.) The same seat might have been sold several times!
You have to simulate and output how many groups and how many persons could sit on their original appointed seat.
If a group cannot sit to its place because it is already occupied, they try to find another place using a seat finding method:
The group sits ONLY if ALL of them can sit next to each other.
They try to shift together: left by 1, right by 1, left by 2, right by 2, etc.
If unsuccessful in the row, then try 1 row towards the front, then by 1 row to back, 2 rows to front, etc.
In each row use the same seat-finding procedure (starting at the same seat position).
If they tried every possible places but still without success:
They adapt to the situation and split into two subgroups of same size (the first subgroup shall be bigger, if the size of the group was odd.).
Now the first subgroup tries to sit on the original row seat position using the same seat-finding procedure as above.
As the group size is now smaller, they might succeed this time.
If they don't succeed, they keep splitting the subgroupsize by another half, and continue trying, BEFORE the original another half subgroup gets the chance to try.
Note: Latest when the subgroup size reaches 1 person, it will always succeed to find a place.
After the whole original group got seated, the next group arrives, and so on.
You have to output two numbers:
groupSuccess is the number of groups, who could sit instantly in their original places. (If a split subgroup can sit later on the original place, that does not count towards this counter.)
personSuccess is the number of individuals, who could find a place on their original group ticket. A person shall be counted as successful, no matter after how many iterations (s)he found the place, if and only if the seat is any of the places appointed to the original group: ( row , seat ) to ( row , seat + numPersons - 1).
In first place, I created a "checkPlaces" function which checks if places at row parameter and comprised between column and column + numPersons - 1 are occupied :
public static boolean checkPlaces(int numPersons, int row, int column) {
for(int i = column; i < column + numPersons - 1; i++) {
if(cinema[row][i] == 1) {
return false;
}
}
return true;
}
I create another function "analyzeRow" where I check in calling "checkPlaces" function several times if original reserved places are available and if not I check consecutively
in shifting from 1, 2, ..., n column to the left and to right if the group can sit elsewhere on the row.
public static boolean analyzeRow(int numPersons, int row, int column, int maxRow, int maxColumn) {
if(checkPlaces(numPersons, row, column)) {
for(int i = column; i < column + numPersons - 1; i++) {
cinema[row][i] = 1;
}
return true;
}
else {
for(int j = 1; j < maxColumn; j++) {
if(j < column) {
int col1 = shiftLeftColumn(column, j);
if(checkPlaces(numPersons, row, col1)) {
for(int i = column; i < column + numPersons - 1; i++) {
cinema[row][i] = 1;
}
return true;
}
}
if(j < maxColumn - column) {
int col2 = shiftRightColumn(column, j);
if(checkPlaces(numPersons, row, col2)) {
for(int i = column; i < column + numPersons - 1; i++) {
cinema[row][i] = 1;
}
return true;
}
}
}
}
return false;
}
A third function "checkGrid" has for purpose to check the entire cinema in changing row
when analyzeRow sends false on a particular row in shifting from 1, 2, ..., n to front and to back until borders of the cinema are reached out.
public static boolean checkGrid(int numPersons, int row, int column, int maxRow, int maxColumn) {
if(!analyzeRow(numPersons, row, column, maxRow, maxColumn)) {
for(int l = 1; l < maxRow; l++) {
if(l < maxRow - row) {
int row1 = moveFrontRow(row, l);
analyzeRow(numPersons, row1, column, maxRow, maxColumn);
}
if(l < row) {
int row2 = moveBackRow(row, l);
analyzeRow(numPersons, row2, column, maxRow, maxColumn);
}
}
}
return true;
}
I also created several functions to shift column or row to left, right, front, back :
public static int shiftLeftColumn(int column, int j) {
int columnReturn = column - j;
return columnReturn;
}
public static int shiftRightColumn(int column, int j) {
int columnReturn = column + j;
return columnReturn;
}
public static int moveFrontRow(int row, int i) {
int rowReturn = row + i;
return rowReturn;
}
public static int moveBackRow(int row, int i) {
int rowReturn = row - i;
return rowReturn;
}
However, I have the feeling to have understood the idea, however I have difficulties to bring my code until the end and I'm not totally sure how I must do to take account the "split groups" part of the exercize, as the statement advice to use the "stack" concept, but I would rather use a binary tree that I create at the beginning of my main function with a static function :
TreeNode root = TreeNode.buildTree(numPersons);
Given that the exercize ask to split the group of people in two parts and then examine a first group and divide again to examine the two split groups issued of this first group,
before to examine the second.
It seems like leafs of a tree.
public class TreeNode {
int value;
TreeNode left;
TreeNode right;
public TreeNode(int value) {
this.value = value;
}
public TreeNode(int value, TreeNode left, TreeNode right) {
this.value = value;
this.left = left;
this.right = right;
}
public static TreeNode buildTree(int numPersons) {
while(numPersons > 1) {
if(numPersons % 2 == 0) {
TreeNode A = new TreeNode(numPersons, buildTree(numPersons/2), buildTree(numPersons/2));
return A;
}
else {
TreeNode B = new TreeNode(numPersons, buildTree((numPersons / 2) + 1), buildTree(numPersons / 2));
return B;
}
}
return new TreeNode(numPersons, null, null);
}
}
It made a long time I think on this, but I can't find how to finish and I would like to know if the way of thinking is the good or if I'm totally aside of the plate concerning the resolution of this exercize and I failed to see some algorithmic subtlety.
Thanks in advance to who could guide me.