【算法模板】基础算法——排序、二分、前缀和、差分、双指针算法、位运算、离散化、区间合并

最新推荐文章于 2024-09-18 20:33:32 发布
最新推荐文章于 2024-09-18 20:33:32 发布
阅读量161 收藏 1
点赞数
分类专栏： 算法模板 文章标签： 算法 排序算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/peterwanye/article/details/124721293
版权

文章目录

week1 基础算法

排序

代码模板
快速排序
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 + 1, r);
}
归并排序
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 <= r) tmp[k ++ ] = q[j ++ ];

    for (i = l, j = 0; i <= r; i ++, j ++ ) q[i] = tmp[j];
}
例子
example 1 : 快速排序

给定你一个长度为 n n n 的整数数列。

请你使用快速排序对这个数列按照从小到大进行排序。

并将排好序的数列按顺序输出。

#include <iostream>

using namespace std;

const int N = 100010;

int q[N];

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 + 1, r);
}

int main()
{
    int n;
    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;
}
example 2 : 第 k k k 个数

给定一个长度为 n n n 的整数数列，以及一个整数 k k k，请用快速选择算法求出数列从小到大排序后的第 k k k 个数。

#include <iostream>

using namespace std;

const int N = 100010;

int q[N];

int quick_sort(int q[], int l, int r, int k)
{
    if (l >= r) return q[l];

    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]);
    }

    if (j - l + 1 >= k) return quick_sort(q, l, j, k);
    else return quick_sort(q, j + 1, r, k - (j - l + 1));
}

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

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

    cout << quick_sort(q, 0, n - 1, k) << endl;

    return 0;
}
example 3 : 归并排序

给定你一个长度为 n n n 的整数数列。

请你使用归并排序对这个数列按照从小到大进行排序。

并将排好序的数列按顺序输出。

#include <iostream>

using namespace std;

const int N = 1e5 + 10;

int a[N], tmp[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 <= r) tmp[k ++ ] = q[j ++ ];

    for (i = l, j = 0; i <= r; i ++, j ++ ) q[i] = tmp[j];
}

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

    merge_sort(a, 0, n - 1);

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

    return 0;
}
example 4 : 逆序对的数量

给定一个长度为 n n n 的整数数列，请你计算数列中的逆序对的数量。

逆序对的定义如下：对于数列的第 i i i​ 个和第 j j j​ 个元素，如果满足 i < j i<j i<j​且 a [ i ] > a [ j ] a[i]>a[j] a[i]>a[j]​ 则其为一个逆序对；否则不是。

#include <iostream>

using namespace std;

typedef long long LL;

const int N = 1e5 + 10;

int a[N], tmp[N];

LL merge_sort(int q[], int l, int r)
{
    if (l >= r) return 0;

    int mid = l + r >> 1;

    LL res = 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
        {
            res += mid - i + 1;
            tmp[k ++ ] = q[j ++ ];
        }
    while (i <= mid) tmp[k ++ ] = q[i ++ ];
    while (j <= r) tmp[k ++ ] = q[j ++ ];

    for (i = l, j = 0; i <= r; i ++, j ++ ) q[i] = tmp[j];

    return res;
}

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

    cout << merge_sort(a, 0, n - 1) << endl;

    return 0;
}

二分

代码模板
整数二分
bool check(int x) {/* ... */} // 检查x是否满足某种性质

// 区间[l, r]被划分成[l, mid]和[mid + 1, r]时使用：
int bsearch_1(int l, int r)
{
    while (l < r)
    {
        int mid = l + r >> 1;
        if (check(mid)) r = mid;    // check()判断mid是否满足性质
        else l = mid + 1;
    }
    return l;
}
// 区间[l, r]被划分成[l, mid - 1]和[mid, r]时使用：
int bsearch_2(int l, int r)
{
    while (l < r)
    {
        int mid = l + r + 1 >> 1;
        if (check(mid)) l = mid;
        else r = mid - 1;
    }
    return l;
}
浮点数二分
bool check(double x) {/* ... */} // 检查x是否满足某种性质

double bsearch_3(double l, double r)
{
    const double eps = 1e-6;   // eps 表示精度，取决于题目对精度的要求
    while (r - l > eps)
    {
        double mid = (l + r) / 2;
        if (check(mid)) r = mid;
        else l = mid;
    }
    return l;
}
例子
example 1 : 数的范围

