模板整理

1:欧拉函数

含义:phi[n]代表小于等于n的数中与n互质的数的数目,phi[1]=1.

性质:若n是素数p的k次方:phi[n]=p^k-p^(k-1)=(p-1)*(p^(k-1))

若m,n互质,则phi[m*n]=phi[n]*phi[m].

公式:令p为n的最小质因数,若p^2|n,则phi[n]=phi[n/p]*p,否则phi[n]=phi[n/p]*(p-1).

const int maxn = 4000010;
ll vis[maxn+100],phi[maxn+100],prime[maxn+100],tot;
//标记是否为素数,欧拉函数值,素数存放,素数总个数
void Getphi()   //O(n)
{
    phi[1]=1;
    for(int i=2;i<=maxn;i++){
        if(!vis[i]){        //素数的欧拉函数值为i-1
            prime[++tot]=i;
            phi[i]=i-1;
        }
        for(int j=1;j<=tot&&i*prime[j]<=maxn;j++){
            vis[i*prime[j]]=1;
            if(i%prime[j]==0){
                phi[i*prime[j]]=phi[i]*prime[j];
                break;
            }
            else{
                phi[i*prime[j]]=phi[i]*(prime[j]-1);
            }
        }
    }
}
ll minDiv[maxn+100],phi[maxn+100];
void Getphi() //O(nlog n)
{
    for(int i=1;i<maxn;i++)minDiv[i]=i;
    for(int i=2;i*i<=maxn;i++){
        if(minDiv[i]==i){
            for(ll j=i*i;j<=maxn;j+=i){
                minDiv[j]=i;
            }
        }
    }
    phi[1]=1;
    for(int i=2;i<=maxn;i++){
        phi[i]=phi[i/minDiv[i]];
        if((i/minDiv[i])%minDiv[i]==0){
            phi[i]*=minDiv[i];
        }
        else{
            phi[i]*=minDiv[i]-1;
        }
    }
}
View Code

 

 2:扩展欧几里德:

 

ll exgcd(ll a,ll b,ll &x,ll &y)//a*x+b*y=gcd(a,b)的解
{
    ll d=a;
    if(b!=0){
        d=exgcd(b,a%b,x,y);
        ll temp=x;
        x=y;
        y=temp-a/b*y;
    }
    else
        x=1,y=0;
    return d;
}
void cal(ll a,ll b,ll c)//a*x+b*y=c的解
{
    ll x,y;
    ll g = exgcd(a,b,x,y);
    if(c%g)cout<<"此方程无解"<<endl;
    else{
        x *= c/g;
        b /= g;
        if(b<0)b = -b;
        x %= b;
        if(x<=0)x += b;
        cout << x << endl;
    }
}
View Code

 

3:素数筛:

void Getprime()//埃式筛法,O(nloglogn),近似线性
{
    for(int i=1;i<=maxn;i++)is_prime[i]=1;
    is_prime[1]=0;
    for(int i=2;i<=maxn;i++){
        if(is_prime[i]){
            prime[++tot]=i;
            for(int j=2*i;j<=maxn;j+=i)is_prime[j]=0;
        }
    }
}
void Getprime()//O(n)
{
    memset(is_prime,1,sizeof(is_prime));
    is_prime[1]=0;
    for(int i=2;i<=maxn;i++){
        if(is_prime[i]){
            prime[++tot]=i;
        }
        for(int j=1;j<=tot&&i*prime[j]<=maxn;j++){
            is_prime[i*prime[j]]=0;
            if(i%prime[j]==0)break;
        }
    }
}
View Code

 

4:质因数分解:

int a[maxn],b[maxn],tot;
void factor(int n)//将n质因子分解,1需要特判
{
    int now=n;
    for(int i=2;i*i<=n;i++){
        if(now%i==0){
            a[++tot]=i;
            while(now%i==0){
                ++b[tot];
                now/=i;
            }
        }
    }
    if(now!=1){
        a[++tot]=now;
        ++b[tot];
    }
}
View Code

 5:lucas定理:

