模板：C++语言相关

C++语言相关

开栈

c++

#pragma comment(linker,"/STACK:102400000,102400000")

g++

一定要最后写一句exit(0);退出程序，否则会得到非零退出的错误，可能RE。

int size=256<<20;//256MB
char *p=(char*)malloc(size)+size;
__asm__ __volatile__("movq %0, %%rsp\n"::"r"(p));//64bit

读入优化

仿C++IO流沙雕版

使用前对比使用后。

struct Istream
{
    char b[20<<20],*i,*e;//20MB
    Istream(FILE* in):i(b),e(b+fread(b,sizeof(*b),sizeof(b)-1,in)) {}
    bool eof()const
    {
        return i==e;
    }
    Istream& operator>>(long long &val)
    {
        return val=strtoll(i,&i,10/*进制，取值2~36*/),*this;
    }
    Istream& operator>>(ll &val)//极限快
    {
        while(*i<'0')++i;//无符号
        for(val=0; *i>='0'; ++i)val=(val<<3)+(val<<1)+*i-'0';
        return *this;
    }
    Istream& operator>>(double &val)
    {
        return val=strtod(i,&i),*this;
    }
    Istream& operator>>(string &s)
    {
        while(!eof()&&isspace(*i))++i;
        for(s.clear(); !eof()&&!isspace(*i); ++i)s+=*i;
        return *this;
    }
} kin(stdin);
#define cin kin

C文件指针版

ll getll(FILE* in=stdin)
{
    ll val=0,sgn=1,ch=getc(in);
    for (; !isdigit(ch)&&ch!=EOF; ch=getc(in))
        if(ch=='-')sgn=-sgn;
    for (; isdigit(ch); ch=getc(in))
        val=val*10+ch-'0';
    return ungetc(ch,in),sgn*val;
}
double getd(FILE* in=stdin)
{
    double val=getll(in),p=val<0?-1:1;
    ll ch=getc(in);
    if(ch=='.')
        for(ch=getc(in); isdigit(ch); ch=getc(in))
            val+=(p/=10)*(ch-'0');
    return ungetc(ch,in),val;
}

运算符优先级

算法库

a为容器时直接传迭代器；a为数组，那么beg变成a，end变成a+m，其中m为a的大小（即传地址）。

//用排序sort、去重unique、二分查找lower_bound实现离散化
sort(beg,end);
int n=unique(beg,end)-beg;//离散化后元素个数，vector可直接resize
int k=lower_bound(beg,beg+n,w)-beg;//k为经排序后原来的元素w离散化后对应的值（从0开始）

//以下算法，用于求给定区间的后一\前一字典序排列，不存在返回0，存在返回1
next_permutation(beg,end);
prev_permutation(beg,end);

nth_element(beg,beg+n,end);//将第n大的元素放在第n位，并且比其小的元素都在它前面，比它大的元素都在后面，线性，但不保证有序
max_element(beg,end);//最大值地址
min_element(beg,end);//最小值地址

copy(beg,end,beg2);//指定区间拷贝到beg2开始的地址，需要保证空间足够
fill(beg,end,val);//区间赋值，比memset安全
reverse(beg,end);//区间翻转

容器库/数据结构

struct tm，time_t，mktime

pair

迭代器

顺序容器

c.insert(p,n,t);//在迭代器p指向的位置插入n个值t，原有元素后移；vector、deque很慢
c.insert(p,b,e);//在迭代器p指向的位置插入元素区间[b,e)，原有元素后移；[b,e)不能指向c；vector、deque很慢

p=c.erase(p);//删除迭代器p指向的元素，并返回被删元素后面一个元素的迭代器；若p为end，则返回值也为end；vector、deque很慢
p=c.erase(b,e);//删除[b,e)内元素，其余同上

string

string也属于顺序容器，用法（以及后台的实现）与vector<char>相当。string还附带其他操作：

string s1("c_stri");//用c_string初始化
string s2(s1,pos,n);//用s1从pos位开始的n个初始化s2，n省略时到末尾

s1.substr(pos,n);//s1从pos位开始的n个字符构成的子串，n省略时到末尾

//以下均为查找函数均为O(N*N)的暴力查找而非匹配算法，其中args均为s2,pos，代表从pos开始查找s2，s2亦可为单个字符，pos默认0；不存在返回一个值s.npos
s.find(args);//第一个args
s.rfind(args);//最后一个args，即反向查找
s.find_first_of(args);//s中args任意一个字符第一个出现的位置
s.find_last_of(args);//最后一个
s.find_first_not_of(args);//s中非args中任意一个字符第一个出现的位置
s.find_last_not_of(args);//最后一个

s1+s2;//返回s1尾部缀上s2的结果
s1+=s2;//s1=s1+s2

< > <= >= == !=//比较字典序

关联容器

//初始化，其中T、T1都要是支持<运算符的类型
set<T> s,s1(beg,end);
multiset<T> ms,ms1(beg,end);
map<T1,T2> m;
multimap<T1,T2> mm;

//自定义排序的初始化，以set为例，传一个比较类进去
strcut Cmp
{
    bool operater()(const T &t1,const T &t2)
    {
        return t1>t2;
    }
};//这个Cmp其实就是greater<T>
set<T,Cmp> s2;

_s.insert(t);//s或ms中插一个t
_m.insert(make_pair(t1,t2));//m和mm插入需要插入一个pair

p=c.begin();//获得c的首迭代器，指向c最小的元素，效率O(logN)；insert操作后失效，需要重新获得
p=c.end();//c的尾迭代器，指向c最大的元素后一位，效率O(logN)；insert操作后失效，需要重新获得
//对于map和multimap的迭代器，解引用之后是一个pair

++p;--p;//移动迭代器，效率O(logN),移动到边界后不再移动

c.erase(t);//删除值为t的所有元素，map类的t为pair，返回实际删除元素的数量
q=c.erase(p);//删除迭代器p指向的元素，返回后一个位置的迭代器
q=c.erase(beg,end);//返回[beg,end)返回end

m[t1];//m中下标为t1的索引，若不存在则会执行T2的默认初始化，可能会插入新元素所以m不能为const；否则应使用find代替；mm不支持

c.count(t);//返回c中元素t的数量，不存在为0，非multi容器最多为1
c.find(t);//返回c中第一个值为t的迭代器，不存在返回c.end();
c.lower_bound(k);//指向第一个不小于k元素的迭代器，不存在返回c.end()
c.upper_bound(k);//指向第一个大于k元素的迭代器，不存在返回c.end()
c.equal_range(k);//返回一个迭代器pair表示值为k的元素的范围，不存在均为c.end()
//map和multiset中参数t均表示第一关键字