(杭电多校)2023“钉耙编程”中国大学生算法设计超级联赛（5）

1001 Typhoon

计算几何

对于每一个避难点,计算其到所有线段的距离,取min即可

AC代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<deque>
#include<cmath>
#include<cstdio>
#include<iomanip>
#define endl '\n'
#define eps 1e-9
//#define int long long
using namespace std;
typedef long long ll;
const int N=1e4+10,inf=2e9;
double dist[N];
//向量表示(定义一个结构体,用坐标表示向量)
struct Point {
    double x,y;
    double len() const { //模
        return sqrt(x*x+y*y);
    }
};
Point operator+(Point a,Point b) { //加法
    return {a.x+b.x,a.y+b.y};
}
Point operator-(Point a,Point b) { //减法
    return {a.x-b.x,a.y-b.y};
}
double operator&(Point a,Point b) { //点积
    return a.x*b.x+a.y*b.y;
}
double operator*(Point a,Point b) { //叉积
    return a.x*b.y-a.y*b.x;
}
//向量的点积
double dot(Point a,Point b,Point c) {
    return (b-a)&(c-a);//a,b,c均为点,向量b-a与向量c-a进行点积
}
//向量的叉积
double cross(Point a,Point b,Point c) {
    return (b-a)*(c-a);
}
int n,m;
void solve() {
    cin>>m>>n;
    vector<Point>p(m);
    for(int i=0; i<m; i++) cin>>p[i].x>>p[i].y;
    vector<Point>s(n);
    for(int i=0; i<n; i++) cin>>s[i].x>>s[i].y;
    vector<double>dis(n,inf);//定义了一个名为dis的变量,它是一个长度为n的vector容器,其中每个元素的初始值都被设置为inf
    for(int i=1; i<m; i++) {
        //枚举线段(用向量表示)
        Point a=p[i-1],b=p[i];
        //枚举避难所
        for(int j=0; j<n; j++) {
            Point c=s[j];
            double d1=dot(a,b,c);//求向量b-a与向量c-a的点积
            double d2=dot(b,a,c);//求向量c-b与向量c-a的点积
            double res;
            if(d1<0||d2<0) {
                res=min((c-a).len(),(c-b).len());//点积小于0说明角度是钝角,那么垂足就在线段外,取两点最小值
            } else {
                res=cross(a,b,c)/(b-a).len();//求点到线段的垂直距离,为向量b-a与向量c-a叉积再除以向量b-a的模(面积/底)
            }
            res=fabs(res);
            if(res<eps) res=0;//如果答案小于精度,则直接相当于等于0
            dis[j]=min(dis[j],res);
        }
    }
    cout<<setiosflags(ios::fixed)<<setprecision(4);//保留四位小数,四舍五入,头文件为#include<iomanip>
    for(int i=0; i<n; i++) cout<<dis[i]<<endl;
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t=1;
//    cin>>t;
    while(t--)
        solve();
    return 0;
}

1006 Touhou Red Red Blue

法一(dp):

AC代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<cstdio>
#define endl '\n'
#define get(a,b) (a*4+b)
//#define int long long
using namespace std;
typedef long long ll;
const int N=1e5+10,M=16;
int f[N][M];//f[i][j]表示当前球为i,两个袋子的球的状态为j的最大得分,袋子1中的球有4种状态,袋子2中的球也有4种状态,一共4*4=16种状态(0代表没有球,1~3代表球的颜色为R,G,B)
void solve() {
    string s;
    cin>>s;
    int n=s.size();
    for(int i=1; i<=n; i++) {
        int c;//表示当前球的颜色,1代表R,2代表G,3代表B
        if(s[i-1]=='R') c=1;
        else if(s[i-1]=='G') c=2;
        else c=3;
        for(int j=0; j<M; j++) f[i][j]=f[i-1][j]; //可以选择存储或放弃UFO,我们选择扔掉它
        //枚举1号袋子的状态和2号袋子的状态,0代表没有球,1~3代表分别代表球的颜色为R,G,B
        for(int a=0; a<=3; a++) {
            for(int b=0; b<=3; b++) {
                //如果两个袋子都不为空
                if(a&&b) {
                    //如果3个球的颜色均相同,那么三个球都消掉,得1分,和消消乐一样
                    if(a==b&&b==c) {
                        //得到一个附加的球放在袋子1里,此时袋子2为空
                        for(int d=1; d<=3; d++) f[i][4*d]=max(f[i][4*d],f[i-1][get(a,b)]+1);
                    }
                    //如果三个球的颜色均不相同,那么3个球都会消失然后会得到两个附加的球,放到袋子1和袋子2中
                    else if(a&&b&&a!=b&&a!=c&&b!=c) {
                        //枚举袋子1的球的颜色
                        for(int d=1; d<=3; d++) {
                            //枚举袋子2的球的颜色
                            for(int e=1; e<=3; e++) {
                                f[i][get(d,e)]=max(f[i][get(d,e)],f[i-1][get(a,b)]);
                            }
                        }
                    }
                    //否则,扔掉袋子1中的球,将袋子2中的球移到袋子1中,并将当前球放到袋子2中
                    else f[i][get(b,c)]=max(f[i][get(b,c)],f[i-1][get(a,b)]);
                }
                //if(a&&b)不满足,说明其中一个袋子是空的,
                //如果a不空,b空,那么就把c放到第二个袋子里
                else if(a) f[i][get(a, c)] = max(f[i][get(a, c)], f[i - 1][get(a, b)]);
                //如果a,b袋子均为空,那么就把c放到第一个袋子里
                else f[i][get(c, 0)] = max(f[i][get(c, 0)], f[i - 1][get(a, b)]);
            }
        }
    }
    int res=0;
    for(int i=0; i<M; i++) res=max(res,f[n][i]);
    cout<<res<<endl;
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    memset(f[0],-0x3f,sizeof f[0]);//初始化为负无穷,因为后面要取max
    f[0][0]=0;//初始状态得分为0,由此开始递推
    int t=1;
    cin>>t;
    while(t--)
        solve();
    return 0;
}

