acwing算法基础课第一章模板

最新推荐文章于 2024-03-09 23:33:09 发布
最新推荐文章于 2024-03-09 23:33:09 发布
阅读量685 收藏 17
点赞数 2
分类专栏： 课程复习 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43790779/article/details/117483291
版权

一、 快速排序（QuickSort）

算法思想：

由冒泡排序改进，在冒泡排序过程中，只对相邻的两个记录进行比较，每次交换只能消除一个逆序；
而快速排序时对不一定相邻的两个记录进行比较，每次交换可以消除多个逆序。
快速排序是不稳定的。
时间复杂度：最差： O ( n 2 ) O(n^2) O(n2)；平均： O ( n l o g 2 n ) O(nlog_2n) O(nlog2​n)。

  1. 如果left>=right，则退出；
  2. 在数组中随即确定一个分界点x，假设x=(left+right)/2；
  3. 设指针i,j，分别指向left，right；
  4. 当i<j时，循环执行5，6，7步；
  5. 如果i指针所指向的数小于x，则i++；否则，跳出循环；
  6. 如果j指针所指向的数大于x，则j--；否则，跳出循环；
  7. 如果i<j，则swap(arr[i],arr[j])；
  8. 调整区间，递归处理左右两段，quick_sort(arr,left,i);quick_sort(arr,i+1,right);

代码：

#include <iostream>
#include <stdio.h>
using namespace std;
const int N = 1e6+10;
int n;
int q[N];
void quick_sort(int q[],int l,int r)
{
	if(l >= r) return;
	int x = q[l],i = l-1,j = r+1;
	while(i < j)
	{
		//如果12 12不先进行++，--操作的话，会造成死循环
		do i++; while(q[i] < x);
		do j--; while(q[j] > x);
		if(i < j) swap(q[i],q[j]);
	}
	//会一直存在(0,i)区间，死循环
	quick_sort(q,l,j);
	quick_sort(q,j+1,r);
}
int main()
{
	scanf("%d",&n);
	for(int i=0;i<n;i++)
		scanf("%d",&q[i]);
	quick_sort(q,0,n-1);
	for(int i=0;i<n;i++)
		printf("%d ",q[i]);
	
	return 0;
}

二、 归并排序（MergeSort）

分治法思想
归并排序是稳定的。
时间复杂度： O ( n l o g 2 n ) O(nlog_2n) O(nlog2​n)。

算法思想：

  1. 取数组的中间值作为分界点mid；
  2. 将mid左边的序列，右边的序列分别排好序；
  3. 对左右序列进行合并。

代码：

#include <iostream>
#include <stdio.h>
using namespace std;

const int N = 1e6+10;
int q[N],tmp[N];
int n;

void merge_sort(int q[],int l,int r)
{
    if(l>=r)
        return;
    int mid = l+r >> 1;
    merge_sort(q,l,mid);
    merge_sort(q,mid+1,r);

    int k=0,i=l,j=mid+1;
    while(i<=mid && j<=r)
        if(q[i] <= q[j])
            tmp[k++] = q[i++];
        else
            tmp[k++] = q[j++];
    while(i <= mid)
        tmp[k++] = q[i++];
    while(j <= mid)
        tmp[k++] = q[j++];

    for(i=l,j=0;i<=r;i++,j++)
        q[i] = tmp[j];
}
int main()
{
	scanf("%d",&n);
	for(int i=0;i<n;i++)
		scanf("%d",&q[i]);

	merge_sort(q,0,n-1);

	for(int i=0;i<n;i++)
		printf("%d ",q[i]);

	return 0;
}

三、 二分查找（BinarySearch）

算法思想：

  1. 首先对数组进行排序。
  2. 将要查找值x与数组中间值mid相比较；
  3. 如果x=mid，则找到x，退出程序；
  4. 如果x<mid，则将边界设为[left,mid]；
  5. 如果x>mid，则将边界设为[mid+1,right]；
  6. 循环执行4，5两步骤，若直到数组长度为1，还没找打x，则数组中不存在x。

代码：

//整数二分查找
#include <iostream>
#include <stdio.h>
using namespace std;

const int N = 1e6+10;
int q[N];
int n,m;


