分治法

最大子數組問題

方法一：暴力求解方法

我們可以很容易地設計出一個暴力方法來求解本問題：簡單地嘗試沒對可能的子數組，共有O(n2)種

#include<iostream>

using namespace std;

#define INT_MIN 0x80000000

int main()

{

     int arr[10]={9,8,-3,-5,7,-39,79,-37,8,9};

     int i,j;

     int sum=0,maxsum=INT_MIN;

     int imax;

     for (i=0;i<10;i++)

     {

         sum=0;

          for (j=i;j<10;j++)

          {

             sum+=arr[j];

             if (maxsum<sum)

             {

                 maxsum=sum;

                 imax=j;

             }

          }

     }

 

     cout<< "maxsum: " <<maxsum<< " imax:" <<imax<<endl;

}

 

方法二：使用分治策略的求解方法（O(nlgn)）

我們來思考如何用分治技術來求解最大子數組問題。假定我們要尋找子數組A[low,high]的最大子數組。使用分治技術意味着我們要將子數組划分為兩個規模盡量相等的子數組。也就是說，找到子數組的中央位置，比如mid，然后考慮求解兩個子數組A[low,mid]和A[mid+1,high]。則A[low,high]的任何連續子數組A[i..j]所處的位置必定是以下3種情況之一：

• 完全位於子數組A[low..mid]中，因此low<=i<=j<=mid
• 完全位於子數組A[mid+1..high]中，因此mid<i<=j<=high;
• 跨越了中點，因此low<=i<=mid<j<=high;

因此，A[low..high]的一個最大子數組所處的位置必然是這三種情況之一。實際上，A[low,high]的一個最大子數組必然是完全位於A[low..mid]中，完全位於A[mid+1..high]中或者跨越中點的所有子數組中和最大者。我們可以遞歸地求解A[low,mid]和A[mid+1,high]的最大子數組，因為這兩個子問題仍然是最大子數組的問題，只是規模更小。因此，剩下的全部工作就是尋找跨越中點的最大子數組，然后在三種情況中選取和最大者。

算法如下：

#include<iostream>

#include<tuple>

using namespace std;

#define INT_MIN 0x80000000

tuple< int , int , int > FindMaxCrossingSubarry( int arr[], int low, int mid, int high)

{

     int leftsum=INT_MIN,rightsum=INT_MIN;

     int sum=0;

     int maxleft=low,maxright=mid+1;

     int i;

     for (i=mid;i!=low;i--)

     {

         sum+=arr[i];

         if (leftsum<sum)

         {

             leftsum=sum;

             maxleft=i;

         }

     }

     sum=0;

     for (i=mid+1;i!=high;i++)

     {

         sum+=arr[i];

         if (rightsum<sum)

         {

             rightsum=sum;

             maxright=i;

         }

     }

     cout<< "maxleft: " <<maxleft<< "  maxright: " <<maxright<< "  leftsum+rightsum: " <<leftsum+rightsum<<endl;

     return tuple< int , int , int >(maxleft,maxright,leftsum+rightsum);

}

 

tuple< int , int , int > FindMaximumSubarry( int arr[], int low, int high)

{

     if (low==high)

         return tuple< int , int , int >(low,high,arr[low]);

     else

     {

         int mid=(low+high)/2;

         tuple< int , int , int > left=FindMaximumSubarry(arr,low,mid);

         tuple< int , int , int > right=FindMaximumSubarry(arr,mid+1,high);

         tuple< int , int , int > middle=FindMaxCrossingSubarry(arr,low,mid,high);

         if (get<2>(left)>=get<2>(right)&&get<2>(left)>=get<2>(middle))

             return left;

         else if (get<2>(right)>=get<2>(left)&&get<2>(right)>=get<2>(middle))

             return right;

         else

             return middle;

     }

}

 

int main()

{

     int arr[10]={9,8,-3,-5,7,-39,79,-37,8,9};

     tuple< int , int , int > result=FindMaximumSubarry(arr,0,9);

     cout<<get<0>(result)<< " " <<get<1>(result)<< " " <<get<2>(result)<<endl;

}

 

方法三：使用動態規划的算法（O(n)）

#include<iostream>

using namespace std;

 

int MaxArraySum( int arr[], int n)

{

     int sum,maxSum,maxi;

     int i;

     maxSum=0;

     maxi=0;

     sum=0;

     for (i=0;i<n;i++)

     {

         sum+=arr[i];

         if (sum<0)

         {

             sum=0;

             continue ;

         }

         if (maxSum<sum)

         {

             maxSum=sum;

             maxi=i;

         }

     }

     cout<< "max sum: " <<maxSum<< " index: " <<maxi<<endl;

     return maxSum;

}

 

int main()

{

     int arr[10]={9,8,-3,-5,7,-39,79,-37,8,9};

     cout<<MaxArraySum(arr,10);

}

 

 

 

分治法總結

