Acwing基础算法1.1

已于 2023-08-19 10:55:08 修改
阅读量81 收藏
点赞数
分类专栏： 算法 文章标签： 算法 数据结构
于 2023-08-18 23:45:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2303_77480410/article/details/132277843
版权

目录

第一章

1.排序
快速: 任意一个分节点：左边数字都比它小，右边都比它大，递归处理
归并：类似于二叉树，先递归，分到最小，然后从最小开始，排序，归并，成为大数组
2.二分（整数，浮点）

排序

快速排序

边界问题：
取数：最左边 最后递归时候不能(l,i-1) (i,r)
右边 (l,j) (j+1,r)
特例：1 2
模板：
很好的推导
运用了递归，双指针，二分的思想
在这里插入图片描述

在这里插入图片描述

题目
在这里插入图片描述

适用例子：
2
1 2

#include <iostream>

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;//x = q[r]
	//最好x=q[l+r>>1
	while(i<j)//如果是i<=j,例子1 2陷入死循环
	{
		do i++; while(q[i] < x);
		do j--; while(q[j] > x);
		//while(q[i] < x) i++;
        //while(q[j] > x) j–;
		//当q[i]和q[j]都为 x 时, i 和 j 都不会更新,导致 while 陷入死循环
		if(i < j) swap(q[i],q[j]);
	}
	
	quick_sort(q,l,j);//q,l,i-1
	quick_sort(q,j+1,r);//q,i,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;	
}

自己写了一遍

#include <iostream>

using namespace std;

const int N = 100000;

int n;
int q[N];

void quick_sort(int q[],int l,int r)
{
    if(l>=r) return;
    int x=q[(l+r)>>1],i=l-1,j=r+1;//取中间节点作为分界点
    while(i<j)
    {
        do i++;while(q[i]<x);//找到大于x的数字，停止右移
        do j--;while(q[j]>x);//找到小于x的数字，停止左移
        if(i<j) swap(q[i],q[j]);//交换
    }
    quick_sort(q,l,j);//递归排序x左右侧的数字
    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;
}

错误代码错因解析：

void quick_sort(int l, int r){
    if(l >= r)  return;

    int mid = l + r >> 1;
    int i = l - 1, j = r + 1;
    while(i < j){
        do i++; while(a[i] < a[mid]);
        do j--; while(a[j] > a[mid]);
        if(i < j) swap(a[i], a[j]);
    }
    quick_sort(l, j), quick_sort(j + 1, r);
}

mid位置所在的值（比较参考值）会改变
在这里插入图片描述
在这里插入图片描述
题解1：排序+print

#include <iostream>
using namespace std;
const int N = 1e6+10;

int n,k;
int q[N];

void quick_sort(int l,int r)
{
    //特殊情况
    if(l>=r) return;
    //分出左右
    int x=q[l+r>>1],i=l-1,j=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(l,j);
    quick_sort(j+1,r);
}
int main()
{
    scanf("%d %d",&n,&k);
    for(int i=0;i<n;i++) scanf("%d",&q[i]);
    
    quick_sort(0,n-1);
    
    printf("%d",q[k-1]);
    return 0;
}

题解2:快排+二分

#include <iostream>
using namespace std;
const int N = 1e6+10;

int n,k;
int q[N];

void quick_sort(int l,int r)
{
    //特殊情况
    if(l>=r) return;
    //分出左右
    int x=q[l+r>>1],i=l-1,j=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]);
    }
    //递归处理左右
    if(k<=j) quick_sort(l,j);//if判断
    else quick_sort(j+1,r);
}
int main()
{
    scanf("%d %d",&n,&k);
    k--;//位置减去
    for(int i=0;i<n;i++) scanf("%d",&q[i]);
    
    quick_sort(0,n-1);
    
    printf("%d",q[k]);
    return 0;
}

