• 2020-2021 “Orz Panda” Cup Programming Contest


    2020-2021 “Orz Panda” Cup Programming Contest

    比赛情况

    我们一共过了道3题

    本场贡献:et3_tsy :过了A,提供了H的关键修改

    1427314831a:尝试写E,可惜没过

    Ryker0923 :过了H,I

    罚时:H,I各罚了一次

    比赛总结


    et3_tsy

    这场比赛是比较考验基本功的,像CG,需要的知识储备很低,但是场上没有写,说明还是有点问题的。


    1427314831a

    多注意一些容易导致死循环的细节。


    Ryker0923

    注意计算几何精度问题。


    部分题解

    A.带权并查集+优先队列

    其他做法(像单调栈)可能更好

    I.计算几何

    因为除2后只会出现0.5和0.0两种情况,double会出现精度损失,所以注意使用long long来存。

    H.思维题

    C.set的使用

    这道题就是说给定一个空序列,往里面放、拿东西。有两种维护,第1种维护,就是说往里面插入一个数,使得他往已经有的东西最远,一样远那么取序号小的,第2种维护,就是取出第K次是操作放入的东西。

    这道题核心就是开两个set。第1个set去储存,我们当前哪些区段放是最优的。第2个set去储存,我们当前哪一些地方已经放置了东西。

    其实这道题处理起来不难,就是考察set使用的基本功,然而我疯狂在T,原因如下:

    auto tmp=pos.lower_bound(x);
    auto tmp=lower_bound(pos.begin(),pos.end(),x);
    

    第一行比第二行快很多,因为它是容器自带的方法,下次使用要注意

    #include<bits/stdc++.h>
    using namespace std;
    #define maxn 200050
    #define int long long
    int n,m,trans,x,mid,lf,y;
    struct seg
    {
        int l,r,dis;
        bool operator<(const seg& sec)const
        {
            if(dis==sec.dis)return l<sec.l;
            return dis>sec.dis;
        }
        seg(int a,int b,int c){l=a;r=b;dis=c;}
        seg(){}
    };
    int op[maxn];
    set<seg>s;
    set<int>pos;
    set<seg>::iterator it;
    set<int>::iterator it2;
    seg t,t2;
    inline void add(int l,int r)
    {
        if(l>r)return;
        if(l==1||r==n)s.insert(seg{l,r,r-l});
        else s.insert(seg{l,r,(r-l)>>1});
    }
    void solve()
    {
        s.clear();
        pos.clear();
        pos.insert(0);
        pos.insert(n+1);
        add(1,n);
        for(int i=1;i<=m;i++)
        {
            scanf("%d",&trans);
            if(trans==1)
            {
                t=*s.begin();
                if(!s.empty())s.erase(s.begin());
                if(t.l==1||t.r==n)
                {
                    if(t.l==1)
                    {
                        printf("1
    ");
                        op[i]=1;
                        pos.insert(1);
                        add(2,t.r);
                    }
                    else
                    {
                        printf("%d
    ",n);
                        op[i]=n;
                        pos.insert(n);
                        add(t.l,n-1);
                    }
                }
                else
                {
                    mid=(0ll+t.l+t.r)>>1;
                    printf("%d
    ",mid);
                    op[i]=mid;
                    pos.insert(mid);
                    add(t.l,mid-1);
                    add(mid+1,t.r);
                }
            }
            else
            {
                scanf("%d",&x);
                x=op[x];
                int l=x,r=x;
                auto tmp=pos.lower_bound(x);
                int pre=*--tmp;++tmp;
                int nxt=*++tmp;
                if(pre+2<=x)
                {
                    l=pre+1;
                    if(pre!=0)s.erase(seg{pre+1,x-1,(x-pre-2)>>1});
                    else s.erase(seg{pre+1,x-1,x-2});
                }
                if(x+2<=nxt)
                {
                    r=nxt-1;
                    if(nxt!=n+1)s.erase(seg{x+1,nxt-1,(nxt-2-x)>>1});
                    else s.erase(seg{x+1,nxt-1,nxt-2-x});
                }
                pos.erase(x);
                add(l,r);
            }
        }
    }
    
    signed main()
    {
        while(scanf("%d%d",&n,&m)!=EOF)solve();
        return 0;
    }
    
    
    

    G.LCA

    这题其实不难,就是很烦人

    一颗结点数量为N的数,美丽度的定义,对于任意的两个点,取遍所有N个节点,分别取他们作为根,求这两个节点在不同的根下,分别到他们lca的距离乘积的总和

    首先要想到真正有贡献的节点,实际上是两点连成路径上的节点以及这些点对应的侧分支。

    然后再去进一步推导公式,比较麻烦的是,要继续拆开,把它拆成很多子项去进行计算。利用树上前缀和去高效求值。

    #include<bits/stdc++.h>
    using namespace std;
    #define MAXN 250003
    #define ll long long
    #define int ll
    const ll mod=998244353;
    inline int read()
    {
        int ans=0;
        char last=' ',ch=getchar();
        while(ch<'0'|ch>'9')last=ch,ch=getchar();
        while(ch>='0' && ch<='9')ans=ans*10+ch-'0',ch=getchar();
        if(last=='-')ans=-ans;
        return ans;
    }
    struct edge
    {
        int r,to;
    };
    edge e[MAXN];
    int head[MAXN],d[MAXN],lg[MAXN],s[MAXN];
    ll Si[MAXN],Sfa[MAXN],SfaDfa[MAXN],SiDfa[MAXN],SiDfa2[MAXN],SfaDfa2[MAXN];
    int fa[MAXN][22];
    int total=0,n,m,root,a,b;
    ll q;
    void add(int x,int y)
    {
        e[++total].r=y;
        e[total].to=head[x];
        head[x]=total;
    }
    void dfs(int cur,int fapos)
    {
        fa[cur][0]=fapos;
        d[cur]=d[fapos]+1;
        for(int i=1;i<=lg[d[cur]];i++)
        {
            fa[cur][i]=fa[fa[cur][i-1]][i-1];
        }
        s[cur]=1;
        for(int i=head[cur];i;i=e[i].to)
        {
            if(e[i].r!=fapos)
            {
                dfs(e[i].r,cur);
                s[cur]+=s[e[i].r];
            }
        }
    }
    void dfs2(int cur,int fapos)
    {
        Si[cur]=s[cur];
        if(cur!=1)
        {
            Si[cur]+=Si[fa[cur][0]];
            Sfa[cur]=s[fa[cur][0]];Sfa[cur]+=Sfa[fa[cur][0]];
            SfaDfa[cur]=s[fa[cur][0]]*d[fa[cur][0]];SfaDfa[cur]+=SfaDfa[fa[cur][0]];
            SiDfa[cur]=s[cur]*d[fa[cur][0]];SiDfa[cur]+=SiDfa[fa[cur][0]];
            SiDfa2[cur]=s[cur]*d[fa[cur][0]]*d[fa[cur][0]]%mod;SiDfa2[cur]+=SiDfa2[fa[cur][0]];
            SfaDfa2[cur]=s[fa[cur][0]]*d[fa[cur][0]]*d[fa[cur][0]]%mod;SfaDfa2[cur]+=SfaDfa2[fa[cur][0]];
        }
        for(int i=head[cur];i;i=e[i].to)
        {
            if(e[i].r!=fapos)
                dfs2(e[i].r,cur);
        }
    }
    int afa,bfa;
    int LCA(int a,int b)
    {
        if(d[a]<d[b])swap(a,b);
        if(d[a]!=d[b])
        {
            while(d[a]>d[b]+1)
            a=fa[a][lg[d[a]-d[b]-1]-1];
        }
        if(fa[a][0]==b)
        {
            afa=bfa=a;
            return b;
        }
        if(d[a]!=d[b])a=fa[a][0];
        for(int k=lg[d[a]-1];k>=0;k--)
            if(fa[b][k]!=fa[a][k])a=fa[a][k],b=fa[b][k];
        afa=a,bfa=b;
        return fa[b][0];
    }
    ll prefix(int a,int b)
    {
        ll ans=0;
        ans+=(Sfa[a]-Sfa[b])*d[a]*(q-d[a])%mod;
        ans+=(SfaDfa[a]-SfaDfa[b])*d[a]%mod;
        ans-=(SfaDfa[a]-SfaDfa[b])*(q-d[a])%mod;
        ans-=(SfaDfa2[a]-SfaDfa2[b])%mod;
        ans-=(Si[a]-Si[b])*d[a]*(q-d[a])%mod;
        ans+=(SiDfa[a]-SiDfa[b])*(q-d[a])%mod;
        ans-=(SiDfa[a]-SiDfa[b])*d[a]%mod;
        ans+=(SiDfa2[a]-SiDfa2[b])%mod;
        return (ans+1ll*100*mod)%mod;
    }
    ll query(int a,int b)
    {
        ll ans=0;
        int c=LCA(a,b);
        if(afa==bfa)
        {
            if(a==c)swap(a,b);
            q=d[a]-d[c];
            //cout<<a<<" "<<afa<<endl;
            ans=prefix(a,afa);
        }
        else
        {
            ans+=1ll*(n-s[afa]-s[bfa])*(d[a]-d[c])%mod*(d[b]-d[c])%mod;
            //cout<<ans<<endl;
            //cout<<afa<<" "<<bfa<<endl;
            q=d[a]-d[c]+d[b]-d[c];
            ans+=prefix(a,afa);
            ans+=prefix(b,bfa);
        }
        return (ans+1ll*100*mod)%mod;
    }
    
    signed main()
    {
        n=read(),m=read();
        root=1;
        for(int i=0;i<n-1;i++)
        {
            a=read(),b=read();
            add(a,b);
            add(b,a);
        }
        for(int i=1;i<=n;i++)
            lg[i]=lg[i-1]+(1<<lg[i-1]==i);
        dfs(root,1);
        dfs2(root,1);
        for(int i=1;i<=m;i++)
        {
            a=read(),b=read();
            if(a==b)cout<<"0
    ";
            else cout<<query(a,b)<<"
    ";
        }
    
        /*
        cout<<endl;
        for(int i=1;i<=n;i++)
        {
            cout<<i<<" "<<Si[i]<<endl;
        }
        */
        return 0;
    }
    /*
    5 1
    1 2
    1 3
    3 4
    3 5
    1 5
    
    4 5
    2 5
    */
    
    

    E.FFT

    按照规律打表后发现了一个循环节

    [2^{log_2 n} ]

    于是最多的操作数不超过131072次

    [每个数的大小不超过2^{17},考虑按位将其拆开,再分别处理 ]

    每次异或操作相当于一次不进位的加法,相当于要对每一位做多次前缀和,最后对2取模

    每一位的多次前缀和用FFT维护,最终时间复杂度为常数很大的nlogn

    现场原本以为是常数太大导致T了,后来发现自己有个while(k%2==0)的循环,当k一开始为0时就会死循环

    #include<bits/stdc++.h>
    using namespace std;
    const int mod=998244353;
    int g=3,a1[300010],b[300010],rev[300010],C[300010];
    int a[100010],n;
    long long m;
    int ksm(int a,int b)
    {
    	int res=1;
    	while(b)
    	{
    		if(b&1)res=1ll*res*a%mod;
    		a=1ll*a*a%mod;
    		b>>=1;
    	}
    	return res;
    }
    void ntt(int *a,int n,int f)
    {
    	for(int i=0;i<n;i++)if(i<rev[i])swap(a[i],a[rev[i]]);
    	for(int i=1;i<n;i<<=1)
    	{
    		int gn=ksm(g,(mod-1)/(i<<1));if(f==-1)gn=ksm(gn,mod-2);
    		for(int j=0;j<n;j+=i<<1)
    		{
    			int gqn=1;
    			for(int k=j;k<i+j;k++)
    			{
    				int x=a[k],y=1ll*gqn*a[k+i]%mod;
    				a[k]=1ll*(x+y)%mod;
    				a[k+i]=1ll*(x-y+mod)%mod;
    				gqn=gqn*1ll*gn%mod;
    			}
    		}
    	}
    	if(f==-1)
    	{
    		int ny=ksm(n,mod-2);
    		for(int i=0;i<n;i++)a[i]=a[i]*1ll*ny%mod;
    	}
    }
    inline int read()
    {
    	int res=0;
    	char c=getchar();
    	while(c<'0'||c>'9')c=getchar();
    	while(c>='0'&&c<='9')
    	{
    		res=(res<<1)+(res<<3)+c-'0';
    		c=getchar();
    	}
    	return res;
    }
    int ans[20][300010],sum[300010];
    int main()
    {
    //	freopen("std.in","r",stdin);
    	int k=1;
    	cin>>n>>m;
    	while(n>=k)k<<=1;
    	m%=k;
    	long long l=1,r=m;
    	int bj=0;
    	k=m;
    	for(int i=1;i<=n;i++)
    	a[i]=read();
    	if(k==0)
    	{
    		for(int i=1;i<=n;i++)
    		cout<<a[i]<<" ";
    		return 0;
    	}
    	while(k%2==0&&k!=0)
    	{
    		k>>=1;bj++;
    	}
    	C[0]=1;C[1]=m;
    	C[1]&=1;
    	for(int i=2;i<=n;i++)
    	{
    		k=m+i-1;
    		while(k%2==0&&k!=0)
    		{
    			k>>=1;
    			bj++;
    		}
    		k=i;
    		while(k%2==0)
    		{
    			k>>=1;
    			bj--;
    		}
    		if(bj)C[i]=0;
    		else C[i]=1;
    	}
    	for(int i=0;i<=17;i++)
    	for(int j=1;j<=n;j++)
    	ans[i][j-1]=((a[j]&(1<<i))!=0);
    	int n1=2,bit;
    	l=n;
    	for(bit=1;(1<<bit)<(l<<1);bit++)n1<<=1;
    	for(int i=1;i<n1;i++)rev[i]=(rev[i>>1]>>1)|((i&1)<<(bit-1));
    	ntt(C,n1,1);
    	for(int i=0;i<=17;i++)
    	{
    		for(int j=0;j<n1;j++)
    		b[j]=ans[i][j];
    //      for(int j=0;j<n1;j++)
    //		cout<<b[j]<<" ";
    //		cout<<"
    ";
    		ntt(b,n1,1);
    //		for(int j=0;j<n;j++)
    //		cout<<b[j]<<" ";
    //		cout<<"
    ";
    		for(int j=0;j<n1;j++)
    		b[j]=1ll*b[j]*C[j]%mod;
    		ntt(b,n1,-1);
    //		for(int j=0;j<n1;j++)
    //		cout<<b[j]<<" ";
    //		cout<<"
    ";
    		for(int j=0;j<n1;j++)
    		ans[i][j]=b[j];
    	}
    	for(int i=0;i<n;i++)
    	{
    		for(int j=0;j<=17;j++)
    		sum[i]+=(ans[j][i]&1)<<j;
    	}
    	for(int i=0;i<n-1;i++)
    	printf("%d ",sum[i]);
    	printf("%d",sum[n-1]);
    	return 0;
    }
    

    J.容斥原理计数

    首先a,b数组的顺序不会影响答案,先将其按照升序排序。

    [从左上角开始,取q=min(a_1,b_1) ]

    设最大值等于p的有y行x列,其形成一个L的图形,考虑对L型的计数

    由容斥原理其方案数为

    [sum_{i=0}^{x}inom{x}{i}(-1)^isum_{j=0}^{y}inom{y}{j}(-1)^jq^{(mx+ny-xy)-(mi+nj-ij)}(q-1)^{mi+nj-ij} ]

    整理后得

    [q^{mx+ny-xy}sum_{i=0}^{x}inom{x}{i}(-1)^i(frac{q-1}{q})^{mi}sum_{i=0}^{y}inom{y}{j}(-1)^j(frac{q-1}{q})^{j(n-i)} ]

    因为

    [(x+y)^n=sum_{i=0}^{n}inom{n}{i}x^iy^{n-i} ]

    令y=1则有

    [(x+1)^n=sum_{i=0}^{n}inom{n}{i}x^i ]

    再令x=-x

    [(-x+1)^n=sum_{i=0}^{n}inom{n}{i}(-x)^i=sum_{i=0}^{n}inom{n}{i}(-1)^ix^i ]

    因此上式可进一步化简为

    [q^{mx+ny-xy}sum_{i=0}^{x}inom{x}{i}(-1)^i(frac{q-1}{q})^{mi}(1-(frac{q-1}{q})^{n-i})^y ]

    将每个L型的数目乘起来就是答案

    注意不要用递归计算,会爆栈

    #include <bits/stdc++.h>
    using namespace std; 
    const int mod=998244353;
    int ksm(int a,int b)
    {
    	int ans=1;
    	while(b)
    	{
    		if(b&1)ans=1ll*ans*a%mod;
    		a=1ll*a*a%mod;
    		b>>=1;
    	}
    	return ans;
    }
    int a[100010],b[100010],inv1[100010];
    long long f(int x1,int y1,int n,int m)
    {
    	long long daan=1;
    	for(;m+n>0;)
    	{
    	int q=min(a[x1],b[y1]);
    	int x2=x1,y2=y1;
    	while(a[x2]==q)x2++;
    	while(b[y2]==q)y2++;
    	long long x=x2-x1,y=y2-y1;
    	long long ans=ksm(q,(m*x+n*y-x*y)%(mod-1));
    	long long ans1=0;
    	long long inv=1ll*(q-1)*ksm(q,mod-2)%mod;
    	long long xx=ksm(inv,m),zhi=1;
    	ans1+=ksm(1-ksm(inv,n)+mod,y);
    	ans1%=mod;
    	long long zuhe=1,flag=1;
    	for(int i=1;i<=x;i++)
    	{
    		flag*=-1;
    		zuhe=zuhe*inv1[i]%mod;
    		zuhe=zuhe*(x-i+1)%mod;
    		zhi=zhi*xx%mod;
    		if(flag==1)
    		ans1+=zuhe*zhi%mod*ksm((1-ksm(inv,n-i)+mod)%mod,y)%mod;
    		else 
    		ans1-=zuhe*zhi%mod*ksm((1-ksm(inv,n-i)+mod)%mod,y)%mod;
    		ans1%=mod;
    		ans1=(ans1+mod)%mod;
    	}
    	daan=daan*ans%mod*ans1%mod;
    	x1=x2;y1=y2;n-=x;m-=y;
        }
        return daan;
    }
    int main()
    {
        int n,m;
        scanf("%d%d",&n,&m);
        inv1[1]=1;
        for(int i=2;i<=100000;i++)
        inv1[i]=mod-1ll*(mod/i)*inv1[mod%i]%mod;
        for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
        for(int j=1;j<=m;j++)
        scanf("%d",&b[j]);
        sort(a+1,a+n+1);
        sort(b+1,b+m+1);
        cout<<f(1,1,n,m)%mod;
    	return 0;	
    } 
    

    B.Polya计数 杜教筛 数论分块

    对于长度为n的手镯,其方案数为

    [frac{1}{n}sum_{d|n}phi(d)g(n/d) ]

    [g(x)=fib(x)+fib(x-2)+2[{x&1=0}] ]

    答案即求

    [sum_{n=1}^msum_{d|n}phi(d)g(n/d) ]

    先枚举d得

    [sum_{d=1}^mphi(d)sum_{i=1}^{lfloor m/d floor}g(i) ]

    [sum_{d=1}^mphi(d)可以杜教筛来求,后面的可以矩阵快速幂来求 ]

    #include <bits/stdc++.h>
    using namespace std; 
    int smu[5000010],mu[5000010],prm[5000010],tot,b[5000010],B=5000010,nop[5000010],mod;
    long long phi[5000010],sphi[5000010];
    map<int,long long>mp_phi;
    inline void SieveMu(int n)
    {
    	mu[1]=1;
    	for(int i=2;i<=n;i++)
    	{
    		if(!b[i])
    		{
    			prm[++tot]=i;
    			mu[i]=-1;
    		}
    		for(int j=1;j<=tot&&i*prm[j]<=n;j++)
    		{
    			b[i*prm[j]]=1;
    			if(i%prm[j]==0)
    			{
    				mu[i*prm[j]]=0;
    				break;
    			}
    			else
    			{
    				mu[i*prm[j]]=-mu[i];
    			}
    		}
    	}
    }
    void getprime(int lim)
    {
    	nop[1]=1,phi[1]=1;
    	for(int i=2;i<=lim;i++)
    	{
    		if(!nop[i])phi[i]=i-1;
    		for(int j=1;j<=tot&&i*prm[j]<=lim;j++)
    		{
    			nop[i*prm[j]]=1;
    			if(i%prm[j]==0)
    			{
    				phi[i*prm[j]]=phi[i]*prm[j];
    				break;
    			}
    			else phi[i*prm[j]]=phi[i]*(prm[j]-1);
    		}
    	}
    }
    long long DujiaoPhi(int n)
    {
    	if(n<=B)return sphi[n];
    	if(mp_phi[n])return mp_phi[n];
    	long long res=1ll*n*(n+1)/2;
    	for(int i=2,j;i<=n;i=j+1)
    	{
    		j=n/(n/i);
    		res-=(j-i+1)*DujiaoPhi(n/i);
    	}
    	return mp_phi[n]=res;
    }
    struct tnode{
    	long long a[2][2];
    };
    tnode mul(tnode a,tnode b)
    {
    	tnode c;
    	c.a[0][0]=(1ll*a.a[0][0]*b.a[0][0]+1ll*a.a[0][1]*b.a[1][0])%mod;
    	c.a[1][0]=(1ll*a.a[0][0]*b.a[0][1]+1ll*a.a[0][1]*b.a[1][1])%mod;
    	c.a[0][1]=(1ll*a.a[1][0]*b.a[0][0]+1ll*a.a[1][1]*b.a[1][0])%mod;
    	c.a[1][1]=(1ll*a.a[1][0]*b.a[0][1]+1ll*a.a[1][1]*b.a[1][1])%mod;
    	return c;
    }
    int ksm(tnode a,int b)
    {
    	tnode ans;
    	ans.a[0][0]=1;
    	ans.a[1][0]=0;
    	ans.a[0][1]=0;
    	ans.a[1][1]=1;
    	while(b)
    	{
    		if(b&1)ans=mul(ans,a);
    		a=mul(a,a);
    		b>>=1;
    	}
    	return ans.a[0][1]%mod;
    }
    int fib(int n)
    {
    	tnode a;
    	a.a[0][0]=1;
    	a.a[0][1]=1;
    	a.a[1][0]=1;
    	a.a[1][1]=0;
    	if(n==1)return 0;
    	if(n==2)return 1;
    	if(n==3)return 1;
    	if(n==4)return 2;
    	return ksm(a,n-1);
    }
    int main()
    {
        SieveMu(B);
        getprime(B);
        int n;
        int r;
        cin>>n>>mod;
        for(int i=1;i<=B;i++)
        sphi[i]=sphi[i-1]+phi[i];
        long long ans=0;
        for(int l=1,r;l<=n;l=r+1)
        {
        	r=n/(n/l);
        	int m=n/l;
        	ans+=(DujiaoPhi(r)-DujiaoPhi(l-1))%mod*(((1ll*fib(m+4)-1+fib(m+2)-1+mod-1)%mod+m/2*2ll+mod)%mod)%mod;
        	ans%=mod;
    	}
    	cout<<ans<<"
    ";
    	return 0;	
    } 
    

    D.推式子+逆元

    [frac{1}{n}sum_{v}frac{s(v)-1}{s(fa(v))}*s(v) ]

    根据每个点修改时对其他点的期望可以推出如下式子,最后通过逆元求出每个点期望的和再除以n即可。

    #include<bits/stdc++.h>
    using namespace std;
    int n,x,cnt;
    long long ans;
    const long long mod=998244353;
    int l[100010],fa[100010];
    long long s[100010];
    struct edge{
    	int w,next;
    }e[500010];
    long long inv(long long a,long long p)
    {
    	long long ans=1;
    	long long b=p-2;
    	a%=p;
    	while(b>0)
    	{
    		if(b&1)
    		ans=(ans*a)%p;
    		a=(a*a)%p;
    		b/=2;
    	}
    	return ans%p;
    }
    void add(int x,int y)
    {
    	e[++cnt].w=y;
    	e[cnt].next=l[x];
    	l[x]=cnt;
    }
    int dfs(int x)
    {
    	for(int i=l[x];i;i=e[i].next)
    	s[x]+=dfs(e[i].w);
    	s[x]++;
    	return s[x];
    }
    int main()
    {
    	cin>>n;
    	for(int i=2;i<=n;i++)
    	{
    		cin>>x;
    		fa[i]=x;
    		add(x,i);
    	}
    	dfs(1);
    	for(int i=2;i<=n;i++)
    	{
    		ans+=1ll*(s[fa[i]]-1-s[i]+mod)%mod*inv(s[fa[i]]-1,mod)%mod*(s[i])%mod;
    		ans%=mod;
    	}
    	ans*=inv(n,mod);
    	ans%=mod;
    	cout<<ans;
    	return 0;
    }
    
  • 相关阅读:
    dedeCMS自定义dede标签
    phpstrom配置Xdebug
    ElasticSearch安装 --- windows版
    MySQL语句优化
    PHP高并发商城秒杀
    【java_需阅读】Java中static关键字用法总结
    【java】public,private和protected
    PICT测试工具的安装及使用
    【android】Android am命令使用
    【python】获取指定网页上的所有超级链接
  • 原文地址:https://www.cnblogs.com/et3-tsy/p/14134119.html
Copyright © 2020-2023  润新知