2021寒假集训

最新推荐文章于 2023-01-02 17:29:00 发布
最新推荐文章于 2023-01-02 17:29:00 发布
阅读量269 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47328850/article/details/112283542
版权

Day1：

埃氏筛

void sushu(int x){
    for(int i=2;i<=x;i++){
        if(!bj[i]){
            prime[cnt]=i;
            cnt++;
            for(int j=2;j<=x/i;j++) bj[i*j]=1;
        } 
    }
    for(int i=0;i<cnt;i++)  printf("%d ",prime [i]);
    printf("\n%d\n",cnt);
}

线性筛

void sushu(int x){
    for(int i=2;i<=x;i++){
        if(!bj[i]){
            prime[cnt]=i;
            cnt++;
        }
        for(int j=0;prime[j]<=x/i;j++){
            bj[prime[j]*i]=1;
            if(i%prime[j]==0) break;
        }
    }
    printf("%d\n",cnt);
}

欧拉函数

1 ~ N 中与 N 互质的数的个数被称为欧拉函数，记为ϕ(N)。
若在算数基本定理中，N=p1^r1 * p2^r2 * p3^r3 * … * pk^rk
则 φ(N)=N(1-1/P1)(1-1/P2)…(1-1/Pk)

证明如下：

∵ p1,p2,p3…pk 均为N的质因子
∴ 在 1 ~ N 中p1,p2,p3…pk的倍数均不可能与N互质
以p1为例 在1 ~ N 中p1的倍数有N/p1个
∴ ϕ(N) = N-N/p1-N/p2-…-N/pk
但是如果有一个数既是p1的倍数也是p2的倍数呢，那么在上式中就重复减了两次，所以我们需要进一步精确一下这个式子
ϕ(N) = N-N/p1-N/p2-…-N/pk+N/p1p2+N/p1p3+…
同理也会出现三个质因子的公倍数，…，k个质因子的公倍数
ϕ(N) = N-N/p1-N/p2-…-N/pk+N/p1p2+N/p1p3+…-N/p1p2p3-N/p1p2p4-…+N/p1p2p3p4…（容斥原理）
化简之后就可以得到 φ(N)=N(1-1/P1)(1-1/P2)…(1-1/Pk)

线性筛求欧拉函数
void ol(int n){
    euler[1] = 1;
    for(int i=2;i<=n;i++){
        if(!bj[i]){
            prime[cnt]=i;
            cnt++;
            euler[i]=i-1;//情况一
        }
        for(int j=0;primes[j]<=n/i;j++){
            int t=primes[j]*i;
            bj[t]=1;
            if(i%primes[j]= =0){
                euler[t]=euler[i]*primes[j];//情况二
                break;
            }
            euler[t]=euler[i]*(primes[j]-1);//情况三
        }
    }
}
情况一：i为质数 euler[i]=i-1
情况二：i%primes[j]= =0

∵ prime[j]为i的质因数
∴ t=prime[j] * i分解质因数后的结果zys(t)=zys(i)，并没有发生变化
euler[t]=t * (1-1/P1)(1-1/P2)…(1-1/Pk)
euler[i]=i * (1-1/P1)(1-1/P2)…(1-1/Pk)
∵ t=prime[j] * i
∴ euler[t]=euler[i]*primes[j]

情况三：i%prime[j]!=0

t=prime[j] * i
∵prime[j]为t的质因数且不为i的质因数
∴ t分解质因数后的结果zys(t)=prime[j] * zys(i)
euler[t]=t * (1-1/P1)(1-1/P2)…(1-1/Pk)(1-1/prime[j])
euler[i]=i * (1-1/P1)(1-1/P2)…(1-1/Pk)
∵ t=prime[j] * i
∴ euler[t]=euler[i] * primes[j] * (1-1/prime[j])
∴ euler[t]=euler[i] * (primes[j]-1);

欧拉定理

若a与n互质，则a^φ(n)≡1 (mod n)

费马小定理

满足欧拉定理条件且n为质数，则a^(n-1)≡1 (mod n)

Day2：

快速幂

//a^b%p
void ksm(int a,int b,int p){
    long long int ans=1,x=a;
    while(b){
        if(b&1) ans=ans*x%p;
        x=x*x%p;
        b>>=1;
    }
    printf("%lld\n",ans);
}

快速幂求逆元

