模板

 

#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
#include<math.h>
#include<cstdio>
using namespace std;
int gcd(int a,int b,int &x,int &y)
{
    a[i]=-【p/i】*a[p%i]; 
}
//a*x ≡c(mod b)
//a*x+b*y ≡c;
线性求逆元

 

#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
#include<math.h>
#include<cstdio>
using namespace std;
int gcd(int a,int b,int &x,int &y)
{
    if(b==0)
    {
        x=1;
        y=0;
        return a;
    }
    int d=gct(b,a%b,x,y);
    int temp=x;x=y,y=temp-a/b*y;
    return d;
}
//a*x ≡c(mod b)
//a
扩展欧几里得

 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
#define M 100000
char al[M],bl[M];
int a[M],b[M],c[M];
int la,lb,ml;
int bas=10000;
int f=1;
void compa()
{
    if(la>lb)
    {
        f=1;
        return;
    }
    if(la<lb)
    {
        f=-1;
        return ;
    }
    for(int i=la;i>=1;i--)
    {
        if(a[i]>b[i])
        {
            f=1;
            return ;
        }else
        if(a[i]<b[i])
        {
            f=-1;
            return ;
        }        
    }
}
void first()
{
    int i,j,k=1;
    for(i=la,j=1;i>=1;i--)
    {
        if(k==10000)    k=1,j++;
        a[j]+=k*(al[i]-'0');
        k*=10;
    }
    la=j;
    k=1;
    for(i=lb,j=1;i>=1;i--)
    {
        if(k==10000)    k=1,j++;
        b[j]+=k*(bl[i]-'0');
        k*=10;
    }
    lb=j;
}
int main()
{
    cin>>(al+1)>>(bl+1);
    la=strlen(al+1);lb=strlen(bl+1);
    first();
    compa();
    ml=max(la,lb);
    if(f==1)
    for(int i=1;i<=ml;i++)
    {
        c[i]+=a[i]-b[i];
        if(c[i]<0)    c[i]+=bas,c[i+1]--;    
    }
    if(f==-1)
    for(int i=1;i<=ml;i++)
    {
        c[i]+=b[i]-a[i];
        if(c[i]<0)    c[i]+=bas,c[i+1]--;    
    }
    while((!c[ml])&&ml>0)    ml--;
    if(f==-1)    printf("-");
    printf("%d",c[ml]);ml--;
    for(int i=ml;i>=1;i--)
        printf("%04d",c[i]);
    if(!ml)    printf("0");
    return 0;
}
高精比较,高精减
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
#define M 100000
char al[M],bl[M];
int a[M],b[M],c[M];
int la,lb,ml;
int bas=10000;
void first()
{
    int i,j,k=1;
    for(i=la,j=1;i>=1;i--)
    {
        if(k==10000)    k=1,j++;
        a[j]+=k*(al[i]-'0');
        k*=10;
    }
    la=j;
    k=1;
    for(i=lb,j=1;i>=1;i--)
    {
        if(k==10000)    k=1,j++;
        b[j]+=k*(bl[i]-'0');
        k*=10;
    }
    lb=j;
}
int main()
{
    cin>>(al+1)>>(bl+1);
    la=strlen(al+1);lb=strlen(bl+1);
    first();
    
    ml=max(la,lb);
    for(int i=1;i<=ml;i++)
    {
        c[i]+=a[i]+b[i];
        c[i+1]+=c[i]/bas;
        c[i]%=bas;
    }
    if(c[ml+1])    ml++;
    printf("%d",c[ml]);ml--;
    for(int i=ml;i>=1;i--)
        printf("%04d",c[i]);
    return 0;
}
高精加法

 

