板子总结

1、数论

浮点数比较及Pi的定义

//浮点数比较及Pi的定义 
#include<cstdio>
#include<cmath>

using namespace std;

const double eps = 1e-8;
const double Pi = acos(-1.0);


#define Equ(a, b) ((fabs((a) - (b))) < (eps))
#define More(a, b) (((a) - (b)) > (eps))
#define Less(a, b) (((a) - (b)) < (-eps))
#define MoreEqu(a, b) (((a) - (b)) > (-eps))
#define LessEqu(a, b) (((a) - (b)) < (eps))

 排列组合 

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

const int maxn = 11;
//P为当前排列，hashTable记录整数x是否已经在P中 
int n, P[maxn], hashTable[maxn] = {false};

//当前处理排列的第index位
void generateP(int index)
{
    //递归边界，已经处理完排列的1 ~ n位
    if(index == n + 1)
    {
        for(int i = 1; i <=n ; ++i)
        {
            cout << P[i];    
        }
        cout << endl;
        return;
    }
    //枚举1 ~ n 位，试图将x填入P[index] 
    for(int x = 1; x <= n; x++)
    {
        if(hashTable[x] == false)
        {
            P[index] = x;
            hashTable[x] = true;
            generateP(index + 1);
            hashTable[x] = false;
        }
    }
} 

int main()
{
    n = 1;
    generateP(1);
    return 0;
}

 快速幂

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

typedef long long LL;

LL binaryPow(LL a, LL b)
{
    if(b == 0) return 1;
    if(b % 2 == 1) return a * binaryPow(a, b - 1);
    else
    {
        LL mul = binaryPow(a, b / 2);
        return mul * mul;
    }
}

int main()
{
    cout << binaryPow(3, 3) << endl;
    return 0;
}

最大公约数（gcd）

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

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

int main()
{
    int a, b;
    while(cin >> a >> b)
    {
        if(a < b) swap(a, b);
        cout << gcd(a, b) << endl;
    }
    return 0;
}

最小公倍数（lcm）

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

int gcd(int a, int b)
{
    if(a < b) swap(a, b);
    return !b ? a : gcd(b, a % b);
}

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

分数相关

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

int gcd(long a, long b)
{
    if(a < b) swap(a, b);
    return !b ? a : gcd(b, a % b);
}

//定义
typedef struct fraction
{
    long up;
    long down;
}frac;

//化简
frac reduction(frac res)
{
    if(res.down < 0)
    {
        res.down = -res.down;
        res.up = -res.up;
    }
    
    if(res.up == 0)
    {
        res.down = 1;
    }
    else
    {
        int d = gcd(abs(res.up), abs(res.down));
        res.up = res.up / d;
        res.down = res.down / d;
    }
    
    return res;
}

//相加
frac add(frac f1, frac f2)
{
    frac res;
    res.up = f1.up * f2.down + f2.up * f1.down;
    res.down = f1.down * f2.down;
    return reduction(res);
}

素数的判断

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

素数表的获取

埃氏筛（O(nloglogn)）

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

const int maxn = 101;//表长 
int prime[maxn], pNum = 0;//prime数组存放所有素数， pNum为素数个数 
bool p[maxn] = {0};//如果i为素数，则p[i]为false；否则p[i]为true 

void findPrime()
{
    for(int i = 2; i < maxn; i++)
    {
        if(p[i] == false)
        {
            prime[pNum++] = i;
            for(int j = i + i; j < maxn; j += i) //筛去i的所有倍数 
            {
                p[j] = true;
            }
        }
    }
}

int main()
{
    findPrime();
    for(int i = 0; i < pNum; i++)
    {
        cout << prime[i] << " ";    
    } 
    cout << endl;
    
    return 0;
}

分解质因子

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

const int maxn = 100010;

/*
bool isPrime(int n)
{
    if(n == 1) return false;
    int sqr = (int)sqrt(1.0 * n);
    for(int i = 2; i <= sqr; i++)
    {
        if(n % i == 0) return false;
    }
    
    return true;
}
*/

int prime[maxn], pNum = 0;
bool p[maxn] = {0};

void findPrime()
{
    for(int i = 2; i < maxn; i++)
    {
        if(p[i] == 0)
        {
            prime[pNum++] = i;
            for(int j = i + i; j < maxn; j += i)
            {
                p[j] = true;
            }
        }
    }
}

struct factor
{
    int x, cnt;
}fac[10]; // 对于一个int型范围的数来说， fac数组的大小只需要开到10就可以了
 
