Top 20 Dynamic Programming Interview Questions

Longest repeating and non-overlapping substring

Last Updated : 16 Nov, 2024

Given a string s, the task is to find the longest repeating non-overlapping substring in it. In other words, find 2 identical substrings of maximum length which do not overlap. Return -1 if no such string exists.

Note: Multiple Answers are possible but we have to return the substring whose first occurrence is earlier.

Examples:

Input: s = "acdcdacdc"
Output: "acdc"
Explanation: The string "acdc" is the longest Substring of s which is repeating but not overlapping.
Input: s = "geeksforgeeks"
Output: "geeks"
Explanation: The string "geeks" is the longest subString of s which is repeating but not overlapping.

Table of Content

Using Brute Force Method - O(n^3) Time and O(n) Space
Using Top-Down DP (Memoization) - O(n^2) Time and O(n^2) Space
Using Bottom-Up DP (Tabulation) - O(n^2) Time and O(n^2) Space
Using Space Optimized DP – O(n^2) Time and O(n) Space

Using Brute Force Method - O(n^3) Time and O(n) Space

The idea is to generate all the possible substrings and check if the substring exists in the remaining string. If substring exists and its length is greater than answer substring, then set answer to current substring.

C++

// C++ program to find longest repeating
// and non-overlapping substring
// using recursion
#include <bits/stdc++.h>
using namespace std;

string longestSubstring(string& s) {
    int n = s.length();

    string ans = "";
    int len = 0;

    int i = 0, j = 0;

    while (i < n && j < n) {

        string curr = s.substr(i, j - i + 1);

        // If substring exists, compare its length
        // with ans
        if (s.find(curr, j + 1) != string::npos 
            && j - i + 1 > len) {
            len = j - i + 1;
            ans = curr;
        }

        // Otherwise increment i
        else
            i++;

        j++;
    }

    return len > 0 ? ans : "-1";
}

int main() {
    string s = "geeksforgeeks";
    cout << longestSubstring(s) << endl;
    return 0;
}

Java

// Java program to find longest repeating
// and non-overlapping substring
// using recursion
class GfG {

    static String longestSubstring(String s) {
        int n = s.length();

        String ans = "";
        int len = 0;

        int i = 0, j = 0;

        while (i < n && j < n) {

            String curr = s.substring(i, j + 1);

            // If substring exists, compare its length
            // with ans
            if (s.indexOf(curr, j + 1) != -1
                && j - i + 1 > len) {
                len = j - i + 1;
                ans = curr;
            }

            // Otherwise increment i
            else
                i++;

            j++;
        }

        return len > 0 ? ans : "-1";
    }

    public static void main(String[] args) {
        String s = "geeksforgeeks";
        System.out.println(longestSubstring(s));
    }
}

Python

# Python program to find longest repeating
# and non-overlapping substring
# using recursion

def longestSubstring(s):
    n = len(s)

    ans = ""
    lenAns = 0

    i, j = 0, 0

    while i < n and j < n:

        curr = s[i:j + 1]

        # If substring exists, compare its length
        # with ans
        if s.find(curr, j + 1) != -1 and j - i + 1 > lenAns:
            lenAns = j - i + 1
            ans = curr

        # Otherwise increment i
        else:
            i += 1

        j += 1

    if lenAns > 0:
        return ans
    return "-1"


if __name__ == "__main__":
    s = "geeksforgeeks"
    print(longestSubstring(s))

// C# program to find longest repeating
// and non-overlapping substring
// using recursion

using System;

class GfG {

    static string longestSubstring(string s) {
        int n = s.Length;

        string ans = "";
        int len = 0;

        int i = 0, j = 0;

        while (i < n && j < n) {

            string curr = s.Substring(i, j - i + 1);

            // If substring exists, compare its length
            // with ans
            if (s.IndexOf(curr, j + 1) != -1
                && j - i + 1 > len) {
                len = j - i + 1;
                ans = curr;
            }

            // Otherwise increment i
            else
                i++;

            j++;
        }

        return len > 0 ? ans : "-1";
    }

    static void Main(string[] args) {
        string s = "geeksforgeeks";
        Console.WriteLine(longestSubstring(s));
    }
}

JavaScript

// JavaScript program to find longest repeating
// and non-overlapping substring
// using recursion

function longestSubstring(s) {
    const n = s.length;

    let ans = "";
    let len = 0;

    let i = 0, j = 0;

    while (i < n && j < n) {

        const curr = s.substring(i, j + 1);

        // If substring exists, compare its length
        // with ans
        if (s.indexOf(curr, j + 1) !== -1
            && j - i + 1 > len) {
            len = j - i + 1;
            ans = curr;
        }

        // Otherwise increment i
        else
            i++;

        j++;
    }

    return len > 0 ? ans : "-1";
}

