数字芯片设计流程

数字芯片的设计，主要是按照以下的顺序来进行的

定义功能和指标、架构设计，代码设计使用代码描述（verilog 、HDL)、功能验证，这些统称为RTL设计

RTL设计后，下一步就是把抽象的代码映射成一个跟工艺相关的实际的文件。 这一步就是逻辑综合

逻辑综合之后，抽象代码就变成了一个由标准单元连接的一个网表，有标准逻辑单元，有连接关系，但是没有确定每一个cell在芯片上的位置坐标。

逻辑综合之后就是芯片的后端

在满足功能时序面积约束条件下，把单元放到芯片位置上，这就是full plan 和placement

根据逻辑单元的连接关系，通过引脚把单元连接起来，也就是布线(Place)

如果是一个立体图，可以看到线是分很多层的

我们可以注意到在芯片设计中,memory一般都摆在两边，逻辑单元都在中间

FPGA设计流程

第一步也是综合，第二步是实现，和芯片设计流程很相似，也是有布局布线等流程。FPGA设计也需要加入约束来进行设计。

静态时序分析概述

大部分Soc电路都是很复杂的，大部分可以理解为局部同步，全局异步

静态时序分析相比于功能验证的区别

simulation的测试机理是不停的生成测试向量。静态时序分析不需要生成测试向量，因此静态时序分析的整个时间相对来说就比较短了

静态时序分析其实是对于simulation的一个非常好的补充。

试除法判定质数

#include <iostream>#include <algorithm>using namespace std;bool is_prime(int x){    if (x < 2) return false;    for (int i = 2; i <= x / i; i ++ )//不要用开方函数或者i*i小于x。开方函数慢，i*i可能越界        if (x % i == 0)            return false;    return true;}int main(){    int n;    cin >> n;    while (n -- )    {        int x;        cin >> x;        if (is_prime(x)) cout << "Yes" << endl;        else cout << "No" << endl;;    }    return 0;}

分解质因数

//详细得可以看这个题解：https://www.acwing.com/solution/content/27448/#include <iostream>#include <algorithm>using namespace std;void divide(int x){    for (int i = 2; i <= x / i; i ++ )//i <= x / i:防止越界，速度大于 i < sqrt(x){        if (x % i == 0)//i为底数        {            int s = 0;//s为指数            while (x % i == 0) x /= i, s ++ ;            cout << i << ' ' << s << endl;//输出        }}    if (x > 1) cout << x << ' ' << 1 << endl;//如果x还有剩余，单独处理    cout << endl;}int main(){    int n;    cin >> n;    while (n -- )    {        int x;        cin >> x;        divide(x);    }    return 0;}

筛质数

//线性法时间复杂度为O(n)//参考这个链接：https://www.acwing.com/solution/content/7950/#include <iostream>#include <algorithm>using namespace std;const int N= 1000010;int primes[N], cnt;bool st[N];void get_primes(int n){    for (int i = 2; i <= n; i ++ )    {        if (!st[i]) primes[cnt ++ ] = i;         for (int j = 0; primes[j] <= n / i; j ++ )        {            st[primes[j] * i] = true; //用最小质因子去筛合数            if (i % primes[j] == 0) break;            //当i%primes[j]!=0时,说明此时遍历到的primes[j]不是i的质因子，那么只可能是此时的primes[j]<i的最小质因子,所以primes[j]*i的最小质因子就是primes[j];            //当有i%primes[j]==0时,说明i的最小质因子是primes[j],因此primes[j]*i的最小质因子也就应该是prime[j]，之后接着用st[primes[j+1]*i]=true去筛合数时，就不是用最小质因子去更新了,因为i有最小质因子primes[j]<primes[j+1],此时的primes[j+1]不是primes[j+1]*i的最小质因子，此时就应该退出循环，避免之后重复进行筛选。        }            }}int main(){    int n;    cin >> n;    get_primes(n);    cout << cnt << endl;    return 0;}

约数

试除法求约数

#include <iostream>#include <vector>#include <algorithm>using namespace std;int main(){    int T;    cin >> T;    while(T--)    {        int n;        cin >> n;        vector<int> res;        //因为约数成对出现，所以只需要循环到根号x        // 不要是用 i *i <= n，因为可能溢出        for(int i = 1; i <= n /i; i++)        {            if(n % i == 0)            {                res.push_back(i);                //如果i * i = x,添加i即可，不用添加 x / i                if(n / i != i)                    res.push_back(n / i);            }        }        sort(res.begin(), res.end());        for(auto x : res) cout << x << " ";        cout << endl;    }}

约数个数

#include <iostream>#include <algorithm>#include <unordered_map>using namespace std;const int mod = 1e9+7 ;//这题只要是考察约数个数的公式int main(){    int T;     cin >> T;    unordered_map<int, int> h;    while(T--)    {        int n;         cin >> n;        //依次求出指数        for(int i = 2; i <= n / i; i++)        {            while(n % i == 0)            {                //指数+1                h[i] ++;                n = n / i;            }        }        //如果有剩余，也是一个质因子        if(n > 1) h[n]++;    }    long long  res = 1;    for(auto iter = h.begin(); iter != h.end(); iter++)    {        //res = (x1+1)(x2+1)(x3+1)…(xk+1)        res = res * (iter->second + 1) % mod ;    }    cout << res;}

约数之和

#include <iostream>#include <algorithm>#include <unordered_map>#include <vector>using namespace std;typedef long long LL;const int N = 110, mod = 1e9 + 7;int main(){    int n;    cin >> n;    unordered_map<int, int> primes;    while (n -- )    {        int x;        cin >> x;        for (int i = 2; i <= x / i; i ++ )        {            while (x % i == 0)            {                x /= i;                primes[i] ++ ;            }        }        if (x > 1) primes[x] ++ ;    }    LL res = 1;    for (auto p : primes)    {        LL a = p.first, b = p.second;        LL t = 1;        while (b -- ) t = (t * a + 1) % mod;// x^2 + x = x(x + 1);        //计算一下：//第一步：//t = (t * a + 1)//t=p1的一次方+p1的零次方；//第二步：//t = (t * a + 1)//t=p1的二次方+p1的一次方+1=p1的二次方+p1的一次方+p1的零次方；        res = res * t % mod;    }    cout << res << endl;    return 0;}

最大公约数

//这段算法得代码关键是辗转相除法具体可以参考以下链接：https://www.acwing.com/solution/content/145791/#include <iostream>#include <algorithm>using namespace std;int main(){    int T;    cin >> T;    while(T--)    {        int a, b;        cin >> a >> b;        //辗转相除，直到小括号内右边数为0        while(b)        {            //c 一定小于 b            int c = a % b;            //小括号左边放除数，右边放约数            a = b;            b = c;        }        //小括号内左边数为最大公约数        cout << a << endl;    }}

欧拉函数

欧拉函数

//只是一个数学公式具体推导看这个链接就可以：https://www.acwing.com/solution/content/8702/#include <iostream>using namespace std;int phi(int x){    int res = x;    for (int i = 2; i <= x / i; i ++ )        if (x % i == 0)        {            res = res / i * (i - 1);            while (x % i == 0) x /= i;        }    if (x > 1) res = res / x * (x - 1);    return res;}int main(){    int n;    cin >> n;    while (n -- )    {        int x;        cin >> x;        cout << phi(x) << endl;    }    return 0;}

筛法求欧拉函数

//不懂的地方看这个代码：https://www.acwing.com/solution/content/3952///y总的代码视频讲的也很纤细：https://www.acwing.com/video/299/#include <iostream>#include <algorithm>using namespace std;typedef long long LL;const int N = 1000010;int primes[N], cnt;int phi[N];bool st[N];void get_eulers(int n){    phi[1] = 1;    for (int i = 2; i <= n; i++)    {        if (!st[i])        {            primes[cnt++] = i;            phi[i] = i - 1;         }        for (int j = 0; primes[j] <= n / i; j++)        {            st[primes[j] * i] = true;            if (i % primes[j] == 0)            {                phi[primes[j] * i] = phi[i] * primes[j];                 break;            }            phi[primes[j] * i] = phi[i] * (primes[j] - 1);        }    }}int main(){    int n;    cin >> n;    get_eulers(n);    LL res = 0;    for (int i = 1; i <= n; i++) res += phi[i];    printf("%lld\n", res);    return 0;}

快速幂

快速幂

//为什么是Logb得时候复杂度，可以看这个链接：https://www.acwing.com/solution/content/15293/#include<bits/stdc++.h>using namespace std;typedef long long LL;LL quick(LL a,LL b,LL p)//二进制，背就完事{    LL res=1;    while(b>0)    {        if(b&1) res=a*res%p; //%p都是为了防止溢出操作        a=a*a%p;//这里也是，每次乘以得数都不一样        b>>=1;    }    return res;}int main(){    int n;    scanf("%d", &n);    for (int i = 0; i < n; i ++ )    {        int a,b,p;        scanf("%d%d%d", &a, &b,&p);        printf("%d\n",quick(a,b,p));    }}

快速幂求逆元

//不懂的话，看下链接这篇文章就懂了：https://www.acwing.com/problem/content/878/#include <iostream>using namespace std;typedef long long LL;LL qmi(int a, int b, int p){    LL res = 1;    while(b){        if(b & 1) res = res * a % p;        a = (LL)a * a % p;        b >>= 1;    }    return res;}int main(){    int n; cin >> n;    while(n --){        int a, p;        cin >> a >> p;        if(a % p == 0) puts("impossible");        else cout << qmi(a, p - 2, p) << endl;    }    return 0;}

扩展欧几里得算法

扩展欧几里得算法

//详细的过程看看这个代码：https://www.acwing.com/solution/content/1393/#include<bits/stdc++.h>using namespace std;int exgcd(int a, int b, int &x, int &y){//返回gcd(a,b) 并求出解(引用带回)    if(b==0){        x = 1, y = 0;        return a;    }    int x1,y1,gcd;    gcd = exgcd(b, a%b, x1, y1);    x = y1, y = x1 - a/b*y1;    return gcd; }int main(){    int n,a,b,x,y;    cin>>n;    while(n--){        cin>>a>>b;        exgcd(a,b,x,y);        cout<<x<<" "<<y<<endl;    }    return 0;}

线性同余方程

//证明思路看一下这个链接：https://www.acwing.com/solution/content/5937/#include<bits/stdc++.h>using namespace std;using LL = long long ;int exgcd(int a, int b, int &x, int &y){//返回gcd(a,b) 并求出解(引用带回)    if(b==0){        x = 1, y = 0;        return a;    }    int x1,y1,gcd;    gcd = exgcd(b, a%b, x1, y1);    x = y1, y = x1 - a/b*y1;    return gcd; }int main(){    int n,a,b,x,y,m;    cin>>n;    while(n--){        cin>>a>>b>>m;        int d=exgcd(a,m,x,y);        if (b % d) puts("impossible");        else         {            x = (LL)x * b / d % m;            cout << x << endl;        }    }    return 0;}

中国剩余定理

表达整数的奇怪方式

//这个代码看不懂#include <cstdio>#include <iostream>using namespace std;typedef long long LL;int n;LL exgcd(LL a, LL b, LL &x, LL &y){    if(b == 0){        x = 1, y = 0;        return a;    }    LL d = exgcd(b, a % b, y, x);    y -= a / b * x;    return d;}LL inline mod(LL a, LL b){    return ((a % b) + b) % b;}int main(){    scanf("%d", &n);    LL a1, m1;    scanf("%lld%lld", &a1, &m1);    for(int i = 1; i < n; i++){        LL a2, m2, k1, k2;        scanf("%lld%lld", &a2, &m2);        LL d = exgcd(a1, -a2, k1, k2);        if((m2 - m1) % d){ puts("-1"); return 0; }        k1 = mod(k1 * (m2 - m1) / d, abs(a2 / d));        m1 = k1 * a1 + m1;        a1 = abs(a1 / d * a2);    }    printf("%lld\n", m1);    return 0;}

高斯消元

高斯消元解线性方程组

