2017-11-07-noip模拟题

• T1 数学老师的报复

• 

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

[1,1]*[A,1

　　　 B,0]

#include <cstdio>

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

struct Matrix_fb {
    LL e[2][2];
    Matrix_fb operator * (Matrix_fb x) const 
    {
        Matrix_fb ret;
        for(int i=0; i<2; ++i)
            for(int j=0; j<2; ++j)
            {
                ret.e[i][j]=0;
                for(int k=0; k<2; ++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<=2) { puts("1"); return 0; }
    ans.e[0][0]=ans.e[0][1]=1;
    ans.e[1][0]=ans.e[1][1]=0;
    base.e[0][0]=a%7,base.e[0][1]=1,
    base.e[1][0]=b%7,base.e[1][1]=0;
    for(n-=2; n; n>>=1,base=base*base)
        if(n&1) ans=ans*base;
    printf("%lld
",ans.e[0][0]);
    return 0;
}

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

• T2 和生物老师的战争

• 

#include <cstdio>

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

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+1;
            double fm=n+1;
            printf("%.6lf
",fz/fm);
        }
    }
    return 0;
}

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

• 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=0; register char ch=getchar();
    for(; ch>'9'||ch<'0'; ) ch=getchar();
    for(; ch>='0'&&ch<='9'; ch=getchar()) x=x*10+ch-'0';
}
const int N(20000+15);
const int M(200000+5);
int n,m;
int head[2][N],sumedge[2];
struct Edge {
    int v,next,w;
    Edge(int v=0,int next=0,int w=0):v(v),next(next),w(w){}
}edge[2][M<<1];
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]=1;
    for(int v,i=head[0][u]; i; i=edge[0][i].next)
    {
        /*if(vis[i]||vis[i^1]) continue;
        vis[i]=vis[i^1]=true;*/ 
        v=edge[0][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=1; i<=sumcol; ++i)
        dis[i]=-1,vis[i]=false;
    
    dis[s]=u.dis=0,u.pos=s; que.push(u); 
    for(; !que.empty(); )
    {
        u=que.top(); que.pop();
        if(vis[u.pos]) continue; vis[u.pos]=1;
        for(int i=head[1][u.pos]; i; i=edge[1][i].next)
        {
            v.pos=edge[1][i].v; if(!vis[v.pos])
            if(dis[v.pos]<dis[u.pos]+edge[1][i].w)
            {
                v.dis=u.dis+(LL)edge[1][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=1; i<=m; ++i)
        read(u),read(v),read(w),ins(u,v,w,0);
    for(int i=1; i<=n; ++i)
        if(!dfn[i]) DFS(i,-1);

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

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

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

可以先求出强连通分量，两次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=0; register char ch=getchar();
    for(; ch>'9'||ch<'0'; ) ch=getchar();
    for(; ch>='0'&&ch<='9'; ch=getchar()) x=x*10+ch-'0';
}

const int N(20000+15);
const int M(200000+5);

int n,m;
int head[2][N],sumedge[2];
struct Edge {
    int v,next,w;
    Edge(int v=0,int next=0,int w=0):v(v),next(next),w(w){}
}edge[2][M<<1];
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]=1;
        for(int v,i=head[0][u]; i; i=edge[0][i].next)
        {
            v=edge[0][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=1; i<=n; ++i)
            if(!dfn[i]) DFS(i,-1);
    }
}

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

int Presist()
{
    freopen("prize.in","r",stdin);
    freopen("prize.out","w",stdout);
    
    read(n),read(m);
    for(int u,v,w,i=1; i<=m; ++i)
        read(u),read(v),read(w),ins(u,v,w,0);
    Tarjan::work();
    Solve ::work();
    return 0;
}

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