Problem Statement:

Given a matrix M of size N where M[i][j] denotes the cost of moving from city i to city j. Your task is to complete a tour from the city 0 (0-based index) to all other cities such that you visit each city at most once and then at the end come back to the city 0 in min cost.

Input Format

The first line of input contains an integer T denoting the no of test cases. Then T test cases follow. Each test case contains an integer N denoting the size of the matrix then in the next line are N*N space separated values of the matrix M.

Constraints

1<=T<=15, 1<=N<=12, 1<=M[][]<10000

Output Format

For each test case print the required result denoting the min cost of the tour in a new line.

Sample Input

220 111112 030 1000 50005000 0 10001000 5000 0

Sample Output

2233000

Input Visualization

Algorithm

• Take the graph input into a 2D matrix.
• Initialize a visited array of n sizes with 0.
• Set visited[0] to 1.
• Call traverse with arr, cur node (0), number of nodes visited (cnt = 1), total cost (0), Since already in 0th node so the cost of going from 0th node to 0th node is 0.
• Check if cnt == n. If true then we have visited all the nodes. Put the minimum of ans and ( total + cost of going from the current node to node 0) into ans. Then return.
• Iterate through all the nodes.
• If the ith node is not visited and it’s a valid node make visited[cur]=1. Call traverse by making ith node equal to cur, cnt+1 and total+cost from cur to ith node (arr[cur][i]).

C++ Implementation

#include <iostream>
#include <vector>
#include <climits>
using namespace std;

int ans = INT_MAX, n;

bool valid(int i) {
  return i >= 0 && i < n;
}

void traverse(vector<vector<int> >& arr, int cur, vector<int> visited, int cnt, int total) {
  // all nodes are visited
  if(cnt == n) {
    ans = min(ans, total + arr[cur][0]); // add the distance from last node to the 0th node
    return;
  }
  
  // explore all the paths that are not yet visited
  for(int i = 0; i < n; i++) {
    if(!visited[i] && valid(i)) {
      visited[i] = 1;
      traverse(arr, i, visited, cnt+1, total+arr[cur][i]);
      visited[i] = 0; // so that this node can be used in another sequence to check if min cost can be obtained
    }
  }
}

int main() {
  int t;
  cin>>t;
  
  while(t--) {
    cin>>n;
    vector<vector<int> > arr(n, vector<int>(n));
    vector<int> visited(n, 0);
    ans = INT_MAX;
    
    // take the graph input
    for(int i = 0; i < n; i++) {
      for(int j = 0; j < n; j++) {
        cin>>arr[i][j];
      }
    }
    
    visited[0] = 1;
    // check all possible path to find the min cost path
    traverse(arr, 0, visited, 1, 0); 
    
    cout<<ans<<endl;
  }
  return 0;
}

Problem link: Travelling Salesman - Target Samsung 13 Nov’19 ——

Before we get any further let’s clear up one thing FUSE is not the fuse that interrupts the circuit when the current becomes too strong. Now that the pun is out of the way let’s get started.

FUSE or Filesystem in Userspace is a software interface for Unix and Unix-like computer operating systems that lets non-privileged users create their own file systems without editing kernel code¹.

Allowing secure, non-privileged mounts is one of FUSE’s most significant features. This broadens the scope of filesystem applications. Sshfs², a secure network filesystem that uses the sftp protocol, is an excellent example.

Premise

This article assumes you already have a filesystem written in Python. Now the next step is to mount it in your system (assuming it’s Unix-like OS). For Windows refer to WinFsp. The article was written using Ubuntu 22.04.

Installing dependencies

To run a FUSE-based filesystem, first, we need to install the FUSE and fusepy modules. The corresponding steps and commands are as follows:

1. Install FUSE: You can install FUSE module on Ubuntu using the following command:

sudo apt-get install fuse

1. Install fusepy: You can install fusepy using pip, the package manager for Python. If pip is not installed, you can install it using the following command:

sudo apt-get install python3-pip

1. Once you have pip installed, you can install fusepy by running the following command:

pip3 install fusepy

Mounting the file-system

Now that we have installed the dependencies why not mount the filesystem to see what it does! Suppose you have the codes for the filesystem saved in a Python file with a .py extension, for example, examplefs.py.

1. Run the code: To run the code, open a terminal and navigate to the directory where you saved the code and run the following command:

python3 entropyfs.py <mountpoint>

1. Replace <mountpoint> with the directory where you want to mount the file system. This directory must exist before you run the command.

2. For example, if you want to mount the file system to the ~/testfs directory, run the following command:

python3 entropyfs.py ~/testfs

1. The file system is now mounted, and you can interact with it as you would any other file system.

2. To see the list of all mounted filesystems run the following command

mount

Unmount the filesystem

To unmount the file system, you can use the umount command in the terminal.

1. First, you need to navigate to the directory where you mounted the file system. For example, if you mounted the file system to ~/testfs, you can navigate to it using the following command:

cd ~/testfs

1. Then, to unmount the file system, run the following command:

sudo umount <mountpoint>

1. Replace <mountpoint> with the directory where you mounted the file system. In this example, it would be ~/testfs.

2. For example, the command to unmount the file system mounted at ~/testfs would be:

sudo umount ~/entropyfs

After running this command, the file system will be unmounted and you can no longer access it.