# Fill 4xN wall with 4×1 and 1×4 bricks

There is a wall with 4 x N dimensions and we have a brick with 4 x 1 dimension. We have to fill the wall with given brick and find out how may ways possible to fill that wall.

For example, if there is wall with N = 3, we have only one way to fill the wall, with three brick laid horizontally.

Where as with N = 4, there are two ways, one with putting four bricks horizontally, or 4 bricks vertically.

Actually, examples themselves give away the answer to the our problem. Let’s start small and build on top of it. What if N = 1 , then wall dimensions are 4 x 1, and there is only one way to fill that wall with brick of 4 x 1, which is to lay the brick horizontally.

What if N = 2, i.e. wall  is 4 x 2, , again, there is only one way  possible, put two bricks horizontally,we cannot put bricks vertical. Why?

Take N  = 3, i.e. wall with 4 x 3, only way we can fill the wall is to put three bricks horizontally, can’t use vertical brick.

What if N = 4, wall with 4 x 4 dimensions, in this scenario, we have two options, put four bricks horizontally or four bricks vertically, so there are two ways to fill a wall of 4 x 4 with brick of 4 x 1.

Now,  if number of ways to fill a wall of dimension 4 x N is f(N) then f(N) for values 1, 2 and 3 is as follows.

`f(1)=1, f(2)=1, f(3)=1`

We have two choices for each brick for wall of size greater than 4 X 3.  Either to keep brick vertically or  to keep brick horizontally.

If we keep brick vertically, we cover four units out of N units height of wall with each brick, require four vertical bricks to cover horizontally, so problem reduces to N-4 units.

If we keep brick horizontally, then it covers only 1 unit height of wall, hence we need to cover N-1 units of height further.
So, for N we have relationship as

`f(N) = f(N-1)  + f(N-4)`

We have the recurrence relation and the base conditions, let’s implement it.

### Fill wall with brick : recursive implementation

```int findWays(int n){
if(n == 0 || n == 1 || n == 2 || n == 3) return 1;
return findWays(n-1) + findWays(n-4);
}

int main(void) {
int N = 5;
int ways = findWays(N);
printf("%d", ways);
return 0;
}
```

Do you think this solution is optimized? Why do you think, it can be optimized and how? If you closely look at the recursion tree of implementation, you will see the problem. Some of the subproblems are solved repeatedly. Can we avoid solving them again and again?  Yes, that’s called memoization.

Well, this problem can be solved using dynamic programming, because two properties hold : First, optimal solution to subproblem gives solution to original problem. Second, overlapping subproblems.

Dynamic programming approach would be to fill a table bottom up where table [N] will be the solution.  table[0] = table[1] = table[2] = table[3] = 1 as discussed above.

Now from N = 4, we can fill the table bottom up as

`table[N] = table[N-1] + table[N-4]`

### Fill wall with brick : dynamic programming implementation

```int find_ways(int n, int table[]){
int i;
for(i = 4; i&lt;= n; i++){
table[i] = table[i-1] + table[i-4];
}
}

int main(void) {
int N =5;
int table[N+1];
table[0] = 1;
table[1] = 1;
table[2] = 1;
table[3] = 1;
find_ways(N, table);
printf("%d", table[N]);
return 0;
}
```

Complexity of dynamic programming approach is O (N) with space complexity of O(N).

Please share if there is something wrong or missing. If you are willing to share your knowledge and help thousands of learners across the world, please reach out to us on communications@algorithmsandme.com

# Scheduling weighted jobs

Suppose we have been give n jobs j1, j2,j3…jn with their start time s1,s2,… sn and finish time f1,f2, f3…fn. There is a value vi associated with each job. Problem is scheduling weighted jobs such all jobs are compatible and we get maximum value. Two jobs are said to be compatible, if there execution time do not overlap.

For example, we have four jobs as shown below:

In above figure maximum value can be achieved by scheduling job 1 and job 4 which is value of 250. Notice that there one more schedule with compatible jobs (Job1, Job2 and Job 3), however, value we get by that schedule is only 170 which is less than what we got in earlier schedule.

## Scheduling weighted jobs : Line of thoughts

There is strong urge to use greedy algorithm here, and problems is very similar to Interval Scheduling Algorithm. However, greedy algorithm works for this problem when value of all jobs is equal. Since value of jobs is different here, greedy algorithm fails.

Let’s consider brute force solution. First of all, sort all jobs based on finish time in increasing order. Now, for each job, decide if including it in schedule gives us maximum value or excluding it will give us maximum value. When we include a job, check if it is compatible with other jobs which are included in schedule. To determine compatibility quickly, we pre-calculate an array, called P such that

``p(j)` = largest index `i` < `j` such that job i is compatible with j.`

