Suffix array, lcp using kasai

Author: Garvit244

900-1000q/1044.py

@@ -0,0 +1,119 @@
+'''
+Given a string S, consider all duplicated substrings: (contiguous) substrings of S that occur 2 or more times.  (The occurrences may overlap.)
+
+Return any duplicated substring that has the longest possible length.  (If S does not have a duplicated substring, the answer is "".)
+
+ 
+
+Example 1:
+
+Input: "banana"
+Output: "ana"
+Example 2:
+
+Input: "abcd"
+Output: ""
+ 
+
+Note:
+
+2 <= S.length <= 10^5
+S consists of lowercase English letters.
+'''
+
+class Suffix(object):
+	def __init__(self):
+		self.index = 0
+		self.first_rank = -1
+		self.adjacent_rank = -1
+
+	def __lt__(self, other):
+		if self.first_rank == other.first_rank:
+			return self.adjacent_rank < other.adjacent_rank
+		return self.first_rank < other.first_rank
+        
+def create_suffix_array(s):
+	N = len(s)
+	suffix_array = []
+
+	for index, char in enumerate(s):
+		suffix_obj = Suffix()
+		suffix_obj.index = index
+		suffix_obj.first_rank = ord(char)-ord('a')
+		suffix_obj.adjacent_rank = ord(s[index+1])-ord('a') if (index+1 < N) else -1
+		suffix_array.append(suffix_obj)
+
+	suffix_array.sort()
+
+	no_char = 4
+	index_map = {}
+	while no_char < 2*N:
+		rank = 0
+		prev_rank, suffix_array[0].first_rank = suffix_array[0].first_rank, rank
+		index_map[suffix_array[0].index] = 0
+
+		for index in range(1, N):
+			if suffix_array[index].first_rank == prev_rank and suffix_array[index].adjacent_rank == suffix_array[index-1].adjacent_rank:
+				suffix_array[index].first_rank = rank
+			else:
+				rank += 1
+				prev_rank, suffix_array[index].first_rank = suffix_array[index].first_rank, rank
+			index_map[suffix_array[index].index] = index
+
+		for index in range(N):
+			adjacent_index = suffix_array[index].index + (no_char/2)
+			suffix_array[index].adjacent_rank = suffix_array[index_map[adjacent_index]] if adjacent_index < N else -1
+
+		suffix_array.sort()
+		no_char *= 2    
+
+	return [suffix.index for suffix in suffix_array]
+
+def lcp_w_suffix_str(array, s):
+	N = len(array)
+
+	lcp_array = [0]*N
+	inv_suffix = [0]*N
+
+	for index in range(N):
+		inv_suffix[array[index]] = index
+
+	maxLen = 0
+
+	for index in range(N):
+		if inv_suffix[index] == N-1:
+			maxLen = 0
+			continue
+
+		index_j = array[inv_suffix[index]+1]
+		while(index+maxLen < N and index_j+maxLen < N and s[index+maxLen] == s[index_j+maxLen]):
+			maxLen += 1
+
+		lcp_array[inv_suffix[index]] = maxLen
+
+		if maxLen > 0:
+			maxLen -= 1
+
+	return lcp_array
+
+		
+class Solution(object):
+    def longestDupSubstring(self, S):
+        """
+        :type S: str
+        :rtype: str
+        """
+        suffix_array = create_suffix_array(S)
+        lcp_array = lcp_w_suffix_str(suffix_array, S)
+        
+        start, end = 0, 0
+		
+        for index in range(len(S)):
+            if lcp_array[index] > end:
+                end = lcp_array[index]
+                start = suffix_array[index]
+            
+        if end == 0:
+            return ""
+        # print start, end
+        return S[start:start+end]

Extra/lcp.py

