基本算法之分治法

最新推荐文章于 2023-05-12 19:31:41 发布
最新推荐文章于 2023-05-12 19:31:41 发布
阅读量771 收藏 1
点赞数 1
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenjun840168660/article/details/8395606
版权

合并排序

合并排序的时间复杂度为：O（nlogn），最坏情况下的键值比较次数接近于任何基于比较的排序算法的理论上能够达到的最小次数，主要缺点是该算法需要线性的额外空间。

#include "stdafx.h"

#include<iostream>
using namespace std;

void Merge(int *a,int *b,int left,int middle,int right)    {
    
    int i=left,j=middle+1,k=left;
    while(i<=middle&&j<=right)    {
        if(a[i]<=a[j])    
            b[k++]=a[i++];
        else
            b[k++]=a[j++];
    }
    if(i>middle)    {
    
        for(int p=j;p<=right;++p)
            b[k++]=a[p];
    }

    else    {
        
        for(int p=i;p<=middle;++p)
            b[k++]=a[p];
    }
}


void CopyArray(int *a,int *b,int left,int right)    {

    for(int i=left;i<=right;++i)
        a[i]=b[i];

}

void MergeSort(int *a,int left,int right)    {

    if(left<right)    {
        int middle=(left+right)/2;
        int b[10];
        MergeSort(a,left,middle);
        MergeSort(a,middle+1,right);
        //合并左右两部分
        Merge(a,b,left,middle,right);
        CopyArray(a,b,left,right);
    }
}

int _tmain(int argc, _TCHAR* argv[])
{
    
    int num=0;
    int a[10];
    cout<<"将要输入的数的个数："<<endl;
    cin>>num;
    cout<<"依次输入每一个数："<<endl;
    for(int i=0;i<num;++i)
        cin>>a[i];
    MergeSort(a,0,num-1);
    cout<<endl;
    for(int i=0;i<num;++i)
        cout<<a[i]<<"   ";
    system("pause");
    return 0;

}


待拓展：K-way merge algorithm




快速排序

时间复杂度为O（nlogn）

#include "stdafx.h"
#include<iostream>
using namespace std;

int Partion(int *a,int left,int right)    {
    
    int pivot=a[left];
    while(left<right)    {
        while(left<right&&a[right]>=pivot)    {
            --right;
        }
        if(left<right)    {
            a[left++]=a[right];
        }
        while(left<right&&a[left]<=pivot)    {
            ++left;
        }
        if(left<right)
            a[right--]=a[left];
    }
    a[left]=pivot;
    return left;
}

void QuickSort(int *a,int left,int right)    {
        
    if(left<right)    {
        
        int povitpos=Partion(a,left,right);
        QuickSort(a,left,povitpos-1);
        QuickSort(a,povitpos+1,right);
    }
}


int _tmain(int argc, _TCHAR* argv[])
{
    
    int a[5];
    cout<<"please input five digits:"<<endl;
    for(int i=0;i<5;++i)
        cin>>a[i];
    QuickSort(a,0,4);
        for(int i=0;i<5;++i)
        cout<<a[i]<<"  ";
        
    system("pause");
    return 0;
}


待扩展：

  • 中枢的选择
  • 当子问题更小时，改用插入排序
  • 不用递归方法


折半查找的递归算法和非递归算法

时间复杂度为logn

#include "stdafx.h"
#include<iostream>
using namespace std;
//递归算法
int BinarySearch(int *a,int key,int left,int right)    {
    
    if(left<=right)    {
    
        int middle=(left+right)/2;
        
        if(a[middle]==key)
            return 1;
        
        else if(a[middle]<key)
            return BinarySearch(a,key,middle+1,right);
        
        else if(a[middle]>key)
            return BinarySearch(a,key,left,middle-1);
    }
   else
       return -1;
}

//非递归算法

int BinarySearchNotRecursion(int *a,int key,int left,int right)    {

    while(left<=right)    {
    
        int middle=(left+right)/2;
        if(key==a[middle]) return 1;
        else if(key<a[middle])
            right=middle-1;
        else if(key>a[middle])
            left=middle+1;
    }
    return -1;


}