#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
#include<math.h>
#include<cstdio>
using namespace std;
#define LL  unsigned long long 
#define MOD 1000000007
LL n,k;
struct node{
    LL v[109][109];
}p,x,ans,b;
node ch(node x,node y)
{
    
    for(int i=1;i<=n;i++)
       for(int j=1;j<=n;j++)
    {    
        p.v[i][j]=0;
        for(int k=1;k<=n;k++)
         p.v[i][j]=(p.v[i][j]+1LL*x.v[i][k]*y.v[k][j] )%MOD;
    }    
    return p;
}
void fastlow( )
{
    while(k)
    {
        if(k%2)    ans=ch(ans,x);
        k/=2; x=ch(x,x);
    }
} 
int main()
{
    scanf("%lld%lld",&n,&k);
    for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
        scanf("%lld",&x.v[i][j]);
    ans=x;k--;
    fastlow();
    for(int i=1;i<=n;i++ ,cout<<endl)
    for(int j=1;j<=n;j++ )
    printf("%lld ",ans.v[i][j]);
    return 0;
}
矩阵快速幂

 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<math.h>
#include<algorithm>
#include<vector>
using namespace std;
int t,f[31000],front[310000],behind[310000];
int find(int x)
{
    if(f[x]==x) return x;
    int fx=find(f[x]);
    front[x]+=front[f[x]];
    return f[x]=fx; 
} 
void bing(int x,int y)
{
    int fx=find(x);
    int fy=find(y);
    f[fx]=fy;
    front[fx]=behind[fy];
    behind[fy]+=behind[fx];
}
int ask(int x,int y)
{
    int fx=find(x);
    int fy=find(y);
    if(fx==fy)
    {
        int ans=abs(front[x]-front[y])-1;
        printf("%d\n",ans);
    }else
        printf("-1\n");
}
int main()
{
    for(int i=1;i<=30000;i++)    f[i]=i,behind[i]=1;        
    scanf("%d\n",&t);
    int a,b;char c;
    for(int i=1;i<=t;i++)
    {
        cin>>c; 
        scanf("%d%d",&a,&b);
        if(c=='M')    bing(a,b);
        else    ask(a,b);
    }
    return 0;
}
带权并查集

 

 

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
#include<algorithm>
#include<cmath>
using namespace std;
const int N=1e5+45;
typedef long long LL;
int n,m,p;
int prime[N/10],cnt;
int sum[N];
bool is[N];
void first()
{
    is[1]=is[0]=1;
    for(int i=2;i<=N;i++)
    {
        if(!is[i])    prime[++cnt]=i;
        for(int j=1;j<=cnt;j++)
        {
            if(i*prime[j]>N)    break;
            is[i*prime[j]]=1;
            if(i%prime[j]==0)    break;
        }
    }
}
void fen(int x,int y)
{
    for(int i=1;i<=cnt;i++)
    {
        int now=prime[i];
        while(now<=x)
        {
            sum[i]+=y*x/now;
            now=now*prime[i];
        }
    }
}
LL fastlow(LL a,LL b)
{
    LL tot=1;
    while(b)
    {
        if(b&1)    tot=(tot*a)%p;
        b/=2;a=(a*a)%p;
    }
    return tot;
}
int main()
{
    int T;first();
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d",&n,&m,&p);
        memset(sum,0,sizeof sum);
        fen(n+m,1);
        fen(n,-1);fen(m,-1);
        LL ans=1;
        for(int i=1;i<=cnt;i++)
        if(sum[i])    
        ans=(ans*fastlow(1LL*prime[i],1LL*sum[i])%p);
        printf("%lld\n",ans);
    }
    return 0;
}
分解质因数
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
#include<algorithm>
#include<cmath>
using namespace std;
const int N=3*1e6+45;
long long  n,p;
long long a[N];
int main()
{
    a[1]=1;
    scanf("%lld%lld",&n,&p);
    printf("1\n");
    for(int i=2;i<=n;i++)
    {
        a[i]=-(p/i)*a[p%i];
        while(a[i]<0)    a[i]+=p;
        printf("%lld\n",a[i]);
    }
    return 0;
}
线性求乘法逆元

 

 

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
#include<algorithm>
#include<cmath>
using namespace std;
const int N=1e6+45;
char a[N],b[N];
int la,lb;
int nex[N];
void get()
{
    int i=2,j=0;
    for(i;i<=lb;i++)
    {
        while(j&&b[j+1]!=b[i])    j=nex[j];
        if(b[i]==b[j+1])    j++;
        nex[i]=j;
    }
}
void work()
{
    for(int i=1,j=0;i<=la;i++)
    {
        while(j&&a[i]!=b[j+1])    j=nex[j];
        if(a[i]==b[j+1])    j++;
        if(j==lb)    printf("%d\n",i-lb+1);
    }
}
int main()
{
    cin>>(a+1)>>(b+1);
    la=strlen(a+1);lb=strlen(b+1);
    get();work();
    for(int i=1;i<=lb;i++)
    printf("%d ",nex[i]);
    return 0;
}
KMP
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
#include<algorithm>
#include<cmath>
using namespace std;
char s[1509];
const int P=1e9+7;
const int bas=70;
int n,len;
int q[10009];
int get_hash()
{
    int ans=0;
    for(int i=1;i<=len;i++)    
        ans=(ans*bas+s[i]-'0'+1)%P;
    return ans;
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        cin>>(s+1);len=strlen(s+1);
        q[i]=get_hash();
    }
    sort(q+1,q+1+n);
    len=n;
    for(int i=1;i<=n;i++)
    if(q[i]==q[i-1])
        len--;
    printf("%d",len);
    return 0;
} 
hash

 

