import java.io.*;
import java.util.Scanner;

public class floyd {

    private static final int INF = (int) 1e9;

    public static void main(String[] args) {
        if (args.length != 1) {
            System.err.println(“Usage: java floyd <input_file_path>”);
            return;
        }

        String filePath = args[0];
        try (Scanner scanner = new Scanner(new File(filePath));
             PrintWriter writer = new PrintWriter(“output.txt”)) {

            while (scanner.hasNextLine()) {
                String line = scanner.nextLine();
                if (line.contains(“Problem”)) {
                    processInput(line, scanner, writer);
                }
            }

        } catch (FileNotFoundException e) {
            System.err.println(“File not found: " + e.getMessage());
        }
    }

    private static void processInput(String line, Scanner scanner, PrintWriter writer) {
        String[] lineParts = line.split(”\s+“);
        int problemNumber = Integer.parseInt(lineParts[0].replaceAll(”[^0-9]“, “”));

        int n = -1;
        for (String part : lineParts) {
            if (part.matches(”\d+")) {
                n = Integer.parseInt(part);
                break;
            }
        }
        if (n == -1) {
            System.err.println(“Failed to find matrix size ‘n’ in line: " + line);
            return;
        }

        int[][] dist = new int[n][n];
        int[][] P = new int[n][n];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (scanner.hasNextInt()) {
                    int distance = scanner.nextInt();
                    dist[i][j] = distance == 0 && i != j ? INF : distance;
                    P[i][j] = j + 1;
                }
            }
        }

        // Floyd-Warshall
        for (int k = 0; k < n; k++) {
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if (dist[i][k] + dist[k][j] < dist[i][j]) {
                        dist[i][j] = dist[i][k] + dist[k][j];
                        P[i][j] = P[i][k];
                    }
                }
            }
        }

        // Output results
        writer.printf(“Problem %d: n = %d\n”, problemNumber, n);
        writer.println(“Pmatrix:”);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                writer.printf(”%d ", P[i][j]);
            }
            writer.println();
        }
        writer.println();

        for (int i = 0; i < n; i++) {
            writer.printf(“V%d-Vj: shortest path and length\n”, i+1);
            for (int j = 0; j < n; j++) {
                if (dist[i][j] >= INF) {
                    writer.printf(“V%d to V%d: NO PATH\n”, i+1, j+1);
                } else {
                    writer.printf("V%d ", i+1); // Start of path
                    printPath(i, j, P, writer);
                    writer.printf(“V%d “, j+1); // End of path
                    writer.printf(”: %d\n”, dist[i][j]);
                }
            }
        }
        writer.println();
    }

    // Updated to properly reconstruct and print the path
    private static void printPath(int i, int j, int[][] P, PrintWriter writer) {
        // If there’s a direct path or no path, do not print intermediates
        if (P[i][j] == j+1 || P[i][j] == 0) return;
        
        int intermediate = P[i][j] - 1;
        printPath(i, intermediate, P, writer);
        writer.printf("V%d ", P[i][j]);
        printPath(intermediate, j, P, writer);
    }
} The program logic should be modified according to the logic of #include <iostream>
#include <fstream>
#include <vector>
#include <sstream>

using namespace std;

const int INF = 1e9; // Assuming INF represents infinity

class floydGraphProcessor
{
public:
    void processInput(const string &line, ifstream &infile, ofstream &outfile)
    {
        // Extract problem number and matrix size
        size_t problem_position = line.find("Problem");
        if (problem_position == string::npos)
        {
            cerr << "Error extracting parameters. \n";
            return;
        }

        int problemNumber, n;
        sscanf(line.c_str() + problem_position, "Problem%d", &problemNumber);

        // Extracting n from the line
        size_t n_position = line.find("n = ");
        if (n_position == string::npos)
        {
            cerr << "Error: 'n =' not found.\n";
            return;
        }

        sscanf(line.c_str() + n_position, "n = %d", &n);

        // Resize output matrix to n x n
        vector<vector<int>> matrix(n, vector<int>(n));

        // Read n x n matrix values
        for (int i = 0; i < n; i++)
        {
            string r;
            getline(infile, r);
            istringstream iss(r);
            for (int j = 0; j < n; j++)
            {
                iss >> matrix[i][j];
            }
        }

        // Output to file
        outfile << "Problem " << problemNumber << ": n = " << n << endl;
        vector<vector<int>> dist = matrix;
        vector<vector<int>> P(n, vector<int>(n, 0));

        // Floyd-Warshall algorithm
        for (int k = 0; k < n; k++)
        {
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    if (k != i && k != j && (dist[i][j] >= dist[i][k] + dist[k][j]))
                    {
                        dist[i][j] = dist[i][k] + dist[k][j];
                        P[i][j] = k + 1;
                    }
                }
            }
        }

        // Output final Pmatrix to file
        outfile << "Pmatrix:" << endl;
        printPath(P, n, outfile);
        outfile << endl;

        // shortest paths and length to file
        for (int i = 0; i < n; i++)
        {
            outfile << "V" << i + 1 << "-Vj: shortest path and length" << endl;
            for (int j = 0; j < n; j++)
            {
                outfile << "V" << i + 1 << " ";
                if (i != j)
                {
                    outfile << "V" << j + 1 << " ";
                    int v = j;
                    while (P[i][v] != 0)
                    {
                        outfile << "V" << P[i][v] << " ";
                        v = P[i][v] - 1;
                    }
                }
                outfile << ": " << dist[i][j] << endl;
            }
        }
    }

private:
    void printPath(const vector<vector<int>> &P, int n, ofstream &outfile)
    {
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                outfile << P[i][j] << " ";
            }
            outfile << endl;
        }
    }
};

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        cerr << "Usage: " << argv[0] << " <input_file_path>" << endl;
        return 1;
    }

    ifstream infile(argv[1]);
    if (!infile.is_open())
    {
        cerr << "Error!. Wrong usage of the file, error opening the file. " << endl;
        cout << "Correct usage : " << argv[0] << " <input_file_path>" << endl;
        return 1;
    }

    ofstream outfile("output.txt");
    if (!outfile.is_open())
    {
        cerr << "Error opening output file." << endl;
        return 1;
    }

    string line;
    floydGraphProcessor processor;
    while (getline(infile, line))
    {
        size_t found = line.find("Problem");
        if (found != string::npos)
        {
            processor.processInput(line, infile, outfile);
        }
    }

    infile.close();
    outfile.close();
    return 0;
} this program