#include <iostream>#include <algorithm>#include <cmath>using namespace std;const int N = 110;const double eps = 1e-6;int n;double a[N][N];int gauss(){    int c, r;// c 代表 列 col ， r 代表 行 row    for (c = 0, r = 0; c < n; c ++ )    {        int t = r;// 先找到当前这一列，绝对值最大的一个数字所在的行号        for (int i = r; i < n; i ++ )            if (fabs(a[i][c]) > fabs(a[t][c]))                t = i;        //这一步就找到了最大的行号                if (fabs(a[t][c]) < eps) continue;// 如果当前这一列的最大数都是 0 ，那么所有数都是 0，就没必要去算了，因为它的约束方程，可能在上面几行        for (int i = c; i < n + 1; i ++ ) swap(a[t][i], a[r][i]);//// 把当前这一行，换到最上面（不是第一行，是第 r 行）去        for (int i = n; i >= c; i -- ) a[r][i] /= a[r][c];// 把当前这一行的第一个数，变成 1， 方程两边同时除以 第一个数，必须要到着算，不然第一个数直接变1，系数就被篡改，后面的数字没法算        for (int i = r + 1; i < n; i ++ )// 把当前列下面的所有数，全部消成 0            if (fabs(a[i][c]) > eps)// 如果非0 再操作，已经是 0就没必要操作了                for (int j = n; j >= c; j -- )// 从后往前，当前行的每个数字，都减去对应列 * 行首非0的数字，这样就能保证第一个数字是 a[i][0] -= 1*a[i][0];                    a[i][j] -= a[r][j] * a[i][c];        r ++ ;// 这一行的工作做完，换下一行    }    if (r < n)// 说明剩下方程的个数是小于 n 的，说明不是唯一解，判断是无解还是无穷多解    {// 因为已经是阶梯型，所以 r ~ n-1 的值应该都为 0        for (int i = r; i < n; i ++ )//             if (fabs(a[i][n]) > eps)// a[i][n] 代表 b_i ,即 左边=0，右边=b_i,0 != b_i, 所以无解。                return 2;        return 1;// 否则， 0 = 0，就是r ~ n-1的方程都是多余方程    }    //这一步的解释看看这个链接的评论区：https://www.acwing.com/solution/content/5151/    // 唯一解 ↓，从下往上回代，得到方程的解    for (int i = n - 1; i >= 0; i -- )        for (int j = i + 1; j < n; j ++ )            a[i][n] -= a[j][n] * a[i][j];//因为只要得到解，所以只用对 b_i 进行操作，中间的值，可以不用操作，因为不用输出    return 0;}int main(){    cin >> n;        //处理数据输入    for (int i = 0; i < n; i ++ )        for (int j = 0; j < n + 1; j ++ )            cin >> a[i][j];    int t = gauss();    if (t == 0)    {        for (int i = 0; i < n; i ++ ) printf("%.2lf\n", a[i][n]);    }    else if (t == 1) puts("Infinite group solutions");    else puts("No solution");    return 0;}

高斯消元解异或线性方程组

#include <iostream>using namespace std;const int N = 110;int a[N][N];int n;int gauss(){    //第一：消成同解的上三角矩阵    int r, c;    //1.枚举列,可以跳过行，但是不能跳过列    for (r = 0, c = 0; c < n; c++) {        //2.找到剩余行中的非零行        int t = r;        for (int i = r; i < n; i++)            if (a[i][c]) {                t = i;                break;            }        if (a[t][c] == 0) continue;        //3.非零行换到剩余行中的最上面        for (int i = c; i <= n; i++) swap(a[r][i], a[t][i]);        //4.剩余行中的第c列下面消成0        for (int i = r + 1; i < n; i++) {            if (a[i][c]) {                for (int j = c; j <= n; j++)                    a[i][j] ^= a[r][j];            }        }        r++;       }       //第二：判断解的情况    if (r < n) {        for (int i = r; i < n; i++)            if (a[i][n])                return 2;        return 1;    } else {        for (int i = n - 1; i >= 0; i--) {            for (int j = i + 1; j < n; j++) {                a[i][n] ^= a[i][j] * a[j][n];            }        }        return 0;    }}int main(){    //int n;    cin >> n;    for (int i = 0; i < n; i++)        for (int j = 0; j <= n; j++)            cin >> a[i][j];    int res = gauss();    if (res == 0) {        for (int i = 0; i < n; i++)            cout << a[i][n] << endl;    } else if (res == 1)         cout << "Multiple sets of solutions"<< endl;    else         cout <<   "No solution" << endl;}

求组合数

求组合数I

#include <iostream>#include <algorithm>using namespace std;const int N = 2010, mod = 1e9 + 7;int c[N][N];void init(){    for (int i = 0; i < N; i ++ )        for (int j = 0; j <= i; j ++ )            if (!j) c[i][j] = 1;            else c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;}int main(){    int n;    init();    scanf("%d", &n);    while (n -- )    {        int a, b;        scanf("%d%d", &a, &b);        printf("%d\n", c[a][b]);    }    return 0;}

排列问题

#include<iostream>using namespace std;const int N = 10;int path[N];//保存序列int state[N];//数字是否被用过int n;void dfs(int u){    if(u > n)//数字填完了，输出    {        for(int i = 1; i <= n; i++)//输出方案            cout << path[i] << " ";        cout << endl;    }    for(int i = 1; i <= n; i++)//空位上可以选择的数字为:1 ~ n    {        if(!state[i])//如果数字 i 没有被用过        {            path[u] = i;//放入空位            state[i] = 1;//数字被用，修改状态            dfs(u + 1);//填下一个位            state[i] = 0;//回溯，取出 i 回溯是关键        }    }}int main(){    cin >> n;    dfs(1);}

n皇后问题

//cpp#include <iostream>using namespace std;const int N = 11;char q[N][N];//存储棋盘bool dg[N * 2], udg[N * 2], cor[N];//点对应的两个斜线以及列上是否有皇后int n;void dfs(int r){    if(r == n)//放满了棋盘，输出棋盘    {        for(int i = 0; i < n; i++)        {            for(int j = 0; j < n; j++)                cout << q[i][j];            cout << endl;        }        cout << endl;        return;    }    for(int i = 0; i < n; i++)//第 r 行，第 i 列 是否放皇后    {        if(!cor[i] && !dg[i + r] && !udg[n - i + r])//不冲突，放皇后         //为什么这里能判断，因为同一条斜线上i + j 和 i - j 相等，所以可以这样处理        {            q[r][i] = 'Q';            cor[i] = dg[i + r] = udg[n - i + r] = 1;//对应的 列， 斜线 状态改变            dfs(r + 1);//处理下一行            cor[i] = dg[i + r] = udg[n - i + r] = 0;//恢复现场,为什么要恢复现场，准备下一种情况的输入递归            q[r][i] = '.';        }    }}int main(){    cin >> n;    for (int i = 0; i < n; i ++ )        for (int j = 0; j < n; j ++ )            q[i][j] = '.';    dfs(0);    return 0;}

BFS

走迷宫问题

#include <cstring>#include <iostream>#include <queue>using namespace std;typedef pair<int, int> PII;//有没有明白的点可以看这个链接https://www.acwing.com/solution/content/36520/const int N = 110;int g[N][N];//存储地图int f[N][N];//存储距离int n, m;void bfs(int a, int b)//广度优先遍历{    queue<PII> q;    q.push({a, b});//入队    //初始点的距离为 0.    //可以不要这一句，因为f初始化的时候，各个点为0    f[0][0] = 0;    while(!q.empty())    {        PII start = q.front();//将队列的第一个元素赋值给start元素        q.pop();//将队首元素移出,这样的操作通常用于处理当前层次的节点        //这一句可以不要，因为入队的时候就置为了1        g[start.first][start.second] = 1; //是标记当前处理的点 (start.first, start.second) 已经被访问过，避免重复访问        int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};        for(int i = 0; i < 4; i++)//往四个方向走        {            //当前点能走到的点            int x = start.first + dx[i], y = start.second + dy[i]; //仔细琢磨这个地方，就可以知道它表示四个移动方向了            //如果还没有走过            if(g[x][y] == 0) //确定是可以走的            {                //走到这个点，并计算距离                g[x][y] = 1;//标记为已经访问                f[x][y] = f[start.first][start.second] + 1;//从当前点走过去，则距离等于当前点的距离+1.                //这个点放入队列，用来走到和它相邻的点。                q.push({x, y});//将他入队            }        }    }    cout << f[n][m];//但是 BFS 本身的性质保证了在搜索过程中首次到达每个点的路径一定是最短路径}int main(){    memset(g, 1, sizeof(g)); //memset函数，将所有的数组中的元素设置为特定值    cin >> n >>m;    for(int i = 1; i <= n; i++)    {        for(int j = 1; j <= m; j++)        {            cin >> g[i][j];        }    }    bfs(1,1);}

八数码问题

#include <iostream>#include <cstring>#include <algorithm>#include <unordered_map>#include <queue>//不明白可以看这个链接https://www.acwing.com/solution/content/36346/using namespace std;// 保存各个序列queue<string> q;string s;// 保存序列与对应的交换次数unordered_map<string, int> h;int main(){    // 输入原始序列    for(int i = 1; i <= 9; i++)    {        char c;        cin >> c;        s += c;    }    // 保存初始状态    h[s] = 0;    q.push(s);    // 定义上下左右四个交换方向    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};    // 依次进行交换    while(!q.empty())    {        // 获得当前序列        string t = q.front();        q.pop();        // 如果是最后结果，输出答案        if(t == "12345678x")        {            cout << h[t] << endl;            return 0;        }        // 找到 x 的位置        int pos = t.find('x');        // 计算 x 的坐标        int a = pos /3 , b = pos % 3 ;        // 获取当前序列对应的交换次数        int dist = h[t];        // 尝试和四个方向的元素进行交换        for(int i = 0; i < 4; i++)        {            int x = a + dx[i], y = b + dy[i];            // 判断是否越界            if(x >= 0 && x <= 2 && y >= 0 && y <= 2)            {                // 交换                swap(t[pos], t[3 * x + y]);//这里这个t[3*x+y]是指的在一维中的索引位置                // 如果是个新序列，就保存新序列和对应的交换次数                if(h.find(t) == h.end())                {                    h[t] = dist + 1;                    q.push(t);                }                // 恢复现场，进行下一个方向的交换                swap(t[pos], t[3 * x + y]);//交换只是交换位置            }        }    }    // 没有得到结果序列，输出-1    cout << -1;    return 0;}

树和图的深度优先遍历

树的重心问题