#include<iostream>
#include<queue>
#include<cstdio>
#include<math.h>
#include<cstring>
#include<algorithm>
using namespace std;
int n,Q;
typedef long long LL;
const int N=200009;
LL sum[N*2];
int a[N],dx[N*2];
void build(int l,int r,int id)
{
    if(l==r)
    {
        sum[id]=a[l];
        return ;
    }
    if(r<l)    return;
    int mid=(l+r)/2;
    build(l,mid,id*2);build(mid+1,r,id*2+1);
    sum[id]=sum[id*2]+sum[id*2+1];
    return ;
}
void set(int l,int r,int id)
{
    dx[id*2]+=dx[id];dx[id*2+1]+=dx[id];
    int mid=(l+r)/2;
    sum[id*2]+=(mid-l+1)*dx[id];
    sum[id*2+1]+=(r-mid)*dx[id];
    dx[id]=0;
}
LL ask(int l,int r,int id,int tl,int tr)
{
    if(tl<=l&&r<=tr)
        return sum[id];
    if(l>tr||r<tl)    return 0;
    if(dx[id])    set(l,r,id);
    int mid=(l+r)/2;
    LL ans=0;
    ans=ask(l,mid,id*2,tl,tr);
    ans+=ask(mid+1,r,id*2+1,tl,tr);
    return ans;
}
void add(int l,int r,int id,int tl,int tr,int x)
{
    if(tl<=l&&r<=tr)
    {
        sum[id]+=(r-l+1)*x;
        dx[id]+=x;
        return ;
    }
    if(l>tr||r<tl)    return ;
    int p1=max(tl,l),p2=min(tr,r);
    if(p1<=p2)
        sum[id]+=(p2-p1+1)*x;
    int mid=(l+r)/2;
    add(l,mid,id*2,tl,tr,x);
    add(mid+1,r,id*2+1,tl,tr,x);
}
int main()
{
    scanf("%d%d",&n,&Q);
    for(int i=1;i<=n;i++)    scanf("%d",&a[i]);
    build(1,n,1);
    for(int i=1,A,x,y,z;i<=Q;i++)
    {
        scanf("%d",&A);
        if(A==1)
        {
            scanf("%d%d%d",&x,&y,&z);
            add(1,n,1,x,y,z);
        }else
        {
            scanf("%d%d",&x,&y);
            printf("%lld\n",ask(1,n,1,x,y));
        }
    }
}
线段树-区间求和
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
const int N=1e6+415;
int n;
priority_queue<int>q;
int main()
{
    scanf("%d",&n);
    while(n--)
    {
        int id,x;
        scanf("%d",&id);
        if(id==1)
        {
            scanf("%d",&x);
            q.push(-x);
        }else
        if(id==2)
        {
            x=-q.top();
            printf("%d\n",x);
        }else
        {
            q.pop();
        }
    }
    return 0;
}
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
const int N=500009;
int c[N];
int n,m;
void add(int x,int k)
{
    for(int i=x;i<=n;i+=(i&(-i)))
        c[i]+=k;
}
int get(int x)
{
    int ans=0;
    for(int i=x;i>=1;i-=(i&(-i)))
        ans+=c[i];
    return ans;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        int x;
        scanf("%d",&x);
        add(i,x);
    }
    for(int i=1,x,y,opt;i<=m;i++)
    {
        scanf("%d%d%d",&opt,&x,&y);
        if(opt==1)
        {
            add(x,y);
        }else
        {
            opt=get(y)-get(x-1);
            printf("%d\n",opt);
        }
    }
    return 0;
}
树状数组维护前缀和
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
const int N=500009;
int h[N/2],nex[N],to[N],w[N],cnt;
int n,m,s;
int dis[N];
void add()
{
    int x,y,z;
    scanf("%d%d%d",&x,&y,&z);
    to[++cnt]=y,nex[cnt]=h[x],h[x]=cnt;w[cnt]=z;
}
queue<int>q;
bool vis[N];
void spfa()
{
    for(int i=1;i<=n;i++)    dis[i]=2147483647;
    dis[s]=0;vis[s]=1;
    int now,t;q.push(s);
    while(!q.empty())
    {
        now=q.front();q.pop();vis[now]=0;
        for(int i=h[now];i;i=nex[i])
        {
            t=to[i];
            if(dis[now]+w[i]<dis[t])
            {
                dis[t]=dis[now]+w[i];
                if(!vis[t])
                    q.push(t);
                vis[t]=1;
            }
        }
    }    
}
int main()
{
    scanf("%d%d%d",&n,&m,&s);
    for(int i=1;i<=m;i++)
        add();
    spfa();
    for(int i=1;i<=n;i++)
    printf("%d ",dis[i]);
    return 0;
}
单源最短路-spfa
 
 
 
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
const int N=200009;
int f[N];
struct node{
    int x,y;
    int z;
}a[N];
int n,m;
long long ans;
bool cmp(node u,node v)
{
    return u.z<v.z;
}
int find(int x)
{
    while(x!=f[x])
        x=f[x]=f[f[x]];
    return x;
}
void krus()
{
    int f1,f2;
    for(int l=1;l<=m;l++)
    {
        f1=find(a[l].x);f2=find(a[l].y);
        if(f1!=f2)
        {
            f[f1]=f2;
            ans+=a[l].z;
        }
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)    
        scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].z);
    for(int i=1;i<=n;i++)    f[i]=i;    
    sort(a+1,a+1+m,cmp);
    krus();
    for(int i=1;i<n;i++)
    if(find(i)!=find(i+1))    
    {
        printf("orz\n");
        return 0;
    }
    printf("%lld\n",ans);
    return 0;
}
    printf("%lld\n",ans);
    return 0;
}    
        scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].z);
    for(int i=1;i<=n;i++)    f[i]=i;    
    sort(a+1,a+1+m,cmp);
    krus();
    for(int i=1;i<n;i++)
    if(find(i)!=find(i+1))    
    {
        printf("orz\n");
        return 0;
    }
    printf("%lld\n",ans);
    return 0;
}
最小生成树

 

 
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
const int N=200009;
int f[N];
struct node{
    int x,y;
    int z;
}a[N];
int n,m;
long long ans;
bool cmp(node u,node v)
{
    return u.z<v.z;
}
int find(int x)
{
    while(x!=f[x])
        x=f[x]=f[f[x]];
    return x;
}
void krus()
{
    int f1,f2;
    for(int l=1;l<=m;l++)
    {
        f1=find(a[l].x);f2=find(a[l].y);
        if(f1!=f2)
        {
            f[f1]=f2;
            ans+=a[l].z;
        }
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
const int N=200009;
int f[N];
struct node{
    int x,y;
    int z;
}a[N];
int n,m;
long long ans;
bool cmp(node u,node v)
{
    return u.z<v.z;
}
int find(int x)
{
    while(x!=f[x])
        x=f[x]=f[f[x]];
    return x;
}
void krus()
{
    int f1,f2;
    for(int l=1;l<=m;l++)
    {
        f1=find(a[l].x);f2=find(a[l].y);
        if(f1!=f2)
        {
            f[f1]=f2;
            ans+=a[l].z;
        }
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)    
        scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].z);
    for(int i=1;i<=n;i++)    f[i]=i;    
    sort(a+1,a+1+m,cmp);
    krus();
    for(int i=1;i<n;i++)
    if(find(i)!=find(i+1))    
    {
        printf("orz\n");
        return 0;
    }#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
const int N=200009;
int f[N];
struct node{
    int x,y;
    int z;
}a[N];
int n,m;
long long ans;
bool cmp(node u,node v)
{
    return u.z<v.z;
}
int find(int x)
{
    while(x!=f[x])
        x=f[x]=f[f[x]];
    return x;
}
void krus()
{
    int f1,f2;
    for(int l=1;l<=m;l++)
    {
        f1=find(a[l].x);f2=find(a[l].y);
        if(f1!=f2)
        {
            f[f1]=f2;
            ans+=a[l].z;
        }
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)    
        scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].z);
    for(int i=1;i<=n;i++)    f[i]=i;    
    sort(a+1,a+1+m,cmp);
    krus();
    for(int i=1;i<n;i++)
    if(find(i)!=find(i+1))    
    {
        printf("orz\n");
        return 0;
    }
    printf("%lld\n",ans);
    return 0;
}
    printf("%lld\n",ans);
    return 0;
}    
        scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].z);
    for(int i=1;i<=n;i++)    f[i]=i;    
    sort(a+1,a+1+m,cmp);
    krus();
    for(int i=1;i<n;i++)
    if(find(i)!=find(i+1))    
    {
        printf("orz\n");
        return 0;
    }
    printf("%lld\n",ans);
    return 0 