给定一个按照升序排列的长度为 n n n 的整数数组，以及 q q q 个查询。

对于每个查询，返回一个元素 k k k 的起始位置和终止位置（位置从 0 0 0 开始计数）。

如果数组中不存在该元素，则返回 − 1 − 1 -1 -1 −1−1​

#include <iostream>

using namespace std;

const int N = 100010;

int n, m;
int q[N];

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;
        while (l < r)
        {
            int mid = l + r >> 1;
            if (q[mid] >= x) r = mid;
            else l = mid + 1;
        }

        if (q[l] != x) cout << "-1 -1" << endl;
        else
        {
            cout << l << ' ';

            int l = 0, r = n - 1;
            while (l < r)
            {
                int mid = l + r + 1 >> 1;
                if (q[mid] <= x) l = mid;
                else r = mid - 1;
            }

            cout << l << endl;
        }
    }

    return 0;
}
example 2 : 数的三次方根

给定一个浮点数 n n n，求它的三次方根。

#include <iostream>

using namespace std;

int main()
{
    double x;
    cin >> x;

    double l = -100, r = 100;
    while (r - l > 1e-8)
    {
        double mid = (l + r) / 2;
        if (mid * mid * mid >= x) r = mid;
        else l = mid;
    }

    printf("%.6lf\n", l);
    return 0;
}

前缀和

代码模板
一维前缀和
S[i] = a[1] + a[2] + ... a[i]
a[l] + ... + a[r] = S[r] - S[l - 1]
二维前缀和
S[i, j] = 第i行j列格子左上部分所有元素的和
以 (x1, y1)为左上角，(x2, y2)为右下角的子矩阵的和为：
S[x2, y2] - S[x1 - 1, y2] - S[x2, y1 - 1] + S[x1 - 1, y1 - 1]
例子
example 1 : 前缀和

输入一个长度为 n n n 的整数序列。

接下来再输入 m m m 个询问，每个询问输入一对 l , r l,r l,r。

对于每个询问，输出原序列中从第 l l l 个数到第 r r r​ 个数的和。

#include <iostream>

using namespace std;

const int N = 100010;

int n, m;
int a[N], s[N];

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

    for (int i = 1; i <= n; i ++ ) s[i] = s[i - 1] + a[i]; // 前缀和的初始化

    while (m -- )
    {
        int l, r;
        scanf("%d%d", &l, &r);
        printf("%d\n", s[r] - s[l - 1]); // 区间和的计算
    }

    return 0;
}
example 2 : 子矩阵的和

输入一个 n n n 行 m m m 列的整数矩阵，再输入 q q q 个询问，每个询问包含四个整数 x 1 , y 1 , x 2 , y 2 x_1,y_1,x_2,y_2 x1​,y1​,x2​,y2​，表示一个子矩阵

的左上角坐标和右下角坐标。

对于每个询问输出子矩阵中所有数的和。

#include <iostream>

using namespace std;

const int N = 1010;

int n, m, q;
int s[N][N];

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

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )
            scanf("%d", &s[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];

    while (q -- )
    {
        int x1, y1, x2, y2;
        scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
        printf("%d\n", s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1]);
    }

    return 0;
}

差分

代码模板
一维差分
给区间[l, r]中的每个数加上c：B[l] += c, B[r + 1] -= c
二维差分
给以(x1, y1)为左上角，(x2, y2)为右下角的子矩阵中的所有元素加上c：
S[x1, y1] += c, S[x2 + 1, y1] -= c, S[x1, y2 + 1] -= c, S[x2 + 1, y2 + 1] += c
例子
example 1 : 差分

输入一个长度为 n n n 的整数序列。

接下来输入 m m m 个操作，每个操作包含三个整数 l , r , c l,r,c l,r,c ， 表示将序列中 [ l , r ] [l,r] [l,r] 之间的每个数加上 c c c。

请你输出进行完所有操作后的序列。

#include <iostream>

using namespace std;

const int N = 100010;

int n, m;
int a[N], b[N];

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

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

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

    while (m -- )
    {
        int l, r, c;
        scanf("%d%d%d", &l, &r, &c);
        insert(l, r, c);
    }

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

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

    return 0;
}
example 2 : 差分矩阵

