【代码模板】不存在的NOIP2016

当年中二，零碎模板

0x01gmath

/*
* 占坑待填 20171004
* Bigint高精度
* 数据结构模板
* 图论算法模板
* 数学完善
*/

//头文件模板
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cctype>
#include<iomanip>
#include<sstream>
#include<cmath>
#include<string>
#include<vector>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<bitset>
#include<list>

using namespace std;

//预处理定义
typedef long long LL;
typedef long double LD;

#define fst first
#define sec second
#define mp make_pair
const int N = 1e5, inf = 1e9;  //代替define的写法 & e计数法的使用

int readint(){  //readint好简单啊为什么。。。
    int x=0, op=1;  char ch = getchar();  //一定要赋初始值
    while(ch < '0' || ch > '9'){ if(ch=='-')op=-1; ch = getchar(); }
    while(ch >= '0' && ch <= '9'){ x=x*10+ch-'0'; ch = getchar(); }
    return x*op;
}

//gmath数学库
//用的时候记得加typedef long long LL;
//int pri[N];
//decom: vector<int>;

//素数
int pri[N];
void get_prime(int n){ //诶氏筛法
    pri[1] = 1;
    for(int i = 2; i*i <= n; i++)if(!pri[i])
        for(int j = 2*i; j <= n; j+=i)
            pri[j] = 1;
}

//数论
LL gcd(LL a, LL b){ return b==0 ? a : gcd(b,a%b); }
LL lcm(LL a, LL b){ return a/gcd(a,b)*b; }
LL exgcd(LL a, LL b, LL &x, LL &y){
    if(!b){
        x = 1, y = 0;
        return a;
    }
    LL r = exgcd(b, a%b, x, y);
    LL t = x;
    x = y;
    y = t-a/b*y;
    return r;
}
/*
vector<int> Decom(int n){ //haveBUG
    int i;
    vector<int>res;
    res.push_back(1);
    for(int i = 2; i <= n; i++){
        if(n == 1)break;
        while(n%i == 0){
            res.push_back(i);
            n /= i;
        }
    }
    if(n)res.push_back(n);
    return res;
}
*/

//快速幂，快速乘
LL mul(LL a, LL b, LL p){
    LL x = 0;
    while(b){
        if(b&1)x=(x+a)%p;
        a = (a<<1)%p;
        b >>= 1;
    }
    return x;
}
LL mul(LL a, LL b){
    LL x = 0;
    while(b){
        if(b&1)x += a;
        a <<= 1;
        b >>= 1;
    }
    return x;
}
LL pow(LL a, LL b, LL p){
    LL x = 1;
    while(b){
        if(b&1)x = mul(x,a,p)%p;
        a = mul(a,a,p)%p;
        b >>= 1;
    }
    return x%p;
}
LL pow(LL a, LL b){
    LL x = 1;
    while(b){
        if(b&1)x = mul(x,a);
        a = mul(a,a);
        b >>= 1;
    }
    return x;
}

//计算几何学
struct Point{ double x, y; }; //点
typedef Point Vector;  //向量
struct Segment{ Point p1, p2; }; //线段
typedef Segment Line;  //直线
class Circle{
    public:  Point c;  double r;
    Circle(Point c = Point(), double r = 0.0):c(c),r(r){}
};
//typedef vector<int> Polygon; //多边形