#include<iostream>
#include<cstdio>
#include<queue>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;//倍增
const int N=1e5+1561;
int mi[N][23];
int n,m;
int a,b,x,ans;
int main ()
{
    scanf("%d%d",&m,&n);
    for(int i=1;i<=m;i++)
        scanf("%d",&mi[i][0]);
    for(int i=1;i<=20;i++)
    for(int j=1;j+(1<<i)-1<=m;j++)
    mi[j][i]=min(mi[j][i-1],mi[j+(1<<i-1)][i-1]);
    
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d",&a,&b);
        x=log2(b-a+1);
        ans=min(mi[a][x],mi[b-(1<<x)+1][x]);
        printf("%d ",ans);
    }
    return 0;
} 
倍增,求区间最值 
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<math.h>
#include<queue>
#include<vector>
using namespace    std;
#define M 500001
int n,m,s,head[M],nex[M+M],num[M+M],deep[M],p[M][99];
void build1(int x,int d)
{
    for(int i=head[x];i;i=nex[i])
    {
        int t=num[i];
        if(!p[t][0])
        {
            p[t][0]=x;
            deep[t]=d;
            build1(t,d+1);
        }
    }
    return ;
}
void build2()
{
    for(int j=1;(1<<j)<=n;j++)
        for(int i=1;i<=n;i++)
            if(!p[i][j])
                p[i][j]=p[p[i][j-1]][j-1];
    return;
}
inline int read(){
    int x=0,f=1;char c=getchar();
    while(c>'9'||c<'0') {if(c=='-') f=-1;c=getchar();}
    while(c>='0'&&c<='9') {x=x*10+c-'0'; c=getchar();}
    return x*f;
}
int LCA(int a,int b)
{
    if(deep[a]<deep[b])
    {
        int c=b;
        b=a;
        a=c;
    }    
    int i;
    for( i=0;(1<<i)<=deep[a];i++)    ;
    i--;
    for    (int j=i;j>=0;j--)
        if(deep[a]-(1<<j)>=deep[b])    a=p[a][j];
    if(a==b)    return a;
    for(int j=i;j>=0;j--)
    {
        if(p[a][0]==p[b][0])    return p[a][0];
        if(p[a][j]!=-1&&p[a][j]!=p[b][j])
        {
            a=p[a][j];
            b=p[b][j];
        }
    }
    return p[a][0];
}

