Point indexes are just a way of naming them. What matters in the
algorithm is only their positions.
The first thing you need is the management of your points. You need a
structure that sorts them according to position when given the initial
list of positions (ascending or descending order, it does not
matter). This structure must allow you to remove a point, and add it
somewhere else at low cost to keep the list sorted when you operate a
change. You will find many such structures in any course on data
structures and algorithms.
Then you need a structure for representing segments that will group
your points into a collection of buckets of points covered by the same
segment. This collection of buckets is a covering. The construction of
an optimal covering is easy. You can show easily that, given any
covering, you can always replace the lefmost segment by a
segment that start rightward at the leftmost point, to get another
covering. From that you can show by induction that you can get an
optimal covering by placing a segment so that its leftmost end is on
the leftmost point, and then reapeat recursively starting at the
lefftmost point not yet covered.
A symetric proof shows that you can alternatively start from the
right. Actually, combining the two proofs, you can show that you can
always chose your next segment either rightward from the leftmost
point or leftward from the rightmost point, computing from both end towards the middle until the two computations "meet" somewhere in the middle (you can choose that "somewhere"). In all versions of the algorithm, the last segment added may cover points that are already covered (though it can be avoided for the unidirectionnal versions of the algorithm - it does not matter anyway).
We assume first you build your covering from the left only.
Each change is composed of two "half-changes", removal of the point from its former position followed by addition of the point in the sorting structure at its new position. After performing them, you have recompute your segments.
You try to limit the new computation to an incremental change to the previous one, and you must have kept your collection of buckets.
You start at the leftmost segment affected by the leftmost
"half-change" (either addition or removal), and you recompute segments until you find a segment
that is the same as for the previous covering (which ends a first incremental update), and you do some
accounting to know whether and how that changes the number of
segments. If the rightmost "half-change" has been passed in the
process, you are also done for that change. Else you do the same for that
second half-change, still recomputing from left to right as in the
first computation of a minimal covering of segments.
The algorithm could alternatively compute coverings from right to left. It is the same in reversal.
Starting from both
ends may make the algorithm a bit more complicated (you have to work out the changes for yourself), On the other hand
it may improve it somewhat as it can avoid having to recompute all
segments up to the right end in pathological cases of incremental recomputation: you are sure an incremental update will not exceed half the collection of points ( actually it is not exactly half, depending on how the "meeting point in the middle" is chosen). But I guess it is
a minor improvement. You might be even more subtle in choosing the
"middle place" and in possibly changing it when you move your points,
to account for
changes of the algorithm behavior according to point density. But this
is marginal and requires a bit of analysis.
Note: the above works for addition and removal of points, without necessarily keeping a constant number of points, provided it is allowed by the structures that I left unspecified and up to your own choice. The fact that the number of points remains constant in the statement of your problem could be an indication that a specific method is expected that would make use of that fact.
P.S. What do you mean by best approach ? What is the criterion.