import java.util.concurrent.*;
import java.util.*;
/*
This class is nearly identical to FindMin, but it extends RecursiveAction instead of RecursiveTask.
The only difference there is that compute() returns nothing, so we store the min value in 'result'.
*/

public class FindMinAlt extends RecursiveAction
{
	static final ForkJoinPool fjPool=new ForkJoinPool();
	
	int[] array;
	int lo,hi; //this represents the range considered by this instance.  Remember that we start at 'lo', and go to 'hi-1'
	static final int SEQUENTIAL_CUTOFF=1000;
	int result;
	
	public FindMinAlt(int[] a,int l,int h)
	{
		array=a;
		lo=l;
		hi=h;
	}
	
	public void compute()
	{
		//first we check if it's at or below the sequential cutoff; if so, do it the easy way
		if(hi-lo<=SEQUENTIAL_CUTOFF)
		{
			int min=Integer.MAX_VALUE;
			for(int i=lo;i<hi;i++) min=Math.min(min,array[i]);
			result=min;
		}
		else //otherwise, divide further
		{
			int mid=(lo+hi)/2;
			FindMinAlt left=new FindMinAlt(array,lo,mid); //so the left starts at 'lo' and goes to 'mid-1'...
			FindMinAlt right=new FindMinAlt(array,mid,hi); //and the right starts at 'mid' and goes to 'hi-1'
			left.fork(); //start the left in its own process
			right.compute(); //compute the right in this process
			left.join(); //wait for the left to finish
			result=Math.min(left.result,right.result);
		}
	}
	
	//this code is here to test out our above program
	public static void main(String[] args)
	{
		//first create an array of random numbers
		Random r=new Random();
		int arrSize=10000000;
		int[] arr=new int[arrSize];
		for(int i=0;i<arr.length;i++) arr[i]=r.nextInt(100000000);
		
		//now find the min; remember, we have to start off the whole thing with 'invoke'
		long startTime=System.currentTimeMillis();
		FindMinAlt findMinAlt=new FindMinAlt(arr,0,arrSize);
		fjPool.invoke(findMinAlt);
		long endTime=System.currentTimeMillis();
		System.out.println("The min is "+findMinAlt.result);
		System.out.println("Time taken: "+(endTime-startTime)+"ms");
	}
}