全平台肘击桑境阳，支持者复制红字挂主页 全平台肘击桑境阳，支持者复制红字挂主页

5201314 = (114514+114514)*(1*14+5-1+4)+(114514+(11451*4+(114*5*1*4+(1*(1+4)*5*1*4))))

# 有需要可以Copy（主要方便我自己）

set & map

set<int> st;
map<string,int> mp;
mp[key] = value;//插入键值

随机数造数据

#include
using namespace std;
int main(){
	freopen( "test.in" , "w" , stdout );
	srand( int ( time ( 0 ) ) );
	int n, m, p, a;
	n = rand() % 10000;
	m = rand() % 10000;
	cout << m << endl;
	cout << n << endl;
	while( m-- ){
		p = rand() % 10000;
		a = rand() % 10000;
		cout << p << ' ' << a << endl;
	}
	fclose( stdout );
}

万能开头：

#include<bits/stdc++.h>
using namespace std;

int main(){

}

关于vector：

vector<int> v;//创建一个空vector
v.push_back(x)//向尾部增加一个元素x
v.insert(pos,x)//向pos地址指向元素前增加一个元素x
v[i]//访问第i位元素
v.pop_back()//删除向量中最后一个元素
v.clear()//清空向量中所有元素
v.empty()//判断向量是否为空
v.size()//返回向量中元素的个数
v.begin()//返回量头指针（迭代器），指向第一个元素
v.end()//返回量尾指针（迭代器），指向第一个元素+1位置
v.erase(v.begin()+i)//删除第i位位置的元素

全排列函数：

next_permutation(数组头地址，数组尾地址);//求下一个全排列
prev_permutation(数组头地址，数组尾地址);//求上一个全排列

排列数组(sort函数)：

sort(a(begin),a(end)+size);//默认小到大
sort(a(begin),a(end)+size,greater<int>());//大到小
sort(a(begin),a(end)+size,less<int>());//小到大

与字符相关的函数

getchar()//输入单个字符
putchar()//输出单个字符
islower(x)//判断x是否为小写字母
isupper(x)//判断x是否为大写字母
isdigit(x)//判断x是否为数字
isalpha(x)//判断x是否为字母

builtin内建函数

__builtin_ffs(x)//返回x中最后一个为1的位是从后往前的第几位
__builtin_popcount(x)//x中1的个数
__builtin_ctz(x)//x末尾0的个数，x=0时结果未定义
__builtin_clz(x)//x前导0的个数，x=0时结果未定义
__builtin_parity(x)//x中1的奇偶性
```二分查找核心代码

```none
int dp[30000];
int n;
int fun(int k){
    int l=0,r=n-1,m=l+r/2;
    while(l<r){
        if(k==dp[m]){
            return m;
        }else if(k>dp[m]){
            l=m+1;
        }else{
            r=m-1;
        }
    }
    return -1;
}

最大公因数&最小公因数

a=al*gcd(a,b)
b=bl*gcd(a,b)
lcm(a,b)=al*gcd(a,b)*bl

a*b=gcd(a,b)*lcm(a,b)

斐波那契数列

int dfs( int a ){
    if( a == 1 || a == 2 ){
        return 1;
    }
    return dfs( a - 1 ) + dfs( a - 2 );
}

二分查找法

binary__search()![]

#include<bits/stdc++.h>
using namespace std;

int n, q;
string s[1000];

bool find( string a , int len , int k){//s[k]------------被查找
if( s[k].size() < len ){
return false;
}
for( int i = s[k].size() - len,i1 = 0; i < s[k].size(); i++ , i1++ ){
if( s[k][i] != a[i1] ){
return false;
}
}
return true;
}

bool cmp( string a, string b ){
if( a.size() == b.size() ){
return a < b;
}else{
return a.size() < b.size();
}
}

