C++中的分治算法及常見題目匯總

目錄

一、分治法基本原理

1. 分治算法基本介紹
2. 分治算法通俗解釋

二、Leecode刷題題解

1. 最大子序和
2. 合並兩個排序的鏈表
3. 數組中出現次數超過一般的數字
4. 最小的k個數(TopK問題)

 

 

一、分治法基本介紹

1. 分治算法基本介紹

　　分治算法即分而治之，就是把一個復雜的問題分解成兩個或多個相同或相似的子問題，再把子問題分解成更小的問題。。。直到最后子問題可以簡單地直接求解，原問題即子問題的合並。分治算法主要分為三個步驟：

• 分解：將問題划分成一系列子問題，子問題的形式和原問題一樣，只是規模更小
• 解決：遞歸地求出子問題。如果子問題的規模足夠小，即停止遞歸，直接求解
• 合並：步驟將子問題的解組合成原問題的解

2. 分治算法通俗解釋

(此例子引用連接如下：https://www.zhihu.com/search?type=content&q=%E5%88%86%E6%B2%BB%E7%AE%97%E6%B3%95)　　

　　有這樣一個經典的問題：有100枚硬幣，其中1枚重量與眾不同，是假幣，更輕一些。如果用天平秤，請問至少稱多少次一定能找到這枚假幣

　　加入我們用傳統的枚舉法，顯然至少需要比較50次

      

 

而假設我們采用分治法的話 ，流程如下：1. 將100硬幣分成3份，33,33,34。

2.稱量1、2份，若天平平衡，則假幣必在另外34枚中。若不平衡，假幣在輕的那33枚里。

3.將34枚分為11/11/12枚（或將33枚分成11*3）。

4.稱量兩組11枚的硬幣，若平衡，假幣在12枚里（或另外的11枚）若不平衡，假幣在輕的11里。

5.將11（或12）枚分成3/4/4（或4/4/4），稱量4/4，方法同上。

6.將剩下的3（或4）分為1/1/1（或1/1），稱量1/1，若平衡，則剩下的一枚是假幣，若不平衡，輕的是假幣。 若還剩4枚，出現1/1平衡，剩下2枚則稱量，顯然輕的是假幣。

這種方法只需要5次就能解決這個問題。

分治算法的流程：

 

 

二、Leecode刷題詳解

1. 最大子序和

• 題目描述

　　

 

•  問題分析

　　解決此問題有兩種方法：

• • 方法一：傳統暴力解決方法，需要遍歷整個數組，其時間復雜度為 O(n)

　　　　　設置一個當前最大值和全局最大值，遍歷整個數組，當此時的最大值小於0時，則前面的都不要，否則，將下一個數相加即可　

class Solution {
public:
    int FindGreatestSumOfSubArray(vector<int> array) {
        /*
        要實現求得連續子數組的最大和,我們可以
        */
        if(array.empty())
            return 0;
        int cursum=0;
        int maxsum=array[0];
        for(int i=0;i<array.size();++i)
        {
            if(cursum<=0)
                cursum=array[i];
            else
            {
                cursum+=array[i];
            }
            if(cursum>=maxsum)
                maxsum=cursum;
        }
        return maxsum;
    }
};

• • 方法二：使用分治算法

　　　　要找到最大連續和的子數組，我們可以用分治算法，設最左邊為left,最右邊為right，中間節點為mid，則最大子數組可以分為以下三種情況：

　　　　1. 最大連續子數組都左邊子數組[left, mid]

　　　　2. 最大連續子數組都在右邊子數組[mid+1,right]

　　　　3. 最大連續子數組跨越了中點，一部分在左邊子數組中，一部分在右邊子數組中

　　　　最大連續子數組一定是三種情況中的最大值

class Solution {
    /*
        要找到連續最大子序和，我們可以用分治算法，設最左邊為left, 最右邊為right,中間節點為mid，則最大連續子數組可能情況為以下三種：
        1. 最大連續子數組都在[left, mid]中
        2. 最大連續子數組都在[mid+1, right]中
        3. 最大連續子數組跨越了中點，因此left<=i<=mid<=j<=right
    */
    //只需要在這三種情況中找出最大值即可
    //首先是求出mid在子數組中間的情況
    /*
        我們的目的是找出mid在子數組中的子數組的和
    */
    int INT_MIN=-2147483648; 
    public int find_max_cross_substr(int[] nums,int left,int mid,int right)
    {
        int maxleft=0,maxright=0;
        int sum=0;
        int leftsum=INT_MIN,rightsum=INT_MIN;
        //首先找到左半邊子數組的最大值
        for(int i=mid;i>=left;--i)
        {
            sum+=nums[i];
            leftsum=Math.max(sum,leftsum);
        }
        //然后找到右半邊子數組的最大值
        sum=0;
        for(int j=mid+1;j<=right;++j)
        {
            sum+=nums[j];
            rightsum=Math.max(sum,rightsum);
        }
        return (leftsum+rightsum);
    }
    //然后進行遞歸查找，比較三種情況，找出最大值
    public int find_max_substr(int[]nums,int left,int right)
    {
        if(left==right)
            return nums[left];//找到遞歸結束條件，結束遞歸
        else
        {
            int mid=left+(right-left)/2;
            int maxleftsum,maxrightsum,maxcrosssum;
            maxleftsum=find_max_substr(nums,left,mid);
            maxrightsum=find_max_substr(nums,mid+1,right);
            maxcrosssum=find_max_cross_substr(nums,left,mid,right);
            return Math.max(Math.max(maxleftsum,maxrightsum),maxcrosssum);
        }
        
    }
    public int maxSubArray(int[] nums) {
        return find_max_substr(nums,0,nums.length-1);
    }
}

class Solution {
    /*
        要找到連續最大子序和，我們可以用分治算法，設最左邊為left, 最右邊為right,中間節點為mid，則最大連續子數組可能情況為以下三種：
        1. 最大連續子數組都在[left, mid]中
        2. 最大連續子數組都在[mid+1, right]中
        3. 最大連續子數組跨越了中點，因此left<=i<=mid<=j<=right
    */
    //只需要在這三種情況中找出最大值即可
    //首先是求出mid在子數組中間的情況
    /*
        我們的目的是找出mid在子數組中的子數組的和
    */
    int INT_MIN=-2147483648; 
    public int find_max_cross_substr(int[] nums,int left,int mid,int right)
    {
        int maxleft=0,maxright=0;
        int sum=0;
        int leftsum=INT_MIN,rightsum=INT_MIN;
        //首先找到左半邊子數組的最大值
        for(int i=mid;i>=left;--i)
        {
            sum+=nums[i];
            leftsum=Math.max(sum,leftsum);
        }
        //然后找到右半邊子數組的最大值
        sum=0;
        for(int j=mid+1;j<=right;++j)
        {
            sum+=nums[j];
            rightsum=Math.max(sum,rightsum);
        }
        return (leftsum+rightsum);
    }
    //然后進行遞歸查找，比較三種情況，找出最大值
    public int find_max_substr(int[]nums,int left,int right)
    {
        if(left==right)
            return nums[left];//找到遞歸結束條件，結束遞歸
        else
        {
            int mid=left+(right-left)/2;
            int maxleftsum,maxrightsum,maxcrosssum;
            maxleftsum=find_max_substr(nums,left,mid);
            maxrightsum=find_max_substr(nums,mid+1,right);
            maxcrosssum=find_max_cross_substr(nums,left,mid,right);
            return Math.max(Math.max(maxleftsum,maxrightsum),maxcrosssum);
        }
        
    }
    public int maxSubArray(int[] nums) {
        return find_max_substr(nums,0,nums.length-1);
    }
}

 

 2. 合並兩個排序的鏈表

• 題目描述

　　

 

•  問題分析

　　(1) 使用while循環。思路：將鏈表B合並到鏈表A中。循環鏈表B，需要創建兩個指針，一個指向當前的節點，另一個指向當前的下一個結點。

　　(2) 分治算法+遞歸。思路：將兩個鏈表中，l1指針和l2指針指向的節點，比較大小，然后遞歸即可，注意需要添加遞歸結束的代碼

• 代碼參考

　　

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode head=null;
        if(l1==null)
            return l2;
        else if(l2==null)
            return l1;
        else
        {
            if(l1.val<l2.val)
            {
                head=l1;
                head.next=mergeTwoLists(l1.next,l2);
            }
            else
            {
                head=l2;
                head.next=mergeTwoLists(l1,l2.next);
            }
        }
        return head;
    }
}

 

