Today's video is a must do although won't be able to give a video due to time constraint. Intuition: At every robot we have two options either we can fire to the left or fire to the right. We can use DP to find the optimal solution to get the maximum no of walls we can break. Approach Dp[i][0] = Maximum no of walls i can break till i if I chose to shoot left at i Dp[i][1] = Maximum no of walls i can break till i if I chose to shoot right at i Sort both the robots and walls arrays. This will help in efficiently processing positions and performing range queries. Now counting number of walls in a range can be easily done using binary search function : int countwalls(int l,int r,vector& walls){ if(l>r) return 0; auto it1 = upper_bound(walls.begin(),walls.end(),r); auto it2 = lower_bound(walls.begin(),walls.end(),l); int res = it1-it2; return res; } Each robot can shoot either left or right. However, if a robot fires and another robot is in its path, the bullet stops. You need to use the positions of neighboring robots to limit the shooting range. range of a robot: left = max(pos - dist, prev_robo + 1) right = min(pos + dist, next_robo - 1) case 1: shoot right (future shoot, no overlapping) max(dp[i - 1][0], dp[i - 1][1]) + no_of_walls from pos to right case 2: shoot left (no overlap with previous left) dp[i - 1][0] + no of walls from left to pos case 3: shoot left and overlap with previous robo's right side dp[i - 1][1] + walls in its range - overlapping walls return max of walls in right or left of last robot Full code with comments : class Solution { public: int maxWalls(vector& robots, vector& d, vector& walls) { int n = robots.size(); // Store robots as {position, distance} vector> x(n); for (int i = 0; i < n; i++) { x[i] = {robots[i], d[i]}; } // Sort robots and walls to get everything in order sort(x.begin(), x.end()); sort(walls.begin(), walls.end()); // Dummy robot to avoid boundary checks x.push_back({(int)1e9, 0}); // Function to count walls in range [l, r] auto query = [&](int l, int r) -> int { if (l > r) return 0; auto it1 = upper_bound(walls.begin(), walls.end(), r); auto it2 = lower_bound(walls.begin(), walls.end(), l); return it1 - it2; }; // dp[i][0] = i-th robot shoots LEFT // dp[i][1] = i-th robot shoots RIGHT vector> dp(n); // Base case (i = 0)- shooting left dp[0][0] = query(x[0][0] - x[0][1], x[0][0]); //shooting right if (n > 1) { dp[0][1] = query( x[0][0], min(x[1][0] - 1, x[0][0] + x[0][1]) ); } else { dp[0][1] = query(x[0][0], x[0][0] + x[0][1]); } // DP transitions for (int i = 1; i < n; i++) { // Case 1: shoot RIGHT dp[i][1] = max(dp[i - 1][0], dp[i - 1][1]) + query( x[i][0], min(x[i + 1][0] - 1, x[i][0] + x[i][1]) ); // Case 2: shoot LEFT (no overlap with previous LEFT) dp[i][0] = dp[i - 1][0] + query( max(x[i][0] - x[i][1], x[i - 1][0] + 1), x[i][0] ); // Case 3: shoot LEFT but previous was RIGHT (handle overlap) int leftStart = max(x[i][0] - x[i][1], x[i - 1][0] + 1); int leftEnd = x[i][0]; int overlapStart = leftStart; int overlapEnd = min(x[i - 1][0] + x[i - 1][1], x[i][0] - 1); int res = dp[i - 1][1] + query(leftStart, leftEnd) - query(overlapStart, overlapEnd); dp[i][0] = max(dp[i][0], res); } return max(dp[n - 1][0], dp[n - 1][1]); } };