输入一个 n n n 行 m m m 列的整数矩阵，再输入 q q q 个操作，每个操作包含五个整数 x 1 , y 1 , x 2 , y 2 , c x_1,y_1,x_2,y_2,c x1​,y1​,x2​,y2​,c，其中 ( x 1 , y 1 ) (x1,y1) (x1,y1)

和 ( x 2 , y 2 ) (x2,y2) (x2,y2) 表示一个子矩阵的左上角坐标和右下角坐标。

每个操作都要将选中的子矩阵中的每个元素的值加上 c c c。

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

#include <iostream>

using namespace std;

const int N = 1010;

int n, m, q;
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()
{
    scanf("%d%d%d", &n, &m, &q);

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

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; 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);
    }

    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 ++ ) printf("%d ", b[i][j]);
        puts("");
    }

    return 0;
}

双指针算法

算法思想

可以把 O ( n 2 ) O(n^{2}) O(n2)的暴力算法优化到 O ( n ) O(n) O(n)

代码模板
for (int i = 0, j = 0; i < n; i ++ )
{
    while (j < i && check(i, j)) j ++ ;
    
    // 具体问题的逻辑
}
常见问题分类：
    (1) 对于一个序列，用两个指针维护一段区间
    (2) 对于两个序列，维护某种次序，比如归并排序中合并两个有序序列的操作
例子
example 1

输出每一个单词，输入abc_def_ghi（单词之间由空格隔开）

#include<iostream>S
#include<string.h>

using namespace std;

int main()
{
    char str[1000];
    
    cin.getline(str,1000);
    
    int n = strlen(str);
    //双指针算法
    for(int i=0;i<n;i++)
    {
        int j=i;
        while(j < n && str[j] != '_') j++;
        for(int k = i; k < j; k ++)
        {
            cout<<str[k];
        }
        cout<<endl;
        i = j;
    }
    
    return 0;
}
example 2 : 最长连续不重复子序列

给定一个长度为 n n n 的整数序列，请找出最长的不包含重复的数的连续区间，输出它的长度。

eg : 输入1 2 2 3 5 输出 3

#include<iostream>

using namespace std;

const int N=100010;

int a[N];
int s[N];

int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
    }
    int i,j;
    int res = 0;
    for(i=0,j=0;i<n;i++)
    { 
        s[a[i]]++;
        while(j<i && s[a[i]]>1)
        {   
            s[a[j]]--;
            j++;
        }
            res = max(res,i-j+1);
    }   
    cout<<res;
    
	return 0;
}
example 3 : 数组元素的目标和

给定两个升序排序的有序数组 A A A 和 B B B，以及一个目标值 x x x。

数组下标从 0 0 0 开始。

请你求出满足 A [ i ] + B [ j ] = x A[i]+B[j]=x A[i]+B[j]=xA 的数对 ( i , j ) (i,j) (i,j)。

数据保证有唯一解。

#include<iostream>

using namespace std;

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

int main()
{
    cin>>n>>m>>x;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
    }
    for(int i=0;i<m;i++)
    {
        cin>>b[i];
    }
    for(int i=0,j=m-1;i<n;i++)
    {
        while(j>=0&&a[i]+b[j]>x)
            j--;
        if(j>=0&&a[i]+b[j]==x)
            cout<<i<<" "<<j<<endl;
    }
}
example 4 : 判断子序列

给定一个长度为 n n n 的整数序列 a 1 , a 2 , … , a n a1,a2,…,an a1,a2,…,an 以及一个长度为 m m m 的整数序列 b 1 , b 2 , … , b m b1,b2,…,bm b1,b2,…,bm。

请你判断 a a a 序列是否为 b b b 序列的子序列。

子序列指序列的一部分项按原有次序排列而得的序列，例如序列 { a 1 , a 3 , a 5 } \{a1,a3,a5\} {a1,a3,a5}是序列 { a 1 , a 2 , a 3 , a 4 , a 5 } \{a1,a2,a3,a4,a5\} {a1,a2,a3,a4,a5} 的

一个子序列。

#include<iostream>

using namespace std;

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