3. 數組中出現次數超過一半的數字

• 題目描述

　　

 

•  問題分析

　　數組中出現次數超過一半的數字特征如下：數字中出現次數超過一半的數字出現總次數大於其余數字出現次數的總數

　　首先我們可以設置一個出現次數times，初始值為0

　　若當前數組的數等於上一次出現的次數，則times++

　　否則，times--

• 代碼參考

class Solution {
    public int majorityElement(int[] nums) {
        //如果一個數字出現的次數是數組長度的一半，則這個數組滿足以下要求
        /*
            首先，這個數字出現的次數比其他數字出現的次數加起來還多
            我們可以設置一個出現次數times，初始化為0
            若當前數組的數等於上一個出現的次數，則times++
            否則times--
        */
        if(nums.length==0)
            return 0;
        int times=0;
        int result=nums[0];
        for(int i=0;i<nums.length;++i)
        {
            if(times==0)
                result=nums[i];
            if(result==nums[i])
                ++times;
            else
                --times;
        }
        int count=0;
        for(int i=0;i<nums.length;++i)
        {
            if(nums[i]==result)
                ++count;
        }
        if(count*2>nums.length)
            return result;
        else
            return 0;
    }
}

 

4. 最小的k個數(TopK問題)

• 題目描述

• 方法一(最大堆實現)