int main()
{
	scanf("%d%d",&n,&m);
	for(int i=0;i<n;i++)
		scanf("%d",&q[i]);

	while(m--)
    {
        int x;
        scanf("%d",&x);

        int l=0,r=n-1;
        //取第一个等于x的数，右边界等于mid
		while(l<r)
        {
            int mid = l+r >> 1;
            if(x <= q[mid])
                r = mid;
            else
                l = mid + 1;
        }
        if(q[l] != x)
            cout << "-1 -1" << endl;
        else
        {
            cout << l << " ";
            int l=0,r=n-1;
            //取最后一个等于x的数，左边界等于mid
            while(l<r)
            {
                int mid = l+r+1 >> 1;
                if(x >= q[mid])
                    l = mid;
                else
                    r = mid -1;
            }
            cout << l << endl;
        }
    }

	return 0;
}

//浮点数二分查找
#include <iostream>
#include <stdio.h>
using namespace std;

int main()
{
	double x;
	scanf("%lf",&x);
	double l = 0,r = x;
	while(r-l > 1e-8)
    {
        double mid = (l+r)/2;
        if(mid*mid >= x)
            r = mid;
        else
            l = mid;
    }
    printf("%lf\n",l);

	return 0;
}

四、 高精度算法

存储： 数组存储，低位数存在低位。
算法思想：

  • 加减法：
    1. 用字符串读入两个大整数a,b；
    2. 用vector<int> 分别倒序存储a,b，得到A,B，设和数向量C；
    3. 如果是减法则执行步骤6；
    4. 设中间变量t来存储进位，t分别加A[i]，B[i]，将t%10 push到C，令t/=10；
    5. 循环执行4，直到i大于A,B两向量的长度。
    6. 首先根据A,B的长度，高位的值比较大小；
    7. 设中间变量t来存储进位，A[i]-B[i]-t，将(t+10)%10 push到C，若t<0，则令t=1，否则令t=0；
  • 乘除法：
    1. 用字符串读入大整数a，整型读入整数b；
    2. 用vector<int> 倒序存储a，得到A，设向量C；
    3. 如果是除法则执行步骤6；
    4. 设中间变量t来存储进位，t加A[i]*b，将t%10 push到C，令t/=10；
    5. 循环执行4，直到i大于A的长度。
    6. 设余数r，r=r*10+A[i]，将r/bpush到C，令r%=b；
    7. 将C中的值反转，去除前置0。

代码：
加法，减法：

#include <iostream>
#include <vector>
using namespace std;

//大整数加法
vector<int> add(vector<int> &A,vector<int> &B)
{
    vector<int> C;
    int t = 0;
    for(int i=0;i<A.size()||i<B.size();i++)
    {
        if(i < A.size())
            t += A[i];
        if(i < B.size())
            t += B[i];
        C.push_back(t%10);
        t /= 10;
    }
    if(t)
        C.push_back(1);
    return C;
}

//大整数减法
bool cmp(vector<int> &A,vector<int> &B)
{
    if(A.size() != B.size())
        return A.size()>B.size();
    else
    {
        for(int i=A.size()-1;i>=0;i--)
            if(A[i] != B[i])
                return A[i] > B[i];
        return true;
    }
}

vector<int> sub(vector<int> &A,vector<int> &B)
{
    vector<int> C ;
    int t = 0;
    for(int i=0;i<A.size();i++)
    {
        if(B.size()<i)
            t = A[i]-t;
        else
            t = A[i] - B[i] - t;
         C.push_back((t+10)%10);
         if(t<0)
            t = 1;
         else
            t = 0;
    }
	//去掉前导0
    while(C.size()>1 && C.back()==0)
        C.pop_back();
    return C;
}


int main()
{
	string a,b;
    vector<int> A,B;

	cin >> a >> b;
	for(int i=a.size()-1;i>=0;i--)
        A.push_back(a[i]-'0');
    for(int i=b.size()-1;i>=0;i--)
        B.push_back(b[i]-'0');

    vector<int> C = add(A,B);

    for(int i=C.size()-1;i>=0;i--)
        cout << C[i];
    cout << endl;
    if(cmp(A,B))
        C = sub(A,B);
    else
    {
    	C = sub(A,B);
		cout << "-";
	}
    for(int i=C.size()-1;i>=0;i--)
        cout << C[i];

	return 0;
}

乘法、除法：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> mul(vector<int> &A,int b)
{
    vector<int> C;
    int t = 0; //进位
    for(int i=0;i<A.size();i++)
    {
        t += A[i]*b;
        C.push_back(t%10);
        t /= 10;
    }
    if(t)
        C.push_back(t);
    return C;
}

