c++ 常用算法 函数 代码段 整理大全csp pat acm

常用函数

字符串处理函数

String to_string(Type)
// 强制转换为string类型
str.substr(beginpos，length)
// 返回str字符串，从beginpos往后length长度的子串
str.length()
// 返回字符串长度
int stoi (const string& str, size_t* idx = 0, int base = 10);
// 在头文件<string>中，相同的还有stol，string to long
// str:表示所要转化的字符串
// idx:表示想要str中开始转化的位置，默认为从第一个字符开始。
// base:表示要用的进制（如2进制、16进制，默认为10进制）转化为int类型十进制数字。
// int a = stoi("111",nullptr,2);
// a=7
char*itoa(int value,char*string,int radix)
// int to string ，有一些编辑器可能不认这个，则需要自己写int转换string
string itos(int n,int d){
    string result="";
    do{
        if(n%d>=10){
            result+='a'+n%d-10;
        }
        else{
            result+=to_string(n%d);     
        }
        n=n/d;
    }while(n!=0);
    reverse(result.begin(),result.end());
    return result;
}
// 自己写的itos，可以配合stoi使用了
const char *p = str.c_str()
// string 转化为 char*
string str = p;
// char* 转string
for 循环 赋值char[]
// string转char[]
string str  = char[];
// char[]转string,直接赋值

isdigit(char c)
// 判断c是否是数字

map

#include <unordered_map>
// 只想用map实现hash，不需要排序，使用unordered的
unordered_map <string,int>m;
m["abc"]++;
// map 可以直接判断是否存在
map["a"]==0 
// a不存在

map<int,double,greater<int>> p;
// 创建时可以通过greater<int>排序，默认key值从小到大
map<int,double,greater<int>>::iterator it = p.begin()
// 获取迭代器
it=p.erase(it);
// 根据迭代器删除元素，注意在循环结构中谨慎使用，返回值为下一个迭代器
// 也可以传入key值参数
it->first
// 获取元素的first值，seconda值
 polysum.find(key)!=polysum.end()
 // 查找元素是否存在，若存在，返回具体位置的迭代器，不存在，返回end
 // map 的遍历
unordered_map<int,vector<int>>::iterator it=course.begin();
    while (it!=course.end())
    {   
        it++;
    };

vector

vector<int> v(n);
// 初始化n个元素
v.push_back(type)
// 将元素存入最后一个
v.pop_back()
// 删除最后一个元素
// vector 没有find，count函数，通过algorithm实现
find(v.begin(),v.end(),item)
// 返回迭代器指针 vector<int> it = XX;
count(v.begin(),v.end().item)
// vector 多元素排序
// 使用结构体存储，重定义cmp函数，使用sort函数排序
struct node {
    string t;
    int value;
};
bool cmp(const node &a, const node &b) {
    return a.value != b.value ? a.value > b.value : a.t < b.t;
}
// 如果value相等，降序比较value，不等，比较t，且升序
vector<node> v(n);
v.push_back({"abc",1})// struct 可以直接{}存储
sort(v.begin(), v.end(),cmp);
// algorithm 库

set

// set 是集合，特点是无序，唯一，可以做数学上的集合操作
#include<set>
set<int> s;
s.insert(1);
s.insert(2);
s.insert(1);
s.size()
// 2

迭代器

for (auto it = n.rbegin(); it != n.rend(); it++)
// 倒序遍历
for (auto it = n.begin(); it != n.end(); it++)
// 正序遍历
*max_element(n.begin(), n.end())
// 找最大值的迭代器对应的元素
reverse(result.begin(),result.end());
// 字符串翻转

输入输出

#include <iomanip>
cout << fixed << setprecision(1)
// 控制输出小数点位数
printf("abc%d%s/n",n,str.c_str())
// string 类不能直接输出，需要转char
printf("%.2f", totalPrice);
// 输出两位小数的double类型数

数组

