AcWing算法学习笔记：基础算法（快速排序 + 归并排序 + 二分 + 高精度 +前缀和差分 + 双指针算法 + 位运算 + 离散化 + 区间和并）

一、快速排序

①快速排序⭐

算法

至于关键步骤第二步，有两种方法

• 优美做法
  使用i， j 两个指针，当a[i] < x,i ++; 当a[j] > x, j –
  当i和j都无法移动时，swap（a[i], a[j])
• 暴力做法
  遍历一遍数组，将小于x的放入a数组，将大于x的放入b数组
  最后将a数组和b数组的数移动到a数组中

上述两种方法均能实现数组a分为两部分

时间复杂度
0(nlogn)
递归logn层，每层0(n)

代码

#include 
#include 
#include 

using namespace std;

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

void quickSort(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(a[i], a[j]);
    }
    quickSort(q, l, j); //i不一定总是等于j，可能存在i > j的情况
    quickSort(q, j + 1, r);
}

int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; i ++) scanf("%d", &a[i]);
    quickSort(a, 0, n - 1); //数组作为函数实参时，编译器总是将其解析为指向数组首元素地址的指针(地址调用)
    for (int i = 0; i < n; i ++) printf("%d ", a[i]);
    return 0;
}

②第k个数

算法
快排算法的简单应用
在递归左右区间时，根据第k个数在哪个区间进行递归
递归时，更新在该区间中那个目标值在区间中的位置
代码

#include 
#include 
#include 

using namespace std;

const int N = 100010;

int n, k, a[N];

void quickSort(int q[], int l, int r, int k) //局部变量与全局变量重名，使用局部变量
{
    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]);
    }
    
    int s = j - l + 1; //左区间的长度
    if (k <= s) quickSort(q, l, j, k); //如果k小于左区间的长度，则依旧是左区间中的第k个数
    else quickSort(q, j + 1, r, k - s); //如果k大于左区间的长度，则是右区间中的第k - s个数
}
int main()
{
    scanf("%d%d", &n, &k);
    for (int i = 1; i <= n; i ++) scanf("%d", &a[i]);
    
    quickSort(a, 1, n, k);

    printf("%d", a[k]);
    return 0;
}

二、归并排序

①归并排序

算法

递归排序后，左右两个区间均为 有序序列
再使用双指针将两个序列合并为一个序列

时间复杂度
递归0(logn)层
每一层遍历0(n)
总的时间复杂度为0(nlogn)

代码

#include 
#include 
#include 

using namespace std;

const int N = 100010;

int n, a[N];

void mergeSort(int q[], int l, int r) //如果返回数组
{
    if (l >= r) return ;
    
    int mid = l + r >> 1;
    mergeSort(q, l, mid);
    mergeSort(q, mid + 1, r);
    
    int t[N];
    int cnt = 0;
    int i = l, j = mid + 1;
    
    while (i <= mid && j <= r)
    {
        while (q[i] < q[j] && i <= mid) t[cnt ++] = q[i ++];
        while (q[j] <= q[i] && j <= r) t[cnt ++] = q[j ++];
    }
    while (i <= mid)t[cnt ++] = q[i ++];
    while (j <= r) t[cnt ++] = q[j ++];
    
    for (int i = l, j = 0; i <= r; i ++, j ++) q[i] = t[j];
}

int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; i ++) scanf("%d", &a[i]);
    
    mergeSort(a, 0, n - 1);
    
    for (int i = 0; i < n; i ++) printf("%d ", a[i]);
    return 0;
}

②逆序对的数量⭐

算法

代码

#include 
#include 
#include 

using namespace std;

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