vector<int> div(vector<int> &A,int b,int &r)
{
    vector<int> C;
    r = 0;
    for(int i=A.size()-1;i>=0;i--)
    {
        r = r*10+A[i];
        C.push_back(r/b);
        r %= b;
    }
    reverse(C.begin(),C.end());
    while(C.size()>1 && C.back()==0)
        C.pop_back();
    return C;
}


int main()
{
	string a;
	int b;
    vector<int> A;

	cin >> a >> b;
	for(int i=a.size()-1;i>=0;i--)
        A.push_back(a[i]-'0');

    vector<int> C = mul(A,b);

    for(int i=C.size()-1;i>=0;i--)
        cout << C[i];
    cout << endl;

    int r;
    C = div(A,b,r);

    for(int i=C.size()-1;i>=0;i--)
        cout << C[i];
    cout << " " << r;

	return 0;
}

五、 一维前缀和

算法思想：

  1. 前缀和数组，原数组的下标均由1开始。
  2. 求前缀和：将S[0]置0，S[i]=S[i-1]+a[i]。
  3. 区间[l,r]的数组的和等于S[r]-S[l-1]。

代码：

#include <iostream>
using namespace std;

const int N = 100010;
int a[N],s[N];
int m,n;

int main()
{
    cin >> n >> m;
    for(int i=1;i<=n;i++)
        cin >> a[i];

    for(int i=1;i<=n;i++)
        s[i] = s[i-1] + a[i];

    while(m--)
    {
        int l,r;
        cin >> l >> r;
        cout << s[r] - s[l-1] << endl;
    }
	return 0;
}

六、 子矩阵前缀和

算法思想：

  1. 先求前缀和：
  2. 求子矩阵的和：

代码：

#include <iostream>
using namespace std;

const int N = 1010;
int a[N][N],s[N][N];
int m,n,q;

int main()
{
    cin >> n >> m >> q;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            cin >> a[i][j];

    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            s[i][j] = s[i-1][j] + s[i][j-1] - s[i-1][j-1] + a[i][j];

    while(q--)
    {
        int x1,x2,y1,y2;
        cin >> x1 >> y1 >> x2 >> y2;
        cout << s[x2][y2] - s[x1-1][y2] - s[x2][y1-1] + s[x1-1][y1-1]<< endl;
    }
	return 0;
}

七、 差分

若a[n]是b[n]的前缀和，则b[n]是a[n]的差分。
使区间[l,r]中的每一个a[i]+c，则只需b[l]+c，b[r+1]-c。

算法思想：

  1. 假设a数组初始值全为0，则b数组的值也全为0。
  2. 将a[i]的值插入a数组，则可以理解为在区间[i,i]中a[i]+c，那么需对b[i]+a[i]，b[i+1]-a[i]。
  3. 最终对b[i]求前缀和即可。

代码：

#include <iostream>
using namespace std;

const int N = 100010;
int a[N],b[N];
int m,n;

void inserta(int l,int r, int c)
{
    b[l] += c;
    b[r+1] -= c;
}

int main()
{
    cin >> n >> m;
    for(int i=1;i<=n;i++)
        cin >> a[i];

    for(int i=1;i<=n;i++)
        inserta(i,i,a[i]);

    while(m--)
    {
        int l,r,c;
        cin >> l >> r >> c;
        inserta(l,r,c);
    }

    for(int i=1;i<=n;i++)
        b[i] += b[i-1];

    for(int i=1;i<=n;i++)
        cout << b[i] << " ";

	return 0;
}

八、 差分矩阵

算法思想：
同上思想相同。

代码：

#include <iostream>
using namespace std;

const int N = 1010;
int a[N][N],b[N][N];
int m,n,q;

void inserta(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()
{
    cin >> n >> m >> q;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        {
            cin >> a[i][j];
            inserta(i,j,i,j,a[i][j]);
        }

    while(q--)
    {
        int x1,x2,y1,y2,c;
        cin >> x1 >> y1 >> x2 >> y2 >> c;
        inserta(x1,y1,x2,y2,c);
    }
    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];

    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
            cout << b[i][j]  << " ";
        cout << endl;
    }


	return 0;
}

九、 双指针算法

算法思想：

  1. 设一个计数数组S[n]，记录在[i,j]区间内数每个数出现的次数。
  2. i每向右移一位，S[a[i]]++；j向右移之前，先S[a[j]]–。
  3. 记录不重复子数组的最长长度。

代码：

#include <iostream>
using namespace std;

const int N = 100010;
int a[N],s[N];

