删除最小数量的顶点以在图中找到链

Question

I have a graph (not directed and not weighted) and its adjacency matrix (matrix type - boolean). I need to remove the minimum number of vertices to find the chain in this graph. For the last two days I've been thinking about how to do this and haven't come to any decision, so I ask you for help.

In my head I have a rough idea of a solution, but I can't implement it. Here are my thoughts on this task.

1. Find the longest chain
2. Create an adjacency matrix for this chain
3. Change the initial adjacency matrix

Here is my attempts to implement this algorithm

    public void createChain() {
    int[][] maxMatrix = new int[adjMatrix.length][adjMatrix.length];
    Map<Integer, int[][]> curStr = new HashMap<>();
    Map<Integer, Map<Integer, int[][]>> maxStr = new HashMap<>();

    for (int i = 0; i < adjMatrix.length; i++) {
        for (int j = 0; j < adjMatrix.length; j++) {
            maxMatrix[i][j] = 0;
        }
    }
    createChain(maxMatrix, curStr, maxStr, 0);

    int maxKey = 0;
    for (int key : maxStr.keySet()) {
        if (key > maxKey) maxKey = key;
    }

    curStr = maxStr.get(maxKey);
    int maxKey1 = 0;
    for (int key : curStr.keySet()) {
        if (key > maxKey1) {
            maxKey1 = key;
        }
    }
    maxMatrix = curStr.get(maxKey1);

    for (int i = 0; i < maxMatrix.length; i++) {
        for (int j = 0; j < maxMatrix.length; j++) {
            adjMatrix[i][j] = maxMatrix[i][j] == 1;
        }
    }

}

private void createChain(int[][] matrix, Map<Integer, int[][]> curStr, Map<Integer, Map<Integer, int[][]>> maxStr, int i) {
    for (int j = i; j < matrix.length; j++) {
        if (adjMatrix[i][j]) {

            if (!curStr.containsKey(i)) {
                matrix[i][j] = 1;
                curStr.put(i, matrix);
                i = j;

                maxStr.put(curStr.size(), curStr);
                Map<Integer, int[][]> copyOfCurStr = new HashMap<>();
                for (Integer key : curStr.keySet()) {
                    copyOfCurStr.put(key, copyOfCurStr.get(key));
                }

                int[][] copyOfMatrix = new int[matrix.length][matrix.length];
                for (int k = 0; k < matrix.length; k++) {
                    for (int l = 0; l < matrix.length; l++) {
                        copyOfMatrix[i][j] = matrix[i][j];
                    }
                }
                createChain(copyOfMatrix, copyOfCurStr, maxStr, i);
            }
        }
    }
}

the program works for some input, but not for other. For example:

1. input , output . As you see, everything is working
2. input , output . The algorithm is not working correctly. The output should be like this

Answer 1

I think I found a solution. It is implemented based on a modified Hamiltonian path search algorithm.

private boolean isSafe(int v, int graph[][], int path[], int pos) {
    if (graph[path[pos - 1]][v] == 0)
        return false;

    for (int i = 0; i < pos; i++)
        if (path[i] == v)
            return false;

    return true;
}


private void hamCycleUtil(int graph[][], int path[], int pos, List<int[]> paths) {
    if (pos >= adjMatrix.length) {
        return;
    }

    for (int v = 0; v < adjMatrix.length; v++) {
        if (isSafe(v, graph, path, pos)) {
            path[pos] = v;

            int[] copyOfPath = new int[adjMatrix.length];
            System.arraycopy(path, 0, copyOfPath, 0, adjMatrix.length);
            paths.add(copyOfPath);


            hamCycleUtil(graph, path, pos + 1, paths);

            path[pos] = -1;
        }
    }
}


public int createChain() {
    List<int[]> paths = new ArrayList<>();
    int[][] matrix = new int[adjMatrix.length][adjMatrix.length];
    for (int i = 0; i < adjMatrix.length; i++) {
        for (int j = 0; j < adjMatrix.length; j++) {
            if (adjMatrix[i][j]) matrix[i][j] = 1;
            else matrix[i][j] = 0;
        }
    }
    int[] path = new int[adjMatrix.length];
    Arrays.fill(path, -1);

    for (int i = 0; i < adjMatrix.length; i++) {
        path[0] = i;
        hamCycleUtil(matrix, path, 1, paths);
    }

    int[] maxPath = new int[adjMatrix.length];
    Arrays.fill(maxPath, -1);
    int quantityOfElems = 0;
    int maxPathLength = 0;
    for (int[] chain : paths) {
        for (int value : chain) {
            if (value == -1) {
                break;
            }
            quantityOfElems++;
        }
        for (int value : maxPath) {
            if (value == -1) {
                break;
            }
            maxPathLength++;
        }
        if (quantityOfElems >= maxPathLength) {
            maxPath = Arrays.copyOf(chain, chain.length);
        }
        maxPathLength = 0;
        quantityOfElems = 0;
    }

    /*
    for (int value : maxPath) {
        System.out.print(value + " ");
    }
    System.out.println();*/

    for (int i = 0; i < adjMatrix.length; i++) {
        for (int j = 0; j < adjMatrix.length; j++) {
            adjMatrix[i][j] = false;
        }
    }

    quantityOfElems = 0;
    for (int i = 0; i < maxPath.length - 1; i++) {
        if (maxPath[i] == -1 || maxPath[i + 1] == -1) break;
        adjMatrix[maxPath[i]][maxPath[i + 1]] = true;
        adjMatrix[maxPath[i + 1]][maxPath[i]] = true;
        quantityOfElems++;
    }

    return maxPath.length - quantityOfElems - 1;
}

Examples:

1. input , output
2. input , output