PS:报告分为两个部分：经典算法原理和模板总结。

本文涉及的基础算法目录

• 快速排序
• 归并排序
• 二分
• 前缀和（一维数组与二维矩阵）
• 差分（一维数组和二维矩阵）

一.快速排序

步骤：

假设左边界位置为l,右边界为r.

1. 找到数组中的任意一个数字（但是如果选择左右端点值有时会触发边界问题导致算法进入死循环）作为一个分界点，为避免边界问题，就选择分界点x=l+r+1>>1。（该表达式等价于x=(l+r+1)/2,">>"运算符表示除以二，"<<"运算符表示乘以二，左移和右移运算符是双目运算符中最低级别，可以不加括号）。
2. 创建一个指针i（不是真的指针，是普通int型标记变量）从左边界往右移动，再创建一个指针j，从右边界往左移动，在i,j移动途中，将i找到的大于等于x的值与j找到的小于等于x的值交换，直到i与j发生相遇（即i>=j）。
3. 此时从l到i-1的所有值都是小于等于x的，从i到r的值均是大于等于x的，此时就把他们分成了两个数组。
4. 将这两个数组分别再次重复以上步骤（通过递归调用），直到每个小数组中l>=r（即数组中只剩一个元素）。

 原理图

                                 3          4            2             1             5 

                                 l                         x                              r

• x=l+r+1>>2=0+4+1/2=2;选择分界点x=2的位置的值2 

                            3          4          2             1              5

                         i ---->i(3>2)                x              j(1<2)        <----j

• 交换3和1；

                                 1          4            2             3              5

                                              i(4>2)    j(2=2)

• 交换4和2；            

                                  1           2           4            3              5

                                                j            i

•  当i和j停下来且i>j所以将其分为两个数组
• 即[1 2]和[ 4 3 5];
• 然后这两段数组分别继续执行相同操作。  

代码模板 

基本无需改动（从小到大排序版）

void quicksort(int a[], int l, int r)
{
	if(l>=r)
	{
		return;
	}
	int x=a[l+r+1>>1],i=l-1,j=r+1;
	while(l<r)
	{
		while(a[++i]<x);
		while(a[++j]>x);
		if(i<j) swap(a[i],a[j]);
	}
	quicksort(a,l,i-1);//x不能取a[l],可以拿a=[1 2]这个数组验证一下
	quicksort(a,i,r);
} 

 (从大到小排序版)

void quicksort(int a[], int l, int r)
{
	if(l>=r)
	{
		return;
	}
	int x=a[l+r>>1],i=l-1,j=r+1;
	while(l<r)
	{
		while(a[++i]<x);
		while(a[++j]>x);
		if(i<j) swap(a[i],a[j]);
	}
	quicksort(a,l,j);//x不能取a[r],可以拿a=[1 2]这个数组验证一下
	quicksort(a,j+1,r);
} 

 二.归并排序

步骤：

假设左边界位置为l,右边界为r，mid为l+r>>1;

1. 将要排序的数组不断从中间分成两部分，直到分成元素数量均为1的数组
2. 采用双指针滑动去做每次排序（每次排序都要排两个数组并且合并成一个数组）不太了解双指针同时合并两个有序数组可以看这篇文章（LeetCode-88:合并两个有序数组(图文并茂)_It‘s so simple的博客-CSDN博客）

原理图：

                |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|   

             [  3                   6                     4                   5                     1                    2  ]

                |~~~~~~~~~~~~~~~~~~~~~|                    |~~~~~~~~~~~~~~~~~~~~~| 

             [ 3                     6                    4 ]               [  5                     1                    2  ]

                |                      |~~~~~~~~~~|                    |                      |~~~~~~~~~~|

             [ 3 ]                  [ 6                    4 ]              [  5  ]                [  1                   2  ]

                |                      |                     |                     |                      |                     |

             [ 3 ]                  [ 6 ]                 [ 4 ]              [ 5 ]                  [ 1 ]                 [ 2 ]

      ***********           以上为不断分组过程，下面为排序和归并还原过程（逆过程）  **********

             [ 3 ]                  [ 6 ]                 [ 4 ]              [ 5 ]                  [ 1 ]                 [ 2 ]     

                |                       |___________|                   |                       |___________|

             [ 3 ]                  [ 4                     6 ]              [ 5 ]                  [ 1                      2 ]

                |_______________________|                   |________________________|

             [  3                    4                       6 ]             [ 1                      2                       5 ]

                 |_________________________________________________________|

             [1                      2                        3                 4                      5                       6 ]

代码模板

void merge_sort(int a[], int l, int r)
{
    if(l>=r) return;
    int mid=l+r>>1;
    //将一个数组不断平分
    merge_sort(a,l,mid);
    merge_sort(a,mid+1,r);
    //然后就是合并过程，边排序边合并，注意这里每次返回的两个数组在他们自己组内是有序的，
//只是整体无序。
    //双指针排序过程
    int i=l,j=mid+1,k=-1;
    while(i<=mid&&j<=r)
    {
        if(a[i]<a[j]) temp[++k]=a[i++];
        else temp[++k]=a[j++];
    }
    while(i<=mid) temp[++k]=a[i++];
    while(j<=r) temp[++k]=a[j++];
    for(int i=r;i>=l;i--)
    {
        a[i]=temp[k--];
    }
}

PS :以上的两种排序法加上自带的sort函数那种最快，试了一下，如图

 第一行是sort,用了363ms；第二行是归并排序，用了168ms;第三行是快速排序，用了167ms。

当然这只是一个例子，不足以说明全部，但是可以看出sort是效率最慢的。