乘法逆元的定义
若整数b，m互质，并且对于任意的整数 a，如果满足b|a（b能被a整除），则存在一个整数x，使得a/b≡a∗x(mod m)，则称x为b的模m乘法逆元，记为b^(−1)(mod m)。

性质：b * b^(-1) ≡ 1 (mod m)

b存在乘法逆元的充要条件是b与模数m互质。
∴模数m为质数时
满足b^(m-1) ≡ 1 (mod m)（费马小定理）
∴ b * b^(m-2) ≡ 1 (mod m)
b^(m−2)即为b的乘法逆元。

例：p是质数,求a模p的乘法逆元，若逆元不存在则输出impossible

void ny(int a,int b,int p){
    long long int ans=1,x=a;
    while(b){
        if(b&1) ans=ans*x%p;
        x=x*x%p;
        b>>=1;
    }
    if(a%p==0) printf("impossible\n");
    else printf("%lld\n",ans);
}

int main(){
    int n,a,p;
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d %d",&a,&p);
        ny(a,p-2,p);
    }
    return 0;
}

gcd

求最大公约数，利用辗转相除法

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

裴蜀定理

（贝祖定理）

若a,b是整数,且gcd(a,b)=d,那么对于任意的非零整数x,y,ax+by都一定是d的倍数,特别地,一定存在整数x,y,使ax+by=d成立。

推论：a,b互质的充要条件是存在整数x,y使ax+by=1.

证明：
∵a,b均为gcd(a,b)的整数倍
且x,y均为整数
∴ax,by均为gcd(a,b)的整数倍
∴ax+by也为gcd(a,b)的整数倍
∴gcd(a,b)是ax+by能得出的最小值

exgcd

已知整数a,b，扩展欧几里得算法可以在求得a,b的最大公约数的同时，能找到整数x、y（其中一个很可能是负数），使它们满足ax+by=gcd(a,b)（裴蜀定理）

如果a是负数，可以把问题转化成|a|(-x)+by=gcd(a,b)，然后令X=-x，则|a|X+by=gcd(a,b)

推导：

1.当a,b中存在0时
∵b=0
∴gcd(a,b)=a
ax+by=gcd(a,b)=a
∴x=1 y=0

2.当a,b均不为零时
∵ gcd(a,b)=gcd(b,a mod b)
∴ ax+by=gcd(a,b)=gcd(b,a mod b)=bY+(a mod b)X
a mod b=a - a/b (向下取整) * b
化简可得 gcd(a,b)=aX+b(Y-a/b (向下取整) * X)
即X=X，Y-=a/b * X;

long long int exgcd(int a,int b,int &x,int &y){
    if(!b){
        x=1;
        y=0;
        return a;
    }
    else{
        int d=exgcd(b,a%b,y,x);
        y-=a/b*x;
        return d;
    }
}

ax+by=d x,y不唯一
x=x0+b/d * k，y=y0-a/d* k，k∈Z

exgcd求逆元

例：线性同余方程
给定整数a,b,m，求出整数x，使其满足a∗x≡b(mod m)，如果无解则输出impossible。

∵ a∗x≡b(mod m)
设 ax=my+b 即 ax-my=b
令 Y=-y
∴ax+mY=b
由裴蜀定理可知 ax+by=gcd(a,m)
若b%gcd(a,m)= =0 则有解，反之无解
利用扩展欧几里得算法求出x0,y0
满足a∗x0+m∗y0=gcd(a,m)
(a∗x0+m∗y0)∗(b/gcd(a,m))=gcd(a,m)∗(b/gcd(a,m))
a∗x0∗b/gcd(a,m)+m∗y0∗b/gcd(a,m)=b
x=x0∗b/gcd(a,m)%m即为所求

题目

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
int n,a,b,x,y,m;
int exgcd(int a,int b,int &x,int &y){
    if(!b){
        x=1;
        y=0;
        return a;
    }
    else{
        int d=exgcd(b,a%b,y,x);
        y-=a/b*x;
        return d;
    }
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d %d %d",&a,&b,&m);
        int d=exgcd(a,m,x,y);
        if(b%d) printf("impossible\n");
        else printf("%d\n",(LL)x*b/d%m);
    }
    return 0;
}

Day3:

约数

N=p1^r1 * p2^r2 * p3^r3 * … * pk^rk

N的约数个数 (r1+1)(r2+1)(r3+1)…(rk+1)

