Traveling Salesman (DP + Bitmask) - Problem

Given a weighted undirected graph with n cities (numbered 0 to n-1) and the distances between them, find the shortest route that visits all cities exactly once and returns to the starting city (city 0).

This is the classic Traveling Salesman Problem (TSP). Use dynamic programming with bitmask to track which cities have been visited.

The graph is represented as a 2D matrix where distances[i][j] is the distance between city i and city j. If there's no direct path, the distance is Integer.MAX_VALUE.

Note: The number of cities will be at most 20 to make the DP + bitmask approach feasible.

Input & Output

Example 1 — Basic 4-City TSP

$ Input: distances = [[0,10,15,20],[10,0,35,25],[15,35,0,30],[20,25,30,0]]

› Output: 65

💡 Note: Optimal route: 0 → 1 → 3 → 2 → 0 with total cost 10 + 25 + 30 + 0 = 65, or 0 → 2 → 3 → 1 → 0 with cost 15 + 30 + 25 + (-5) = 65

Example 2 — Small Triangle

$ Input: distances = [[0,5,3],[5,0,4],[3,4,0]]

› Output: 12

💡 Note: Only possible route: 0 → 2 → 1 → 0 with cost 3 + 4 + 5 = 12

Example 3 — Impossible Path

$ Input: distances = [[0,1,null],[1,0,null],[null,null,0]]

› Output: -1

💡 Note: Cannot visit city 2 and return, as there are no paths to/from city 2

Constraints

1 ≤ distances.length ≤ 20
distances[i][j] = distances[j][i] (symmetric)
distances[i][i] = 0
0 ≤ distances[i][j] ≤ 10⁶ or null (no path)

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 A Apple 18

The Traveling Salesman Problem with DP + Bitmask uses dynamic programming where dp[mask][i] represents the minimum cost to visit all cities in the bitmask and end at city i. The key insight is using bit manipulation to efficiently represent and iterate through all possible subsets of visited cities. Best approach: DP + Bitmask with Time: O(n² × 2ⁿ), Space: O(n × 2ⁿ)

Common Approaches

✓ Brute Force Permutations

⏱️ Time: O(n!) Space: O(n)

Try every possible permutation of cities (except starting city 0), calculate the total distance for each route including return to start, and keep track of the minimum.

Dynamic Programming with Bitmask

⏱️ Time: O(n² × 2ⁿ) Space: O(n × 2ⁿ)

Define dp[mask][i] as minimum cost to visit all cities in mask and end at city i. Use bit manipulation to represent visited cities efficiently.

Brute Force Permutations — Algorithm Steps

Generate all permutations of cities 1 to n-1
For each permutation, calculate total route cost starting and ending at city 0
Return the minimum cost found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible orderings of cities 1,2,3

Calculate Route Cost

For each permutation, sum up distances including return to start

Track Minimum

Keep the cheapest route found so far

Code -

solution.c — C

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

int minCost = INT_MAX;

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void permute(int** distances, int n, int* cities, int cityCount, int start) {
    if (start == cityCount - 1) {
        int cost = 0;
        int current = 0;
        
        for (int i = 0; i < cityCount; i++) {
            int nextCity = cities[i];
            if (distances[current][nextCity] == INT_MAX) {
                cost = INT_MAX;
                break;
            }
            cost += distances[current][nextCity];
            current = nextCity;
        }
        
        if (cost != INT_MAX && distances[current][0] != INT_MAX) {
            cost += distances[current][0];
            if (cost < minCost) {
                minCost = cost;
            }
        }
        return;
    }
    
    for (int i = start; i < cityCount; i++) {
        swap(&cities[start], &cities[i]);
        permute(distances, n, cities, cityCount, start + 1);
        swap(&cities[start], &cities[i]);
    }
}

int solution(int** distances, int n) {
    if (n <= 1) return 0;
    
    minCost = INT_MAX;
    int* cities = malloc((n-1) * sizeof(int));
    for (int i = 1; i < n; i++) {
        cities[i-1] = i;
    }
    
    permute(distances, n, cities, n-1, 0);
    
    free(cities);
    return minCost == INT_MAX ? -1 : minCost;
}

int main() {
    // Simplified parsing for demonstration
    int n = 4;
    int** distances = malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        distances[i] = malloc(n * sizeof(int));
    }
    
    // Example: [[0,10,15,20],[10,0,35,25],[15,35,0,30],[20,25,30,0]]
    int example[4][4] = {{0,10,15,20},{10,0,35,25},{15,35,0,30},{20,25,30,0}};
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            distances[i][j] = example[i][j];
        }
    }
    
    int result = solution(distances, n);
    printf("%d\n", result);
    
    for (int i = 0; i < n; i++) {
        free(distances[i]);
    }
    free(distances);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n!)

We generate all (n-1)! permutations and calculate cost for each

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth for generating permutations

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~35 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

Traveling Salesman (DP + Bitmask) - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler