ACM常用模板

前言

注意事项：

1、当需要读取大量的数据，推荐使用scanf printf

2、字符串最好使用char []来存储，不要用string，否则可能会占用大量内存及减低速度

常用头文件

#define _CRT_SBCURE_NO_DEPRECATE
#include <bits/stdc++.h>
#include <iostream>
#include <algorithm>
#include <functional>
#include <set>
#include <cmath>
#include <queue>
#include <stack>
#include <vector>
#include <string>

 
typedef long long ll;
const int INF = 0x3f3f3f3f;
std::ios::sync_with_stdio(false);

STL常用方法

void iterator () {    // 获取迭代器
    容器::iterator it;
    it = 容器.begin();
    it = 容器.end();
    容器::reverse_iterator it;
    it = 容器.rbegin();
    it = 容器.rend();
}
void funtion() {
    
    transform(begin, end, begin, ::toupper); // 转换大写
    transform(begin, end, begin, ::tolower); // 转换小写

    lower_bound(begin, end, num);    // 返回第一个符合条件的地址
    upper_bound(begin, end, num);    // 返回最后符合条件的地址
    upper_bound(begin, end, num, greater<int>());// 从大到小排序后

    assign(begin, end);        // 赋值给调用者
    copy(begin, end, begin);   // 拷贝
    fill(begin, end, num);     // 用num填充数组
    
    count(bengin, end, num);        // 返回指定元素出现的次数
    count_if(begin, end, func);     // 返回指定条件元素出现的次数
    equal(begin, end, begin, func); // 判断指定条件下是否相等
    find(begin, end, num);          // 查找一个元素
    search(begin, end, begin, end); // 在第一个序列中查找第二个序列
    search_n(begin, end, n, num);   // 查找n个连续的num
      
    
    remove(begin, end, num); // 删除所有值为num的元素 
    erase(begin, end);       // 删除区间元素   
    sort(begin, end);        // 排序
    swap(num, num);          // 交换
    reverse(begin, end);     // 反转
    next_permutation(begin, end); // 下一排列
}


bitset<n> a(10);           // 将10进制转化为n位二进制数
itoa(int n,char* s,int r)  // 将10进制n转换为r进制并赋给s

STL序列容器

// vector是顺序容器，支持随机访问
void vector() {
    vector<int> v;
    v.push_back(); // 尾部插入
    v.pop_back();  // 弹出最后一个元素
    v.at();        // 返回编号位数据
    v.insert();    // 指定位置插入
    v.front();     // 返回第一个元素
    v.back();      // 返回最后一个元素
    v.resize();    // 重置大小
    v.clear();     // 清空容器
    v.empty();     // 判断是否为空
    v.size();      // 返回容器大小
    v.swap();      // 与另一个vector交换数据
}

// list中的数据元素是通过链表指针串连成逻辑意义上的线性表
void list() {
    list<int> l;
    l.push_front();
    l.push_back(); 
    l.front();
    l.back();
    l.pop_front();
    l.pop_back();
    l.remove();   // 删除指定数值
    l.merge();    // 合并两个list
}

// deque双端队列
void deque() {
    deque<int> d;
    d.push_front();
    d.push_back();
    d.insert();
    d.at();
    d.front();
    d.back();
    d.pop_front();
    d.pop_back();
}

STL容器适配器

// queue队列
void queue() {
    queue<int> q;
    q.push();
    q.pop();
    q.front();
    q.back();
    q.empty();
    q.size();

}

// priority_queue 优先队列
void priority_queue() {
    // 与队列一样，特性是队列中最大(小)的元素总是位于队首
    // greater从小到大 less从大到小
    priority_queue<int,vector<int>,greater<int>> q;
    q.top();    // 相当于队列的front()
}

// stack栈
void stack() {
    stack<int> s;
    s.push();
    s.top();
    s.pop();
    s.empty();
    s.size();
}

STL关联式容器

typedef pair<int,int> P;

// set / multiset: multiset中值可以重复出现
void set() {
    set<int> s;
    s.insert();
    s.count();
    s.find();
}

// map / multimap: multimap允许重复元素
void map() {
    map<int,int> m;
    m[1] = 1;
    m.insert(P(1,1));
    m.insert(map<int,int>::value_type(1,1));
    m.keySet();
    map.get(key);
}

尺取法

int chiqu() {
    int l = 0,r = 0;
    int ans = 0,len = MAXN;
    while(true)
    {
        while(r <= n && ans < S)
            r ++,ans += num[r];
        if(ans < S)  break;
        len = min(len,r - l + 1);
        ans -= num[l ++];
    }
    return len < n ? len : 0;
}

模拟退火算法

/*==================================================*\ 
 | J(y)：在状态y时的评价函数值
 | Y(i)：表示当前状态， Y(i+1)：表示新的状态
 | r： 用于控制降温的快慢
 | T： 系统的温度，系统初始应该要处于一个高温的状态
 | T_min ：温度的下限，若温度T达到T_min，则停止搜索
\*==================================================*/

while( T > T_min ) {
　　dE = J( Y(i+1) ) - J( Y(i) ) ; 

　　if ( dE >=0 ) //表达移动后得到更优解，则总是接受移动
       Y(i+1) = Y(i) ; //接受从Y(i)到Y(i+1)的移动
　　else {
      // 函数exp( dE/T )的取值范围是(0,1) ，dE/T越大，则exp( dE/T )也
      if ( exp( -dE/T ) > random( 0 , 1 ) )
      Y(i+1) = Y(i) ; //接受从Y(i)到Y(i+1)的移动
　　}
　　T = r * T ; //降温退火 ，0<r<1 。r越大，降温越慢；r越小，降温越快
　　// 若r过大，则搜索到全局最优解的可能会较高，但搜索的过程也就较长。
    //若r过小，则搜索的过程会很快，但最终可能会达到一个局部最优值
　　i ++ ;
}

 

代码多源于网络，更多模板