//排序算法模板
int swap(int &a, int &b){ int t = a; a = b; b = t; }
//冒泡排序
//1.相邻的数据两两比较,小数放前面,大数放后面
//2.这样每一次操作过后最小的数就被排在了最前面
void BubbleSort(int a[], int n){
    for(int i = 1; i < n; i++){ //循环有序数组,每次循环后保证到i位置的值是有序的。
        for(int j = n; j > i; j--) //循环无序数组两两比较
            if(a[j] < a[j-1])swap(a[j],a[j-1]); //如果是逆序对就交换(保证每次把最小的值往前交换)
        //Print(a,n);
    }
}
//插入排序
//1.数据分为两部分,一开始有序部分包含1个元素
//2.依次将无序部分的元素插入到有序部分当中
void InsertSort(int a[], int n){  //直接插入排序
    for(int i = 2; i <= n; i++){ //遍历无序部分,每次取出第一个元素
        int j = i-1, k = a[i];  //j为当前下标, k为无序部分第一个元素
        while(j>=1 && k<a[j]){ //找到k元素在有序部分的位置
            a[j+1] = a[j];    //循环的时候直接右移有序数组,为k腾出位置
            j--;             //不是k正确的位置,继续往前循环
        }
        a[j+1] = k;  //出来的时候j多减了1,要加回去
        //for(int i = 1; i <= n; i++)cout<<a[i]<<" ";  cout<<"
";
    }
}
//选择排序
//1.在未排序序列中找到最小的元素,记录位置
//2.将它放到已排序序列的末尾(和第一个无序元素交换即可)
void SelecSort(int a[], int n){
    for(int i = 1; i <= n; i++){ //对于每一个位置的值(实质是未排序序列的第一个元素)
        int index = i;  //index：记录未排序序列中最小元素的位置
        for(int j = i+1; j <= n; j++) //遍历剩余未排序序列
            if(a[j] < a[index])index = j; //保证index是最小元素的位置
        swap(a[i],a[index]);//将最小的值放到未排序序列的第一个,完成排序
        //for(int i = 1; i <= n; i++)cout<<a[i]<<" ";  cout<<"
";
    }
}
//快速排序
//1.每次选择一个基准数,把比之小的都放到其左边,大的都放到其右边
//2.排放时候的细节
void QuickSort(int a[], int n, int l, int r){
    if(l > r)return ; //递归出口,越界返回
    int k = a[l];//k就是基准数(k的选取与内循环的找数顺序有关)
    int i = l, j = r;//区间
    while(i < j){ //i==j时,两数相遇,
        //顺序有影响,先从右往左找,找到第一个比基准数小的位置
        while(i<j && a[j]>=k)j--;//切记‘>=’(可以忽略掉与k相等的值,不然i永远不会大于j,则死循环)
        //然后从左往右找到第一个比基准数大的位置
        while(i<j && a[i]<=k)i++;
        //如果他们没有相遇,就交换这两个数的位置,并继续寻找
        if(i < j)swap(a[i],a[j]);
    }
    //将基准数归位
    a[l] = a[i];  //相遇的位置
    a[i] = k;    //
    QuickSort(a,n,l,i-1);//递归后不用考虑基准数
    QuickSort(a,n,i+1,r);
}

//数据结构模板
//并查集
struct UnionFindSet{
    int fa[N];
    UnionFindSet(int n){
        for(int i = 1; i <= n; i++)fa[i] = i;
    }
    int find(int x){  return fa[x]==x ? x : fa[x]=find(fa[x]);  }
    void merge(int u, int v){
        int x = find(u), y = find(v);
        if(x != y)fa[x] = y;
    }
    int query(int u, int v){
        return find(u) == find(v);
    }
};

//图论算法模板
struct UndirectedEdge{ //图的边集存储
    int u, v, w;
    UndirectedEdge(){}
    UndirectedEdge(int u, int v, int w): u(u),v(v),w(w){}
    bool operator < (const UndirectedEdge & other)const{
        return w < other.w;
    }
};
//Kruskal
struct Kruskal{
    int n, m;
    UndirectedEdge edges[N];
    inline int kruskal(){
        int sum = 0,  count = 0;
        UnionFindSet ufs(n);  
        std::sort(edges, edges+m);  //对所有边进行排序
        for(int i = 1; i <= m; i++){
            if(ufs.find(edges[i].u) != ufs.find(edges[i].v)){
                ufs.merge(edges[i].u,edges[i].v);
                sum += edges[i].w;
                count++;
                if(count == n-1) break;
            }
        }
        return sum;
    }
};