void swap(int *a,int i,int j)
{
	int t = a[i];
	a[i] = a[j];
	a[j] = t;
}
void quicksort(int *a,int begin,int end)
{
    if(begin >= end)
	return ;
	int flag = begin;//注意：flag在左边，则从右边开始，反之亦然
	int l = begin + 1;
	int r = end;
	while(l < r)
	{
		while(l<r&&a[r]>a[flag])//找到比flag小的数，然后停下来
		r--;
		while(l<r&&a[l]<a[flag])//找到比flag大的数，然后停下来
		l++;
		if(l<r)//交换两个位置上的数
		swap(a,l,r);
	}
	swap(a,flag,r);//l = r,(注意的原因),此时此位置上的数字一定小于flag,
	//因为是从右边开始先走的
	quicksort(a,begin,r-1);
	quicksort(a,r+1,end);	//递归
}

快速排序题目

在著名的快速排序中，有一个经典的过程叫做划分。
在此过程中，我们通常选取其中一个元素作为分界值。
将小于分界值的元素移到其左侧，将大于分界值的元素移到其右侧。

给定 N个不同的正整数进行过一次划分后的排列情况。

请你判断，共有多少元素可能是此次划分的分界值。

例如，N=5
，各元素排列为 1,3,2,4,5
，则：
1 可能是分界值，因为它的左侧没有元素，而右侧的元素都比它大。
3一定不是分界值，因为尽管它的左侧的元素都比它小，但是它右侧的 2
也小于它。
2一定不是分界值，因为尽管它的右侧的元素都比它大，但是它左侧的 3
也大于它。
出于类似判断可知 4,5也可能是分界值。
因此，在此样例中，共有 3 个可能的分界值。

输入格式

第一行包含整数 N
第二行包含 N 个不同的正整数。

输出格式

第一行输出可能的分界值数量。

第二行按升序顺序输出所有可能的分界值。

如果分界值数量为 0
，则在输出分界值数量后，输出一个空行即可。

输入样例：

5
1 3 2 4 5

输出样例：

3
1 4 5

最开始的做法：

int sort(int *a,int *b,int n)
{
	int i,l,r,k = 0,p = 0;
	for(i = 0;i < n;i++)
    {
    	k = 0;
    	for(l = i - 1;k == 0&&l >= 0 && l < i;l++)
    	{
    		if(a[l] > a[i])
    		{
    			k = 1;
			}
		}
		for(r = i + 1;k == 0&& r < n;r ++)
		{
			if(a[r] < a[i])
    		{
    			k = 1;
			}
		}
		if(k == 0)
		b[p ++] = a[i];
	}
	return p;
}

超时了，然后

void sort(int *a,int n)
{
    int i;
	int LeftMax[n],RightMin[n];
	LeftMax[0] = 0;
	RightMin[n-1] = 1000000;
	for(i = 1;i < n;i++)	
	    LeftMax[i] = LeftMax[i - 1] > a[i - 1]?LeftMax[i - 1]:a[i - 1];
	for(i = n - 2;i >= 0;i --)
	    RightMin[i] = RightMin[i + 1] < a[i + 1]?RightMin[i + 1]:a[i + 1];
	vector<int> b;
	for(i = 0;i < n;i ++)
	{
		if(a[i] > LeftMax[i]&&a[i] < RightMin[i])
		b.push_back(a[i]);
	}
	int n1 = b.size();
	cout << n1 << endl;
	if(n1 == 0)
	puts(" ");
	else
	{
	  	for(i = 0;i < n1;i ++)
        	cout << b[i] << " ";	
	}
}

这个题解有点懵：

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
const int N=100010;
int a[N],b[N];
int n;
int main()
{
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
        b[i]=a[i];
    }
    sort(a,a+n);
    int lmax=0;
    vector<int> res;
    for(int i=0;i<n;i++)
    {
        if(a[i]==b[i]&&a[i]>lmax) res.push_back(a[i]);
        if(b[i]>lmax) lmax=b[i];
    }

    cout<<res.size()<<endl;
    if(res.size()==0) puts("");
    else
    {
        for(int i=0;i<res.size();i++) cout<<res[i]<<" ";
    }
    return 0;
}

//作者：陌若安生
//链接：https://www.acwing.com/solution/content/15523/
//来源：AcWing
//著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

归并排序

相关推导
类似于二叉树
1.递归拆分
2.双指针排序回到原来
运用了递归，双指针，二分的思想
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

#include <iostream>
using namespace std;
const int N=1e6+10;

int n;
int q[N],res[N];