int _tmain(int argc, _TCHAR* argv[])
{
    int a[5];
    int key;

    cout<<"请输入5个有序的数字："<<endl;
    for(int i=0;i<5;++i)
        cin>>a[i];
    cout<<"输入要查找的数字："<<endl;
    cin>>key;
    //cout<<BinarySearch(a,key,0,4);
    cout<<BinarySearchNotRecursion(a,key,0,4);
    system("pause");
    return 0;
}


大整数相乘

该算法是为了减少相乘的次数，对于不是很大的整数，该算法的运行时间很可能比经典算法长，因为它是一个递归算法，但实验显示，从大于600位的整数开始，分治法的性能超越了笔算算法的性能。    其算法时间复杂度为n的平方；

#include "stdafx.h"
#include<iostream>
using namespace std;
// 假设输入的a和b都是非负的，且N 为2的幂

int BigIntMultiplication(int a,int b,int N)    {
    
    if(a==0||b==0)
        return 0;
    else if(N==1)
        return a*b;
    else {
    
    int a1,a2,b1,b2;
    
    a1=a/pow(10.0,N/2);
    a2=a-a1*pow(10.0,N/2);
    b1=b/pow(10.0,N/2);
    b2=b-b1*pow(10.0,N/2);

    int c0,c1,c2;
    c1=BigIntMultiplication(a1,b1,N/2);
    c2=BigIntMultiplication(a2,b2,N/2);
    c0=(BigIntMultiplication((a1+a2),(b1+b2),N/2))-(c1+c2);     //  实际上c0=a1*b2+a2*b1

    return c1*pow(10.0,N)+c0*pow(10.0,N/2)+c2;
    }

}

int _tmain(int argc, _TCHAR* argv[])
{
    cout<<"请输入大整数的位数(必须为2的幂)及两个大整数："<<endl;
    int a,b,N;
    cin>>N>>a>>b;
    cout<<"结果为："<<BigIntMultiplication(a,b,N);
    system("pause");
    return 0;
}


strassen矩阵乘法

思路： 两个n阶方正相乘a*b=c（假设n为2的幂，若n不是2的幂可以通过给方正添加0来达到效果），可以分别将这两个方正拆成4个n/2阶的小方阵，分别为a11、a12、a21、a22、b11、b12、b21、b22，然后分别通过将这8个小方阵相乘、相加、或是相减来分别求出c11、c12、c21、c22，具体的公式如下：

m1=（a11+a22）*（b11+b22），m2=(a21+a22)*b11，m3=a11*(b12-b22)，m4=a22*(b21-b11)，m4=a22*(b21-b11)，m5=(a11+a12)*b22，m6=(a21-a11)*(b11+b12)

m7=(a12-a22)*(b21+b22)；  

c11=m1+m4+m7-m5，c12=m3+m5，c21=m2+m4，c22=m1+m3+m6-m2  ；

通常的方法计算方阵乘积要计算nE3个乘法，而strassen方法有所提高，需要nElog7次乘法计算。

源代码如下：

#include "stdafx.h"
#include<iostream>
using namespace std;

//#define N 8;
const int N=8;

//方阵数据
void InputMatrix(int n,int a[][N])    {
    
    for(int i=0;i<n;++i)    {
        cout<<"请输入第"<<i+1<<"行数据"<<endl;
        for(int j=0;j<n;++j)
            cin>>a[i][j];
    }

}

//方阵数据
void OutputMatrix(int n,int a[][N])    {

        for(int i=0;i<n;++i)    {
            for(int j=0;j<n;++j)
                cout<<a[i][j]<<" ";
            cout<<endl;
    }

}


//方阵相加
void MatrixAdd(int n,int a[][N],int b[][N],int c[][N])    {
    for(int i=0;i<n;++i)
        for(int j=0;j<n;++j)    {
        
        c[i][j]=a[i][j]+b[i][j];
        }
}

//方阵相减
void MatrixSub(int n,int a[][N],int b[][N],int c[][N])    {
    for(int i=0;i<n;++i)
        for(int j=0;j<n;++j)    {
        
        c[i][j]=a[i][j]-b[i][j];
        }
}