法二(贪心):

AC代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<cstdio>
#define endl '\n'
//#define int long long
using namespace std;
typedef long long ll;
void solve() {
    string s;
    cin>>s;
    int n=s.size();
    int r=0,g=0,b=0;
    int res=0;
    int t=0;//表示这一轮可以自己选几个球,初始为0
    for(int i=0;i<n;){
        //这轮可以自选一个球放在袋子1中,然后看后面两个球颜色是否相同
        if(t==1){
            if(i==n-1) break;//自选的1个球加上最后一个球一共也才2个球,不足三个球是不能消消乐的,不可以得分了,直接跳出
            if(s[i]==s[i+1]) t=1,res++;//,如果后两个球颜色相同,那么将这个自选的球颜色变得和后两个球颜色一样,使得三个消消乐消掉,+1分,下一轮进入t=1的状态,即下一轮可以自选一个球放到袋子1中
            else t=2;//如果后两个球颜色不相同,那么就使得三个球颜色均不相同,下一轮进入t=2的状态,即下一轮可以自选2个球分别放到袋子1和袋子2中
            i+=2;//跳过本次和下一次,因为连续三个球都消失了
        }
        //这轮可以自选两个球放在袋子1和袋子2中,我们完全可以使得这两个球和当前球颜色相同,然后消消乐消掉这三个球,+1分,下一轮
        else if(t==2){
            t=1;//凑成3个颜色相同的球,消消乐,下一轮进入t=1的状态
            res++;
            i++;//跳过本此
        }
        //只有初始状态为t=0,然后接下来就是在t=1和t=2两状态之间转来转去
        else{
            if(s[i]=='R') r++;
            else if(s[i]=='G') g++;
            else b++;
            if(r&&g&&b) t=2;//如果三种颜色的球的数量都不为0,那么说明三个球颜色均不相同,那么进入t=2的状态,下一轮可以自选两个球
            else if(r==3||b==3||g==3) t=1,res++;//如果三个球颜色均相同,那么消消乐,+1分,进入t=1的状态,下一轮可以自选一个球
            i++;//继续下一轮
        }
    }
    cout<<res<<endl;
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t=1;
    cin>>t;
    while(t--)
        solve();
    return 0;
}

1007 Expectation(Easy Version)

算期望

根据样例:

一共有n局比赛

通项=组合数(n局中赢哪x局)*n局赢x局的概率*(1^m+2^m+...x^m)

然后遍历1到n,将其全部加起来

也就是:

假设赢一局的概率为p

C(n,1)*p^1*(1-p)^(n-1)*1^m+C(n,2)*p^2*(1-p)^(n-2)*(1^m+2^m)+...C(n,n)*p^n*(1^m+2^m+...+n^m)

由此,我们可以将其分为三个部分A,B以及C

然后呢,每一部分我们都可以不断地累加或者累乘

我们可以发现组合数每次都可以在上一项C(n,i)的基础上乘(n-i)/(i+1)

对于概率这一部分也是同样如此：

再次转换： 

发现每次都是乘a*(b-a)^(-1)

分母始终都是b^n,所以先不用管分母,只需要当全部算完之后,最后除以一个b^n就行了

最后一部分相比之下就很简单,直接加(i+1)^m

