[32]（CSP 集训） CSP-S 模拟 3

A 奇观

考虑到 CCF 可以拆开算，答案为 \((ans_c)^2\times ans_f\)

剩下的东西比较少，考虑 DP

我的 dp 是从爆搜改的，设 \(f_{i,j}\) 表示递归到第 \(i\) 层时 \(j\) 的方案数，原始的爆搜代码如下：

int dfs_f2(int now,int id){
    if(now==0) return 1;
    if(now==1) return f_c[0][id];
    if(f_c[now][id]) return f_c[now][id];//cth<<"dfs "<<now<<" "<<id<<endl;
    int res=0;
    if(now!=2){
        for(int i=1;i<=n;++i){
            if(i!=id and hdk.find(i,id)){
                res+=dfs_f2(now-1,i);
                res%=p;
            }
        }
    }
    else{
        for(int i=1;i<=n;++i){
            if(i!=id and hdk.find(i,id)){
                res+=f_c[0][i]*f_c[0][id];
                res%=p;
            }
        }
    }
    return f_c[now][id]=res%p;
}

可以发现该搜索的最大问题在于内层枚举时的循环，注意到此题是完全图删边形成的，因此考虑做容斥，用总方案数减去不合法的，不合法的可以通过枚举得到

我写的 dp 比较异端，看个乐子就行

    scanf("%lld %lld",&n,&m);
    for(int i=1;i<=n;++i){
        f_c[0][i]=n-1;
    }
    for(int i=1;i<=m;++i){
        int x,y;scanf("%lld %lld",&x,&y);
        del_e[x].push_back(y);
        del_e[y].push_back(x);
        f_c[0][x]--;f_c[0][y]--;
    }
    int sum=0;
    for(int i=1;i<=n;++i){
        sum=(sum+f_c[0][i])%p;
    }
    for(int i=1;i<=n;++i){
        f_c[1][i]=fixed(sum-f_c[0][i]);
        for(int j:del_e[i]) f_c[1][i]=fixed(f_c[1][i]-f_c[0][j]);
    }
    sum=0;
    for(int i=1;i<=n;++i){
        sum=(sum+f_c[1][i])%p;
    }
    for(int i=1;i<=n;++i){
        f_c[2][i]=fixed(sum-f_c[1][i]);
        for(int j:del_e[i]) f_c[2][i]=fixed(f_c[2][i]-f_c[1][j]);
    }
    sum=0;
    for(int i=1;i<=n;++i){
        sum=(sum+f_c[2][i])%p;
    }
    int c=sum%p;
    memset(f_c[1],0,sizeof f_c[1]);
    memset(f_c[2],0,sizeof f_c[2]);
    memset(f_c[3],0,sizeof f_c[3]);
    sum=0;
    for(int i=1;i<=n;++i){
        sum=(sum+f_c[0][i])%p;
    }
    for(int i=1;i<=n;++i){
        f_c[1][i]=fixed((sum-f_c[0][i])*f_c[0][i]);
        for(int j:del_e[i]){
            f_c[1][i]=fixed(f_c[1][i]-f_c[0][j]*f_c[0][i]);
        }
    }
    sum=0;
    for(int i=1;i<=n;++i){
        sum=(sum+f_c[1][i])%p;
    }
    for(int i=1;i<=n;++i){
        f_c[2][i]=fixed(sum-f_c[1][i]);
        for(int j:del_e[i]){
            f_c[2][i]=fixed(f_c[2][i]-f_c[1][j]);
        }
    }
    int f=0;
    for(int i=1;i<=n;++i){
        f=(f+f_c[2][i])%p;
    }
    cout<<fixed(c*c%p*f)<<endl;

B 铁路

非常好的题

注意到我们没有必要非得去给每次操作新建边，我们可以直接在树上跳 lca 来用并查集合并，这样能解决我们求节点数目的问题：每进行一次操作，节点数加一，并查集上每进行一次合并，节点数减一

然后考虑怎么优化这个过程，注意到，已经在同一个并查集里的数是不需要合并的，因此我们可以借助并查集维护相关信息来直接跳过这段并查集，那么维护什么东西能快速跳节点呢，因为我们是在向根跳，因此我们直接维护并查集中深度最小的节点编号就好了，维护的时候直接往深度最小的节点跳。有人会问这么跳，万一跳过头了怎么办，其实无所谓，因为既然你能跳过头，说明你的目标节点一定在当前并查集内，直接判断当前点和目标点是否在同一并查集内即可

随后我们需要解决新建节点的问题，因为我们并没有真的新建节点，那么如果它询问我们一个新的节点编号，我们要知道往哪里去找。这是很好办的，因为新建节点的下属节点一定已经被合并在同一个并查集里了，因此我们直接维护一个下标，存储每一个新建节点对应的并查集的深度最小的点就行了

