// Implementation of Dynamic Programming for the contiguous
// load-balancing problem (Module 9). The code as shown is
// incomplete: it only computes the optimal costs. The computation
// of the actual partition itself is left as an exercise (of course).


public class DynamicProgrammingLoadBalancing {

  static int[] dynamicProgramming (double[] taskTimes, int numProcessors)
  {
    int numTasks = taskTimes.length;

    // If we have enough processors, one processor per task is optimal.
    if (numProcessors >= numTasks) {
      int[] partition = new int [numTasks];
      for (int i=0; i<numTasks; i++)
        partition[i] = i;
      return partition;
    }

    // Create the space for the array D.
    double[][] D = new double [numProcessors+1][];
    for (int p=0; p<=numProcessors; p++)
      D[p] = new double [numTasks];

    // Base cases:
    for (int i=0; i<numTasks; i++) {
      // Set D[1][i] = s_0 + ... + s_i
      double sum = 0;
      for (int j=0; j<=i; j++) 
        sum += taskTimes[j];
      D[1][i] = sum;
      for (int k=i+2; k<=numProcessors; k++)
        D[k][i] = Double.MAX_VALUE;
      // Note: we are using MAX_VALUE in lieu of INFINITY.
    }


    // Dynamic programming: compute D[k][i] for all k
    // Now iterate over the number of processors.
    for (int k=2; k<=numProcessors; k++) {

      // In computing D[k][i], we iterate over i second.
      for (int i=0; i<numTasks; i++) {

        // Find the optimal value of D[k][i] using
        // prior computed values.

        double min = Double.MAX_VALUE;
        double max = Double.MAX_VALUE;

        // Try each value of j in the recurrence relation.
        for (int j=0; j<=i; j++) {

          // Compute s<sub>j+1</sub> + ... + s<sub>i</sub>
          double sum = 0;
          for (int m=j+1; m<=i; m++)
            sum += taskTimes[m];

          // Use the recurrence relation.
          max = D[k-1][j];
          if (sum > max) {
            max = sum;
          }

          // Record the best (over j).
          if (max < min) {
            min = max;
            D[k][i] = min;
          }
        } // end-innermost-for
        
      } // end-second-for

      // Optimal D[k][i] found.

    } //end-outermost-for

    

    int[] partition;

    // ... compute the partition itself (not shown) ...

    return partition;
  }
  

  public static void main (String[] argv)
  {
    test();
  }
  
  public static void test ()
  {
    // Test1:
    int numProcessors = 3;
    double[] taskTimes = {50, 23, 62, 72, 41};
    System.out.println ("Test1: (optimal time: 113)");
    runTest (taskTimes, numProcessors);

    // Test2: 
    numProcessors = 2;
    double[] taskTimes2 = {50, 23, 62, 72, 41};
    System.out.println ("Test2: (optimal time: 135)");
    runTest (taskTimes2, numProcessors);

    // Test3: 
    numProcessors = 6;
    double[] taskTimes3 = {50, 23, 62, 72, 41, 17, 68, 12, 19, 45};
    System.out.println ("Test3: (optimal time: 76)");
    runTest (taskTimes3, numProcessors);
  }


  static void runTest (double[] taskTimes, int numProcessors)
  {
    int[] partition = dynamicProgramming (taskTimes, numProcessors);
    double cost = cost (taskTimes, partition, numProcessors, true);
    System.out.println ("DYNAMICPROG: numTasks=" + taskTimes.length + " numProcessors=" + numProcessors + "  Final completion time: " + cost);
  }
  

  static double cost (double[] taskTimes, int[] partition, int numProcessors, boolean printIt)
  {
    // Check whether too many processors were assigned.
    if (partition.length > numProcessors) {
      System.out.println ("ERROR: partition length=" + partition.length + " larger than numProcessors=" + numProcessors);
      System.exit(1);
    }

    // Print partition.
    if (printIt) {
      System.out.print ("Partition: ");
      for (int i=0; i<partition.length; i++) 
        System.out.print (" " + partition[i]);
      System.out.println ("");
    }


    // Process partitions.
    double max = 0;
    int currentLeft = 0;
    int start=0, end=0;

    for (int i=0; i<partition.length; i++) {

      // Identify i-th partition.
      start = currentLeft;
      end = partition[i];
      // Convention: partition[i] includes the rightmost element in partition.

      if (end < start) {
        System.out.println ("ERROR: wrong partition i=" + i + " start=" + start + " end=" + end + " partition[i]=" + partition[i]);
        System.exit(1);
      }

      // Find the completion time of the i-th partition.
      double sum = 0;
      for (int j=start; j<=end; j++)
        sum += taskTimes[j];
      if (sum > max) {
        max = sum;
      }

      if (printIt) {
        System.out.print ("  Partition i=" + i + "(sum=" + sum + ",max=" + max + ",end=" + partition[i] + "): ");
        for (int j=start; j<=end; j++)
          System.out.print (" " + taskTimes[j]);
        System.out.println ("");
      }

      // Advance to next partition.
      currentLeft = end + 1;
    }


    // The last partition should end with the last task.
    if (end != taskTimes.length-1) {
      System.out.println ("ERROR: end=" + end + " numTasks=" + taskTimes.length);
      System.exit(1);
    }
    
    // Return total completion time.
    return max;
  }

}