Most of them need to add header files #include < cmath > or #include < algorithm >
List of common functions:

swap(nums[i], nums[ptr]); //Exchange function
max(merged.back()[1], R); //Size comparison selection
max_element(myvector.begin(),myvector.end());//Returns the iterator of the largest element in the vector. Note that the iterator is returned and the header file is algorithm
reverse(ans.begin(), ans.end());//Answer reversal
rand Function, C A function used to generate a random number in a language.
sqrt(5); //Root 5
pow(a,2); //Square of a
num = abs(num);//Take the absolute value. abs is for int type
//The distance() function calculates the number of elements in the range represented by the two iterators
rand();  //Returns an arbitrary integer from 0 to the maximum random number
int result = accumulate(nums.begin(), nums.end(), 0);//Sequence summation

reverse function

The function is reverse order (or reverse), which is mostly used for strings, arrays and containers. The header file is #include < algorithm >
The reverse function is used to reverse the order within the range of [first, last] (including the elements pointed to by first, excluding the elements pointed to by last). The reverse function has no return value.
give an example:

string str="hello world , hi";
reverse(str.begin(),str.end());//str result is IH, dlrow olleh
vector<int> v = {5,4,3,2,1};
reverse(v.begin(),v.end());//The value of container v becomes 1,2,3,4,5

max_element() find the maximum value

Header file: #include < algorithm >
Returns the iterator pointing to the maximum value in the [front closed and back open) sequence interval. If the output value is, an asterisk should be added in front of max_element, and the third parameter cmp can be written or not.
max_element() and min_element() is arranged from small to large by default, and then
max_element() outputs the last value, min_element() outputs the first value. If the custom cmp function is arranged from large to small, it will lead to max_element() and min_ The two results of element () are reversed.
It can be used for vector < int > or vector < string >, int arr[4] or string arr[4], or structure vector or structure array.
Usage example:

int a[5] = {0, 3, 9, 4, 5};
int *b;
b = max_element(a, a+5);
cout << *b;
//Also applies to vectors
vector<int> myvector;
vector<int>::iterator it;
it = max_element(myvector.begin(),myvector.end());
cout<<*max_element(myvector.begin(),myvector.end());
//Or write a comparison function as the third parameter
static bool cmp(int& a, int& b)
{
	return abs(a)<abs(b);
}
it = max_element(myvector.begin(),myvector.end(),cmp);	
cout<<*it<<end;

abs() absolute value function

abs function of C language:

#include <stdio.h>
#include <stdlib. h> / / use this header file
//abs is an absolute value for int type
num = abs(num);
//Use labs() for long type
long b=-2;
b = labs(b);
//For float, double type
float d = -4.12;         
//The total significant digits of float are generally 7, for example, 12.34, and the total significant digits are 5
d = fabs(d);

C++ abs can naturally support integer and floating-point numbers, which are defined in the cmath header file, \include <cmath>
[note] math H is the header file of C language. In C + +, use math H is also OK. C + + is compatible with C. However, it is recommended to use #include < cmath >, but this must be declared in the std namespace: using namespace std; The functions and methods of use are almost identical.

distance() calculates the number of elements

The distance() function is defined in the #include < iterator > header file and in the std namespace. It is used to calculate the number of elements contained in the range represented by the two iterators. This function returns the number of elements contained in the [first, last] range.

int num = distance (InputIterator first, InputIterator last);
//Create an empty list container
list<int> mylist;
//Add elements 0 ~ 9 to the empty list container
for (int i = 0; i < 10; i++) {
    mylist.push_back(i);}
//Gets the number of elements contained in the [first,last) range
 cout << "distance() = " << distance(mylist.begin(), mylist.end());
//distance() = 10

INT_MAX/MIN max min integer

Constant int in C + +_ Max and INT_MIN represents the maximum and minimum integers respectively.
Header file #include < clips >
For example, if you want to assign a maximum initial value to a variable, you can do the following:

int indexSum = INT_MAX;

Because int occupies 4 bytes and 32 bits, according to the rules of binary coding, INT_MAX =   2 31 − 1   \ 2^{31}-1\,  231−1
，INT_MIN=   − 2 31   \ -2^{31}\,  −231
#define INT_MAX 2147483647
#define INT_MIN (-INT_MAX - 1)
C + + integer upper and lower limits INT_MAX INT_MIN and its operation

next_permutation() array full permutation