int main()
{
    cin>>n>>m;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
    }
    for(int i=0;i<m;i++)
    {
        cin>>b[i];
    }
    int i=0,j=0;
    while(i<n&&j<m)
    {
        if(a[i]==b[j])
        {
            i++;
        }
        j++;
    }
    if(i==n)
    {
        cout<<"Yes"<<endl;
    }
    else
    {
        cout<<"No"<<endl;
    }
    return 0;
}

位运算

算法公式

求n的第k位数字: n > > k & 1 n >> k \& 1 n>>k&1

返回n的最后一位1： l o w b i t ( n ) = n & − n lowbit(n) = n \& -n lowbit(n)=n&−n （根据原码与补码的相关性质得出）

例子
example 1 : 二进制一的个数

给定一个长度为 n n n的数列，请你求出数列中每个数的二进制表示中 1 1 1 的个数。

#include<iostream>

using namespace std;

const int N=100010;

int a[N];
int s[N];

int lowbit(int n)
{
    int t;
    t=n & -n;
    return t;
}

int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
        int t=a[i];
        int count=0;
        while(t>0)
        {
            t=t-lowbit(t);
            count++;
        }
        s[i]=count;
        count=0;
    }
    for(int i=0;i<n;i++)
    {
        cout<<s[i]<<" ";
    }
    
    return 0;
}

离散化

核心思想

将一些较为离散的值映射为一些连续的较小的整数

代码模板
vector<int> alls; // 存储所有待离散化的值
sort(alls.begin(), alls.end()); // 将所有值排序
alls.erase(unique(alls.begin(), alls.end()), alls.end());   // 去掉重复元素

// 二分求出x对应的离散化的值
int find(int x) // 找到第一个大于等于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; // 映射到1, 2, ...n
}
例子
example 1 : 区间和

假定有一个无限长的数轴，数轴上每个坐标上的数都是 0 0 0。

现在，我们首先进行 n n n 次操作，每次操作将某一位置 x x x 上的数加 c c c。

接下来，进行 m m m 次询问，每个询问包含两个整数 l l l 和 r r r，你需要求出在区间 [ l , r ] [l,r] [l,r]之间的所有数的和。

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

using namespace std;

typedef pair<int, int> PII;

const int N = 300010;

int n, m;
int a[N], s[N];

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

int find(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 (auto item : add)
    {
        int x = find(item.first);
        a[x] += item.second;
    }

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

    // 处理询问
    for (auto item : query)
    {
        int l = find(item.first), r = find(item.second);
        cout << s[r] - s[l - 1] << endl;
    }

    return 0;
}

区间合并

算法思想

将所有存在交集的区间进行合并

算法模板
// 将所有存在交集的区间合并
void merge(vector<PII> &segs)
{
    vector<PII> res;

    sort(segs.begin(), segs.end());

    int st = -2e9, ed = -2e9;
    for (auto seg : segs)
        if (ed < seg.first)
        {
            if (st != -2e9) res.push_back({st, ed});
            st = seg.first, ed = seg.second;
        }
        else ed = max(ed, seg.second);

    if (st != -2e9) res.push_back({st, ed});

    segs = res;
}
例子
example 1 : 区间合并

给定 n n n 个区间 [ l i , r i ] [li,ri] [li,ri]，要求合并所有有交集的区间。

注意如果在端点处相交，也算有交集。

输出合并完成后的区间个数。

例如： [ 1 , 3 ] [1,3] [1,3]和 [ 2 , 6 ] [2,6] [2,6] 可以合并为一个区间 [ 1 , 6 ] [1,6] [1,6]。

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

using namespace std;

typedef pair<int, int> PII;