#include <iostream>#include <algorithm>#include <cstring>using namespace std;//这个题目的代码我真的很迷，看了一个多小时都有点摸不着头脑const int N = 1e5 + 10; //数据范围是10的5次方const int M = 2 * N; //以有向图的格式存储无向图，所以每个节点至多对应2n-2条边int h[N]; //邻接表存储树，有n个节点，所以需要n个队列头节点int e[M]; //存储元素int ne[M]; //存储列表的next值int idx; //单链表指针int n; //题目所给的输入，n个节点int ans = N; //表示重心的所有的子树中，最大的子树的结点数目bool st[N]; //记录节点是否被访问过，访问过则标记为true//a所对应的单链表中插入b  a作为根 void add(int a, int b) {    e[idx] = b, ne[idx] = h[a], h[a] = idx++;}// dfs 框架/*void dfs(int u){    st[u]=true; // 标记一下，记录为已经被搜索过了，下面进行搜索过程    for(int i=h[u];i!=-1;i=ne[i]){        int j=e[i];        if(!st[j]) {            dfs(j);        }    }}*///返回以u为根的子树中节点的个数，包括u节点int dfs(int u) {    int res = 0; //存储 删掉某个节点之后，最大的连通子图节点数    st[u] = true; //标记访问过u节点    int sum = 1; //存储 以u为根的树 的节点数, 包括u，如图中的4号节点    //访问u的每个子节点    for (int i = h[u]; i != -1; i = ne[i]) {        int j = e[i];        //因为每个节点的编号都是不一样的，所以 用编号为下标 来标记是否被访问过        if (!st[j]) {            int s = dfs(j);  // u节点的单棵子树节点数 如图中的size值            res = max(res, s); // 记录最大联通子图的节点数            sum += s; //以j为根的树的节点数        }    }    //n-sum 如图中的n-size值，不包括根节点4；    res = max(res, n - sum); // 选择u节点为重心，最大的 连通子图节点数    ans = min(res, ans); //遍历过的假设重心中，最小的最大联通子图的节点数    return sum;}int main() {    memset(h, -1, sizeof h); //初始化h数组 -1表示尾节点    cin >> n; //表示树的结点数    // 题目接下来会输入，n-1行数据，    // 树中是不存在环的，对于有n个节点的树，必定是n-1条边    for (int i = 0; i < n - 1; i++) {        int a, b;        cin >> a >> b;        add(a, b), add(b, a); //无向图    }    dfs(1); //可以任意选定一个节点开始 u<=n    cout << ans << endl;//最后是输出ans我终于悟了    return 0;}/*它这里实际上没有删除这个概念，它就只是，找到树中的一个节点，把它一分为二，位于它下面的，和除了“从此点蔓延下去的树（包括此点）”之外的所有节点，对于它下面的这类，处理是用一个for循环遍历和此点的所有出度，找到其中节点数，也就是联通量最大的一颗子树，记录下来，然后用这颗树总的节点数减去这颗最大的子树节点，再减一，也就是减去当前的节点，得到的值就是除了“从此点蔓延下去的树（包括此点）”之外的所有节点，取个min，就是答案了，每一个点一分为二后的最优解都会存到全局变量里，也就是每一次的dfs执行，都会将当前这个点的最大联通量与全局最优联通量比较，自然执行完所有dfs，此时的全局变量就是我们的答案。说起来有点绕，其实要想明白它每一次往下递归调用dfs，不仅仅是在算子树的节点大小，同时也在并行处理当前被dfs的这个节点它的最优解，就行了,最后输出的是ans*/

树和图的广度优先遍历

图中点的层次

//简单的广度优先遍历问题#include <iostream>#include <cstring>#include <algorithm>#include <queue>using namespace std;const int N = 100010;int h[N],ne[N], e[N], idx;//邻接表数据结构int dist[N];//存储距离int st[N];//标记点是否走到过int n, m;void add(int a, int b)//邻接表存储图{    e[idx] = b, ne[idx] = h[a], h[a] = idx++;}void bfs(){    memset(dist, 0x3f, sizeof(dist));//初始都没有走到过，距离无穷大    dist[1] = 0;//从1号节点开始，距离为0    queue<int> q;//队列    q.push(1);//1号节点入队列    st[1] = 1;//1到1的距离为0，已经求出    while(q.size())//对列非空，就一直往后搜索    {        int t = q.front();//队头出队，找该点能到的点        q.pop();        for(int i = h[t]; i != -1; i = ne[i])//遍历所有t节点能到的点，i为节点索引        {            int j = e[i];//通过索引i得到t能到的节点编号            if(!st[j])//如果没有遍历过            {                dist[j] = dist[t] + 1;//距离为t号节点的距离+1                q.push(j);//节点入队                st[j] = 1;//入队后标记，已经遍历过了            }        }    }}int main(){    cin >> n >>m;    memset(h, -1, sizeof h);//初始化，所有节点没有后继，后继都是-1    for(int i = 0; i < m; i++)//读入所有边    {        int a, b;        cin >> a >> b;        add(a, b);//加入邻接表    }    bfs();//广度优先遍历    cout << (dist[n] == 0x3f3f3f3f ? -1 : dist[n]);//如果到n号节点的距离不是无穷大，输出距离，如果是无穷大，输出-1.    return 0;}

拓扑排序

有向图的拓扑序列

#include <iostream>#include <cstring>#include <algorithm>using namespace std;const int N = 100010;//有疑问看这个链接：https://www.acwing.com/solution/content/103954/int e[N], ne[N], idx;//邻接表存储图int h[N];int q[N], hh = 0, tt = -1;//队列保存入度为0的点，也就是能够输出的点，int n, m;//保存图的点数和边数int d[N];////保存各个点的入度void add(int a, int b){    e[idx] = b, ne[idx] = h[a], h[a] = idx++;}void topsort(){    for(int i = 1; i <= n; i++){//遍历一遍顶点的入度。        if(d[i] == 0)//如果入度为 0, 则可以入队列            q[++tt] = i;    }    while(tt >= hh){//循环处理队列中点的        int a = q[hh++];        for(int i = h[a]; i != -1; i = ne[i]){//循环删除 a 发出的边            int b = e[i];//a 有一条边指向b            d[b]--;//删除边后，b的入度减1            if(d[b] == 0)//如果b的入度减为 0,则 b 可以输出，入队列                q[++tt] = b;        }    }    if(tt == n - 1){//如果队列中的点的个数与图中点的个数相同，则可以进行拓扑排序        for(int i = 0; i < n; i++){//队列中保存了所有入度为0的点，依次输出            cout << q[i] << " ";        }    }    else//如果队列中的点的个数与图中点的个数不相同，则可以进行拓扑排序        cout << -1;//输出-1，代表错误}int main(){    cin >> n >> m;//保存点的个数和边的个数    memset(h, -1, sizeof h);//初始化邻接矩阵    while (m -- ){//依次读入边        int a, b;        cin >> a >> b;        d[b]++;//顶点b的入度+1        add(a, b);//添加到邻接矩阵    }    topsort();//进行拓扑排序    return 0;}

Dijstra

Dijstra求最短路径I

#include<iostream>#include <cstring>#include <algorithm>using namespace std;const int N = 510, M = 100010;int h[N], e[M], ne[M], w[M], idx;//邻接表存储图int state[N];//state 记录是否找到了源点到该节点的最短距离int dist[N];//dist 数组保存源点到其余各个节点的距离int n, m;//图的节点个数和边数void add(int a, int b, int c)//插入边{    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;}void Dijkstra(){    memset(dist, 0x3f, sizeof(dist));//dist 数组的各个元素为无穷大    dist[1] = 0;//源点到源点的距离为置为 0    for (int i = 0; i < n; i++)    {        int t = -1;        for (int j = 1; j <= n; j++)//遍历 dist 数组，找到没有确定最短路径的节点中距离源点最近的点t        {            if (!state[j] && (t == -1 || dist[j] < dist[t]))                t = j;        }        state[t] = 1;//state[i] 置为 1。        for (int j = h[t]; j != -1; j = ne[j])//遍历 t 所有可以到达的节点 i        {            int i = e[j];            dist[i] = min(dist[i], dist[t] + w[j]);//更新 dist[j]        }    }}int main(){    memset(h, -1, sizeof(h));//邻接表初始化    cin >> n >> m;    while (m--)//读入 m 条边    {        int a, b, w;        cin >> a >> b >> w;        add(a, b, w);    }    Dijkstra();    if (dist[n] != 0x3f3f3f3f)//如果dist[n]被更新了，则存在路径        cout << dist[n];    else        cout << "-1";}

Dijstra求最短路径II

//利用小根堆寻找最短距离点//priority_queue：是C++标准库中的优先队列类模板，实现了一个堆（heap）数据结构。//更多详细的解释可以看这个链接：https://www.acwing.com/solution/content/38318/#include <cstring>#include <iostream>#include <algorithm>#include <queue>//堆的头文件using namespace std;typedef pair<int, int> PII;//堆里存储距离和节点编号const int N = 1e6 + 10;int n, m;//节点数量和边数int h[N], w[N], e[N], ne[N], idx;//邻接表存储图int dist[N];//存储距离bool st[N];//存储状态void add(int a, int b, int c){    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;}int dijkstra(){    memset(dist, 0x3f, sizeof dist);//距离初始化为无穷大    dist[1] = 0;    priority_queue<PII, vector<PII>, greater<PII>> heap;//小根堆    heap.push({0, 1});//插入距离和节点编号    while (heap.size())    {        auto t = heap.top();//取距离源点最近的点        heap.pop();        int ver = t.second, distance = t.first;//ver:节点编号，distance:源点距离ver 的距离        if (st[ver]) continue;//如果距离已经确定，则跳过该点        st[ver] = true;        for (int i = h[ver]; i != -1; i = ne[i])//更新ver所指向的节点距离        {            int j = e[i];            if (dist[j] > dist[ver] + w[i])            {                dist[j] = dist[ver] + w[i];                heap.push({dist[j], j});//距离变小，则入堆            }        }    }    if (dist[n] == 0x3f3f3f3f) return -1;    return dist[n];}int main(){    scanf("%d%d", &n, &m);    memset(h, -1, sizeof h);    while (m -- )    {        int a, b, c;        scanf("%d%d%d", &a, &b, &c);        add(a, b, c);    }    cout << dijkstra() << endl;    return 0;}

bellman-ford

有边数限制的最短路

#include<iostream>#include<cstring>using namespace std;const int N = 510, M = 10010;struct Edge {    int a;    int b;    int w;} e[M];//把每个边保存下来即可int dist[N];int back[N];//备份数组防止串联int n, m, k;//k代表最短路径最多包涵k条边int bellman_ford() {    memset(dist, 0x3f, sizeof dist);    dist[1] = 0;    for (int i = 0; i < k; i++) {//k次循环 ，每一次循环都遍历所有的边        memcpy(back, dist, sizeof dist);//的memcpy函数，其目的是将存储在dist数组中的数据复制到back数组中。具体而言，memcpy用于在内存之间复制一定数量的字节。在这里，back是目标数组，dist是源数组，sizeof dist表示要复制的字节数，即dist数组的大小。        for (int j = 0; j < m; j++) {//遍历所有边            int a = e[j].a, b = e[j].b, w = e[j].w;            dist[b] = min(dist[b], back[a] + w);            //使用backup:避免给a更新后立马更新b, 这样b一次性最短路径就多了两条边出来        }    }    if (dist[n] > 0x3f3f3f3f / 2) return -1;    else return dist[n];}int main() {    scanf("%d%d%d", &n, &m, &k);    for (int i = 0; i < m; i++) {        int a, b, w;        scanf("%d%d%d", &a, &b, &w);        e[i] = {a, b, w};    }    int res = bellman_ford();    if (res == -1) puts("impossible");    else cout << res;    return 0;}

spfa

spfa求最短路

#include <iostream>#include <algorithm>#include <cstring>using namespace std;//和bellman-ford区别就在于，它更新最短路径时，没有纯暴力，采取了如果有变化就加入队列的方式const int N = 100010;int h[N], e[N], w[N], ne[N], idx;//邻接表，存储图int st[N];//标记顶点是不是在队列中int dist[N];//保存最短路径的值int q[N], hh, tt = -1;//队列void add(int a, int b, int c){//图中添加边和边的端点    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;}void spfa(){    q[++tt] = 1;//从1号顶点开始松弛，1号顶点入队    dist[1] = 0;//1号到1号的距离为 0    st[1] = 1;//1号顶点在队列中    while(tt >= hh){//不断进行松弛        int a = q[hh++];//取对头记作a，进行松弛        st[a] = 0;//取完队头后，a不在队列中了        for(int i = h[a]; i != -1; i = ne[i])//遍历所有和a相连的点        {            int b = e[i], c = w[i];//获得和a相连的点和边            if(dist[b] > dist[a] + c){//如果可以距离变得更短，则更新距离                dist[b] = dist[a] + c;//更新距离                if(!st[b]){//如果没在队列中                    q[++tt] = b;//入队                    st[b] = 1;//打标记                }            }        }    }}int main(){    memset(h, -1, sizeof h);//初始化邻接表    memset(dist, 0x3f, sizeof dist);//初始化距离    int n, m;//保存点的数量和边的数量    cin >> n >> m;    for(int i = 0; i < m; i++){//读入每条边和边的端点        int a, b, w;        cin >> a >> b >> w;        add(a, b, w);//加入到邻接表    }    spfa();    if(dist[n] == 0x3f3f3f3f )//如果到n点的距离是无穷，则不能到达         cout << "impossible";    else cout << dist[n];//否则能到达，输出距离    return 0;}

