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
