c++算法模板（二）

<6>最短路问题：

1.      Flored-warshall 算法(n^3)

  for(int k=1;k<=n;k++)

          for(int i=1;i<=n;i++)

            for(int j=1;j<=n;j++)

          if((dis[i][j]>dis[i][k]+dis[k][j]) && (i!=k) && (i!=j) && (k!=j))

          {

                  dis[i][j]=dis[i][k]+dis[k][j];

                  pre[i][j]=pre[k][j];

          }

输出路径函数：

在调用处加上：cout<<s<<” ”;   //s为起点；

void print (int x)

 {

         if(pre[s][x]==0) return ;

         print(pre[s][x]);

         cout<<"->"<<x;

 }

2.      dijkstra算法(n^2)

无优化，用了现写的快读搞定。洛谷的模板题P3371.用cin流最后一个点超时，scanf和快读都是可以过的。当数据规模比较大的时候用scanf好咯。

#include<iostream>

#include<cstdio>

#include<cstring>

#include<cstdlib>

#include<cmath>

#include<algorithm>

#define maxn 10010

#define maxm 500010

using namespace std;

int num,minl,k,n,m,s;

int v[maxn],dis[maxn],head[maxn];

int read()

{

int out=0,fh=1;

char cc=getchar();

if (cc=='-')fh=-1;

while(cc>'9'||cc<'0')cc=getchar();

while(cc>='0'&&cc<='9'){out=out*10+cc-'0';cc=getchar();}

return out*fh;}

/*void write(int x)

{

if(x==0){

putchar('0');

return;}

int num=0;char c[15];

while(x)c[++num]=(x%10)+48,x/=10;

while(num) putchar(c[num--]);

putchar(' ');}  */

struct Edge

{

int next;

int to;

int dis;

}edge[maxm];

void add_edge (int u,int v,int w)

{

num++;

edge[num].next=head[u];

edge[num].to=v;

edge[num].dis=w;

head[u]=num;

}

void dijstra (int v0)

{

for(int i=1;i<=n;i++)

 dis[i]=2147483647;

dis[v0]=0;

for(int i=1;i<=n;i++)

{

           minl=2147483647;

           k=0;

           for(int j=1;j<=n;j++)

           {

                    if(v[j]==0 && minl>dis[j])

                    {

                             minl=dis[j];

                             k=j;

                    }

           }

           v[k]=1;

           for(int i=head[k];i!=0;i=edge[i].next)

           {

                    if(v[edge[i].to]==0 && minl+edge[i].dis<dis[edge[i].to])

                    dis[edge[i].to]=minl+edge[i].dis;

           }

 }

}

int main()

{

cin>>n>>m>>s;

for(int i=1;i<=m;i++)

{

           int u,v,w;

           u=read();

           v=read();

           w=read();

           add_edge(u,v,w);

}

dijstra(s);

for(int i=1;i<=n;i++)

cout<<dis[i]<<" ";

return 0;

 }

3.Dijkstra(堆优化):

实测516ms; 堆优化是指在寻找最近点时,用堆log时间复杂度取点,用priority_queue(堆/优先队列)实现;

较朴素算法,利用了堆,能更快取得最近点;

#include<cstdio>

#include<iostream>

#include<algorithm>

#include<queue>

using namespace std;

const int INF=2147483647;

const int maxn=10000+10;

const int maxm=500000+10;

int n,m,s;

int fir[maxn],nxt[maxm],to[maxm],val[maxm],cnt;

void add_edge(int u,int v,int w)

{

    nxt[++cnt]=fir[u];fir[u]=cnt;to[cnt]=v;val[cnt]=w;

}

struct Node {

    int d,id;

    Node(){}

    Node(int d,int id):d(d),id(id){}

    bool operator < (const Node& rhs) const {

        return d>rhs.d;//重载<,方便堆

    }

};

int dis[maxn],vis[maxn];

void Dijkstra(int s)

{

    for(int i=1;i<=n;i++) dis[i]=INF; dis[s]=0;

    priority_queue<Node>Q;

    Q.push(Node(0,s));

    while(!Q.empty()) {

        Node u=Q.top(); Q.pop();

        if(vis[u.id]) continue;//若某个点已经被更新到最优,就不用再次更新其他点

        vis[u.id]=1;

        for(int e=fir[u.id];e;e=nxt[e]) {

            int v=to[e],w=val[e];

            if(u.d+w<dis[v]) {

                dis[v]=u.d+w;

                Q.push(Node(dis[v],v));

            }

        }

    }

}

int main()

{

    scanf("%d%d%d",&n,&m,&s);

    for(int u,v,w,i=0;i<m;i++) {

        scanf("%d%d%d",&u,&v,&w);

        add_edge(u,v,w);

    }

    Dijkstra(s);

    for(int i=1;i<=n;i++) printf("%d ",dis[i]);

    return 0;

}

4.SPFA(无优化):

766ms;

耗时主要原因是可能某个能将更多点尽可能优化的,却放进了队尾;