AC代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<deque>
#include<cmath>
#include<cstdio>
#define endl '\n'
#define int long long
using namespace std;
typedef long long ll;
const int mod=998244353;
int n,m,a,b;
inline int qmi(int a,int k){
    int res=1;
    while(k){
        if(k&1) res=(ll)res*a%mod;
        a=(ll)a*a%mod;
        k>>=1;
    }
    return res;
}
inline int inv(int x){
    return qmi(x,mod-2);
}
int solve() {
    cin>>n>>m>>a>>b;
    int res=0;
    int k=a*inv(b-a)%mod;
    int A=n%mod,B=qmi(b-a,n-1)*a%mod,C=1;
    for(int i=1;i<=n;i++){
        (res+=A*B%mod*C%mod)%=mod;
        A=A*(n-i)%mod*inv(i+1)%mod;
        (B*=k)%=mod;
        (C+=qmi(i+1,m))%=mod;
    }
    return (res*inv(qmi(b,n)))%mod;
}
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int t=1;
    cin>>t;
    while(t--)
    cout<<solve()<<endl;
    return 0;
}

1012 Counting Stars 

如图,比如说想要求以1为顶点的2-star图的数量,发现顶点1有三条边,那么就是在三条边中选择两条边的方案数,这样就用到了组合数学

原本我想的是分别求每一个cnt[i],对于每一个cnt[i],枚举所有的顶点,将每个顶点所形成的i-star图的个数加起来,但是会发现这样双重循环就超时了

for (int i = 2; i <= n - 1; i++) {
        for (int j = 1; j <= n; j++) {
            (cnt[i] += c[e[j].size()][i]) %= mod;
        }
    }

可以换一种思路:枚举所有的顶点,然后我们知道该顶点的度数,就是每枚举一个顶点,就记录以该顶点可以形成的2-star,3-star...的数量,这样做的好处是不会超时,因为根据握手定理

握手定理:

所以度数之和为2*m,为2e6,也就是说时间复杂度不会超过2e6 

    for(int i=1;i<=n;i++){
        for(int j=2;j<=d[i];j++){
            (ans[j]+=C(deg[i],j))%=mod;
        }
    }

 可以这样理解,加一个cnt++,然后cnt加的次数不会超过2e6

for(int i=1;i<=n;i++){
        for(int j=2;j<=d[i];j++){
            (ans[j]+=C(deg[i],j))%=mod,cnt++;
        }
    }

现在主要就是求组合数的问题,因为n太大了,所以求组合数不好求

我们发现C(n,1)=n/1,C(n,2)=n*(n-1)/(1*2),C(n,3)=n*(n-1)/(1*2*3)

所以我们可以先预处理阶乘以及阶乘的逆元

AC代码:

#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<deque>
#include<cmath>
#include<cstdio>
#define endl '\n'
//#define int long long
using namespace std;
typedef long long ll;
const int N=1e6+10,mod=1e9+7;
int d[N];
int fac[N],ifac[N];
int ans[N];
int n,m;
//快速幂
int qmi(int a,int k){
    int res=1;
    while(k){
        if(k&1) res=(ll)res*a%mod;
        a=(ll)a*a%mod;
        k>>=1;
    }
    return res;
}
//求组合数
int C(int n,int m){
    if(n<m) return 0;
    return 1ll*fac[n]*ifac[m]%mod*ifac[n-m]%mod;
}
void solve() {
    cin>>n>>m;
    for(int i=1;i<=n;i++) d[i]=ans[i]=0;
    for(int i=0;i<m;i++){
        int u,v;
        cin>>u>>v;
        d[u]++,d[v]++;
    }
    for(int i=1;i<=n;i++){
        for(int j=2;j<=d[i];j++){
            (ans[j]+=C(d[i],j))%=mod;
        }
    }
    int res=0;
    for(int i=2;i<=n-1;i++) res^=ans[i];
    cout<<res<<endl;
}
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    //预处理阶乘以及阶乘的逆元
    fac[0]=ifac[0]=1;//0的阶乘是1,0的阶乘的逆元也是1
    for(int i=1;i<N;i++) fac[i]=1ll*fac[i-1]*i%mod;//预处理阶乘
    ifac[N-1]=qmi(fac[N-1],mod-2);//先求出fac[N-1]的逆元,由于(n+1)!=n!*(n+1)==>n!^(-1)=(n+1)!^(-1)*(n+1),所以也可以通过递推得到阶乘的逆元
    for(int i=N-2;i>=1;i--) ifac[i]=1ll*ifac[i+1]*(i+1)%mod;
    int t=1;
    cin>>t;
    while(t--)
    solve();
    return 0;
}