what's the difference between these two lines of code in c++?
size_t (*B)[N] = new size_t[N][N]; and
size_t *B[N] = new size_t[N][N];
first one compiles correctly but with second line, g++ gives this error
matrixim.cpp:43:20: error: array must be initialized with a brace-enclosed initializer
43 | size_t *B[N] = new size_t[N][N];
size_t *B[N]
Here, B is an array of N pointers to size_t
size_t (*B)[N]
Here, B is a pointer to an array of N size_ts
Both of these constructs could be used to create something approximating a 2-dimensional array, but their layout in memory is very different.
size_t *B[N] would look something like this:
B +-------------+-------------+-----+-------------+
+--------+ | B[0][0] | B[0][1] | ... | B[0][N-1] |
| B[0] +--->+-------------+-------------+-----+-------------+
+--------+
| B[1] +--->+-------------+-------------+-----+-------------+
+--------+ | B[1][0] | B[1][1] | ... | B[1][N-1] |
| | +-------------+-------------+-----+-------------+
| ... |
| |
+--------+
| B[N-1] +--->+-------------+-------------+-----+-------------+
+--------+ | B[N-1][0] | B[N-1][1] | ... | B[N-1][N-1] |
+-------------+-------------+-----+-------------+
B is an array of N pointers to size_t, each of which points to the first element of an array of N size_t.
size_t (*B)[N] would look something like this:
B +---------------------------------------------------+
+----+ | B[0] |
| +--->+ +-------------+-------------+-----+-------------+ |
+----+ | | B[0][0] | B[0][1] | ... | B[0][N-1] | |
| +-------------+-------------+-----+-------------+ |
+---------------------------------------------------+
| B[1] |
| +-------------+-------------+-----+-------------+ |
| | B[1][0] | B[1][1] | ... | B[1][N-1] | |
| +-------------+-------------+-----+-------------+ |
+---------------------------------------------------+
| |
| ... |
| |
+---------------------------------------------------+
| B[N-1] |
| +-------------+-------------+-----+-------------+ |
| | B[N-1][0] | B[N-1][1] | ... | B[N-1][N-1] | |
| +-------------+-------------+-----+-------------+ |
+---------------------------------------------------+
Here, B is a pointer to the first element of an array of N arrays of N size_t.
Related
With a singly linked list, swapping non-adjacent cells can be described by the following operation, assuming '=>' means 'now links to':
Y => X->next
X => Y->next
BeforeY => X
BeforeX => Y
However, this operation does not work for swapping adjacent records, creating circular links, as X->next (say) will be Y.
Adjacent record swaps, assuming X is before Y, can be described by a separate set of operations:
X => Y->next
Y => X
BeforeX => Y
I can't seem to solve this set of operations as a subset of the previous set or common children of a parent set.
Is there a uniform, unconditional set of operations that describes a swap that works for both adjacent and non-adjacent records?
Here is some ASCII Art for the two scenarios.
Non-adjacent X and Y
X can come before or after Y in the list as long as there is at least one element between X and Y (so Ax and By could identify the same node when X comes before Y). The situation before:
Bx X Ax By Y Ay
+----+ +----+ +----+ +----+ +----+ +----+
| | | | | | | | | | | |
-->| |-->| |-->| |--...->| |-->| |-->| |-->
| | | | | | | | | | | |
+----+ +----+ +----+ +----+ +----+ +----+
The situation after:
Bx X Ax By Y Ay
+------------------------------+
| |
+------------------------------+ |
| | | |
+----+ | +----+ | +----+ +----+ | +----+ | +----+
| |-+ | |-+ | | | | +>| | +>| |
-->| #| | #| | |--...->| #| | #| | |-->
| | +>| | +>| | | |-+ | |-+ | |
+----+ | +----+ | +----+ +----+ | +----+ | +----+
| | | |
+------------------------------+ |
| |
+------------------------------+
The 4 'next' pointers marked with # are changed.
Before:
Bx->next = X
X->next = Ax
By->next = Y
Y->next = Ay
After:
Bx->next = Y
Y->next = Ax
By->next = X
X->next = Ay
Adjacent X and Y
Assume X immediately precedes Y. The situation before:
Bx X Ax
By Y Ay
+----+ +----+ +----+ +----+
| | | | | | | |
-->| |---->| |---->| |---->| |-->
| | | | | | | |
+----+ +----+ +----+ +----+
The situation after:
Bx X Ax
By Y Ay
+------------+
| |
+----+ | +----+ | +----+ +----+
| |-+ | | +>| | | |
-->| #| | #| | #| | |-->
| | +>| |-+ | |-+ +>| |
+----+ | +----+ | +----+ | | +----+
| | | |
+-------------------+ |
| |
+------------+
Before:
Bx->next = X
X->next = Ax = Y
By->next = Y
Y->next = Ay
After:
Bx->next = Y
Y->next = X # Different
By->next = Ay # Different
X->next = Ay
The result values in the pointers are different, as shown. This means that there isn't a single mapping that works for both the "non-adjacent X and Y" and the "adjacent X and Y" cases — the pointer twizzling must be different.
I have the following function(toy example, but good for demonstration):
// finds the iterator pointing to the start of n consectuve 47s or return values.end() if not found
auto find_n_47s(const int n, const std::vector<int>& values){
std::vector<bool> predicate_result;
predicate_result.reserve(values.size());
std::transform(values.begin(), values.end(), std::back_inserter(predicate_result), []
(const auto& val){return val==47; });
std::vector<bool> search_pattern(n, true);
auto it= std::search(predicate_result.begin(), predicate_result.end(),
search_pattern.begin(), search_pattern.end());
return values.begin() + std::distance(predicate_result.begin(), it);
}
I am looking for a nicer and more efficient way to accomplish the same thing.
My problems:
I can not use manual iteration + std::all_of(from current element to
n elements ahead) because it is too slow(in theory for every element
that I do up to n predicate applications).
My solution allocates memory and calculates predicate for every
element although we might find the result in the first 1% of the
elements.
Full code here: https://wandbox.org/permlink/rBVFS64IcOI6gKe6
As Cruz Jean pointed out you can use search_n:
https://wandbox.org/permlink/ENgEi5ZVPDx1D1GQ
The GCC implementation of search_n
https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/include/bits/stl_algo.h
does not check every element:
|---------|---------|---------|----------------|
| Find first occurence of n=7 consecutive 47 |
|---------|---------|---------|----------------|
| vector | step# | count | |
|---------|---------|---------|----------------|
| 47 | | | |
| 47 | | | |
| 47 | | | |
| 0 | 4 | 3 | |
| 47 | 3 | 3 | |
| 47 | 2 | 2 | |
| 47 | 1 | 1 | start |
| 47 | | | |
| 47 | | | |
| 0 | 5 | 0 | |
| 47 | | | |
| 0 | | | |
| 0 | | | |
| 47 | | | |
| 0 | | | |
| 47 | | | |
| 0 | 6 | 0 | |
| 0 | | | |
| 0 | | | |
| 0 | | | |
| 0 | | | |
| 47 | | | |
| 0 | | | |
| 0 | 7 | 0 | |
| 47 | | | |
| 47 | | | |
| 47 | | | |
| 47 | | | |
| 0 | | | |
| 0 | 9 | 1 | |
| 47 | 8 | 1 | |
| 47 | 15 | 7 | success |
| 47 | 14 | 6 | |
| 47 | 13 | 5 | |
| 47 | 12 | 4 | |
| 47 | 11 | 3 | |
| 47 | 10 | 2 | |
| 47 | | | |
| 0 | | | |
| 0 | | | |
| 47 | | | |
| 0 | | | |
| … | | | |
|---------|---------|---------|----------------|
All, my professor gave us the following loop for use in this weeks assignment:
char *ptr1, *ptr2;
char c;
ptr1 = &arr[0];
ptr2 = &arr[idx-1];
while(ptr1 < ptr2){
c = *ptr1;
*ptr1 = *ptr2;
*ptr2 = c;
ptr1++;
ptr2--;
}
Is this about the position of ptr1 vs. ptr2? The program reverses a c_str and works just fine, I just don't understand why.
Do you have a problem understanding any of the individual statements? If not, then seeing how it works is just a question of going through the steps.
The first three statements of the loop swap the character pointed by ptr1 and the one pointed by ptr2. Initially, ptr1 and ptr2 point to the first and last characters of the string. The second pass, they are pointing to the second and the second-last characters of the string, etc.
Initially:
+-----+-----+-----+-----+-----+-----+ +-----+
arr --> | a | b | c | d | e | NUL | c | ? |
+-----+-----+-----+-----+-----+-----+ +-----+
^ ^
| |
ptr1 ptr2
After c = *ptr1;:
+-----+-----+-----+-----+-----+-----+ +-----+
arr --> | a | b | c | d | e | NUL | c | a |
+-----+-----+-----+-----+-----+-----+ +-----+
^ ^
| |
ptr1 ptr2
After *ptr1 = *ptr2;:
+-----+-----+-----+-----+-----+-----+ +-----+
arr --> | e | b | c | d | e | NUL | c | a |
+-----+-----+-----+-----+-----+-----+ +-----+
^ ^
| |
ptr1 ptr2
After *ptr2 = c;:
+-----+-----+-----+-----+-----+-----+ +-----+
arr --> | e | b | c | d | a | NUL | c | a |
+-----+-----+-----+-----+-----+-----+ +-----+
^ ^
| |
ptr1 ptr2
After ptr1++; ptr2--;:
+-----+-----+-----+-----+-----+-----+ +-----+
arr --> | e | b | c | d | a | NUL | c | a |
+-----+-----+-----+-----+-----+-----+ +-----+
^ ^
| |
ptr1 ptr2
After another pass:
+-----+-----+-----+-----+-----+-----+ +-----+
arr --> | e | d | c | b | a | NUL | c | b |
+-----+-----+-----+-----+-----+-----+ +-----+
^ ^
| |
ptr1 ptr2
Loop ends.
Let's say you have a string.
+---+---+---+---+---+---+---+---+---+---+---+
| t | h | i | s | | i | s | | f | o | o |
+---+---+---+---+---+---+---+---+---+---+---+
Now let's say ptr1 and ptr2 point to:
ptr1 ptr2
| |
v v
+---+---+---+---+---+---+---+---+---+---+---+
| t | h | i | s | | i | s | | f | o | o |
+---+---+---+---+---+---+---+---+---+---+---+
at the start of the while loop. You can now follow the lines in the
while loop one step at a time to understand why the code reverses the
string.
I am lost in this declaration - int (*(*foo)(double))[3];
My understanding is that this is an array with size 3 which element is a function pointer taking double and returning pointer to int. However, the correct explanation seems to be "pointer to function taking double and returning pointer to array of 3 int". The returning pointer to array of 3 int confuses me a lot as int and [3] far apart.
Why is that? What is the syntax or rule to declare variables like this complex?
You just read from the inside out remembering that postfix array ([]) and function "call" (()) bind tighter than prefix pointer (*):
(*foo) // foo is a pointer...
(*foo)(double) // to a function taking a double...
(*(*foo)(double)) // returning a pointer...
(*(*foo)(double))[3] // to an array of 3...
int (*(*foo)(double))[3]; // ints
(To work out where to start you might want to work from the outside in, but you need to read back from the inside out to read the declaration in the conventional order.)
You can use "clockwise spiral rule"
+----------------------------------+
| +---------------------------+ |
| | +--------------------+ | |
| | | +----+ | | |
| | | |+--+| | | |
| | | |^ || | | |
int ( * ( *foo)( double ) [3 ];
| ^ ^ ^ ^ || | | |
| | | | +---+| | | |
| | | +------+ | | |
| | +------------------------+ | |
| +------------------------------+ |
+-------------------------------------+
Thus, Identifier foo
is a pointer
to function taking double as argument returning
pointer to
array 3
of int
Assume I have a pile of rectangles, some of which intersect, some isolate. E. g.
+--------------- + +-------- +
| | | |
| | | |
| A | | C |
| +---------------- + | |
| | | | +---------+-------- +
| | | | | |
+---------|----- + B | | D |
| | | |
| | +------------------ +
+---------------- +
+------------------ + +-------- +
| | | |
| E | | X |
+-------------------+ | |
| | +-------- +
| | +------------ +
| | | |
| F | | |
| | | Y |
| | | |
+-------------------+ +------------ +
Rect A, B intersect with each other, C, D have one same point, E, F have two same points, X, Y are isolated.
I have two questions:
How to partion these rectangles into rectangles which cover A, B, C, D, E, F, X, Y exactly also have minimum count like this:
+---------+----- + +-------- +
| | | | |
| | | | |
| | | | |
| | +--------- + | |
| | | | +---------+-------- +
| | | | | |
+---------+ | | | |
| | | | |
| | | +-------------------+
+------+----------+
+------------------ + +-------- +
| | | |
| | | |
| | | |
| | +---------+
| | +------------ +
| | | |
| | | |
| | | |
| | | |
+-------------------+ +-------------+
How to cover intersected rectangles with big ones? Like this:
+---------------------------+ +-------------------+
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | +-------------------+
+---------------------------+
+-------------------+ +---------+
| | | |
| | | |
| | | |
| | +---------+
| | +------------ +
| | | |
| | | |
| | | |
| | | |
+-------------------+ +-------------+
For Q1, I've no idea at all....
For Q2, I wrote some code in C++ but have poor efficiency. I believe there're better methods/algorithm.
bool intersectRect(const Rect& rect1, const Rect& rect2) {
/* if rect1 and rect2 intersect return true
else return false
*/
}
Rect mergeIntersectRects(const set<Rect>& rects) {
// suppose rects are all intersected. This function only return a smallest Rect that cover all rects.
}
set<Rect> mergeRectToRects(const set<Rect>& rectset, const Rect& rect) {
set<Rect> _intersect_rects;
set<Rect> _unintersect_rects;
for(set<Rect>::const_iterator it = rectset.begin();
it != rectset.end();
++it) {
if(intersectRect(*it, rect))
_intersect_rects.insert(*it);
else
_unintersect_rects.insert(*it);
}
if(!_intersect_rects.empty()) {
_intersect_rects.insert(rect);
return mergeRectToRects(_unintersect_rects,
mergeIntersectRects(_intersect_rects));
}
else {
_unintersect_rects.insert(rect);
return _unintersect_rects;
}
}
First, I'm assuming that your rectangles are all axis-aligned.
For Q1, one option would be to sweep the plane while maintaining a list of line segments along the sweep line that lie in the interior of the rectangles. As you discover each rectangle vertex during the sweep you can check to see if it modifies the current interior segments and if so, start or end a rectangle as necessary.
For example, let's say your sweep line moves left to right:
Current
Interior
|
+-|------------- + +-------- + *
| | | | | |
| | | | | |
| | A | | C | |
| | +---------------- + | | |
| | | | | +---------+-------- + |
| | | | | | | |
+-|-------|----- + B | | D | *
| | | | |
| | | +------------------ +
| +---------------- +
|
+-|---------------- + +-------- + *
| | | | | |
| | E | | X | |
| |-----------------+ | | |
| | | +-------- + |
| | | +------------ + |
| | | | | |
| | F | | | |
| | | | Y | |
| | | | | |
+-|-----------------+ +------------ + *
|
When the sweep line is in the position shown above, there are two interior segments. Namely, that inside A and that inside (E U F). When the sweep line reaches the leftmost edge of B, we output a rectangle for the portion of A lying to the left. We then replace the interior of A in the segment list with the interior of (A U B).
Current
Interior
|
+---------+-|--- + +-------- + *
| | | | | | |
| | | | | | |
| | | | | C | |
| | |-------------- + | | |
| | | | | +---------+-------- + |
| | | | | | | |
+---------+ |--- + B | | D | |
| | | | | |
| | | +------------------ + |
+-|-------------- + *
|
+-----------|------ + +-------- + *
| | | | | |
| | | | X | |
| |-------+ | | |
| | | +-------- + |
| | | +------------ + |
| | | | | |
| | | | | |
| | | | Y | |
| | | | | |
+-----------|-------+ +------------ + *
|
For Q2, the answer could be computed during the same sweep by keeping track of the x-coordinate at which a segment was first added to the list (e.g. "left side of A") as well as the min and max y-coordinates that it spans during its lifetime (e.g. bottom of B to top of A). When the segment is finally removed from the list (e.g. "right side of B"), then output a rectangle using these four coordinates.
Sorting the rectangle vertices lexicographically in a preprocessing step would be O(n * log n). Processing them would be O(log n) since you can do a binary search on the known interior ranges. The total runtime should be O(n * log n).
Q1: this is called partition of rectilinear polygon. Answer from Rob's comment has very good description. I found paper mentioned in the answer useful.
Q2: I suppose that you don't want two covers of non-intersecting regions to intersect. Like cover for 3 rectangle, 2 rectangle producing L and rectangle intersection cover of L but not any L rectangle.
If it is like that, than it is possible to incrementally create covers. Here is a simple algorithm for it.
covers = {A}
for each rectangle R
while there is a cover that intersects R, say C
remove C from covers and set R = cover of R and C
add R to covers
This code is not efficient in standard form. With good structure for covers structure, it can be efficient.
Here's the algorithm: http://goo.gl/aWDJo
You can read about finding the convex hull algorithms: http://ralph.cs.cf.ac.uk/papers/Geometry/boxing.pdf
I'd use the method suggested by #Damon but speed up neighbouring rectangle search with some spatial indexing structure, for example a quadtree or a grid. You'd need two of them, first built over the set of input rectangles, to search for intersecting rectangles to split, and second built over the set of split rectangles obtained in first step, to search adjacent rectangles to merge. That should speed things up considerably compared to the naive approach.