ll fac[maxn];
void Init()
{
    fac[0]=1;
    for(int i=1;i<=maxn;i++){
        fac[i]=fac[i-1]*i%mod;
    }
}
ll inv(ll a,ll m)
{
    if(a==1)return 1;
    return inv(m%a,m)*(m-m/a)%m;
}
ll lucas(ll n,ll m,ll mod)
{
    ll ans=1;
    while(n&&m){
        ll a=n%mod;
        ll b=m%mod;
        if(a<b)return 0;
        ans=ans*fac[a]%mod*inv(fac[b]*fac[a-b]%mod,mod)%mod;
        n/=mod;
        m/=mod;
    }
    return ans;
}
View Code

 6:求幂塔公式:a^(a^(a^(a^...))))总共有b个a,结果对m取模

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e6+5;
typedef long long ll;
bitset<maxn>notprime;
int phi[maxn],prime[maxn],cnt=0;
void pre(){
    phi[1]=1;
    for(int i=2;i<=maxn-5;i++){
        if(!notprime[i]){
            prime[++cnt]=i;
            phi[i]=i-1;//i为素数时,phi[i]=i-1
        }
        for(int j=1;j<=cnt&&prime[j]*i<=maxn;j++){
            notprime[i*prime[j]]=1;
            if(i%prime[j]==0){//每个数只被它的最小质因数给筛掉
                phi[i*prime[j]]=phi[i]*prime[j];
                //当a与b互质时,满足phi(a∗b)=phi(a)∗phi(b),积性函数
                break;
            }
            else phi[i*prime[j]]=phi[i]*(prime[j]-1);
            //phi[i∗prime[j]]=phi[i]∗phi[prime[j]]=phi[i]∗(prime[j]−1);
        }
    }
}
ll quick_mod(ll a,ll n,ll mod)
{
    ll res=1;
    while (n)
    {
        if(n&1)res=res*a%mod;
        a=a*a%mod;
        n>>=1;
//        if(n&1)res=res*a>mod?res*a%mod+mod:res*a;
//        a=a*a>mod?a*a%mod+mod:a*a;
//        n>>=1;//这里保证了a与m不互质的情况?
    }
    return res;
}
ll deal(ll a,ll b,ll m)
{
    if(b==0)return 1;
    if(m==1)return 1;
    ll res=deal(a,b-1,phi[m]);
    return quick_mod(a,res,m);
}
int main(){
    pre();
    int t;
    cin>>t;
    ll a,b,m;
    while (t--)
    {
        cin>>a>>b>>m;
        cout<<deal(a,b,m)%m<<endl;
    }
    return 0;
}
View Code

7:ST表RMQ

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=100010;
int ST[maxn][40];
int a[maxn];

void Init1(int n)//区间最值初始化
{
    for(int j = 1;(1<<j) <= n;j++){
        for(int i = 1;i+(1<<j)-1 <= n;i++){
            ST[i][j]=max(ST[i][j-1],ST[i+(1<<(j-1))][j-1]);
        }
    }
}
int query(int l,int r)//询问区间最值
{
    int k=(int)(log(r-l+1)/log(2.0));
    return max(ST[l][k],ST[r+1-(1<<k)][k]);
}
void Init2(int n)//区间求和初始化
{
    for(int j = 1;(1<<j) <= n;j++){
        for(int i = 1;i+(1<<j)-1 <= n;i++){
            ST[i][j]=ST[i][j-1]+ST[i+(1<<(j-1))][j-1];
        }
    }
}
int sum(int l,int r)//区间求和
{
    int ans=0;
    for(int i=20;i>=0;i--){
        if(l+(1<<i)>r)continue;
        ans+=ST[l][i];
        l+=(1<<i);
    }
    return ans+ST[l][0];
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        ST[i][0]=a[i];
    }
    Init2(n);
    while(m--){
        int l,r;
        scanf("%d%d",&l,&r);
        printf("%d\n",sum(l,r));
    }
    return 0;
}
View Code

BM线性递推模板:

#include<bits/stdc++.h>
#define mp make_pair
#define rep(i,a,n) for (int i=a;i<n;i++)
#define per(i,a,n) for (int i=n-1;i>=a;i--)
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
#define SZ(x) ((int)(x).size())
using namespace std;
typedef vector<int> VI;
typedef long long ll;
typedef pair<int, int> PII;
const ll mod = 1000000007;
ll powmod(ll a, ll b) { ll res = 1; a %= mod; assert(b >= 0); for (; b; b >>= 1) { if (b & 1)res = res * a%mod; a = a * a%mod; }return res; }
// head
ll n;
namespace linear_seq {
    const int N = 10010;
    ll res[N], base[N], _c[N], _md[N];