const s = "geeksforgeeks";
console.log(longestSubstring(s));

Output

geeks

Using Top-Down DP (Memoization) - O(n^2) Time and O(n^2) Space

The approach is to compute the longest repeating suffix for all prefix pairs in the string s. For indices i and j, if s[i] == s[j], then recursively compute suffix(i+1, j+1) and set suffix(i, j) as min(suffix(i+1, j+1) + 1, j - i - 1) to prevent overlap. If the characters do not match, set suffix(i, j) = 0.

Note:

To avoid overlapping we have to ensure that the length of suffix is less than (j-i) at any instant.
The maximum value of suffix(i, j) provides the length of the longest repeating substring and the substring itself can be found using the length and the starting index of the common suffix.
suffix(i, j) stores the length of the longest common suffix between indices i and j, ensuring it doesn’t exceed j - i - 1 to avoid overlap.

C++

// C++ program to find longest repeating
// and non-overlapping substring
// using memoization
#include <bits/stdc++.h>
using namespace std;

int findSuffix(int i, int j, string &s, 
               vector<vector<int>> &memo) {

    // base case
    if (j == s.length())
        return 0;

    // return memoized value
    if (memo[i][j] != -1)
        return memo[i][j];

    // if characters match
    if (s[i] == s[j]) {
        memo[i][j] = 1 + min(findSuffix(i + 1, j + 1, s, memo),
                             j - i - 1);
    }
    else {
        memo[i][j] = 0;
    }

    return memo[i][j];
}

string longestSubstring(string s) {

    int n = s.length();

    vector<vector<int>> memo(n, vector<int>(n, -1));

    // find length of non-overlapping
    // substrings for all pairs (i,j)
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            findSuffix(i, j, s, memo);
        }
    }

    string ans = "";
    int ansLen = 0;

    // If length of suffix is greater
    // than ansLen, update ans and ansLen
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (memo[i][j] > ansLen) {
                ansLen = memo[i][j];
                ans = s.substr(i, ansLen);
            }
        }
    }

    return ansLen > 0 ? ans : "-1";
}

int main() {
    string s = "geeksforgeeks";
    cout << longestSubstring(s) << endl;
    return 0;
}

Java

// Java program to find longest repeating
// and non-overlapping substring
// using memoization
import java.util.Arrays;

class GfG {

    static int findSuffix(int i, int j, String s,
                          int[][] memo) {

        // base case
        if (j == s.length())
            return 0;

        // return memoized value
        if (memo[i][j] != -1)
            return memo[i][j];

        // if characters match
        if (s.charAt(i) == s.charAt(j)) {
            memo[i][j] = 1
                         + Math.min(findSuffix(i + 1, j + 1,
                                               s, memo),
                                    j - i - 1);
        }
        else {
            memo[i][j] = 0;
        }

        return memo[i][j];
    }

    static String longestSubstring(String s) {

        int n = s.length();

        int[][] memo = new int[n][n];
        for (int[] row : memo) {
            Arrays.fill(row, -1);
        }

        // find length of non-overlapping
        // substrings for all pairs (i, j)
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                findSuffix(i, j, s, memo);
            }
        }

        String ans = "";
        int ansLen = 0;

        // If length of suffix is greater
        // than ansLen, update ans and ansLen
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (memo[i][j] > ansLen) {
                    ansLen = memo[i][j];
                    ans = s.substring(i, i + ansLen);
                }
            }
        }

        return ansLen > 0 ? ans : "-1";
    }

    public static void main(String[] args) {
        String s = "geeksforgeeks";
        System.out.println(longestSubstring(s));
    }
}

Python

# Python program to find longest repeating
# and non-overlapping substring
# using memoization

def findSuffix(i, j, s, memo):

    # base case
    if j == len(s):
        return 0

    # return memoized value
    if memo[i][j] != -1:
        return memo[i][j]

    # if characters match
    if s[i] == s[j]:
        memo[i][j] = 1 + min(findSuffix(i + 1, j + 1, s, memo), \
                             j - i - 1)
    else:
        memo[i][j] = 0

    return memo[i][j]


def longestSubstring(s):
    n = len(s)

    memo = [[-1] * n for _ in range(n)]

    # find length of non-overlapping
    # substrings for all pairs (i, j)
    for i in range(n):
        for j in range(i + 1, n):
            findSuffix(i, j, s, memo)

    ans = ""
    ansLen = 0

    # If length of suffix is greater
    # than ansLen, update ans and ansLen
    for i in range(n):
        for j in range(i + 1, n):
            if memo[i][j] > ansLen:
                ansLen = memo[i][j]
                ans = s[i:i + ansLen]

    if ansLen > 0:
        return ans

    return "-1"


