AcWing 第一讲 基础算法

最新推荐文章于 2024-08-14 11:22:43 发布
最新推荐文章于 2024-08-14 11:22:43 发布
阅读量181 收藏 1
点赞数
分类专栏： # AcWing 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37642480/article/details/118661785
版权

文章目录

1.快速排序

AcWing 785. 快速排序

#include <iostream>
using namespace std;

const int N = 1e5 + 1;
int cnt[N];

// 有等号 + 无等号 + 有等号 是最好的选择  101
void quick_sort(int l,int r){
    if(l >= r) return; //可以无视等号
    int pivot = cnt[l],i = l,j = r;
    while(i < j){
        while(cnt[j] >= pivot && i < j) j--; //可以无视 >=
        cnt[i] = cnt[j];
        while(cnt[i] <= pivot && i < j) i++;
        cnt[j] = cnt[i];
    }
    cnt[i] = pivot;
    quick_sort(l,i-1);
    quick_sort(i+1,r);
}

int main(){
    int n; cin >> n;
    for(int i = 1; i <= n; i++) cin >> cnt[i];
    quick_sort(1,n);
    for(int i = 1; i <= n; i++) cout << cnt[i] << " ";
    cout << endl;
    return 0;
}

AcWing 786. 第k个数

#include <iostream>
using namespace std;

const int N = 1e5 + 1;
int cnt[N];

int quick_sort(int l,int r,int k){
    int pivot = cnt[l],i = l,j  = r;
    while(i < j){
        while(cnt[j] >= pivot && i < j) j--;
        cnt[i] = cnt[j];
        while(cnt[i] <= pivot && i < j) i++;
        cnt[j] = cnt[i];
    }
    cnt[i] = pivot;
    if(i == k) return pivot;
    if(i < k) return quick_sort(i+1,r,k);
    else return quick_sort(l,i-1,k);
}


int main(){
    int n,k; cin >> n >> k;
    for(int i = 1; i <= n;  i++) cin >> cnt[i];
    cout << quick_sort(1,n,k) << endl;
    return 0;
}

2.归并排序

AcWing 787. 归并排序

#include <iostream>
using namespace std;

const int N = 1e5 + 11;
int cnt[N],tmp[N];

void merge_sort(int l,int r){
    if(l >= r) return;
    int mid = (l+r)/2;
    merge_sort(l,mid);
    merge_sort(mid+1,r);
    
    int k = 0,i = l,j = mid+1;
    while(i <= mid && j <= r){
        if(cnt[i] <= cnt[j]) tmp[k++] = cnt[i++];
        else tmp[k++] = cnt[j++];
    }
    while(i <= mid) tmp[k++] = cnt[i++];
    while(j <= r) tmp[k++] = cnt[j++];
    
    k = 0;
    for(int q = l; q <= r; q++,k++){
        cnt[q] = tmp[k];
    }
}

int main(){
    int n; cin >> n;
    for(int i = 1; i <= n; i++) cin >> cnt[i];
    merge_sort(1,n);
    for(int i = 1; i <= n; i++) cout << cnt[i] << " ";
    cout << endl;
    
    return 0;
}

AcWing 788. 逆序对的数量

#include <iostream>
using namespace std;

const int N = 1e5 + 1;
int cnt[N],tmp[N];
long long res = 0;

void merge_sort(int l,int r){
    if(l >= r) return;
    int mid = l + (r-l)/2;
    merge_sort(l,mid);
    merge_sort(mid+1,r);
    
    int k = 0,i = l,j = mid+1;
    while(i <= mid && j <= r){
        if(cnt[i] <= cnt[j]){
            tmp[k++] = cnt[i++];
        }else{
            res += mid-i+1; //有待深究，宏观来看 --> 美
            tmp[k++] = cnt[j++];
            
        } 
    }
    while(i <= mid) tmp[k++] = cnt[i++];
    while(j <= r) tmp[k++] = cnt[j++];
    
    for(int q = l,k = 0; q <= r;q++,k++){
        cnt[q] = tmp[k];
    }
}