#include<bits/stdc++.h>
using namespace std;
#define io_h
// #include"./include/hdk/lib.h"
namespace reader{
	template<typename T>
	inline void read(T& x){
		x=0;bool sym=0;char c=getchar();
		while(!isdigit(c)){sym^=(c=='-');c=getchar();}
		while(isdigit(c)){x=x*10+c-48;c=getchar();}
		if(sym)x=-x;
	}
	template<size_t N>
	inline void read(char (&str)[N]){
		size_t n=0;char c=getchar();
		while(n<N-1&&!isspace(c)){str[n]=c;c=getchar();++n;}
		str[n]=0;
	}
	template<typename T,typename... Args>
	inline void read(T& x,Args&... args){
		read(x);read(args...);
	}
}
int deep[1000001];
using namespace reader;
template<int size>
struct dsu{
    int fa[size+1],minn[size+1];
    void clear(int n){
        for(int i=1;i<=n;++i){
            fa[i]=i;
            minn[i]=i;
        }
    }
    int find(int id){
        if(id==fa[id]){
            return id;
        }
        fa[id]=find(fa[id]);
        return fa[id];
    }
    void join(int x,int y){
        int fx=find(x),fy=find(y);
        if(fx!=fy){
            fa[fx]=fy;
            if(deep[fx]>deep[fy]){
                minn[fx]=minn[fy];
            }
        }
    }
};
int n,m;
int fa[1000001];
dsu<(int)1e6>d;
int ans=0;
int to[1000001];
void join(int x,int y,int newid){
    // cout<<"join "<<x<<" "<<y<<endl;
    int ori=x;
    while(x!=y){
        // cout<<"... "<<x<<" "<<y<<"("<<deep[x]<<","<<deep[y]<<")"<<endl;
        if(d.find(x)!=x){
            // cout<<"find x("<<x<<")!="<<d.find(x)<<endl;
            x=d.minn[d.find(x)];
            continue;
        }
        if(d.find(y)!=y){
            // cout<<"find y("<<y<<")!="<<d.find(y)<<endl;
            y=d.minn[d.find(y)];
            continue;
        }
        if(deep[x]>deep[y]){
            d.join(x,fa[x]);
            ans--;
            x=fa[x];
        }
        else{
            d.join(y,fa[y]);
            ans--;
            y=fa[y];
        }
    }
    to[newid]=ori;
}
vector<int>e[500001];
void dfs(int now,int last){
    fa[now]=last;
    deep[now]=deep[last]+1;
    for(int i:e[now]){
        if(i!=last){
            dfs(i,now);
        }
    }
}
int main(){
    freopen("a.in","r",stdin);
    freopen("a.out","w",stdout);
    read(n,m);
    d.clear(n+m);
    for(int i=1;i<=n-1;++i){
        int x,y;read(x,y);
        e[x].push_back(y);
        e[y].push_back(x);
    }
    dfs(1,0);
    for(int i=1;i<=m;++i){
        int x,y;read(x,y);
        if(x>n) x=to[x];
        if(y>n) y=to[y];
        join(x,y,n+i);
        cout<<n+ans<<endl;
    }
}

C.光纤

非常不好的题

旋转卡壳是好的，就是给你一个凸包，让你维护凸包直径，也就是一条直线到凸包内所有节点的最大距离最小

有一个结论，这样的直线一定与凸包的某一条边平行，所以你只需要绕着凸包转一圈就能搞定这个问题

问题是怎么确定凸包上哪个点到这条直线距离最大，有一个显然的 \(n^{2}\) 做法

但实际上不是的，因为这个决策点也有单调性，所以开一个双指针就做完了

这题不好，唐诗有理数类

一开始用的平面向量求点线距做的，后来调不出来了，所以改叉积了

