Two similar codes: one throws TLE while the other doesn't. Can't figure out the difference between both

I was solving a problem during the biweekly contest on Leetcode.

Link: https://leetcode.com/problems/find-servers-that-handled-most-number-of-requests/

I first tried a brute force but I was sceptical if it would work. And as it turned out, I ended up with a TLE. Later after having solved the question using TreeSet and PQs, I found one submission which was almost a replica of my own brute force attempt. And this one was accepted. I was unable to find any differences. Can anyone point them out to me?

MY CODE:

public List<Integer> busiestServers(int k, int[] arrival, int[] load) {
        int[] time = new int[k];
        int[] count = new int[k];
        for (int i = 0; i < arrival.length; i++) {
            int x = i%k;
            for (int j = 0; j < k; j++, x++) {
                if (x == k) x = 0;
                if (time[x] <= arrival[i]) {
                    count[x]++;
                    time[x] = arrival[i] + load[i]; 
                    break;
                }
            }
        }
        List<Integer> ans = new ArrayList<Integer>();
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < count.length; i++) {
            if (count[i] == max)
                ans.add(i);
            else if (count[i] > max) {
                ans = new ArrayList<Integer>();
                ans.add(i);
                max = count[i];
            }
        }
        return ans;
    }

THE CODE THAT WAS ACCEPTED:

public List<Integer> busiestServers(int k, int[] as, int[] ls) {
        int exp[] = new int[k], cnt[] = new int[k], max = 0;
        for (int i = 0; i < as.length; i++) {
            int t = as[i], l = ls[i], s = i % k;
            for (int j = 0; j < k; j++, s++) {
                if (s == k) s = 0;
                if (exp
展开收缩
 <= t) {  // check if free by last job expiration time;
                    cnt
展开收缩
++;
                    exp
展开收缩
 = t + l;  // load the job and set the job exp time;
                    break;
                }
            }
        }
        List<Integer> res = new ArrayList<>();
        for (int i = 0; i < k; i++) {
            if (cnt[i] == max) res.add(i);
            else if (cnt[i] > max) {
                max = cnt[i];
                res = new ArrayList<>();
                res.add(i);
            }
        }
        return res;
    }

The only (barely) meaningful difference I can see is that you access arrival[i] and load[i] each time inside your j loop, whereas the accepted solution puts them in variables outside the loop and refers to those variables every time, which means their inner loop is (apparently) slightly faster. Incredibly, for this specific Leetcode problem, this does seem to make the difference between Accepted and Time Limit Exceeded.

Specifically, I rewrote this loop in your code:

for (int j = 0; j < k; j++, x++) {
    if (x == k) x = 0;
    if (time[x] <= arrival[i]) {
        count[x]++;
        time[x] = arrival[i] + load[i];
        break;
    }
}

as follows to match the second solution you posted, which was Accepted:

int currentArrival = arrival[i];
int currentLoad = load[i];
for (int j = 0; j < k; j++, x++) {
    if (x == k) x = 0;
    if (time[x] <= currentArrival) {
        count[x]++;
        time[x] = currentArrival + currentLoad;
        break;
    }
}