You are visiting each index only once, but for every index you do a loop. If the there are N elements your worstcase in O(N^2), for example if all the values are greater tha N.

My solution is much simpler and works: The distance of the first value is 0, after that you will update the distance of every value once. I iterate over all values keeping the next value that I have not visited yet, when I update the next values I don't iterate over the value for which I have already found the minimum distance.

int n=A.size();
vector<int> dist(n,-1);
dist[0]=0;
int li=1; //next value to update
for(int i=0;i<n;i++){
    if(dist[i]==-1) return -1; //I cant'arrive here 
    for(;li<=i+A[i] && li<n;li++) dist[li]=dist[i]+1; //updating only new values
}
return dist[n-1];

Instead of running loop inside, you can keep track from where you need to start.

int Solution::jump(vector<int> &a) {
    int n=a.size();
    vector <bool> visited(n,false);
    visited[0]=true;
    queue <int> q;
    q.push(0);
    int ans=0;
    int start=1;
    while(!q.empty())
    {
        int n1=q.size();
        for(int i=0;i<n1;i++)
        {
            int s=q.front();
            if(s==n-1)
                return ans;
            q.pop();
            for(int j=start;j<=min(s+a[s],n-1);j++)
            {
                if(!visited[j])
                {
                    visited[j]=true;
                    q.push(j);
                    start++;
                }
            }
        }
        ans++;
    }
    return -1;
}