#include<cstdio>

#include<iostream>

#include<algorithm>

#include<queue>

using namespace std;

const int INF=2147483647;

const int maxn=10000+10;

const int maxm=500000+10;

int n,m,s;

int fir[maxn],nxt[maxm],to[maxm],val[maxm],cnt;

void add_edge(int u,int v,int w)

{

    nxt[++cnt]=fir[u];fir[u]=cnt;to[cnt]=v;val[cnt]=w;

}

int dis[maxn],inq[maxn];

void SPFA(int s)

{

    for(int i=1;i<=n;i++) dis[i]=INF; dis[s]=0;

    queue<int>Q;Q.push(s);

    while(!Q.empty()) {

        int u=Q.front(); Q.pop();

        for(int e=fir[u];e;e=nxt[e]) {

            int v=to[e],w=val[e];

            if(dis[u]+w<dis[v]) {

                dis[v]=dis[u]+w;

                if(!inq[v]) Q.push(v);

            }

        }

    }

}

int main()

{

    scanf("%d%d%d",&n,&m,&s);

    for(int u,v,w,i=0;i<m;i++) {

        scanf("%d%d%d",&u,&v,&w);

        add_edge(u,v,w);

    }

    SPFA(s);

    for(int i=1;i<=n;i++) printf("%d ",dis[i]);

    return 0;

}

5.SPFA(SLF优化):

实测497ms; SLF优化是指,当前进队的dis值与队首的dis值比较,若<=进队首,否则进队尾,用deque(双向队列)实现;

#include<cstdio>

#include<iostream>

#include<algorithm>

#include<queue>

using namespace std;

const int INF=2147483647;

const int maxn=10000+10;

const int maxm=500000+10;

int n,m,s;

int fir[maxn],nxt[maxm],to[maxm],val[maxm],cnt;

void add_edge(int u,int v,int w)

{

    nxt[++cnt]=fir[u];fir[u]=cnt;to[cnt]=v;val[cnt]=w;

}

int dis[maxn],inq[maxn];

void SPFA(int s)

{

    for(int i=1;i<=n;i++) dis[i]=INF; dis[s]=0;

    deque<int>Q;

    Q.push_front(s);

    while(!Q.empty()) {

        int u=Q.front(); Q.pop_front(); inq[u]=0;

        for(int e=fir[u];e;e=nxt[e]) {

            int v=to[e],w=val[e];

            if(dis[u]+w<dis[v]) {

                dis[v]=dis[u]+w;

                if(!inq[v]) {

                    if(Q.empty()||dis[v]<=dis[Q.front()]) Q.push_front(v);

                    else Q.push_back(v);

                    inq[v]=1;

                }

            }

        }

    }

}

int main()

{

    scanf("%d%d%d",&n,&m,&s);

    for(int u,v,w,i=0;i<m;i++) {

        scanf("%d%d%d",&u,&v,&w);

        add_edge(u,v,w);

    }

    SPFA(s);

    for(int i=1;i<=n;i++) printf("%d ",dis[i]);

    return 0;

}

总结: 对于此题而言,时间效率:SPFA(ELF优化)>Dijkstra(堆优)>SPFA>Dijkstra;

实际上SPFA的时间复杂度不够稳定,有些时候易被出题人卡常数,建议使用更稳定的Dijkstra;

 

 <7>最小环问题

ans为最小环的最优值：

for(int k=1;k<=n;k++)

           for(int i=1;i<k;i++)

            for(int j=i+1;j<k;i++)

           ans=min(ans,dis[i][k]+dis[k][j]+dis[i][j]);

          for(int i=1;i<=n;i++)

            for(int j=1;j<=n;j++)

              dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);

<8>并查集

“并”：void unionn (int x,int y)

{

         x=find(x);

         y=find(y);

         if(x!=y) 

         pre[x]=y; 

}

 “查”：int find (int x)

{

         if(pre[x]!=x)                  //路径压缩算法，如果不需要可以这样写

           pre[x]=find(pre[x]);       //if(x!=y) return find(pre[x]);

         return pre[x];               //else return x;

}

“集”：bool judge(int x,int y)  //判断是否连通，可以直接写在代码里不用另写函数。

{

         x=find(x);             

         y=find(y);

         if(x==y) return true;

         else return false;

 }

<9>MST(最小生成树)

1.      prim算法

 #include<iostream>

#include<cstring>

#define maxn 5010

#define maxm 200010

using namespace std;

int map[maxn][maxn];

int e[maxm];

int v[maxn];

int n,x,y,w,m;

int main()

{

memset(e,0x7f,sizeof(e));

cin>>n>>m;

for(int i=1;i<=m;i++)

{

           cin>>x>>y>>w;

           map[x][y]=map[y][x]=w;

}

e[1]=0;

for(int i=1;i<=n;i++)

{

           int k=0;

           for(int j=1;j<=n;j++)

            if((v[j]==0) && (e[j]<e[k]))

              k=j;

           v[k]=1;

           for(int j=1;j<=n;j++)

            if((v[j]==0) && (map[k][j]<e[j]))

              e[j]=map[k][j];

}

int sum=0;

for(int i=1;i<=n;i++)

 sum+=e[i];

cout<<sum<<endl;

return 0;

}