In addition to the functions in the standard c + + library, it can also be implemented in a recursive way_ Permutation() and prev_permutation() function. Their header file is #include < algorithm >.
The function has two formal parameters, one is the address of the first element of the sequence, and the other is the address of the last element of the sequence. The return value is bool type. When the full permutation reaches the last case, it returns false, otherwise it returns true.
Note: use next_ Permutation (first address, last address) the sequence for Full Permutation must start with the smallest dictionary permutation (i.e. from small to large).
prev_permutation() function requires that the original sequence of numbers must be arranged from large to small.
Therefore, these two library functions are generally used in combination with the sort() function
Examples are as follows:

//46. Full arrangement
vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int> > ans;
        sort(nums.begin(),nums.end());//From small to large
        ans.emplace_back(nums);
        while(next_permutation(nums.begin(),nums.end()))
        {
            ans.emplace_back(nums);
        }
        return ans;
    }

If the array int a[] = {3,2,1} arranged from large to small; For full permutation, you need to use while (prev_permutation(a, a+3)).
It should be noted that the full arrangement starts from the next arrangement of the current array, and the current array needs to be output and saved in advance.

The full arrangement is realized by backtracking recursion. The input is nums array and the full arrangement is output:

//46. Full arrangement
void backTrace(vector<vector<int> >& ans, vector<int>& nums, int index, int n)
    {
        // All the numbers have been filled in
        if(index==n)
        {
            ans.emplace_back(nums);
            return ;
        }
        for(int i=index;i<n;++i)
        {
            // Dynamically maintain the array, fill in any number of the current index position and subsequent positions, and exchange them,
            //This allows you to select only the unused numbers on the right at a time
            swap(nums[index],nums[i]);
            // Continue to fill in the next number recursively
            backTrace(ans,nums,index+1,n);
            // Undo the operation, switch back to the current number and prepare to change to the next number
            swap(nums[index],nums[i]);
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int> > ans;
        int n = nums.size();
        backTrace(ans, nums, 0, n);
        return ans;
    }

rand() random number function

Header file #include < cstdlib >
1) rand() does not require parameters, it returns an arbitrary integer from 0 to the maximum random number.
The internal implementation of rand() is realized by linear congruence method. It is a pseudo-random number. Due to the long period, it can be regarded as random in a certain range.

2) If you want to generate a random integer from 0 to 99, it can be expressed as: int num = rand()% 100;
If 1 ~ 100 is to be generated, it is as follows: int num = rand()% 100 + 1;

In summary, it can be expressed as: int num = rand()% N + A;
Where a is the starting value, n-1+a is the ending value, and N is the range of integers.

3) Generality: rand ()% (B-A + 1) + A; Represents a random integer between a and B.

4) To generate decimals between 0 and 1, you can first obtain integers from 0 to 10, and then divide them by 10 to obtain 10 random decimals of "random to tenths".
If you want to get random decimals from "random to percentile", you need to get 10 integers from 0 to 100, then divide them by 100, and so on in other cases.

5) Before calling the rand() function, you can use srand() function Set the random number seed. If the random number seed is not set, the random number seed will be automatically designed as 1 when the rand() function is called. If the random seed is the same, the random number generated each time will be the same.

srand() initializes random seed

Is the initialization function of the random number generator. Prototype: void srand(unsigned seed);
Usage: it initializes a random seed and provides a seed corresponding to a random number. If the same seed is used, the following rand() function will appear the same random number, such as srand(1); Use 1 directly to initialize the seed. That is, when the parameter value of srand() is fixed, the number obtained by Rand () is also fixed.
However, in order to prevent the random number from repeating each time, the time function is often used to obtain the system time for initialization. At the same time, the program contains a new header file #include < CTime > to let the random seed come from the system clock.
If you want to generate a random number sequence in a program, you need to set the random seed at most once before generating the random number. That is: just call srand((unsigned)time(NULL)) at the beginning of the main program; Just use rand in the back.
For example:

#include <iostream>
#include <cstdlib> // Header file needed to use srand and rand
#include <ctime> // Header file needed to use time
using namespace std;
void test_rand(void)
     {
           unsigned long n;
          srand((unsigned)time(NULL));
          for(int i = 0; i < 100; i++)
          {
                n = rand();
                printf("d\n", n);
           }
}
Or call time Function must be passed an argument 0:
int main()
{
    unsigned seed;  // Random generator seed
    // Use the time function to get a "seed" value for srand
    seed = time(0);
    srand(seed);
    // Now generate and print three random numbers
    cout << rand() << " " ;
    cout << rand() << " " ;
    cout << rand() << endl;
    return 0;
}

accumulate() accumulation function