if __name__ == "__main__":
    s = "geeksforgeeks"
    print(longestSubstring(s))

// C# program to find longest repeating
// and non-overlapping substring
// using memoization

using System;

class GfG {

    static int findSuffix(int i, int j, string s,
                          int[, ] memo) {

        // base case
        if (j == s.Length)
            return 0;

        // return memoized value
        if (memo[i, j] != -1)
            return memo[i, j];

        // if characters match
        if (s[i] == s[j]) {
            memo[i, j] = 1
                         + Math.Min(findSuffix(i + 1, j + 1,
                                               s, memo),
                                    j - i - 1);
        }
        else {
            memo[i, j] = 0;
        }

        return memo[i, j];
    }

    static string longestSubstring(string s) {
        int n = s.Length;

        int[, ] memo = new int[n, n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                memo[i, j] = -1;
            }
        }

        // find length of non-overlapping
        // substrings for all pairs (i, j)
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                findSuffix(i, j, s, memo);
            }
        }

        string ans = "";
        int ansLen = 0;

        // If length of suffix is greater
        // than ansLen, update ans and ansLen
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (memo[i, j] > ansLen) {
                    ansLen = memo[i, j];
                    ans = s.Substring(i, ansLen);
                }
            }
        }

        return ansLen > 0 ? ans : "-1";
    }

    static void Main(string[] args) {
        string s = "geeksforgeeks";
        Console.WriteLine(longestSubstring(s));
    }
}

JavaScript

// JavaScript program to find longest repeating
// and non-overlapping substring
// using memoization

function findSuffix(i, j, s, memo) {

    // base case
    if (j === s.length)
        return 0;

    // return memoized value
    if (memo[i][j] !== -1)
        return memo[i][j];

    // if characters match
    if (s[i] === s[j]) {
        memo[i][j]
            = 1
              + Math.min(findSuffix(i + 1, j + 1, s, memo),
                         j - i - 1);
    }
    else {
        memo[i][j] = 0;
    }

    return memo[i][j];
}

function longestSubstring(s) {
    const n = s.length;

    const memo
        = Array.from({length : n}, () => Array(n).fill(-1));

    // find length of non-overlapping
    // substrings for all pairs (i, j)
    for (let i = 0; i < n; i++) {
        for (let j = i + 1; j < n; j++) {
            findSuffix(i, j, s, memo);
        }
    }

    let ans = "";
    let ansLen = 0;

    // If length of suffix is greater
    // than ansLen, update ans and ansLen
    for (let i = 0; i < n; i++) {
        for (let j = i + 1; j < n; j++) {
            if (memo[i][j] > ansLen) {
                ansLen = memo[i][j];
                ans = s.substring(i, i + ansLen);
            }
        }
    }

    return ansLen > 0 ? ans : "-1";
}

const s = "geeksforgeeks";
console.log(longestSubstring(s));

Output

geeks

Using Bottom-Up DP (Tabulation) - O(n^2) Time and O(n^2) Space

The idea is to create a 2D matrix of size (n+1)*(n+1) and calculate the longest repeating suffixes for all index pairs (i, j) iteratively. We start from the end of the string and work backwards to fill the table. For each (i, j), if s[i] == s[j], we set suffix[i][j] to min(suffix[i+1][j+1]+1, j-i-1) to avoid overlap; otherwise, suffix[i][j] = 0.

C++

// C++ program to find longest repeating
// and non-overlapping substring
// using tabulation
#include <bits/stdc++.h>
using namespace std;

string longestSubstring(string s) {

    int n = s.length();
    vector<vector<int>> dp(n+1, vector<int>(n+1, 0));
    
    string ans = "";
    int ansLen = 0;
    
    // find length of non-overlapping 
    // substrings for all pairs (i,j)
    for (int i=n-1; i>=0; i--) {
        for (int j=n-1; j>i; j--) {
            
            // if characters match, set value 
            // and compare with ansLen.
            if (s[i]==s[j]) {
                dp[i][j] = 1 + min(dp[i+1][j+1], j-i-1);
                
                if (dp[i][j]>=ansLen) {
                    ansLen = dp[i][j];
                    ans = s.substr(i, ansLen);
                }
            }
        }
    }
    
    return ansLen>0?ans:"-1";
}