For jth job or interval to be compatible with ith interval, start time of jth interval or job should be greater than end time of ith interval or job.

For example: p(8) = 5, p(7) = 3, p(2) = 0.

Now, let’s say OPT(j) represents the maximum value which we gain by adding jobs from 1 to j. As mentioned above, there are two cases:

Case 1: OPT selects job j. In this case we can not use incompatible jobs `{p(j) + 1, p(j) + 2, …, j – 1}` and must include optimal solution to problem consisting of remaining compatible jobs` 1, 2, …, p(j)`.

Case 2: OPT does not select job j. – must include optimal solution to problem consisting of remaining compatible jobs 1, 2, …, j-1

For case 1, we already have P[j] calculated. With P[j] already prepared, we know that we don’t have to check any job later than P[j] as all of them will be conflicting with current job. Recursive formula for calculating maximum value for n jobs will be:

```OPT( j) = 0 if j = 0
max { vj + OPT( p(j) ), OPT(j-1)} otherwise```

## Scheduling weighted jobs : Recursive solution

```package com.company;

import java.util.Arrays;

/**
* Created by sangar on 4.5.18.
*/
public class ScheduleWeightedJobs {

public static int optimalScheduling(Job[] jobs, int[] nonConflictJobs, int j){
if(j == -1){
return 0;
}

return Integer.max(optimalScheduling(jobs, nonConflictJobs, nonConflictJobs[j]) + jobs[j].getValue(),
optimalScheduling(jobs, nonConflictJobs, j-1));
}

public static void main(String[] args) {

Job[] jobs = new Job[4];
jobs[0] = new Job(1, 3, 50);
jobs[1] = new Job(3, 5, 20);
jobs[2] = new Job(6, 9, 100);
jobs[3] = new Job(3, 12, 200);

Arrays.sort(jobs, (o1, o2) -> o1.getEndTime() - o2.getEndTime());

int[] nonConflictingJobs = new int[jobs.length];

for (int j = 0; j < jobs.length; j++) {
nonConflictingJobs[j] = -1;
for(int i = j-1; i >= 0; i--) {
if(jobs[i].getEndTime() <= jobs[j].getStartTime()) {
nonConflictingJobs[j] = i;
break;
}
}
}

int maxValue = optimalScheduling(jobs,nonConflictingJobs, jobs.length-1);

System.out.println(maxValue);
}
}
```

This recursive algorithm has exponential complexity as there are lot of subproblems which are calculated repeatedly. For example,

Recursive execution tree for above problem would like

If we revisit the problems there are two properties of this problem : First it is optimal substructure, which means, optimal solution to subproblem leads to optimal solution to bigger problem. Second, there are overlapping subproblems. From figure, we can see that there are subproblems which are being re-calculated. Typical way to avoid this repetition is to store solutions to subproblem, this method is called memoization. This is kind of a cache where results of subproblems are stored and looked into whenever required.

This is typical case of dynamic programming application.

## scheduling weighted job : Dynamic programming implementation

```package com.company;

import java.util.Arrays;

/**
* Created by sangar on 4.5.18.
*/
public class ScheduleWeightedJobs {

public static int optimalSchedulingDP(Job[] jobs, int[] nonConflictJobs){
int[] optimalValue = new int[jobs.length];

optimalValue[0] = jobs[0].getValue();

for(int i = 1; i < jobs.length; i++){
optimalValue[i] = Integer.max(optimalValue[nonConflictJobs[i]] + jobs[i].getValue(),
optimalValue[i-1]);
}
return optimalValue[jobs.length-1];
}

public static void main(String[] args) {

Job[] jobs = new Job[4];
jobs[0] = new Job(1, 3, 50);
jobs[1] = new Job(3, 5, 20);
jobs[2] = new Job(6, 9, 100);
jobs[3] = new Job(3, 12, 200);

Arrays.sort(jobs, (o1, o2) -> o1.getEndTime() - o2.getEndTime());

int[] nonConflictingJobs = new int[jobs.length];

for (int j = 0; j < jobs.length; j++) {
nonConflictingJobs[j] = -1;
for(int i = j-1; i >= 0; i--) {
if(jobs[i].getEndTime() <= jobs[j].getStartTime()) {
nonConflictingJobs[j] = i;
break;
}
}
}

int maxValue = optimalSchedulingDP(jobs,nonConflictingJobs);

System.out.println(maxValue);
}
}
```

Run time complexity of dynamic programming approach is `O(n2)`. Sorting takes `O(n log n)` and calculation of maximum value takes `O(n2)`.
If we have pre-sorted input based on finish time, then this approach takes only O(n). Note that we need additional O(n) space for storing results of subproblems.

How about finding the solution itself, means to find which jobs are actually give us optimal value? This requires some post processing. Algorithm is as follows

```Find-solution(j) :
if (j = 0) output nothing
else if (vj + Table[P(j)] > Table[j-1]) print j
Find-Solution(p(j))
else Find-Solution(j-1)```

Please share if there is something wrong or missing. If you are interested in contributing to algorithms and me, please drop a mail

# Box stacking problem

Consider, we have been given 3-Dimensional boxes. Each box has width, depth and height (wi, di, hi). Box stacking problem is to stack these boxes in such a way that we achieve maximum height. There is one condition which is attached to it : A box can be placed on top of another only if both it’s base dimensions width and depth are less than box on which it stacked on. There is no restriction on height, a tall box can be placed on a short box.

With conditions in place, with given n boxes, we are actually, we are building a pyramid of boxes with maximum height.

This problem is closely related to longest increasing subsequence.

## Recurrence relation for box stacking problem

Solution involves understanding of rotation aspects of the boxes. To avoid this aspect affect our solution, we list down all rotations of boxes as individual boxes. Therefore, for each box there are three representations. For example, for a box with dimensions a,b,c such that a>b>c

```representation 1 : ;
representation 2 : ;
representation 3 :
```

Without losing generalization, we can avoid representation where wi < di. Now that we have three representations for each box, our input space increases to 3XN and solution will be using these 3N boxes. There is another catch here. This solution works only when there are multiple instances of each box and we can use two different orientations of same box while fetching maximum height.

### Finding the sort order

Another problem is these boxes which are given to us are not ordered in any form. However, to stack boxes, we need to consider them in some order. As height does not affect stacking order, we can ignore it. Now, we have to consider only two dimensions.

Let’s say, we order boxes on base area in decreasing order. How does it work? Consider two boxes with different base areas. It is impossible for a box with larger base area to be stacked on top of a box with smaller base area. There are only two dimensions, so at least one must be larger than corresponding dimension smaller base area box. Therefore, if a box within our sequence can’t be placed on top, no box with a greater area can be placed on top either.

Let H(i) be height of stack of boxes 1,2,3,4…i. Modeling recurrent relation for H(i), put box i on a box j such that wi < wj and di < dj and H(j) is maximum for all j less than i.

`H(i) = max(H(i), H(j) for all j < i such that wi < wj && di < dj ) + hi`

Finally,output will be max of all H[i].

## Box stacking problem using dynamic programming implementation

```#include <iostream>
#include <algorithm>
using namespace std;

typedef struct box {
int width;
int depth;
int height;
} Box;

bool boxComparator(Box b1, Box b2) {
return ( b1.depth * b1.width > b2.depth * b2.width );
}

int findMaxHeightBoxStack(Box boxes[], int n)
{
int H[n];
for(int i=0; i<n; i++){
H[i] = boxes[i].height;
}
for(int i=1; i<n; i++){
for( int j=i-1; j>=0; j--){
if(boxes[j].width > boxes[i].width
&& boxes[j].depth > boxes[i].depth
&& H[j] + boxes[i].height){
H[i] = H[j] + boxes[i].height;
}
}
}

int maxHeight = 0 ;
for(int i=0; i<n; i++){
if(maxHeight < H[i]){
maxHeight = H[i];
}
}
return maxHeight;
}

int boxStacking(Box boxes[], int n)
{

Box orientations[3*n]; //for rotations
int index = 0;
for(int i=0; i<n; i++){
orientations[index] = boxes[i]; // first one as such
index++;

orientations[index].height = boxes[i].width;
orientations[index].width = max( boxes[i].height, boxes[i].depth) ;
orientations[index].depth = min( boxes[i].height, boxes[i].depth);

index++;
orientations[index].height = boxes[i].depth;
orientations[index].width = max( boxes[i].height, boxes[i].width) ;
orientations[index].depth = min( boxes[i].height, boxes[i].width) ;
index++;
}
n = 3*n;

sort(orientations, orientations+n, boxComparator);
return findMaxHeightBoxStack( orientations, n);
}

// Driver program
int main()
{
Box boxes[] = { {4, 6, 7}, {1, 2, 3}, {4, 5, 6}, {10, 12, 32} };
int n = sizeof(boxes)/sizeof(boxes[0]);
cout << "Maximum height is " << boxStacking(boxes, n);
return 0;
}
```

Implementation is quite simple, we need one dimension array H[]. These boxes are already sorted by area in decreasing order.

Complexity of algorithm to find maximum height in box stacking problem is O(n2) and space complexity is O(n).

This problem can be extended by putting boxes with K dimensions instead of 3 dimensions. Then also, approach would be the same only number of orientations will change.

Please share if there is something is wrong or missing. If you want to contribute to algorithms and me, please contact us, we would love to hear from you.

Reference : https://people.cs.clemson.edu/~bcdean/dp_practice/dp_5.swf