Maximum Profit from Valid Topological Order in DAG

Maximum Profit from Valid Topological Order in DAG - Problem

Array Dynamic Programming Bit Manipulation Graph Topological Sort Bitmask Hard

Maximum Profit from Valid Topological Order in DAG

You're given a Directed Acyclic Graph (DAG) with n nodes labeled from 0 to n - 1. The graph is represented by a 2D array edges, where edges[i] = [ui, vi] indicates a directed edge from node ui to node vi.

Each node has an associated score[i] representing its value. Your task is to find a valid topological order of the nodes that maximizes profit.

🎯 Profit Calculation: Each node is assigned a 1-based position in the processing order. The total profit is the sum of score[i] × position[i] for all nodes.

📝 Topological Order: A linear ordering where for every directed edge u → v, node u comes before node v in the ordering.

Goal: Return the maximum possible profit achievable with an optimal topological order.

Input & Output

example_1.py — Simple Chain

$ Input: n = 3, edges = [[0,1],[1,2]], scores = [5,3,8]

› Output: 35

💡 Note: Only valid topological order is [0,1,2]. Profit = 5×1 + 3×2 + 8×3 = 5 + 6 + 24 = 35

example_2.py — Multiple Valid Orders

$ Input: n = 3, edges = [[0,1]], scores = [2,4,3]

› Output: 17

💡 Note: Valid orders: [0,1,2], [0,2,1], [2,0,1]. Best is [2,0,1] with profit = 3×1 + 2×2 + 4×3 = 3 + 4 + 12 = 19. Wait, let me recalculate: [0,2,1] gives 2×1 + 3×2 + 4×3 = 2 + 6 + 12 = 20. Actually [2,0,1] gives 3×1 + 2×2 + 4×3 = 3 + 4 + 12 = 19. The optimal is [0,2,1] = 20. But 0 must come before 1, so valid orders are [0,1,2]: 2×1 + 4×2 + 3×3 = 17, [0,2,1]: 2×1 + 3×2 + 4×3 = 20. Wait, this violates the constraint. Let me fix: [2,0,1]: not valid since 0→1. [0,1,2]: 2×1 + 4×2 + 3×3 = 17. [0,2,1]: 2×1 + 3×2 + 4×3 = 20, but this violates 0→1. So only [0,1,2] and [2,0,1] where 2 can go first. Actually [2,0,1] is valid. So [2,0,1]: 3×1 + 2×2 + 4×3 = 19. [0,1,2]: 2×1 + 4×2 + 3×3 = 17. [0,2,1]: not valid. Answer should be 19.

example_3.py — Single Node

$ Input: n = 1, edges = [], scores = [10]

› Output: 10

💡 Note: Only one node with score 10 at position 1. Profit = 10×1 = 10

Visualization

Tap to expand

Understanding the Visualization

Build Dependency Graph

Create adjacency list and track which courses depend on others

Identify Constraints

A course can only be taken after all its prerequisites are completed

Maximize Weighted Score

Place high-value courses later in the sequence when dependencies allow

Use DP with Bitmask

Efficiently explore all valid orderings using dynamic programming

Return Optimal Profit

Find the ordering that gives maximum weighted GPA sum

Key Takeaway

🎯 Key Insight: To maximize profit in topological ordering, place nodes with higher scores at later positions whenever the DAG constraints permit, using DP with bitmask for efficient exploration of all valid orderings.

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! possible topological orders, O(n) to calculate profit for each

⚠ Quadratic Growth

Space Complexity

O(n²)

O(n) recursion depth and O(n) for storing current ordering

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 20
0 ≤ edges.length ≤ n × (n - 1) / 2
edges[i].length == 2
0 ≤ u_i, v_i ≤ n - 1
The graph is guaranteed to be a DAG (no cycles)
1 ≤ scores[i] ≤ 10⁴

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

