蓝桥杯基本算法和函数

基本算法

计算闰年

bool isleaf (int x){
    return x%400==0||(x%4==0&&x%100!=0)
}

计数月，日或分钟等等

int syear,smonth,sday;
int countday(int year,int month,int day){
    int ans=0;
    int mon[13]={0,31,28,31,30,31,30,31,31,30,31,30,31}
while(1){
    if(year==syear&&month==smonth&&day==sday){
        break;
    }
    day++;
    if(isleaf(year)&&month==2){
        if(day>mon[month]+1){
            month++;
            day=1;
        }
    }
    else{
        if(day>mon[month]){
            month++;
            day++;
        }
    }
    if(month>12){
        month=1;
        year++;
    }
    ans++;
}
    return ans;
}

筛选素数

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

最大公约数gcd

int gcd(int a,int b){
    return b?gcd(b,a%b):a;
}

最小公倍数lcm

int lcm(int a,int b){
    return a*b/gcd(a,b);
}

多个数的gcd和lcm模板

int gcds(int a[],int n){
    int g=a[0];
    for(int i=1;i<n;i++){
        g=gcd(g,a[i]);
    }
    return g;
}
int lcms(int a[],int n){
    int l=a[0];
    for(int i=1;i<n;i++){
        l=lcm(a[i],l);
    }
    return l;
}

背包问题

#include <iostream>
using namespace std;
int main(){
    int v[MAXN],w[MAXN],dp[MAXN];
    int n,m;
    cin>>m>>n;
    for(int i=1;i<=n;i++){
        cin>>v[i]>>w[i];
    }
    for(int i=1;i<=n;i++){
        for(int j=m;j>=v[i];j--){
            dp[j]=max(dp[j],dp[j-v[i]]+w[i]);
        }
    }
    cout<<dp[m];
}

快速幂

#define long long ll
#define mod 1e9+7
ll quickpow(ll a,lln){
    if(n==0||a==1) return 1;
    ll ans=1;
    while(n!=){
        if(n%2==1) ans =a*ans%mod;
        n>>1;
    }
    return ans;
}

求组合数C(n,m)模板

long long C(int n,int m){
    if(m==0) return 1;
    long long ans=1;
    for(int n;i>n-m;i--) ans*=i;
    for(int m;i>1;i--) ans/=i;
    return ans;
}

全排列

vector<vector<int>> permuteUnique (vector<int>& nums){
    vector<vector<int>> ret;
    sor(nums.begin(),nums.end());
    do{
        ret.emplace_back(nums);
    }while(next_permutation(nums.begin(),nums.end()))
        return ret;
}

并查集

int n,m,cnt=0;
int f[10005];
int find(int x){
    if(f[x]==x) return x;
    return f[x]=find(f[x]);
}
void union (int x,int y){
    int a=find(x);
    int b=find(y);
    if(a!=b){
        f[a]=b;
        cnt++;
    }
}

基本函数

数据类型的转换

#include <iostream>
#include<sstream>
uisng namespace std;
//整型化为字符串型，其余类推
string itos(int n){
    string s;
    sstringstream ss;
    ss<<n;
    ss>>s;
    return s;
}
int main(){
    int n=1024;
    string s=itos(n);
    for(int i=0;i<s.length();i++){
        cout<<s[i]<<",";
    }
    cout<<endl;
    return 0;
}

排序函数

#include <iostream>
#include<algorithm>
using namespace std;
//设置排序方式函数
bool compare(int a,int b){
    return a>b;
}
int main(){
    int a[]={1,3,2,5,34,3,5,6};
    sort(a,a+20,compare);
}

比较字符串内容

#include<iostream>
#include<string.h>
using namespace std;
int main(){
    char *a="11112";
    char *b="11117";
    cout<<strcmp(a,b)<<endl;
    return 0;
}

辗转相除法求最大公约数

int fun(int ,.int n){
    int rem;  //余数，当余数为0时，最后的m为最大公约数
    //先用较小的数对较大的数取余，再用余数对较小的数取余，直到余数为零
    while (n>0){
        rem=m%n;
        m=n;
        n=rem;
    }
    return m;
}

vector 容器

#include<iostream>
#include<string.h>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
    vector<int> n;//新建容器，类型为int
    n,push_back(1024);//向容器内添加元素
    n.pop_back();//移除最后一个数据
    cout<<n.size()<<enl;//输出n中数据的数量
    n.clear();//清空n中所有的元素
    sort(n.begin(),n.end());//从小到大排序
    reverse(n.begin()，n.end());//从大到小排序
    for(int i=0;i<n.size();i++){
        cout<<n[i]<<endl;
    }//访问n中的元素
    return 0;
}

map容器

#include<map>
#include<iostream>
using namespace std;
int main(){
    map<char,int>mapstudent;//构建map容器
    mapstudent.insert(pair<char,int>('wang,803'));//插入数据
    mapstudent['li']=801;
    mapstudent.find('aaa');
    cout<<mapstudent['wang']<<endl;//根据键查找相应的值，若没有该键，则在map中添加此键
    int a=mapstudent.size();//查看map中数据的数量
    cout<<a<<endl;
    char key='wang';//判断map中是否有该键，若有则输出对应的值，没有则不做操作
    if(mapstudent.cout(key)>0){
        cout<<mapstudent[key]<<endl;
    }
    int b=mapstudent.erase('li');//删除元素，删除成功返回1，否则返回0
    cout<<b<<endl;
    return 0;
}

queue队列

#include<queue>
struct Point {
    int x;
    int y;
};
queue<Point> que;
que.push(start);//从队尾入队
current=que.front();//获得队首元素
que.pop();//从队首出队
que.empty()//bool型变量，队空为true

数组整体赋值

//将src数组的值赋给dest数组
#include<cstring>
memcpy(dest,src,sizeof(src));
//将dest的数组全部赋值为0
#include<cstring>
memset(dest,0,sizeof(dest));

set容器

#include<iostream>
#include<string>
#include<set>
using namespace std;
int main(){
    set<string> se;
    string a='3563234520';
    se.insert(a);
    if(se.find(a)==se.end()){
        cout<<"not exit"<<endl;
    }
    else{
        cout<<"exit"<<endl;
    }
    return 0;
}

整数二分步骤

1.找到一个区间[l,r]，使答案一定在该区间中

2.找到一个判断条件，使得该判断条件具有二段性，并且答案一定是该二段性的分界点

3.分析终点m在该判断条件下是否诚僚，如果成立，考虑答案在哪个区间，如果不成立，考虑答案在哪个区间

4.如果更新方式写的是r=mid，则不做任何处理，如果更新方式懈怠是l=mid，则需要在计算mid时加上1

int searchRange(vector<int>&nums,int traget){
    int l=0,r=nums.size()-1;
    while(l<r){
        int mid=l+r>>1;
        if(check(mid)) r=mid;
        else l=mid+1;
    }
    return 1;
}