long long mergeSort(int l, int r)
{
	//明确递归结束条件
    if (l >= r) return 0;
    
    int mid = l + r >> 1;
    int i = l, j = mid + 1;
    
    //递归处理左右两部分
    long long res = mergeSort(l, mid) + mergeSort(mid + 1, r);
    
    int tmp[N];
    int cnt = -1;
    while  (i <= mid && j <= r)
    {
        while (i <= mid && a[i] <= a[j]) tmp[ ++ cnt] = a[i ++];
        while (j <= r && a[i] > a[j])
        {
            tmp[ ++ cnt] = a[j ++];
            res += (mid - i + 1);
        }
    }
    while (i <= mid) tmp[ ++ cnt] = a[i ++];
    while (j <= r) tmp[ ++ cnt] = a[j ++];
    
    for (int i = l, j = 0; i <= r; i ++, j ++) a[i] = tmp[j];
    
    return res;
}
int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; i ++) scanf("%d", &a[i]);
    
    cout << mergeSort(0, n - 1);
    
    return 0;
}

三、二分

①数的范围⭐

算法
利用某种性质，使数组一分为二，不断缩小区间，最后找到性质的边界范围

将数组a[N]根据某种性质划分为两部分
根据mid值所在的区间进行边界的判定

如果想要得到红色边界
当mid在红色边界内时，缩小L，L = mid
反之 缩小R， R = mid - 1

如果想要得到绿色边界
当mid在绿色边界内时，缩小R， R = mid
反之，缩小L， L = mid + 1

代码

#include 
#include 
#include 
#include 

using namespace std;

const int N = 100010;

int n, q, a[N];
unordered_map <int, int> m;

int main()
{
    scanf("%d%d", &n, &q);
    
    for (int i = 0; i < n; i ++)
    {
        scanf("%d", &a[i]);
        m[a[i]] = 1;
    }
    
    while (q --)
    {
        int x;
        scanf("%d", &x);
        
        int resR, resL;
        int l = 0, r = n - 1;
        while (l < r)
        {
            int mid = l + r + 1 >> 1;
            if (a[mid] <= x) l = mid; //确定数组中小于等于x的右边界
            else r = mid - 1;
        }
        resR = r; //二分结束后，L和R相同，共同指向边界
        
        l = 0; r = n - 1;
        while (l < r)
        {
            int mid = l + r >> 1;
            if (a[mid] >= x) r = mid;//确定数组中大于等于x的左边界
            else l = mid + 1;
        }
        resL = r;
        
        if (m[x]) cout << resL << " " << resR << endl; //得到x在数组中的左边界以及右边界
        else cout << -1 << " " << -1 << endl;
    }
    return 0;
}

②数的三次方根⭐

算法
与整数二分类似
浮点数的二分，边界无需加一，只需要根据mid所在的区域，更新L/R为mid即可
代码

#include 
#include 
#include 

using namespace std;

double n = 0;

int main()
{
    cin >> n;
    double l = -50, r = 50;
    while (r - l >= 1e-8) //使l和r精确到1e-6，比要求的多两位，常识
    {
        double mid = (l + r) / 2;
        if (mid * mid * mid >= n) r = mid;
        else l = mid; //浮点数不需要加一，因为存在更小的单位，最小单位不是1
    }
    printf("%.6lf", l);//输出六位小数 .6lf是double  .6f是float
    return 0;
}

四、高精度

①高精度加法

算法
A + B （A和B是两个大整数，位数可以是1e6）

然后根据加法从低位逐位相加，并处理进位即可
代码

#include 
#include 
#include 

using namespace std;

const int N = 100010;
int a[N], b[N], c[N];
string stra, strb;

int main()
{
    cin >> stra >> strb;
    if (stra.size() > strb.size()) //将a变为长度较小的那个串
    {
        string t = stra;
        stra = strb;
        strb = t;
    }
    
    //将串逆序存入数组
    for (int i = stra.size() - 1, j = 0; i >= 0; i --, j ++) a[j] = stra[i] - '0';
    for (int i = strb.size() - 1, j = 0; i >= 0; i --, j ++) b[j] = strb[i] - '0';
    
    int lena = stra.size(), lenb = strb.size();
    
    //将a 与 b相加
    int t = 0;
    int cnt = 0;
    for (; cnt < lena; cnt ++)
    {
        c[cnt] = (a[cnt] + b[cnt] + t) % 10;
        t = (a[cnt] + b[cnt] + t) / 10;
    }
    
    //将b多余的部分处理进位
    while (cnt < lenb)
    {
        c[cnt] = (b[cnt] + t) % 10;
        t = (b[cnt] + t) / 10;
        cnt ++;
    }
    if (t) //不要忘记最高位可能存在进位的情况
    {
        c[cnt ++] = t;
    }
    
    //最终将答案逆序输出
    for (int i = cnt - 1; i >= 0; i --)
    {
        cout << c[i];
    }
    return 0;
}