//2阶矩阵的乘法
void MatrixMultiplication(int a[][N],int b[][N],int c[][N])    {

    for(int i=0;i<2;++i)
        for(int j=0;j<2;++j)    {
            c[i][j]=0;
            for(int k=0;k<2;++k)
                c[i][j]+=a[i][k]*b[k][j];
        }

}

/* 递归法   strassen矩阵乘法*/

void StrassenMatrixMultiplication(int n,int a[][N],int b[][N],int c[][N])    {
    
    int a11[N][N],a12[N][N],a21[N][N],a22[N][N];
    int b11[N][N],b12[N][N],b21[N][N],b22[N][N];

    int c11[N][N],c12[N][N],c21[N][N],c22[N][N];
    int M1[N][N],M2[N][N],M3[N][N],M4[N][N],M5[N][N],M6[N][N],M7[N][N];

    int a_temp1[N][N],a_temp2[N][N],b_temp1[N][N],b_temp2[N][N],M_temp1[N][N],M_temp2[N][N];

    for(int i=0;i<n/2;++i)
        for(int j=0;j<n/2;++j)    {
        
            a11[i][j]=a[i][j];
            a12[i][j]=a[i][j+n/2];
            a21[i][j]=a[i+n/2][j];
            a22[i][j]=a[i+n/2][j+n/2];


            b11[i][j]=b[i][j];
            b12[i][j]=b[i][j+n/2];
            b21[i][j]=b[i+n/2][j];
            b22[i][j]=b[i+n/2][j+n/2];
    }
    if(n==2)    {
        MatrixMultiplication(a,b,c);
        
    }

    else    {

        MatrixAdd(n/2,a11,a22,a_temp1);
        MatrixAdd(n/2,b11,b22,b_temp1);
        StrassenMatrixMultiplication(n/2,a_temp1,b_temp2,M1);    //  M1=(a11+a22)*(b11+b22)

        MatrixAdd(n/2,a21,a22,a_temp1);
        StrassenMatrixMultiplication(n/2,a_temp1,b11,M2);       //  M2=(a21+a22)*b11

        MatrixSub(n/2,b12,b22,b_temp1);
        StrassenMatrixMultiplication(n/2,a11,b_temp1,M3);        //  M3=a11*(b12-b22)

        MatrixAdd(n/2,b21,b11,b_temp1);
        StrassenMatrixMultiplication(n/2,a22,b_temp1,M4);    //   M4=a22*(b21-b11)
        
        MatrixAdd(n/2,a12,a11,a_temp1);
        StrassenMatrixMultiplication(n/2,a_temp1,b22,M5);    //  M5=(a11+a12)*b22

        MatrixSub(n/2,a21,a11,a_temp1);
        MatrixAdd(n/2,b11,b12,b_temp1);
        StrassenMatrixMultiplication(n/2,a_temp1,b_temp1,M6);     // M6=(a21-a11)*(b11+b12)

        MatrixSub(n/2,a12,a22,a_temp1);
        MatrixAdd(n/2,b21,b22,b_temp1);
        StrassenMatrixMultiplication(n/2,a_temp1,b_temp1,M7);    //M7=(a12-a22)*(b21+b22)


        MatrixAdd(n/2,M1,M4,M_temp1);
        MatrixSub(n/2,M7,M5,M_temp2);
        MatrixAdd(n/2,M_temp1,M_temp2,c11);      // c11=M1+M4-M5+M7

        MatrixAdd(n/2,M3,M5,c12);           //  c12=M3+M5

        MatrixAdd(n/2,M2,M4,c21);        // c21=M2+M4


        MatrixAdd(n/2,M1,M3,M_temp1);
        MatrixSub(n/2,M6,M2,M_temp2);
        MatrixAdd(n/2,M_temp1,M_temp2,c22);    //c22=M1+M3-M2+M6
        
        for(int i=0;i<n/2;++i)
            for(int j=0;j<n/2;++j)    {
                c[i][j]=c11[i][j];
                c[i][j+n/2]=c12[i][j];
                c[i+n/2][j]=c21[i][j];
                c[i+n/2][j+n/2]=c22[i][j];
            }
         }

}

