題目一：Zero Sum Subarray

給定一整形陣列，返回序列和為0的子陣列的起始和結束下標。

比如：int[] array={-3,1,2,-3,4};   返回（0,2）和（1,3）。

題解：使用hashmap儲存陣列中從0開始到索引i的子段和，在將值push進map之前，先檢查map中是否已經存在，

若存在則表示找到一組。

注意：map中的鍵值對key表示cursum，而value應表示在index之前的sum為多少。這是為了能成功返回第一組（0,2），

所以事先先將（0,0）的鍵值對put進map中，則當index=2時，才能找到（0,2）這個滿足要求的子陣列！！！

//zero sum subarray
    public void subarraySum(int[] data)
    {
    	HashMap<Integer,Integer> map=new HashMap();
    	map.put(0, 0);//necessary~
    	int cursum=0;
    	for(int i=0;i<data.length;i++)
    	{
    		cursum+=data[i];
    		if(map.containsKey(cursum))
    		{
    			System.out.println("下標："+map.get(cursum)+"到"+i);
    		}
    			map.put(cursum,i+1);//i+1之前的子段和為cursum;
    	}
    }
 

      但是該例程若在（0,2）的和為0，且（3,5）的和為零時，那麼（0,5）的和也為0，但是結果沒有給出。

給定一個整型陣列，找到和最接近0的子序列。

返回該子陣列的起始和結束下標。

比如：Given [-3, 1, 1, -3, 5], return [0, 2], [1, 3], [1, 1], [2, 2] or [0, 4].

解析：因要求的子串和不固定，所以不適合再用雜湊表的方法，使用排序可在O（n*logn）內解決。

具體步驟：

1.首先遍歷一遍陣列求的子串和；

2.對子串和排序；

3.逐個比較相鄰兩項差值的絕對值，返回差值絕對值最小的兩項。

這種方法的時間複雜度主要集中在排序上，由於除了記錄子串和之外，還需記錄索引，故引入pair類。最後排序時先按照sum值先排序，再按照索引值排序。

import java.util.*;
public class TestClass {
    public static void main(String args[]) {
	  TestClass test=new TestClass();

			int[] array={-3,1,1,-3,5};
			Result res=test.subarraySumClosest(array);
			System.out.println(""+res.begin+" "+res.end);
    }
//sum subarray closest
    public Result subarraySumClosest(int[] data)
    {
    	if(data == null||data.length <= 1)
    		return new Result(0,0);
    	Pair[] array=new Pair[data.length+1];//array的長度為data.length+1
    	array[0]=new Pair(0,0);//array[0]表示data[0]之前的和，設為0；
    	       //類似連結串列中dummy頭結點的做法，避免了對單個子串和是否為最小情況的單獨考慮；
    	int cursum=0;
    	for(int i=1;i<=data.length;i++)
    	{
    		cursum+=data[i-1];
    		array[i]=new Pair(cursum,i);
    	}
    	//對array按規則排序
    	Arrays.sort(array,new Comparator<Pair>(){
    		public int compare(Pair a,Pair b)//先按sum排序
    		{
    				return a.sum-b.sum;
    		}
    	});
    	int min_subsum=Integer.MAX_VALUE;
    	int closest_p=1;
    	for(int i=1;i<array.length;i++)
    	{
    		if(array[i].sum-array[i-1].sum < min_subsum)
    		{
    			min_subsum=array[i].sum-array[i-1].sum;
    			closest_p=i;
    		}
    	}
    	//排序後大的index可能排在了小的index的前面；
    	int begin=Math.min(array[closest_p].index, array[closest_p-1].index);
    	int end=Math.max(array[closest_p].index, array[closest_p-1].index)-1;// end要減去1；
    	Result result=new Result(begin,end);
    	return result;
    }
       
    class Pair
    {
    	int sum;//sum存放陣列當前下標之前的字首陣列和！！！
    	int index;//index存放陣列下標
    	public Pair(int sum,int index)
    	{
    		this.sum=sum;
    		this.index=index;
    	}
    }
    class Result
    {
    	int begin;
    	int end;
    	public Result(int begin,int end)
    	{
    		this.begin=begin;
    		this.end=end;
    	}
    }
}
 

題目三：

給定一個無序陣列，其中元素可正，可負，可0，給定一個整數k。求array所有子陣列中累加和為k的最長子陣列長度。

變型題目：

1 。陣列中元素可正，可負，可0，求所有子陣列中正數與負數個數相等的最大子陣列長度

2 。陣列中元素只有1或0，求所有子陣列中1和0個數相等的最長子陣列長度

原問題程式碼如下：仍利用Zero Sum Subarray的方法，map中只記錄一個累加和最早出現的位置。

 public int getMaxLength(int[] array,int k)
   {
	   if(array == null||array.length == 0)
		   return 0;
	   int len=0;
	   int cursum=0;
	   HashMap<Integer,Integer> map=new HashMap();
	   map.put(0,0);//0之前的累加和為0;
	   for(int i=0;i<array.length;i++)
	   {
		  cursum+=array[i];
		 if(map.containsKey(cursum-k))
		 {
			 len=Math.max(len, i-map.get(cursum-k)+1);
		 }
		 if(!map.containsKey(cursum))
		 {
			 map.put(cursum,i+1);//i+1之前的累加和為cursum且cursum第一次出現；
		 }
	   }
	   return len;
 }

第二個補充問題，把0全部變為-1,1不變，求累加和為0的最長子陣列長度即可。