int main()
{
    findPrime();
    int n, num = 0;
    cin >> n;
    if(n == 1) cout << "1=1";
    else
    {
        cout << n << "=";
        int sqr = (int)sqrt(1.0 * n);
        for(int i = 0; i < pNum && prime[i] <= sqr; i++)
        {
            if(n % prime[i] == 0)
            {
                fac[num].x = prime[i];
                fac[num].cnt = 0;
                while(n % prime[i] == 0)
                {
                    fac[num].cnt++;
                    n /= prime[i];
                }
                num++;
            }
            
            if(n == 1) break;
        }
        
        if(n != 1)//无法被根号n以内的因子除尽 
        {
            fac[num].x = n;
            fac[num++].cnt = 1; 
        }
        
        for(int i = 0; i < num; i++)
        {
            if(i > 0) cout << "*";
            cout << fac[i].x;
            if(fac[i].cnt > 1)
            {
                cout << "^" << fac[i].cnt;
            }
        }
    }
    return 0;
}

N 的因子个数=(e1 + 1) *(e2 + 1) * ... *(ek + 1)    ei为各因子个数。

大整数

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

//大整数的存储 
struct bign
{
    int d[1000];
    int len;
    bign()//定义结构体变量时，会自动对该变量进行初始化 
    {
        memset(d, 0, sizeof(d));
        len = 0;
    }
};

//字符串转化为大整数 
bign bignChange(string str)
{
    bign a;
    a.len = str.size();
    for(int i = 0; i < a.len; i++)
    {
        a.d[i] = str[a.len - i - 1] - '0'; //逆着赋值 
    }
    
    return a;
}

//大整数比较 a大 1，相等 0，a小 -1 
int bignCompare(bign a, bign b)
{
    if(a.len > b.len) 
    {
        return 1;
    }
    else if(a.len < b.len)
    {
        return -1;
    }
    else
    {
        for(int i = a.len - 1; i >= 0; i--)
        {
            if(a.d[i] > b.d[i])
            {
                return 1;
            }
            else if(a.d[i] < b.d[i])
            {
                return -1;
            }
        }
        return 0;
    }
}

//高精度加法 （将改位上的两个数字和进位相加，得到的结果取个位数作为该位结果，取十位数作为新的进位）
bign bignAdd(bign a, bign b) 
{
    bign c;
    int carry = 0; //进位
    for(int i = 0; i < a.len || i < b.len; i++)//较长的为界限 
    {
        int temp = a.d[i] + b.d[i] + carry;
        c.d[c.len++] = temp % 10;
        carry = temp / 10;
    }
    if(carry != 0)//最后进位不为0，则直接赋值给最高位 
    {
        c.d[c.len++] = carry;
    }
    return c;
}

//高精度减法 a - b （需要比较大小，如果被减数小于减数，要交换两个变量，然后输出负号）
bign bignSub(bign a, bign b)
{
    bign c;
    for(int i = 0; i < a.len || i < b.len; i++)
    {
        if(a.d[i] < b.d[i])
        {
            a.d[i + 1]--;
            a.d[i] += 10;
        }
        c.d[c.len++] = a.d[i] - b.d[i];
    }
    
    while(c.len - 1 >= 1 && c.d[c.len - 1] == 0)
    {
        c.len--;//去除最高位的0，同时至少保留一位最低位 
    }
    
    return c;
}

//高精度与低精度的乘法 （始终将低精度数作为一个整体）
bign bignMul(bign a, int b)
{
    bign c;
    int carry = 0;
    for(int i = 0; i < a.len; i++)
    {
        int temp = a.d[i] * b + carry;
        c.d[c.len++] = temp % 10;
        carry = temp / 10;
    }
    while(carry != 0)
    {
        c.d[c.len++] = carry % 10;
        carry /= 10;
    }
    
    return c;
}

bign bignDiv(bign a, int b, int& r)//r为余数
{
    bign c;
    c.len = a.len;//被除数的每一位和商的每一位是一一对应的 
    for(int i = a.len - 1; i >= 0; i--)
    {
        r = r * 10 + a.d[i];
        if(r < b)
        {
            c.d[i] = 0;
        } 
        else
        {
            c.d[i] = r / b;
            r = r % b;
        }
    } 
    
    while(c.len - 1 >= 1 && c.d[c.len - 1] == 0)
    {
        c.len--;
    }
    return c;
} 

void bignPrint(bign a)
{
    for(int i = a.len - 1; i >= 0; i--)
    {
        cout << a.d[i];
    }
    cout << endl;
}

int main()
{
    string s1, s2;
    cin >> s1 >> s2;
    bign b1 = bignChange(s1);
    bign b2 = bignChange(s2);
    
    bignPrint(bignAdd(b1, b2));
    bignPrint(bignSub(b1, b2));
    bignPrint(bignMul(b1, 2));
    int r = 0;
    bignPrint(bignDiv(b1, 2, r));
    
    return 0;
}

ax + by = gcd(a, b)的求解

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

int exGcd(int a, int b, int &x, int &y) 
{
    if(b == 0)
    {
        x = 1;
        y = 0;
        return a;
    }
    
    int g = exGcd(b, a % b, x, y);
    int temp = x;
    x = y;
    y = temp - a / b * y;
    return g;
}