int main(){
    res = 0;
    int n; cin >> n;
    for(int i = 1; i <= n; i++) cin >> cnt[i];
    merge_sort(1,n);
    cout << res << endl;
    
    
    return 0;
}

3.二分

我的想法

// 如果想要最左边的一个2,那么就先砍掉比2小的数，l = mid+1;
// 然后 if(cnt[mid] >= 2) r = mid; 那么可以让右边缩小，保留最左边的
void solve1(){
    int cnt[] = {1,2,2,3,3,4};
    int l = 0,r = 5;
    while(l < r){
        int mid = l + (r-l)/2;
        if(cnt[mid] < 2) l = mid+1; 
        else r = mid;
    }
    cout << l << endl;
}

//最右边的一个2
void solve2(){
    int cnt[] = {1,2,2,3,3,4};
    int l = 0,r = 5;
    while(l < r){
        int mid = (l+r+1)/2; // 当l+1=r 防止死循环
        if(cnt[mid] > 2) r = mid-1;
        else l = mid;
    }
    cout << l << endl;
}

AcWing 789. 数的范围

lower_bound()
upper_bound()

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

// 1 2 2 3 3 4
int main(){
    int n,q;  cin >> n >> q;
    for(int i = 0; i < n; i++) cin >> cnt[i];
    while(q--){
        int k; cin >> k;
        int l = 0,r = n-1;
        while(l < r){
            int mid = l + (r-l)/2;
            if(cnt[mid] < k) l = mid+1;
            else r = mid;
        }
        if(cnt[l] != k) cout << "-1 -1" << endl;
        else {
            cout << l << " ";
            l = 0, r = n-1;
            while(l < r){
                int mid = (l+r+1) >> 1;
                if(cnt[mid] > k) r = mid-1;
                else l = mid;
            }
            cout << l << endl;
        }
    }
    return 0;
}

AcWing 790. 数的三次方根

#include <iostream>
using namespace std;

int main(){
    double a; cin >> a;
    double l = -100,r = 100;
    while(r-l > 0.0000001){
        double mid = (l+r)/2; //一定要用double
        if(mid*mid*mid > a) r = mid;
        else l = mid;
    }
    printf("%6lf\n",l);
    
    return 0;
}

4.高精度

AcWing 791. 高精度加法

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

int main(){
    string a,b; cin >> a >> b;
    vector<int> v1,v2,v3;
    for(int i = a.length()-1; i >= 0; i--) v1.push_back(a[i]-'0');
    for(int i = b.length()-1; i >= 0; i--) v2.push_back(b[i]-'0');
    int t = 0,i = 0,j = 0;
    while(i <= v1.size()-1 || j <= v2.size()-1){
        if(i <= v1.size()-1) t += v1[i++];
        if(j <= v2.size()-1) t += v2[j++];
        v3.push_back(t%10);
        t/=10;
    }
    if(t != 0) v3.push_back(t);
    for(int i = v3.size()-1; i >= 0; i--) cout << v3[i];
    return 0;
}

AcWing 792. 高精度减法

注意两数相同的时候，输出-0

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

bool cmp(vector<int>& v1,vector<int>& v2){
   if(v1.size() == v2.size()){
       for(int i = v1.size()-1; i >= 0; i--){
           if(v1[i] == v2[i]) continue;
           return v1[i] > v2[i];
       }
   }else{
        return v1.size() > v2.size();
   }
   
}

vector<int> sub(vector<int>& v1,vector<int>& v2){
    vector<int> res;
    int t = 0;
    for(int i = 0; i < v1.size(); i++){
        v1[i] -= t;
        if(i < v2.size()) v1[i] -= v2[i];
        res.push_back((v1[i]+10)%10);
        if(v1[i] < 0) t = 1;
        else t = 0;
    }
    while(res.size() > 1 && res.back() == 0) res.pop_back();
    return res;
}

