# What is the fastest trajectory for constant acceleration rendezvous?

Suppose you were controlling a space probe floating around in a gravity-less environment, and you wanted to rendezvous with a moving target. That is, intercept the target while matching its velocity, in order to, say, take a sample of an asteroid.

Assuming that this probe's engine is arbitrarily efficient, and the probe was under a constant acceleration, is there some generalized way that you could find the fastest possible method to rendezvous with the target?

Now, when navigating in space, all velocity and position are relative to a reference point. If you measure your position and velocity relative to the target, then the problem is reduced to simply trying to come to a full stop at the origin.

Correct me if I'm wrong here, but the one-dimensional case for this problem seems easy. You determine the optimal approach velocity, which will always be in the direction of the origin, with a speed of $$\sqrt{2A|Z|}$$, where $$|Z|$$ is the probe's distance from the origin, and $$A$$ is the thrust acceleration. Then, you just constantly accelerate in a direction to match this velocity as it changes as you approach the target.

You can do something similar in the two-dimensional case, by accelerating to match an optimal velocity vector which is heading towards the origin, with a magnitude of $$\sqrt{2A|Z|}$$. This works fine until you encounter a case where the probe's initial velocity is significantly perpendicular to the direction towards target, in which case the probe always slightly overshoots and has to quickly turn around.

I assume this is because the optimal approach speed is assuming the acceleration is maximally towards or away from the target. If there is any perpendicular component to the constant acceleration, it takes away from the component towards or away from the target, which means that the probe can never quite fully match the approach velocity.

Is there any way to compoensate for this in a way that would cause the approach to be significantly quicker? Or am I going about this problem in completely the wrong way.