Introduction-to-Algorithms | book Introduction to Algorithms , Third Edition | Learning library

The slide says for j ← p + 1 to q, which you turned to for (int j = p+1; j < q; j++). This is an off-by-one error.

Given the condition above in A why go to the left? instead of the right?

If you would go to the right (without first checking condition B), there is a small probability that the values at the right will keep going down (from left to right), and you would not find a peak there.

At the left side, however, you know that you cannot have that situation, as you have found at least one value that is higher (the neighbour) and could potentially even be a peak. Here is how you can prove that a peak exists at the left side (this is not a description of the algorithm; just a way to prove it):

If the immediate neighbour is not a peak, then possibly the next one to its left is. If not, then possibly the next one to its left....etc. This series will end when finding a peak or arriving at the left most value. If none of the others were peaks, then this one must be it. This only happens when the values never decreased while looking further to the left.

In short, whatever the situation at the left side, there is a peak somewhere there at that side, and that is all we need to know when choosing a side.

Given the condition above in B why go to the right? instead of the left?

This is of course the same reasoning, but mirrored.

Note that you can decide to first check condition B and only then A. When both conditions are true at the same time, you can actually choose which side to go. This is where you got the feeling from that the choice looks "arbitrary". It is indeed arbitrary when both conditions A and B are true.

But also think about the case where one of A and B is true and the other false. If you would go the wrong (downward) way, you have no guarantee that values would ever go up in that direction. And so there is a small probability that there is no peak on that side.

Of course, there still could be a peak on that side, but since we are sure there is one on the other side, it is wise to go for certainty. We don't care about potentially discarding some peaks, as we only need to find one peak.

The binary search algorithm assumes we start from a sorted array, so how come it makes sense to apply it to data that may be unsorted?

Binary search for a particular value would only work in a sorted array, but here we are not looking for a particular value. The conditions of the value we are looking for are less strict. Instead of a particular value, we will be happy with any value that is a local peak.

It appears to me that you made a mistake in the indices. I couldn't make it work as expected but the following code should give you an indication where I was heading at (there is probably an off by one somewhere):

Pay close attention to the definitions, as they are not the same as what you would expect intuitively.

he defines the peak as a <= b,c,d,e (with b,c,d and e being the elements to the left,right,top,bottom of the current element 'a')

So there you have it -- a peak is defined as a local maximum (an element larger than all of its immediate neighbors), rather than a global maximum (an element larger than all other elements). By this definition, it's clear that while 20 is not the largest element it is a peak.

(As noted in comments, the definition should probably be a >= b,c,d,e that's probably just a typo in the original post)

Can anyone help me understand as to why the first rs()==rt() required?

I assume you mean the one right before the range-loop. If the strings have the same length, then the range-loop will not run (empty range). The check is necessary to cover that case.

If it’s used, then shouldn’t we also check first by brute force whether the strings are equal and then move ahead?

Not sure what you mean here. The posted code leaves blank (with ...) after matching hashes are found. Let's not forget that at that point, we must compare strings to confirm we really found a match. And, it's up to the (not shown) implementation to continue searching until the end or not.

Why is it that we are not considering equality of strings when hashing is done from t[0] and then trying to find other string matches?

I really don't get this part. Note the first two loops are to populate the rolling hashes for the input strings. Then comes a check if we have a match at this point, and then the loop updating the rolling hashes pair wise, and then comparing them. The entire t is checked, from start to end.

The easiest solution that I have found as of today is using the url_absolute(x, base) function of the xml2 package. For the base parameter, you use the url of the page you retrieved the source from.

This seems less error prone than trying to extract the base url of the address via regexp.

The DFS has to be logically DFS, but programmatically you can try a work around.

1. writing the DFS in such a way that you can retry it from one of the top functions, if it reaches a near the recursion limit.

2. Try to use multiprocessing.

PS: Is it possible that an infinite recursion is occurring for the larger dataset? logical error which comes forth when using a larger dataset. If you have datasets of incremental sizes, you could also identify the limit of the algorithm's implementation in python.

For finding all peaks, you can't do any better than just going through the whole array and comparing every element to its neighbors. There's no way to tell whether an element you didn't look at is or isn't a peak, so you have to look at all of them.

Thus, the time complexity is O(n) for n elements.