int main()
{
    int x, y;
    int g = exGcd(25, 15, x, y);
    printf("25 * %d + 15 * %d = %d
", x, y, g);
    
    //k为任意整数，经过一下运算后得到全部解 
    int xx, yy, k;
    xx = x + 15 / g * k;
    yy = y - 25 / g * k;
    
    printf("25 * %d + 15 * %d = %d
", xx, yy, g);
    
    return 0;
}

组合数的计算

组合数是指在n个元素中选出m个元素的方案数

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

typedef long long LL;

LL C(LL n, LL m)
{
    LL ans = 1;
    for(LL i = 1; i <= m; i++)
    {
        ans = ans * (n - m + i) / i;
    }
    return ans;
}
int main()
{
    int n, m;
    while(cin >> n >> m)
    {
        cout << C(n, m) << endl; 
    }
    return 0;
}

组合数 % p

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

typedef long long LL;

LL C(LL n, LL m)
{
    LL ans = 1;
    for(LL i = 1; i <= m; i++)
    {
        ans = ans * (n - m + i) / i;
    }
    return ans;
}

int Lucas(int n, int m)
{
    if(m == 0) return 1;
    return C(n % p, m % p) * Lucas(n / p, m / p) % p;
}

2、排序

归并排序

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

const int maxn = 100;
//将数组A的[L1, R1]与[L2, R2]区间合并为有序区间（此处L2即为R1 + 1）
void merge(int A[], int L1, int R1, int L2, int R2)
{
    int i = L1, j = L2;
    int temp[maxn], index = 0;
    while(i <= R1 && j <= R2)
    {
        if(A[i] <= A[j])
        {
            temp[index++] = A[i++];
        }
        else
        {
            temp[index++] = A[j++];
        }
    }
    
    while(i <= R1) temp[index++] = A[i++];
    while(j <= R2) temp[index++] = A[j++];
    for(i = 0; i < index; i++)
    {
        A[L1 + i] = temp[i]; 
    }
}

/*
void mergeSort(int A[], int left, int right)
{
    if(left < right)
    {
        int mid = (left + right) / 2;
        mergeSort(A, left, mid);
        mergeSort(A, mid + 1, right);
        merge(A, left, mid, mid + 1, right);
    }
}
*/

void mergeSort(int A[], int n)
{
    for(int step = 2; step / 2 < n; step *= 2)
    {
        for(int i = 0; i <= n; i += step)
        {
            int mid = i + step / 2 - 1;
            if(mid + 1 <= n)
            {
                merge(A, i, mid, mid + 1, min(i + step - 1, n));
            }
        }
    }
}

int main()
{
    int a[10] = {9,8,7,6,5,4,3,2,1,0};
    mergeSort(a, 9);
    for(int i = 0; i < 10; i++)
    {
        cout << a[i] << " ";
    }
    cout << endl;
    return 0;
}

3、字符串

整型与字符串相互转换

#include <iostream>
#include <cstdio>
#include <string> 

using namespace std;

int main(){
    //字符串转整型 
    string s = "123";
    cout << atoi(s.c_str()) << endl;
    
    //整形转字符串
    int i = 123;
    cout << to_string(i) << endl;
    
    
    return 0;
}

3、二分

（1）二分查找指定元素所在位置

#include <iostream>
#include <cstdio>

using namespace std;

int binarySearch(int A[], int left, int right, int target)
{
    while(left <= right)
    {
        int mid = left + (right - left) / 2;
        if(A[mid] == target) return mid;
        else if(A[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

int main()
{
    int a[10] = {1,2,3,4,5,6,7,8,9,10};
    
    cout << binarySearch(a, 0, 9, 5) << endl;
    
    return 0;
}

（2）二分查找序列中第一个大于等于给定元素的位置

#include <iostream>
#include <cstdio>

using namespace std;

int binarySearch(int A[], int left, int right, int target)
{
    while(left < right)
    {
        int mid = left + (right - left) / 2;
        if(A[mid] >= target) right = mid ;
        else left = mid + 1;
    }
    return left;
}

int main()
{
    int a[10] = {1,2,3,4,5,6,7,8,9,10};
    
    cout << binarySearch(a, 0, 9, 5) << endl;
    
    return 0;
}

（3）二分查找序列中第一个大于给定元素的位置

#include <iostream>
#include <cstdio>

using namespace std;

int binarySearch(int A[], int left, int right, int target)
{
    while(left < right)
    {
        int mid = left + (right - left) / 2;
        if(A[mid] > target) right = mid ;
        else left = mid + 1;
    }
    return left;
}

int main()
{
    int a[10] = {1,2,3,4,5,6,7,8,9,10};
    
    cout << binarySearch(a, 0, 9, 5) << endl;
    
    return 0;
}