N的约数之和 (p10+p11+p12+…+p1r1)…(pk0+pk1+pk2+…+pkrk)

中国剩余定理

给定m1,m2,m3…mn两两互质
x ≡ a1(mod m1)
x ≡ a2(mod m2)
…
x ≡ ak(mod mk)

令M=m1m2m3…mk
Mi=M/mi
Mi^(-1)表示Mi模mi的逆
即Mi^(-1) * Mi ≡ 1(mod mi)

x=a1 * M1 * M1^(-1)+a2 * M2 * M2^(-1)+…+ak * Mk * Mk^(-1)

证明：（反证法）
假设x=a1 * M1 * M1^(-1)+a2 * M2 * M2^(-1)+…+ak * Mk * Mk^(-1)
等式两边同时mod m1
x mod m1 = a1 * M1 * M1^(-1)mod m1+a2 * M2 * M2^(-1)mod m1+…+ak * Mk * Mk^(-1)mod m1
∵ M1^(-1) * M1 ≡ 1(mod m1)
∴ 原式 = a1 * 1+a2 * M2 * M2^(-1)mod m1+…+ak * Mk * Mk^(-1)mod m1
又∵M2=m1m3m4…mk
∴ M2/m1=m3m4m5…mk
∴ M2 ≡ 0(mod m2)
同理 M3,M4,…Mk模m1均为0
∴ 原式 = a1 * 1+a2 * 0+…+ak * 0
∴ x mod m1 = a1满足题目要求
同理可证其余线性方程均满足要求，故假设成立

模板题

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=20;
LL m[N],a[N],M[N],M_[N],ans;
LL exgcd(LL a,LL b,LL &x,LL &y){
    if(!b){
        x=1,y=0;
        return a;
    }
    else{
        LL d=exgcd(b,a%b,y,x);
        y-=a/b*x;
        return d;
    }
}
int  main(){
    int n;
    LL MM=1,ans=0,x,y;
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%lld %lld",&m[i],&a[i]);
        MM*=m[i];
    }
    for(int i=1;i<=n;i++){
        M[i]=MM/m[i];
        LL d=exgcd(M[i],m[i],x,y);
        M_[i]=x/d%m[i];
        ans+=a[i]*M[i]*M_[i]%MM;
        ans%=MM;
    }
    ans=(ans+MM)%MM;
    printf("%lld\n",ans);
    return 0;
}

（扩展）中国剩余定理

x ≡ a1(mod m1)
x ≡ a2(mod m2)
…
x ≡ ak(mod mk)
m1,m2,m3…mn不一定两两互质，求最小正整数x

中国剩余定理有一个很重要的前提条件，就是m1,m2,m3…mn一定两两互质，但本题不满足要求，所以不能套用x的公式

∵ x ≡ a1(mod m1)，x ≡ a2(mod m2)
∴ x=m1k1+a1,x=m2k2+a2
∴ m1k1+a1 = m2k2+a2
移项可得 m1k1-m2k2 = a2-a1
∵ m1,m2,a1,a2均可知
∴ 可套用扩展欧几里得公式计算k1’,k2’使其满足m1k1’+m2k2’ = d
k1=k1’(a2-a1)/d,k2=k2’(a2-a1)/d
∵ 需要求得最小正整数x，可利用公式先求通解K1
(ax+by=d x,y不唯一
x=x0+b/d * k，y=y0-a/d* k，k∈Z)
∵ K1 = k1 + k * m2/d
x=m1K1+a1=(k1+k * m2/d)m1+a1=m1k1+a1+m1 * k * m2/d
a=m1k1+a1
m=m1m2/d
x=ak+m
即求x ≡ a(mod m)
易知当x=a时，是满足条件的最小值，输出a即可

模板题

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
LL exgcd(LL a,LL b,LL &x,LL &y){
    if(!b){
        x=1;
        y=0;
        return a;
    }
    LL d=exgcd(b,a%b,y,x);
    y-=a/b*x;
    return d;
}
int main(){
    int n;
    LL a1,a2,m1,m2,k1,k2;
    scanf("%d",&n);
    scanf("%lld %lld",&m1,&a1);
    for(int i=2;i<=n;i++){
        scanf("%lld %lld",&m2,&a2);
        LL d=exgcd(m1,m2,k1,k2);
        if((a2-a1)%d){
            a1=-1;
            break;
        }
        k1*=(a2-a1)/d;
        k1=(k1%(m2/d)+m2/d)%(m2/d); 
        a1=k1*m1+a1;
        m1=abs(m1/d*m2);
    }
    printf("%lld\n",a1);
    return 0；
}

