10.3模拟赛

 

#include<bits/stdc++.h>
#define ll long long
using namespace std;
inline ll re_ad() {
    char ch=getchar(); ll x=0,f=1;
    while(ch<'0' || ch>'9') { if(ch=='-') f=-1; ch=getchar(); }
    while('0'<=ch && ch<='9') x=(x<<1)+(x<<3)+ch-'0',ch=getchar();
    return x*f;
}

ll a,b,c,k,K;
ll Exgcd(ll a,ll b,ll &x,ll &y) {
    if(!b) return x=1,y=0,a;
    ll res=Exgcd(b,a%b,x,y);
    ll tmp=x; x=y,y=tmp-(a/b)*y;
    return res;
}

int main()
{
    freopen("loop.in","r",stdin);
    freopen("loop.out","w",stdout);
    while(1) {
        a=re_ad(),b=re_ad(),c=re_ad(),k=re_ad();
        K=1; for(ll i=1;i<=k;++i) K*=2;
        if(!a&&!b&&!c&&!k) break;
        ll x,y,tag=(b-a)%K;
        ll d=Exgcd(c,K,x,y);
        if(tag%d) { printf("FOREVER\n"); continue; }
        tag/=d,K/=d;
        printf("%lld\n",(tag*x%K+K)%K);
    }
    return 0;
}

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const ll N=11;
ll n,p;

inline ll TuMulti(ll x,ll y) { ll res=0; for(;y;y>>=1,(x+=x)%=p) if(y&1) (res+=x)%=p; return res%p; }
struct Node {
    ll a[N][N];
    Node Init(ll op) {
        if(!op) memset(a,0,sizeof(a));
        else a[1][1]=a[1][3]=a[1][4]=a[2][2]=a[2][3]=a[2][4]=1,a[3][3]=a[4][4]=2;
    }
    Node operator * (Node B) {
        Node res; res.Init(0);
        for(ll i=1;i<=4;++i) for(ll j=1;j<=4;++j) for(ll k=1;k<=4;++k)
            (res.a[i][j]+=TuMulti(a[i][k],B.a[k][j]))%=p; //,printf("%lld %lld %lld: %lld %lld\n",i,k,j,a[i][k],a[k][j]);
        return res;
    }
}g,lj;
inline ll QuickPow(ll x) { for(;x;x>>=1,g=g*g) if(x&1) lj=lj*g; }

int main()
{
    freopen("beauty.in","r",stdin);
    freopen("beauty.out","w",stdout);
    while(scanf("%lld%lld",&n,&p)!=EOF) {
        if(n==1) { printf("1\n"); continue; }
        if(n==2) { printf("2\n"); continue; }
        g.Init(1),lj.Init(1);
        QuickPow(n-3);
        ll ans=0;
        for(ll i=1;i<=4;++i) (ans+=(lj.a[1][i]+lj.a[2][i])%p)%=p;
        printf("%lld\n",ans);
//        for(ll i=1;i<=4;++i) { for(ll j=1;j<=4;++j) printf("%lld ",lj.a[i][j]); puts(""); }
    }
    return 0;
}

 

#pragma GCC optimize(2)

#define FASTER
#ifdef FASTER
#pragma GCC diagnostic error "-std=c++11"
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#endif

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int inf=9999999999999;
int A,B,dep,lj[10],ans[10];
bool flag;

int gcd(int x,int y) { return !y?x:gcd(y,x%y); }
void dfs(int a,int b,int k) {
    if(k==dep+1) return;
    if(b%a==0 && b>a*lj[k-1]) {
        lj[k]=b/a;
        if(!flag || lj[k]<ans[k]) memcpy(ans,lj,sizeof(lj));
        flag=true; return ;
    }
    int s=b/a; if(s<=lj[k-1]) s=lj[k-1]+1;
    int t=(dep-k+1)*b/a; if(t>inf/b) t=inf/b;
    for(int i=s,G;i<=t;++i) {
        lj[k]=i,G=gcd(a*i-b,b*i);
        dfs((a*i-b)/G,(b*i)/G,k+1); 
    }
}

signed main()
{
    freopen("history.in","r",stdin);
    freopen("history.out","w",stdout);
    scanf("%d%d",&A,&B); lj[0]=1;
    for(dep=2;dep<=10;++dep) {
        dfs(A,B,1);
        if(!flag) continue;
        for(int j=1;j<=dep;++j) printf("%d ",ans[j]); puts("");
        break;
    }
    return 0;
}

 

#include<bits/stdc++.h>
#define ll long long
using namespace std;
inline ll re_ad() {
    char ch=getchar(); ll x=0,f=1;
    while(ch<'0' || ch>'9') { if(ch=='-') f=-1; ch=getchar(); }
    while('0'<=ch && ch<='9') x=(x<<1)+(x<<3)+ch-'0',ch=getchar();
    return x*f;
}

const ll N=1e3+11,mod=1e9;
ll n,m,a[N],b[N],pri[N];
ll gcd(ll x,ll y) { return !y?x:gcd(y,x%y); }

