暑假集训CSP提高模拟11

A.Fate

求次短路方案数.

这题有点小水了，好像之前做过.

具体的方案显然是 DP，考虑枚举当前每一个路径长度，假如比最短路更优则覆盖最短路，之前的最短路用来覆盖次短路. 否则如果比次短路更优，则直接覆盖次短路.

方案数的话考虑一样的方法维护，只是在遇到相等的路径长时使方案数加一即可.

考试的时候把转移写在最短路里面了，所以错了一遍，因为这样是不完全更新，所以要拉到外面跑一遍.

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int p=1e9+7;
vector<int>e[200001];
int dis[200001],f[2][200001];
struct node{
    int id,dis;
    bool operator <(const node& A)const{
        return dis>A.dis;
    }
};
priority_queue<node>q;
void dij(int s){
    memset(dis,0x3f,sizeof dis);
    dis[s]=0;
    q.push({s,dis[s]});
    while(!q.empty()){
        node u=q.top();
		q.pop();
        if(dis[u.id]!=u.dis){
			continue;
		}
        for(int i:e[u.id]){
            if(dis[i]>dis[u.id]+1){
            	dis[i]=dis[u.id]+1;
				q.push({i,dis[i]});
			}
        }
    }
}
struct node_{
	int id,dis;
	bool operator <(const node_ &A)const{
		return dis<A.dis;
	}
}no[200001];
signed main(){
//	freopen("Fate9.in","r",stdin);
    int n,m,s,t;
    scanf("%lld %lld %lld %lld",&n,&m,&s,&t);
    for(int i=1;i<=m;++i){
        int u,v;scanf("%lld %lld",&u,&v);
        e[u].push_back(v);
        e[v].push_back(u);
    }
    dij(s);
    for(int i=1;i<=n;++i){
		no[i].id=i;
		no[i].dis=dis[i];
	}
    sort(no+1,no+n+1);
    f[0][s]=1;
    for(int k=0;k<=1;++k){
        for(int i=1;i<=n;++i){
            for(int j:e[no[i].id]){
                if(dis[j]==dis[no[i].id]+1){
					f[k][j]+=f[k][no[i].id];
					f[k][j]%=p;
				}
                if(k==0 and dis[no[i].id]+1==dis[j]+1){
					f[1][j]+=f[0][no[i].id];
					f[1][j]%=p;
				}
            }
        }
    }
    printf("%lld",f[1][t]%p);
}

B.EVA

首先，把区间左端点放在一条鱼身上一定比较优，考虑到这个题 \(n\) 不是很大，可以枚举一遍左端点放在哪条鱼上.

其次，对于其他的鱼，可以考虑用相对速度算出它和当前鱼的相遇和离开时间，相遇时加上贡献，离开时减去贡献，计算途中最大值即可.

需要注意的是 \(v_{i}=v_{j}\) 时这么干会除以零，因为相对静止所以遇到这样的鱼直接在最初判一下就行了.

#include<bits/stdc++.h>
using namespace std;
const long double eps=1e-7;
int n,a,ans;
struct fish{
	int w,x,v;
}f[3001];
int main(){
	scanf("%d %d",&n,&a);
	for(int i=1;i<=n;++i){
		scanf("%d %d %d",&f[i].w,&f[i].x,&f[i].v);
	}
	for(int i=1;i<=n;++i){
		map<double,int>mp;
		int res=0;
		for(int j=1;j<=n;++j){
			if(f[i].v==f[j].v){
				if(f[j].x>=f[i].x and f[j].x-f[i].x<=a){
					res+=f[j].w;
				}
			}
			else{
				double l=(f[i].x-f[j].x)*1.0/(f[j].v-f[i].v);
				double r=(f[i].x-f[j].x+a)*1.0/(f[j].v-f[i].v);
				if(r-l<eps) swap(l,r);
				if(r>=0){
					l=max(l,0.0);
					mp[l]+=f[j].w;
					mp[r+eps]-=f[j].w;
				}
			}
		}
		ans=max(ans,res);
		for(auto i=mp.begin();i!=mp.end();i++){
			res+=i->second;
			ans=max(ans,res);
		}
	}
	printf("%d\n",ans);
}

C.嘉然登场

考虑一种策略：每次在插入 \(x\) 时，首先把所有 \(\ge k-x\) 的数全部放进去（也就是从大到小放），会发现，放完了之后，现在没放的数都是 \(i+x\lt k\) 的，因此全都不合法，而我们已经放入的数全部都是合法的.

新放的数不能与任何一个已经放过的 \(\le \lfloor\frac{k}{2}\rfloor\) 的数相邻，因此考虑插空算方案书，乘法原理算一下即可.

(\(e\) 是空位数量)

\[x(\ge \lfloor\frac{k}{2}\rfloor) C^{e-1}_{cnt_{x}+s-1},e=e+cnt_{x}
\]

\[x(\lt \lfloor\frac{k}{2}\rfloor) C^{cnt_{x}}_{e},e=e-cnt_{x}
\]

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int p=998244353;
int n,m,ans=1;
int a[200001],inv[200001];
signed main(){
    cin>>n>>m;
    for(int i=1;i<=n;++i){
        cin>>a[i];
    }
    sort(a+1,a+n+1);
    int l=1,r=n;
    for(int i=1;i<=n;++i){
        ans=ans*(i-2*(l-1))%p;
        if(a[l]+a[r]>=m){
            r--;
        }
        else{
            l++;
        }
    }
    inv[0]=inv[1]=1;
    for(int i=2;i<=n;++i){
        inv[i]=(p-p/i)*inv[p%i]%p;
    }
    a[0]=a[n+1]=-1;
    int iv=1,cnt=1;
    for(int i=1;i<=n+1;++i){
        if(a[i]!=a[i-1]){
            ans=ans*iv%p;
            iv=cnt=1;
        }
        else{
            cnt++;
            iv=iv*inv[cnt]%p;
        }
    }
    cout<<ans<<endl;
}

D.Clannad