Algorithms and Data Structures

N.Wirth. Algorithms and Data Structures. Oberon version 42
i will now store the comparison point; the variable j will as before point to the corresponding element of the
pattern. See fig. 1.10.
0
i
N-1
A
B
C
D
string
A B C E
pattern
Fig. 1.10. In the notations of the KMP algorithm, the alignment position of the pattern is now i-j (and
not i, as was the case with the simple algorithm).
The central pont of the algorithm is the comparison of s[i] and p[j], if they are equal then i and j are
both increased by 1, otherwise the pattern must be shifted by assigning to j of some smaller value D. The
boundary case j = 0 shows that one should provide for a shift of the pattern entirely beyond the current
comparison point (so that p[0] becomes aligned with s[i+1]). For this, it is convenient to choose D = -1.
The main loop of the algorithm takes the following form:
i := 0; j := 0;
0 j M-1
WHILE (i < N) & (j < M) & ((j < 0) OR (s[i] = p[j])) DO
INC( i ); INC( j )
ELSIF (i < N) & (j < M) DO (* (j >= 0) & (s[i] # p[j]) *)
j := D
END
This formulation is admittedly not quite complete, because it contains an unspecified shift value D. We shall
return to it shortly, but first point out that the invariant here is chosen the same as in the simple algorithm; in
the new notation it is Q(i-j) & P(i-j, j).
The post condition of the loop — evaluated as a conjuction of negations of all guards — is given by the
expression (j >= M) OR (i >= N), but in reality only equalities can occur. If the algorithm terminates due to
j = M, the term P(i-j, j) of the invariant implies P(i-M, M) = R(i), that is, a match at position i-M.
Otherwise it terminates with i = N, and since j < M, the first term of the invariant, Q(i-j), implies that no
match exists at all.
We must now demonstrate that the algorithm never falsifies the invariant. It is easy to show that it is
established at the beginning with the values i = j = 0. Let us first investigate the effect of the two statements
incrementing i and j by 1 in the first branch. They apparently do not falsify Q(i-j), since the difference i-j
remains unchanged. Nor do they falsify P(i-j, j) thanks to the equality in the guard (see the definition of P).
As to the second branch, we shall simply postuate that the value D always be such that replacing j by D will
maintain the invariant.
Provided that D < j the assignment j := D represents a shift of the pattern to the right by j-D positions.
Naturally, we wish this shift to be as large as possible, i.e., D to be as small as possible. This is illustrated
by Fig. 1.11.
i
A B C D
A B C E
string
pattern
A B C D
A B C E
j = 3
D = 0
j = 0
Fig. 1.11. Assignment j := D shifts pattern by j-D positions