I read that for implementation of range minimum queries using segment trees, it takes O(n) time for preprocessing and O(log(n)) time to find the solution for each query. It requires extra space too.
If instead we simply, find the minimum for a certain sub-array for an array, we can find it in O(n).
Then, why do we use the segment tree implementation? What are the logistics?
Is it about the constant factor?
Is there a special case when segment trees are particularly useful?
There are many structures that let you do a whole host of operations on arrays in sub-linear time. I will classify these into two groups: fixed and dynamic.
Fixed structures boast superior query runtimes, but do not support array updates.An RMQ lets you do range min/max/gcd in constant time query (with O(n log n) precomp and memory) but does not support updates. Prefix sums let you get range sums in constant time but also does not support updates. Both of these are examples of fixed structures, as an update in the array would require a near complete recomputation of the structure.
Dynamic structures sacrifice a little bit more memory and time in order to support a wider range of operations. A BIT/Fenwick Tree lets you do point updates, range sum in O(log n) per operation. This structure has lower overhead than a segment tree and is useful in cases where you only need these operations. Then of course: Segment Trees.
Segment trees do support range min/max/gcd queries like an RMQ. They also support range sum, like a BIT / prefix sum. These queries support updates, so you can do a point-update like above. However, with a little cleverness, they can do so much more! Segment trees are very easily modified to support range-update (add/subtract a value to every element in a range). They can support point-set and range-set queries (set all values in a range to a desired value). They can support range-bitwise-operations (AND, OR, XOR). They can support range-count (count the number of a predetermined desired number), or return the first/last index of a queried value.
These are just a few of the operations a segment tree can be trivially modified to support. The possibilities are very extensive, which is why segment trees are such a useful structure for so many applications. Getting to know them is quite important, and practicing how to bend their power to your problem is a very useful skill.