一、基本概念
在計算機科學中，分治法是一種很重要的算法。字面上的解釋是“分而治之”，就是把一個復雜的問題分成兩個或更多的相同或相似的子問題，再把子問題分成更小的子問題……直到最后子問題可以簡單的直接求解，原問題的解即子問題的解的合並。這個技巧是很多高效算法的基礎，如排序算法(快速排序，歸並排序)，傅立葉變換(快速傅立葉變換)……

任何一個可以用計算機求解的問題所需的計算時間都與其規模有關。問題的規模越小，越容易直接求解，解題所需的計算時間也越少。例如，對於n個元素的排序問題，當n=1時，不需任何計算。n=2時，只要作一次比較即可排好序。n=3時只要作3次比較即可，…。而當n較大時，問題就不那么容易處理了。要想直接解決一個規模較大的問題，有時是相當困難的。

--------------------------------------------------------------------------------

二、基本思想及策略
分治法的設計思想是：將一個難以直接解決的大問題，分割成一些規模較小的相同問題，以便各個擊破，分而治之。
分治策略是：對於一個規模為n的問題，若該問題可以容易地解決（比如說規模n較小）則直接解決，否則將其分解為k個規模較小的子問題，這些子問題互相獨立且與原問題形式相同，遞歸地解這些子問題，然后將各子問題的解合並得到原問題的解。這種算法設計策略叫做分治法。

如果原問題可分割成k個子問題，1<k≤n，且這些子問題都可解並可利用這些子問題的解求出原問題的解，那么這種分治法就是可行的。由分治法產生的子問題往往是原問題的較小模式，這就為使用遞歸技術提供了方便。在這種情況下，反復應用分治手段，可以使子問題與原問題類型一致而其規模卻不斷縮小，最終使子問題縮小到很容易直接求出其解。這自然導致遞歸過程的產生。分治與遞歸像一對孿生兄弟，經常同時應用在算法設計之中，並由此產生許多高效算法。

--------------------------------------------------------------------------------

三、分治法適用的情況
分治法所能解決的問題一般具有以下幾個特征：
1) 該問題的規模縮小到一定的程度就可以容易地解決
2) 該問題可以分解為若干個規模較小的相同問題，即該問題具有最優子結構性質。
3) 利用該問題分解出的子問題的解可以合並為該問題的解；

4) 該問題所分解出的各個子問題是相互獨立的，即子問題之間不包含公共的子子問題。

第一條特征是絕大多數問題都可以滿足的，因為問題的計算復雜性一般是隨着問題規模的增加而增加；
第二條特征是應用分治法的前提它也是大多數問題可以滿足的，此特征反映了遞歸思想的應用；、
第三條特征是關鍵，能否利用分治法完全取決於問題是否具有第三條特征，如果具備了第一條和第二條特征，而不具備第三條特征，則可以考慮用貪心法或動態規划法。
第四條特征涉及到分治法的效率，如果各子問題是不獨立的則分治法要做許多不必要的工作，重復地解公共的子問題，此時雖然可用分治法，但一般用動態規划法較好。

--------------------------------------------------------------------------------

四、分治法的基本步驟
分治法在每一層遞歸上都有三個步驟：
step1 分解：將原問題分解為若干個規模較小，相互獨立，與原問題形式相同的子問題；
step2 解決：若子問題規模較小而容易被解決則直接解，否則遞歸地解各個子問題
step3 合並：將各個子問題的解合並為原問題的解。

它的一般的算法設計模式如下：
Divide-and-Conquer(P)
1. if |P|≤n0
2. then return(ADHOC(P))
3. 將P分解為較小的子問題 P1 ,P2 ,...,Pk
4. for i←1 to k
5. do yi ← Divide-and-Conquer(Pi) △ 遞歸解決Pi
6. T ← MERGE(y1,y2,...,yk) △ 合並子問題
7. return(T)
其中|P|表示問題P的規模；n0為一閾值，表示當問題P的規模不超過n0時，問題已容易直接解出，不必再繼續分解。ADHOC(P)是該分治法中的基本子算法，用於直接解小規模的問題P。因此，當P的規模不超過n0時直接用算法ADHOC(P)求解。算法MERGE(y1,y2,...,yk)是該分治法中的合並子算法，用於將P的子問題P1 ,P2 ,...,Pk的相應的解y1,y2,...,yk合並為P的解。

--------------------------------------------------------------------------------

五、分治法的復雜性分析
一個分治法將規模為n的問題分成k個規模為n／m的子問題去解。設分解閥值n0=1，且adhoc解規模為1的問題耗費1個單位時間。再設將原問題分解為k個子問題以及用merge將k個子問題的解合並為原問題的解需用f(n)個單位時間。用T(n)表示該分治法解規模為|P|=n的問題所需的計算時間，則有：T（n）= k T(n/m)+f(n)

通過迭代法求得方程的解：
遞歸方程及其解只給出n等於m的方冪時T(n)的值，但是如果認為T(n)足夠平滑，那么由n等於m的方冪時T(n)的值可以估計T(n)的增長速度。通常假定T(n)是單調上升的，從而當 mi≤n<mi+1時，T(mi)≤T(n)<T(mi+1)。

