Largest subarray sum of all connected components in undirected graph

// Java implementation to find
// largest subarray sum among
// all connected components
import java.io.*;
import java.util.*;

class GFG{

// Function to traverse the undirected
// graph using the Depth first traversal
static void depthFirst(int v, List<List<Integer>> graph,
                       boolean[] visited, 
                       List<Integer> storeChain)
{
  // Marking the visited
  // vertex as true
  visited[v] = true;

  // Store the connected chain
  storeChain.add(v);

  for (int i : graph.get(v)) 
  {
    if (visited[i] == false) 
    {
      // Recursive call to
      // the DFS algorithm
      depthFirst(i, graph, 
                 visited, 
                 storeChain);
    }
  }
}

// Function to return maximum
// subarray sum of each connected
// component using Kadane's Algorithm
static int subarraySum(int arr[], 
                       int n)
{
  int maxSubarraySum = arr[0];
  int currentMax = arr[0];

  // Following loop finds maximum
  // subarray sum based on Kadane's
  // algorithm
  for (int i = 1; i < n; i++) 
  {
    currentMax = Math.max(arr[i], arr[i] + 
                          currentMax);

    // Global maximum subarray sum
    maxSubarraySum = Math.max(maxSubarraySum, 
                              currentMax);
  }

  // Returning the sum
  return maxSubarraySum;
}

// Function to find the maximum subarray
// sum among all connected components
static void maxSubarraySum(List<List<Integer>> graph,
                           int vertices,
                           List<Integer> values)
{
  // Initializing boolean array
  // to mark visited vertices
  boolean[] visited = new boolean[1001];

  // maxSum stores the
  // maximum subarray sum
  int maxSum = Integer.MIN_VALUE;

  // Following loop invokes DFS 
  // algorithm
  for (int i = 1; i <= vertices; i++) 
  {
    if (visited[i] == false) 
    {
      // Variable to hold
      // temporary length
      int sizeChain;

      // Variable to hold temporary
      // maximum subarray sum values
      int tempSum;

      // Container to store each chain
      List<Integer> storeChain = 
           new ArrayList<Integer>();

      // DFS algorithm
      depthFirst(i, graph, 
                 visited, storeChain);

      // Variable to hold each 
      // chain size
      sizeChain = storeChain.size();

      // Container to store values
      // of vertices of individual chains
      int[] chainValues = 
            new int[sizeChain + 1];

      // Storing the values of each chain
      for (int j = 0; j < sizeChain; j++) 
      {
        int temp = values.get(storeChain.get(j) - 1);
        chainValues[j] = temp;
      }

      // Function call to find maximum
      // subarray sum of current connection
      tempSum = subarraySum(chainValues, 
                            sizeChain);

      // Conditional to store current
      // maximum subarray sum
      if (tempSum > maxSum) 
      {
        maxSum = tempSum;
      }
    }
  }

  // Printing global maximum subarray sum
  System.out.print("Maximum subarray sum among all ");
  System.out.print("connected components = ");
  System.out.print(maxSum);
}

// Driver code
public static void main(String[] args)
{
  // Initializing graph in the
  // form of adjacency list
  List<List<Integer>> graph = 
       new ArrayList();

  for (int i = 0; i < 1001; i++)
    graph.add(new ArrayList<Integer>());

  // Defining the number
  // of edges and vertices
  int E = 4, V = 7;

  // Assigning the values for each
  // vertex of the undirected graph
  List<Integer> values = 
       new ArrayList<Integer>();
  
  values.add(3);
  values.add(2);
  values.add(4);
  values.add(-2);
  values.add(0);
  values.add(-1);
  values.add(-5);

  // Constructing the undirected
  // graph
  graph.get(1).add(2);
  graph.get(2).add(1);
  graph.get(3).add(4);
  graph.get(4).add(3);
  graph.get(4).add(5);
  graph.get(5).add(4);
  graph.get(6).add(7);
  graph.get(7).add(6);

  maxSubarraySum(graph, V, values);
}
}

// This code is contributed by jithin