int main() {
	string s = "geeksforgeeks";
    cout << longestSubstring(s) << endl;
	return 0;
}

Java

// Java program to find longest repeating
// and non-overlapping substring
// using tabulation


class GfG {

    static String longestSubstring(String s) {

        int n = s.length();
        int[][] dp = new int[n + 1][n + 1];
        
        String ans = "";
        int ansLen = 0;
        
        // find length of non-overlapping 
        // substrings for all pairs (i, j)
        for (int i = n - 1; i >= 0; i--) {
            for (int j = n - 1; j > i; j--) {
                
                // if characters match, set value 
                // and compare with ansLen.
                if (s.charAt(i) == s.charAt(j)) {
                    dp[i][j] = 1 + Math.min(dp[i + 1][j + 1], j - i - 1);
                    
                    if (dp[i][j] >= ansLen) {
                        ansLen = dp[i][j];
                        ans = s.substring(i, i + ansLen);
                    }
                }
            }
        }
        
        return ansLen > 0 ? ans : "-1";
    }

    public static void main(String[] args) {
        String s = "geeksforgeeks";
        System.out.println(longestSubstring(s));
    }
}

Python

# Python program to find longest repeating
# and non-overlapping substring
# using tabulation

def longestSubstring(s):
    n = len(s)
    dp = [[0] * (n + 1) for _ in range(n + 1)]
    
    ans = ""
    ansLen = 0
    
    # find length of non-overlapping 
    # substrings for all pairs (i, j)
    for i in range(n - 1, -1, -1):
        for j in range(n - 1, i, -1):
            
            # if characters match, set value 
            # and compare with ansLen.
            if s[i] == s[j]:
                dp[i][j] = 1 + min(dp[i + 1][j + 1], j - i - 1)
                
                if dp[i][j] >= ansLen:
                    ansLen = dp[i][j]
                    ans = s[i:i + ansLen]
    
    return ans if ansLen > 0 else "-1"

if __name__ == "__main__":
    s = "geeksforgeeks"
    print(longestSubstring(s))

// C# program to find longest repeating
// and non-overlapping substring
// using tabulation

using System;

class GfG {

    static string longestSubstring(string s) {
        int n = s.Length;
        int[,] dp = new int[n + 1, n + 1];
        
        string ans = "";
        int ansLen = 0;
        
        // find length of non-overlapping 
        // substrings for all pairs (i, j)
        for (int i = n - 1; i >= 0; i--) {
            for (int j = n - 1; j > i; j--) {
                
                // if characters match, set value 
                // and compare with ansLen.
                if (s[i] == s[j]) {
                    dp[i, j] = 1 + Math.Min(dp[i + 1, j + 1], j - i - 1);
                    
                    if (dp[i, j] >= ansLen) {
                        ansLen = dp[i, j];
                        ans = s.Substring(i, ansLen);
                    }
                }
            }
        }
        
        return ansLen > 0 ? ans : "-1";
    }

    static void Main(string[] args) {
        string s = "geeksforgeeks";
        Console.WriteLine(longestSubstring(s));
    }
}

JavaScript

// JavaScript program to find longest repeating
// and non-overlapping substring
// using tabulation

function longestSubstring(s) {
    const n = s.length;
    const dp = Array.from({ length: n + 1 }, () => Array(n + 1).fill(0));
    
    let ans = "";
    let ansLen = 0;
    
    // find length of non-overlapping 
    // substrings for all pairs (i, j)
    for (let i = n - 1; i >= 0; i--) {
        for (let j = n - 1; j > i; j--) {
            
            // if characters match, set value 
            // and compare with ansLen.
            if (s[i] === s[j]) {
                dp[i][j] = 1 + Math.min(dp[i + 1][j + 1], j - i - 1);
                
                if (dp[i][j] >= ansLen) {
                    ansLen = dp[i][j];
                    ans = s.substring(i, i + ansLen);
                }
            }
        }
    }
    
    return ansLen > 0 ? ans : "-1";
}

const s = "geeksforgeeks";
console.log(longestSubstring(s));

Output

geeks

Using Space Optimized DP – O(n^2) Time and O(n) Space

The idea is to use a single 1D array instead of a 2D matrix by keeping track of only the "next row" values required to compute suffix[i][j]. Since each value suffix[i][j] depends only on suffix[i+1][j+1] in the row below, we can maintain the previous row's values in a 1D array and update them iteratively for each row.

C++

// C++ program to find longest repeating
// and non-overlapping substring
// using space optimised
#include <bits/stdc++.h>
using namespace std;