int main()
{
    freopen("home.in","r",stdin);
    freopen("home.out","w",stdout);
    n=re_ad();
    for(ll i=1;i<=n;++i) a[i]=re_ad();
    m=re_ad();
    for(ll i=1;i<=m;++i) b[i]=re_ad();
    ll ans=1;
    bool flag=false;
    for(ll i=1;i<=n;++i) for(ll j=1;j<=m;++j) {
        ll g=gcd(a[i],b[j]);
        ans=ans*g,a[i]/=g,b[j]/=g;
        if(ans>mod) flag=true,ans%=mod;
    }
    if(!flag) printf("%lld\n",ans);
    else {
        for(ll i=1;i<=9;++i) pri[i]=ans%10,ans/=10;
        for(ll i=9;i>=1;--i) printf("%lld",pri[i]); puts("");
    }
    return 0;
}

 

#include<bits/stdc++.h>
using namespace std;
inline int re_ad() {
    char ch=getchar(); int x=0,f=1;
    while(ch<'0' || ch>'9') { if(ch=='-') f=-1; ch=getchar(); }
    while('0'<=ch && ch<='9') x=(x<<1)+(x<<3)+ch-'0',ch=getchar();
    return x*f;
}

const int N=2e5+11,M=4e5+11,L=21;
int n,m;
int to[M],nxt[M],edge,head[N];
int dep[N],gr[N][L];

inline void addedge(int x,int y) {
    ++edge,to[edge]=y,nxt[edge]=head[x],head[x]=edge;
    ++edge,to[edge]=x,nxt[edge]=head[y],head[y]=edge;
}

void dfs(int d,int f) {
    gr[d][0]=f,dep[d]=dep[f]+1;
    for(int i=1;i<=20;++i) gr[d][i]=gr[gr[d][i-1]][i-1];
    for(int i=head[d];i;i=nxt[i]) if(to[i]!=f) dfs(to[i],d);
}

inline int LCA(int x,int y) {
    if(dep[x]<dep[y]) x^=y^=x^=y;
    for(int i=20;i>=0;--i) if(dep[gr[x][i]]>=dep[y]) x=gr[x][i];
    if(x==y) return x;
    for(int i=20;i>=0;--i) if(gr[x][i]!=gr[y][i]) x=gr[x][i],y=gr[y][i];
    return gr[x][0];
}

inline int Dist(int x,int y) { int lca=LCA(x,y); return dep[x]+dep[y]-dep[lca]*2; }

int main()
{
    freopen("reaction.in","r",stdin);
    freopen("reaction.out","w",stdout);
    n=re_ad(),m=re_ad();
    for(int i=1,x,y;i<n;++i) x=re_ad(),y=re_ad(),addedge(x,y);
    dfs(1,0);
    for(int i=1,x,y;i<=m;++i) x=re_ad(),y=re_ad(),printf("%d\n",Dist(x,y));
    return 0;
}

#include<bits/stdc++.h>
#define ll long long
using namespace std;
ll n,m,p,N,M;
inline ll QuickPow(ll x,ll y) { ll res=1; for(;y;y>>=1,(x*=x)%=p) if(y&1) (res*=x)%=p; return res; }
int main()
{
    freopen("lucknum.in","r",stdin);
    freopen("lucknum.out","w",stdout);
    scanf("%lld%lld%lld",&n,&m,&p);
    N=n+m-1,M=n;
    ll ans=1,fac=1;
    for(ll i=N;i>=N-M+1;--i) (ans*=i)%=p;
    for(ll i=M;i>=1;--i) (fac*=i)%=p;
//    printf("%lld %lld\n",ans,fac);
    fac=QuickPow(fac,p-2);
    printf("%lld\n",ans*fac%p);
    return 0;
}

 

#include<bits/stdc++.h>
using namespace std;
inline int re_ad() {
    char ch=getchar(); int x=0,f=1;
    while(ch<'0' || ch>'9') { if(ch=='-') f=-1; ch=getchar(); }
    while('0'<=ch && ch<='9') x=(x<<1)+(x<<3)+ch-'0',ch=getchar();
    return x*f;
}

const int N=1e5+11,M=2e5+11;
int n,m;
int fr[M],to[M],nxt[M],edge,head[N];
int dfn[N],low[N],tot,top,sta[N];
int cnt,tag[N],mem[N];
bool vis[M];

inline void addedge(int x,int y) {
    ++edge,fr[edge]=x,to[edge]=y,nxt[edge]=head[x],head[x]=edge;
}

void tarjan(int d,int ff) {
    dfn[d]=low[d]=++tot,sta[++top]=d,vis[d]=true;
    for(int i=head[d],u;i;i=nxt[i]) {
        u=to[i];
        if(!dfn[u]) tarjan(u,d),low[d]=min(low[d],low[u]);
        else if(vis[u]) low[d]=min(low[d],dfn[u]);
    }
    if(dfn[d]==low[d]) {
        ++cnt;
        while(sta[top]!=d) tag[sta[top]]=cnt,vis[sta[top]]=false,--top;
        tag[d]=cnt,vis[d]=false,--top;
    }
}

int main()
{
    freopen("prom.in","r",stdin);
    freopen("prom.out","w",stdout);
    n=re_ad(),m=re_ad(); edge=1;
    for(int i=1,x,y;i<=m;++i) x=re_ad(),y=re_ad(),addedge(x,y);
    for(int i=1;i<=n;++i) if(!dfn[i]) tarjan(i,0);
    for(int i=1;i<=n;++i) ++mem[tag[i]];
    int ans=0;
    for(int i=1;i<=n;++i) if(mem[i]>1) ++ans;
    printf("%d\n",ans);
    return 0;
}