@@ -0,0 +1,42 @@
+from suffix_array import SuffixArray
+
+class LCP(object):
+	def __init__(self, s):
+		self.s = s
+		self.lcp_array = []
+		self.suffix_array = SuffixArray(s)
+		self.suffix_array.create_suffix_array()
+
+	def lcp_w_suffix_str(self):
+		N = len(self.suffix_array.suffix_array)
+		array = self.suffix_array.suffix_array
+
+		self.lcp_array = [0]*N
+		inv_suffix = [0]*N
+
+		for index in range(N):
+			inv_suffix[array[index].index] = index
+
+		maxLen = 0
+
+		for index in range(N):
+			if inv_suffix[index] == N-1:
+				maxLen = 0
+				continue
+
+			index_j = array[inv_suffix[index]+1].index
+			while(index+maxLen < N and index_j+maxLen < N and self.s[index+maxLen] == self.s[index_j+maxLen]):
+				maxLen += 1
+
+			self.lcp_array[inv_suffix[index]] = maxLen
+
+			if maxLen > 0:
+				maxLen -= 1
+
+		return self.lcp_array
+
+
+if __name__ == '__main__':
+	lcp = LCP("banana")
+	lcp.lcp_w_suffix_str()
+	print lcp.lcp_array

Extra/suffix_array.py

@@ -0,0 +1,59 @@
+class Suffix(object):
+	def __init__(self):
+		self.index = 0
+		self.first_rank = -1
+		self.adjacent_rank = -1
+
+	def __lt__(self, other):
+		if self.first_rank == other.first_rank:
+			return self.adjacent_rank < other.adjacent_rank
+		return self.first_rank < other.first_rank
+
+class SuffixArray(object):
+	def __init__(self, s):
+		self.s = s
+		self.suffix_array = []
+
+	def print_suffix(self):
+		for index in range(len(self.s)):
+			ele = self.suffix_array[index]
+			print("Suffix index {}, Suffix string {}".format(ele.index, self.s[ele.index:]))
+
+	def create_suffix_array(self):
+		N = len(self.s)
+		
+		for index, char in enumerate(self.s):
+			suffix_obj = Suffix()
+			suffix_obj.index = index
+			suffix_obj.first_rank = ord(char)-ord('a')
+			suffix_obj.adjacent_rank = ord(self.s[index+1])-ord('a') if (index+1 < N) else -1
+			self.suffix_array.append(suffix_obj)
+
+		self.suffix_array.sort()
+
+		no_char = 4
+		index_map = {}
+		while no_char < 2*N:
+			rank = 0
+			prev_rank, self.suffix_array[0].first_rank = self.suffix_array[0].first_rank, rank
+			index_map[self.suffix_array[0].index] = 0
+
+			for index in range(1, N):
+				if self.suffix_array[index].first_rank == prev_rank and self.suffix_array[index].adjacent_rank == self.suffix_array[index-1].adjacent_rank:
+					self.suffix_array[index].first_rank = rank
+				else:
+					rank += 1
+					prev_rank, self.suffix_array[index].first_rank = self.suffix_array[index].first_rank, rank
+				index_map[self.suffix_array[index].index] = index
+
+			for index in range(N):
+				adjacent_index = self.suffix_array[index].index + (no_char/2)
+				self.suffix_array[index].adjacent_rank = self.suffix_array[index_map[adjacent_index]] if adjacent_index < N else -1
+
+			self.suffix_array.sort()
+			no_char *= 2
+
+if __name__ == '__main__':
+	suffix_array = SuffixArray("banana")
+	suffix_array.create_suffix_array()
+	suffix_array.print_suffix()

Extra/suffix_array.pyc

@@ -4,9 +4,16 @@ Python solution of problems from [LeetCode](https://leetcode.com/).
 
 ### LeetCode Algorithm
 
+##### [Extra](./Extra/)
+ # | Title | Solution |
+|---| ----- | -------- | 
+|1|Suffix Array|[Python](./Extra/suffix_array.py)|
+|2|Longest Common Prefix|[Python](./Extra/lcp.py)|
+
 ##### [Problems 1000-1100](./1000-1100q/)
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|1044|[Longest Duplicate Substring](https://leetcode.com/problems/longest-duplicate-substring)|[Python](./1000-1100q/1044.py)|Hard|
 |1039|[Minimum Score Triangulation of Polygon](https://leetcode.com/problems/minimum-score-triangulation-of-polygon)|[Python](./1000-1100q/1039.py)|Medium|
 |1038|[Binary Search Tree to Greater Sum Tree](https://leetcode.com/problems/binary-search-tree-to-greater-sum-tree/)|[Python](./1000-1100q/1038.py)|Medium|
 |1037|[Valid Boomerang](https://leetcode.com/problems/valid-boomerang/)|[Python](./1000-1100q/1037.py)|Easy|