Maximum sum of segments among all segments formed in array after Q queries

<script>

    // JavaScript program for the above approach

    // Stores the maximum integer of the sets
    // for each query
    let maxAns = -2147483648;

    // Function to perform the find operation
    // of disjoint set union
    const Find = (parent, a) => {
        return parent[a]
            = (parent[a] == a)
                ? a
                : (Find(
                    parent, parent[a]));
    }

    // Function to perform the Union operation
    // of disjoint set union
    const Union = (parent, rank, setSum, a, b) => {
    
        // Find the parent of a and b
        a = Find(parent, a);
        b = Find(parent, b);

        if (a == b)
            return;

        if (rank[a] > rank[b])
            rank[a]++;

        if (rank[b] > rank[a])
            swap(a, b);

        // Update the parent
        parent[b] = a;

        // Update the sum of set a
        setSum[a] += setSum[b];
    }

    // Function to find the maximum element
    // from the sets after each operation
    const maxValues = (arr, queries, N) => {

        // Stores the parent elements of
        // the sets
        let parent = new Array(N + 1).fill(0);

        // Stores the rank of the sets
        let rank = new Array(N + 1).fill(0);

        // Stores the sum of the sets
        let setSum = new Array(N + 1).fill(0);

        // Stores the maximum element for
        // each query
        let currMax = [];

        for (let i = 1; i < N + 1; i++) {

            // Initially set is empty
            parent[i] = -1;

            // Update the sum as the
            // current element
            setSum[i] = arr[i - 1];
        }

        // After the last query set will
        // be empty and sum will be 0
        currMax.push(0);

        for (let i = N - 1; i > 0; i--) {

            // Check if the current element
            // is not in any set then make
            // parent as current element
            // of the queries
            if (parent[queries[i]] == -1) {

                parent[queries[i]] = queries[i];
            }

            // Check left side of the queries[i]
            // is not added in any set
            if (queries[i] - 1 >= 0
                && parent[queries[i] - 1] != -1) {

                // Add the queries[i] and the
                // queries[i]-1 in one set
                Union(parent, rank, setSum,
                    queries[i],
                    queries[i] - 1);
            }

            // Check right side of the queries[i]
            // is not added in any set
            if (queries[i] + 1 <= N
                && parent[queries[i] + 1] != -1) {

                // Add queries[i] and the
                // queries[i]+1 in one set
                Union(parent, rank, setSum,
                    queries[i],
                    queries[i] + 1);
            }

            // Update the maxAns
            maxAns = Math.max(setSum[queries[i]], maxAns);

            // Push maxAns to the currMax
            currMax.push(maxAns);
        }

        // Print currMax values in the
        // reverse order
        for (let i = currMax.length - 1; i >= 0; i--) {
            document.write(`${currMax[i]} `);
        }
    }

    // Driver Code
    let arr = [1, 3, 2, 5];
    let queries = [3, 4, 1, 2];
    let N = arr.length;

    maxValues(arr, queries, N);

    // This code is contributed by rakeshsahni
</script>