Find Longest Common Subpath

#include <bits/stdc++.h>
using namespace std;

const int MOD = 1e9 + 7;
// Base for Rabin-Karp algorithm
const int BASE = 100001;

bool check(int mid, vector<vector<int> >& paths, int n)
{
    // Map to store possible key value pair of hashes
    // and their starting position in previous path
    unordered_map<int, vector<int> > hs;
    for (int i = 0;
         i < paths.size() && (i == 0 || !hs.empty()); ++i) {
        // d stores the required power of base
        long long hash = 0, d = 1;
        // Map to store the found hashes in current path
        unordered_map<int, vector<int> > hs1;
        for (int j = 0; j < paths[i].size(); ++j) {
            // Update hash for current element
            hash = (hash * BASE + paths[i][j]) % MOD;
            // Remove the extra element in the front
            if (j >= mid) {
                hash = (MOD + hash
                        - d * paths[i][j - mid] % MOD)
                       % MOD;
            }
            else {
                // Increase the power of base
                d = d * BASE % MOD;
            }
            // We find a new hash every index from j = m
            // - 1
            if (j >= mid - 1) {
                // If this is the first path
                if (i == 0) {
                    hs1[hash].push_back(j + 1 - mid);
                }
                // For subsequent paths, check if hash
                // exists in previous path
                else {
                    if (hs.count(hash)) {
                        for (auto pos : hs[hash]) {
                            if (equal(begin(paths[0]) + pos,
                                      begin(paths[0]) + pos
                                          + mid,
                                      begin(paths[i]) + j
                                          + 1 - mid)) {
                                hs1[hash].push_back(pos);
                                break;
                            }
                        }
                    }
                }
            }
        }
        // Current map becomes previous map for next path
        swap(hs, hs1);
    }
    return !hs.empty();
}

int longestCommonSubpath(int n, vector<vector<int> >& paths)
{
    // Find the smallest length path of the given paths
    int lo = 0, hi = 1e9;
    for (auto path : paths) {
        hi = min(hi, (int)path.size());
    }

    // Binary Search on answer
    while (lo < hi) {
        // Check if common path of length mid exists
        int mid = (lo + hi + 1) / 2;

        if (check(mid, paths, n)) {
            lo = mid;
        }
        else {
            hi = mid - 1;
        }
    }
    return lo;
}

int main()
{
    // Sample Input
    vector<vector<int> > paths = { { 0, 1, 2, 3, 4 },
                                   { 2, 3, 4 },
                                   { 4, 0, 1, 2, 3 } };

    cout << longestCommonSubpath(5, paths) << endl;
    return 0;
}