int _tmain(int argc, _TCHAR* argv[])
{
    
    int a[N][N],b[N][N],c[N][N];
    int n=0;
    
    cout<<"请输入矩阵的阶数（<8）:"<<endl;
    cin>>n;
    cout<<"输入第一个矩阵："<<endl;
    InputMatrix(n,a);

    cout<<"输入第2个矩阵："<<endl;
    InputMatrix(n,b);

    StrassenMatrixMultiplication(n,a,b,c);
    
    OutputMatrix(n,c);
    system("pause");
    return 0;
}

分治法求最近对

思路：时间复杂度为nlog(n)，先按照每个点的x坐标用快速排序法进行排序，然后再递归求出左右两侧的最近对，还要求出中点附近位于分别位于左右两侧的最近对，为了处理

所有可能的点的个数，递归的出口时当点的数量为2或者3时。具体的代码如下：

#include "stdafx.h"
#include<iostream>
using namespace std;

typedef struct Point{
    float x;
    float y;
};

typedef struct Closepair{
    Point a;
    Point b;
    float dis;

};

//   依据点的X坐标对点进行排序，快排
int X_PartitionsPointArray(Point *a,int left,int right)    {
    Point pivot=a[left];
    while(left<right)    {
    
        while(left<right&&a[right].x>=pivot.x)
            --right;
        if(left<right)
            a[left++]=a[right];
        
        while(left<right&&a[left].x<=pivot.x)
            ++left;
        if(left<right)
            a[right--]=a[left];
    }
    a[left]=pivot;
    return left;
}

void SortPointArray(Point *a,int left,int right)    {
    if(left<right)    {
    
        int par=X_PartitionsPointArray(a,left,right);
        SortPointArray(a,left,par-1);
        SortPointArray(a,par+1,right);
    }

}

float DistancePointPair(Point a,Point b)    {
    
    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));

}


void ClosedPair(Point *a,int left,int right,Closepair &result)    {
    
    if((right-left+1)==1)
        cout<<"错误，点的数量必须大于1"<<endl;
    
    else if((right-left+1)==2)    {
    
        result.a=a[left];
        result.b=a[right];
        result.dis=DistancePointPair(a[left],a[right]);
    
    }
    
    
    else if((right-left+1)==3)    {
        float temp1=DistancePointPair(a[left],a[left+1]),temp2=DistancePointPair(a[right],a[left+1]),temp3=DistancePointPair(a[left],a[right]);

        if(temp1<temp2)    {
            result.a=a[left];
            result.b=a[left+1];
            result.dis=temp1;
            
        }
        else{
            result.a=a[right];
            result.b=a[left+1];
            result.dis=temp2;
            
        }
            
        if(temp3<result.dis){
            result.a=a[left];
            result.b=a[right];
            result.dis=temp3;
            
        }
    }


    else    {
        
        SortPointArray(a,left,right);
        

        Closepair left_result;
        Closepair right_result;

        ClosedPair(a,left,(left+right)/2,left_result);
        ClosedPair(a,(left+right)/2+1,right,right_result);

        Closepair all_result;
        
        if(left_result.dis<right_result.dis)
            all_result=left_result;
        else
            all_result=right_result;

        float distance=all_result.dis;

        int middle=(left+right)/2;
        
        for(int i=middle;i>=left;--i)    {
            
            if((a[middle+1].x-a[i].x)>distance)
                break;
            else    {
                for(int j=middle+1;j<=right;++j)    {
                    
                
                    if((a[j].x-a[middle].x)>distance)
                        break;
                    else    {
                    
                        float tempdis=DistancePointPair(a[j],a[i]);
                        if(tempdis<all_result.dis)    {
                            all_result.dis=tempdis;
                            all_result.a=a[i];
                            all_result.b=a[j];
                        }
                    
                    }
                
                }
            }
        }
        result=all_result;
    }

}