--------------------------------------------------------------------------------

六、可使用分治法求解的一些經典問題
（1）二分搜索
（2）大整數乘法
（3）Strassen矩陣乘法
（4）棋盤覆蓋
1,快速排序

快排是C.R.A.Hoare於1962年提出的一種划分交換排序。它采用了一種分治的策略，該方法的基本思想是：
1)．先從數列末尾取出一個數作為基准元。
2)．分區過程，將比這個數大的數全放到它的右邊，小於或等於它的數全放到它的左邊。
3)．再對左右區間重復第二步，直到各區間只有一個數。

 //手動快速默寫快排：先划界，再分治....   int *arr,  low,  high)
   pos = rand() % (high - low + 1) + low;

  key = arr[high];
  i = low - 1;
  ( j = low; j <= high - 1; j++)
   (arr[j] <= key)
     i;
   void *arr,  low,  high)
   (low < high)
   mid = quickPartion(arr, low, high);
    }

2，歸並排序
歸並排序是把序列遞歸地分成短序列，遞歸出口是短序列只有1個元素(認為直接有序)或者2個序列(1次比較和交換),然后把各個有序的段序列合並成一個有序的長序列，不斷合並直到原序列全部排好序。可以發現，在1個或2個元素時，1個元素不會交換，2個元素如果大小相等也沒有人故意交換，這不會破壞穩定性。那么，在短的有序序列合並的過程中，穩定是是否受到破壞？沒有，合並過程中我們可以保證如果兩個當前元素相等時，我們把處在前面的序列的元素保存在結果序列的前面，這樣就保證了穩定性。所以，歸並排序也是穩定的排序算法。

核心函數：

 //分治法的合並函數   //arr[low...mid]與arr[mid+1...high]相合並 void *arr,  low,  mid,  high)
   leftlen = mid - low + 1;
  rightlen = high - mid;
   *L =  [leftlen + 1];
  *R =  [rightlen + 1];


  i = 0;
  (; i < leftlen; i++)
    j = 0;
  (; j < rightlen; j++)

   ( k = low; k <= high; k++)
   (L[i] <= R[j])

    [] L; L = NULL;
 [] R; R = NULL;
   //合並排序法（分治法）   void *arr,  low,  high)
   (low < high)
   mid = (low + high) / 2;
     }

九，Leetcode實例

題目：

在一個未排序的數組中找到第k大的元素，注意此言的第k大就是排序后的第k大的數，
注意：給定k總是安全有效的。

分析：

設數組下表從low開始，至high結束。
1、 總是取要划界的數組末尾元素為划界元x，開始划界：

a) 用j從low遍歷到high-1（最后一個暫不處理），i=low-1，如果nums[j]比x小就將nums[++i]與nums[j]交換位置

b) 遍歷完后再次將nums[i+1]與nums[high]交換位置（處理最后一個元素）;

c) 返回划界元的位置i+1，下文稱其為midpos

這時的midpos位置的元素，此時就是整個數組中第N-midpos大的元素，我們所要做的就像二分法一樣找到K=N-midpos的“中間位置”，即midpos=N-K

2、 如果midpos==n-k，那么返回該值，這就是第k大的數。
3、 如果midpos>n-k，那么第k大的數在左半數組
4、 如果midpos<n-k，那么第k大的數在右半數組

//思路首先：
//快排划界，如果划界過程中當前划界元的中間位置就是k則找到了
//time,o(n*lg(k)),space,o(1)
class Solution {
public:
    //對數組vec，low到high的元素進行划界，並獲取vec[high]的“中間位置”
    int quickPartion(vector<int> &vec, int low,int high)
    {
        int x = vec[high];
        int i = low - 1;
        for (int j = low; j <= high - 1; j++)
        {
            if (vec[j] <= x)//小於x的划到左邊
                swap(vec,++i,j);
        }
        swap(vec,++i,high);//找到划界元的位置
        return i;//返回位置
    }
    //交換數組元素i和j的位置
    void swap(vector<int>& nums, int i, int j){
        int temp = nums[i];
        nums[i]=nums[j];
        nums[j]=temp;
    }
    int getQuickSortK(vector<int> &vec, int low,int high, int k)
    {
        if(low >= high) return vec[low];
        int  midpos = quickPartion(vec, low,high);   //對原數組vec[low]到vec[high]的元素進行划界
        if (midpos == vec.size() - k)      //如果midpos==n-k，那么返回該值，這就是第k大的數
            return vec[midpos];
        else if (midpos < vec.size() - k)  //如果midpos<n-k，那么第k大的數在右半數組
            return getQuickSortK(vec, midpos+1, high, k);
        else                               //如果midpos>n-k，那么第k大的數在左半數組
            return getQuickSortK(vec, low, midpos-1, k);
    }
    int findKthLargest(vector<int>& nums, int k) {
        return getQuickSortK(nums,0,nums.size()-1,k);
    }
};