int main(){
    
    string s1,s2; cin >> s1 >> s2;
    vector<int> v1,v2,v3;
    for(int i = s1.length()-1; i >= 0; i--) v1.push_back(s1[i]-'0'); //个位排在前面
    for(int i = s2.length()-1; i >= 0; i--) v2.push_back(s2[i]-'0');
    if(cmp(v1,v2)){
        v3 = sub(v1,v2);
    }else{
         cout << "-";
        v3 = sub(v2,v1);
    }
    for(int i = v3.size()-1; i >= 0; i--) cout << v3[i];
    
    
    return 0;
}

AcWing 793. 高精度乘法

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

const int N = 1e5 + 1;

vector<int> v1,v2;
int c[N];
vector<int> mul(){
    vector<int> c(v1.size()+v2.size()+11,0);
    for(int i = 0; i < v1.size(); i++){
        for(int j = 0; j < v2.size(); j++){
            c[i+j] += v1[i]*v2[j];  //注意这里 += 
            if(c[i+j] > 9) c[i+j+1] += c[i+j]/10;
            c[i+j] %= 10;
        }
    }
    //去掉后置0
    while(c.size() > 1 && c.back() == 0) c.pop_back();
    return c;
}

int main(){
    string a,b; cin >> a >> b;
    for(int i = a.length()-1; i >= 0; i--) v1.push_back(a[i]-'0');
    for(int i = b.length()-1; i >= 0; i--) v2.push_back(b[i]-'0');
    vector<int> v3 = mul();
    for(int i = v3.size()-1; i >= 0; i--)   cout << v3[i];
    return 0;
}

AcWing 794. 高精度除法

AcWing 794. 高精度除法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lugPHNDV-1626774629438)(https://csdn-img-blog.oss-cn-beijing.aliyuncs.com/cb0afaf813bc4c2e8ea23a837f14248b.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjQyNDgw,size_16,color_FFFFFF,t_70)]

#include <iostream>
#include <vector>
#include <deque>
using namespace std;
deque<int> res;


int main(){
    string a; int b; cin >> a >> b;
    vector<int> v1;
    for(int i = 0; i < a.length(); i++) v1.push_back(a[i] - '0');
    
    int t = 0;
    for(int i = 0; i < v1.size(); i++){
        t = t*10 + v1[i];
        if(t < b){
            res.push_back(0);
        }else{
            res.push_back(t/b);
            t = t%b;
        }
    }
    while(res.size() > 1 && res.front() == 0) res.pop_front();
    for(int i = 0; i < res.size(); i++) cout << res[i];
    cout << endl;
    cout << t << endl;
    
    return 0;
}

5. 前缀和与差分

AcWing 795. 前缀和

AcWing 795. 前缀和

#include <iostream>
using namespace std;

const int N = 1e5 + 11;
int a[N];

int main(){
    int n,m; cin >> n >> m;
    a[0] = 0;
    for(int i = 1; i <= n; i++){
        cin >> a[i];
        a[i] += a[i-1];
    }
    while(m--){
        int l,r; cin >> l >> r;
        cout << a[r]-a[l-1] << endl;
    }
    return 0;
}

AcWing 796. 子矩阵的和(二维前缀和)

AcWing 796. 子矩阵的和
题解
在这里插入图片描述

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

const int N = 1e3 + 11;
int cnt[N][N];
int qzh[N][N];

int main(){
    int n,m,q; cin >> n >> m >> q;
    memset(qzh,0,sizeof(qzh));
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j++){
            cin >> cnt[i][j];
            qzh[i][j] = cnt[i][j] + qzh[i][j-1] + qzh[i-1][j] - qzh[i-1][j-1];
        }
    }
    while(q--){
        int x1,y1,x2,y2; cin >> x1 >> y1 >> x2 >> y2;
        int res = qzh[x2][y2] - qzh[x2][y1-1] - qzh[x1-1][y2] + qzh[x1-1][y1-1];
        cout << res << endl;
    }
    return 0;
}

AcWing 797. 差分

AcWing 797. 差分
题解
题解 insert()
在这里插入图片描述