int _tmain(int argc, _TCHAR* argv[])
{
    Point a[10];
    Closepair result;
    int num;
    cout<<"要输入的点数(<10)："<<endl;
    cin>>num;

    cout<<"依次输入每个点的x坐标和y坐标："<<endl;
    for(int i=0;i<num;++i)
        cin>>a[i].x>>a[i].y;

    ClosedPair(a,0,num-1,result);

    cout<<"最近点为：("<<result.a.x<<","<<result.a.y<<")--->"<<"("<<result.b.x<<","<<result.b.y<<")    最近距离为："<<result.dis<<endl;
    system("pause");
    return 0;
}

分治法求凸包

#include "stdafx.h"
#include<iostream>
using namespace std;
const int N=20;

typedef struct Point{
    float x;
    float y;
};

typedef struct PointArray{
    Point plist[N];
    int num;
};

typedef struct Line{
    Point a;
    Point b;
};

typedef struct LineArray{
    Line llist[N];
    int num;

};


int X_PartitionsPointArray(Point *a,int left,int right)    {
    Point pivot=a[left];
    while(left<right)    {
    
        while(left<right&&a[right].x>=pivot.x)
            --right;
        if(left<right)
            a[left++]=a[right];
        
        while(left<right&&a[left].x<=pivot.x)
            ++left;
        if(left<right)
            a[right--]=a[left];
    }
    a[left]=pivot;
    return left;
}

void SortPointArray(Point *a,int left,int right)    {
    if(left<right)    {
    
        int par=X_PartitionsPointArray(a,left,right);
        SortPointArray(a,left,par-1);
        SortPointArray(a,par+1,right);
    }

}

// 求有向面积
float GetArea(Point p1,Point p2,Point p3)    {
      
    return (p1.x * p2.y + p3.x * p1.y + p2.x * p3.y -
             p3.x * p2.y - p2.x * p1.y - p1.x * p3.y);

}

void QuickHull(PointArray &a,LineArray &b)    {

    if(a.num==0||a.num==1)
        return;
    b.num=0;
    PointArray left,right;
    left.num=right.num=0;   //初始化

    SortPointArray(a.plist,0,a.num-1);   //按X坐标排序

    Point mostleft=a.plist[0];
    Point mostright=a.plist[a.num-1];

    float area=0;

    for(int i=1;i<a.num-1;++i)    {
        
        Point temp=a.plist[i];
        area=GetArea(mostleft,a.plist[i],mostright);
        if(area>0)    {
            left.plist[left.num++]=temp;
        }
        else if(area>0)    {
            right.plist[right.num++]=temp;    
        }
    }

    RecurtionHull(mostleft,mostright,left,b);
    RecurtionHull(mostright,mostleft,right,b);

}

void RecurtionHull(Point mostleft,Point mostright,PointArray a,LineArray &b )    {

        float area=0;
        float maxarea=0;
        Point pmax;
    
    
    
    if(a.num==0)    {
        
        b.llist[b.num++].a=mostleft;
        b.llist[b.num++].a=mostright;
    }


    else    {


        for(int i=0;i<a.num;++i)    {
            Point temp=a.plist[i];
            area=GetArea(mostleft,mostright,temp);
            if(area>maxarea)    {
                maxarea=area;
                pmax=temp;
            
            }
        }
    }

    PointArray a_left,a_right;
    a_left.num=a_right.num=0;
    for(int i=0;i<a.num;++i)    {
        Point temp=a.plist[i];
        if (GetArea(mostleft,pmax,temp)>0) {
            a_left.plist[a_left.num++]=temp;
            
        }
        else if(GetArea(mostleft,pmax,temp)<0)    {
            a_right.plist[a_right.num++]=temp;
        }
    }
    

    RecurtionHull(mostleft,pmax,a_left,b);
    RecurtionHull(pmax,mostright,a_right,b);
}