　　這是一道典型的TopK問題，比較直觀的方法是利用堆數據結構來輔助得到最小的k個數。堆的性質是每次可以找出最大或者最小的元素。我們可以使用一個大小為k的最大堆(大堆頂)，將數組中的元素依次入堆，當堆的大小超過k時，便將多出的元素從堆頂彈出。如果數組中待插入的元素與堆頂元素進行比較，若待插入元素小於堆頂元素，則將堆頂元素彈出后將待插入元素插入堆

　　這樣，由於每次從堆頂彈出的數都是堆中最大的，最小的k個元素一定會留在堆中。這樣，把數組中的元素全部入堆后，堆中剩下的元素就是最大的k個數了。

• 代碼參考

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        /*
            可以使用一個大根堆實時維護數組的前k個小值
            首先將k個數插入大根堆中
            然后從k+1個數開始遍歷
                如果當前遍歷到的數比大根堆的堆頂的數要小，就把堆頂的數彈出，再插入當前遍歷到額數
                最后將大根堆的數存入數組返回即可
        */
        if(k==0)
            return new int[0];
        //使用一個最大堆實現TopK問題
        //Java的priorityQueue默認是小堆頂，添加comparator參數使其變成大堆頂
        Queue<Integer> pq=new PriorityQueue<>(k,(i1,i2)->Integer.compare(i2,i1));

        //首先把數組中的前k個數字入堆
        for(int num:arr)
        {
            if(pq.size()<k)
                pq.offer(num);
            else if(num<pq.peek())
            {
                pq.poll();
                pq.offer(num);
            }
        }
        //返回堆中的元素
        int []res=new int[pq.size()];
        int idx=0;
        for(int num:pq)
        {
            res[idx++]=num;
        }
        return res;
    }
}

• 方法二：快速排序思想(分治算法)

　　可以使用快速排序思想來做，其是分治的思想

　　快速排序中有一步很重要的操作是partition(划分)，從數組中隨機選取一個樞紐元素v，然后原地移動數組中的元素，使得v小的元素在v的左邊，比v大的元素在v的右邊，如下圖所示：

　　

 

 　　我們的目的是尋找最小的k個數。假設經過一次partition操作，樞紐元素位於下標m，也就是說，左側的數組有m個元素，是原數組中最小的m個數，那么：

• • 若k=m，我們就找到了最小的k個數，就是左側的數組
  • 若k<m，則最小的k個數一定在左邊數組，我們只需要對左側數組遞歸即可
  • 若k>m，則左側數組中的m個數都屬於最小的k個數，我們還需要在右側數組中尋找最小的k-m個數，對右側數組遞歸地partition即可
• 代碼參考

class Solution {
    /*
        方法二，可以利用快速排序的思想
        快速排序中有一個很重要的一步就是partition，從數組中隨機選取一個元素v，然后原地移動數組中的元素，使得比v小的元素在v的左邊，比v大的元素在v的右邊
        我們的目的是找到最小的k個數，假設經過一次partition操作，樞紐元素位於下標m，
            若k==m，則找到最小的k個元素，即左側的數組
            若k<m，則最小的k個數一定在左側數組中，只需要對左側數組中尋找最小的k-m個數即可
            若k>m，左側數組中的m個數都屬於最小的k個數，我們還需要右側數組中尋找最小的k-m個數，對右側數組遞歸的partition即可        
    */
    public int[] getLeastNumbers(int[] arr, int k) {
        if(k==0)
            return new int[0];
        else if(arr.length<=k)
            return arr;
        //原地不斷划分數組
        partitionArray(arr,0,arr.length-1,k);
        //數組的前k個數此時就是最小的k個數，將其存入結果
        int[] res=new int[k];
        for(int i=0;i<k;++i)
        {
            res[i]=arr[i];
        }
        return res;

    }
    int partition(int[] arr,int low,int high)
    {
        int i=low;
        int j=high+1;
        int pivot=arr[low];
        while(true)
        {
            //左邊：小而移動，大而賦值
            while(arr[++i]<pivot)
            {
                if(i==high)
                    break;
            }
            //右邊：大而移動，小而賦值
            while(arr[--j]>pivot)
            {
                if(j==low)
                    break;
            }
            if(i>=j)
                break;
            swap(arr,i,j);
        }
        swap(arr,low,j);
        return j;
    }
    void swap(int[]arr,int i,int j)
    {
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
    void partitionArray(int [] arr,int low,int high,int k)
    {
        //實現第一次partition
        int m=partition(arr,low,high);
        if(m==k)
            //剛好找到最小的k個數
            return;
        else if(k<m)
        {
            //最小的k個數一定在前m個數中，遞歸划分
            partitionArray(arr,low,m-1,k);
        }
        else
        {
            //在右側數組中尋找最小的k-m個數
            partitionArray(arr,m+1,high,k);
        }
    }
}