    vector<int> Md;
    void mul(ll *a, ll *b, int k) {
        rep(i, 0, k + k) _c[i] = 0;
        rep(i, 0, k) if (a[i]) rep(j, 0, k) _c[i + j] = (_c[i + j] + a[i] * b[j]) % mod;
        for (int i = k + k - 1; i >= k; i--) if (_c[i])
            rep(j, 0, SZ(Md)) _c[i - k + Md[j]] = (_c[i - k + Md[j]] - _c[i] * _md[Md[j]]) % mod;
        rep(i, 0, k) a[i] = _c[i];
    }
    int solve(ll n, VI a, VI b) { // a 系数 b 初值 b[n+1]=a[0]*b[n]+...
                                  //        printf("%d\n",SZ(b));
        ll ans = 0, pnt = 0;
        int k = SZ(a);
        assert(SZ(a) == SZ(b));
        rep(i, 0, k) _md[k - 1 - i] = -a[i]; _md[k] = 1;
        Md.clear();
        rep(i, 0, k) if (_md[i] != 0) Md.push_back(i);
        rep(i, 0, k) res[i] = base[i] = 0;
        res[0] = 1;
        while ((1ll << pnt) <= n) pnt++;
        for (int p = pnt; p >= 0; p--) {
            mul(res, res, k);
            if ((n >> p) & 1) {
                for (int i = k - 1; i >= 0; i--) res[i + 1] = res[i]; res[0] = 0;
                rep(j, 0, SZ(Md)) res[Md[j]] = (res[Md[j]] - res[k] * _md[Md[j]]) % mod;
            }
        }
        rep(i, 0, k) ans = (ans + res[i] * b[i]) % mod;
        if (ans<0) ans += mod;
        return ans;
    }
    VI BM(VI s) {
        VI C(1, 1), B(1, 1);
        int L = 0, m = 1, b = 1;
        rep(n, 0, SZ(s)) {
            ll d = 0;
            rep(i, 0, L + 1) d = (d + (ll)C[i] * s[n - i]) % mod;
            if (d == 0) ++m;
            else if (2 * L <= n) {
                VI T = C;
                ll c = mod - d * powmod(b, mod - 2) % mod;
                while (SZ(C)<SZ(B) + m) C.pb(0);
                rep(i, 0, SZ(B)) C[i + m] = (C[i + m] + c * B[i]) % mod;
                L = n + 1 - L; B = T; b = d; m = 1;
            }
            else {
                ll c = mod - d * powmod(b, mod - 2) % mod;
                while (SZ(C)<SZ(B) + m) C.pb(0);
                rep(i, 0, SZ(B)) C[i + m] = (C[i + m] + c * B[i]) % mod;
                ++m;
            }
        }
        return C;
    }
    int gao(VI a, ll n) {
        VI c = BM(a);
        c.erase(c.begin());
        rep(i, 0, SZ(c)) c[i] = (mod - c[i]) % mod;
        return solve(n, c, VI(a.begin(), a.begin() + SZ(c)));
    }
};
int main() {
    vector<int> V;
    int a[] = {2, 24, 96, 416, 1536, 5504, 18944, 64000, 212992, 702464, 2301952};
    cin >> n;
    for(int i = 0; i <= 10; i++) V.push_back(a[i]);
    printf("%lld\n", 1ll * linear_seq::gao(V, n - 1)%mod);
}
View Code

 

转载于:https://www.cnblogs.com/cherish-lin/p/11355855.html

深度学习是机器学习的一个子领域,它基于人工神经网络的研究,特别是利用多层次的神经网络来进行学习和模式识别。深度学习模型能够学习数据的高层次特征,这些特征对于图像和语音识别、自然语言处理、医学图像分析等应用至关重要。以下是深度学习的一些关键概念和组成部分: 1. **神经网络(Neural Networks)**:深度学习的基础是人工神经网络,它是由多个层组成的网络结构,包括输入层、隐藏层和输出层。每个层由多个神经元组成,神经元之间通过权重连接。 2. **前馈神经网络(Feedforward Neural Networks)**:这是最常见的神经网络类型,信息从输入层流向隐藏层,最终到达输出层。 3. **卷积神经网络(Convolutional Neural Networks, CNNs)**:这种网络特别适合处理具有网格结构的数据,如图像。它们使用卷积层来提取图像的特征。 4. **循环神经网络(Recurrent Neural Networks, RNNs)**:这种网络能够处理序列数据,如时间序列或自然语言,因为它们具有记忆功能,能够捕捉数据中的时间依赖性。 5. **长短期记忆网络(Long Short-Term Memory, LSTM)**:LSTM 是一种特殊的 RNN,它能够学习长期依赖关系,非常适合复杂的序列预测任务。 6. **生成对抗网络(Generative Adversarial Networks, GANs)**:由两个网络组成,一个生成器和一个判别器,它们相互竞争,生成器生成数据,判别器评估数据的真实性。 7. **深度学习框架**:如 TensorFlow、Keras、PyTorch 等,这些框架提供了构建、训练和部署深度学习模型的工具和库。 8. **激活函数(Activation Functions)**:如 ReLU、Sigmoid、Tanh 等,它们在神经网络中用于添加非线性,使得网络能够学习复杂的函数。 9. **损失函数(Loss Functions)**:用于评估模型的预测与真实值之间的差异,常见的损失函数包括均方误差(MSE)、交叉熵(Cross-Entropy)等。 10. **优化算法(Optimization Algorithms)**:如梯度下降(Gradient Descent)、随机梯度下降(SGD)、Adam 等,用于更新网络权重,以最小化损失函数。 11. **正则化(Regularization)**:技术如 Dropout、L1/L2 正则化等,用于防止模型过拟合。 12. **迁移学习(Transfer Learning)**:利用在一个任务上训练好的模型来提高另一个相关任务的性能。 深度学习在许多领域都取得了显著的成就,但它也面临着一些挑战,如对大量数据的依赖、模型的解释性差、计算资源消耗大等。研究人员正在不断探索新的方法来解决这些问题。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值