int main()
{
    int cnt=0;
    //scanf("%d%d%d",&n,&m,&s);
    n=read();m=read();s=read();
    for(int i=1,x,y;i<n;i++)
    {
        //scanf("%d%d",&x,&y);
        x=read();y=read();
        num[++cnt]=x;nex[cnt]=head[y];head[y]=cnt;
        num[++cnt]=y;nex[cnt]=head[x];head[x]=cnt;
    }
    p[s][0]=-1;
    build1(s,1);
    build2();
    for(int i=1,a,b;i<=m;i++)
    {
        //scanf("%d%d",&a,&b);
        a=read();b=read();
        printf("%d\n",LCA(a,b));
    }
    return 0;
}
LCA-st
#include<iostream>
#include<cstdio>
#include<queue>
#include<cstdlib>
#include<cmath>
using namespace std;
const int N=500009; 
int h[N],nex[N*2],to[N*2],cnt;
int f[N];
int H_[N],Nex_[N*2],To_[N*2],Cnt_,Id[N*2];
int n,m,s;
bool vis[N];
int ans[N*2];
void add()
{
    int x,y;
    scanf("%d%d",&x,&y);
    to[++cnt]=y,nex[cnt]=h[x],h[x]=cnt;
    to[++cnt]=x,nex[cnt]=h[y],h[y]=cnt;
}
void Add(int i)
{
    int x,y;
    scanf("%d%d",&x,&y);
    To_[++Cnt_]=y,Nex_[Cnt_]=H_[x],H_[x]=Cnt_;Id[Cnt_]=i;
    To_[++Cnt_]=x,Nex_[Cnt_]=H_[y],H_[y]=Cnt_;Id[Cnt_]=i;
}
int find(int x)
{
    while(x!=f[x])
        x=f[x]=f[f[x]];
    return x;
}
void merge(int x,int y)
{
    x=find(x);
    y=find(y);
    if(x!=y)
        f[x]=y;
}
void tarjan(int x,int fa)
{    
    int v;
    for(int i=h[x];i;i=nex[i])    
    {
        v=to[i];
        if(v==fa)    continue;
        if(!vis[v])
            tarjan(v,x);
        merge(v,x);
        vis[v]=1;
    }
    for(int i=H_[x];i;i=Nex_[i])
    {
        v=To_[i];
        if(vis[v])
            ans[Id[i]]=find(v);
    }
}
int main()
{
    scanf("%d%d%d",&n,&m,&s);
    for(int i=1;i<=n;i++)
        f[i]=i;
    for(int i=1;i<n;i++)
        add();
    for(int i=1;i<=m;i++)
        Add( i);
    tarjan(s,s);
    for(int i=1;i<=m;i++)
    printf("%d\n",ans[i]);
    return 0;
}
LCA-tarjan

 

posted @ 2017-11-04 18:51  浪矢-CL  阅读(155)  评论(0编辑  收藏  举报