②高精度减法

算法
A - B （A和B是两个大整数，位数可以是1e6）
如果A >= B 则计算 A - B
如果A < B 则计算 - (B - A)
也是使用数组进行逆序
按照减法逐位相减，处理借位
注意去除前导0，至少保留一个0
代码

#include 
#include 
#include 
#include 

using namespace std;

vector <int> Sub(vector <int> a, vector <int> b)
{
    vector <int> res;
    int t = 0;
    int i = 0;
    for (; i < a.size(); i ++)
    {
        int x = a[i] - t;
        if (i < b.size()) x -= b[i];
        if (x < 0)
        {
            x += 10;
            t = 1;
        }
        else t = 0;
        res.push_back(x);
    }

    //去掉前导0，记得至少留一位，避免答案为0的情况
    while (res.size() > 1 && res.back() == 0) res.pop_back(); //vector.back()获取back
    return res;
}
int main()
{
    string stra, strb;
    cin >> stra >> strb;

    if ((stra.size() < strb.size()) || ((stra.size() == strb.size()) && (stra < strb)))
    {
        cout << '-';
        string t = stra;
        stra = strb;
        strb = t;
    }
 
    vector <int> a, b;
    for (int i = stra.size() - 1; i >= 0; i --) a.push_back(stra[i] - '0');
    for (int i = strb.size() - 1; i >= 0; i --) b.push_back(strb[i] - '0');
    
    auto c = Sub(a, b);
    
    for (int i = c.size() - 1; i >= 0; i --) cout << c[i];
    return 0;
}

③高精度乘法

算法
A * a (大整数A 和 小整数a相乘，A位数为1e6，a数值为1e9)

代码

#include 
#include 
#include 
#include 

using namespace std;

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

④高精度除法

算法
A ➗ a (大整数A 和 小整数a相乘，A位数为1e6，a数值为1e9)

就是模拟除法的过程
代码

#include 
#include 
#include 

using namespace std;

int main()
{
    string str;
    int b;
    cin >> str >> b;
    
    vector <int> a;
    for (int i = 0; i < str.size(); i ++) a.push_back(str[i] - '0');
    
    vector <int> res;
    
    int t = 0;
    for (int i = 0; i < a.size(); i ++)
    {
        int x = t * 10 + a[i];
        res.push_back(x / b);
        t = x % b;
    }
    while (res.size() > 1 && res.front() == 0) res.erase(res.begin(), res.begin() + 1);
    
    for (int i = 0; i < res.size(); i ++) cout << res[i];
    cout << endl;
    cout << t;
    return 0;
}

五、前缀和差分

①前缀和

算法

代码

#include 
#include 
#include 

using namespace std;

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

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

②子矩阵的和

算法

代码

#include 

using namespace std;

const int N = 1010;

int a[N][N];
long long s[N][N];
int n, m, 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];
            s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + a[i][j];
        }
    }
    
    while (q --)
    {
        int x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;
        
        long long res = s[x2][y2] - s[x2][y1 - 1] - s[x1 - 1][y2] + s[x1 - 1][y1 - 1];
        cout << res << endl;
    }
    return 0;
}

③差分

算法

代码

#include 
#include 

using namespace std;

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

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

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

④差分矩阵

算法

代码

#include 

using namespace std;

const int N = 1010;

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