Day4:

高斯消元

时间复杂度O(n³)

a11x1+a12x2+a13x3+…+a1nxn=b1
a21x1+a22x2+a23x3+…+a2nxn=b2
…
an1x1+an2x2+an3x3+…+annxn=bn
求x1,x2,x3…xn
(线性代数化为上三角型，利用行列式的性质)

做法：for（枚举每一列）{
1.找到绝对值最大的一行（除了已经处理过的行）
2.将该行换到未处理的最上面
3.将该行的第一个数变成1
4.将下面所有本列的数变成0
}
5.利用主对角线的1，清空其余数，使其仅主对角线存在元素
6.xn=bn

变为上三角型后，若为完美阶梯型则有唯一解，若解得某式子出现0=非零数则无解，若解出0=0则有无穷多组解

今天还做了几道中国剩余定理的题，有一道比较神奇的还没有A，A了回来补充~
组合数也学了一点点，明天继续，学完了写在明天的博客里~

Day5

组合数

方法一：公式递推

时间复杂度O(N^2)

C m n = C m − 1 n − 1 ⋅ C m − 1 n C_m^n=C_{m-1}^{n-1}⋅C_{m-1}^n Cmn​=Cm−1n−1​⋅Cm−1n​

公式证明：
若在m个物品中选出n个物品即 C m n C_m^n Cmn​
现在从m个物品中选出一个物品，对于这个物品仅有两种可能
①选，那么还需要从余下的m-1个物品中选择n-1个，即 C m − 1 n − 1 C_{m-1}^{n-1} Cm−1n−1​
②不选，那么还需要从余下的m-1个物品中选择n个，即 C m − 1 n C_{m-1}^n Cm−1n​
这两种情况已经包含了全部情况，所以 C m n = C m − 1 n − 1 ⋅ C m − 1 n C_m^n=C_{m-1}^{n-1}⋅C_{m-1}^n Cmn​=Cm−1n−1​⋅Cm−1n​

模板题
（1≤n≤10000 1≤b≤a≤2000，查询次数多，数据范围小）

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int mod=1e9+7,N=2010;
LL 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(){
    init();
    int t;
    scanf("%d",&t);
    for(int i=1;i<=t;i++){
        LL a,b;
        scanf("%lld %lld",&a,&b);
        printf("%lld\n",c[a][b]);
    }
    return 0;
}
方法二：预处理

C m n = m ! ( n − m ) ! n ! C_m^n=\frac{m!}{(n-m)!n!} Cmn​=(n−m)!n!m!​

时间复杂度O(NlogN)

如果模数为质数，可以根据费马小定理利用快速幂求逆元

（1≤n≤10000 1≤b≤a≤1e5，数据范围较大）

模板题

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int mod=1e9+7,N=1e5+10;
LL q[N],inq[N];
int ksm(int a,int b,int p){
    LL ans=1,x=a;
    while(b){
        if(b&1) ans=ans*x%p;
        x=x*x%p;
        b>>=1;
    }
    return ans;
}
void init(){
    q[0]=inq[0]=1;
    for(int i=1;i<N;i++){
        q[i]=q[i-1]*i%mod;
        inq[i]=ksm(q[i],mod-2,mod);
    }
}
int main(){
    init();
    int t;
    scanf("%d",&t);
    for(int i=1;i<=t;i++){
        int a,b;
        scanf("%d %d",&a,&b);
        LL ans=q[a]*inq[b]%mod*inq[a-b]%mod;
        printf("%lld\n",ans);
    }
    return 0;
}
方法三：卢卡斯定理

时间复杂度O(plogN)

C m n = C m / p n / p ⋅ C m m o d p n m o d p ( m o d p ) C_m^n=C_{m/p}^{n/p}⋅C_{m mod p}^{n mod p}(mod p) Cmn​=Cm/pn/p​⋅Cmmodpnmodp​(modp)

定理证明 这个公式背住就可以，目前没发现变形应用，不必掌握推导方法

模板题

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

LL ksm(LL a,LL b,LL p){
    LL ans=1,x=a;
    while(b){
        if(b&1) ans=ans*x%p;
        x=x*x%p;
        b>>=1;
    }
    return ans;
}