void merge_sort(int l,int r)
{
    if(l>=r) return;
    int mid = l+r >> 1;
    //递归拆分
    merge_sort(l,mid);
    merge_sort(mid+1,r);
    //双指针排序
    //（1）双指针走
    int i=l,j=mid+1,k=0;
    while(i<=mid&&j<=r)
    {
        if(q[i]<q[j]) res[k++]=q[i++];
        else res[k++] = q[j++];
    }
    //（2）剩余部分不上
    while(i<=mid) res[k++] = q[i++];
    while(j<=r) res[k++] = q[j++];
    //（3）复制到原数组
    for(i=l,j=0;i<=r;i++,j++) q[i] = res[j];
}
int main()
{
    scanf("%d",&n);
    for(int i=0;i<n;i++) scanf("%d",&q[i]);
    
    merge_sort(0,n-1);
    
    for(int i=0;i<n;i++) printf("%d ",q[i]);
    return 0;
}

在这里插入图片描述

#include <iostream>
using namespace std;
const int N=1e5+10;

int n;
long long cnt=0;
int q[N];

void merge_sort(int l,int r)
{
    //边界条件
    if(l>=r) return ;
    int mid = l+r >> 1;
    //递归分开
    //wrong(1)忘记写递归
    merge_sort(l,mid);
    merge_sort(mid+1,r);
    int i=l,j=mid+1,k=0,res[r-l+1],h;//wrong(2):l-r+1
    //双指针对比
    while(i<=mid&&j<=r)
    {
        if(q[i]<=q[j]) {res[k++] = q[i++];}
        else {res[k++] = q[j++]; cnt+=mid-i+1;}
    }
    //0-mid还剩下没有复制完
    while(i<=mid)
    {
        res[k++] = q[i++];
    }
    //mid+1~r还剩下
    //错误（3）:改变了i,j
    while(j<=r)
    {
        res[k++] = q[j++];
    }
    for(i=l,j=0;i<=r;i++,j++) q[i]=res[j];
}
int main()
{
    scanf("%d",&n);
    for(int i=0;i<n;i++) scanf("%d",&q[i]);
    
    merge_sort(0,n-1);
    
    printf("%lld",cnt);
    return 0;
}

二分

写的特别好的优质文章

整数二分

前提：单调
（1）防止溢出：
int mid = l + ((r - l) / 2);
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
题目：
在这里插入图片描述
模板：

#include <iostream>
using namespace std;
const int N=1e6+10;
int n;
int q[N];

void binary_sort(int x)
{
    //找到左边界
    int mid,l=0,r=n-1;
    while(l<r)
    {
        mid = l+r >>1;
        // if(q[mid]<x) l=mid+1;
        // else r=mid;
        if(q[mid]>=x) r=mid;
        else l=mid+1;
    }
    
    if(q[r] != x ) 
    {
        cout<<"-1 -1"<<endl;
        return ;
    }
    cout<<r<<" ";
    
    //找到右边界
    l=0,r=n-1;
    while(l<r)
    {
        mid = l+r+1 >>1;
        if(q[mid]<=x) l=mid;
        else r=mid-1;
    }
    cout<<r<<endl;
}
int main()
{
    int m,x;
    scanf("%d %d",&n,&m);
    for(int i=0;i<n;i++) scanf("%d",&q[i]);
    while(m--)
    {
        scanf("%d",&x);
        binary_sort(x);
    }
    return 0;
}

解析：
二分：

（1） while(l<r)？还是while(l<=r)?
（2）mid = l+r >>1还是mid = l+r+1 >>1？
（3）q[mid] <x 还是q[mid<=x]？
模板中：2.1配3.1 2.2配3.2
（4）谁是左边界谁是右边界？

找到左边界 :
例如找数列1 2 2 3 3 4中左边的2

while(l<r)
    {
        mid = l+r>>1;
        //错误情况1:
        //改成l+r+1:超时无限循环 例如 1 2 2 3 3 4
        //例如：当mid =l+r+1，l=r-1
        //mid=r
        //若满足q[mid]>=x -> r=mid =r
        //r 保持不变，l也是，无限循环
        
        if(q[mid]<x) l=mid+1;
         else r=mid;
         //if-else 内容可以根据判断条件推导
         //因为if语句的条件可以推导出后面的语句
         //然而后面的语句，在l+r+1的时候超时
         //所以L+r+1不能和q[mid]<x匹配
         //l+r 可以，下面的模板同理
         
         // 上面两句等价于
        //if(q[mid]>=x) r=mid;
        //else l=mid+1;
        
        //讨论第二个：q[mid]<x or q[mid]<=x ?
        //q[mid]<=x 时，成立：l=mid 否则：r=mid-1
        //q[mid]<=x时此时情况就成为了错误情况2(解释看下面)
    }