#include <iostream>
using namespace std;
const int N = 1e5 + 11;
int a[N];
int b[N]; //差分数组

int main(){
    int n,m; cin >> n >> m;
    a[0] = 0;
    b[0] = 0;
    for(int i = 1; i <= n; i++){
        cin >> a[i];
        b[i] = a[i] - a[i-1];
    } 
    while(m--){
        int l,r,c; cin >> l >> r >> c;
        b[l] += c;
        b[r+1] -= c;
    }
    for(int i = 1; i <= n; i++){
        b[i] += b[i-1];
        cout << b[i] << " ";
    }
    
    return 0;
}

另外一种写法

#include <iostream>
#include <cstring>
using namespace std;
const int N = 1e5 + 11;
int a[N],b[N];
void insert(int l,int r,int c){
    b[l] += c;
    b[r+1] -= c;
}

int main(){
    int n,m; cin >> n >> m;
    memset(a,0,sizeof(a)); memset(b,0,sizeof(b));
    for(int i = 1; i <= n; i++){
        cin >> a[i];
        insert(i,i,a[i]); //构造差分数组
    } 
    while(m--){
        int l,r,c; cin >> l >> r >> c;
        insert(l,r,c);
    }
    for(int i = 2; i <= n; i++) b[i] += b[i-1]; //一系列操作之后的a数组
    for(int i = 1; i <= n; i++) cout << b[i] << " ";

    return 0;
}

AcWing 798. 差分矩阵

AcWing 798. 差分矩阵
在这里插入图片描述在这里插入图片描述

#include <iostream>
#include <cstring>
using namespace std;
const int N = 1010;
int a[N][N],b[N][N];