int main() {
cin >> n >> q;
for( int i = 0; i < n; i++ ){
cin >> s[i];
}
sort( s, s+n ,cmp);
for( int i = 0; i < q; i++ ){
int a;
cin >> a;
string str;
cin >> str;
bool flag = true;
for( int i = 0; i < n; i++ ){
if( find(str,a,i) ){
cout << s[i] << endl;
flag = false;
break;
}
}
if( flag ){
cout << -1 << endl;
}
}
return 0;
}

·解决了自身逻辑意义的完整性。（补码表示的数相加时，如果最高位（符号位)有进位，这个进位会被  舍弃）
     位运算符(&,|,~,<<,>>)
     & 按位与（同时为1，则为1）
     101011
     010011
     --------
     000011
     | 按位或（有一个1，则为1）
     101011
     010011
     --------
     111011
     ~ 按位取反（转补码，取反（含符号位），-1，符号位不变取反）
     ~2
原码：0 0010
补码：0 0010
取反：1 1101
减一：1 1100
符号位不变取反： 1 0011 = -3
eg：（1010）B——>对应的格雷码为：
 1010
+ 1010
————
 11110
舍弃最后一位，得对应的格雷码为1111。
下拉异惑（格——>二）
方法：把格雷码写一遍，下拉第一位，与最后一位异或，
直至最后一位结束，即可得到的对应的二进制数。
最后，运算符的优先级
·大致按照以下

-------------线性结构------------
1.数组
2.链表
3.栈
4.队列
-------------非线性结构---------
5.堆
6.树
7.图
8.散列表
--------

数组：优点：元素在地址上连续查找元素非常快缺点：长度不可变，需要在创建时指定插入、删除元素效率较低链表：（单向链表 双向链表 循环链表单向链表有一个head（头指针），单向链表每个节点分为两个部分data（数据），next/rlink代表下一个地址双向链表：有三个空间，pre上一个地址，data数据，next下一个地址循环链表：尾指针的下一个地址指向第一个元素单向链表头节点插入LinkList p=new LNode;//申请空间p->data=item;//存入数据p->link=list;//让p指向头指针指向的节点list=p;//让头指针指向p

单向链表	尾部插入：while(r->link!=NULL){r=r->link;}Linklist p=new LNode;//申请空间p->data=iteml;//存入数据p=NULL;r->link=p;//r指向的下一个为p单向链表删除：while(r->link!=q&&r->link!=NULL){r->link=q->link;}free(q);//删除（释放q）双向链表插入：p->llink=q;//p指向的上一个节点是qp->rlink=q->rlink;//p的下一个节点=q指向的的下一个节点q->rlink->llink=p;//q指向的下一个节点=q指向的上一个节点是pq->rlink=p;//q的下一个节点是q双向链表删除：q->llink->rlink=q->rlink;q->rlink->llink=q->llink;free(q)//delete(q);

队列：（先进先出）queue<int> q;//队列申请q.front()//获取队首元素q.push()//入队q.pop()//出队首元素栈：（先进后出）stack<int> s;//创建s.top()//获取栈顶元素s.push()//推入栈s.pop()//出栈

string快读快写

#include<bits/stdc++.h>
#define f_Getchar() getchar()
#define f_Putchar(ch) putchar(ch)
using namespace std;
// string 整行快速读入
inline void inputs(char *s){
	char ch = f_Getchar(); //获取字符串
	while(ch=='\n'){
		ch = f_Getchar();
	} 
	while(ch!='\n'){
		*s = ch;
		++s;
		ch = f_Getchar();
	} 
	*s ='\0';
	return;
} 

int main(){
	char s[100];
	inputs(s);
	// 字符数组转成字符串
	string c(s);
	cout<<c;
}

快读和快写