找到右边界 :
例如找数列1 2 2 3 3 4中右边的2

l=0,r=n-1;
    while(l<r)
    {
        mid = l+r+1 >>1;
        //错误情况2
        //改成l+r超时无限循环
        //例如：当mid =l+r，l=r-1
        //mid=l(向下取整)
        //若满足q[mid]<=x -> l=mid =l
        //l 保持不变，r也是，无限循环
        if(q[mid]<=x) l=mid;
        else r=mid-1;
    }

浮点数二分

在这里插入图片描述
在这里插入图片描述

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

int main()
{
    double n;
    scanf("%lf",&n);
    double ans=1e-9,mid=0,flag=1;
    //负数
    if(n<0)
    {
        n=fabs(n);
        flag=0;
    }
    double l=0,r;
    //小于1的数字
    n>1.0?r=n:r=1;
    
    //while(fabs(ans-n)>1e-6)
    for(int i=0;i<1000;i++)//改进：while(r-l>1e-6) r=-22 l=22(解决了负数和小数的问题)
    {
        mid = (l+r)/2;
        ans = mid*mid*mid;
        if(ans<n) l=mid;
        else r=mid;
    }
    if(flag==1)
    {
        printf("%.6lf",l);
    }
    else
    {
        printf("-%.6lf",l);
    }
    return 0;
}
Osatnb.c
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
AcWing算法基础课（一）基础算法
TiercelChow’s Blog
10-30 7025
1.1 排序 快速排序 归并排序 快速排序（不稳定的排序） 分治思想 步骤（对左边界为l，右边界为r的一段数进行排序）： 确定分界点：q[l], q[(l + r) / 2], q[r], 随机值 调整区间（重点）：通过x对区间进行划分，使得左边区间都≤x，右边区间都≥x（左右区间不一定相等） 递归处理左右两个区间 调整区间的方式： 设置两个指针i，j分别指向区间的左右两个元素 i指针向右移动，直至其指向的元素≥x，停下 j指针向左移动，直至其指向的元素≤x，停下 交换i，j所指向的元素（两个
Acwing 基础算法 1.1 快速排序、归并排序
m0_71558827的博客
01-09 160
Acwing 基础算法 1.1 快速排序、归并排序
AcWing算法基础1.1
weixin_30507269的博客
05-26 2742
排序 快速排序(快排) 写题的时候用的不多基本都是直接sort ( )，面试可能要手撸快排，上模板 1 void quick_sort(int q[], int l, int r) 2 { 3 if(l >= r) return; 4 int i = l - 1, j = r + 1, x = q[l]; 5 while(i < j...
AcWing算法基础（1.1基础算法——快速排序）
2301_76495560的博客
08-05 65
快速排序的重点代码详解，例题展示
Acwing基础算法
qq_43157097的博客
03-24 1137
acwing算法基础课学习
Acwing基础算法学习
晓的博客
07-21 984
首先，什么是KMP算法。这是一个字符串匹配算法，对暴力的那种一一比对的方法进行了优化，使时间复杂度大大降低（我不会算时间复杂度。。。，目前也只能这么理解，还有KMP是取的三个发明人的名字首字母组成的名字）。然后是一些基本概念：1、s[ ]是模式串，即比较长的字符串。2、p[ ]是模板串，即比较短的字符串。（这样可能不严谨。。。）3、“非平凡前缀”：指除了最后一个字符以外，一个字符串的全部头部组合。4、“非平凡后缀”：指除了第一个字符以外，一个字符串的全部尾部组合。
【无标题】AcWing算法基础课——基础算法
hdheid的博客
04-19 4615
AcWing算法基础课 1.1 快速排序 快速排序属于分治算法，快速排序的算法步骤，用分治的思想 确定分界点，数组内任意一个值（这里建议取中点，即(l+r)/2）； 调整区间，让x左边的数都小于x，右边的数都大于x； 递归处理左右两个区间，直到细分到不能细分 对于第二步的调整区间，具体就是弄两个指针，分别指向数组的左右边界；不断的向中间遍历，将遍历过程中左边比x大的数和右边比x小的数交换；直到i，j相遇。 快排模版 void quick_sort(int q[],int l,int r)
[AcWing] 算法基础课（一）学算法强推哦
m0_47437411的博客
02-15 2539
第一讲 基础算法 包括排序、二分、高精度、前缀和与差分、双指针算法、位运算、离散化、区间合并等内容。
acwing(一)—基础算法总结
weixin_41399650的博客
08-23 2033
记录acwing算法基础课第一章基础算法和其模板的相关内容，记录下来供以后复习。
【AcWing算法基础】第一讲 基础算法
flowral的博客
10-15 199
虽然说有常用的模板，但是更习惯自己写的。 4、高精度 4.1 高精度加法 #include<iostream> #include<vector> #include<string> using namespace std; int main() { string A,B; cin>>A>>B; vector<int> a,b,c; for(int i=A.size()-1;i>=0;i--) a.
【AcWing算法基础】第三讲 搜索与图论
flowral的博客
11-06 224
一、DFS 1.1 排列数字 是全排列的问题，很经典的dfs题，没什么难度，硬敲就行 #include<iostream> using namespace std; const int N = 10; int n; int path[N]; bool st[N]; void dfs(int cnt){ if(cnt==n){ for(int i=0;i<n;i++){ cout<<path[i]<<" ";
Acwing算法—动态规划
HENRYyangtuo的博客
06-12 5215
目录 数字三角形模型AcWing 898. 数字三角形AcWing 1015. 摘花生AcWing 1018. 最低通行费AcWing 1027. 方格取数AcWing 275. 传纸条最长上升子序列模型AcWing 895. 最长上升子序列AcWing 896. 最长上升子序列 IIAcWing 1017. 怪盗基德的滑翔翼AcWing 1014. 登山AcWing 482. 合唱队形AcWing 1012. 友好城市AcWing 1016. 最大上升子序列和AcWing 1010. 拦截导弹AcWing
基础算法 --- 线性DP
Reserve_Scale的博客
05-13 378
线性DP同样作为DP领域中非常重要的一部分，其指的是状态之间含有某种线性关系，大多求最大/最小值。最典型的题目为子序列，编辑距离，股票问题。
趣味算法------试用 6 和 9 组成的最大数字
最新发布
markingyi的博客
08-26 253
给出一个数字，反转其中一位使数字最大化，递归求解。
代码随想录算法训练营19-回溯1
weixin_53416771的博客
08-22 372
画出来的树是这样记录所有组合，一个变量current装当前的处理结果，一个res装所有的处理的结果下面的代码还可以剪枝优化。
算法日记day 45（单调栈之每日温度|接雨水）
m0_74980681的博客
08-22 893
如果大于，则取栈顶元素为中间值并弹出栈顶元素，将遍历的元素与新的栈顶元素值比较取较小者，减去中间值得到高度h，然后栈顶元素下标值减去当前遍历的元素下标值再减一得到宽度w，最后高×宽得到面积，并记录，重复上述操作，直到遍历结束。第三种，如果遍历的元素值大于栈顶元素，用该下标减去栈顶元素下标，并将栈顶元素弹出，继续用该元素与新的栈顶元素比较，如果小于等于，则压入栈，如果大于，重复第三步操作。第一种，如果之后遍历的元素值小于栈顶压入的元素，将该元素的下标压入栈中。如果小于栈顶元素值，则压入栈内。
7-7 数组中能被5整除的数的和
Virgo_616的博客
08-26 132
在一维数组中有10个整数，求出其中能被5整除的所有数的和。
算法025：前缀和
m0_62319039的博客
08-22 231
算法025：前缀和
ACWing基础算法入门：前缀和与二维差分矩阵讲解
本资源是一份关于ACWing基础算法课程的详细笔记，针对第一章的内容进行了整理。章节重点介绍了二维前缀和的概念，包括其在数据结构中的理解和记忆方法。二维前缀和用于高效计算从左上角到某一点的所有元素之和，通过...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值