This problem requires finding the optimal topological ordering that maximizes profit. The key insight is that nodes with higher scores should be placed later in the ordering (higher positions) when possible, while respecting DAG constraints. For small graphs (n ≤ 20), dynamic programming with bitmask provides an efficient solution by exploring all valid orderings with memoization, achieving O(2^n × n²) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Generate All Valid Topological Orders	O(n! × n)	O(n²)	Generate all possible topological orders and compute profit for each
Dynamic Programming with Bitmask	O(2^n × n²)	O(2^n × n)	Use DP with bitmask to efficiently explore all valid orderings

Generate All Valid Topological Orders — Algorithm Steps

Build adjacency list and calculate in-degrees for all nodes
Use recursive backtracking to generate all valid topological orders
For each complete ordering, calculate total profit (score × position)
Track and return the maximum profit found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with empty ordering, all nodes available based on in-degree

Choose Node

Pick a node with in-degree 0 (no prerequisites)

Update State

Add node to ordering, decrease in-degrees of its neighbors

Recurse

Continue until complete ordering is formed

Calculate Profit

Compute profit for complete ordering and update maximum

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int maxProfit = 0;

void backtrack(int* order, int orderSize, int* inDegree, int** graph, 
               int* graphSizes, int* scores, int n) {
    if (orderSize == n) {
        // Calculate profit for this ordering
        int profit = 0;
        for (int i = 0; i < orderSize; i++) {
            profit += scores[order[i]] * (i + 1);
        }
        if (profit > maxProfit) {
            maxProfit = profit;
        }
        return;
    }
    
    // Try all nodes with in-degree 0
    for (int node = 0; node < n; node++) {
        if (inDegree[node] == 0) {
            // Check if node already in order
            int found = 0;
            for (int i = 0; i < orderSize; i++) {
                if (order[i] == node) {
                    found = 1;
                    break;
                }
            }
            
            if (!found) {
                // Add node to ordering
                order[orderSize] = node;
                
                // Update in-degrees of neighbors
                int* newInDegree = malloc(n * sizeof(int));
                memcpy(newInDegree, inDegree, n * sizeof(int));
                for (int i = 0; i < graphSizes[node]; i++) {
                    newInDegree[graph[node][i]]--;
                }
                
                backtrack(order, orderSize + 1, newInDegree, graph, graphSizes, scores, n);
                free(newInDegree);
            }
        }
    }
}

int maxProfitTopologicalOrder(int n, int** edges, int edgesSize, int* scores) {
    // Build graph and in-degrees
    int** graph = malloc(n * sizeof(int*));
    int* graphSizes = calloc(n, sizeof(int));
    int* inDegree = calloc(n, sizeof(int));
    
    for (int i = 0; i < n; i++) {
        graph[i] = malloc(n * sizeof(int));
    }
    
    for (int i = 0; i < edgesSize; i++) {
        graph[edges[i][0]][graphSizes[edges[i][0]]++] = edges[i][1];
        inDegree[edges[i][1]]++;
    }
    
    maxProfit = 0;
    int* order = malloc(n * sizeof(int));
    backtrack(order, 0, inDegree, graph, graphSizes, scores, n);
    
    free(order);
    for (int i = 0; i < n; i++) {
        free(graph[i]);
    }
    free(graph);
    free(graphSizes);
    free(inDegree);
    
    return maxProfit;
}

int main() {
    printf("Implementation requires JSON parsing\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! possible topological orders, O(n) to calculate profit for each

⚠ Quadratic Growth

Space Complexity

O(n²)

O(n) recursion depth and O(n) for storing current ordering

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 20
0 ≤ edges.length ≤ n × (n - 1) / 2
edges[i].length == 2
0 ≤ u_i, v_i ≤ n - 1
The graph is guaranteed to be a DAG (no cycles)
1 ≤ scores[i] ≤ 10⁴

28.4K Views

Medium Frequency

~25 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Generate All Valid Topological Orders — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler