The.Algorithm.Design.Manual.Springer-Verlag.1998

War Story: Stripping Triangulations
planar subdivision representing the triangulation (see Section ) captures all the information about the
triangulation needed to partition it into triangle strips. Section describes our experiences constructing
the graph from the triangulation.
Once we had the dual graph available, the project could begin in earnest. We sought to partition the
vertices of the dual graph into as few paths or strips as possible. Partitioning it into one path implied that
we had discovered a Hamiltonian path, which by definition visits each vertex exactly once. Since finding
a Hamiltonian path was NP-complete (see Section ), we knew not to look for an optimal algorithm,
but to concentrate instead on heuristics.
It is always best to start with simple heuristics before trying more complicated ones, because simple
might well suffice for the job. The most natural heuristic for strip cover would be to start from an
arbitrary triangle and then do a left-right walk from there until the walk ends, either by hitting the
boundary of the object or a previously visited triangle. This heuristic had the advantage that it would be
fast and simple, although there could be no reason to suspect that it should find the smallest possible set
of left-right strips for a given triangulation.
A heuristic more likely to result in a small number of strips would be greedy. Greedy heuristics always
try to grab the best possible thing first. In the case of the triangulation, the natural greedy heuristic would
find the starting triangle that yields the longest left-right strip, and peel that one off first.
Being greedy also does not guarantee you the best possible solution, since the first strip you peel off
might break apart a lot of potential strips we would have wanted to use later. Still, being greedy is a good
rule of thumb if you want to get rich. Since removing the longest strip would leave the fewest number of
triangles for later strips, it seemed reasonable that the greedy heuristic would out-perform the naive
heuristic.
But how much time does it take to find the largest strip to peel off next? Let k be the length of the walk
possible from an average vertex. Using the simplest possible implementation, we could walk from each
of the n vertices per iteration in order to find the largest remaining strip to report in time. With
the total number of strips roughly equal to n/k, this yields an -time implementation, which would be
hopelessly slow on a typical model of 20,000 triangles.
How could we speed this up? It seems wasteful to rewalk from each triangle after deleting a single strip.
We could maintain the lengths of all the possible future strips in a data structure. However, whenever we
peel off a strip, we would have to update the lengths of all the other strips that will be affected. These
strips will be shortened because they walked through a triangle that now no longer exists. There are two
aspects of such a data structure:
file:///E|/BOOK/BOOK/NODE37.HTM (2 of 4) [19/1/2003 1:28:34]