#include<bits/stdc++.h>
using namespace std;
inline int read(){//快读
	register int x=0,t=1;
	register char ch=getchar();
	while(ch<'0'||ch>'9'){
		if(ch==' '||ch==\n){
			t--;
		}
		ch=getchar();
	}
	while(ch<'0'||ch>'9'){
		//x=x*10+ch-'0';
		x=(x<<1)+(x<<3)+(ch^48);
		ch=getchar();
	}
	return x*t;
} 
inline int super_read(char s[]){
	int tot=0;
	char ch=getchar();
	while(ch==' '||ch==\n){
		ch=getchar();
	}
	while(ch!=' '||ch!=\n){
		s[tot++]=ch;
		ch=getchar();
	}
	//return ;
}
inline void write(){//快写
	register int x=0,t=1;
	if(x<0){
		putchar(' ');
		x=-x;
	}
	if(x>9){
		write(x/10);
	}
	putchar(x%10+'0');
	return;
}
int main(){
	
	return 0;
}

bitset2

将字符串转成数字：

1.借用bitset将01字符串变成无符号整数

string a = "1001";

bitset<64> b(string("1001"))

bitset<64> b(a)

cout<<b.to\_ulong()

2.用sscanf() 函数把字符数组里面的字符串打印到数值变量里面

int buf;

sscanf("123456","%d",&buf)

printf("%d\\n",buf)

3.用sprintf()把数据打印到字符数组里面

char s[100]

sprintf(s,"%d",123)

4.用直接的方式

string s = "1234";

int n = 0;

for(int i = 0;i<4;i++){

n = n\*10+s[i]-'0';

}

5.一般用法

char buf[512] = ;

sscanf("123456 ", "%s", buf);

printf("%s\\n", buf);

结果为：123456

1. 取指定长度的字符串。如在下例中，取最大长度为4字节的字符串。

sscanf("123456 ", "%4s", buf);

printf("%s\\n", buf);

结果为：12342. 取到指定字符为止的字符串。如在下例中，取遇到空格为止字符串。

sscanf("123456 abcdedf", "%[^ ]", buf);

printf("%s\\n", buf);

结果为：123456

3. 取仅包含指定字符集的字符串。如在下例中，取仅包含1到9和小写字母的字符串。

sscanf("123456abcdedfBCDEF", "%[1-9a-z]", buf);

printf("%s\\n", buf);

结果为：123456abcdedf

4. 取到指定字符集为止的字符串。如在下例中，取遇到大写字母为止的字符串。

sscanf("123456abcdedfBCDEF", "%[^A-Z]", buf);

printf("%s\\n", buf);

结果为：123456abcdedf

5、给定一个字符串iios/12DDWDFF@122，获取 / 和 @ 之间的字符串，先将 "iios/"过滤掉，再将

非'@'的一串内容送到buf中

sscanf("iios/12DDWDFF@122", "%\*[^/]/%[^@]", buf);

printf("%s\\n", buf);

结果为：12DDWDFF

6、给定一个字符串"hello, world"，仅保留"world"。（注意：“，”之后有一空格）

sscanf("hello, world", "%\*s%s", buf);

printf("%s\\n", buf);

结果为：world　　P.S. %\*s表示第一个匹配到的%s被过滤掉，即hello,被过滤了，如果没有空格则结果为

NULL

bitset

#include<iostream>
#include<bitset>
using namespace std;

