【ICPC备战||Day2】基础算法

Content：

1. 对昨天题目的补充；

2. 排序

3. 二分

4. Conclusion

Part1 对昨天题目的补充

第一题是一道有关STL的好题：

输入一组数字（可能包含重复数字），输出其所有的排列方式

对于这道题，应该调用next_permutation的函数，这个函数可以判定是否为倒序排列，若不是，则会进行倒序操作，因此我们可以从刚开始进行sort正向排列，随后不断地将进行倒序排列操作后的nums序列push_back，在不断进行next_permutation直至最终形成完全倒序，也就得到了我们想要的所有排序可能。

class Solution {
public:
    vector<vector<int>> permutation(vector<int>& nums) {
      sort(nums.begin(),nums.end());
      vector<vector<int>> res;
      do
      {
          res.push_back(nums);
      } while(next_permutation(nums.begin(),nums.end()))；
      return res;
      }
};

这种方法的巧妙之处在于，采用了do-while循环，将每次得到的新排序置于vector的最后位，随后再将这个新的vector进行do-while，从而实现不断更新。至于next_permutation的用法，实际上，next_permutation()会取得[first,last)所标示之序列的下一个排列组合，如果没有下一个排列组合，便返回false;否则返回true。而在{a,b,c}这个三元字典当中，abc无疑是最小的，也就是first，acb是第二小的，bac其次，以此类推，最终得到整个排列组合的结果，对于全排列问题，都可以利用sort排序+此函数进行无脑求解。

第二题，找出数组中重复的数字

class Solution {
public:
    int duplicateInArray(vector<int>& nums) {
        int n = nums.size();
        for (auto x : nums)
            if (x < 0 || x >= n)
                return -1;
        for (int i = 0; i < n; i ++ ) {
            while (nums[nums[i]] != nums[i]) swap(nums[i], nums[nums[i]]);
            if (nums[i] != i) return nums[i];
        }
        return -1;
    }
};

这种做法充分利用了数轴思想，本身数组就是一个一一对应的关系，在数组中的各个位置上都不能出现重复的相同元素占据同一位置的情况，因此正好通过nums【x】=x的赋值方式，使每个值都被插入到数组中相应的位置上，这就相当于每个整数在数组中的位置原本就是固定的，如果出现了固定位置上已经被占据而无法插入的情况，刚好也就是重复的数字。

第三题，求出一个整数所对应的二进制中1的个数

经典位运算问题，不再过多赘述

算法一：

class Solution {
public:
    int NumberOf1(int n) {
        int res=0;
       for(int i=0;i<32;i++){
           if(n>>i&1==1)res++;
       }
       return res;
    }
};

算法二：采用lowbits（）函数

lowbit(x) = x & -x，返回x的最后一位

class Solution{
public:
  int Number(int n){
     int res=0;
     while(n) n-=n & -n,res++;
     return res;
}
}

Part2 排序

主要的排序算法分为快排和归并排序。

快排的方式：

先确定分界点；再调整区间，确定左右区间中的元素；最后递归处理左右两段，将左右两端排序完毕

归并排序的方式：

先确定分界点；采用递归的方式使左右两端形成有序序列；最后进行归并，采用双指针方法。

quick sort中的难点：

如何以最快的速度进行调整区间，即在不开辟额外空间的情况下，完成数据的分区。

实现代码：

#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 i = l - 1, j = r + 1, x = q[l + r >> 1];//>>1就相当于除2操作
    while (i < j)
    {
        do i++; while (q[i] < x);
        do j--; while (q[j] > x);//大于、小于x的元素分别进行前置后置操作
        if (i < j) swap(q[i], q[j]);
    }
    quick_sort(q, l, j), quick_sort(q, j + 1, r);//递归
}
int main()
{
    scanf_s("%d", &n);
    for (int i = 0; i < n; i++) scanf_s("%d", &q[i]);
    quick_sort(q, 0, n - 1);
    for (int i = 0; i < n; i++) printf("%d", q[i]);
    return 0;
}

归并排序的难点：

通过双指针的方法将两个数组合并，应在两数组的最前端置一指针，由于这两个数组是已经排序完毕的，因此两个指针所对应的值都应该是数组中的min值，之后指针不断前移，在指针1中遇到比指针2所指向的数更小的数字则前置，否则向后移动，直至比指针2大时，指针2向后移动，如此反复，直至其中一方的指针全部走完成为空数组，另一方中所剩下的元素全部添加至最后即可（因为是两个指针中剩下最大的数了），通过这种方式将数组归并。

#include<iostream>
using namespace std;
const int N = 1e6 + 10;
int n;
int q[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()
{
    scanf_s("%d", &n);
    for (int i = 0; i < n; i++) scanf_s("%d", &q[i]);
    merge_sort(q, 0, n - 1);
    for (int i = 0; i < n; i++) printf("%d", q[i]);
    return 0;
}

注意：递归时，可以将需要递归的函数写在被递归函数内部的任意位置！

Part3 二分

二分算法主要用以提高计算精度，通过不断二分以得到最终结果的过程，分为整数型二分与浮点型二分。

整数型二分：

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

Part4 Conclusion

通过排序和二分的学习，可以得到以下思路和心得：

1. 递归的重要性，确定好递归的条件，递归对象应写在函数括号内，例如在快排过程中不断变化的区间（左右界），但递归函数写在函数内部的位置则并无任何要求。

2. 善用while（）与函数定义的重要性，可以省去许多循环嵌套问题。