//有向图强连通分量
namespace Kosaraju{
    int n, m;
    vector<int>G[N], rG[N];
    vector<int>vs, cmp[N];
    int vis[N], book[N], cnt;
    void dfs(int u){
        if(vis[u])return ;
        vis[u] = 1;
        for(int i = 0; i < G[u].size(); i++)dfs(G[u][i]);
        vs.push_back(u);
    }
    void rdfs(int u){
        if(book[u])return ;
        book[u] = cnt;
        cmp[cnt].push_back(u);
        for(int i = 0; i < rG[u].size(); i++)rdfs(rG[u][i]);
    }
};

struct Bigint{
    vector<int>s;
    int is_minus;
    Bigint(long long num = 0, int ok = 1){ *this = num; is_minus = ok;}//构造函数,元素初始值为0
    Bigint operator = (long long num){
        s.clear();
        do{
            s.push_back(num%10);
            num /= 10;
        }while(num > 0);
        return *this;
    }
    Bigint operator = (const string& str){
        s.clear();
        for(int i = str.size()-1; i >= 0; i--)
            if(str[i] == '-')is_minus = -1;
            else s.push_back(str[i]-'0');
    }
    Bigint operator + (const Bigint& b)const{
        Bigint c;  c.s.clear();
        Bigint n = *this, m = b;
        if(n.is_minus==-1 && m.is_minus==1){
            c = m-n;
        }else if(n.is_minus==1 && m.is_minus==-1){
            c = n-m;
        }else {
            if(n.is_minus==-1 && m.is_minus==-1) c.is_minus = -1;
            int x = 0, len = max(n.s.size(),m.s.size());//x是进位
            for(int i = 0; i < len; i++){
                if(len >= n.s.size())n.s.push_back(0);//不够长的话补0
                if(len >= m.s.size())m.s.push_back(0);
                c.s.push_back(n.s[i]+m.s[i]+x);
                x = c.s[i]/10;
                c.s[i] %= 10;
            }
            if(x)c.s.push_back(x);//最高进位
            len = c.s.size()-1;
            while(c.s[len]==0 && len>0)len--;
            c.s.resize(len+1);
        }
        return c;
    }
    Bigint operator - (const Bigint& b)const{
        Bigint n = *this, m = b;
        int ok = 1; //保证被减数大于减数
        if(n.s.size()<m.s.size() || n.s.size()==m.s.size()&&n.s<m.s){
            swap(n.s, m.s);
            ok = -1;
        }
        Bigint c; c.s.clear();
        int len = max(n.s.size(), m.s.size());
        n.s.resize(len); m.s.resize(len); c.s.resize(len);//改变大小自动补0防止内存错误
        for(int i = 0; i < len; i++){
            if(n.s[i] < m.s[i]){
                n.s[i] += 10;
                n.s[i+1]--;
            }
            c.s[i] = n.s[i]-m.s[i];
        }
        len--;//最后一位的坐标
        while(c.s[len]==0 && len>0)len--;//删去多余的0
        c.s.resize(len+1);
        //c.s.back() *= ok;
        c.is_minus = ok;
        return c;
    }
    Bigint operator * (const Bigint& b)const{
        Bigint n = *this, m = b;
        n.s.insert(n.s.begin(),0); m.s.insert(m.s.begin(), 0);
        Bigint c; c.s.clear();
        if(n.is_minus==-1 && m.is_minus==1)c.is_minus = -1;
        if(n.is_minus==1 && m.is_minus==-1)c.is_minus = -1;
        c.s.resize(n.s.size()+m.s.size());
        for(int i = 1; i < n.s.size(); i++){
            int x = 0; //进位
            for(int j = 1; j < m.s.size(); j++){
                c.s[i+j-1] += n.s[i]*m.s[j] + x;//原数+当前乘积+上次乘机进位
                x = c.s[i+j-1]/10;
                c.s[i+j-1] %= 10;
            }
            c.s[i+m.s.size()-1] = x;//进位
        }
        c.s.erase(c.s.begin());
        int len = c.s.size();
        while(c.s[len]==0 && len>0) len--; //删除多余的0
        c.s.resize(len+1);
        return c;
    }
};
istream& operator >> (istream &in, Bigint& x){
    string s;
    if(in>>s) x = s;
    return in;
}
ostream& operator << (ostream &out, const Bigint& x){
    if(x.is_minus == -1)out<<-1*x.s[x.s.size()-1];
    else out<<x.s[x.s.size()-1];
    for(int i = x.s.size()-2; i >= 0; i--)out<<x.s[i];
    return out;
}