2.      kruskal算法

#include<iostream>

#include<algorithm>

#define maxn 5010

#define maxm 200010

using namespace std;

int n,k,m,sum,pre[maxn];

int find (int x);

struct point

{

         int x;

         int y;

         int v;

}a[maxm];

void unionn (int x,int y)

{

         x=find(x);

         y=find(y);

         if(x!=y) 

         pre[x]=y; 

}

int find (int x)

{

         if(pre[x]!=x)          

           pre[x]=find(pre[x]);  

         return pre[x];     

}

int cmp(const point &a,const point &b)

{

         if(a.v<b.v)return 1;

         else return 0;

}

int main()

{

         cin>>n>>m;

         for(int i=1;i<=m;i++)

         {

                   cin>>a[i].x;

                   cin>>a[i].y;

                   cin>>a[i].v;

         }

         for(int i=1;i<=n;i++)

           pre[i]=i;

         sort(a+1,a+1+m,cmp);

         for(int i=1;i<=m;i++)

         {

                   if(find(a[i].x)!=find(a[i].y))

                   {

                            unionn(a[i].x,a[i].y);

                            sum+=a[i].v;

                            k++;

                   }

                   if(k==n-1) break;

         }

         cout<<sum<<endl;

         return 0;

}

<10>拓扑排序

#include<iostream>

using namespace std;

int a[101][101],c[101],r[101],ans[101];

int i,j,tot,temp,num,n,m;

int main()

{

         cin>>n;

         for(int i=1;i<=n;i++)

         {

                   do

                   {

                            cin>>j;

                            if(j!=0)

                            {

                                     c[i]++;

                                     a[i][c[i]]=j;

                                     r[j]++;

                            }

                   }while(j!=0);

         }

         for(int i=1;i<=n;i++)

          if(r[i]==0)

           ans[++tot]=i;

         do

         {

                   temp=ans[tot];

                   cout<<temp<<" ";

                   tot--;

                   num++;

                   for(int i=1;i<=c[temp];i++)

                   {

                            r[a[temp][i]]--;

                            if(r[a[temp][i]]==0)

                             ans[++tot]=a[temp][i];

                   }

         }while(num!=n);

         return 0;

}

<11>关键路径

1.      求出每个点的最早发生的时间，正序求得

Earliest[1…n]=max(Earliest[1…n+map[pre][ 1…n])

2.      求出每个点最迟发生的时间，逆序求得

Last[n…1]=min(Last[n…1]-map[n…1][pre])

3.      最迟－最早的的余量如果为0，则此点为关键点，项连得路径叫做关键路径。

1.      数论

 <1>辗转相除法

 a / b = b / a%b；

int gcd (int a,int b)

{

      if(b==0)

      return a;

      else

      gcd(b,a%b);

 }

也可以用来求最小公倍数，lcm=a/gcd(a,b)*b。先除后乘的原因是为了避免乘法溢出。

2.唯一分解定理：一个数可以分成若干个素数相乘的形式。

3.      素数定理：π(x)~x/lnx.求出有多少个小于x的素数。

4.      Eratosthenes筛素数

 Int m=sqrt(n+0.5);

 For（int i=1;i<=n;i++）

  If(vis[i]==0)

   For(int j=i*i;j<=n;j++)

Vis[j]=1;

还要确定1不是素数，2是素数。如果标记为1则i不为素数，如果未标记则为素数。

5.      扩展欧几里得算法

 Void gcd (int a,int b,int &d,int &x,int &y)

{

  If(b==0)  {d=a; x=1; y=0;}

  Else { gcd(b,a%b,y,x);

        Y-=x*(a/b);

       }

}

求出一组解来，其他部分可写为(x0+kb’,y0-ka’),a’=a/gcd(a,b),b’=b/gcd(a,b);k是整数。

G=gcd(g/b)  若ax+bx=c 若c不为g的倍数是，则此方程无整数解。

6.      幂取模

 a^n %m 的值：

 Int mod (int a,int b,int m)

{

If(n==0) return 1;

 Int x=mod(a,n/2,m);

 Long long ans=(long long)x*x %m;

If(n%2==1) ans=ans*a % m;

Return (int) ans;

}

7.      同余与模运算：

  (a+b)%n=((a %n)+(b%n))%n

  (a-b)%n=((a%n)-(b%n)+n)%n

  ab%n=(a%n)(b%n)%n

8.      杨辉三角：

                      1

                   1    1

                  1   2   1

               1    3    3   1

             1    4   6    4    1

           1   5    10  10   5    1  

         1   6   15    20  15   6    1

 

C[i]=c[i+1]*(n-i+1)/i;

C[i]=n!/i!(n-1)!;