Header file #include < numeric >
Adds a number from beginning to end, or performs an operation using a specified operator.
Calculate (first, last, initial value, operation); Four parameters: the starting address of the accumulated element; The end address of the accumulated element and the initial value of the accumulation (usually 0); The fourth parameter is the operation to be performed. It is cumulative by default.
Common summation examples:

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

int main() {
    vector<int> nums = {1, 2, 3, 4, 5};
    int result = accumulate(nums.begin(), nums.end(), 0);
    cout << result << endl; //result = 15    
    return 0;
}

When summing, accumulate takes three formal parameters: the starting address of the accumulated element; The end address of the accumulated element and the initial value of the accumulation (usually 0).
For example:

int list[10] = { 1,2,3,4,5,6,7,8,9,10 };
sum= accumulate(list, list+10, 0) ; //sum=55

When calculating the continuous product, calculate takes four formal parameters: the starting address of the element of continuous multiplication; The end address of the element of concatenation, the initial value of concatenation (usually 1), and the operation of multiples < int > ()

con_product= accumulate(list, list+3, 1, multiplies<int>()) ;//sum=6

Merge string

 vector<string>a{"1","-2345","+6"};
string a_sum=accumulate(a.begin(), a.end(),string("out: "));//Get out: 1-2345+6

Tower() capital to lowercase

Header file: #include < stdlib h>
Function: returns converted lowercase letters. If no conversion is required, the parameter value will be returned

#include <cstdlib>
int main()
{
    char s[] = "aBcDeFgH12345;!#$";
    printf("before tolower() : %s\n", s);
    //before tolower() : aBcDeFgH12345;!#$
    for(int i = 0; i < sizeof(s); i++)
    {
        s[i] = tolower(s[i]);
    }
    printf("after tolower() : %s\n", s);  
    //after tolower() : abcdefgh12345;!#$   
    return 0;
}

toupper() convert lowercase to uppercase

Convert lowercase letters to uppercase letters.
Declaration of toupper() function:

int toupper(int c);

If c has a corresponding capital letter, the function returns the capital letter of c, otherwise c remains unchanged. The return value is an int value that can be implicitly converted to char type.

The transform(first,last,result,op) operation works on each element

Applies an action to each element of the specified range.
The commonly used overloaded function versions are: transform(first,last,result,op);
Among them, first is the first iterator of the container, last is the last iterator of the container, result is the container where the results are stored, and op is the unary function object to be operated (such as:: tower or:: Tower) or sturct and class.

For example, use the transform function to rewrite the lowercase letters in a given string into uppercase letters, and save the result in an array called second. The content of the original string remains unchanged.

#include <iostream>
#include <algorithm>
using namespace std;
char op(char ch)
{
    if(ch>='A'&&ch<='Z')
        return ch+32;
    else
        return ch;
}
int main()
{
    string first,second;
    cin>>first;
    second.resize(first.size());
    transform(first.begin(),first.end(),second.begin(),op);
    cout<<second<<endl;
    return 0;
}

Of course, you can use existing function objects (such as:: toupper or:: Tower) to simplify and save the results to the str string itself.

string str;  cin>>str;
transform(str.begin(), str.end(), str.begin(), ::toupper);//Capitalize
transform(str.begin(), str.end(), str.begin(), ::tolower);//Convert to lowercase

isalpha() determines whether it is a letter

Header file: #include < ctype h>
Function declaration: int isalpha(int c);
Return value: if c is a letter, the function returns a non-zero value; otherwise, it returns 0.
Usage example:
If str[i] is a letter, it becomes a lowercase letter

	if (isalpha(str[i])) 
    {
        word.push_back(tolower(str[i]));//Convert to lowercase
     } 

isdigit() determines whether to use decimal numbers

Header file: #include < ctype h>
Declaration: int isdigit(int c);
Return value: if c is a number, the function returns a non-zero value; otherwise, it returns 0.

isalnum() determines whether letters or numbers

Check whether the transmitted characters are letters and numbers
Declaration: int isalnum(int c);
Return value: if c is a number or a letter, the function returns a non-zero value; otherwise, it returns 0.

islower() determines whether lowercase letters

Check whether the characters passed are lowercase letters.
Declaration: int islower(int c);
Return value: if c is a lowercase letter, the function returns a non-zero value (true), otherwise it returns 0 (false).

isupper() determines whether capital letters are used

Check whether the characters passed are capital letters
Declaration: int isupper(int c);
Return value: if c is an uppercase letter, the function returns a non-zero value (true), otherwise it returns 0 (false)