void insert(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(){
    //memset(a,0,sizeof(a)); memset(b,0,sizeof(b));
    int m,n,q;
    cin >> m >> n >> q;
    for(int i = 1; i <= m; i++)
        for(int j = 1; j <= n; j++) cin >> a[i][j];
    //构造差分矩阵
    for(int i = 1; i <= m; i++)
        for(int j = 1; j <= n; j++)
            insert(i,j,i,j,a[i][j]);
        
    //操作
    while(q--){
        int x1,y1,x2,y2,c; cin >> x1 >> y1 >> x2 >> y2 >> c;
        insert(x1,y1,x2,y2,c);
    }
    // b数组求前缀和就是 一系列操作之后的 a数组
    for(int i = 1; i <= m; i++)
        for(int j = 1; j <= n; j++)
            b[i][j] = b[i][j] + b[i-1][j] + b[i][j-1] - b[i-1][j-1];
        
    // 输出b数组
    for(int i = 1; i <= m; i++){
        for(int j = 1; j <= n; j++) cout << b[i][j] << " ";
        cout  << endl;
    }

    
    return 0;
}

6. 双指针算法

AcWing 799. 最长连续不重复子序列

AcWing 799. 最长连续不重复子序列
在这里插入图片描述
在这里插入图片描述

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

int a[N];
unordered_map<int,int> mp;

int main(){
    int n; cin >> n;
    for(int i = 1; i <= n; i++) cin >> a[i];
    int j = 1,res = 0;
    for(int i = 1; i <= n; i++){
        mp[a[i]]++;
        if(mp[a[i]] > 1){
            while(mp[a[j]] == 1){
                mp[a[j]]--; //一定要清除j之前 map中的数据,后面的数据会累加
                j++;
            }
            mp[a[j]]--;
            j++;
        }
        res = max(res,i-j+1);
    }
    cout << res << endl;;
    
    
    return 0;
}

#include <iostream>
using namespace std;

const int N = 1e5 + 11;
int a[N];

int main(){
    int n; cin >> n;
    for(int i = 1; i <= n; i++) cin >> a[i];
    int start = 1;
    int ans = 0;
    for(int i = 1; i <= n; i++){
        for(int j = start; j < i; j++){
            if(a[i] == a[j]){
                ans = max(ans,i-j+1);
                start = j+1;
                break;
            }
        }
    }
    cout << ans << endl;
    return 0;
}

AcWing 3624. 三值字符串

AcWing 3624. 三值字符串
在这里插入图片描述
在这里插入图片描述


#include <string.h>
#include <stdio.h>
//#include <iostream>
using namespace std;
int min(int a,int b){
    if(a >= b) return b;
    return a;
}

const int N = 2e5 + 11;
char s[N];

int main(){
    //std::ios::sync_with_stdio(false);  cin.tie(0);
    int T; scanf("%d",&T);
    while(T--){
        scanf("%s",s);
        int n = strlen(s);
        int cnt[4] = {0};
        int j = 0, res = n+1;
        for(int i = 0; i < n; i++){
            cnt[s[i]-'0']++;
            if(cnt[s[i]-'0'] > 1){
                while(cnt[s[j]-'0'] > 1 && j < i)  cnt[s[j++]-'0']--;
                
            }
            if(cnt[1] && cnt[2] && cnt[3]) res = min(res,i-j+1);
        }
        if(res == n+1) res = 0;
        printf("%d\n",res);
    }
    return 0;
}

求子段和小于等于𝑠的最长子段

在这里插入图片描述
注意 LL sum

#include <iostream>
using namespace std;
const int N = 3e5 + 11;
 
int a[N];
typedef long long LL;
 
int main(){
    int n; LL s; 
    bool has_ans = false;
    scanf("%d%lld",&n,&s);
    for(int i = 1; i <= n; i++){
        scanf("%d",&a[i]);
        if(s >= a[i]) has_ans = true;
    } 
    if(has_ans == false){
        printf("0\n");
        return 0;
    }
    int l = 1, res = 0;
    LL sum = 0;
    for(int i = 1; i <= n; i++){
        sum += a[i];
        while(sum > s){
            sum -= a[l];
            l++;
        }
        res = max(res,i-l+1);
        // cout << "i == " << i << " j == " << j << endl;
        // cout << "w == " << w << endl;
        // cout << "res == " << res << endl;
        // cout << "-----" << endl;
    }
    printf("%d\n",res);
 
    return 0;
}

求子段和大于等于𝑠的最短子段

在这里插入图片描述

#include <iostream>
using namespace std;

const int N = 3e5 + 11;
int a[N];
typedef long long LL;
int main(){
    int n; LL s; 
    bool has_ans = false;
    scanf("%d%lld",&n,&s);
    LL t_sum = 0;
    for(int i = 1; i <= n; i++){
        scanf("%d",&a[i]);
        t_sum += a[i];
    }
    if(t_sum < s){
        printf("-1\n");
        return 0;
    }
    int l = 1,res = n + 1;
    LL sum = 0;
    for(int i = 1; i <= n; i++){
        sum += a[i];
        while(sum - a[l] > s && l < i){
            sum -= a[l];
            l++;
        }
        if(sum >= s) res = min(res,i-l+1);
    }
    printf("%d\n",res);


    return 0;
}

AcWing 800. 数组元素的目标和

AcWing 800. 数组元素的目标和
在这里插入图片描述

使用unordered_map

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

const int N = 100010;

int a[N];
unordered_map<int,int> mp;


int main(){
    int n,m,x; scanf("%d%d%d",&n,&m,&x);
    for(int i = 1; i <= n; i++) scanf("%d",&a[i]);
    for(int i = 1; i <= m; i++){
        int t; scanf("%d",&t);
        mp[t] = i;
    }
    for(int i = 1; i <= n; i++){
        if(mp.count(x-a[i])){
            printf("%d %d\n",i-1,mp[x-a[i]]-1);
            break;
        }
    }
    return 0;
}

双指针
在这里插入图片描述

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

const int N = 100010;

int a[N],b[N];



int main(){
    int n,m,x; scanf("%d%d%d",&n,&m,&x);
    for(int i = 1; i <= n; i++) scanf("%d",&a[i]);
    for(int i = 1; i <= m; i++) scanf("%d",&b[i]);
    int j = m;
    for(int i = 1; i <= n; i++){
        while(j > 0 && a[i] + b[j] > x) j--;
        if(a[i] + b[j] == x){
            printf("%d %d\n",i-1,j-1);
            return 0;
        }
    }
    return 0;
}

AcWing 2816. 判断子序列

AcWing 2816. 判断子序列
在这里插入图片描述

1e5 为啥不行？

#include <iostream>
using namespace std;
const int N = 2e5;
int a[N],b[N];

int main(){
    int n,m; scanf("%d%d",&n,&m);

    for(int i = 1; i <= n; i++) scanf("%d",&a[i]);
    for(int i = 1; i <= m; i++) scanf("%d",&b[i]);

    int j = 1;
    bool isok = false;
    for(int i = 1; i <= n; i++){
        while(a[i] != b[j] && j < m) j++;
        if(i == n && j <= m && a[i] == b[j]){
             isok = true;
             break;
        }
        j++;
    }
    if(!isok) puts("No");
    else puts("Yes");
    
    return 0;
}

7. 位运算

AcWing 801. 二进制中1的个数

AcWing 801. 二进制中1的个数
在这里插入图片描述

#include <iostream>
using namespace std;
int lowbit(int a){
    return a&-a;
}
int main(){
    int n; cin >> n;
    for(int i = 1; i <= n; i++){
        int t; cin >> t;
        int res = 0;
        while(t > 0){
            res++;
            t -= lowbit(t);
        }
        cout << res << " ";
    }
    return 0;
}

这个样子会慢一点

#include <iostream>
using namespace std;


int main(){
    int n; cin >> n;
    for(int i = 1; i <= n; i++){
        int t; cin >> t;
        int res = 0;
        for(int i = 0; i < 32; i++){
            if((t >> i) & 1) res++;
        }
        cout << res << " ";
    }
    // int t = 0x7fffffff;
    // cout << t << endl;
    // for(int i = 0; i < 32; i++)  cout << ((t >> i)&1);
    return 0;
}

7. 离散化

AcWing 802. 区间和

AcWing 802. 区间和

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
const int N = 3e5 + 11;
int a[N],s[N];

vector<int> all;
vector<pair<int,int> > add,query;

//find x in all's index
int find(int x){
    int l = 0, r = all.size()-1;
    while(l <= r){
        int mid = l + (r-l)/2;
        if(all[mid] == x) return mid;
        if(all[mid] < x) l = mid + 1;
        else r = mid - 1;
    }
    return l;
}

int main(){
    int n,m; scanf("%d%d",&n,&m);
    int a[N] = {0};
    for(int i = 1; i <= n; i++){
        int x,c; scanf("%d%d",&x,&c);
        all.push_back(x);
        add.push_back({x,c});
    }
    for(int i = 1; i <= m; i++){
        int l,r; scanf("%d%d",&l,&r);
        all.push_back(l);
        all.push_back(r);
        query.push_back({l,r});
    }
    sort(all.begin(),all.end());
    all.erase(unique(all.begin(),all.end()),all.end());
    
    //离散化 a[1开始]
    for(int i = 0; i < add.size(); i++){
        a[find(add[i].first)+1] += add[i].second; //add[0].first = 1, c = 3 -->  a[0] += 3
        //cout << "i == " << i <<  " " << a[i] << endl;
    }
    for(int i = 1; i <= all.size(); i++){
        a[i] += a[i-1];

    }
    for(int i = 0; i < query.size(); i++){
        int l = find(query[i].first)+1;
        int r = find(query[i].second)+1;
        cout << a[r] - a[l-1] << endl;
    }
    return 0;
}

8. 区间合并

AcWing 803. 区间合并

AcWing 803. 区间合并

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

vector<pair<int,int> > all;

int main(){
    int n; cin >> n;
    while(n--){
        int l,r; cin >> l >> r;
        all.push_back({l,r});
    }
    sort(all.begin(),all.end());
    int ans = 1;
    //  for(int i = 1; i < all.size(); i++){
    //     cout << all[i].first << " " << all[i].second << endl;
    // }
    int t_max = all[0].second;
    for(int i = 1; i < all.size(); i++){
        if(all[i].first > t_max){
            ans++;
        } 
        t_max = max(t_max,all[i].second);
    }
    cout << ans << endl;
  
    
    return 0;
}
superkcl2022
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法基础课 acwing
Destiny_159的博客
09-06 6216
算法基础课 本博客基于acwing算法基础课,所做笔记 目的在于方便复习 课程链接:https://www.acwing.com/activity/content/introduction/11/ 主讲人:yxc 上课的时候理解算法的主要思想 课后把模板背过,并且调试题目,多重复,多敲 第一讲 基础算法 快速排序 调整区间的方法: 1、暴力，需要开辟两个数组 2、双指针 1、i往后面扫描，当i指向的数字小于等于x，就继续往后，当指向的数字大于x的时候停下 2、此时j往前面扫描，当j指向的数字大于x
acwing算法第三讲
04-30
acwing算法第三讲 -acwing算法第三讲中，闫学灿强调了编程语言语法是次要的，思维是主要的。学习循环语句需要抓住一个要点——代码执行顺序。 一、 while 循环 while 循环可以简单理解为循环版的 if 语句。如果...
Acwing 基础课—基础算法—归并排序
ForTres的博客
02-21 299
归并排序模板 稳定O(n*log n) 空间O(n) 参考链接 https://www.acwing.com/solution/content/2099/ #include<stdio.h> const int N = 100005; int a[N]; int t[N]; void ms(int l,int r){ if(l >= r) return ; int mid = l + r >> 1; ms(l,mid);ms(mid+1,r);
Aacwing练习代码汇总
fang 0 jun的博客
04-19 1052
文章目录动态规划背包问题图论dfsbfs树与图的DFS树与图的BFS拓扑排序最短路相关Dijkstra 单源最短路径bellman-fordFloyd最小生成树相关PrimKruskal 动态规划 背包问题 // 01背包 #include <iostream> using namespace std; const int N = 1010; int n, m; int v[N], w[N]; int f[N]; int main() { cin >> n >&g
acwing基础算法
恁村扛把子的博客
11-29 6694
文章目录基础算法快速排序归并排序整数二分浮点数二分高精度加法高精度减法高精度乘法高精度除法一维前缀和 —— 模板题二维前缀和 —— 模板题一维差分 —— 模板题二维差分 —— 模板题 基础算法 快速排序 void quick_sort(int q[], int l, int r) { if(l >= r)return; int i = l - 1, j = r + 1, x = q...
AcWing 算法基础课 第一讲 基础算法 离散化
weixin_54014603的博客
09-23 194
接下来，进行 m次询问，每个询问包含两个整数 l和 r，你需要求出在区间 [l,r] 之间的所有数的和。链接：https://www.acwing.com/solution/content/13511/sort(alls.begin(),alls.end());现在，我们首先进行 n次操作，每次操作将某一位置 x上的数加 c。//存储所有待离散化的值。//利用二分法找出x对应的离散化的值。
AcWing第一章算法模板总结——基础算法
weixin_43389219的博客
05-07 526
一、排序算法二、二分三、高精度四、前缀和与差分五、位运算六、双指针算法七、离散化八、区间合并。
acwing算法基础课-第一章 基础算法
偶然路过的帅小伙z的博客
04-13 772
排序 二分 高精度 前缀和与差分 双指针算法 位运算 离散化 区间合并
【无标题】AcWing算法基础课——基础算法
hdheid的博客
04-19 4472
AcWing算法基础课 1.1 快速排序 快速排序属于分治算法，快速排序的算法步骤，用分治的思想 确定分界点，数组内任意一个值（这里建议取中点，即(l+r)/2）； 调整区间，让x左边的数都小于x，右边的数都大于x； 递归处理左右两个区间，直到细分到不能细分 对于第二步的调整区间，具体就是弄两个指针，分别指向数组的左右边界；不断的向中间遍历，将遍历过程中左边比x大的数和右边比x小的数交换；直到i，j相遇。 快排模版 void quick_sort(int q[],int l,int r)
ACwing算法基础课——基础算法
astruggle___的博客
11-15 1161
算法基础课复习
Acwing-基础算法-第一章-基础算法
03-24
【Acwing基础算法】课程是面向初学者设计的，涵盖了算法和数据结构的基本概念。本章节主要讲解了一维和二维的基础算法，包括前缀和、差分、最长子序列、双指针算法以及二进制运算等核心概念，旨在帮助学习者建立扎实...
Acwing 算法基础课超详细笔记
11-27
Acwing 算法基础课超详细笔记 本资源摘要信息中，我们将对 Acwing 算法基础课进行详细笔记，涵盖快速排序、快速选择算法、归并排序、逆序对的数量和二分搜索等多个知识点。 快速排序 快速排序是一种基于分治的...
Acwing-基础算法-第二章-数据结构
03-24
以下是对标题“Acwing-基础算法-第二章-数据结构”和描述中涉及的知识点的详细说明： 1. **链表**： - 单链表：由一系列节点组成，每个节点包含数据和指向下一个节点的引用。在单链表中，插入和删除操作相对简单，...
Acwing-基础算法-第三章-搜素与图论
04-01
【Acwing-基础算法-第三章-搜索与图论】主要涵盖了两个核心概念：搜索算法和图论。在本章中，重点讲述了如何利用搜索算法解决图论问题。 1. **深度优先搜索（DFS, Depth-First Search）** - DFS是一种用于遍历或...
【LeetCode每日一题】——623.在二叉树中增加一行
最新发布
IronmanJay的博客
08-14 783
给定一个二叉树的根 root 和两个整数 val 和 depth ，在给定的深度 depth 处添加一个值为 val 的节点行。 注意，根节点 root 位于深度 1 。 加法规则如下: 给定整数 depth，对于深度为 depth - 1 的每个非空树节点 cur ，创建两个值为 val 的树节点作为 cur 的左子树根和右子树根。 cur 原来的左子树应该是新的左子树根的左子树。 cur 原来的右子树应该是新的右子树根的右子树。 如果 depth == 1 意味着 depth - 1 根本没有深度
代码随想录算法训练营第十一天
b1ankwall的博客
08-10 1255
参加代码随想录第43期算法训练营day11|150. 逆波兰表达式求值，239. 滑动窗口最大值，347.前 K 个高频元素，栈与队列总结
[算法2] 第二集 二叉树中的深度搜索
2301_80017277的博客
08-09 894
一、（DFS，全称为 Depth First Traversal），是我们树或者图这样的数据结构中常⽤的⼀种遍历算法。这个算法会尽可能深的搜索树或者图的分支，直到⼀条路径上的所有节点都被遍历完毕，然后再回溯到上⼀层，继续找⼀条路遍历。在⼆叉树中，常见的深度优先遍历为：前序遍历、中序遍历以及后序遍历。因为树的定义本⾝就是递归定义，因此采⽤递归的方法去实现树的三种遍历不仅容易理解⽽且代码很简洁。
算法：外卖调度
m0_73915763的博客
08-13 1063
有N个餐厅和M个外卖员，每个餐厅在某个时间点会产生一个外卖订单，这些订单都有产生时间、所需送达时间和优先级。外卖员在空闲时会选择最优先的订单来配送，直到所有订单都被送达。具体规则如下: 对于每个餐厅的订单，优先级高的订单优先，其次是所需送达时间最短的订单，再次是产生时间最早的订单。外卖员在空闲时会从所有餐厅的最高优先级订单中挑选一个所需送达时间最短的订单进行配送，若所需送达时间相同则选择餐厅编号最小的订单。
ACWing基础算法入门：前缀和与二维差分矩阵讲解
本资源是一份关于ACWing基础算法课程的详细笔记，针对第一章的内容进行了整理。章节重点介绍了二维前缀和的概念，包括其在数据结构中的理解和记忆方法。二维前缀和用于高效计算从左上角到某一点的所有元素之和，通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值