void merge(vector<PII> &segs)
{
    vector<PII> res;

    sort(segs.begin(), segs.end());

    int st = -2e9, ed = -2e9;
    for (auto seg : segs)
        if (ed < seg.first)
        {
            if (st != -2e9) res.push_back({st, ed});
            st = seg.first, ed = seg.second;
        }
        else ed = max(ed, seg.second);

    if (st != -2e9) res.push_back({st, ed});

    segs = res;
}

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

    vector<PII> segs;
    for (int i = 0; i < n; i ++ )
    {
        int l, r;
        scanf("%d%d", &l, &r);
        segs.push_back({l, r});
    }

    merge(segs);

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

    return 0;
}
NUAA_Peter
关注
专栏目录
莫队算法 ( MO's algorithm )
06-05 633
莫队算法是由清华大学神牛莫涛发明的一种处理区间问题的离线算法 算法核心是通过先将问询区间总长度平方分块、然后将所有的问询区间按照左端点所在的块编号排序、在同一块内的则按右端点升序 然后设置左右两个下标指针、每次都移动两个指针指向问询块的左右端点、在移动的过程中不断维护答案。 可以证明原本只通过两个下标指针移动来处理问询的方法最坏可达 O(N*Q) 经过莫队算法排序后可降为 O((N...
离散化、贪心、双指针、二分、倍增、构造、位运算
m0_74343360的博客
04-02 1585
双指针算法通常用于在数组或字符串中进行快速查找、匹配、排序或移动操作。双指针并非真的用指针实现，一般用两个变量来表示下标(在后面都用指针来表示)。双指针算法使用两个指针在数据结构上进行迭代，并购根据问题的要求移动这些指针。双指针往往也和单调性、排序联系在一起，在数组的区间问题上，暴力法的时间复杂度往往是O()，但双指针利用”单调性“可以优化到O(n)。对撞指针快慢指针倍增 从字面的上意思看就是成倍的增长 ,这是指我们在进行递推时,如果状态空间。
【算法学习】：排序、二分、前缀和、差分
m0_61960885的博客
08-07 157
acwing
排序与二分
Pbw_666的博客
01-08 335
今天，算法篇要续更了。内容的话对于一些算法竞赛是适用的。内容涵盖： 基础算法：排序，二分，前缀和差分等等。 数据结构：栈，队列，堆，哈希等等。 图论与搜索：图的应用+DFS+BFS等等。 贪心算法：区间问题+huffman树等等。 动态规划：线性，区间等等。 数学类：快速幂，博弈论等等。（这个看时间） 理论补充完后，将补充习题，正文开始。 排序包含：快速排序和归并排序。 快速排序： 1.确定枢轴量x，以及双指针i，j。 2.交换元素，使得左区间元素小于等于x，右区间大于等于x。 3.递归左区间，递归右区
前缀和+模拟+归并排序
weixin_43492045的博客
03-17 208
令小明头疼的是，这些日期采用的格式非常不统一，有采用年/月/日的，有采用月/日/年的，还有采用日/月/年的。这里所说的连号区间的定义是：如果区间 [L,R] 里的所有元素（即此排列的第 L个到第 R 个元素）递增排序后能得到一个长度为 R−L+1 的“连续”数列，则称这个区间连号区间。当 N 很小的时候，小明可以很快地算出答案，但是当 N 变大的时候，问题就不是那么简单了，现在小明需要你的帮助。：因为要求第l到第r个数的和，所以就可以想到前缀和，也就是前r个数的和减去前l个数的和就是第l到第r个数的和。
hdu5714 排序+前缀和
RockyHOO1209的博客
01-30 497
首先需要知道视角就是平时理解的视角（角度），题目中说垂直河岸容易误导。然后需要注意的是看到完整的船只。思路：对于每条船，能观察到它完整的观测点区间为（y-z,x+z),把区间存储。接下来的排序比较关键：先按点的位置从小到大排，如果位置相同则前端点排前面（对于向右船只的区间，左端点为前端点；向右的区间，右端点为前端点。 这样算出来的才能是区间重叠的最大值，这里需要想一想），如果前面二者都相等，则向右
Acwing-基础算法-第一章-基础算法
03-24
本章节主要讲解了一维和二维的基础算法，包括前缀和、差分、最长子序列、双指针算法以及二进制运算等核心概念，旨在帮助学习者建立扎实的算法基础。 1. **前缀和** 前缀和是一种利用空间换取时间的技术，常用于...
常用算法代码模板 Java版 (1) ：基础算法
www.h y p e r p l a s m a.top
08-14 1122
常用算法模板 Java版——基础算法：排序、二分、高精度、前缀和与差分、位运算、双指针、离散化、区间合并
leetcode中国-leetcode_algo:leetcode相关算法和模板使用python
06-29
前缀和与差分 双指针算法 回朔法 位运算 离散化 区间合并 数据结构 —— 代码模板链接 常用代码模板2——数据结构 链表与邻接表：树与图的存储 栈与队列：单调队列、单调栈 kmp Trie 并查集 堆 Hash表 C++ STL使用...
常用算法代码模板 (1) ：基础算法
www.h y p e r p l a s m a.top
04-19 1338
常用算法模板——基础算法：排序、二分、高精度、前缀和与差分、位运算、双指针、离散化、区间合并
前缀和详解
weixin_52477733的博客
12-06 7644
目录前缀和概念前缀和代码前缀和例题题目介绍思路分析相关代码总结 前缀和概念 前缀和：顾名思义，是要求前缀的总和，什么是前缀，对于一个存放数字的数组而言，前缀就是指的数组的前k项，因此对应的前缀和就是数组前k项的和。前缀和一般用来求数组中连续段子数组的值的和，类似于等差数列中利用等差数列的和来求某一段子数列的和： 前缀和代码 public int[] prefix(int[] arr){ int[] prefixArr = new int[arr.length]; //前缀和的
第二章--归并排序
a219219219219的博客
07-26 118
public class Example { public static boolean less(Comparable v1,Comparable w1){ int v=Integer.parseInt((String)v1); int w=Integer.parseInt((String)w1); if (v<w) return true; else return false; } protected static .
排序算法04-归并排序算法
yuhuofei的草屋
09-28 93
package com.org.example; import java.util.Arrays; /** * @description 归并排序（递归方式） 核心思想：分而治之，先拆分后排序合并归一 */ public class MergeSort { public static void main(String[] args) { int[] arr = { 24, 3, 6, 8, 85, 6, 7 }; sort(arr, 0, arr.length - 1); Syste
归并排序——day—2
qq_40433783的博客
02-18 127
Method 确定分界点 中点 ：q[(l+r)/2]； 递归排序 归并——合二为一(重点) Example 问题 给定你一个长度为n的整数数列。 请你使用归并排序对这个数列按照从小到大进行排序。 并将排好序的数列按顺序输出。 输入格式 输入共两行，第一行包含整数 n。 第二行包含 n 个整数（所有整数均在1~1000000范围内），表示整个数列。 输出格式 输出共一行，包含 n 个整数，表...
基数排序
Mudrobot的博客
02-27 146
二话不说，先上代码： 接下来将重点解释有important注释的地方： #include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;algorithm&gt; using namespace std; const int N=1000005; long long origin[N],final[N],last[N];//原始数组，当...
代码随想录算法训练营Day7
最新发布
lynyzy的博客
09-18 448
双指针
力扣 16.最接近的三数之和
qq_51352130的博客
09-16 361
设 s=nums[i]+nums[j]+nums[k]，为了判断 s 是不是与 target 最近的数，我们还需要用一个变量 minDiff 维护 ∣s−target∣ 的最小值。分类讨论：如果 s=target，那么答案就是 s，直接返回 s。如果 s>target，那么如果 s−target<minDiff，说明找到了一个与 target 更近的数，更新 minDiff 为 s−target，更新答案为 s。然后和三数之和一样，把 k 减一。
拥塞控制算法为何失效，网络为何难以测量？
Netfilter
09-14 7301
所以你知道实验室仿真的宇宙第一算法为啥拉了吧，也就不用再问为什么部署了 bbr 却还不如 cubic 了吧，如果你还希望研发一个精准的，普适的端到端算法，我劝你改行去卖皮鞋，至少还有很多经理市场。这和上一篇说的测量系统容量的方法并不矛盾，因为对于网络传输系统而言，系统是动态变化的，在流量部署到系统上并开始传输时，没有全局视图，就不能指望全局公平，留下的 gap 是固有的，没法靠算法弥补。，超级经典的一篇论文，我推荐过不止一次，因此我本文不谈异构问题，说点别的，比如拓扑。对，就是要砸，因为我不干了。
[ABC330E] Mex and Update
2301_80882026的博客
09-18 861
给定一个序列，支持单点修改，每次修改后输出全局mex。一个序列的mex定义为，序列中最小的没有出现过的非负整数。
二分搜索与快速排序算法详解：代码实现与分析
本资源主要涵盖了两个重要的算法：二分搜索算法和快速排序算法，并提供了详细的代码实现和实际应用示例。对于二分搜索算法，它是一种在有序数组中查找特定元素的有效方法，具有较高的效率。在给定的数组a[0 : 8]={1,...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

NUAA_Peter

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值