calculate the "shortest" path from vertex/node 0 to vertex/node 8 using Dijkstra's label setting algorithm. Show your work in the tables next to each vertex/node (i.e., each time you change the label associated with a vertex/node you must add a row to the associated table that contains the new label and the new predecessor).

1. Change the 62 to a 49 and perform a "sift up".
2. Change the 46 to a 17 and perform a "sift up".
3. Remove the smallest element by swapping the "front" and "back" elements, removing the new "back" element, and performing a sift down.
4. Add a new element (with a value of 27) by making it the "back" element and performing a sift up.

public class Node
{
    public int              label;
    public String           id;    
}
    

complete the following GroupedCollection class:

import java.util.*;

/**
 * A GroupedCollection is a collection of Node objects.
 * Each node is kept in a "bucket" that corresponds to 
 * an intervale of labels.
 *
 * For example, if the maximum label is 100 and the 
 * number of buckets is 2, then the Node objects are
 * kept in two buckets, one containing Node objects with
 * labels in the interval [0, 50] and one containing Node 
 * objects with labels in the interval [51, 100].
 * corresponding to its label.
 */
public class GroupedCollection
{



    

    /**
     * Explicit Value Constructor
     *
     * @param maxLabel    The value of the largest possible label
     * @param numBuckets  The number of buckets
     */
    public GroupedCollection(int maxLabel, int numBuckets)
    {




    }
    


    /**
     * Add a Node to this GroupedCollection (i.e., put
     * it in the appropriate bucket)
     *
     * Note: This method assumes that the Node is not
     *       already in this GroupedCollection
     */
    public void addNode(Node node)
    {












    }
    


    /**
     * Get the Node with the smallest label (and remove it
     * from this GroupedCollection)
     *
     * @retun  The appropriate Node
     */
    public Node getNodeWithSmallestLabel()
    {














    }
    


    /**
     * Modify the label of a Node that is already
     * in this GroupedCollection (and move the Node
     * to the correct bucket)
     *
     * @param node      The Node to modify
     * @param newLabel  The new label for this Node
     */
    public void modifyNode(Node node, int newLabel)
    {














    }
}
    

Using this, find the minimum distance between each of the following points and the line segment connecting the points (1,1) and (4,4).

public class Subdivide
{
    public static Point      i, j, one, startMax, startMin;
    

    public static void main(String[] args)
    {
       double[]        v;


       // Create the unit vector i = (0,1)
       v = new double[2];
       v[0] = 1.0;
       v[1] = 0.0;
       i = new Point(v);
       

       // Create the unit vector j = (1,0)
       v[0] = 0.0;
       v[1] = 1.0;
       j = new Point(v);
       
       // Create the vector one = (1,1);
       one = i.plus(j);       

       // Create the vector lowerLeft = (0,0)
       v[0] = 0.0;
       v[1] = 0.0;
       startMin = new Point(v);

       // Create the vector upperRight = (4,4)
       v[0] = 4.0;
       v[1] = 4.0;
       startMax = new Point(v);
       
       // Quarter the rectangle formed by (0,0) and (4,4)
       quarter(startMin, startMax);
    }
    



    public static void quarter(Point min, Point max)
    {
       Point               delta, rho, tmin, tmax;
       

       System.out.println("Min: "+min+"     Max: "+max);
       

       rho   = max.minus(min);       
       delta = rho.times(0.5);
       
       if (delta.gt(one))
       {
          // NW
          tmin = min.plus(j.ctimes(delta));
          tmax = tmin.plus(delta);
          quarter(tmin, tmax);
          
          // NE
          tmin = min.plus(delta);
          tmax = tmin.plus(delta);
          quarter(tmin, tmax);
          
          // SE
          tmin = min.plus(i.ctimes(delta));
          tmax = tmin.plus(delta);
          quarter(tmin, tmax);
          
          // SW
          tmin = min;
          tmax = tmin.plus(delta);
          quarter(tmin, tmax);
       }
    }
    
}
    

$y = 10 + x^{2}$

$y = 2 + x^{4}$

You must find non-negative values of $x$ and $y$ that solve this system. Specifically, you must use the Golden Section algorithm to find the value of $x$ that minimizes:

$[(10 + x^{2}) - (2 + x^{4})]^{2}$

Show three iterations of the Golden Section algorithm starting with a lower bound of $L = 0$ and an upper bound of $R = 3$.