SDE - 1

Intuition

Robbers have 2 choices either rob this house or the neighbouring house
The neighbourhood is designed circularly.
To fix this
first, we make him start from house no 2 up to the last house
next time we make him go from house 1 to the second last house
Since we are calculating every possibility we use recursion
To optimize the solution we use dp
Approach

The first and second move is where the robber goes from either 1st house to the second last or the second house to the last house.

Use the array for the job with info (startTime, endTime, profit)

Sort the vector for the jobs[i]=(startTime[i], endTime[i], profit[i]).

Use the binary search (C++ upper_bound) to find the index next[i] for the target {jobs[i][1], 0, 0}={endTime[i], 0, 0} where endTime[i] is according to sorting.

Use DP to find the maximal profit

Sort the input array
Initialize a set to store the unique triplets and an output vector to store the final result
Iterate through the array with a variable i, starting from index 0.
Initialize two pointers, j and k, with j starting at i+1 and k starting at the end of the array.
In the while loop, check if the sum of nums[i], nums[j], and nums[k] is equal to 0. If it is, insert the triplet into the set and increment j and decrement k to move the pointers.
If the sum is less than 0, increment j. If the sum is greater than 0, decrement k.
After the while loop, iterate through the set and add each triplet to the output vector.
Return the output vector

The two-pointer technique starts with the widest container and moves the pointers inward based on the comparison of heights.
Increasing the width of the container can only lead to a larger area if the height of the new boundary is greater. By moving the pointers towards the centre, we explore containers with the potential for greater areas.

Tip 1:Stay confident
Tip 2: Answer as much as you remember
Tip 3: Don't answer wrong

I explained all the 3 pre-order, in-order and post-order traversal of the tree firstly recursively and then iteratively and explained how the recursive approach takes extra stack space and is harder to debug.

Tip 1: Be thorough with the concepts
Tip 2: Be present and ask for inputs if necessary
Tip 3: Communicate