string longestSubstring(string s) {

    int n = s.length();
    vector<int> dp(n+1,0);
    
    string ans = "";
    int ansLen = 0;
    
    // find length of non-overlapping 
    // substrings for all pairs (i,j)
    for (int i=n-1; i>=0; i--) {

        for (int j=i; j<n; j++) {
            
            // if characters match, set value 
            // and compare with ansLen.
            if (s[i]==s[j]) {
                dp[j] = 1 + min(dp[j+1], j-i-1);
                
                if (dp[j]>=ansLen) {
                    ansLen = dp[j];
                    ans = s.substr(i, ansLen);
                }
            }
            else dp[j] = 0;
        }
    }
    
    return ansLen>0?ans:"-1";
}

int main() {
	string s = "geeksforgeeks";
    cout << longestSubstring(s) << endl;
	return 0;
}

Java

// Java program to find longest repeating
// and non-overlapping substring
// using space optimised

class GfG {

    static String longestSubstring(String s) {

        int n = s.length();
        int[] dp = new int[n + 1];
        
        String ans = "";
        int ansLen = 0;
        
        // find length of non-overlapping 
        // substrings for all pairs (i, j)
        for (int i = n - 1; i >= 0; i--) {
            for (int j = i; j < n; j++) {
                
                // if characters match, set value 
                // and compare with ansLen.
                if (s.charAt(i) == s.charAt(j)) {
                    dp[j] = 1 + Math.min(dp[j + 1], j - i - 1);
                    
                    if (dp[j] >= ansLen) {
                        ansLen = dp[j];
                        ans = s.substring(i, i + ansLen);
                    }
                } else {
                    dp[j] = 0;
                }
            }
        }
        
        return ansLen > 0 ? ans : "-1";
    }

    public static void main(String[] args) {
        String s = "geeksforgeeks";
        System.out.println(longestSubstring(s));
    }
}

Python

# Python program to find longest repeating
# and non-overlapping substring
# using space optimised

def longestSubstring(s):
    n = len(s)
    dp = [0] * (n + 1)
    
    ans = ""
    ansLen = 0
    
    # find length of non-overlapping 
    # substrings for all pairs (i, j)
    for i in range(n - 1, -1, -1):
        for j in range(i, n):
            
            # if characters match, set value 
            # and compare with ansLen.
            if s[i] == s[j]:
                dp[j] = 1 + min(dp[j + 1], j - i - 1)
                
                if dp[j] >= ansLen:
                    ansLen = dp[j]
                    ans = s[i:i + ansLen]
            else:
                dp[j] = 0
    
    return ans if ansLen > 0 else "-1"

if __name__ == "__main__":
    s = "geeksforgeeks"
    print(longestSubstring(s))

// C# program to find longest repeating
// and non-overlapping substring
// using space optimised

using System;

class GfG {

    static string longestSubstring(string s) {
        int n = s.Length;
        int[] dp = new int[n + 1];
        
        string ans = "";
        int ansLen = 0;
        
        // find length of non-overlapping 
        // substrings for all pairs (i, j)
        for (int i = n - 1; i >= 0; i--) {
            for (int j = i; j < n; j++) {
                
                // if characters match, set value 
                // and compare with ansLen.
                if (s[i] == s[j]) {
                    dp[j] = 1 + Math.Min(dp[j + 1], j - i - 1);
                    
                    if (dp[j] >= ansLen) {
                        ansLen = dp[j];
                        ans = s.Substring(i, ansLen);
                    }
                } else {
                    dp[j] = 0;
                }
            }
        }
        
        return ansLen > 0 ? ans : "-1";
    }

    static void Main(string[] args) {
        string s = "geeksforgeeks";
        Console.WriteLine(longestSubstring(s));
    }
}

JavaScript

// JavaScript program to find longest repeating
// and non-overlapping substring
// using space optimised

function longestSubstring(s) {
    const n = s.length;
    const dp = new Array(n + 1).fill(0);
    
    let ans = "";
    let ansLen = 0;
    
    // find length of non-overlapping 
    // substrings for all pairs (i, j)
    for (let i = n - 1; i >= 0; i--) {
        for (let j = i; j < n; j++) {
            
            // if characters match, set value 
            // and compare with ansLen.
            if (s[i] === s[j]) {
                dp[j] = 1 + Math.min(dp[j + 1], j - i - 1);
                
                if (dp[j] >= ansLen) {
                    ansLen = dp[j];
                    ans = s.substring(i, i + ansLen);
                }
            } else {
                dp[j] = 0;
            }
        }
    }
    
    return ansLen > 0 ? ans : "-1";
}

const s = "geeksforgeeks";
console.log(longestSubstring(s));