spfa求负环

#include <cstring>#include <iostream>#include <algorithm>#include <queue>using namespace std;const int N = 2010, M = 10010;int n, m;int h[N], w[M], e[M], ne[M], idx;int dist[N], cnt[N];bool st[N];void add(int a, int b, int c){    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;}bool spfa(){    queue<int> q;    for (int i = 1; i <= n; i ++ )    {        st[i] = true;        q.push(i);    }    while (q.size())    {        int t = q.front();        q.pop();        st[t] = false;        for (int i = h[t]; i != -1; i = ne[i])        {            int j = e[i];            if (dist[j] > dist[t] + w[i])            {                dist[j] = dist[t] + w[i];                cnt[j] = cnt[t] + 1;                if (cnt[j] >= n) return true; //如果路径的长度大于等于n，就说明存在负环                if (!st[j])                {                    q.push(j);                    st[j] = true;                }            }        }    }    return false;}int main(){    scanf("%d%d", &n, &m);    memset(h, -1, sizeof h);    //求负环不需要初始化距离，因为不是求取最短路径    while (m -- )    {        int a, b, c;        scanf("%d%d%d", &a, &b, &c);        add(a, b, c);    }    if (spfa()) puts("Yes");    else puts("No");    return 0;}

Floyd

Floyd求最短路

#include <iostream>using namespace std;const int N = 210, M = 2e+10, INF = 1e9;int n, m, k, x, y, z;int d[N][N];//floyd算法很简单，思路在胡凡算法笔记的398页解释的非常透彻且详细void floyd() {    for(int k = 1; k <= n; k++)        for(int i = 1; i <= n; i++)            for(int j = 1; j <= n; j++)                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);}int main() {    cin >> n >> m >> k;    for(int i = 1; i <= n; i++)        for(int j = 1; j <= n; j++)            if(i == j) d[i][j] = 0;            else d[i][j] = INF;    while(m--) {        cin >> x >> y >> z;        d[x][y] = min(d[x][y], z);        //注意保存最小的边    }    floyd();    while(k--) {        cin >> x >> y;        if(d[x][y] > INF/2) puts("impossible");        //由于有负权边存在所以约大过INF/2也很合理        else cout << d[x][y] << endl;    }    return 0;}

Prim

Prim算法求最小生成树

#include <iostream>#include <cstring>#include <algorithm>using namespace std;const int N = 510;int g[N][N];//存储图int dt[N];//存储各个节点到生成树的距离int st[N];//节点是否被加入到生成树中int pre[N];//节点的前去节点int n, m;//n 个节点，m 条边void prim(){    memset(dt,0x3f, sizeof(dt));//初始化距离数组为一个很大的数（10亿左右）    int res= 0;    dt[1] = 0;//从 1 号节点开始生成     for(int i = 0; i < n; i++)//每次循环选出一个点加入到生成树    {        int t = -1;        for(int j = 1; j <= n; j++)//每个节点一次判断        {            if(!st[j] && (t == -1 || dt[j] < dt[t]))//如果没有在树中，且到树的距离最短，则选择该点                t = j;        }        //2022.6.1 发现测试用例加强后，需要判断孤立点了        //如果孤立点，直返输出不能，然后退出        if(dt[t] == 0x3f3f3f3f) {            cout << "impossible";            return;        }        st[t] = 1;// 选择该点        res += dt[t];        for(int i = 1; i <= n; i++)//更新生成树外的点到生成树的距离        {            if(dt[i] > g[t][i] && !st[i])//从 t 到节点 i 的距离小于原来距离，则更新。            {                dt[i] = g[t][i];//更新距离                pre[i] = t;//从 t 到 i 的距离更短，i 的前驱变为 t.            }        }    }    cout << res;}void getPath()//输出各个边{    for(int i = n; i > 1; i--)//n 个节点，所以有 n-1 条边。    {        cout << i <<" " << pre[i] << " "<< endl;// i 是节点编号，pre[i] 是 i 节点的前驱节点。他们构成一条边。    }}int main(){    memset(g, 0x3f, sizeof(g));//各个点之间的距离初始化成很大的数    cin >> n >> m;//输入节点数和边数    while(m --)    {        int a, b, w;        cin >> a >> b >> w;//输出边的两个顶点和权重        g[a][b] = g[b][a] = min(g[a][b],w);//存储权重    }    prim();//求最下生成树    //getPath();//输出路径    return 0;}

Kruskal

算法求最小生成树

#include <iostream>#include <cstring>#include <algorithm>using namespace std;const int N = 100010;int p[N];//保存并查集//并查集判断是否构成回路struct E{    int a;    int b;    int w;    bool operator < (const E& rhs){//通过边长进行排序        return this->w < rhs.w;    }}edg[N * 2];int res = 0;int n, m;int cnt = 0;int find(int a){//并查集找祖宗    if(p[a] != a) p[a] = find(p[a]);    return p[a];}void klskr(){    for(int i = 1; i <= m; i++)//依次尝试加入每条边    {        int pa = find(edg[i].a);// a 点所在的集合        int pb = find(edg[i].b);// b 点所在的集合        if(pa != pb){//如果 a b 不在一个集合中            res += edg[i].w;//a b 之间这条边要            p[pa] = pb;// 合并a b            cnt ++; // 保留的边数量+1        }    }}int main(){    cin >> n >> m;    for(int i = 1; i <= n; i++) p[i] = i;//初始化并查集    for(int i = 1; i <= m; i++){//读入每条边        int a, b , c;        cin >> a >> b >>c;        edg[i] = {a, b, c};    }    sort(edg + 1, edg + m + 1);//按边长排序    klskr();    //如果保留的边小于点数-1，则不能连通    if(cnt < n - 1) {        cout<< "impossible";        return 0;    }    cout << res;    return 0;}

染色法判定二分图

染色法判定二分图

#include <iostream>#include <cstring>#include <algorithm>using namespace std;const int N = 100010 * 2;int e[N], ne[N], idx;//邻接表存储图int h[N];int color[N];//保存各个点的颜色，0 未染色，1 是红色，2 是黑色int n, m;//点和边void add(int a, int b)//邻接表插入点和边{    e[idx] = b, ne[idx]= h[a], h[a] = idx++;}bool dfs(int u, int c)//深度优先遍历{    color[u] = c;//u的点成 c 染色    //遍历和 u 相邻的点    for(int i = h[u]; i!= -1; i = ne[i])    {        int b = e[i];                           if(!color[b])//相邻的点没有颜色,则递归处理这个相邻点        {            if(!dfs(b, 3 - c)) return false;//（3 - 1 = 2， 如果 u 的颜色是2，则和 u 相邻的染成 1）                                            //（3 - 2 = 1， 如果 u 的颜色是1，则和 u 相邻的染成 2）        }        else if(color[b] && color[b] != 3 - c)//如果已经染色，判断颜色是否为 3 - c        {                                                 return false;//如果不是，说明冲突，返回                           }    }    return true;}int main(){    memset(h, -1, sizeof h);//初始化邻接表    cin >> n >> m;    for(int i = 1; i <= m; i++)//读入边    {        int a, b;        cin >> a >> b;        add(a, b), add(b, a);    }    for(int i = 1; i <= n; i++)//遍历点    {        if(!color[i])//如果没染色        {            if(!dfs(i, 1))//染色该点，并递归处理和它相邻的点            {                cout << "No" << endl;//出现矛盾，输出NO                 return 0;            }        }    }    cout << "Yes" << endl;//全部染色完成，没有矛盾，输出YES    return 0;}

匈牙利算法

二分图的最大匹配

#include<iostream>#include <cstring>#include<algorithm>using namespace std;// 邻接表存储图int n1, n2, m;int h[500], e[100010],ne[100010], idx = 0;//st 标记是否递归找过， match[x]：和 x 编号的男生的编号int st[510], match[510];//存图函数void add(int a, int b){    e[idx] = b, ne[idx] = h[a]; h[a] = idx++;}//递归找可以匹配的点//详细得思路主要是这个链接：https://www.acwing.com/solution/content/179030/bool find(int x){    // 和各个点尝试能否匹配    for(int i = h[x]; i != -1; i = ne[i]){        int b = e[i];        if(!st[b]){//打标记            st[b] = 1;            // 当前尝试点没有被匹配或者和当前尝试点匹配的那个点可以换另一个匹配            if(match[b] == 0 || find(match[b])){//注意这里find(match[b]是寻找下一个匹配的女生                // 和当前尝试点匹配在一起                match[b] = x;                return true;            }        }    }    return false;}int main(){    memset(h, -1, sizeof h);    cin >> n1 >> n2 >> m;    // 保存图，因为只从一遍找另一边，所以该无向图只需要存储一个方向    for(int i = 0; i < m; i++){        int a, b;        cin >> a >> b;        add(a, b);    }    int res = 0;    //为各个点找匹配    for(int i = 1; i <= n1; i++){        memset(st, 0, sizeof st);        //找到匹配        if(find(i)) res++;    }    cout << res;    return 0;}

最近的生活感觉特别的迷茫和枯燥，整个人不想奋斗，不想学习，不想游戏，什么都不想，唯一还在坚持做的事情，就是每天去健身房健身了，可能是最近情绪反扑了。最近真的很想陶俊余，但是我很清楚，我们之间是没有再复合的可能性了，中午的时候和段永强一起吃了鸡公煲，我的乖乖，北京的鸡公煲的价格比起四川，真的贵的不是一点半点，真的给我整无语了，坐下差点想走了，不过还是呆在那里继续吃饭了，最近一直在犹豫要不要去重庆找陶俊余的这个事情，设想过很多次从北京到重庆再回来，我心里有时候在想，也许我只是单纯的不甘心吧，但是我也不知道我不甘心啥，很奇怪，你说我去见他毫无意义，难道是去确定一下，她也后悔？她也想我？然后我们也还有可能？但是没有可能了，问题没有解决，就算重新再一起也会分手的，短时间在一起，长时间也会分手的，没有任何意义我觉得，而且主动权也不在我的手上，但是去重庆找她的念头，好像有魔力一样，一发就不可收拾，又找方姐谈了下这个事情，方姐最近应该是很忙，但是还是回复了我，以后还是尽量少打扰人家，也少窥探人家的生活，我是说陶俊余的，但是感觉现在明显比半年前好了，希望再过半年，我可以更好

学习

要抓紧了，要好好学习了，不要再荒废时间了，想回家了，这破学校真的一天都呆不下去了，受不了张金豪这个傻逼，世界上怎么会有这么傻逼的人。

如何输入多个操作
eg:第一行包含整数 N，表示操作数。接下来 N 行，每行包含一个操作指令
answer:

