Forgive me if I'm wrong, but I think you can save values. This is the difference (if a[i] >= b[i] store it in an array), and also store a[i] in an array. Then sort the array, and find if there is so number that is repeated N times by your preference (binary search or pointer(s)). Alternatively you can iterate over a map, and count the number of times the element occurs.

Can be solved in $$$O(n*lg(n))$$$. Let the final value be $$$x$$$ then $$$x$$$ should satisfy $$$x \equiv a[i] \;(\bmod\; b[i]) \forall i$$$. Solution to all of the equations will be of the form $$$x \equiv r \;(\bmod\; lcm(b[1],b[2]..b[n]))$$$. $$$r$$$ can be calculated by using CRT. So no we will find $$$x$$$ s.t $$$x<=a[i] \forall i$$$ giving us the answer. Now remember lcm can get really big, so while processing equations one by one(blog) as soon as lcm gets > 5000, we know there will be only one $$$x$$$ in between [1..5000] so now you just need to check for that potential answer in O(n).

Another $$$n*log(n)$$$ solution:
Let $$$x$$$ be the number we make all $$$a$$$ for the best solution. Let's find $$$x$$$ first, then we can calculate the number of steps to make all $$$a$$$ to $$$x$$$ in $$$O(n)$$$.

For each $$$i,j$$$ such that $$$b_{i} = b_{j}$$$;
     If $$$a_{i} \not\equiv a_{j} (mod$$$ $$$b_{i})$$$ then the answer is $$$-1$$$ since we can never make equal $$$a_{i}$$$ and $$$a_{j}$$$.
     Otherwise, (let's assume $$$a_{i} < a_{j}$$$) Whatever the $$$x$$$ is, first we must transform $$$a_{j}$$$ to $$$a_{i}$$$ before we transform it to $$$x$$$. Therefore, we can ignore $$$a_{j}$$$ while finding $$$x$$$.

So, for each unique $$$b_{i}$$$ value, only the numbers { $$$ a_{i}, a_{i}-b_{i}, a_{i}-2*b_{i} \dots $$$ } are reachable ($$$\frac{a_{i}} {b_{i}}$$$ numbers).

$$$x$$$ is the maximum number such that it's reachable for all different $$$b_{i}$$$ values. While finding all "reachables" of all different $$$b$$$, we visit $$$\frac{a_{i}}{b_{i}}$$$ numbers for each different $$$b_{i}$$$. So, in the worst case, number of operations is $$$\frac{a_{max}}{1} + \frac{a_{max}}{2} + \dots + \frac{a_{max}}{a_{max}}$$$. Which is smaller than $$$a_{max}*log(a_{max}) = O(n*log(n))$$$

Here is my code. I got AC and maximum time is 0.009748 sec.

#include<bits/stdc++.h>
#define fori(A,B,C) for(int A=B; A<C; ++A)
#define ford(A,B,C) for(int A=B; A>=C; --A)
using namespace std;
typedef long long     ll;
typedef pair<int,int>   ii;
const int maxn = 5007, inf = 2e9 +9, mod = 1e9 +7;

int n,a[maxn],b[maxn],min_a_for[maxn],reachable[maxn],remainder_of[maxn];
vector<int> different_b;

int calculate_steps_for(int x) {
    int steps = 0;
    fori(i,0,n) {
       if(b[i]) /// there was a test case with a b[i] = 0 although there shouldn't
         steps += (a[i]-x)/b[i];
    }
    return steps;
}

int main() {
//  freopen("test.in","r",stdin);
    //freopen("test.out","w",stdout);
    scanf("%d",&n);
    fori(i,0,n)
    scanf("%d",&a[i]);
    fori(i,0,n)
    scanf("%d",&b[i]);

    fori(i,0,n) {
       int A = a[i];
       int B = b[i];
       if(!B) {/// there was a test case with a b[i] = 0 although there shouldn't
         printf("%d",calculate_steps_for(A));
         return 0;
       }
       if(min_a_for[B] == 0) { // first time we encountered B
         min_a_for[B] = A;
         remainder_of[B] = A % B;
         different_b.push_back(B);
       } else if(remainder_of[b[i]] != a[i] % b[i]) { // two indexes has same b, but remainders are different
         printf("-1");
         return 0;
       } else { // update min a vaulue which's b vaulue is B
         min_a_for[B] = min(min_a_for[B], A);
       }
    }
    for(int B : different_b) {
       for(int i = min_a_for[B]; i >= 0; i -= B) {
         reachable[i]++;
       }
    }

    // find greates number which is reachable by all different b values, hence by every element
    ford(i,maxn-1,0) {
       if(reachable[i] == different_b.size()) {
         printf("%d",calculate_steps_for(i));
         return 0;
       }
    }
    printf("-1");
    return 0;
}