Maximize Amount After Two Days of Conversions

Maximize Amount After Two Days of Conversions - Problem

Imagine you're a currency trader with a unique opportunity: you have access to different exchange rates on two consecutive trading days, and you want to maximize your profit!

You start with 1.0 unit of your initial currency. On Day 1, you can make any number of currency conversions using the rates from pairs1 and rates1. On Day 2, you can make additional conversions using pairs2 and rates2.

Key Rules:

Each conversion is bidirectional: if you can convert A→B at rate r, you can also convert B→A at rate 1/r
You can make zero or more conversions each day
Your goal is to end up with the maximum possible amount of your initial currency

Example: Start with 1.0 USD, convert USD→EUR at 0.85, then EUR→GBP at 1.2, then on day 2 convert GBP→USD at 1.3. Final amount: 1.0 × 0.85 × 1.2 × 1.3 = 1.326 USD

Input & Output

example_1.py — Basic Currency Exchange

$ Input: initialCurrency = "EUR", pairs1 = [["EUR","USD"], ["USD","JPY"]], rates1 = [2.0, 3.0], pairs2 = [["JPY","USD"], ["USD","EUR"]], rates2 = [4.0, 5.0]

› Output: 20.0

💡 Note: Day 1: Start with 1.0 EUR → convert to USD (1.0 × 2.0 = 2.0) → convert to JPY (2.0 × 3.0 = 6.0). Day 2: Convert JPY to USD (6.0 × 4.0 = 24.0) → convert to EUR (24.0 × 5.0 = 120.0). But wait, we can also convert back: JPY→USD at 4.0, USD→EUR at 5.0 gives us 6.0 × 4.0 × 5.0 = 120.0. However, the optimal path is EUR→USD→JPY on day 1 (getting 6.0 JPY), then JPY→USD on day 2 (getting 24.0 USD), but we need EUR back, so USD→EUR gives us 24.0/5.0 = 4.8. Actually, JPY→USD→EUR gives us 6.0 × 4.0 / 5.0 = 4.8. The maximum we can achieve is 20.0 EUR.

example_2.py — No Conversion Optimal

$ Input: initialCurrency = "USD", pairs1 = [["USD","EUR"]], rates1 = [0.8], pairs2 = [["EUR","USD"]], rates2 = [1.1]

› Output: 1.0

💡 Note: Day 1: We can convert USD→EUR at 0.8 (getting 0.8 EUR) or stay with USD (1.0). Day 2: If we have 0.8 EUR, we can convert back to USD at 0.8 × 1.1 = 0.88 USD. Since 1.0 > 0.88, the optimal strategy is to make no conversions and keep the original 1.0 USD.

example_3.py — Multiple Currency Chain

$ Input: initialCurrency = "USD", pairs1 = [["USD","EUR"], ["EUR","GBP"]], rates1 = [0.85, 1.2], pairs2 = [["GBP","USD"]], rates2 = [1.3]

› Output: 1.326

💡 Note: Day 1: USD→EUR→GBP gives us 1.0 × 0.85 × 1.2 = 1.02 GBP. Day 2: Convert GBP→USD gives us 1.02 × 1.3 = 1.326 USD. This is better than staying in USD (1.0) or just converting USD→EUR and back.

Constraints

1 ≤ pairs1.length, pairs2.length ≤ 10
rates1.length == pairs1.length and rates2.length == pairs2.length
1 ≤ pairs1[i][0].length, pairs1[i][1].length ≤ 5
0.01 ≤ rates1[i], rates2[i] ≤ 100
All currency names consist of uppercase English letters only
No contradictory rates within the same day

Asked in

This problem requires finding the maximum product path across two weighted graphs. The optimal approach uses DFS with backtracking to find all reachable currencies and their maximum amounts on Day 1, then applies the same technique for Day 2 to find the best return path to the initial currency. Key insight: treat this as two separate graph traversal problems where Day 1 results become starting points for Day 2.

Common Approaches

Approach	Time	Space	Notes
✓ Graph DFS with Memoization	O(V₁ + E₁ + V₂ + E₂)	O(V₁ + V₂)	Use DFS with visited tracking to find maximum conversion paths efficiently
Brute Force (DFS All Paths)	O(2^(E₁+E₂))	O(V₁+V₂)	Try every possible sequence of conversions using recursive DFS

Graph DFS with Memoization — Algorithm Steps

Build bidirectional weighted graphs for both days from currency pairs
Use DFS on day 1 graph to find all currencies reachable with maximum amounts
For each currency from day 1, use DFS on day 2 graph to find paths back to initial currency
Track the maximum amount of initial currency achievable across all paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graphs

Create bidirectional weighted graphs for both trading days

Day 1 DFS

Find maximum amounts reachable for each currency using DFS with backtracking

Day 2 DFS

For each Day 1 result, find optimal paths back to initial currency

Track Maximum

Maintain running maximum of initial currency amounts found

Code -

solution.c — C

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

#define MAX_CURRENCIES 100
#define MAX_PAIRS 1000
#define MAX_NAME_LEN 10

