Largest Area Axis-Aligned Rectangle Inside Convex Polygon [duplicate] - c++
Given an NxN binary matrix (containing only 0's or 1's), how can we go about finding largest rectangle containing all 0's?
Example:
I
0 0 0 0 1 0
0 0 1 0 0 1
II->0 0 0 0 0 0
1 0 0 0 0 0
0 0 0 0 0 1 <--IV
0 0 1 0 0 0
IV
For the above example, it is a 6×6 binary matrix. the return value in this case will be Cell 1:(2, 1) and Cell 2:(4, 4). The resulting sub-matrix can be square or rectangular. The return value can also be the size of the largest sub-matrix of all 0's, in this example 3 × 4.
Here's a solution based on the "Largest Rectangle in a Histogram" problem suggested by #j_random_hacker in the comments:
[Algorithm] works by iterating through
rows from top to bottom, for each row
solving this problem, where the
"bars" in the "histogram" consist of
all unbroken upward trails of zeros
that start at the current row (a
column has height 0 if it has a 1 in
the current row).
The input matrix mat may be an arbitrary iterable e.g., a file or a network stream. Only one row is required to be available at a time.
#!/usr/bin/env python
from collections import namedtuple
from operator import mul
Info = namedtuple('Info', 'start height')
def max_size(mat, value=0):
"""Find height, width of the largest rectangle containing all `value`'s."""
it = iter(mat)
hist = [(el==value) for el in next(it, [])]
max_size = max_rectangle_size(hist)
for row in it:
hist = [(1+h) if el == value else 0 for h, el in zip(hist, row)]
max_size = max(max_size, max_rectangle_size(hist), key=area)
return max_size
def max_rectangle_size(histogram):
"""Find height, width of the largest rectangle that fits entirely under
the histogram.
"""
stack = []
top = lambda: stack[-1]
max_size = (0, 0) # height, width of the largest rectangle
pos = 0 # current position in the histogram
for pos, height in enumerate(histogram):
start = pos # position where rectangle starts
while True:
if not stack or height > top().height:
stack.append(Info(start, height)) # push
elif stack and height < top().height:
max_size = max(max_size, (top().height, (pos - top().start)),
key=area)
start, _ = stack.pop()
continue
break # height == top().height goes here
pos += 1
for start, height in stack:
max_size = max(max_size, (height, (pos - start)), key=area)
return max_size
def area(size):
return reduce(mul, size)
The solution is O(N), where N is the number of elements in a matrix. It requires O(ncols) additional memory, where ncols is the number of columns in a matrix.
Latest version with tests is at https://gist.github.com/776423
Please take a look at Maximize the rectangular area under Histogram and then continue reading the solution below.
Traverse the matrix once and store the following;
For x=1 to N and y=1 to N
F[x][y] = 1 + F[x][y-1] if A[x][y] is 0 , else 0
Then for each row for x=N to 1
We have F[x] -> array with heights of the histograms with base at x.
Use O(N) algorithm to find the largest area of rectangle in this histogram = H[x]
From all areas computed, report the largest.
Time complexity is O(N*N) = O(N²) (for an NxN binary matrix)
Example:
Initial array F[x][y] array
0 0 0 0 1 0 1 1 1 1 0 1
0 0 1 0 0 1 2 2 0 2 1 0
0 0 0 0 0 0 3 3 1 3 2 1
1 0 0 0 0 0 0 4 2 4 3 2
0 0 0 0 0 1 1 5 3 5 4 0
0 0 1 0 0 0 2 6 0 6 5 1
For x = N to 1
H[6] = 2 6 0 6 5 1 -> 10 (5*2)
H[5] = 1 5 3 5 4 0 -> 12 (3*4)
H[4] = 0 4 2 4 3 2 -> 10 (2*5)
H[3] = 3 3 1 3 2 1 -> 6 (3*2)
H[2] = 2 2 0 2 1 0 -> 4 (2*2)
H[1] = 1 1 1 1 0 1 -> 4 (1*4)
The largest area is thus H[5] = 12
Here is a Python3 solution, which returns the position in addition to the area of the largest rectangle:
#!/usr/bin/env python3
import numpy
s = '''0 0 0 0 1 0
0 0 1 0 0 1
0 0 0 0 0 0
1 0 0 0 0 0
0 0 0 0 0 1
0 0 1 0 0 0'''
nrows = 6
ncols = 6
skip = 1
area_max = (0, [])
a = numpy.fromstring(s, dtype=int, sep=' ').reshape(nrows, ncols)
w = numpy.zeros(dtype=int, shape=a.shape)
h = numpy.zeros(dtype=int, shape=a.shape)
for r in range(nrows):
for c in range(ncols):
if a[r][c] == skip:
continue
if r == 0:
h[r][c] = 1
else:
h[r][c] = h[r-1][c]+1
if c == 0:
w[r][c] = 1
else:
w[r][c] = w[r][c-1]+1
minw = w[r][c]
for dh in range(h[r][c]):
minw = min(minw, w[r-dh][c])
area = (dh+1)*minw
if area > area_max[0]:
area_max = (area, [(r-dh, c-minw+1, r, c)])
print('area', area_max[0])
for t in area_max[1]:
print('Cell 1:({}, {}) and Cell 2:({}, {})'.format(*t))
Output:
area 12
Cell 1:(2, 1) and Cell 2:(4, 4)
Here is J.F. Sebastians method translated into C#:
private Vector2 MaxRectSize(int[] histogram) {
Vector2 maxSize = Vector2.zero;
int maxArea = 0;
Stack<Vector2> stack = new Stack<Vector2>();
int x = 0;
for (x = 0; x < histogram.Length; x++) {
int start = x;
int height = histogram[x];
while (true) {
if (stack.Count == 0 || height > stack.Peek().y) {
stack.Push(new Vector2(start, height));
} else if(height < stack.Peek().y) {
int tempArea = (int)(stack.Peek().y * (x - stack.Peek().x));
if(tempArea > maxArea) {
maxSize = new Vector2(stack.Peek().y, (x - stack.Peek().x));
maxArea = tempArea;
}
Vector2 popped = stack.Pop();
start = (int)popped.x;
continue;
}
break;
}
}
foreach (Vector2 data in stack) {
int tempArea = (int)(data.y * (x - data.x));
if(tempArea > maxArea) {
maxSize = new Vector2(data.y, (x - data.x));
maxArea = tempArea;
}
}
return maxSize;
}
public Vector2 GetMaximumFreeSpace() {
// STEP 1:
// build a seed histogram using the first row of grid points
// example: [true, true, false, true] = [1,1,0,1]
int[] hist = new int[gridSizeY];
for (int y = 0; y < gridSizeY; y++) {
if(!invalidPoints[0, y]) {
hist[y] = 1;
}
}
// STEP 2:
// get a starting max area from the seed histogram we created above.
// using the example from above, this value would be [1, 1], as the only valid area is a single point.
// another example for [0,0,0,1,0,0] would be [1, 3], because the largest area of contiguous free space is 3.
// Note that at this step, the heigh fo the found rectangle will always be 1 because we are operating on
// a single row of data.
Vector2 maxSize = MaxRectSize(hist);
int maxArea = (int)(maxSize.x * maxSize.y);
// STEP 3:
// build histograms for each additional row, re-testing for new possible max rectangluar areas
for (int x = 1; x < gridSizeX; x++) {
// build a new histogram for this row. the values of this row are
// 0 if the current grid point is occupied; otherwise, it is 1 + the value
// of the previously found historgram value for the previous position.
// What this does is effectly keep track of the height of continous avilable spaces.
// EXAMPLE:
// Given the following grid data (where 1 means occupied, and 0 means free; for clairty):
// INPUT: OUTPUT:
// 1.) [0,0,1,0] = [1,1,0,1]
// 2.) [0,0,1,0] = [2,2,0,2]
// 3.) [1,1,0,1] = [0,0,1,0]
//
// As such, you'll notice position 1,0 (row 1, column 0) is 2, because this is the height of contiguous
// free space.
for (int y = 0; y < gridSizeY; y++) {
if(!invalidPoints[x, y]) {
hist[y] = 1 + hist[y];
} else {
hist[y] = 0;
}
}
// find the maximum size of the current histogram. If it happens to be larger
// that the currently recorded max size, then it is the new max size.
Vector2 maxSizeTemp = MaxRectSize(hist);
int tempArea = (int)(maxSizeTemp.x * maxSizeTemp.y);
if (tempArea > maxArea) {
maxSize = maxSizeTemp;
maxArea = tempArea;
}
}
// at this point, we know the max size
return maxSize;
}
A few things to note about this:
This version is meant for use with the Unity API. You can easily make this more generic by replacing instances of Vector2 with KeyValuePair. Vector2 is only used for a convenient way to store two values.
invalidPoints[] is an array of bool, where true means the grid point is "in use", and false means it is not.
Solution with space complexity O(columns) [Can be modified to O(rows) also] and time complexity O(rows*columns)
public int maximalRectangle(char[][] matrix) {
int m = matrix.length;
if (m == 0)
return 0;
int n = matrix[0].length;
int maxArea = 0;
int[] aux = new int[n];
for (int i = 0; i < n; i++) {
aux[i] = 0;
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
aux[j] = matrix[i][j] - '0' + aux[j];
maxArea = Math.max(maxArea, maxAreaHist(aux));
}
}
return maxArea;
}
public int maxAreaHist(int[] heights) {
int n = heights.length;
Stack<Integer> stack = new Stack<Integer>();
stack.push(0);
int maxRect = heights[0];
int top = 0;
int leftSideArea = 0;
int rightSideArea = heights[0];
for (int i = 1; i < n; i++) {
if (stack.isEmpty() || heights[i] >= heights[stack.peek()]) {
stack.push(i);
} else {
while (!stack.isEmpty() && heights[stack.peek()] > heights[i]) {
top = stack.pop();
rightSideArea = heights[top] * (i - top);
leftSideArea = 0;
if (!stack.isEmpty()) {
leftSideArea = heights[top] * (top - stack.peek() - 1);
} else {
leftSideArea = heights[top] * top;
}
maxRect = Math.max(maxRect, leftSideArea + rightSideArea);
}
stack.push(i);
}
}
while (!stack.isEmpty()) {
top = stack.pop();
rightSideArea = heights[top] * (n - top);
leftSideArea = 0;
if (!stack.isEmpty()) {
leftSideArea = heights[top] * (top - stack.peek() - 1);
} else {
leftSideArea = heights[top] * top;
}
maxRect = Math.max(maxRect, leftSideArea + rightSideArea);
}
return maxRect;
}
But I get Time Limite exceeded excpetion when I try this on LeetCode. Is there any less complex solution?
I propose a O(nxn) method.
First, you can list all the maximum empty rectangles. Empty means that it covers only 0s. A maximum empty rectangle is such that it cannot be extended in a direction without covering (at least) one 1.
A paper presenting a O(nxn) algorithm to create such a list can be found at www.ulg.ac.be/telecom/rectangles as well as source code (not optimized). There is no need to store the list, it is sufficient to call a callback function each time a rectangle is found by the algorithm, and to store only the largest one (or choose another criterion if you want).
Note that a proof exists (see the paper) that the number of largest empty rectangles is bounded by the number of pixels of the image (nxn in this case).
Therefore, selecting the optimal rectangle can be done in O(nxn), and the overall method is also O(nxn).
In practice, this method is very fast, and is used for realtime video stream analysis.
Here is a version of jfs' solution, which also delivers the position of the largest rectangle:
from collections import namedtuple
from operator import mul
Info = namedtuple('Info', 'start height')
def max_rect(mat, value=0):
"""returns (height, width, left_column, bottom_row) of the largest rectangle
containing all `value`'s.
Example:
[[0, 0, 0, 0, 0, 0, 0, 0, 3, 2],
[0, 4, 0, 2, 4, 0, 0, 1, 0, 0],
[1, 0, 1, 0, 0, 0, 3, 0, 0, 4],
[0, 0, 0, 0, 4, 2, 0, 0, 0, 0],
[0, 0, 0, 2, 0, 0, 0, 0, 0, 0],
[4, 3, 0, 0, 1, 2, 0, 0, 0, 0],
[3, 0, 0, 0, 2, 0, 0, 0, 0, 4],
[0, 0, 0, 1, 0, 3, 2, 4, 3, 2],
[0, 3, 0, 0, 0, 2, 0, 1, 0, 0]]
gives: (3, 4, 6, 5)
"""
it = iter(mat)
hist = [(el==value) for el in next(it, [])]
max_rect = max_rectangle_size(hist) + (0,)
for irow,row in enumerate(it):
hist = [(1+h) if el == value else 0 for h, el in zip(hist, row)]
max_rect = max(max_rect, max_rectangle_size(hist) + (irow+1,), key=area)
# irow+1, because we already used one row for initializing max_rect
return max_rect
def max_rectangle_size(histogram):
stack = []
top = lambda: stack[-1]
max_size = (0, 0, 0) # height, width and start position of the largest rectangle
pos = 0 # current position in the histogram
for pos, height in enumerate(histogram):
start = pos # position where rectangle starts
while True:
if not stack or height > top().height:
stack.append(Info(start, height)) # push
elif stack and height < top().height:
max_size = max(max_size, (top().height, (pos - top().start), top().start), key=area)
start, _ = stack.pop()
continue
break # height == top().height goes here
pos += 1
for start, height in stack:
max_size = max(max_size, (height, (pos - start), start), key=area)
return max_size
def area(size):
return size[0] * size[1]
To be complete, here's the C# version which outputs the rectangle coordinates.
It's based on dmarra's answer but without any other dependencies.
There's only the function bool GetPixel(int x, int y), which returns true when a pixel is set at the coordinates x,y.
public struct INTRECT
{
public int Left, Right, Top, Bottom;
public INTRECT(int aLeft, int aTop, int aRight, int aBottom)
{
Left = aLeft;
Top = aTop;
Right = aRight;
Bottom = aBottom;
}
public int Width { get { return (Right - Left + 1); } }
public int Height { get { return (Bottom - Top + 1); } }
public bool IsEmpty { get { return Left == 0 && Right == 0 && Top == 0 && Bottom == 0; } }
public static bool operator ==(INTRECT lhs, INTRECT rhs)
{
return lhs.Left == rhs.Left && lhs.Top == rhs.Top && lhs.Right == rhs.Right && lhs.Bottom == rhs.Bottom;
}
public static bool operator !=(INTRECT lhs, INTRECT rhs)
{
return !(lhs == rhs);
}
public override bool Equals(Object obj)
{
return obj is INTRECT && this == (INTRECT)obj;
}
public bool Equals(INTRECT obj)
{
return this == obj;
}
public override int GetHashCode()
{
return Left.GetHashCode() ^ Right.GetHashCode() ^ Top.GetHashCode() ^ Bottom.GetHashCode();
}
}
public INTRECT GetMaximumFreeRectangle()
{
int XEnd = 0;
int YStart = 0;
int MaxRectTop = 0;
INTRECT MaxRect = new INTRECT();
// STEP 1:
// build a seed histogram using the first row of grid points
// example: [true, true, false, true] = [1,1,0,1]
int[] hist = new int[Height];
for (int y = 0; y < Height; y++)
{
if (!GetPixel(0, y))
{
hist[y] = 1;
}
}
// STEP 2:
// get a starting max area from the seed histogram we created above.
// using the example from above, this value would be [1, 1], as the only valid area is a single point.
// another example for [0,0,0,1,0,0] would be [1, 3], because the largest area of contiguous free space is 3.
// Note that at this step, the heigh fo the found rectangle will always be 1 because we are operating on
// a single row of data.
Tuple<int, int> maxSize = MaxRectSize(hist, out YStart);
int maxArea = (int)(maxSize.Item1 * maxSize.Item2);
MaxRectTop = YStart;
// STEP 3:
// build histograms for each additional row, re-testing for new possible max rectangluar areas
for (int x = 1; x < Width; x++)
{
// build a new histogram for this row. the values of this row are
// 0 if the current grid point is occupied; otherwise, it is 1 + the value
// of the previously found historgram value for the previous position.
// What this does is effectly keep track of the height of continous avilable spaces.
// EXAMPLE:
// Given the following grid data (where 1 means occupied, and 0 means free; for clairty):
// INPUT: OUTPUT:
// 1.) [0,0,1,0] = [1,1,0,1]
// 2.) [0,0,1,0] = [2,2,0,2]
// 3.) [1,1,0,1] = [0,0,1,0]
//
// As such, you'll notice position 1,0 (row 1, column 0) is 2, because this is the height of contiguous
// free space.
for (int y = 0; y < Height; y++)
{
if (!GetPixel(x, y))
{
hist[y]++;
}
else
{
hist[y] = 0;
}
}
// find the maximum size of the current histogram. If it happens to be larger
// that the currently recorded max size, then it is the new max size.
Tuple<int, int> maxSizeTemp = MaxRectSize(hist, out YStart);
int tempArea = (int)(maxSizeTemp.Item1 * maxSizeTemp.Item2);
if (tempArea > maxArea)
{
maxSize = maxSizeTemp;
maxArea = tempArea;
MaxRectTop = YStart;
XEnd = x;
}
}
MaxRect.Left = XEnd - maxSize.Item1 + 1;
MaxRect.Top = MaxRectTop;
MaxRect.Right = XEnd;
MaxRect.Bottom = MaxRectTop + maxSize.Item2 - 1;
// at this point, we know the max size
return MaxRect;
}
private Tuple<int, int> MaxRectSize(int[] histogram, out int YStart)
{
Tuple<int, int> maxSize = new Tuple<int, int>(0, 0);
int maxArea = 0;
Stack<Tuple<int, int>> stack = new Stack<Tuple<int, int>>();
int x = 0;
YStart = 0;
for (x = 0; x < histogram.Length; x++)
{
int start = x;
int height = histogram[x];
while (true)
{
if (stack.Count == 0 || height > stack.Peek().Item2)
{
stack.Push(new Tuple<int, int>(start, height));
}
else if (height < stack.Peek().Item2)
{
int tempArea = (int)(stack.Peek().Item2 * (x - stack.Peek().Item1));
if (tempArea > maxArea)
{
YStart = stack.Peek().Item1;
maxSize = new Tuple<int, int>(stack.Peek().Item2, (x - stack.Peek().Item1));
maxArea = tempArea;
}
Tuple<int, int> popped = stack.Pop();
start = (int)popped.Item1;
continue;
}
break;
}
}
foreach (Tuple<int, int> data in stack)
{
int tempArea = (int)(data.Item2 * (x - data.Item1));
if (tempArea > maxArea)
{
YStart = data.Item1;
maxSize = new Tuple<int, int>(data.Item2, (x - data.Item1));
maxArea = tempArea;
}
}
return maxSize;
}
An appropriate algorithm can be found within Algorithm for finding the largest inscribed rectangle in polygon (2019).
I implemented it in python:
import largestinteriorrectangle as lir
import numpy as np
grid = np.array([[0, 0, 0, 0, 1, 0],
[0, 0, 1, 0, 0, 1],
[0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 1],
[0, 0, 1, 0, 0, 0]],
"bool")
grid = ~grid
lir.lir(grid) # [1, 2, 4, 3]
the result comes as x, y, width, height
Related
What can cause a Stack Overflow in this function?
I was writing a casual minesweeper, and wanted to realize a method to track an empty cells at the field, so I had wrote this algorothm: //bigger array was taken to prevent out of range,when init mines and numbers /*creating mines in 1 to FIELD_NUM range(0 -non-active field,1-active field) * { * 0 0 0 0 0 0 * 0 1 1 1 1 0 * 0 1 1 1 1 0 * 0 1 1 1 1 0 * 0 1 1 1 1 0 * 0 0 0 0 0 0 * } */ //view is a display vect,x and y are mouse interp. coord. void MinerField::OpenCell(vector<vector<int>>& view, int x, int y) { if (gridLogic[x][y] == 9) { for (int i = 1; i <= FIELD_NUM; i++) for (int j = 1; j <= FIELD_NUM; j++) { view[i][j] = gridLogic[i][j]; } } else { if (gridLogic[x][y] == 0) OpenVoidCells(view, x, y); else view[x][y] = gridLogic[x][y]; } } And the second func,that is causing Stack-Overflow: void MinerField::OpenVoidCells(vector<vector<int>>& view, int x, int y) { if (x >= (FIELD_NUM) || y >= (FIELD_NUM))//check out of range return; if (gridLogic[x][y] == 10 || gridLogic[x][y]==11 ||gridLogic[x][y]==-1) return; if ((gridLogic[x][y] <= 8) && (gridLogic[x][y] >= 1)) { view[x][y] = gridLogic[x][y]; return; } view[x][y] = gridLogic[x][y]; OpenVoidCells(view,x + 1, y); //North; OpenVoidCells(view,x - 1, y); //South OpenVoidCells(view,x, y + 1); //East OpenVoidCells(view, x, y - 1); //West OpenVoidCells(view, x - 1, y - 1); //South-West OpenVoidCells(view, x + 1, y + 1); //North-East OpenVoidCells(view, x - 1, y + 1); //South-East OpenVoidCells(view, x + 1, y - 1); //North-West } gridLogic vector is MinerField local and have the same size as view. Run fails with FIELD_NUM=10. What can cause a stack overflow?
OpenVoidCells doesn't have anything to prevent visiting the same square over and over. It will go north, south, north, south, north, south ... forever, until you run out of stack. You need to keep track of visited squares and avoid re-checking them.
Fill color before or after recursive call (Flood Fill algorithm)
I was implementing a basic version of the flood fill algorithm when I ran into this doubt. When should you color the present cell (i.e. do image[sr][sc] = newColor) before the recursive calls or after the recursive calls? Why is there a difference between the two approaches? When the current cell is colored before the recursive calls works but if I change the order then it gives segmentation error. Here's the code: vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int newColor) { if(image.size()<=0 || image[sr][sc] == newColor) return image; int rows = image.size(),cols=image[sr].size(); int temp = image[sr][sc]; image[sr][sc] = newColor; //check up if((sr-1)>=0 && image[sr-1][sc] == temp){ image = floodFill(image,sr-1,sc,newColor); } //check left if((sc-1)>=0 && image[sr][sc-1] == temp){ image = floodFill(image,sr,sc-1,newColor); } //check right if((sc+1)<cols && image[sr][sc+1] == temp){ image = floodFill(image,sr,sc+1,newColor); } //check down if((sr+1)<rows && image[sr+1][sc] == temp){ image = floodFill(image,sr+1,sc,newColor); } //if i put the image[sr][sc] = newColor; here it give seg error return image; }
This code appears to modify image in-place by reference, so there's no need to return it -- in fact, it's a bad idea to do so. Writing the cell to the new color after the recursive call won't work because the child call's base case-related tests of image[sr+N][sc] == temp and image[sr][sc] == newColor will be wrong -- the parent call plans to color the cell but since it has't gotten around to it, it's revisited, giving an infinite loop as it spawns more child calls. Here's my suggestion in a runnable example you can adapt to your use case: #include <iostream> #include <vector> void floodFill( std::vector <std::vector<int> > &image, int r, int c, int newColor, int oldColor ) { if ( r < 0 || c < 0 || r >= (int)image.size() || c >= (int)image[r].size() || image[r][c] == newColor || image[r][c] != oldColor ) { return; } image[r][c] = newColor; floodFill(image, r - 1, c, newColor, oldColor); floodFill(image, r, c - 1, newColor, oldColor); floodFill(image, r, c + 1, newColor, oldColor); floodFill(image, r + 1, c, newColor, oldColor); } void printMatrix(std::vector<std::vector<int> > &img) { for (auto row : img) { for (int cell : row) { std::cout << cell << " "; } std::cout << "\n"; } } int main() { std::vector<std::vector<int> > img{ {0, 2, 2, 1, 1, 1,}, {0, 0, 0, 1, 0, 1,}, {1, 1, 0, 1, 0, 1,}, {0, 1, 0, 1, 1, 1,}, {1, 0, 0, 0, 0, 0,}, {0, 0, 0, 2, 1, 0,}, }; printMatrix(img); std::cout << "\n"; floodFill(img, 2, 2, 1, img[2][2]); printMatrix(img); return 0; } Output: 0 2 2 1 1 1 0 0 0 1 0 1 1 1 0 1 0 1 0 1 0 1 1 1 1 0 0 0 0 0 0 0 0 2 1 0 1 2 2 1 1 1 1 1 1 1 0 1 1 1 1 1 0 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 1 1 As you can see, you can remove a lot of repetition by making one base case check at the start of the recursive call. This adds an extra call relative to checking conditions in branches, but that's probably a premature optimization.
Initializing std::memset
I'm using std::memset to solve a LeetCode problem copied here. Currently, map_cherries has been initialized as: map_cherries[70][70][70] = {} ... std::memset(map_cherries, -1, sizeof(map_cherries)); Is there a way to set up dimensions and values of map_cherries at the same time, or maybe any better/alternative way to do that? Thank you! Problem Given a rows x cols matrix grid representing a field of cherries. Each cell in grid represents the number of cherries that you can collect. You have two robots that can collect cherries for you, Robot #1 is located at the top-left corner (0,0), and Robot #2 is located at the top-right corner (0, cols-1) of the grid. Return the maximum number of cherries collection using both robots by following the rules below: From a cell (i,j), robots can move to cell (i+1, j-1) , (i+1, j) or (i+1, j+1). When any robot is passing through a cell, It picks it up all cherries, and the cell becomes an empty cell (0). When both robots stay on the same cell, only one of them takes the cherries. Both robots cannot move outside of the grid at any moment. Both robots should reach the bottom row in the grid. Example 1: Input: grid = [[3,1,1],[2,5,1],[1,5,5],[2,1,1]] Output: 24 Explanation: Path of robot #1 and #2 are described in color green and blue respectively. Cherries taken by Robot #1, (3 + 2 + 5 + 2) = 12. Cherries taken by Robot #2, (1 + 5 + 5 + 1) = 12. Total of cherries: 12 + 12 = 24. Example 2: Input: grid = [[1,0,0,0,0,0,1],[2,0,0,0,0,3,0],[2,0,9,0,0,0,0],[0,3,0,5,4,0,0],[1,0,2,3,0,0,6]] Output: 28 Explanation: Path of robot #1 and #2 are described in color green and blue respectively. Cherries taken by Robot #1, (1 + 9 + 5 + 2) = 17. Cherries taken by Robot #2, (1 + 3 + 4 + 3) = 11. Total of cherries: 17 + 11 = 28. Constraints: rows == grid.length cols == grid[i].length 2 <= rows, cols <= 70 0 <= grid[i][j] <= 100 Attempt #include <cstdint> #include <vector> #include <cstring> struct Solution { int map_cherries[70][70][70] = {}; int cherryPickup(std::vector<std::vector<int>>& grid) { std::memset(map_cherries, -1, sizeof(map_cherries)); const std::size_t row_length = grid.size(); const std::size_t col_length = grid[0].size(); return depth_first_search(grid, row_length, col_length, 0, 0, col_length - 1); } private: int depth_first_search( std::vector<std::vector<int>>& grid, const std::size_t row_length, const std::size_t col_length, int row, int left_robot, int right_robot ) { if (row == row_length) { return 0; } if (map_cherries[row][left_robot][right_robot] != -1) { return map_cherries[row][left_robot][right_robot]; } int max_cherries = 0; for (int left = -1; left < 2; left++) { for (int right = -1; right < 2; right++) { const int curr_left_robot = left_robot + left; const int curr_right_robot = right_robot + right; if (curr_left_robot > -1 and curr_left_robot < col_length and curr_right_robot > -1 and curr_right_robot < col_length) { max_cherries = std::max(max_cherries, depth_first_search( grid, row_length, col_length, row + 1, curr_left_robot, curr_right_robot )); } } } int total_cherries = grid[row][left_robot]; if (left_robot != right_robot) { total_cherries += grid[row][right_robot]; } total_cherries += max_cherries; return map_cherries[row][left_robot][right_robot] = total_cherries; } }; Inputs [[3,1,1],[2,5,1],[1,5,5],[2,1,1]] [[1,0,0,3],[0,0,0,3],[0,0,3,3],[9,0,3,3]] [[1,10,0,3,86,40],[0,0,0,3,86,40],[0,0,3,3,86,40],[9,0,3,3,86,40], [1,0,40,3,86,40],[0,22,0,3,86,40],[99,0,3,3,86,40],[9,0,3,3,86,40]] Outputs 24 22 819 References Problem Discuss Solution
One way would be like this: auto map_cherries = std::vector(70, std::vector(70, std::vector(70, -1))); Only works starting from c++17.
Evenly distribute values into array
I have a fixed size boolean array of size 8. The default value of all elements in the array is false. There will be a number of truth values to fill between 1-8. I want to distribute the truth values as far away from one another as possible. I also wish to be able to randomize the configuration. In this scenario the array wraps around so position 7 is "next to" position 0 in the array. here are some examples for fill values. I didn't include all possibilities, but hopefully it gets my point across. 1: [1, 0, 0, 0, 0, 0, 0, 0] or [0, 1, 0, 0, 0, 0, 0, 0] 2: [1, 0, 0, 0, 1, 0, 0, 0] or [0, 1, 0, 0, 0, 1, 0, 0] 3: [1, 0, 0, 1, 0, 0, 1, 0] or [0, 1, 0, 0, 1, 0, 0, 1] 4: [1, 0, 1, 0, 1, 0, 1, 0] or [0, 1, 0, 1, 0, 1, 0, 1] 5: [1, 1, 0, 1, 1, 0, 1, 0] 6: [1, 1, 0, 1, 1, 1, 0, 1] 7: [1, 1, 1, 1, 1, 1, 1, 0] 8: [1, 1, 1, 1, 1, 1, 1, 1] The closest solution I have come up with so far hasn't quite produced the results I'm looking for... I seek to write it in c++ but here is a little pseudo-code of my algorithm so far... not quite working out how I wanted truths = randBetween(1, 8) values = [0,0,0,0,0,0,0,0] startPosition = randBetween(0, 7) //starting index distance = 4 for(i = 0; i < truths; i++) { pos = i + startPosition + (i * distance) values[pos % 8] = 1 } this is an example output from my current code. those marked with a star are incorrect. [0, 0, 0, 0, 1, 0, 0, 0] [0, 1, 0, 0, 1, 0, 0, 0]* [0, 1, 0, 0, 1, 0, 1, 0] [0, 1, 0, 1, 1, 0, 1, 0]* [1, 1, 0, 1, 1, 0, 1, 0] [1, 1, 0, 1, 1, 1, 1, 0]* [1, 1, 1, 1, 1, 1, 1, 0] [1, 1, 1, 1, 1, 1, 1, 1] I'm looking for a simple way to distribute the truth values evenly throughout the array without having to code for special cases.
Check this out: #include <cassert> #include <vector> #include <iostream> #include <iomanip> /** * Generate an even spaced pattern of ones * #param arr destination vector of ints * #param onescnt the requested number of ones */ static inline void gen(std::vector<int>& arr, size_t onescnt) { const size_t len = arr.size(); const size_t zeroscnt = len - onescnt; size_t ones = 1; size_t zeros = 1; for (size_t i = 0; i < len; ++i) { if (ones * zeroscnt < zeros * onescnt) { ones++; arr[i] = 1; } else { zeros++; arr[i] = 0; } } } static inline size_t count(const std::vector<int>& arr, int el) { size_t cnt = 0; for (size_t i = 0; i < arr.size(); ++i) { cnt += arr[i] == el; } return cnt; } static inline void gen_print(size_t len, size_t onescnt) { std::vector<int> arr(len); gen(arr, onescnt); std::cout << "gen_printf(" << std::setw(2) << len << ", " << std::setw(2) << onescnt << ") = {"; for (size_t i = 0; i < len; ++i) { std::cout << arr[i] << ","; } std::cout << "}\n"; assert(count(arr, 1) == onescnt); } int main() { for (int i = 0; i <= 8; ++i) { gen_print(8, i); } for (int i = 0; i <= 30; ++i) { gen_print(30, i); } return 0; } Generates: gen_printf( 8, 0) = {0,0,0,0,0,0,0,0,} gen_printf( 8, 1) = {0,0,0,0,0,0,0,1,} gen_printf( 8, 2) = {0,0,0,1,0,0,0,1,} gen_printf( 8, 3) = {0,1,0,0,1,0,0,1,} gen_printf( 8, 4) = {0,1,0,1,0,1,0,1,} gen_printf( 8, 5) = {1,0,1,1,0,1,0,1,} gen_printf( 8, 6) = {1,1,0,1,1,1,0,1,} gen_printf( 8, 7) = {1,1,1,1,1,1,0,1,} gen_printf( 8, 8) = {1,1,1,1,1,1,1,1,} gen_printf(30, 0) = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,} gen_printf(30, 1) = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,} gen_printf(30, 2) = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,} gen_printf(30, 3) = {0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,} gen_printf(30, 4) = {0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,} gen_printf(30, 5) = {0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,} gen_printf(30, 6) = {0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,} gen_printf(30, 7) = {0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,} gen_printf(30, 8) = {0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,} gen_printf(30, 9) = {0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,1,} gen_printf(30, 10) = {0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,} gen_printf(30, 11) = {0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,1,} gen_printf(30, 12) = {0,1,0,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,0,1,} gen_printf(30, 13) = {0,1,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,1,0,0,1,} gen_printf(30, 14) = {0,1,0,1,0,1,0,1,0,1,0,1,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,1,} gen_printf(30, 15) = {0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,} gen_printf(30, 16) = {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,} gen_printf(30, 17) = {1,0,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,0,1,0,1,} gen_printf(30, 18) = {1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,} gen_printf(30, 19) = {1,0,1,1,0,1,1,0,1,0,1,1,0,1,1,0,1,1,0,1,0,1,1,0,1,1,0,1,0,1,} gen_printf(30, 20) = {1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,} gen_printf(30, 21) = {1,1,0,1,1,0,1,1,0,1,1,1,0,1,1,0,1,1,0,1,1,1,0,1,1,0,1,1,0,1,} gen_printf(30, 22) = {1,1,0,1,1,1,0,1,1,1,0,1,1,0,1,1,1,0,1,1,1,0,1,1,1,0,1,1,0,1,} gen_printf(30, 23) = {1,1,1,0,1,1,1,0,1,1,1,0,1,1,1,1,0,1,1,1,0,1,1,1,0,1,1,1,0,1,} gen_printf(30, 24) = {1,1,1,0,1,1,1,1,0,1,1,1,1,0,1,1,1,1,0,1,1,1,1,0,1,1,1,1,0,1,} gen_printf(30, 25) = {1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0,1,} gen_printf(30, 26) = {1,1,1,1,1,1,0,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,1,1,1,1,0,1,} gen_printf(30, 27) = {1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,0,1,} gen_printf(30, 28) = {1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,} gen_printf(30, 29) = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,} gen_printf(30, 30) = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,} #edit - better evenly spaced pattern. Explanation: So let's take an array of 8 ints and we want to have 5 ones. The ideal ratio of (ones / zeros) in a sequence with 8 elements and 5 ones, well would be (5 / 3). We will never approach such ratio, but we can try. The idea is to loop through the array and remember the number of ones and zeros we have written in the array. If the ratio of (written ones / written zeros) is lower then the destination ratio (ones / zeros) we want to achieve, we need to put a one to the sequence. Otherwise we put zero in the sequence. The ratio changes and we make the decision next time. The idea is to pursue the ideal ratio of ones per zeros in each slice of the array.
A simple way to do this would be to round the ideal fractional positions. truths = randBetween(1, 8) values = [0,0,0,0,0,0,0,0] offset = randBetween(0, 8 * truths - 1) for(i = 0; i < truths; i++) { pos = (offset + (i * 8)) / truths values[pos % 8] = 1 }
This is an application of Bresenham's line-drawing algorithm. I use it not because it's fast on old hardware, but it places true values exactly. #include <iostream> #include <stdexcept> #include <string> #include <random> int main(int argc, char **argv) { try { // Read the argument. if(argc != 2) throw std::invalid_argument("one argument"); int dy = std::stoi(argv[1]); if(dy < 0 || dy > 8) throw std::out_of_range("[0..8]"); int values[8] = {0}; // https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm int dx = 8; int delta = 2 * dy - dx; // Balance the line. Permute it up later. for(int x = 0; x < dx; x++) { if(delta > 0) { values[x] = 1; delta -= 2 * dx; } delta += 2 * dy; } for(int x = 0; x < dx; x++) std::cout << (x ? ", " : "") << values[x]; std::cout << std::endl; // Rotate the number by a random amount. // I'm sure there is an easier way to do this. // https://stackoverflow.com/questions/7560114/random-number-c-in-some-range std::random_device rd; // obtain a random number from hardware std::mt19937 eng(rd()); // seed the generator std::uniform_int_distribution<> distr(0, dx - 1); int rotate = distr(eng); bool first = true; int x = rotate; do { std::cout << (first ? "" : ", ") << values[x]; first = false; x = (x + 1) % dx; } while(x != rotate); std::cout << std::endl; } catch(const std::exception &e) { std::cerr << "Something went wrong: " << e.what() << std::endl; return 1; } return 0; } Once you have an exact solution, rotate it by a random amount. 0, 1, 0, 0, 1, 0, 1, 0 1, 0, 0, 1, 0, 0, 1, 0
You need to calculate distance dynamically. One element is clear, that can reside at arbitrary location 2 elements is clear, too, distance needs to be 4. 4 elements need a distance of 2 8 elements a distance of 1 More difficult are numbers that don't divide the array: 3 requires a distance of 2.66. 5 requires a distance of 1.6 7 requires a distance of 0.875 Errm... In general, if you have a distance of X.Y, you will have to place some of the elements at distances of X and some at distances of X + 1. X is simple, it will be the result of an integer division: 8 / numberOfElements. The remainder will determine how often you will have to switch to X + 1: 8 % numberOfElements. For 3, this will result in 2, too, so you will have 1x distance of 2 and 2x distance of 3: [ 1 0 1 0 0 1 0 0 ] 2 3 3 (distance to very first 1) For 5, you'll get: 8/5 = 1, 8%5 = 3, so: 2x distance of 1, 3x distance of 2 [ 1 1 1 0 1 0 1 0 ] 1 1 2 2 2 For 7 you'll get: 8/7 = 1, 8%7 = 1, so: 7x distance of 1, 1x distance of 2 [ 1 1 1 1 1 1 1 0 ] 1 1 1 1 1 1 2 That will work for arbitrary array length L: L/n = minimum distance L%n = number of times to apply minimum distance L-L%n = number of times to apply minimum distance + 1 Mathematical metrics won't reveal any difference between first applying all smaller distances then all larger ones, human sense for aesthetics, though, might prefer if you alternate between larger and smaller as often as possible – or you apply the algorithm recursively (for larger array length), to get something like 2x2, 3x3, 2x2, 3x3 instead of 4x2 and 6x3.
How do you check if points within a grid are connected vertically/horizontally? (1 away from each other)
Let's just use 1 as there is a point, and 0 if nothing. For example, the grid: 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 1 1 1 1 1 would not be connected together, while 0 0 1 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 1 1 is. I feel as if using something like BFS would be horribly inefficient for something that should probably be fairly simple; is there any other option?
The best asymptotic complexity for this kind of problem comes from the union find algorithm using rank and path compression. Union find associates each new point with a group name that is either unique, taken from left or top neighbor, or unifies the groups (by making a link from one group to the other). In the end all parents of all initially unique groups point to same item, in which case the set is connected. Further reading with c++ source code Further reading for image processing #include "catch.hpp" #include <vector> template <typename T> T parent(std::vector<T> &links, T item) { if (item == 0) return item; while (links[(size_t)item - 1] != item) item = links[(size_t)item - 1]; // Should implement path compression return item; } template <typename T, int N, int M> bool is_connected(T(&array)[N][M]) { // Assumption is that the type T is large enough to hold N*M/2 distinct entries // Thus we can use/modify the array itself to record (roots) of distinct labels // Of course we could copy the array into a vector of type size_t std::vector<T> parents; for (auto j = 0; j < N; j++) { for (auto i = 0; i < M; i++) { T ¤t = array[j][i]; if (!current) continue; T left = i ? parent(parents, array[j][i - 1]) : 0; T above = j ? parent(parents, array[j - 1][i]) : 0; if (left == 0) { if (above) current = above; else parents.emplace_back(current = (T)(parents.size() + 1)); } else { // Todo: implement rank based selection of joining the sets current = left; if (above != 0 && above != left) parents[(size_t)above - 1] = left; } } } // Check that all intermediate disjoint sets have now a single root if (parents.size() == 0) return false; // is empty set connected or not? auto last_item = parents.back(); auto root = parent(parents, last_item); parents.pop_back(); for (auto &group : parents) { if (root != parent(parents, group)) return false; } return true; } SCENARIO("Is connected") { int arr[4][4] = { { 1, 0, 1, 0 }, { 1, 0, 1, 0 }, { 1, 0, 1, 0 }, { 1, 1, 1, 1 } }; auto foo = is_connected(arr); CHECK(foo == true); arr[3][1] = 0; CHECK(is_connected(arr) == false); }
BFS or DFS is indeed the proper solution. The rest is just a matter of taking advantage of properties of rectilinear grid (raster) for implementing such search algorithms in more efficient manner, preferably more efficient than a "straightforward" implementation. For example, some classic 4-way raster scanline flood-fill algorithm is a good approach for searching connected components in your grid (see the "Scanline fill" section).