while (n -- )    {        char op[2];        scanf("%s%s",op str);    }```C++

最近痘痘看了很久的医生。已经消除的差不多了，下一步就是祛痘印的过程，坚持坚持，然后，我今天翻视频发现我好像白了不少，我待会会把视频传上来，最近解锁了一个新的爱好，觉得自己好像真的好喜欢做饭，以后想做一个好的厨师，可能是在成都给陶俊余做了之后，发现自己真的挺喜欢做饭的

手臂分为二头肌和三头肌，所以练手臂用四个动作，两个动作练二头，两个动作练三头

动作篇

第一个动作—–哑铃弯举

首先大臂固定住，发力，然后收到最紧，二头收到最紧的时候停住，然后往下放，放的时候，不要放到完全打直，放到一点点微曲，然后再发力就可以，选择一个重量，然后每组只能做八次到十二次之间，这个重量就是适合你，做完一边，再做另一边，不要交替去做，咱们做的时候，手腕保持中立位，手腕不要往下踏，两边都练完，然后休息40s左右，然后进行下一组就可以了，做四组

第二个动作—-杠铃弯举

首先，握距和肩等宽，然后也是大臂固定住发力，收到最紧，然后往下放，放的时候要匀速往下放，不要放的太快，不要晃动，这个也是一组做12个，然后做四组，组间休息50s左右就可以

第三个动作—–绳索臂屈伸

首先握住这个两边，然后身体前倾，固定住大臂，三头发力往下压，压的时候，侧面看手臂垂直于地面，然后手臂完全打直就ok,一定要就是尽量打直的时候，两条手臂是平行的，不要怼到一块，顶峰有一个短暂的停留，停留0.5s左右，每组十二次，做四组

第四个动作—-俯身哑铃臂屈伸

首先俯身，然后身体呈一个弓箭步，身体不要扭太多，大臂水平与地面不要动，手臂完全打直，放的时候完全放下去，做这个动作一定要把手臂打到最直，越直越好，这样你的三头感觉才会更强，每组做十二次，做四组

第一个动作—-哑铃推举

哑铃推举的时候，小臂是始终垂直于地面的，推的时候，想象把哑铃往正上方推，推的时候，两个哑铃是微微八字，放的时候，放到耳朵两侧就可以，推的时候再往上推，发力，手臂不要完全打直，只要肩膀收紧就可以，这个时候，前束最受力，从侧面看，肘关节要微微在肩膀的前侧，这样肩关节的压力还是最小，推的时候，从侧面看，小臂始终垂直于地面，坐在凳子上推荐的时候，屁股可以微微往前去一点（也就是往前做一点），去五公分左右，然后背部贴近凳子，做四组，每组12次，组间休息休息到50秒到一分钟都可以。

第二个动作—–哑铃侧平举

首先我们拿到哑铃之后，要把哑铃放到大腿前侧，然后沉肩，什么是沉肩，就是耸肩的反义词，沉肩，固定住斜方肌，然后中束发力，记住做的过程中，尽量也不要缩脖子去做，始终往下压着肩，从正面看，肩最高，肘第二，手第三的高度关系不要错，手腕保持中立位置，也不要往下掉，也不用往上飞，中立位就可以，肘在肩膀的前侧，这样去做。每组十二次，做四组

第三个动作——哑铃俯身飞鸟

做这个动作，有一个点就很重要，就是要控制住肩胛骨，推出去含胸，是肩胛骨打开的一个状态，咱们做哑铃俯身飞鸟的时候，，就要保持肩胛骨始终打开的这样一个状态，这样才能更好的刺激我们的这个后束，咱们首先要找到一个凳子，屁股尽量往前坐，腿部下面留有足够的空间，然后俯身，肩胛骨打开，保持打开这样的一个固定的角度，一直打开，然后后束发力，把哑铃完全收紧，手臂不要完全打直，微曲，每组12次，每次做四组

开肩—-两只手扶着一个杠俯身打开肩胛骨，同时也能适当拉伸一下背阔肌–压十秒钟左右就好

练背篇

第一个动作—高位下拉

首先稳定住自己的下半身，腿卡住，卡紧，完全卡死，然后把肩胛骨往上送，背阔肌拉长，收的时候，肩胛骨下沉，然后拉的时候，把杠拉到自己的锁骨上面。肩胛骨收住

两个注意点：
第一：往下拉的时候，拉到锁骨上方
第二：肩胛骨往上放的时候，一定要完全放上去，背阔肌充分拉伸，然后拉的时候，尽量往下夹住，夹到最紧，让行程达到最大化
第三：做这个动作可以往后仰，但不能往后太多，微微向后仰一点，收紧就ok
第四：因为这是第一个动作，所以我们组数可以做多一点，一般会做到六组，然后重量采用依次递增，这样既能热身，又能激活自己的肌肉，重量可以从四片开始，然后两片两片的加，一直加到第六组，如果加到后面重量加不动了，那就用这个固定的重量一直做到第六组就结束

第二个动作—坐姿划船

首先固定好自己的下半身，然后腰部挺直，往前送，把肩胛骨打开送出去，收的时候挺胸，把把手拉到自己的肚子上面，夹肘，肘夹紧挺胸，肩胛骨使劲往后夹收住，这就是顶峰的动作，有一个短暂的停顿0.5s，放身体微前倾，打开肩胛骨收夹肘

特点：首先要把肩胛骨送出去，让行程达到最大化，然后收的时候就紧贴着身体往后收，夹住，把杠拉到自己肚子上面挺胸，这样背阔肌、大圆肌才能完全收住，这个动作我们需要做四组，然后采用固定重量，次数在八到十二次之间

第三个动作—-直臂下压

这个动作也是练背阔肌，大小圆肌的一个动作，首先，身体往后站一点，身体前倾固定住，然后手臂和身体，呈一条直线，尽量拉长自己的背阔肌，收的时候，想象一个画弧的过程，收的时候，前三分之二的路程是直臂，最后曲臂收紧，把杠拉到自己腰带的位置，最后有一个夹背的动作，肩胛骨往后收，肘往后夹

注意：
因为这个动作比较轻松，所以每组需要做12-15次之间

第四个动作—窄距高位下拉

首先夹住把手的近端，也就是离你近的这一端，然后肩胛骨往上送，把背阔肌完全拉长，身体微微向后仰挺胸，然后把手拉到自己的胸前，这个时候，腰是一个微微反弓的状态，送上去，这个动作我们选择固定重量，做四组，每组12次就可以

第五个动作—杠铃俯身划船

这个动作，也是我们练背当中必不可少的一个动作，首先，俯身屈膝，腰挺直，把力施加在腿后侧链上，减少腰部压力，肩胛骨下沉，把杠铃放出去，收的时候，杠顺着自己大腿的方向，平行往后，夹肘，收肩胛骨，这个杠铃划船我们采用固定的重量，做五组，每组要做到十二次

第六个动作—宽距坐姿划船

这个动作，是锻炼我们比较薄弱的中上背
注意点：
第一：是宽距的，可以用高位下拉的把手
第二：拉的时候，拉到胸部的位置，普通的坐姿划船是拉到肚子这里，这个动作就不需要刻意去夹肘了
第三：还是腰注意的是，把肩胛骨完全的送到前面，然后收的时候挺胸，肩胛骨使劲向后夹，这样完全夹住，这样才能最大程度的刺激到我们的中背部，这个动作，采用固定的重量，因为重量比较小，所以每组要做到十五次，做四组就结束了

总结

这六个动作，要在90分钟内做完，然后小白组间休息可以到一分钟，新手练背会遇到很多困难，因为手臂借力或者前臂借力等，给新手的建议是，不要依赖助力带

第一个动作

大臂水平保持不动，小臂往后摆甩–经典招财猫动作–20次为一组，一次一组，可以速度快一点，幅度大一点

第二个动作

大臂夹紧身体，小臂往外，往外甩，幅度大一点—20次为一组，一次一组

第三个动作

手臂长大点，向前画圆，抡的越圆越大越好—-20圈为一组，一次一组

第四个动作

手臂长大点，向后画圆，抡的越圆越大越好—-20圈为一组，一次一组

练胸篇

第一个动作—-杠铃平板卧推–黄金动作

首先，你要找你的眼睛和这个杠的位置，你的眼睛要在这个杠的正下方

脚微微的往里面收一点，身体成一个反弓的姿态

如何调整握距

首先你要保持自己握对称，然后起杠之后，先往下放，放到杠铃触胸的时候，看看小臂是否和杠垂直（这样很重要）

如何调整手腕

采用全握，自由重量一定要采用全握，大拇指扣紧，让杠的重量，压在小臂的延长线上

推举的方式

杠铃往下放的的时候，放到乳头，上下一两公分的位置都可以，从侧面靠，小臂始终垂直于地面

身体动作

推的时候，收紧肩胛骨，肩胛骨微往后夹一点点，肩膀下沉，挺胸，推的时候，手臂不要完全打直，微曲，胸部收紧就可以，放的时候匀速往下放，杠铃的轨迹，你就想象成推的直上直下，大臂和身体的夹角大约是四十五度

呼吸

杠下来的时候吸气，发力的时候，吐出去

第二个动作—蝴蝶机夹胸

位置调整

要让你的肩，高于你的手，一拳左右的距离

身体部位

手臂全程打直，手臂内侧相对，胸部收紧，肩膀不要往前，肩胛骨微微向后。手臂微曲，始终感觉是挺胸的状态去做，肘向后的时候，手臂不要打太直，发力的时候，手打直，下去的时候手弯曲，也是做4组，每组12次

第三个动作—哑铃上斜卧推

肩胛骨向后微微缩紧，手臂打直，将哑铃举起，哑铃微微成八字，往下放，放到胸部两侧，这个时候，大臂和身体，大约是一个45度的角度，垂直往上发力，做四组，每组12次

生活

2023年的生活过的一塌糊涂，从新年的第一天就一直吵架，3月复试失败，4月到六月感情不顺，六月分手到如今，患上了抑郁症，还困在感情里走不出来，至今还在疗伤，2023过的一团糟糕，对于2023年，我对自己的忠告的是，以后做什么决定，一定不要头脑一热就去做，要仔细想，反复想，关于生活的选择，有可能从一开始就决定了一项重大事情的失败，我时常会想，假如当时我选择了向父母要钱，而不是去工作，我和陶俊余，会走到今天这步吗，我想好的心态真的决定了最终问题的走向，所以以后在生活的选择上，一定要好好想，站在十年之后想，十年之后，你会希望自己怎么做，做出怎样的选择，拥有怎么样的人生体验

事业

事业坎坎坷坷，复试失败后，居然调剂到了中石油，这辈子没想过来北方，只能说，也许一切冥冥之中自有安排。

未来展望

不要浪费时间，把时间花费在学习，健身，看书上，珍惜人生的每一缕光阴

长相

2023的气质变化真的巨大，具体见下图

数据结构

单链表

=#include <iostream>using namespace std;const int N = 100010;/*这个题的理解上有一个问题困扰了我很久，就是这个Idx究竟代表什么，翻了很多的评论，我觉得以下这个评论我觉得很合适说说的我个人对idx的理解先区分两个概念：节点和结点节点：一个点结点：链表的元素，含e[idx],ne[idx]两个部分e[idx]:结点编号为idx对应的节点值ne[idx]：结点编号为idx对应的下一个结点的编号区分完这两个概念应该能理解idx的作用，为结点编号我觉得看完这个之后，应该就能很好的理解这个代码*/// head 表示头结点的下标// e[i] 表示节点i的值// ne[i] 表示节点i的next指针是多少// idx 存储当前已经用到了哪个点int head, e[N], ne[N], idx;// 初始化void init(){    head = -1;    idx = 0;}// 将x插到头结点void add_to_head(int x){    e[idx] = x, ne[idx] = head, head = idx ++ ;}// 将x插到下标是k的点后面void add(int k, int x){    e[idx] = x, ne[idx] = ne[k], ne[k] = idx ++ ;}// 将下标是k的点后面的点删掉void remove(int k){    ne[k] = ne[ne[k]];}int main(){    int m;    cin >> m;    init();    while (m -- )    {        int k, x;        char op;        cin >> op;        if (op == 'H')        {            cin >> x;            add_to_head(x);        }        else if (op == 'D')        {            cin >> k;            if (!k) head = ne[head];            else remove(k - 1);        }        else        {            cin >> k >> x;            add(k - 1, x);        }    }    for (int i = head; i != -1; i = ne[i]) cout << e[i] << ' ';    cout << endl;    return 0;}

双链表

#include <iostream>using namespace std;const int N = 100010;/*这个题目，初始的时候我看的有点懵逼，在这个模板里，加了两个哑巴结点，这样就能够减少操作，实际上0和1这个结点一直不会被删除，是一个很好的做法*/int m;int e[N], l[N], r[N], idx;// 在节点a的右边插入一个数xvoid insert(int a, int x){    e[idx] = x;    l[idx] = a, r[idx] = r[a];    l[r[a]] = idx, r[a] = idx ++ ;}// 删除节点avoid remove(int a){    l[r[a]] = l[a];    r[l[a]] = r[a];}int main(){    cin >> m;    // 0是左端点，1是右端点    r[0] = 1, l[1] = 0;    idx = 2;    while (m -- )    {        string op;        cin >> op;        int k, x;        if (op == "L")        {            cin >> x;            insert(0, x);        }        else if (op == "R")        {            cin >> x;            insert(l[1], x);        }        else if (op == "D")        {            cin >> k;            remove(k + 1);        }        else if (op == "IL")        {            cin >> k >> x;            insert(l[k + 1], x);        }        else        {            cin >> k >> x;            insert(k + 1, x);        }    }    for (int i = r[0]; i != 1; i = r[i]) cout << e[i] << ' ';//输出的时候也是从r[0]输出，没有输出哑巴结点    cout << endl;    return 0;}

栈

模拟栈

#include <iostream>using namespace std;const int N = 100010;int st[N];int top = -1;int n;int main(){    cin >> n;    while(n--)    {        string s;        cin >> s;        //栈顶所在索引往后移动一格，然后放入x。        if(s == "push")        {            int a;            cin >> a;            st[++top] = a;        }        //往前移动一格        if(s == "pop")        {            top --;        }        //返回栈顶元素        if(s == "query")        {            cout << st[top] << endl;        }        //大于等于 0 栈非空，小于 0 栈空        if(s == "empty")        {            cout << (top == -1 ? "YES" : "NO") << endl;        }    }}

表达式求值

#include <iostream>#include <stack>#include <string>#include <unordered_map>using namespace std;stack<int> num;stack<char> op;//优先级表unordered_map<char, int> h{ {'+', 1}, {'-', 1}, {'*',2}, {'/', 2} };void eval()//求值{    int a = num.top();//第二个操作数    num.pop();    int b = num.top();//第一个操作数    num.pop();    char p = op.top();//运算符    op.pop();    int r = 0;//结果     //计算结果    if (p == '+') r = b + a;    if (p == '-') r = b - a;    if (p == '*') r = b * a;    if (p == '/') r = b / a;    num.push(r);//结果入栈}int main(){    string s;//读入表达式    cin >> s;    for (int i = 0; i < s.size(); i++)    {        if (isdigit(s[i]))//数字入栈        {            int x = 0, j = i;//计算数字            while (j < s.size() && isdigit(s[j]))            {                x = x * 10 + s[j] - '0';                j++;            }            //这个地方的理解可以看看海绵宝宝题解的第一条评论，写的很好            num.push(x);//数字入栈            i = j - 1;        }        //左括号无优先级，直接入栈        else if (s[i] == '(')//左括号入栈        {            op.push(s[i]);        }        //括号特殊，遇到左括号直接入栈，遇到右括号计算括号里面的        else if (s[i] == ')')//右括号        {            while(op.top() != '(')//一直计算到左括号                eval();            op.pop();//左括号出栈        }        else        {            while (op.size() && h[op.top()] >= h[s[i]])//待入栈运算符优先级低，则先计算                eval();            op.push(s[i]);//操作符入栈        }    }    while (op.size()) eval();//剩余的进行计算    cout << num.top() << endl;//输出结果    return 0;}

队列

模拟队列

#include <iostream>using namespace std;const int N = 100010;int q[N];//[hh, tt] 之间为队列（左闭右闭）int hh = 0;//队头位置int tt = -1;//队尾位置//操作次数int m;//操作方式string s;//入队：队尾先往后移动一格，再放入要插入的数据void push(int x){    q[++tt] = x;}//出队：队头往后移动一格void pop(){    hh++;}//[hh, tt]表示队列区间，当tt >= hh时，区间不为空void empty(){    if(tt >= hh) cout << "NO" << endl;    else cout << "YES" << endl;} //hh指向队头，q[hh]代表队头元素void query (){    cout << q[hh] << endl;}int main(){    cin >> m;    while(m--){        cin >> s;        //入队        if(s == "push"){            int x;            cin >> x;            push(x);        }        //出队        if(s == "pop"){            pop();        }        //问空        if(s == "empty"){            empty();        }        //问队头        if(s == "query"){            query();        }    }}

单调栈

#include <iostream>using namespace std;const int N = 100010;int stk[N], tt;int main(){    int n;    cin >> n;    while (n -- )    {        int x;        scanf("%d", &x);        while (tt && stk[tt] >= x) tt -- ;        if (!tt) printf("-1 ");        else printf("%d ", stk[tt]);        stk[ ++ tt] = x;    }    return 0;}

单调队列

#include <iostream>using namespace std;const int N = 1000100;//这段代码中很关键的点在于，q[N]中存的是数组下标，而不是数组元素//单调队列一般用双端队列保证其单调性int a[N], q[N], n, k;//队头和队尾，在队尾插入，队头获取int front = 0, tail = -1;int main() {    scanf("%d%d", &n, &k);    for (int i = 0; i < n; i++) scanf("%d", &a[i]);    //先找每个窗口的最小值    for (int i = 0; i < n; i++) {        //如果当前队头在数组的下标小于当前窗口的最小下标，这个窗口就不包含这个元素了那么无论如何都要剔除队头这个元素        //所以要在队头删除这个元素        if (front <= tail && i - k + 1 > q[front]) front++;        //保证单调性，在队尾删除（为什么要在队尾删除，简单来说在队头删除不能保证单调        //比如-3 5为当前队列，当前的元素为3，如果在队头操作，那么按照a[i] <= a[q[front]，有3 > -3，因此不做删除操作        //但是接下来就出现问题了，3就要入队了。此时队列就是-3 5 3，不符合单调性了！        //但如果在队尾操作，按照a[i] <= a[q[tail]，有3 < 5，就要让5出队        //之后3入队，队列就是-3 3，满足单调性        while (front <= tail && a[i] <= a[q[tail]]) tail--;        q[++tail] = i;        //队头为窗口的最小值        if (i >= k - 1) printf("%d ", a[q[front]]);    }    printf("\n");    //这次找最大值，同理    front = 0, tail = -1;    for (int i = 0; i < n; i++) {        if (front <= tail && i - k + 1 > q[front]) front++;        while (front <= tail && a[i] >= a[q[tail]]) tail--;        q[++tail] = i;        if (i >= k - 1) printf("%d ", a[q[front]]);    }}

KMP

//这段代码我还有很多没明白的地方，回头看看算法笔记#include <iostream>using namespace std;const int N = 100010, M = 1000010;int n, m;int ne[N];char s[M], p[N];int main(){    cin >> n >> p + 1 >> m >> s + 1;    //求next数组    for (int i = 2, j = 0; i <= n; i ++ )    {        while (j && p[i] != p[j + 1]) j = ne[j];        if (p[i] == p[j + 1]) j ++ ;        ne[i] = j;    }    //匹配代码    for (int i = 1, j = 0; i <= m; i ++ )    {        while (j && s[i] != p[j + 1]) j = ne[j];        if (s[i] == p[j + 1]) j ++ ;        if (j == n)        {            printf("%d ", i - n);            j = ne[j];        }    }    return 0;}

Trie (专门用来处理存储字符串的集合问题)

Trie字符串统计

#include <iostream>using namespace std;const int N = 100010;//trie树专门用来处理存储字符串的集合问题，如果还是有不懂的地方，参照这篇博客//https://blog.csdn.net/raelum/article/details/128885107int son[N][26], cnt[N], idx;char str[N];void insert(char *str){    int p = 0;    for (int i = 0; str[i]; i ++ )    {        int u = str[i] - 'a';        if (!son[p][u]) son[p][u] = ++ idx;        p = son[p][u];    }    cnt[p] ++ ;}int query(char *str){    int p = 0;    for (int i = 0; str[i]; i ++ )    {        int u = str[i] - 'a';        if (!son[p][u]) return 0;        p = son[p][u];    }    return cnt[p];}int main(){    int n;    scanf("%d", &n);    while (n -- )    {        char op[2];        scanf("%s%s", op, str);        if (*op == 'I') insert(str);        else printf("%d\n", query(str));    }    return 0;}

最大异或对

#include <iostream>#include <algorithm>//有不懂的地方，看这篇博客https://blog.csdn.net/raelum/article/details/128885107using namespace std;const int N = 100010, M = 3100010;int n;int a[N], son[M][2], idx;void insert(int x){    int p = 0;    for (int i = 30; i >= 0; i -- )    {        int &s = son[p][x >> i & 1];        if (!s) s = ++ idx;        p = s;    }}int search(int x){    int p = 0, res = 0;    for (int i = 30; i >= 0; i -- )    {        int s = x >> i & 1;        if (son[p][!s])        {            res += 1 << i;//这是等于加上2^i次方            p = son[p][!s];        }        else p = son[p][s];    }    return res;}int main(){    scanf("%d", &n);    for (int i = 0; i < n; i ++ )    {        scanf("%d", &a[i]);        insert(a[i]);    }    int res = 0;    for (int i = 0; i < n; i ++ ) res = max(res, search(a[i]));    printf("%d\n", res);    return 0;}

并查集

合并集合

#include<bits/stdc++.h>using namespace std;const int N = 100010;int p[N];//建立一个父结点数组int n,m;int find(int x)//find函数，路径压缩{    if(p[x]!=x) p[x]=find(p[x]);//如果祖宗结点不是自己，那么路径压缩；    return p[x];}int main(){    scanf("%d%d", &n, &m);    for (int i = 1; i <=n; i ++ ) p[i]=i;    while (m -- )    {        int a,b;        char op[2];//两个操作        scanf("%s%d%d",op, &a, &b);        if(op[0]=='M') p[find(a)]=find(b);        else        {            if(find(a)==find(b)) puts("Yes");            else                puts("No");        }    }    return 0;}

连通块中点的数量

#include<bits/stdc++.h>using namespace std;const int N = 100010;int p[N],cnt[N];int find(int x){    if(p[x]!=x) p[x]=find(p[x]);    return p[x];}int main(){    int n,m;    scanf("%d%d", &n, &m);    for (int i = 1; i <= n; i ++ )    {        p[i]=i;        cnt[i]=1;    }    while (m -- )    {        string op;        cin>>op;        int a,b;        if(op=="C")        {            cin >> a>>b;            a=find(a),b=find(b);            if(a!=b)            {                p[a]=b;                cnt[b]+=cnt[a];            }        }        else if(op=="Q1")        {            cin >> a>>b;            if(find(a)==find(b)) puts("Yes");            else puts("No");        }        else         {            cin >> a;            int x=find(a);            cout << cnt[x]<<endl;        }    }    return 0;}

食物链、

#include <iostream>using namespace std;const int N = 1e5 + 10;//这个算法的关键是划分集合,，用距离来判断是否属于同一类，思路实在是很绝，来判断是不是真话，如果有疑问，可以看yxc代码的评论区int n, m;int p[N], d[N]; //p[]寻找祖宗节点，d[]求到祖宗节点的距离int find(int x){    if (p[x] != x)    {        int t = find(p[x]); // u暂时存一下p[x]根节点，辅助变量        d[x] += d[p[x]];    // 更新距离        p[x] = t;    }    return p[x];}// 不行，因为这个路径的长度（高度），是需要自上而下加起来的，从根节点往下走// 所以要先调用递归// int find(int x)// {//     if (p[x] != x)//     {//         d[x] += d[p[x]];    // 更新距离//         p[x] = find(p[x]); //     }//     return p[x];// }int main(){    scanf("%d%d", &n, &m);    for (int i = 1; i <= n; i ++ ) p[i] = i;    int res = 0;//记录错误数    while (m -- )    {        int t, x, y;        scanf("%d%d%d", &t, &x, &y);        if (x > n || y > n) res ++ ; // 当前的话中X或Y比N大，是假话        else        {            int px = find(x), py = find(y); // 查找根节点            if (t == 1) // 判断是否同类            {                if (px == py) {  // 若 x 与 y 在同一个集合中                    if ((d[x] - d[y]) % 3) res ++ ; // 两数到根节点距离之差的模不为 0，说明不是同一类，是假话                    // 其中 (d[x] - d[y]) % 3 不可写为 d[x] % 3 != d[y] % 3                    // 因为 d[x], d[y] 可能为负数（一正一负），可改做 (d[x] % 3 + 3) % 3 != (d[y] % 3 + 3) % 3                    // 负数 mod 正数为负数                } else {    // 则 x 与 y 不在同一个集合中                    p[px] = py;     // x 所在集合 合并到 y 所在集合                    d[px] = d[y] - d[x];//这里是先把所有的存到一个集合里的意思，认定没出现在集合里的第一句话为真话                    // d[x] 的距离为什么不更新？                    // 只是暂时不更新，在调用 find 时再更新                }            }            else // X 是否吃 Y            {                if (px == py) {     // 若 x 与 y 在同一个集合中                    // 若 X 吃 Y，则 d[x] 比 d[y] 大 1                    if ((d[x] - d[y] - 1) % 3) res ++ ;  // 若距离之差 - 1 的模不为 0，说明吃不掉，是假话                } else {    // 则 x 与 y 不在同一个集合中                    p[px] = py;                    // (d[x] - d[y] - 1) % 3 == 0                    // d[x] + d[px] - 1 = d[y]  则：                    d[px] = d[y] + 1 - d[x];//这里和上面一样                }            }        }    }    printf("%d\n", res);    return 0;}

堆

堆排序

#include <iostream>#include <algorithm>//详细的内容看这个链接：https://www.acwing.com/solution/content/120483///以及这个链接：https://raelum.blog.csdn.net/article/details/128800503using namespace std;const int N = 100010;int n, m;int h[N], cnt;void down(int u) //小根堆的构建方法{    int t = u;    if (u * 2 <= cnt && h[u * 2] < h[t]) t = u * 2;    if (u * 2 + 1 <= cnt && h[u * 2 + 1] < h[t]) t = u * 2 + 1;    if (u != t)    {        swap(h[u], h[t]);        down(t);    }}int main(){    scanf("%d%d", &n, &m);    for (int i = 1; i <= n; i ++ ) scanf("%d", &h[i]);    cnt = n;    for (int i = n / 2; i; i -- ) down(i);//这样就构建成了一个小根堆    while (m -- )    {        printf("%d ", h[1]);//初始时这个h[1]为什么是最小值        h[1] = h[cnt -- ];        down(1);    }    puts("");    return 0;}

模拟堆

#include <iostream>#include <algorithm>using namespace std;const int N = 1e5 + 10;int heap[N], cnt;int ph[N];  // 记录第k个插入的元素的下标(次序->下标)int hp[N];  // 记录当前元素下标对应元素插入的次序(也就是第几个插入的 下标->次序)/*    原来交换是直接交换堆中的两个元素，但是本题需要对第k个插入的数修改，    所以我们需要一个数组ph来存储第k次插入的元素的下标，所以当我们交换两个元素时，    存储下标的数组对应位置也需要交换，从而保证第k次插入的元素与其下标对应。    然而由于交换操作传入的是两个元素在堆中的下标，若我们要交换下标记录数组ph数组中对应的下标，    则需要知道这两个元素是第几个插入的，所以我们需要一个hp数组来存放下标对应元素的插入次序，    于是当我们交换两个元素时，存储数组元素插入次序的对应位置也需要交换，    从而保证当前下标对应的元素与其插入次序对应。*/void heap_swap(int a, int b) {    // 注意不能改为swap(a, b)，因为我们是要将数组ph中保存的两元素的下标进行交换，否则数组ph中的位置并未改变。    swap(ph[hp[a]], ph[hp[b]]);  // 先由hp找到对应的插入次序，然后交换ph数组中记录的两个元素的下标    swap(hp[a], hp[b]);         // 交换hp数组中记录的两个元素的插入次序    swap(heap[a], heap[b]);    // 最后交换堆中的两个元素}void downAdjust(int u) {    int m = u;    if (u * 2 <= cnt && heap[u * 2] < heap[m]) m = u * 2;    if (u * 2 + 1 <= cnt && heap[u * 2 + 1] < heap[m]) m = u * 2 + 1;    if (u != m) {                   // 如果当前结点不为最小结点        heap_swap(u, m);        downAdjust(m);    }}void upAdjust(int u) {    while (u / 2 && heap[u / 2] > heap[u]) {        heap_swap(u, u / 2);        u /= 2;    }}int main() {    int index = 0;                  // 记录每个元素插入的次序     int n = 0;    cin >> n;    while (n--) {        string op;        cin >> op;        int x, k;        if (op == "I") {            // 插入一个数x            cin >> x;            cnt++;            index++;                // 记录当前元素是第几次插入的            ph[index] = cnt;        // 堆尾插入，故第index次插入的元素下标为cnt            hp[cnt] = index;        // 当前下标为cnt的元素为第index次插入            heap[cnt]=x;            // 记录插入的值(即heap[ph[index]] = x)            upAdjust(cnt);          // 从堆尾向上调整        } else if (op == "PM") {    // 输出当前集合中的最小元素            cout << heap[1] << endl;        } else if (op == "DM") {    // 删除当前集合中的最小值            heap_swap(1, cnt);      // 将堆头元素与堆尾元素交换            cnt--;            downAdjust(1);        } else if (op == "D") {     // 删除第k个插入的数            cin >> k;            /*                为什么需要用pos保存第k次插入元素的下标？                因为当我们执行完heap_swap(pos, cnt)操作后，第k次插入元素的下标会变成cnt(即ph[k] = cnt)，                而我们需要调整的是交换后的原来cnt位置上的元素(其下标变为了pos)，所以需要保存下来。            */            int pos = ph[k];        // 由插入次序得到在堆中的下标            heap_swap(pos, cnt);    // 将第k个插入的数与堆尾元素交换            cnt--;                  // 堆容量减一            upAdjust(pos), downAdjust(pos);          } else if (op == "C") {     // 修改第k个插入的数，将其变为x             cin >> k >> x;            int pos = ph[k];        // 得到第k个插入的元素的下标            heap[pos] = x;          // 修改第k个插入的数            upAdjust(pos), downAdjust(pos);        }    }    return 0;}

哈希表

模拟散列函数

#include <cstring>#include <iostream>using namespace std;const int N = 200003, null = 0x3f3f3f3f;int h[N];//find 函数实现了开放寻址法的线性探测。首先计算哈希值 t，然后循环查找直到找到空位置或者找到目标值 x。如果找到了空位置，或者找到了目标值 x 所在的位置，返回该位置。int find(int x){    int t = (x % N + N) % N;    while (h[t] != null && h[t] != x)     {        t ++ ;        if (t == N) t = 0;//当遍历到最后一个元素的时候，从头开始寻找    }    return t;}int main(){    memset(h, 0x3f, sizeof h);//用 `memset` 函数将数组 `h` 中的所有元素初始化为 `0x3f3f3f3f`，即 `null`。    int n;    scanf("%d", &n);    while (n -- )    {        char op[2];        int x;        scanf("%s%d", op, &x);        if (*op == 'I') h[find(x)] = x;        else        {            if (h[find(x)] == null) puts("No");            else puts("Yes");        }    }    return 0;}

字符串哈希

#include<iostream>#include<cstdio>#include<string>using namespace std;typedef unsigned long long ULL;const int N = 1e5+5,P = 131;//131 13331ULL h[N],p[N];//可以仔细看这两个链接：https://www.acwing.com/solution/content/24738///https://www.acwing.com/solution/content/205524/// h[i]前i个字符的hash值// 字符串变成一个p进制数字，体现了字符+顺序，需要确保不同的字符串对应不同的数字// P = 131 或  13331 Q=2^64，在99%的情况下不会出现冲突// 使用场景： 两个字符串的子串是否相同ULL query(int l,int r){    return h[r] - h[l-1]*p[r-l+1];}int main(){    int n,m;    cin>>n>>m;    string x;    cin>>x;    //字符串从1开始编号，h[1]为前一个字符的哈希值    p[0] = 1;    h[0] = 0;    for(int i=0;i<n;i++){        p[i+1] = p[i]*P; //求p的多少次方用的，比如p[i]就是p的i次方                  h[i+1] = h[i]*P +x[i];      //前缀和求整个字符串的哈希值        //假设字符串为“123”，那h[2]=(1p^2+2p^1+3p^0) 又等于h[1]p+s[2] 即 (1p^1+2p^0)p+3,这里的123其实实际上不是数字，是用它的ASSIC码计算，为了方便理解才直接用数字    }    while(m--){        int l1,r1,l2,r2;        cin>>l1>>r1>>l2>>r2;        if(query(l1,r1) == query(l2,r2)) printf("Yes\n");        else printf("No\n");    }    return 0;}

排序

快速排序模板

#include<iostream>#include<bits/stdc++.h>using namespace std;const int N = 100010;int q[N];void quick_sort(int q[],int l,int r){    if(l>=r)  return;    int i=l-1,j=r+1, x=q[l+r>>1];    while(i<j)    {        do i++; while(q[i]<x);        do j--; while(q[j]>x);        if(i<j) swap(q[i],q[j]);    }    quick_sort(q,l,j);    quick_sort(q,j+1,r);    }int main(){    int n;    scanf("%d",&n);    for(int i=0;i<n;i++) scanf("%d",&q[i]);    quick_sort(q,0,n-1);    for(int i=0;i<n;i++) printf("%d ",q[i]);    return 0;    }

归并排序模板

#include<bits/stdc++.h>using namespace std;const int N=1000010;int q[N],temp[N];void merge_sort(int q[], int l, int r){    //递归的终止情况    if(l >= r) return;    //第一步：分成子问题    int mid = l + r >> 1;    //第二步：递归处理子问题    merge_sort(q, l, mid ), merge_sort(q, mid + 1, r);    //第三步：合并子问题    int k = 0, i = l, j = mid + 1, tmp[r - l + 1];    while(i <= mid && j <= r)        if(q[i] <= q[j]) tmp[k++] = q[i++];        else tmp[k++] = q[j++];    while(i <= mid) tmp[k++] = q[i++];    while(j <= r) tmp[k++] = q[j++];    for(k = 0, i = l; i <= r; k++, i++) q[i] = tmp[k];}int main(){    int n;    scanf("%d",&n);    for(int i=0;i<n;i++) scanf("%d",&q[i]);    merge_sort(q,0,n-1);    for(int j=0;j<n;j++) printf("%d ",q[j]);    return 0;}

二分模板

//写的 非常好的二分模板#include<iostream>using namespace std;const int N=1e5+5;int n,m,q[N];int main(){    scanf("%d %d",&n,&m);    for(int i=0;i<n;i++) scanf("%d",&q[i]);    while(m--)    {        int k;scanf("%d",&k);        //寻找第一个等于K的坐标 我这边让二分的边界定为 左边为<5 右边>=5 则所求为r        int l=-1,r=n;        while(l+1!=r)//当l与r没有相接的时候,求边界        {            int mid=l+r>>1;            //下面找第一个>=5的坐标            if(q[mid]>=k) r=mid;            else l=mid;        }        //此时得到的r是第一个>=5的坐标        if(q[r]!=k) printf("-1 -1\n");        else{            printf("%d ",r);                //现在找最后一个<=5的数字 我这边让二分的左边为<=5 右边为>5 则所求为ll                int ll=-1,rr=n;                while(ll+1!=rr)                {                                        int mid=ll+rr>>1;                    if(q[mid]<=k) ll=mid;                    else rr=mid;                }                if(q[ll]!=k) printf("%d\n",r);                else printf("%d\n",ll);            }            }    }//非常好的二分博客引用https://blog.csdn.net/WJPnb1/article/details/126360962?spm=1001.2014.3001.5502

高精度

高精度加法模板

#include<bits/stdc++.h>using namespace std;//总结：//第一步：字符串输入//第二步：字符串转数字，逆序//第三步：模板相加；//第四步：逆序输出vector<int> add(vector<int> &A,vector<int> &B){    vector<int> C;    int t=0;    for(int i=0;i<A.size()||i<B.size();i++)    {        if(i<A.size()) t+=A[i];        if(i<B.size()) t+=B[i];        C.push_back(t%10);        t/=10;    }    if(t) C.push_back(1);    return C;}int main(){    string a,b;    cin>>a>>b;//123456    vector<int>A,B;    for(int i=a.size()-1;i>=0;i--) A.push_back(a[i]-'0');//[6,5,4,3,2,1]    for(int i=b.size()-1;i>=0;i--) B.push_back(b[i]-'0');    auto C=add(A,B);    for(int i=C.size()-1;i>=0;i--) printf("%d",C[i]);    return 0;}

高精度减法模板

#include<bits/stdc++.h>using namespace std;//第一步：输入//第二步：比较//第三步：相减：注意括号和前缀0要去掉//第四步：输出bool cmp(vector<int>&A,vector<int> &B){    if(A.size()!=B.size()) return A.size()>B.size();    for(int i=A.size()-1;i>=0;i--)             if(A[i]!=B[i]) return A[i]>B[i];    return true;}vector<int> sub(vector<int>&A,vector<int>&B){    vector<int>C;    int t=0;    for(int i=0;i<A.size();i++)    {        if(i<A.size()) t=A[i]-t;        if(i<B.size()) t-=B[i];        C.push_back((t+10)%10);//虽然A比B大，但是A的某一位的数字可能比B小，所以这里加上10再模10        if(t<0) t=1;//用于给A去减掉        else t=0;    }    while(C.size()>1&&C.back()==0) C.pop_back();    return C;}int main(){    string a,b;    vector<int> A,B;    cin>>a>>b;    for(int i=a.size()-1;i>=0;i--) A.push_back(a[i]-'0');    for(int i=b.size()-1;i>=0;i--) B.push_back(b[i]-'0');    vector<int>C;    if(cmp(A,B)) C=sub(A,B);    else C=sub(B,A),cout << '-';//这里的负号是A-B=-(B-A)；    for(int i=C.size()-1;i>=0;i--)  printf("%d",C[i]);    cout<<endl;    return 0;    }

高精度乘法模板

#include <iostream>#include <vector>#include <algorithm>using namespace std;vector<int> add(vector<int> A, vector<int> B) {    // A: 4 3 2 1    // B: 6 5    vector<int> C(max(A.size(), B.size()) + 7, 0);  // 数组C开大一点没事，反正可以去前导零的    for (int i = 0; i < A.size(); i ++) C[i] += A[i];    for (int i = 0; i < B.size(); i ++) C[i] += B[i];    // 处理进位    for (int i = 0; i + 1 < C.size(); i ++) {        C[i + 1] += C[i] / 10;        C[i] %= 10;    }    // 处理前导零    while (C.size() > 1 && C.back() == 0) C.pop_back();    reverse(C.begin(), C.end());    return C;}vector<int> mul(vector<int> A, vector<int> B) {    // A: 4 3 2 1    // B: 6 5    vector<int> C(A.size() + B.size() + 7, 0);  // 数组C开大一点没事，反正可以去前导零的    for (int i = 0; i < A.size(); i ++) {        for (int j = 0; j < B.size(); j ++) {            C[i + j] += A[i] * B[j];        }    }    // 处理进位    for (int i = 0; i + 1 < C.size(); i ++) {        C[i + 1] += C[i] / 10;        C[i] %= 10;    }    // 处理前导零 "0000" 去掉前导零    while (C.size() > 1 && C.back() == 0) C.pop_back();    reverse(C.begin(), C.end());    return C;}int main() {    string s1 = "9899", s2 = "100";    vector<int> A, B;    for (int i = s1.size() - 1; i >= 0; i --) A.push_back(s1[i] - '0');    for (int i = s2.size() - 1; i >= 0; i --) B.push_back(s2[i] - '0');    vector<int> C = add(A, B);    cout << s1 << "+" << s2 << "=";    for (int i = 0; i < C.size(); i ++) cout << C[i];    cout << endl;    C = mul(A, B);    cout << s1 << "*" << s2 << "=";    for (int i = 0; i < C.size(); i ++) cout << C[i];    cout << endl;    return 0;}链接：https://www.acwing.com/solution/content/13694/

高精度除法

#include<iostream>#include<vector>#include<algorithm>using namespace std;//int r=0;vector<int> div(vector<int> &A,int B,int &r){//r传入r的地址，便于直接对余数r进行修改    vector<int> C;    for(int i=0;i<A.size();i++){//对A从最高位开始处理        r=r*10+A[i];//将上次的余数*10在加上当前位的数字，便是该位需要除的被除数        C.push_back(r/B);//所得即为商在这一位的数字        r=r%B;//这里的余数是一个等价关系，不懂可以看视频    }    //由于在除法运算中，高位到低位运算，因此C的前导零都在vector的前面而不是尾部，vector只有删除最后一个数字pop_back是常数复杂度，而对于删除第一位没有相应的库函数可以使用，而且删除第一位，其余位也要前移，    //因此我们将C翻转，这样0就位于数组尾部，可以使用pop函数删除前导0    reverse(C.begin(),C.end());    while(C.size()>1&&C.back()==0) C.pop_back();    return C;}int main(){    string a;    int B,r=0; //代表余数    cin>>a>>B;    vector<int> A;    for(int i=0;i<a.size();i++) A.push_back(a[i]-'0');//注意这次的A是由高为传输至低位，由于在除法的手算过程中，发现从高位进行处理    //for(int i=0;i<A.size();i++) cout<<A[i];    //cout<<B;    auto C = div(A,B,r);    for(int i=C.size()-1;i>=0;i--) cout<<C[i];//将C从最高位传给最低位    cout<<endl<<r;//输出余数    cout<<endl;    return 0;}

前缀和与差分

前缀和

//前缀和的思想是存sum，然后相减进行计算#include<iostream>#include<cstdio>using namespace std;const int N=1e5+10;int a[N],sum[N];int main(){    int n,m,x;    cin>>n>>m;    for(int i=1;i<=n;i++)    {        cin>>x;        sum[i]=x+sum[i-1];    }    while(m--)    {        int l,r;        cin>>l>>r;        cout<<sum[r]-sum[l-1]<<endl;    }    return 0;}

一维差分模板

//差分非常高效的减少了运算关系的时间复杂度，二维差分的模板同样可以看y总给的那个矩阵#include<bits/stdc++.h>using namespace std;const int N = 100010;int a[N],b[N];void insert(int &l,int &r,int &c){    b[l]+=c;    b[r+1]-=c;}int main(){    int n,m;    scanf("%d%d", &n, &m);    for (int i = 1; i <= n; i ++ ) scanf("%d", &a[i]);    for (int i = 1; i <= n; i ++ ) insert(i,i,a[i]);        while(m--)    {        int l,r,c;        scanf("%d%d%d", &l, &r,&c);        insert(l,r,c);    }    for (int i = 1; i <=n; i ++ ) b[i]+=b[i-1];    for (int i = 1; i <=n; i ++ ) printf("%d ",b[i]);    return 0;}

双指针算法

最长连续不重复子序列

//其实这在后面好像是一道dp题目，双指针算法的核心就是用两个指针来解题# include <iostream>using namespace std;const int N = 100010;int a[N], s[N];int main(){    int n, r = 0;    cin >> n;    for (int i = 0, j = 0; i < n; ++ i)    {        cin >> a[i];        ++ s[a[i]];        while (s[a[i]] > 1) -- s[a[j++]]; // 先减次数后右移        r = max(r, i - j + 1) ;    }    cout << r;    return 0;}

位运算

//这里主要是了解一个lowbit操作#include<bits/stdc++.h>using namespace std;int  lowbit(int &x)//这个代码的关键是这个函数，每次输出x=的最后一位1;{    return x&-x;}int main(){    int n;    cin>>n;    while (n -- )    {        int x;         cin >> x;        int res=0;        while(x>0) x-=lowbit(x),res++;//每次减去x的最后一位1;直到没有1，那么res即为所求        cout << res<<" ";    }    }

区间和

//当空间稀疏性非常大的时候的做法，最后的实现也是前缀和，通过离散化，将空间的利用率降低了#include <iostream>#include <vector>#include <algorithm>using namespace std;const int N = 300010; //n次插入和m次查询相关数据量的上界int n, m;int a[N];//存储坐标插入的值int s[N];//存储数组a的前缀和vector<int> alls;  //存储（所有与插入和查询有关的）坐标vector<pair<int, int>> add, query; //存储插入和询问操作的数据int find(int x) { //返回的是输入的坐标的离散化下标    int l = 0, r = alls.size() - 1;    while (l < r) {        int mid = l + r >> 1;        if (alls[mid] >= x) r = mid;        else l = mid + 1;    }    return r + 1;}int main() {    scanf("%d%d", &n, &m);    for (int i = 1; i <= n; i++) {        int x, c;        scanf("%d%d", &x, &c);        add.push_back({x, c});        alls.push_back(x);    }    for (int i = 1; i <= m; i++) {        int l , r;        scanf("%d%d", &l, &r);        query.push_back({l, r});        alls.push_back(l);        alls.push_back(r);    }   //排序，去重    sort(alls.begin(), alls.end());    alls.erase(unique(alls.begin(), alls.end()), alls.end());    //执行前n次插入操作    for (auto item : add) {        int x = find(item.first);        a[x] += item.second;    }    //前缀和    for (int i = 1; i <= alls.size(); i++) s[i] = s[i-1] + a[i];    //处理后m次询问操作    for (auto item : query) {        int l = find(item.first);        int r = find(item.second);        printf("%d\n", s[r] - s[l-1]);    }    return 0;}

区间合并

这里看到一个区间合并，很绝的思路模板#include<iostream>#include<algorithm>using namespace std;const int N=1e6+10;typedef pair<int,int> PII;PII a[N];int main(){    int n;    cin>>n;    for(int i=1;i<=n;i++)scanf("%d%d",&a[i].first,&a[i].second);    sort(a+1,a+n+1);//sort对于二元组的排序规则是先考虑第一个元素，再考虑第二个元素    int ed=a[1].second,ans=0;    for(int i=2;i<=n;i++)    {        if(ed>=a[i].first)ed=max(ed,a[i].second);        else ans++,ed=a[i].second;    }    cout<<ans+1<<endl;}

职位描述:

平台验证工程师负责验证业界领先的SOC实现工具和流程解决方案，如“IC Compiler II”，“Design Compiler”，formal和下一代数字平台“Fusion Compiler”等。

·了解客户需求，基于数字化设计流程验证新特性，包括先进节点、5nm、3nm等新特性。

·验证Synopsys前端/后端流程，跟踪前端/后端流程QOR/性能。

·了解客户使用情况，提出新要求，完善流程解决方案。

·用Perl、TCL、Python或C/ c++设计和开发测试程序，包括测试工具和自动化测试套件。

工作要求:

电子电气、微电子或相关专业硕士，三年工作经验

·精通ASIC设计流程。包括平面图，综合，P&R, STA等。期望在很少的复习和指导下找出问题的经典解决方案

·具有团队合作精神和良好的学习能力，对先进技术和设计流程方法论保持热情和兴趣!

·必须具备较强的沟通和人际交往能力

·具备良好的中英文口头和书面沟通能力

·具有以下一个或多个计算机科学领域的知识和经验者优先考虑:

编程语言(C/ c++， Shell, TCL, Perl, Python等)

·Unix/Linux操作系统

应该很久没有写日记了，已经忘记上次写日记是哪天了，生活似乎并没有好过点，还是在不断的告诉自己熬过去熬过去中一天天度过，不知道生活什么时候才会有变化，也许我应该时常问自己，邓福星，你有慢慢的变成更好的自己的吗，不知道为什么，我想告诉自己，我确实好像似乎，在慢慢的变好，我的体重慢慢的下去，我慢慢的去护肤，慢慢的健身，慢慢的去体会生活，我想比起之前的一团糟，我觉得我确实有在慢慢变好，我还是有些时候免不了想陶俊余，我在想，是不是每当我脆弱的时候，我就会想有复合的念头，这样的念头是不正确的，也不该有的对吗，我应该习惯自己慢慢的面对这一切，就写到这里吧，得去忙着改代码了