LL C(LL a,LL b,LL p){
    if(b>a) return 0;
    LL ans=1;
    for(int i=1,j=a;i<=b;i++,j--){
         ans=ans*j%p;
         ans=ans*ksm(i,p-2,p)%p;
    }
    return ans;
}

LL lucas(LL a,LL b,LL p){
    if(a<p&&b<p) return C(a,b,p);
    else return C(a%p,b%p,p)*lucas(a/p,b/p,p)%p;
}
int main(){
    int n;
    LL a,b,p;
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%lld %lld %lld",&a,&b,&p);
        printf("%lld\n",lucas(a,b,p));
    }
    return 0;
}

Day 6:

题目 高精度+组合数

C m n = m ! ( n − m ) ! n ! C_m^n=\frac{m!}{(n-m)!n!} Cmn​=(n−m)!n!m!​

可以通过计算m，n-m，m的质因子个数来化简本题，对于质因子p的数量sl§即为，sl§=sl(a!)-sl((n-m)!)-sl(m!),再利用高精度乘法求解即可

#include<bits/stdc++.h>
using namespace std;
const int N=5000+10;
int prime[N],cnt,sum[N],st[N];

void sushu(int n){
    for(int i=2;i<=n;i++){
        if(!st[i]){
            prime[cnt]=i;
            cnt++;
        }  
        for(int j=0;prime[j]<=n/i;j++){
            st[prime[j]*i]=1;
            if(i%prime[j]==0) break;
        }
    }
}

int Sum(int n,int p){
    int ans=0;
    while(n){
        ans+=n/p;
        n/=p;
    }
    return ans;
}

vector<int>mul(vector<int>&A,int b){
    vector<int>C;
    int t=0;
    for(int i=0;i<A.size()||t;i++){
        if(i<A.size()) t+=A[i]*b;
        C.push_back(t%10);
        t/=10;
    }
    while(C.size()>1&&C.back()==0) C.pop_back();
    return C;
}

int main(){
    int a,b;
    scanf("%d %d",&a,&b);
    sushu(a);
    for(int i=0;i<cnt;i++){
        int p=prime[i];
        sum[i]=Sum(a,p)-Sum(a-b,p)-Sum(b,p);
    }
    vector<int>res;
    res.push_back(1);
    for(int i=0;i<cnt;i++){
        for(int j=0;j<sum[i];j++){
            res=mul(res,prime[i]);
        }
    }
    for(int i=res.size()-1;i>=0;i--) printf("%d",res[i]);
    return 0;
}

Day 7:

卡特兰数

通过例题推理证明一下
给定n个0和n个1，它们将按照某种顺序排成长度为2n的序列，求它们能排列成的所有序列中，能够满足任意前缀序列中0的个数都不少于1的个数的序列有多少个。

假设在一个n * n的坐标系里，从原点（0,0）出发到点（n,n）结束，序列里的0表示向右走一格，1表示向上走一格。
假设n=6，题目要求任意前缀序列中0的个数都需要大于等于1的个数，即所有合法路线必须严格处于红线下方，所以答案即为全部情况-经过红线的情况 C 12 6 − x C_{12}^6-x C126​−x
随意给出一条经过红线的路线，如图黄色线所示，将其与红线相交的第一个点到终点的路线，关于红线做对称线，如图粗绿线。可以发现绿线的终点为（5,7），易知所有经过红线到达（6,6）的路线经对称终点均为（5,7），易知从（0,0）出发到达（5,7）的所有路线必须穿过红线，即求从（0,0）到（5,7）的所有路线 x = C 12 5 x=C_{12}^5 x=C125​
所以答案等于 C 12 6 − C 12 5 C_{12}^6-C_{12}^5 C126​−C125​

卡特兰数 C 2 n n − C 2 n n − 1 = C 2 n n n + 1 C_{2n}^n-C_{2n}^{n-1}=\frac{C_{2n}^n}{n+1} C2nn​−C2nn−1​=n+1C2nn​​

