模板区域[未完待续]（会定期的更新哦（有时间就更了））

Posted 2020-10-03 Shadow

　　　　写这个博客目的就是为了记录下学过的模板方便我这焫鷄复习吧//dalao们绕道

　　　　近期学的：

　　　　（1）来自机房学长jjh大神教的求1~n的所有最小素因数和加上本焫鷄的批注

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>//求1~n的最小质因数
using namespace std;
const int MAXN=1e6+5;
const int LIM=1e6;
int prime[MAXN],mnp[MAXN],cnt=0;
bool vis[MAXN];
int main()
{
    for(int i=2;i<=LIM;i++)
    {
        if(!vis[i])
        {
            mnp[i]=i;//最小质因数
            prime[++cnt]=i;//质因数
        }
        for(int j=1;j<=cnt;j++)
        {
            if(1LL*i*prime[j]>LIM)
                break;
            vis[i*prime[j]]=1;//合数直接标记
            if(i%prime[j]==0)//如果i可以整除以prime[j]
            {
                mnp[i*prime[j]]=mnp[i];//那么这个数的最小质因数就为i的最小质因数
                break;
            }
            else //否则
                mnp[i*prime[j]]=prime[j];//他的最小质因数就为prime[j]
        }
    }
}

ヾ(?°?°?)??

　　　　　（2）比较简单的筛法求素数

void shai(int x)
{
    memset(f,1,sizeof(f));
    for(int i=2;i<=x;i++)
    {
        if(f[i])
        {
            for(int j=i+i;j<=x;j+=i)
            {
                f[j]=false;
            }
        }
    }
    for(int i=2;i<=x;i++)
        if(f[i])
            prime[++len]=i;
}

?(?>?<?)?

　　　　　（3）反素数

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#define LL long long
using namespace std;
LL yi[15]={2,3,5,7,11,13,17,19,23,29};
LL n;
LL big,num;
void dfs(LL x,int y,int limit,int z)
{
    if(x>n)
        return;
    if(num<y)
    {
        big=x;
        num=y;
    }
    if(num==y&&big>x)
    {
        big=x;
    }
    LL temp=x;
    for(int i=1;i<=limit;i++)
    {
        temp=temp*yi[z];
        if(temp>n)
            return;
        dfs(temp,y*(i+1),i,z+1);
    }
}
int main()
{
    cin>>n;
    big=0;
    num=0;
    dfs(1,1,50,0);
    cout<<big<<endl;
    return 0;
}

(￣▽￣)／

　　　　　（4）来个图论的基本算法Bellman-ford

bool Bellman-ford(int st)
{
    memset(dis,10,sizeof(dis));
    dis[st]=0;
    bool rel=0;
    for(int i=1;i<=n;i++)
    {
        rel=0;
        for(int j=1;j<=len;j++)
        {
            if(dis[a[j].x]+a[j].v<dis[a[j].y])
            {
                dis[a[j].y]=dis[a[j].x]+a[j].v;
                rel=1;
            }
        }
        if(!rel) return 0;
    }
    for(int i=1;i<=len;i++)
    {
        if(dis[a[i].x]+a[i].v<dis[a[i].y])
        {
            return 1;
        }
    }
    return 0; 
}

￣へ￣

　　　　　（5）SPFA

void SPFA(int s)        
{
    memset(dis,10,sizeof(dis));
    memset(vis,0,sizeof(vis));
    dis[s]=0;vis[s]=1;q[s]=i;
    head=0;tail=1;
    while(head<tail)
    {
        int tn=q[++head];
        vis[tn]=0;
        int te=lin[tn];
        for(int j=te;j;j=a[j].next)
        {
            int tmp=a[j].y;
            if(dis[tn]+a[j].v<dis[tmp])
            {
                dis[tmp]=dis[tn]+a[j].v;
                if(!vis[tmp])
                {
                    q[++tail]=tmp;
                    vis[tmp]=1;
                }
            }
        }
    }
}

φ(>ω<*)

　　　　　（6）dijkstra算法

void dijkstra(int st)
{
    for(int i=1;i<=n;i++)
        dis[i]=a[st][i];
    memset(vis,0,sizeof(vis));
    vis[st]=1;dis[st]=0;
    for(int i=1;i<n;i++)
    {
        int minn=9999999;
        int k=0;
        for(int j=1;j<=n;j++)
        {
            if(!vis[j]&&dis[j]<minn)
            {
                minn=dis[j];
                k=j;
            }
        }
        if(k==0)
            return;
        vis[k]=1;
        for(int j=1;j<=n;j++)
        {
            if((!vis[j])&&(dis[k]+a[k][j]<dis[j]))
                dis[j]=dis[k]+a[k][j];
        }
    }
}

￣ω￣=

　　　　　（7）最小生成树---Prim算法

void Prim(int s)
{
    memset(dis,10,sizeof(dis));
    for(int i=1;i<=n;i++)
        dis[i]=a[s][i];//所有点都不在队列里，除了s
    memset(vis,0,sizeof(vis));
    vis[s]=1; sumn=0;
    for(int i=2;i<=n;i++)
    {
        //寻找现在能到达的边中最短的那条
        int minn=a[0][0],c=0;
        for(int j=1;j<=n;j++)
        {
            if((!vis[j])&&(dis[j]<minn))
            {
                minn=dis[j];
                c=j;
            }
        }
        //c点到达了，最小生成树长度增加
        vis[c]=1;
        sumn+=minn;
        //基于这个点做松弛操作
        for(int j=1;j<=n;j++)
        {
            if((a[c][j]<dis[j])&&(!vis[j]))
                dis[j]=a[c][j];
        }
    }
}

(??ω??)

　　　　　　//未完待续（欲知后事如何请听下回分解）