#include<bits/stdc++.h>
using namespace std;
#define int __int128
#define abs(x) (x>=0?x:-x)
void _print(__int128 x,bool first=true){
	if(x<0){
		putchar('-');
		_print(-x,false);
		return;
	}
	if(x==0){
		if(first) putchar('0');
		return;
	}
	_print(x/10,false);
	putchar((int)(x%10)+'0');
}
namespace reader{
	template<typename T>
	inline void read(T& x){
		x=0;bool sym=0;char c=getchar();
		while(!isdigit(c)){sym^=(c=='-');c=getchar();}
		while(isdigit(c)){x=x*10+c-48;c=getchar();}
		if(sym)x=-x;
	}
	template<size_t N>
	inline void read(char (&str)[N]){
		size_t n=0;char c=getchar();
		while(n<N-1&&!isspace(c)){str[n]=c;c=getchar();++n;}
		str[n]=0;
	}
	template<typename T,typename... Args>
	inline void read(T& x,Args&... args){
		read(x);read(args...);
	}
}
using namespace reader;
class frac{
    private:
        int z,m;
    public:
        frac(int x=0,int y=1){
            z=x,m=y;
            fixed();
        }
        frac fixed(){
            int gcd=__gcd(abs(z),abs(m));
            if(m<0){
                m*=-1;z*=-1;
            }
            if(z==0){
                m=1;return *this;
            }
            if(gcd==0) return *this;
            z/=gcd;m/=gcd;
            return *this;
        }
        frac upside(){
            return frac(m,z);
        }
        frac operator = (pair<int,int>A){
            z=A.first;m=A.second;fixed();
            return *this;
        }
        frac operator + (frac A){
            return (frac(z*A.m+m*A.z,m*A.m)).fixed();
        }
        frac operator * (frac A){
            // cout<<"multi ";this->print();putchar(' ');
            // A.print();putchar('=');
            int gcd1=__gcd(z,A.m);
            int gcd2=__gcd(A.z,m);
            frac ans=(frac((z/gcd1)*(A.z/gcd2),(m/gcd2)*(A.m/gcd1))).fixed();
            // ans.print();putchar('\n');
            return ans;
        }
        frac operator / (frac A){
            return (*this*A.upside()).fixed();
        }
        frac operator -(){
            return frac(-z,m);
        }
        frac operator -(frac A){
            return *this+(-A);
        }
        bool operator <(frac A){
            return z*A.m<A.z*m;
        }
        bool operator ==(frac A){
            return z*A.m==A.z*m;
        }
        bool operator >(frac A){
            return !(*this==A and *this<A);
        }
        void print(){
            fixed();
            _print(z);putchar('/');_print(m);
            // cout<<z<<"/"<<m<<endl;
        }
        frac _abs(){
            return frac(abs(z),abs(m));
        }
        long double it(){
            return z*1.0/m;
        }
};
int n;
int q[1000001],top;
int q1[1000001],top1;
struct node{
	__int128 x,y;
}d[1000001],sta[1000001];
#define K(i,j) ((double)(d[j].y-d[i].y)/(d[j].x-d[i].x))
int cha(int x,int y,int z){
    return (d[y].x-d[x].x)*(d[z].y-d[x].y)-(d[y].y-d[x].y)*(d[z].x-d[x].x);
}
int len(int x,int y){
    return (d[y].x-d[x].x)*(d[y].x-d[x].x)+(d[y].y-d[x].y)*(d[y].y-d[x].y);
}
frac ans;
char anss[1000001];
inline void print(__int128 x){
	if(!x)putchar('0');
	else{
		if(x<0)x=-x,putchar('-');
		int cnt=0;
		while(x)anss[++cnt]=x%10+'0',x/=10;
		for(int i=cnt;i;--i)
			putchar(anss[i]);
	}
}
signed main(){
    freopen("a.in","r",stdin);
    freopen("a.out","w",stdout);
	read(n);
	if(n<=2){
        ans.print();
        return 0;
    }
	for(int i=1;i<=n;++i){
		read(d[i].x,d[i].y);
    }
	sort(d+1,d+1+n,[](const node&x,const node&y){return x.x==y.x?x.y<y.y:x.x<y.x;});
	n=unique(d+1,d+1+n,[](const node&x,const node&y){return x.x==y.x&&x.y==y.y;})-d-1;
	for(int i=1;i<=n;++i){
		while(top>1 and (K(q[top],i)<=K(q[top-1],q[top]))){
			--top;
		}
		q[++top]=i;
	}
	for(int i=n;i;--i){
		while(top1>1 and K(i,q1[top1])<=K(q1[top1],q1[top1-1]))--top1;
		q1[++top1]=i;
	}
	for(int i=2;i<top1;++i){
		q[++top]=q1[i];
	}
	for(int i=1;i<=top;++i){
		sta[i]=d[q[i]];
    }
	for(int i=1;i<=top;++i){
		d[i]=sta[i];
    }
    int now=1;
	for(int i=1;i<=top;++i){
		while((now==(i==top?1:i+1))||((abs(cha(now,i,(i==top?1:i+1))))<=(abs(cha((now==top?1:now+1),i,(i==top?1:i+1)))))){
			now=(now==top?1:now+1);
		}
		if(ans==frac(0,1) or ans.it()>(double)cha(now,i,(i==top?1:i+1))*cha(now,i,(i==top?1:i+1))/len(i,(i==top?1:i+1))){
            ans=frac(cha(now,i,(i==top?1:i+1))*cha(now,i,(i==top?1:i+1)),len(i,(i==top?1:i+1)));
        }
	}
    (ans*frac(1,4)).print();
}