As in the picture, I am not sure what method to use to get the minimum number of modifications to change the node values of a binary tree to get a BST, I’m searching for a long time on net and tried to change values bottom-up, but got the wrong answer. Please help or try to give some ideas how to achieve thisfull description of this problem, thanks in advance

I did try some basic depth first search, but it had a problem with calculating minimal modify times, and I don’t know how to improve it,here’s the code I wrote:
my problem is in the part annotated//DFS part
I’ll be really grateful if anyone can provide some ideas

import java.util.*;

class Node {
int value;
Node left, right, parent;
int nodeNumber;

public Node(int value, int nodeNumber) {
    this.value = value;
    this.nodeNumber = nodeNumber;
}
}

public class Main {
private static int minModifications;
private static List<Integer> inorderTraversalList = new ArrayList<>();
public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();
    int[] values = new int[n];
    Node[] nodes = new Node[n + 1];

    for (int i = 1; i <= n; i++) {
        values[i - 1] = scanner.nextInt();
        nodes[i] = new Node(values[i - 1], i);
    }

    for (int i = 1; i < n; i++) {
        int fa = scanner.nextInt();
        int ch = scanner.nextInt();
        if (ch == 0) {
            nodes[fa].left = nodes[i + 1];
        } else {
            nodes[fa].right = nodes[i + 1];
        }
        nodes[i + 1].parent = nodes[fa];
    }
   //DFS part 
    inorderTraversal(nodes[1]);
    Collections.sort(inorderTraversalList);
    minModifications = 0;
    dfs(nodes[1], nodes[1].value, inorderTraversalList.get(0));
    System.out.println(minModifications);
    }

    private static void inorderTraversal(Node node) {
    if (node == null) {
        return;
    }
    inorderTraversal(node.left);
    inorderTraversalList.add(node.value);
    inorderTraversal(node.right);
    }

    private static void dfs(Node node, int currentValue, int sortedValue) {
    if (node == null) {
        return;
    }
    if(node.parent!=null){
        if(node.value==node.parent.value){
            minModifications++;
        }
    }
    if (node.value != sortedValue) {
        minModifications++;
    }
    dfs(node.left, currentValue + 1, sortedValue == node.value ? sortedValue + 1 :            sortedValue);
    dfs(node.right, currentValue + 1, sortedValue == node.value ? sortedValue :     sortedValue + 1);
}

}