bool EqualSubArrExists(vector<int>& A, vector<int>& B, int length) {
        unordered_set<long long> first_str_hashes;
        const int kP = 31;
        long long kP_n = 1;
        for (int i = 0; i < length; ++i)
            kP_n *= kP;

        // precompute all hashes of subarrays of length |length| for |A| using rolling hash algo:
        long long h1 = 0;
        for (int i = 0; i < length; ++i)
            h1 = h1 * kP + A[i];

        first_str_hashes.insert(h1);

        for (int i = length; i < A.size(); ++i) {
            h1 = (h1 - A[i - length] * kP_n) * kP + A[i];
            first_str_hashes.insert(h1);
        }

        // traverse all hashes in |B| and see if there is a matching hash in |first_str_hashes|:
        long long h2 = 0;
        for (int i = 0; i < length; ++i)
            h2 = h2 * kP + B[i];
        if (first_str_hashes.count(h2) > 0) return true;

        for (int i = length; i < B.size(); ++i) {
            h2 = (h2 - B[i - length] * kP_n) * kP + B[i];
            if (first_str_hashes.count(h2) > 0) return true;
        }

        return false;
    }


    int findLengthDP(vector<int>& A, vector<int>& B) {
        vector<int> dp(A.size());
        int max_len = 0;

        for (auto c : B) {
            for (int i = dp.size() - 1; i >= 0; --i) {
                if (A[i] == c) dp[i] = dp[i - 1] + 1;
                else  dp[i] = 0;

                max_len = max(max_len, dp[i]);
            }
        }

        return max_len;
    }