1```csharp
2using System;
3using System.Collections.Generic;
4
5public class ParallelCourses {
6    public static int MinTime(int n, int[][] relations, int[] time) {
7        var adj = new List<int>[n + 1];
8        var indegree = new int[n + 1];
9        var dp = new int[n + 1];
10
11        for (int i = 0; i <= n; i++)
12            adj[i] = new List<int>();
13
14        foreach (var relation in relations) {
            int u = relation[0], v = relation[1];
            adj[u].Add(v);
            indegree[v]++;
        }

        var queue = new Queue<int>();
        for (int i = 1; i <= n; i++) {
            if (indegree[i] == 0) {
                queue.Enqueue(i);
                dp[i] = time[i - 1];
            }
        }

        while (queue.Count > 0) {
            int u = queue.Dequeue();
            foreach (var v in adj[u]) {
                dp[v] = Math.Max(dp[v], dp[u] + time[v - 1]);
                indegree[v]--;
                if (indegree[v] == 0) {
                    queue.Enqueue(v);
                }
            }
        }

        int maxTime = 0;
        for (int i = 1; i <= n; i++)
            maxTime = Math.Max(maxTime, dp[i]);

        return maxTime;
    }

    public static void Main() {
        int n = 5;
        int[][] relations = new int[][] { new int[] { 1,5 }, new int[] { 2,5 }, new int[] { 3,5 }, new int[] { 3,4 }, new int[] { 4,5 } };
        int[] time = new int[] { 1, 2, 3, 4, 5 };
        Console.WriteLine(MinTime(n, relations, time)); // Output: 12
    }
}
```

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int dfs(int u, const vector<vector<int>>& adj, vector<int>& dp, const vector<int>& time) {
    if (dp[u] != 0) return dp[u];
    dp[u] = time[u - 1];
    for (int v : adj[u]) {
        dp[u] = max(dp[u], dfs(v, adj, dp, time) + time[u - 1]);
    }
    return dp[u];
}

int minTimeDFS(int n, vector<vector<int>>& relations, vector<int>& time) {
    vector<vector<int>> adj(n + 1);
    for (const auto& rel : relations) {
        adj[rel[0]].push_back(rel[1]);
    }

    vector<int> dp(n + 1, 0);
    int maxTime = 0;
    for (int i = 1; i <= n; ++i) {
        maxTime = max(maxTime, dfs(i, adj, dp, time));
    }

    return maxTime;
}

int main() {
    int n = 5;
    vector<vector<int>> relations = {{1,5},{2,5},{3,5},{3,4},{4,5}};
    vector<int> time = {1, 2, 3, 4, 5};
    cout << minTimeDFS(n, relations, time) << endl;
    return 0;
}
```