0x02STL

//提供了STL的范例

//顺序容器：vector, deque, list
//关联容器：set, map,
//适配容器：stack, queue, priority_queue
#include<iostream>
#include<set>  //基于红黑树
#include<map>  //基于平衡二叉树
#include<vector>  //时间换空间(逃
#include<string> //各种黑科技
#include<bitset>

using namespace std;

//操作整理：声明，插入，删除，查找，遍历
//用法整理：你自己想啊

void setting(){
    set<int>myset; //声明int类型的集合(突然发现重名好像不会炸233333)

    //1. 基本操作
    myset.insert(233);  //往里面添加元素(重复插入无效)
    myset.erase(233);  //删除里面的某个元素(如果不存在该元素则不操作)(这里也可以用迭代器删除区间)
    myset.count(233); //查询集合中是否存在某个元素
    myset.clear();   //清空集合

    //2. 迭代器
    myset.insert(233);  myset.insert(322);
    set<int>::iterator it;  //如果重名声明迭代器的时候会炸掉
    set<int>::reverse_iterator rit; //反向迭代器
    for(it = myset.begin(); it != myset.end(); it++){
        cout<<*it<<" ";
    }
    cout<<"
";
    for(rit = myset.rbegin(); rit != myset.rend(); rit++){
        cout<<*rit<<" ";
    }
    cout<<"
";

    //3. 熟练搞事
    cout<< (myset.find(233)==myset.begin()) <<" 
"; //查找键值的位置并返回迭代器
    cout<< *myset.lower_bound(234)<<"
";  //返回第一个>=key的元素的迭代器
    cout<< *myset.upper_bound(233)<<"
";  //返回第一个>key的元素的迭代器
}

void maping(){ 
    map<int,int>mymap; //左键右值

    //1. 基本操作，，同为关联容器,基本和set差不多吧
    mymap[5] = 7;  //添加元素(注意 "mymap[0];" 同样往map中添加了元素，只是没有赋值而已)

    //2. 迭代器
    map<int,int>::iterator it = mymap.begin();
    cout<<(it->first)<<" "<<(it->second)<<"
"; //map遍历时访问的是pair类型

    //3. 

}

void bitsetting(){

}

void stringing(){
    string str = "123456789";  char ch[110]="233";

    //构造函数
    str = string(ch); //用c语言字符串s初始化
    str = string(5,'c');  //用5个字符c初始化
    string s1 = str;  //赋值操作

    //基本特性
    str.size(); //返回大小

    //各种操作
    str.substr(0, 2);  //返回子串,返回0开始的由两个字符组成的字符串


}

int main(){
    stringing();
    cout<<"Hello World"<<endl;
    return 0;
}

0x03框架什么的

//头文件模板
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cctype>
#include<iomanip>
#include<sstream>
#include<cmath>
#include<string>
#include<vector>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<bitset>
#include<list>

//命名空间
using namespace std;

//声明与宏定义
typedef long long LL;
typedef long double LD;

#define fst first
#define sec second
#define mp make_pair

//常量定义
const int N = 1e5, inf = 1e9;  //代替define的写法 & e计数法的使用

//输入输出优化
int readint(){  //readint好简单啊为什么。。。
    int x=0, op=1;  char ch = getchar();  //一定要赋初始值
    while(ch < '0' || ch > '9'){ if(ch=='-')op=-1; ch = getchar(); }
    while(ch >= '0' && ch <= '9'){ x=x*10+ch-'0'; ch = getchar(); }
    return x*op;
}

int main(){
    cout<<"Hello World"<<endl;
    return 0;
}