/*
bitset<N> varm(M) 用于处理进制
N 代表占的位数
varm 代表bitset名
M变量的初始值
bitset头文件：
#include<bitset>
bitset例子：
bitset<32> b;
相关STL函数：
b.any() 当bitset对象的一位或多个位被设置为1 时any()返回true
用途：检测总开关是否全被关闭状态
b.none() 如果bitset 对象的所有位都被设置为0 ,则none()操作返回true
用途：检测总开关是否全被关闭状态(出现一个没关false)
b.count() count()操作返回被设置为1的位的个数.
b.set() 我们可以用set()操作或者下标操作符来设置某个单独的位
b.test(位置) 测试某个单独的位是否为1
if(b.test(2)) 返回真测试第二位是否为1
b.reset(x) 把x位设置为0
b.flip()  操作翻转整个bitset 对象或一个独立的位
b.flip( 0 ); // 翻转第一位
b[0].flip(); // 也是翻转第一位
b.flip(); // 翻转所有的位的值
size()：返回大小（位数）。
to_ulong()：返回它转换为unsigned long的结果，如果超出范围，则报错。
to_string()：返回它转换为string的结果。

*/
bitset<32> b(12); // 000000000000000000000000000000000000001100
int main(){
//	string s;
//	cin>>s;
//	int len = s.size();
//	for(int i = 0;i<len-1;i++){
//		ans+=(s[i]-'0')*pow(2,len-i-1);
//		cout<<ans<<endl;
//	}
cout<<b<<endl;
bool c = b.any();
bool k = b.none();
cout<<c<<" "<<k<<endl;
//偶数位数设为1会变成什么
for(int i = 0;i<32;i++){
if(i%2==0){
b[i]=1;
}
}
//	int m = b.count();
cout<<b<<endl;
if(b.test(13)){
cout<<"第13位是1";
} else{
cout<<"第13位是0";
}
b.reset(4);
cout<<endl<<b<<endl;
b.flip(0);
b.flip(2);
b[6].flip();
cout<<"翻转第一位后的结果：";
cout<<endl<<b<<endl;
cout<<"把整个bitset翻转:"<<endl;
b.flip();
cout<<endl<<b<<endl;
int l = b.to_ulong();
cout<<"改变后的进制转成数字"<<l;

}

最值

/*
max_element(begin,end);返回最小值的地址
min_element(begin,end);返回最大值的地址
begin:序列的起始地址
end:序列的结束地址+1
cout<<*(max_element(begin,end));
地址-数组名=元素下标
*/

vector

/*
vector<int> v;//创建一个空vector
v.push_back(x)//向尾部增加一个元素x
v.insert(pos,x)//向pos地址指向元素前增加一个元素x
v[i]//访问第i位元素
v.pop_back()//删除向量中最后一个元素
v.clear()//清空向量中所有元素
v.empty()//判断向量是否为空
v.size()//返回向量中元素的个数
v.begin()//返回量头指针（迭代器），指向第一个元素
v.end()//返回量尾指针（迭代器），指向第一个元素+1位置
v.erase(v.begin()+i)//删除第i位位置的元素
*/

char和string

/*
// 单个字符
char c = getchar(); // 输入单个字符
putchar(c);// 输出单个字符
islower(c);// 判断c是否为小写字母
isupper(c);// 判断c是否为大写字母
isalpha(c);// 判断是否为字母
isdigit(c);// 判断是否为数字
// 字符数组
'\0' // 字符数组最后一个：ASCII值：0
char str[];
cin>>str; // 可以作为一个整体进行cin,cout
cout<<str;
str ="sdfa"；// 可以直接用字符串赋值

// 字符数组常用处理函数：
char str[100]; // char *str
puts(str); // 输出字符串
gets(str);// 输入一整行字符串（包括空格，已弃用）
fgets(str,100,stdin) // 将标准输入中长度最多为100的字符串输入到 str
strcat(str1,str2) // 把str2连接到str1后面
strcmp(str1,str2) // 比较两个字符串，正数：1大；0：一样大，负数：2大
strlen(str) // 获取字符串长度（不包括'\0'）

// string
#include<string> // 字符串头文件
=  可以重新赋值
+= 尾部加入字符串

+ 连接字符串
  ==，！=，<,>,<=,>= 字符串的比较
  [] 存取单一字符
  getline(cin,str) // 输入（包括空格，enter键结束）
  str.substr(i,1) // 从i开始截取，截取长度为1的子字符串
  str.find(str2) // 在str字符串中去找到str字符串
  str.rfind(str2) //  str中查找str2，返回所在的下标，没找到返回string::npos
  str.erase(i,1)  // 第i个字符开始往后面去删除
  str.inser(i,str2) // 在个位置 cun

<< // 输出
str.substr(i, l); // 从i开始，截取长度为l的子字符串
str.find(str2); // 在str中查找str2，返回所在的下标，没找到返回string::npos
str.rfind(str2); // 同find，但是从右向左找
str.erase(i, l); // 从i开始，删除长度为l的子字符串
str.insert(i, str2); // 在i的位置前，插入str2
str.size(); // 获取str的长度
str.c_str(); // 获取str对应的char[]
str.begin(); // 获取str的首地址
str.end(); // 获取str的尾地址(最后一个元素后面)

*/

