一、題目描述

給定一個整型陣列，找出最大下標距離j-i，當且僅當a[j]>a[i]，i < j。

二、直觀方案（ 時間複雜度為O(n^2) ）

對每個元素，從其後找出比其大的元素，並計算下標距離，取距離中的最大值即可。該

方案的時間複雜度為O(n^2)。那麼能不能優化下呢？

三、優化方案（ 時間複雜度為O(n) ）

存在這樣一個事實，當a[i+1]大於a[i]時，如果在它們的後面存在一個大於它們的元素a[k]，k > i+1>i 那麼我們就不需要考慮a[i+1]，因為明顯的k-i > k-(i+1)。舉個例子，陣列{3，4， 1， 2，7 }，因為3>4

基於以上的事實，我們只要從陣列的第一個元素開始，找一個下降的序列，從尾部開始掃描，求出最大下標距離。

例如，陣列{5， 3， 4， 0， 1， 4， 1}，首先找到下降序列{5， 3， 0 }，然後依據以下步驟找出答案:

第一步，i = 3，j = 6，a[3] = 0 < a[6] = 1，nMaxSubDistance = 3；

第二步，i = 1，j = 6，a[1] = 3 > a[6] = 1；

第三步，i = 1，j = 5，a[1] = 3 < a[5] = 4，nMaxSubDistance = 3；

第四步，i = 0，j = 5

第五步，i = 0，j = 4，a[0] = 5 > a[4] = 1；

第六步，i = 0，j = 3，a[0] = 5 > a[3] = 0；

第七步，i = 0，j = 2，a[0] = 5 > a[2] = 4；

第八步，i = 0，j = 1，a[0] = 5 > a[1] = 3；

第九步，i = -1，結束；

注意，每次找到一個最大值後，j不需要重置，繼續從原來j的位置掃描下去，如果每次j都重置，那演算法複雜度就回到O(n^2)了。

程式碼實現如下：

//返回陣列中最大下標距離j-i,當且僅當nArray[i]<nArray[j],j>i
int MaxSubDistance( int nArray[], int nCount )
{
	//查詢一個下降序列
	bool* bDescSeq = new bool[nCount];
	memset( bDescSeq, 0, sizeof(bool)*nCount );
	int nMinNum = nArray[0];
	for ( int i = 1; i < nCount; ++i )
	{
		if ( nArray[i] < nMinNum )
		{
			bDescSeq[i] = true;
			nMinNum = nArray[i];
		}
	}


	int nMaxSubDistance = 0;
	int i = nCount - 1;
	int j = nCount - 1;
	while( i >= 0 )
	{
		if( !bDescSeq[i] )
		{
			--i;
			continue;
		}

		while( j > i && nArray[i] >= nArray[j] )
			--j;

		if ( (j - i) > nMaxSubDistance )
		{
			nMaxSubDistance = j - i;
			//j = nCount - 1;//這句多餘，這句加上的話，時間複雜度則為O(n^2)了。
		}

		--i;
	}


	if ( NULL != bDescSeq )
	{
		delete[] bDescSeq;
		bDescSeq = NULL;
	}

	return nMaxSubDistance;
}
 

系列文章說明:
1.本系列文章[演算法練習],僅僅是本人學習過程的一個記錄以及自我激勵,沒有什麼說教的意思。如果能給讀者帶來些許知識及感悟，那是我的榮幸。
2.本系列文章是本人學習陳東鋒老師《進軍矽谷，程式設計師面試揭祕》一書而寫的一些心得體會，文章大多數觀點均來自此書，特此說明！
3.文章之中,難免有諸多的錯誤與不足,歡迎讀者批評指正,謝謝.

作者：山丘兒
轉載請標明出處，謝謝。原文地址：http://blog.csdn.net/s634772208/article/details/46462775