//数组赋值 有fill和memset两种方式，fill包含在头文件algorithm
fill(first，last，value);
// 一维数组int a[10]
fill(a,a+10,2)
// 二维数组int a[10][10]
fill(a[0],a[0]+10*10,2)
max_element（begin,end）
// 返回最大元素的索引指针，begin，end分别为数组的搜索起始指针和结束指针，
int data[10]
value *= *max_element(data+i*3,data+i*3+3);
// value 乘上data+i*3,data+i*3+3范围内的最大值
string name=word[max_element(data+i*3,data+i*3+3)-data-i*3];
// 获得最大值的索引，指针之间可以相减
int a[10009] = {0}; 
// 用0初始化
find(a,a+10,2)
// 找到返回指针，找不到返回最后的指针，判断可以使用a+10为最后的指针，索引可以通过指针相减方式求得

数学

#include<cmath>
pow(a,b)
// a 的 b次方

常用算法结构

dfs

深度优先搜索

void dfs(int cur, int dis) 
//cur-当前所在城市编号，dis-当前已走过的路径
{
    if(dis > mindis) return; //若当前路径已比之前找到的最短路大，没必要继续尝试（一个小优化，可以不写）
    if(cur == c2) //当前已到达目的城市，更新min
    {
        if(dis < mindis) 
        {
            mindis = dis;
        }      
        return;
    }
    
    for(int i = 1; i < n; i++) //对1~n号城市依次尝试
    {
        if(roads[cur][i] != inf && mark[i] == 0) 
        //若cur与i可达，且i没有在已走过的路径中
        {
            mark[i] = 1; //标记i为已在路径中
            dfs(i, dis+roads[cur][i]); //继续搜索
            mark[i] = 0; //对从i出发的路径探索完毕，取消标记
        }
    }
}

判断质数

bool isPrime(int n) {
    if (n == 0 || n == 1) return false;
    for (int i = 2; i * i <= n; i++)
        if (n % i == 0) return false;
    return true;
}

int转string

// An highlighted block
string itos(int n,int d){
    string result="";
    do{
        if(n%d>=10){
            result+='a'+n%d-10;
        }
        else{
            result+=to_string(n%d);     
        }
        n=n/d;
    }while(n!=0);
    reverse(result.begin(),result.end());
    return result;
}

排序

// 数组排序
int group[1005];
bool cmp (int x,int y){
    return x>y;
}
sort(group,group+1005,cmp);

// vector 排序
vector<int> a;
sort(a.begin(), a.end());

//vector 结构体排序
struct node{
int value;
int number;
};
vector<node> v;
bool cmp(const node& n1,const node& n2){
	return (n1.value!=n2.value)?n1.value>n2.value:n1.number<n2.number;
}
sort(v.begin(),v.end(),cmp)

常用思想

1. 使用find函数，每次需要什么找什么索引的方式，不方便会很慢，尝试增加一个数组来记录每个元素的下标，O（n）
2. hash思想，大意就是，使用一个额外的数组，保存当前已有的数据的个数，使其可以快速得出是否已有某些数据
3. set可以用来保存互斥的元素，用作直接计数（互斥总数）
4. map是键值对映射，会自动排序，可以用做hash，直接++，默认为0（也可以利用此来判断是否存在及hash，hash还可以使用大数组的方式（如果键值是int或者字符型））
5. 链表注意，遍历的时候不能漏掉最后一个
6. 贪心算法，注意，一要把每一次选择封装成一个状态，使得每一次开始和结束都能用同样的方式来处理，二要确定问题是有局部最优解导出的全局解，这类问题一般有不可逆性，如汽车加油，背包装东西，安排活动（占场地，时间）
7. 并查集 核心是对元素进行分类，类似链表一样，维护一个当前元素的父元素，而比较方法就是不断的找两个元素的父元素，判断他们是否是一个组，合并也是找两个父元素合并
8. 并查集带来的问题是，如何优化，优化方式有，第一，把一次搜索中，所有节点的父节点都变成根节点，这叫路径压缩，或者第二，使用树的深度来进行合并