chenjun840168660
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
快速排序算法代码分治法
10-29
这个代码是利用快速排序算法，求第K大的数。 快速排序由C. A. R. Hoare在1960年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后...
23.合并K个升序链表
icehill的专栏
05-01 111
23.合并K个升序链表 解题思路：1顺序合并，2分治合并 package leadcode; import leadcode.lib.ListNode; import leadcode.lib.ListNodeInit; import java.util.List; /** * @author : icehill * @description : 合并K个升序链表 * 给你一个链表数组，每个链表都已经按升序排列。 * 请你将所有链表合并到一个升序链表中，返回合并后的链表。 * 示例 1：
归并排序
forrest420的专栏
12-05 398
推导公式： 递推公式： merge_sort(p…r) = merge(merge_sort(p…q), merge_sort(q+1…r)) 终止条件： p >= r 不用再继续分解 merge_sort(p…r) 表示，给下标从 p 到 r 之间的数组排序。我们将这个排序问题转化为了两个子问题，merge_sort(p…q) 和 merge_sort(q+1…r)，其中下标 q 等于...
LeetCodet题解--23. Merge k Sorted Lists（合并K个已排序的链表）
OSKernelLAB(gatieme)
04-08 4257
链接 LeetCode题目：https://leetcode.com/problems/generate-parentheses GitHub代码：https://github.com/gatieme/LeetCode/tree/master/022-GenerateParentheses CSDN题解：http://blog.csdn.net/gatieme/article
分治法（算法）
Alingte7的博客
09-10 1万+
二分法，归并排序，快速排序，快速幂，汉诺塔
【算法】分治法详解和汇总
weixin_45434953的博客
03-14 4190
分治法的基本思想是将一个难以直接解决的大问题划分为一些规模较小的子问题，分别求各个子问题，然后将各个子问题的答案合并成为规模较大的原问题的解。在用分治法设计算法的时候，最好使得子问题的规模大致相同。也就是将一个问题的划分称为规模相等的k个子问题，这种使得子问题规模大致相等的做法是出自一种的启发性问题。另外，在使用分治法设计算法的时候，最好使得各个子问题之间相互独立，如果各个子问题不是独立的，那么分治法会求一些重复求解的重叠子问题，这会导致做很多重复工作，使得算法的效率下降，此时使用动态规划算法更好。
算法详解之分治法具体实现
01-01
分治算法的基本思想是将一个规模为N的问题分解为K个规模较小的子问题，这些子问题相互独立且与原问题性质相同。求出子问题的解，就可得到原问题的解。 分治法解题的一般步骤： （1）分解，将要解决的问题划分成若干...
C语言分治法实现归并排序
12-31
将两个及其以上的有序表合并为一张有序表，把待排序序列通过分治法分为若干个有序子序列，然后每两个子序列合并为一个子序列，经过多次合并后整合为一张有序表。 排序过程如图： 代码如下： #include stdio.h #...
计算机算法基础分治法
04-11
这是有关算法的知识，分治法的基本思想 在分治法中,子问题的解法通常与原问题相同,自然导致递归过程
分治法算法实践
10-26
这次的二分查找算法实践，加深了我对二分法的理解。因为书本上有二分法查找的相关内容，我们没出现大问题。问题是出现在数组的定义上。我们一起找，没找到，最后上网查了一下才知道原来是我们数组定义的时候出了错!...
【算法设计与分析】分治法（最近点对问题）
b1ngsha的博客
05-05 2678
考虑最近点对有可能是上述某次递归调用找出的距离为d的点对，也有可能是SL中的一个点与SR中的一个点形成的点对。在分治开始前，已经对X和Y数组进行递增排序，此时取中间点将点集划分为左区域SL和右区域SR，SL中所有点都在中线上或是在中线的左侧，SR中所有点都在中线上或是在中线的右侧。遍历n个点与剩余n-1个点之间的距离，在计算点对距离时不断更新最短距离的值，遍历完所有点对后即可求得最短点对距离。遍历一点在Y’L中，另一点在Y’R中的所有点对距离，并返回得到的最小点对距离。此方法的时间复杂度为O(n²)，
三大算法之一：分治法（带你用分治法思想优化程序，计算降低复杂算法的时间复杂度）
分享学习的知识，记录我的技术成长道路
10-07 1万+
1.排序 1.排序的概念 排序是计算中经常进行的一系列操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。简单来说 无序->有序。 通常情况下排序分为两种：内部排序，外部排序 1.内部排序 若整个排序的过程中不需要访问外存便能完成，则成这类问题为内部排序。 2.外部排序 若参与排序的数据数量过大，整个序列排序过程中不可能在内存中完成，则称此类排序为外部排序。 我们主要讨论的是内部排序的各种方法。 2.排序的流程 1.排序流程 1.得到n个记录数据的序列为{R1,R2,
分治算法详细讲解（含经典例题分析）
热门推荐
qq_44398094的博客
11-22 4万+
分治法思路： 将整个问题分解成若干小问题后再分而治之。如果分解得到的子问题相对来说还是太大，则可反复使用分治策略将这些子问题分成更小的同类型子问题，直至产生方便求解的子问题，必要时逐步合并这些子问题的解，从而得到问题的解。 分治算法可以由递归过程来表示，因为分治法就是一种找大规模问题与小规模问题关系的方法，是递归设计的一种具体策略。 步骤 1.分解 将原问题分解为若干规模较小，相互独立，与原问题相同的子问题。 2.解决 若干子问题较小而容易被解决则直接解决，否则再继续分解为更小的子问题，直到容易解决。 3.
【算法分析】分治法详解+范例+习题解答
weixin_50927106的博客
06-17 3479
将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破， 分而治之 1.4主定理Master Theorem 将待排序元素分成大小大致相同的2个子集合，分别对2个子集合进行排序，最终将排好序的子集合合并成为所要求的排好序的集合。 T(n)=Θ(nlogn) 渐进意义下的最优算法给已排好序的n个元素中寻找特定元素xA和B的乘积矩阵C中的元素C[i,j]定义为 传统方法：O(n3)【计算时，三个for循环】为了降低时间复杂度，必须减少乘法的次数 请设计一个有效的算法，可以进行两个n位大整数
算法（3）分治法
weixin_42776344的博客
03-08 3574
1 基本思想 分治法，字面上的解释是"分而治之"，就是把一个复杂的问题分成两个或更多的相同子问题，再把子问题分成更小的子问题，直到最后各个子问题可以简单地直接求解，对各个子问题的解进行合并即得原问题的解。 分治法的特征： （1）问题的规模缩小到一定程度就可以容易地解决。 （2）问题可以分解为若干个规模较小的相同子问题。 （3）问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子问题。 （4）问题分解出的子问题的解可以合并为原问题的解。 第四条特征是关键，能否利用分治法完全取决于问题是否具有第四条
算法设计 - 分治法
伏城之外的博客
08-06 1267
分治法、分治思想、快速排序、单边循环、双边循环、时间复杂度、O(nlogn)、O(n^2)优化、打乱有序、归并排序、归并原理分析、归并排序的非递归实现
【分治法】
@76135327的博客
05-12 669
叶子到树根的最长路径。
分 治 算 法
欢迎来到代码骑士的秘密基地
03-25 3281
一、什么是分治（what？） 分治，即分而治之。这是一种将大规模问题分解为若干个规模较小的相同子问题，进而求得最终结果的一种策略思想。 二、为什么要分治（why? ） 当一个问题规模较大，且 （1）原问题可分为若干个规模较小的子问题。 （2）子问题相互独立。 （3）子问题的解可以合并为原问题的解。 这时使用分治算法能更好的解决问题。 三、怎么使用分治（how？） 分治的步骤一般如下： ...
分治法简介
li_kin的博客
08-19 3109
Task01-分治法1 简介1.1 分支算法步骤1.2 分治算法适用场景1.3 伪代码解释1.4 分治算法实例1.4.1 分治算法应用在排序1.4.2 LeetCode真题 1 简介 分治算法思想：是将原问题递归地分成若干个子问题，直到子问题满足边界条件，停止递归，将子问题逐个解决(一般是同种方法)，将已经解决的子问题合并，最后，算法会层层合并得到原问题的答案。 1.1 分支算法步骤 分：递归地将问题分解为各个的子问题(性质相同的，相互独立的子问题) 治：将这些规模更小的子问题逐个击破 合：将已解决的问题
K-D Tree算法、分治法
最新发布
05-15
K-D Tree（K-Dimensional Tree）算法是一种基于分治法的数据结构，用于高维空间的搜索和排序。它的基本思想是将多维空间中的点以某种方式分割成更小的子空间，然后在每个子空间中递归地进行搜索。这样可以大大降低...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值