typedef struct {
    char name[MAX_NAME_LEN];
    double rate;
} Edge;

typedef struct {
    Edge edges[MAX_PAIRS];
    int count;
} AdjList;

typedef struct {
    char currencies[MAX_CURRENCIES][MAX_NAME_LEN];
    AdjList adj[MAX_CURRENCIES];
    int currencyCount;
} Graph;

typedef struct {
    char currency[MAX_NAME_LEN];
    double amount;
} Result;

int findOrAddCurrency(Graph* graph, const char* currency) {
    for (int i = 0; i < graph->currencyCount; i++) {
        if (strcmp(graph->currencies[i], currency) == 0) {
            return i;
        }
    }
    strcpy(graph->currencies[graph->currencyCount], currency);
    return graph->currencyCount++;
}

Graph* buildGraph(char*** pairs, double* rates, int pairCount) {
    Graph* graph = (Graph*)calloc(1, sizeof(Graph));
    
    for (int i = 0; i < pairCount; i++) {
        int aIdx = findOrAddCurrency(graph, pairs[i][0]);
        int bIdx = findOrAddCurrency(graph, pairs[i][1]);
        double rate = rates[i];
        
        strcpy(graph->adj[aIdx].edges[graph->adj[aIdx].count].name, pairs[i][1]);
        graph->adj[aIdx].edges[graph->adj[aIdx].count].rate = rate;
        graph->adj[aIdx].count++;
        
        strcpy(graph->adj[bIdx].edges[graph->adj[bIdx].count].name, pairs[i][0]);
        graph->adj[bIdx].edges[graph->adj[bIdx].count].rate = 1.0 / rate;
        graph->adj[bIdx].count++;
    }
    
    return graph;
}

void dfs(Graph* graph, const char* currency, double amount, int* visited, Result* maxAmounts, int* resultCount) {
    int currencyIdx = -1;
    for (int i = 0; i < graph->currencyCount; i++) {
        if (strcmp(graph->currencies[i], currency) == 0) {
            currencyIdx = i;
            break;
        }
    }
    
    if (currencyIdx == -1 || visited[currencyIdx]) return;
    
    visited[currencyIdx] = 1;
    
    // Update max amount for this currency
    int found = 0;
    for (int i = 0; i < *resultCount; i++) {
        if (strcmp(maxAmounts[i].currency, currency) == 0) {
            maxAmounts[i].amount = fmax(maxAmounts[i].amount, amount);
            found = 1;
            break;
        }
    }
    if (!found) {
        strcpy(maxAmounts[*resultCount].currency, currency);
        maxAmounts[*resultCount].amount = amount;
        (*resultCount)++;
    }
    
    // Continue DFS
    for (int i = 0; i < graph->adj[currencyIdx].count; i++) {
        dfs(graph, graph->adj[currencyIdx].edges[i].name, 
            amount * graph->adj[currencyIdx].edges[i].rate, 
            visited, maxAmounts, resultCount);
    }
    
    visited[currencyIdx] = 0;
}

int findMaxAmounts(Graph* graph, const char* startCurrency, double startAmount, Result* results) {
    int visited[MAX_CURRENCIES] = {0};
    int resultCount = 0;
    
    dfs(graph, startCurrency, startAmount, visited, results, &resultCount);
    return resultCount;
}

double maxAmountAfterTwoDaysOfConversions(char* initialCurrency, char*** pairs1, double* rates1, int pairs1Count, char*** pairs2, double* rates2, int pairs2Count) {
    Graph* graph1 = buildGraph(pairs1, rates1, pairs1Count);
    Graph* graph2 = buildGraph(pairs2, rates2, pairs2Count);
    
    Result day1Results[MAX_CURRENCIES];
    int day1Count = findMaxAmounts(graph1, initialCurrency, 1.0, day1Results);
    
    double maxFinal = 1.0;
    
    // Find initial currency amount after day 1
    for (int i = 0; i < day1Count; i++) {
        if (strcmp(day1Results[i].currency, initialCurrency) == 0) {
            maxFinal = day1Results[i].amount;
            break;
        }
    }
    
    // Try day 2 conversions from each day 1 result
    for (int i = 0; i < day1Count; i++) {
        if (strcmp(day1Results[i].currency, initialCurrency) == 0) continue;
        
        Result day2Results[MAX_CURRENCIES];
        int day2Count = findMaxAmounts(graph2, day1Results[i].currency, day1Results[i].amount, day2Results);
        
        for (int j = 0; j < day2Count; j++) {
            if (strcmp(day2Results[j].currency, initialCurrency) == 0) {
                maxFinal = fmax(maxFinal, day2Results[j].amount);
            }
        }
    }
    
    free(graph1);
    free(graph2);
    return maxFinal;
}

Time & Space Complexity

Time Complexity

⏱️

O(V₁ + E₁ + V₂ + E₂)

We visit each vertex and edge at most once in each graph using proper DFS

✓ Linear Growth

Space Complexity

O(V₁ + V₂)

Space for graphs, recursion stack, and visited tracking

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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