vector<long long> Solution::solve(vector<long long> &A, vector<int> &B, vector<vector<int> > &C) {
    int n = A.size();
    
    vector <pair <long long, long long>> adj[n + 1];
    vector <vector <long long>> dist1(n + 1, vector <long long>(n + 1, 1e18));
    vector <vector <long long>> dist2(n + 1, vector <long long>(n + 1, 1e18));
    
    for(auto& edge : C){
        adj[edge[0]].push_back({edge[1], edge[2]});
        adj[edge[1]].push_back({edge[0], edge[2]});
    }
    
    for(int i=1; i<=n; i++){
        priority_queue <pair <long long, long long>, vector <pair <long long, long long>>, greater <pair <long long, long long>>> pq;
        
        dist1[i][i] = 0;
        pq.push({0, i});
        
        while(!pq.empty()){
            auto p = pq.top();
            pq.pop();
            
            long long d = p.first, v = p.second;
            for(auto& u : adj[v]){
                if(d + u.second < dist1[i][u.first]){
                    dist1[i][u.first] = d + u.second;
                    pq.push({dist1[i][u.first], u.first});
                }
            }
        }
        
        dist2[i][i] = A[i - 1];
        pq.push({A[i - 1], i});
        
        while(!pq.empty()){
            auto p = pq.top();
            pq.pop();
            
            long long d = p.first, v = p.second;
            for(auto& u : adj[v]){
                if(d + u.second + B[i - 1] < dist2[i][u.first]){
                    dist2[i][u.first] = d + u.second + B[i - 1];
                    pq.push({dist2[i][u.first], u.first});
                }
            }
        }
    }
    
    vector <long long> ans;
    for(int i=1; i<=n; i++){
        long long curr = 1e18;
        for(int j=1; j<=n; j++){
            if(dist1[i][j] != 1e18 && dist2[j][i] != 1e18){
                curr = min(curr, dist1[i][j] + dist2[j][i]);
            }
        }
        
        ans.push_back(curr);
    }
    
    return ans;
}

Main thing to observe was we may not follow the same path while returning. We want to minimise (path weight + number of edges in path * B[v]) while returning. For each u, we will calculate 2 dp values.
dp1: dp1[v] = minimum weight to get to v from u.
dp2: dp2[v][cnt] = minimum weight to get to v from u using cnt edges.
dp1 can be calculated using Dijkstras.
For dp2 also I was using Dijkstras which resulted in O(n^2 * log(n^2)) complexity and thus TLE.

Now using dp1 and dp2 we can calculate for each u the minimum cost to get the treasure in O(n^2). So overall complexity will be O(n^3)