competitive-programming | A one-stop Destination✏️ for all your Competitive Programming Resources.📗📕 Refer CONTRIBUTING.m | Learning library

Here is my implementation of a lower_bound-like function for a Fenwick tree with 0-based indexing:

We CAN use that theorem when looking for an exact value, because we
only use it when discarding one half. If we are looking for say 5,
and we find say 6 in the middle, the we can discard the upper half,
because we now know (due to the theorem) that all items in there are > 5

Also notice, that if we have a sorted sequence, and want to find any element
that satisfies an inequality, looking at the end elements is enough.

Before finding recursive solution for DP, try identifying sub-problems of the problem in question. Since, each sub problem is same as parent problem and same algorithm will be applied.

Let's take the example for coin change where you are given list of denominations, d[] and sum, S and we need to find minimum number of denominations, count (of denominations) for summing up to S. If we want to define a solution (method) for finding count that would be int findMinDenom(int[] d, int S). At this point we don't know what implementation it would be but we do know what parameters are required for the problem which is d and S.

Keeping in mind that sub-problems would also have same solution but with lower sum. Hence, we try to implement in such way that findMinDenom solves for each of sub-problems. This will lead us to a recursive solution where we call same method with lower sum, s.

how do I ensure that the buffer doesn't get overflowed,

The output buffer doesn't "overflow". When it gets full, it is automatically flushed, i.e. its contents are written out and its length is reset to 0. This is the case whether cin / cout are tied or not.

cin and cout work properly without blocking

You normally want operations on cin / cout to block. But again, blocking vs. non-blocking I/O has nothing to do with whether cin / cout are tied.

and buffer gets flushed properly when I am not using std::endl. Does the use of "\n" automatically handles it?

Outputting '\n' only flushes the buffer if the stream is in line-buffered mode. cout is automatically put in line-buffered mode if output goes to a terminal; otherwise it is block buffered (i.e. it only gets flushed when it runs full).

In a programming competition cout usually goes to a pipe or log file, so it will be block buffered and '\n' doesn't cause a flush. However, in that situation it also doesn't matter whether prompts are displayed before input is read (which is the normal use case for tied cin / cout). Just make sure you produce the right output and let the I/O library worry about buffering. The buffer is automatically flushed when it runs full, when the stream is closed, and when your program exits. No output is lost (unless your program crashes, but then you have other things to worry about).

the output is shown as 0 and not the input number.

the test in

If we have some set represented as a bitmask, for example if we have the universe:

You have to count for every cell [i,j]
  how many of cell [i,j-1], cell[i,j+1], cell[i-1,j], cell[i+1,j] (i.e. the adjacent cells, i.e. neighbour cells) contain an 'o'.

If count is an even number (for every cell [i,j]) the result is "yes", else "no". (Thus, the test may be finished when the first odd count is detected.) Thereby, 0 is counted as even number as well (of course).

The possible issue:

For border cells, some of the tests have to be skipped to prevent out-of-bound access.

The solution uses a trick for this: It stores input beginning from indices [1,1] instead of indices [0,0]. This leaves "unused" border cells around the actual input matrix. The advance: no tests for cells to skip are necessary.

As the memory is filled with '*' before the unused border cells will not have any negative effect for counting.

Why the trick is used:

The platform will hopefully perform read access to border cells and counting faster than the check (for every cell) whether cells have to be skipped (to prevent out-of-bound access).