int main()
{
    int n;
    cin >> n;
    for(int i=0;i<n;i++)
        cin >> a[i];

    int res = 0;
    for(int i=0,j=0;i<n;i++)
    {
        s[a[i]]++;
        while(s[a[i]] > 1)
        {
            s[a[j]]--;
            j++;
        }
        res = max(res,i-j+1);
    }

    cout << res << endl;

	return 0;
}

十、 位运算

算法思想：

  1. 求n的二进制表示中第k+1位是几，n>>k&1。
  2. 返回x的最后一位1是多少，x&-x，x=1010，lowbit(x)=2。（求x的二进制中多少个1）
    代码：
#include <iostream>
using namespace std;

int lowbit(int x)
{
    return x&-x;
}

int main()
{
    int n;
    cin >> n;
    while(n--)
    {
        int x;
        cin >> x;

        int res = 0;
        while(x)
        {
            x -= lowbit(x);
            res++;
        }

        cout << res << " ";
    }

	return 0;
}

十一、 离散化

算法思想：

  1. 用到前缀和求区间内值的和。
  2. 去重：先将数组进行排序，利用unique，erase去重。
  3. 二分查找。

代码：

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

typedef pair<int,int> p;
const int N = 300010;
int n,m;
int a[N],s[N];

vector<int> alls;
vector<p> query,add;

int findf(int x)
{
    int l=0,r=alls.size()-1;
    while(l < r)
    {
        int mid = l+r>>1;
        if(alls[mid]>=x)
            r = mid;
        else
            l = mid + 1;
    }
    return r+1;
}


int main()
{
    cin >> n >> m;
    for(int i=0;i<n;i++)
    {
        int x,c;
        cin >> x >> c;
        add.push_back({x,c});

        alls.push_back(x);
    }

    for(int i=0;i<m;i++)
    {
        int l,r;
        cin >> l >> r;
        query.push_back({l,r});
        alls.push_back(l);
        alls.push_back(r);
    }

    //去重
    sort(alls.begin(),alls.end());
    alls.erase(unique(alls.begin(),alls.end()),alls.end());

    //处理插入
    for(int i=0;i<add.size();i++)
    {
        int x = findf(add[i].first);
        a[x] += add[i].second;
    }

    //预处理前缀和
    for(int i=1;i<=alls.size();i++)
        s[i] =  s[i-1] + a[i];

    //处理询问
    for(int i=0;i<query.size();i++)
    {
        int l = findf(query[i].first);
        int r = findf(query[i].second);
        cout << s[r] - s[l-1] << endl;
    }

	return 0;
}

十二、 区间合并

算法思想：

  1. 按照区间左端点排序。
  2. 初始化左st右ed边界为-2e9。
  3. 比较ed与当前所在区间左端点，更新区间，并将更新后的区间记录下来。
  4. 返回数组长度。

代码：

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

typedef pair<int,int> p;
const int N = 100010;

int n;
vector<p> seg;

void mergea(vector<p> &seg)
{
    vector<p> res;
    sort(seg.begin(),seg.end());

    int st = -2e9, ed = -2e9;
    for(int i=0;i<seg.size();i++)
    {
        if(ed < seg[i].first)
        {
            if(st != -2e9)
                res.push_back({st,ed});
            st = seg[i].first;
            ed = seg[i].second;
        }
        else
            ed = max(ed,seg[i].second);
    }
    if(st != -2e9)
        res.push_back({st,ed});
    seg = res;
}

