# Question

Formatted question description: https://leetcode.ca/all/243.html

Given an array of strings wordsDict and two different strings that already exist in the array word1 and word2, return the shortest distance between these two words in the list.

Example 1:

Input: wordsDict = ["practice", "makes", "perfect", "coding", "makes"], word1 = "coding", word2 = "practice"
Output: 3


Example 2:

Input: wordsDict = ["practice", "makes", "perfect", "coding", "makes"], word1 = "makes", word2 = "coding"
Output: 1


Constraints:

• 2 <= wordsDict.length <= 3 * 104
• 1 <= wordsDict[i].length <= 10
• wordsDict[i] consists of lowercase English letters.
• word1 and word2 are in wordsDict.
• word1 != word2

# Algorithm

It is enough to traverse the array once, initialize the two variables p1, p2 to -1, and then traverse the array.

When word 1 is encountered, its position is stored in p1, and if word 2 is encountered, its position is stored in p2. If p1, p2 are not -1 anymore, then update the result.

# Code

• 
public class Shortest_Word_Distance {

public static void main(String[] args) {
Shortest_Word_Distance out = new Shortest_Word_Distance();
Solution s = out.new Solution();

System.out.println(s.shortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"}, "makes", "coding"));
}

public class Solution {
public int shortestDistance(String[] words, String word1, String word2) {
int posA = -1;
int posB = -1;
int minDistance = Integer.MAX_VALUE;

for (int i = 0; i < words.length; i++) {
if (words[i].equals(word1)) {
posA = i;
}

if (words[i].equals(word2)) {
posB = i;
}

if (posA != -1 && posB != -1) { // will be run every time, after 1st pair is found
minDistance = Math.min(minDistance, Math.abs(posA - posB));
}
}

return minDistance;
}
}
}

############

class Solution {
public int shortestDistance(String[] wordsDict, String word1, String word2) {
int ans = 0x3f3f3f3f;
for (int k = 0, i = -1, j = -1; k < wordsDict.length; ++k) {
if (wordsDict[k].equals(word1)) {
i = k;
}
if (wordsDict[k].equals(word2)) {
j = k;
}
if (i != -1 && j != -1) {
ans = Math.min(ans, Math.abs(i - j));
}
}
return ans;
}
}

• // OJ: https://leetcode.com/problems/shortest-word-distance/
// Time: O(N)
// Space: O(1)
class Solution {
public:
int shortestDistance(vector<string>& words, string word1, string word2) {
int prev1 = -1, prev2 = -1, ans = INT_MAX;
for (int i = 0; i < words.size(); ++i) {
if (words[i] == word1) {
if (prev2 != -1) ans = min(ans, i - prev2);
prev1 = i;
}
if (words[i] == word2) {
if (prev1 != -1) ans = min(ans, i - prev1);
prev2 = i;
}
}
return ans;
}
};

• class Solution:
def shortestDistance(self, wordsDict: List[str], word1: str, word2: str) -> int:
i = j = -1
ans = inf
for k, w in enumerate(wordsDict):
if w == word1:
i = k
if w == word2:
j = k
if i != -1 and j != -1:
ans = min(ans, abs(i - j))
return ans

############

class Solution(object):
def shortestDistance(self, words, word1, word2):
"""
:type words: List[str]
:type word1: str
:type word2: str
:rtype: int
"""
idx1 = idx2 = -1
ans = len(words)
for i in range(0, len(words)):
word = words[i]
if word in (word1, word2):
if word == word1:
idx1 = i
elif word == word2:
idx2 = i
if idx1 != -1 and idx2 != -1:
ans = min(ans, abs(idx2 - idx1))
return ans


• func shortestDistance(wordsDict []string, word1 string, word2 string) int {
ans := 0x3f3f3f3f
i, j := -1, -1
for k, w := range wordsDict {
if w == word1 {
i = k
}
if w == word2 {
j = k
}
if i != -1 && j != -1 {
ans = min(ans, abs(i-j))
}
}
return ans
}

func min(a, b int) int {
if a < b {
return a
}
return b
}

func abs(x int) int {
if x < 0 {
return -x
}
return x
}