2017-11-07-noip模拟题

• T1 数学老师的报复

• 

_{矩阵快速幂模板，类似于菲波那切数列的矩阵}

[1,1]*[A,1

　　　 B,0]

 #include <cstdio>

 #define LL long long
 inline void read(LL &x)
 {
     x=; register char ch=getchar(); register bool _=;
     for(; ch>''||ch<''; ch=getchar()) if(ch=='-') _=;
     for(; ch>=''&&ch<=''; ch=getchar()) x=x*+ch-'';
     x=_?((~x)+):x;
 }
 const int mod();
 LL a,b,n;

 struct Matrix_fb {
     LL e[][];
     Matrix_fb operator * (Matrix_fb x) const
     {
         Matrix_fb ret;
         for(int i=; i<; ++i)
             for(int j=; j<; ++j)
             {
                 ret.e[i][j]=;
                 for(int k=; k<; ++k)
                     ret.e[i][j]+=e[i][k]*x.e[k][j],ret.e[i][j]%=mod;
             }
         return ret;
     }
 } ans,base;

 int Presist()
 {
 //    freopen("attack.in","r",stdin);
 //    freopen("attack.out","w",stdout);

     read(a),read(b),read(n);
     if(n<=) { puts(""); return ; }
     ans.e[][]=ans.e[][]=;
     ans.e[][]=ans.e[][]=;
     base.e[][]=a%,base.e[][]=,
     base.e[][]=b%,base.e[][]=;
     for(n-=; n; n>>=,base=base*base)
         if(n&) ans=ans*base;
     printf("%lld\n",ans.e[][]);
     return ;
 }

 int Aptal=Presist();
 int main(int argc,char**argv){;}

AC

• T2 和生物老师的战争

• 

 #include <cstdio>

 inline void read(int &x)
 {
     x=; register char ch=getchar();
     for(; ch>''||ch<''; ) ch=getchar();
     for(; ch>=''&&ch<=''; ch=getchar()) x=x*+ch-'';
 }

 int Presist()
 {
     freopen("fseq.in","r",stdin);
     freopen("fseq.out","w",stdout);
     int t; read(t);
     for(int n,m; t--; )
     {
         read(n),read(m);
         if(n<m) puts("0.000000");
         else
         {
             double fz=n-m+;
             double fm=n+;
             printf("%.6lf\n",fz/fm);
         }
     }
     return ;
 }

 int Aptal=Presist();
 int main(int argc,char**argv){;}

AC

• T3 化学竞赛的大奖

• 

 #include <cstring>
 #include <cstdio>
 #include <queue>

 #define LL long long
 #define min(a,b) (a<b?a:b)
 #define max(a,b) (a>b?a:b)

 inline void read(int &x)
 {
     x=; register char ch=getchar();
     for(; ch>''||ch<''; ) ch=getchar();
     for(; ch>=''&&ch<=''; ch=getchar()) x=x*+ch-'';
 }
 const int N(+);
 const int M(+);
 int n,m;
 int head[][N],sumedge[];
 struct Edge {
     int v,next,w;
     Edge(int v=,int next=,int w=):v(v),next(next),w(w){}
 }edge[][M<<];
 inline void ins(int u,int v,int w,int op)
 {
     edge[op][++sumedge[op]]=Edge(v,head[op][u],w),head[op][u]=sumedge[op];
     edge[op][++sumedge[op]]=Edge(u,head[op][v],w),head[op][v]=sumedge[op];
 }

 int tim,dfn[N],low[N];
 int top,sta[N],insta[N];
 int sumcol,col[N];
 void DFS(int u,int pre)
 {
     low[u]=dfn[u]=++tim;
     sta[++top]=u, insta[u]=;
     for(int v,i=head[][u]; i; i=edge[][i].next)
     {
         /*if(vis[i]||vis[i^1]) continue;
         vis[i]=vis[i^1]=true;*/
         v=edge[][i].v; if(v==pre) continue;
         if(!dfn[v]) DFS(v,u),low[u]=min(low[u],low[v]);
         else if(insta[v])  low[u]=min(low[u],dfn[v]);
     }
     if(low[u]==dfn[u])
     {
         col[u]=++sumcol;
         for(; u!=sta[top]; top--)
         {
             col[sta[top]]=sumcol;
             insta[sta[top]]=false;
         }
         insta[u]=false, top--;
     }
 }

 struct Node {
     int pos; LL dis;
     bool operator < (const Node&x)const
     {
         return dis<x.dis;
     }
 }u,v;
 std::priority_queue<Node>que;
 LL dis[N],ans[N];
 bool vis[N];
 inline void Dijkstra(int s)
 {
     for(; !que.empty(); ) que.pop();
     for(int i=; i<=sumcol; ++i)
         dis[i]=-,vis[i]=false;

     dis[s]=u.dis=,u.pos=s; que.push(u);
     for(; !que.empty(); )
     {
         u=que.top(); que.pop();
         if(vis[u.pos]) continue; vis[u.pos]=;
         for(int i=head[][u.pos]; i; i=edge[][i].next)
         {
             v.pos=edge[][i].v; if(!vis[v.pos])
             if(dis[v.pos]<dis[u.pos]+edge[][i].w)
             {
                 v.dis=u.dis+(LL)edge[][i].w;
                 ans[s]=max(ans[s],v.dis);
                 dis[v.pos]=v.dis;
                 que.push(v);
             }
         }
     }
 }

 int Presist()
 {
 //    freopen("prize.in","r",stdin);
 //    freopen("prize.out","w",stdout);

     read(n),read(m);
     for(int u,v,w,i=; i<=m; ++i)
         read(u),read(v),read(w),ins(u,v,w,);
     for(int i=; i<=n; ++i)
         if(!dfn[i]) DFS(i,-);

     for(int v,u=; u<=n; ++u)
         for(int i=head[][u]; i; i=edge[][i].next)
         {
             v=edge[][i].v; if(col[u]==col[v]) continue;
             ins(col[u],col[v],edge[][i].w,);
         }

     for(int i=; i<=sumcol; ++i) ans[i]=-, Dijkstra(i);
     for(int i=; i<=n; ++i) printf("%lld\n",ans[col[i]]);
     return ;
 }

 int Aptal=Presist();
 int main(int argc,char**argv){;}