三.二分

假设左边界位置为l,右边界为r，中间位置mid为l+r>>1;

步骤：

1. 通过题目要求的条件每次取左边部分或者每次取右边部分，这样就可以每次减少一半的搜索量。
2. 最后会达到l>=r的条件（其实就是l==r），那么那个就是解。

 Ps:二分必有解，如果程序运行后无解,那一定是题目存在无解情况。

整数的二分代码：

//第一种 
int l = 0, r = n - 1;//n为数组总长度
while (l < r)
{
    int mid = l + r >> 1;
    if (q[mid] >= x/*填求解条件*/) r = mid;
    else l = mid + 1;
}

//第二种
while (l < r)
{
    int mid = l + r + 1 >> 1;
    if (q[mid] <= x/*填求解条件*/) l = mid;
    else r = mid - 1;
}
//依据情况选择这两种，如果选择左半部分（即r=mid），那么上一行l+r>>1部分不用+1；
//若选择右半部分（即l=mid），上一行要用int mid = l + r + 1 >> 1;
/*为什么？还是因为会陷入死循环，当第二种情况出现l=r-1时，如果使用依然mid=l+r>>1;
那么mid=2*l+1>>1,因为int型向下取整,mid=l,那么下一步时，l=mid=l，死循环*/

浮点数二分代码：

 double mid=(l+r)/2;
        if(mid*mid*mid>=n/*此处填求解判断条件*/) r=mid;
        else l=mid;

四.前缀和（一维数组和二维矩阵）

一维前缀和就不概述了，这里有推荐文章可以回顾

前缀和——（1）什么是前缀和和一维前缀和_努力的老周的博客-CSDN博客_前缀和

二维矩阵前缀和：

首先在一个二维矩阵中某一位置（x,y）的前缀和是指一块矩阵内的所有数的和，例如求中间一个矩阵和就是从左上角坐标(x1,y1)到右下角坐标(x2,y2)构成的矩阵内的数，而前缀和则指（0,0）为左上角坐标，（x,y）为右下角坐标的矩阵。

设a[i][j]为原二维数组，sum[i][j]为（0,0）为左上角坐标，（i,j）为右下角坐标的矩阵和数组。

这里采用了dp动态规划求前缀和。

原理图 

代码贴这

//前缀和函数代码---要用一个额外数组存前缀和
void sumprefix()
{
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            sum[i][j]=sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1]+a[i][j];
        }
    }
}
//也可以在原数组基础上直接更新并存储前缀和，如果原数组的值后面用不上
void sumprefix()
{
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            a[i][j]+=a[i-1][j]+a[i][j-1]-a[i-1][j-1];
        }
    }
}

五.差分（一维数组和二维矩阵）

差分其实是用来对于数组的各个任意区间做多次加减操作的快速解法。

差分一维的就不概述了，推荐了解一下这篇文章

差分法_威威攻城狮的博客-CSDN博客_差分

二维差分原理图

 应用例题理解

解法：

1. 先构建差分数组，这一步类似一维的a[l]+=c;a[r+1]-=c操作;
2. 对整个数组求前缀和（二维），这一步类似一维的sum求前缀和。

输入一个 n 行 m 列的整数矩阵，再输入 q 个操作，每个操作包含五个整数 x1,y1,x2,y2,c，其中 (x1,y1) 和 (x2,y2) 表示一个子矩阵的左上角坐标和右下角坐标。每个操作都要将选中的子矩阵中的每个元素的值加上 c。

请你将进行完所有操作后的矩阵输出。

输入格式

第一行包含整数 n,m,q。

接下来 n 行，每行包含 m 个整数，表示整数矩阵。

接下来 q 行，每行包含 5 个整数 x1,y1,x2,y2,c，表示一个操作。

输出格式

共 n 行，每行 m 个整数，表示所有操作进行完毕后的最终矩阵。

数据范围

1≤n,m≤1000,
1≤q≤100000,
1≤x1≤x2≤n,
1≤y1≤y2≤m,
−1000≤c≤1000,
−1000≤矩阵内元素的值≤1000

输入样例：

3 4 3
1 2 2 1
3 2 2 1
1 1 1 1
1 1 2 2 1
1 3 2 3 2
3 1 3 4 1

输出样例：

2 3 4 1
4 3 4 1
2 2 2 2

 

#include<iostream>
using namespace std;
int a[1010][1010];//存放原矩阵值
int b[1010][1010]={0};//用于构造差分矩阵的数组，值都设为零，与一维构造差分数组一样
int n,m,q;

//求前缀和
void sumprefix()
{
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            b[i][j]+=b[i-1][j]+b[i][j-1]-b[i-1][j-1];
        }
    }
}

//构造差分矩阵
void difference(int x1, int y1, int x2, int y2, int c)
{
    b[x1][y1]+=c;
    b[x2+1][y1]-=c;
    b[x1][y2+1]-=c;
    b[x2+1][y2+1]+=c;
}

int main()
{
    int x1,x2,y1,y2,c;
    cin>>n>>m>>q;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            cin>>a[i][j];
        }
    }
    
    //使用差分，标记
    while(q--)
    {
        cin>>x1>>y1>>x2>>y2>>c;
        difference(x1,y1,x2,y2,c);
    }
    //求前缀和，完成区间的加减操作
    sumprefix();
 
    //b[][]只是数值为零基础上完成加减操作矩阵，所以要加上a[][]原矩阵。 
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            cout<<b[i][j]+a[i][j]<<" ";
        }
        cout<<endl;
    }
    return 0;
}