题目链接

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int mod=1e9+7;
int ksm(int a,int b){
    int ans=1,x=a;
    while(b){
        if(b&1) ans=(LL)ans*x%mod;
        x=(LL)x*x%mod;
        b>>=1;
    }
    return ans;
}
int main(){
    int n,ans=1;
    scanf("%d",&n);
    for(int i=2*n;i>n;i--) ans=(LL)ans*i%mod;
    for(int i=1;i<=n;i++) ans=(LL)ans*ksm(i,mod-2)%mod;
    ans=(LL)ans*ksm(n+1,mod-2)%mod;
    printf("%d\n",ans);
    return 0;
}
苿＊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2021寒假集训-Updating
qq_45811601的博客
01-03 168
### Day1 #### 一、 [codeforces](https://ac.nowcoder.com/acm/problem/21314 "codeforces") 题目描述 牛牛正在打一场CF 比赛时间为T分钟，有N道题，可以在比赛时间内的任意时间提交代码 第i道题的分数为maxPoints[i],题目的分数随着比赛的进行，每分钟减少pointsPerMinute[i] 这是一场比较dark的Cf，分数可能减成负数 已知第i道题需要花费 requiredTime[i] 的时间解决 请问最多可以得到.
2021纪中寒假集训总结
Z_Y_S_的博客
01-14 195
2021.1.14B组总结 t1 直接模拟，可以证明复杂度为O(log⁡n)O(\log n)O(logn) t2 约瑟夫问题，递推，由于mmm较小，递推时不一定每次都要模，可以用追击问题跳过 t3 若有向量A=(x1,y1)A=(x_1,y_1)A=(x1​,y1​)和B=(x2,y2)B=(x_2,y_2)B=(x2​,y2​)，∣A×B∣=x1⋅y2−x2⋅y1|A\times B|=x_1\cdot y_2-x_2\cdot y_1∣A×B∣=x1​⋅y2​−x2​⋅y1​ 原式=∑1≤i<j
寒假培训总结
gotLee的博客
02-01 638
寒假培训报告 本次寒假培训我们从原来的51最小系统转换到了STM32，开始了对STM32的学习，主要是通过一个课题让我们从新建工程开始，一步步地认识STM32，了解它，最后能够用它来实现我们想要实现的单片机功能。 题目：基于STM32的超声波测距显示系统 基本要求：利用STM32开发完成一个超声波测距系统（毫米级），要求能够实时显示所测距离，利用串口打印到电脑上，或者直接显示在LCD屏幕上，
2021寒假集训Part 1
qq_53218344的博客
01-28 141
学习目标： 巩固算法笔记第四章 学习内容： 2021寒假集训Part 1 学习时间： 2021-01-24 25 26 学习产出： 题单由此进！！！ 以下只记录个人觉得有意思的 1 P1177 【模板】快速排序 #include<iostream> using namespace std; int n,a[1000001]; void qsort(int l,int r)//应用二分思想 { int mid=a[(l+r)/2];//中间数 int i=l,j=r; do
2021寒假集训Part 2
qq_53218344的博客
09-17 66
学习目标： 巩固算法笔记第五章 学习内容： 2021寒假集训Part 1 学习时间： 2021-9-17 学习产出： 题单点这里 补题弱鸡 1 P2181 对角线 #include<iostream> using namespace std; int main(){ unsigned long long n, ans; scanf("%lld",&n); ans = n * (n - 1) / 2 * (n - 2) / 3 * (n - 3) /4; printf("%lld"
ThinkSpirit2021寒假集训专题一题解
DKwindne的博客
01-23 241
专题1题解 A：照题意模拟qs：看清楚题目要求的输出顺序 代码：https://paste.nugine.xyz/ptnybhi1/ B:题意：对于二开始的数列每次操作对从第k个存在的数开始没隔K隔删掉一个 思路：直接暴力模拟找到3000个答案中最后一个。然后将模拟规模改成找到的这个数就AC了 代码：https://paste.nugine.xyz/cdruyjdq/ C：高精度乘法+高精度摸鱼（模余） D：字典树加格式输出 难点：如何将一个字符串影射成一个点建树目前还在研究中 E：数据规模过小，穷举2n（
2021寒假集训（1）动态规划
lifeforge的博客
01-22 128
(1)区间DP 基本模板 for(int len=2;len<=n;len++) { for(int i=1;i<n;i++) { int j=i+len-1; if(j>n) break; for(int k=i;k<=j;k++) { dp[i][j]=max(dp[i][j],dp[i][k]+dp[k+1][j]); } } } (
2021寒假集训.2018牛客多校第二场I-car[模拟]
qq_43660826的博客
01-29 218
White Cloud has a square ofn×nn×nfrom(1,1)(1,1)to(n,n)(n,n). White Rabbit wants to put in several cars. Each car will start moving at the same time and move from one side of one row or one line to the other. All cars have the same speed. If two cars ...
2023寒假集训通知
hsyoi的博客
01-02 621
2023 寒假 编程 报名
matlab集成c代码-2021-IFR-WinterTraining:2021寒假集训每日进度
05-22
2021寒假集训每日进度 1.6 回顾单个电机控制代码，封装函数使代码更简洁并完成遥控器对电机控制的模式切换与看门狗。 1.7 完成编写并封装4麦轮步兵底盘代码（函数名称前缀My），待测试。 1.8 学习、复习C语言，测试4...
2013年heu寒假集训练习赛AK--第3场
01-23
2013年heu寒假集训练习赛--第3场
小学信息奥赛网寒假集训题8
02-20
小学信息奥赛网寒假习题
2013年heu寒假集训练习赛AK--第4场
01-24
2013年heu寒假集训练习赛--第4场
pd16.py11111111111
最新发布
06-02
pd16.py11111111111
u-boot-2024.07-rc3.tar.bz2
06-02
【U-Boot 2024.07源码深度解析】002 - 下载及编译 U-Boot 源码 https://blog.csdn.net/Ciellee/article/details/139381921 配套的资源
287_基于移动端选课系统的设计与实现-源码.zip
06-02
提供的源码资源涵盖了安卓应用、小程序、Python应用和Java应用等多个领域，每个领域都包含了丰富的实例和项目。这些源码都是基于各自平台的最新技术和标准编写，确保了在对应环境下能够无缝运行。同时，源码中配备了详细的注释和文档，帮助用户快速理解代码结构和实现逻辑。 适用人群： 这些源码资源特别适合大学生群体。无论你是计算机相关专业的学生，还是对其他领域编程感兴趣的学生，这些资源都能为你提供宝贵的学习和实践机会。通过学习和运行这些源码，你可以掌握各平台开发的基础知识，提升编程能力和项目实战经验。 使用场景及目标： 在学习阶段，你可以利用这些源码资源进行课程实践、课外项目或毕业设计。通过分析和运行源码，你将深入了解各平台开发的技术细节和最佳实践，逐步培养起自己的项目开发和问题解决能力。此外，在求职或创业过程中，具备跨平台开发能力的大学生将更具竞争力。 其他说明： 为了确保源码资源的可运行性和易用性，特别注意了以下几点：首先，每份源码都提供了详细的运行环境和依赖说明，确保用户能够轻松搭建起开发环境；其次，源码中的注释和文档都非常完善，方便用户快速上手和理解代码；最后，我会定期更新这些源码资源，以适应各平台技术的最新发展和市场需求。
4_New Project_2024-05-28_touch_test.eprj
06-02
4_New Project_2024-05-28_touch_test.eprj
intel_openmp-2021.3.0-py2.py3-none-win_amd64.whl
06-01
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
寒假rhino入门教程
01-07
寒假是一个很好的时间去学习新的知识和技能，如果你想要学习Rhino建模软件，可以按照以下步骤进行入门教程。 首先，你需要了解Rhino软件的基本界面和操作按钮，可以通过观看相关的教学视频或者阅读Rhino软件的官方手册来学习。然后，你可以尝试创建一些简单的基本几何体，比如立方体、球体或者圆柱体，以此来熟悉Rhino软件的建模工具和命令。接着，可以尝试使用Rhino软件的编辑工具对创建的基本几何体进行一些简单的修改，比如拉伸、旋转或者缩放等。这样可以帮助你更好地理解Rhino软件的建模原理和操作方法。 接下来，可以学习如何使用Rhino软件进行曲面建模。你可以从简单的曲面开始，比如平面、球面或者圆锥面，然后逐渐挑战一些复杂的曲面建模，比如自由曲面或者双曲面等。在学习曲面建模的过程中，可以多做一些练习来加深对Rhino软件建模工具的掌握。 最后，你还可以尝试使用Rhino软件进行CAD和CAM建模，在这个过程中可以学习一些Rhino软件的辅助工具和插件，比如Grasshopper插件等，来提高你的建模技能和效率。 总的来说，学习Rhino软件需要不断的实践和练习，希望上述入门教程能够帮助你顺利掌握Rhino软件的使用方法。祝你在寒假里学有所成！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值