缩点后，n边Dijkstra 40分，，考试暴力

可以先求出强连通分量，两次dfs得到数的直径，ans[i]=max(dis(s,i),dis(t,i)）

 #include <cstring>
 #include <cstdio>

 #define min(a,b) (a<b?a:b)
 #define max(a,b) (a>b?a:b)

 inline void read(int &x)
 {
     x=; register char ch=getchar();
     for(; ch>''||ch<''; ) ch=getchar();
     for(; ch>=''&&ch<=''; ch=getchar()) x=x*+ch-'';
 }

 const int N(+);
 const int M(+);

 int n,m;
 int head[][N],sumedge[];
 struct Edge {
     int v,next,w;
     Edge(int v=,int next=,int w=):v(v),next(next),w(w){}
 }edge[][M<<];
 inline void ins(int u,int v,int w,int op)
 {
     edge[op][++sumedge[op]]=Edge(v,head[op][u],w),head[op][u]=sumedge[op];
     if(!op) edge[op][++sumedge[op]]=Edge(u,head[op][v],w),head[op][v]=sumedge[op];
 }

 int tim,dfn[N],low[N];
 int top,sta[N],insta[N];
 int sumcol,col[N];

 namespace Tarjan {

     void DFS(int u,int pre)
     {
         low[u]=dfn[u]=++tim;
         sta[++top]=u, insta[u]=;
         for(int v,i=head[][u]; i; i=edge[][i].next)
         {
             v=edge[][i].v;
             if(!dfn[v]) DFS(v,u),low[u]=min(low[u],low[v]);
             else if(insta[v]&&v!=pre) low[u]=min(low[u],dfn[v]);
         }
         if(low[u]==dfn[u])
         {
             col[u]=++sumcol;
             for(; u!=sta[top]; top--)
             {
                 col[sta[top]]=sumcol;
                 insta[sta[top]]=false;
             }
             insta[u]=false, top--;
         }
     }
     inline void work()
     {
         for(int i=; i<=n; ++i)
             if(!dfn[i]) DFS(i,-);
     }
 }

 int dis[][N],s,t,maxx;
 namespace Solve {
     void DFS(int u,int pre)
     {
         for(int v,i=head[][u]; i; i=edge[][i].next)
         {
             v=edge[][i].v; if(pre==v) continue;
             dis[][v]=dis[][u]+edge[][i].w;
             if(dis[][v]>maxx) maxx=dis[][v],s=v;
             DFS(v,u);
         }
     }
     void DFS_(int u,int pre)
     {
         for(int v,i=head[][u]; i; i=edge[][i].next)
         {
             v=edge[][i].v; if(v==pre) continue;
             dis[][v]=dis[][u]+edge[][i].w; DFS_(v,u);
         }
     }
     inline void work()
     {
         for(int v,u=; u<=n; ++u)
             for(int i=head[][u]; i; i=edge[][i].next)
             {
                 v=edge[][i].v; if(col[u]==col[v]) continue;
                 ins(col[u],col[v],edge[][i].w,);
             }
         DFS (,-);
         for(int i=; i<=sumcol; ++i) dis[][i]=; maxx=; DFS (s,-);
         DFS_(s,-);
         for(int i=; i<=n; ++i)
             printf("%d\n",max(dis[][col[i]],dis[][col[i]]));
     }

 }

 int Presist()
 {
     freopen("prize.in","r",stdin);
     freopen("prize.out","w",stdout);

     read(n),read(m);
     for(int u,v,w,i=; i<=m; ++i)
         read(u),read(v),read(w),ins(u,v,w,);
     Tarjan::work();
     Solve ::work();
     return ;
 }

 int Aptal=Presist();
 int main(int argc,char**argv){;}

AC