int main()
{
    cin >> n >> m >> q;
    for (int i = 1; i <= n; i ++)
    {
        for (int j = 1; j <= m; j ++)
        {
            cin >> a[i][j];
        }
    }
    
    while (q --)
    {
        int x1, y1, x2, y2, c;
        cin >> x1 >> y1 >> x2 >> y2 >> c;
        s[x1][y1] += c;
        s[x2 + 1][y2 + 1] += c;
        s[x2 + 1][y1] -= c;
        s[x1][y2 + 1] -= c;
    }
    
    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] += s[i][j];
            cout << a[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

六、双指针算法

①最长连续不重复子序列

算法

该题使用 j ~ i表示选中的区间
i右移，使用s数组记录选中的数，当选中区间中有重复数字出现时，j右移，当选中区间没有重复数字时j停止移动
区间的长度为i - j + 1

代码

#include 
#include 
using namespace std;

const int N = 100010;

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

int main()
{
    cin >> n;
    for (int i = 0; i < n; i ++) cin >> a[i];
    
    int res = 0;
    
    int i, j = 0; //i是区间右端点，j是区间左端点
    for (; i < n; i ++)
    {
        s[a[i]] ++; //i指针后移一位，并计数
        while (s[a[i]] > 1) //如果a[i]之前出现过，则右移j指针直到a[i]只计数过一次
        {
            s[a[j]] --;
            j ++;
        }
        res = max(res, i - j + 1);
    }
    cout << res;
    return 0;
}

②数组元素的目标和

算法
由于两个数组均是有序递增
因此i只需要从小到大不断右移
如果a[i] + b[j] > x ，则不断左移j，当j停止移动时，a[i] + b[j] 只有可能等于或小于x ，如果是小于，再右移i，增大a[i]即可。
代码

#include 
#include 
#include 

using namespace std;

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

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

③判断子序列

算法
遍历一遍b数组，如果能够顺次找到a中的每一个数字，则存在子序列
代码

#include 
#include 
#include 

using namespace std;

const int N = 100010;

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

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) puts("Yes");
    else puts("No");
    return 0;
}

七、位运算(二进制数中1的个数)⭐

算法

代码

#include 

using namespace std;

const int N = 100010;

int n;

int lowbit(int x) //返回x最后一个1构成的整数
{
    return x & -x;
}
int main()
{
    cin >> n;
    
    while (n --)
    {
        int x;
        cin >> x;
        
        int res = 0;
        while (x) x -= lowbit(x), res ++; //语句写在一行，用逗号分隔，不会报错
        cout << res << " ";
    }
    return 0;
}

八、离散化( 区间和)⭐

算法

代码

#include 
#include 
#include 
#include 

using namespace std;

const int N = 300010; //将操作点以及查询点全部离散化
typedef pair <int, int> PII;

int a[N], s[N];
vector <int> alls; //存储所有点
vector <PII> add, query;

int find(int x) //寻找大于等于x的第一个数的下标映射
{
    int i = 0, j = alls.size() - 1;
    while (i < j)
    {
        int mid = i + j >> 1;
        if (alls[mid] >= x) j = mid;
        else i = mid + 1;
    }
    return i + 1; //将下标映射从1开始
}

int main()
{
    int n, m;
    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);
    }
    
    //对alls去重
    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;
}

九、区间合并

算法
将所有区间按照左端点从小到大进行排序
依次遍历所有区间
如果该区间的左端点大于前面总区间的右端点最大值，则res ++
每次都要更新右端点的最大位置
代码

#include 
#include 
#include 
#include 

using namespace std;

const int N = 100010;

typedef pair <int, int> PII;

vector <PII> alls;
int main()
{
    int n;
    cin >> n;
    
    for (int i = 0; i < n; i ++)
    {
        int l, r;
        cin >> l >> r;
        alls.push_back({l, r});
    }
    
    sort(alls.begin(), alls.end());
    
    int p = -2e9;
    int res = 0;
    for (auto item : alls)
    {
        if (item.first > p)
        {
            res ++;
        }
        p = max(p, item.second);
    }
    cout << res;
    return 0;
}