快速排序

#include<bits/stdc++.h>
using namespace std;
vector<long long> v;
int i,j,temp;
void quicksort(int l,int r){
    if(l>r){
        return;
    }
    temp=v[l];
    i=l;
    j=r;
    while(i!=j){
        while(v[j]>=temp&&i<j){
            j--;
        }
        while(v[i]<=temp&&i<j){
            i++;
        }
        if(i!=j){
            swap(v[i],v[j]);
        }
    }
    swap(v[l],v[j]);
    quicksort(l,j-1);
    quicksort(i+1,r);
}
int main(){
    int n,x,cnt;
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>x;
        v.push_back(x);
    }
    quicksort(0,n-1);
    for(int i=0;i<n;i++){
        cout<<v[i]<<' ';
    }
    return 0;
}

归并排序

#include<bits/stdc++.h>
using namespace std;
vector<int> s1,s2;
void marge(int l,int m,int r){
     s2.clear();
     int i=l,j=m+1;
     while(i<=m&&j<=r){
         if(s1[i]<s1[j]){
            s2.push_back(s1[i++]);
         }else{
            s2.push_back(s1[j++]);
         }
     }
     while(i<=m){
         s2.push_back(s1[i++]);
     }
     while(j<=r){
         s2.push_back(s1[j++]);
     }
     for(i=l;i<=r;i++){
        s1[i]=s2[i-l];
     }
}
void margesort(int a,int b){
     if(a==b){
       return;
     }
     int m=(a+b)/2;
     margesort(a,m);
     margesort(m+1,b);
     marge(a,m,b);
}
int main(){
    int n,x;
    cin>>n;
    for(int i=1;i<=n;i++){
       cin>>x;
       s1.push_back(x);
    }
    margesort(0,n-1);
    for(int i=0;i<n;i++){
       cout<<s1[i];
    }
    return 0;
}

选择排序

#include<bits/stdc++.h>
using namespace std;
void fun(int a[],int n){
     for(int i=0;i<n;i++){
        int minn=i;
        for(int j=i+1;j<n;j++){
          if(a[j]<a[minn]){
            minn=j;
          }
        }
     swap(a[i],a[minn]);
     }
}
int main(){
    int n,a[305];
    cin>>n;
    for(int i=0;i<n;i++){
      cin>>a[i];
    } 
    fun(a,n);
    for(int i=0;i<n;i++){
      cout<<a[i];
    }
    return 0;v```v

插入排序

#include<bits/stdc++.h>
using namespace std;
void insertsort(int a[],int n){
     int x;
     for(int i=1;i<n;i++){
        x=a[i];
        int j=0;
        for(j=i-1;j>=0;j--){
           if(a[j]>x){
             a[j+1]=a[j];
           }else{
             a[j+1]=x;
           }
        }
        if(j<0){
          a[0]=x;
        }
    }
}
int main(){
   int n,v[1005];
   cin>>n;
   for(int i=0;i<n;i++){
      cin>>v[i];
   }
   insertsort(v,n);
   for(int i=0;i<n;i++){
      cout<<v[i];
   }
   return 0;
}

二分查找

#include<bits/stdc++.h>
using namespace std;
int n,x,h;
vector<int> a;
int fun(){
    int l=1,r=n,v;
    while(l<r){
        v=(l+r)/2;
        if(a[v]>=x){
            r=v;
        }else{
            l=v+1;
        }
    }
    if(x==a[l]){
        return l;
    }else{
        return -1;
    }
}
int main(){
   cin>>n;
   for(int i=1;i<=n;i++){
      scanf("%d",&h);
      a.push_back(h);
   }
   cin>>x;
   printf("%d",fun()+1);
}