int main()
{
    cin >> n;

    for(int i=0;i<n;i++)
    {
        int l,r;
        cin >> l >> r;
        seg.push_back({l,r});
    }

    mergea(seg);

    cout << seg.size() << endl;

	return 0;
}
abtgu
关注
专栏目录
基础算法模板(Acwing)
Allen的博客
01-27 1307
1.快速排序（Acwing 785.快速排序） void quick_sort(int a[],int l,int r) { if(l>=r)return; int i=l-1,j=r+1,x=l+r>>1;//'+'的优先级高于'>>'移位运算符 while(i<j) { do i++;while(a[i]<x); do ...
Acwing算法基础课学习笔记
togph的博客
04-16 1928
Acwing 算法基础学习笔记
AcWing算法基础的一些模板
qq_34348564的博客
05-26 743
快速排序模板 void quick_sort(int q[],int l,int r){ if(l >= r) return; int i = l-1,j = r+1,,x = q[l+r>>1]; while(i < j){ do i++;while(q[i] < x); do j--;while(q[j] > x); if(i < j) swap(q[i],q[j]); } quick_sort(q,l,j);quick_sort(q,j+
AcWing算法基础课——简单算法模板
最新发布
Beau_Will的博客
03-09 644
本篇文章只给出代码模板，以及自己对该模板的理解。如果想看正确的算法思路，可以移步AcWing官网看详情。如有理解错误，欢迎大家批评指正。
【模板】ACwing算法基础课模板小全
Zh0uKal1的博客
03-30 2984
边界问题因为边界问题只有这两种组合，不能随意搭配 归并排序算法模板 整数二分算法模板 浮点数二分算法模板 高精度加法 高精度减法 高精度乘低精度 高精度乘高精度 高精度除低精度 一维前缀和 前缀和可以用于快速计算一个序列的区间和，也有很多问题里不是直接用前缀和，但是借用了前缀和的思想。 应用 二维前缀和 应用 一维差分 差分是前缀和的逆运算，对于一个数组a，其差分数组b的每一项都是a [ i ]和前一项a [ i − 1 ]的差。注意：差分数组和原数组必须分开存放！！！！ 应用 二维差
Acwing 算法基础课 c++模板整理（附python语法基础题）
zombotany的博客
11-26 1319
第kkk个数 归并排序 逆序对数 数的范围 三次方根 高精加 高精减 高精乘 高精除 前缀和 矩阵前缀和 差分 差分矩阵 最长连续不重复子序列 数组元素的目标和 二进制中1的个数 区间和离散化 区间合并 数据结构 单调栈 给定一个长度为 NNN的整数数列，输出每个数左边第一个比它小的数，如果不存在则输出 −1。 滑动窗口 你的任务是确定滑动窗口位于每个位置时，窗口中的最大值和最小值。 KMP Trie 最大异或对 并查集 连通块中点的数量 堆排序 模拟堆 维护
Acwing基础算法模板
qq_2604939074的博客
01-16 1114
文章目录第一章 基础算法排序快速排序归并排序二分整数二分浮点数二分高精度高精度加法高精度减法前缀和差分双指针前缀和差分位运算离散化区间合并 第一章 基础算法 排序 快速排序 算法模板： void quick_sort(int q[], int l, int r) { if (l >= r) { return; } int i = l - 1, j = r + 1, x = q[(l + r) / 2]; while (i < j) { do { i++; } whi
acwing算法基础课文字版（看不懂你打我）——第三课基础算法之：区间和并
m0_48340706的博客
03-08 1870
写在前面：acwing是由北大学长创立的算法学习平台，在IT资源良莠不齐的当下异军突起。只需一顿火锅钱，就能跟着获得noi金牌的北大学长学习算法，是IT初学者进行深入研究的不二平台。本系列帖子将围绕AcWing平台的主打课程——算法基础课，并辅以本人自己的学习心得与广大算法爱好者分享知识。如果觉得本篇内容对你有帮助的话，希望不吝点赞。若有不同看法的话欢迎在评论区友善探讨。下面附上AcWing平台的地址，强烈推荐大家去学习视频课程哦！！！ 链接：https://www.acwing.com/activity/
acwing算法基础课文字版（看不懂你打我）——第一课基础算法之：快速排序
m0_48340706的博客
02-28 470
写在前面：acwing是由北大学长创立的算法学习平台，在IT资源良莠不齐的当下异军突起。只需一顿火锅钱，就能跟着获得noi金牌的北大学长学习算法，是IT初学者进行深入研究的不二平台。本系列帖子将围绕AcWing平台的主打课程——算法基础课，并辅以本人自己的学习心得与广大算法爱好者分享知识。如果觉得本篇内容对你有帮助的话，希望不吝点赞。若有不同看法的话欢迎在评论区友善探讨。下面附上AcWing平台的地址，强烈推荐大家去学习视频课程哦！！！ 链接：https://www.acwing.com/activity/
acwing算法基础课文字版（看不懂你打我）——第二课基础算法之：前缀和（一维/二维）
m0_48340706的博客
03-01 1180
写在前面：acwing是由北大学长创立的算法学习平台，在IT资源良莠不齐的当下异军突起。只需一顿火锅钱，就能跟着获得noi金牌的北大学长学习算法，是IT初学者进行深入研究的不二平台。本系列帖子将围绕AcWing平台的主打课程——算法基础课，并辅以本人自己的学习心得与广大算法爱好者分享知识。如果觉得本篇内容对你有帮助的话，希望不吝点赞。若有不同看法的话欢迎在评论区友善探讨。下面附上AcWing平台的地址，强烈推荐大家去学习视频课程哦！！！ 链接：https://www.acwing.com/activity/
acwing基础算法模板整理
02-27
算法整理，包括但不限于基础算法，数据结构，搜索图论以及数学知识
acwing算法基础 模板
weixin_47741017的博客
07-17 717
快排： 经典快排 #include<bits/stdc++.h> using namespace std; const int N=1e6+10; int q[N]={}; //核心 void quick_sort(int q[],int l,int r){ if(l>=r) return ; int x=q[(l+r)/2],i=l-1,j=r+1; while(i<j){ do i++;while(q[i]<x);
acwing算法基础课模版分析
m0_60565784的博客
10-03 3210
基础算法 快排模版 模版分析: 整数二分算法 模版分析:这个算法一般是用来求开方后的结果的!!用一个例题来理解! 给你一个数字x,请你求根号x的结果,保留六位小数! 模版分析:举个例子你就知道什么叫前缀和了,已知原数组是a(下标从1开始,0位置数值为0),前缀和数组是s,s[i]=a[0]+a[1]+…+a[i] ,这就是前缀和!!! 前缀和的好处是当你频繁计算区间和时,支持O(1)复杂度计算! 性质: 求[L,R]区间和=>s[R]-S[L-1]看图分析: 性质: 求以(x1, y1)为左上角，(x
算法与数据结构模版（AcWing算法基础课笔记，持续更新中）
emmmnmm的博客
04-06 2026
AcWing算法基础课笔记 第一章 基础算法 包括排序、二分、高精度、前缀和与差分、双指针算法、位运算、离散化、区间合并 1. 排序 快速排序： 思路：基于分治思想 确定分界点（取左边界，去中间点，随机取） 调整区间，分<x与>x两部分分别是[l, j]、[j+1, r] 递归左右 void quick_sort(vector<int>&q, int l, int r) { if (l >= r) return; //注意这里是>= int
acwing模板整理（第一讲）（基础算法）
foremost1的博客
08-19 2262
acwing算法基础班总结
[AcWing算法基础课] 一.基础算法
☆迷茫Dog的秘密基地☆
09-15 3789
Algorithms + Data Structures = Programs.——Niklaus Wirth 本章包括排序、二分、高精度、前缀和与差分、双指针算法、位运算、离散化、区间合并等内容 目录 一.排序 快速排序 归并排序 模板 二.二分 三.高精度 四.前缀和与差分 五.双指针算法 六.离散化 七.区间合并 一.排序 快速排序 AcWing 785. 快速排序 #include<iostream> using nam...
AcWing算法基础课
fujang的博客
07-10 2320
目录第一讲 基础算法快速排序AcWing 785. 快速排序AcWing 786. 第k个数归并排序AcWing 787. 归并排序AcWing 788. 逆序对的数量二分AcWing 789. 数的范围AcWing 790. 数的三次方根 第一讲 基础算法 快速排序 AcWing 785. 快速排序 AcWing 786. 第k个数 归并排序 AcWing 787. 归并排序 AcWing 788. 逆序对的数量 二分 AcWing 789. 数的范围 AcWing 790. 数的三次方根 ...
2021-05-12 acwing算法基础课 快速幂，扩展欧几里得，中国剩余定理，高斯消元
weixin_46064382的博客
06-01 211
AcWing 875. 快速幂 1.题意： 2.题解： 3.ac代码： #include<bits/stdc++.h> using namespace std; const int N=1e6+10; typedef long long ll; ll quick_pow(ll a,ll k,ll p){ ll res=1; while(k){ if(k&1) res=res*a%p; k>>=1; a=
Acwing 第一章模板及详解（基础算法）
weixin_64393298的博客
02-03 9691
一、排序 二、二分 三、高精度 四、前缀和与差分 五、双指针算法 六、位运算 七、离散化 八、区间合并 快速排序算法模板： 1.确定分界点 q[l] , q[(l+r)/2] , q[r]； //随机选取 2.调整区间，使小于等于x的在左边，大于等于x 的在右边； 3.递归处理x的左右段； void quick_sort(int q[], int l, int r) { if (l >= r) return; int i = l - 1, j = r +...
acwing算法基础课网盘
07-13
总之，acwing算法基础课网盘是一项非常便利和实用的服务，为学生们提供了更加全面和深入的学习资源，帮助他们更好地掌握和运用算法知识。 ### 回答2： acwing算法基础课是一门优质的算法学习资源，其中的课程内容...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值