Codeforces Round #537 (Div. 2)解题报告

第一题：（模拟）

#include<iostream>
#include<cstring>
#include<cmath>
#include<cstdio>
using namespace std;

#define debug puts("YES");
#define rep(x,y,z) for(int (x)=(y);(x)<(z);(x)++)
#define ll long long

#define lrt int l,int r,int rt
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define root l,r,rt
#define mst(a,b) memset((a),(b),sizeof(a))
#define pii pair<ll,ll>
#define mk(x,y) make_pair(x,y)
const int mod=998244353;
const int ub=1e6;
ll powmod(ll x,ll y){ll t; for(t=1;y;y>>=1,x=x*x%mod) if(y&1) t=t*x%mod; return t;}
ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
int vis[26];
string s1,s2;
int main()
{
    vis['a'-'a']=1;
    vis['e'-'a']=1;
    vis['i'-'a']=1;
    vis['o'-'a']=1;
    vis['u'-'a']=1;
    cin>>s1>>s2;
    int len1=s1.size(),len2=s2.size();
    if(len1!=len2) puts("No");
    else{
            int flag=0;
        rep(i,0,len1){
            if(vis[s1[i]-'a']!=vis[s2[i]-'a']) {flag=1;break;}
        }
        if(flag) puts("No");
        else puts("Yes");
    }


    return 0;
}

第二题：（贪心）

#include<bits/stdc++.h>
using namespace std;

#define debug puts("YES");
#define rep(x,y,z) for(int (x)=(y);(x)<(z);(x)++)
#define ll long long

#define lrt int l,int r,int rt
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define root l,r,rt
#define mst(a,b) memset((a),(b),sizeof(a))
#define pii pair<ll,ll>
#define mk(x,y) make_pair(x,y)
const int maxn=1e5+9;
const int mod=998244353;
const int ub=1e6;
ll powmod(ll x,ll y){ll t; for(t=1;y;y>>=1,x=x*x%mod) if(y&1) t=t*x%mod; return t;}
ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
/*
题目大意：给定一个长度为n的序列，要求可以执行m次操作，
每次操作可以把一个人的权值加一，可以删除一个人（如果删除后人数不为空），
但每个人增长的权值最大值为k，问执行操作后其序列平均值是多少。

题目分析：贪心，假设删除了x次，增长了y次，
其删除的肯定是数值最小的，所以把原数组排个序，然后枚举删除的次数即可。
时间复杂度:O(n).
*/

ll a[maxn];
ll sum[maxn];
ll n,k,m;

int main()
{
    cin>>n>>k>>m;
    sum[0]=0LL;
    for(int i=1;i<=n;i++) cin>>a[i];
    sort(a+1,a+n+1);
    rep(i,1,n+1) sum[i]=sum[i-1]+a[i];
    double ans=1.0*sum[n]/n;
    rep(i,0,n) if(i<=m){
        int tm=m-i;
        ans=max(ans,1.0*(sum[n]-sum[i]+1.0*min(1LL*tm,(n-i)*k))/(n-i));
    }
    else break;
    printf("%.7f\n",ans);
    return 0;
}

第三题：（分治）

#include<bits/stdc++.h>
using namespace std;

#define debug puts("YES");
#define rep(x,y,z) for(int (x)=(y);(x)<(z);(x)++)
#define ll long long

#define lrt int l,int r,int rt
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define root l,r,rt
#define mst(a,b) memset((a),(b),sizeof(a))
#define pii pair<ll,ll>
#define mk(x,y) make_pair(x,y)
const int maxn=1e5+8;
const int ub=1e6;
ll A,B;
int n,k;
ll h[maxn];
ll tmp[31];
/*
题目意思不再描述，感觉如果不是空间限制就是个线段树的题目，
但是空间开不了这么大，一种做法是动态开点，
还有一种就是分治处理，分治的样子和线段树差不多，
详见代码。
*/

ll f(int nn,int s,int t,ll add){
    if(nn==0){
         int pos1=lower_bound(h,h+k,h[s])-h;
         int pos2=upper_bound(h,h+k,h[s])-h;
         return 1LL*(pos2-pos1)*B;
    }
    int pos=upper_bound(h+s,h+t,tmp[nn-1]+add)-h-s;///
    ///while(pos+1<t&&h[pos]==h[pos+1]) pos++;
    if(pos==t-s){
        ll val=f(nn-1,s,t,add)+A;
        val=min(val,1LL*(t-s)*B*tmp[nn]);
        return val;
    }else if(pos==0){
        ll val=f(nn-1,s,t,add+tmp[nn-1])+A;
        val=min(val,1LL*(t-s)*B*tmp[nn]);
        return val;
    }
    else  return min(1LL*(t-s)*B*tmp[nn],f(nn-1,s,s+pos,add)+f(nn-1,s+pos,t,add+tmp[nn-1]));
}

int main(){
    mst(h,0);
    tmp[0]=1LL;rep(i,1,31) tmp[i]=tmp[i-1]*2LL;
    cin>>n>>k>>A>>B;
    rep(i,0,k)  cin>>h[i];
    sort(h,h+k);///
    if(k==0) cout<<A<<'\n';
    else cout<<f(n,0,k,0LL)<<'\n';
    return 0;
}

第三题：（线段树动态开点）

#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
const int N = 1e5 + 10;

ll n,k,A,B;
map<int,int> mp;

struct Node {
    Node *lson = nullptr;
    Node *rson = nullptr;
    int sum = 0;
} *root;

void update(Node *o,int l,int r,int x) {
    o->sum++;
    if(l == r) return;
    int mid = (l + r) >> 1;
    if(x <= mid) {
        if(!o->lson) o->lson = new Node;
        update(o->lson,l,mid,x);
    } else {
        if(!o->rson) o->rson = new Node;
        update(o->rson,mid + 1,r,x);
    }
}

int query(Node *o,int l,int r,int ql,int qr) {
    if(ql <= l && qr >= r) return o->sum;
    int mid = (l + r) >> 1;
    int res = 0;
    if(ql <= mid && o->lson) res += query(o->lson,l,mid,ql,qr);
    if(qr > mid && o->rson) res += query(o->rson,mid + 1,r,ql,qr);
    return res;
}

ll f(int l,int r) {
    if(l == r) return mp.count(l) ? B * mp[l] : A;
    int cnt = query(root,1,1 << n,l,r);
    if(cnt == 0) return A;
    int mid = (l + r) >> 1;
    int len = r - l + 1;
    ll sum = B * len * cnt;
    return min(f(l,mid) + f(mid + 1,r),sum);
}

int main() {

    cin >> n >> k >> A >> B;
    root = new Node;
    for(int i = 0;i < k;i++) {
        int x;
        cin >> x;
        mp[x]++;
        update(root,1,1 << n,x);
    }
    cout << f(1,1 << n) << endl;
    return 0;
}

第四题（组合数学+退背包DP）：

#include<bits/stdc++.h>
using namespace std;

#define debug puts("YES");
#define rep(x,y,z) for(int (x)=(y);(x)<(z);(x)++)
#define ll long long

#define lrt int l,int r,int rt
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define root l,r,rt
#define mst(a,b) memset((a),(b),sizeof(a))
#define pii pair<int,int>
#define fi first
#define se second
#define mk(x,y) make_pair(x,y)
const int mod=1e9+7;
const int maxn=1e5+5;
const int ub=1e6;
const double inf=1e-4;
ll powmod(ll x,ll y){ll t; for(t=1;y;y>>=1,x=x*x%mod) if(y&1) t=t*x%mod; return t;}
ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
char s[maxn];
int len,cnt[52],q,x,y;
ll dp[maxn],g[maxn],ans[52][52];
int idx(char c){
    if(c<='z'&&c>='a') return c-'a';
    return 26+c-'A';
}
ll fac[maxn],inv[maxn];
void init(){
    fac[0]=1;rep(i,1,maxn) fac[i]=fac[i-1]*i%mod;
    inv[maxn-1]=powmod(fac[maxn-1],mod-2);
    for(int i=maxn-2;i>=0;i--) inv[i]=inv[i+1]*(i+1)%mod;
}
ll C(ll p,ll q){
    return fac[p]*inv[q]%mod*inv[p-q]%mod;
}
void Back(int x){
    rep(k,0,x) g[k]=dp[k];
    rep(k,x,len/2+1) g[k]=(dp[k]-g[k-x]+mod)%mod;
}
int main(){
    init();
    scanf("%s",s);len=strlen(s);///
    rep(i,0,len) cnt[idx(s[i])]++;

    mst(dp,0),mst(g,0),dp[0]=1;
    rep(i,0,52) if(cnt[i]) for(int j=len/2;j>=cnt[i];j--)
        (dp[j]+=dp[j-cnt[i]])%=mod;

    mst(ans,0);///
    rep(i,0,52) rep(j,i,52){
        Back(cnt[i]);
        if(i!=j) rep(k,cnt[j],len/2+1)
            g[k]=(g[k]-g[k-cnt[j]]+mod)%mod;
        ans[i][j]=g[len/2];
    }

    ll xishu=fac[len/2]*fac[len/2]%mod;
    rep(i,0,52) xishu=xishu*inv[cnt[i]]%mod;
    cin>>q;
    rep(i,0,q){
        cin>>x>>y;
        x=idx(s[x-1]),y=idx(s[y-1]);
        ll ret=max(ans[x][y],ans[y][x]);
        ret=ret*2%mod*xishu%mod;
        cout<<ret<<endl;
    }
    return 0;
}

第四题（树状数组+DP+LCA）：

#include<bits/stdc++.h>
using namespace std;
#define rep(x,y,z) for(int (x)=(y);(x)<(z);(x)++)
#define ll long long
#define mst(a,b) memset((a),(b),sizeof(a))
const int mod=1e9+7;
const int maxn=1e5+10;
const int ub=1e6;
const double inf=1e-4;
ll powmod(ll x,ll y){ll t; for(t=1;y;y>>=1,x=x*x%mod) if(y&1) t=t*x%mod; return t;}
ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
/*
题目大意：
给定一棵树，和若干个询问，
k,m,r和k个数，问把这k个点分成至多m组
且每组中的点集没有父节点与子节点的关系，
其方案数有多少种。

题目分析：
这道题我是看了别人的思路才懂的，
果然还是自己太弱了呀。。。
先简化问题，如果根是固定的如何考虑，
那么观察到m的数据范围去考虑DP计数，
dp(i,j)代表i个数分成j组有多少种方案，
转移方程：dp(i,j)=dp(i-1,j-1)+dp(i-1,j)*(j-f[i])，
其中f[i]代表的是i节点对于1根有多少个父节点，
因为这f[i]个父节点肯定安排在不同的集合中，
那么根据DFS序性质，我们可以利用树状数组统计父节点的个数，
但只能对于特定的根，如果根变换呢？
考虑路径差，特定的点其到特定的根的路径上的权重，
即树上任意两点之间路径的权值和，我们利用LCA来辅助转换。
所以就是对于每个查询，我们不难统计出每个点的f[i],这样状态转移方程的
条件就有了。
我的想法是直接按DFS再搜一遍，遇到其k个点之一就刷新状态数组，
但是我看的这位博主另有想法，它直接把f数组排序然后对这个数组进行DP了，
DP的性质是无后效性，而子节点不会比父节点的f值来的大，所以对于
任意一个互斥对都满足了更新顺序。

最后一些细节就是滚动数组，还有DP数组开int再类型转换取模优化下，
我开long long被T了。
*/
int n,q,x,y;
///前式链向星
vector<int> g[maxn];
int pl[maxn],pr[maxn],bit[maxn],tot;///深度
inline void refresh(int x,int d){
    for(;x<maxn;bit[x]+=d,x+=x&-x);
}
inline int sum(int x){
    int ret=0;for(;x;ret+=bit[x],x-=x&-x);return ret;
}
int st[maxn][20],dep[maxn];
inline void dfs(int u,int pre){
    pl[u]=++tot;
    dep[u]=dep[pre]+1;
    st[u][0]=pre;rep(i,1,20) st[u][i]=st[st[u][i-1]][i-1];
    for(int i=0;i<g[u].size();i++){
        int v=g[u][i];
        if(v==pre) continue;
        dfs(v,u);
    }
    pr[u]=tot;
}
inline int lca(int u,int v){
    if(u==v) return u;
    if(dep[u]<dep[v]) swap(u,v);
    for(int i=19;i>=0;i--) if(dep[st[u][i]]>=dep[v])
        u=st[u][i];
    if(u==v) return u;
    for(int i=19;i>=0;i--) if(st[u][i]!=st[v][i])
        u=st[u][i],v=st[v][i];
    return st[u][0];
}
int dp[maxn];
int k,m,r,a[maxn],f[maxn],vis[maxn];
int main(){
    scanf("%d%d",&n,&q);
    rep(i,0,n-1){
        scanf("%d%d",&x,&y);
        g[x].push_back(y);
        g[y].push_back(x);
    }
    tot=0;dfs(1,0);
    rep(i,0,q){
        scanf("%d%d%d",&k,&m,&r);
        rep(i,1,k+1){
            scanf("%d",&a[i]);
            vis[a[i]]=1;
            refresh(pl[a[i]],1);
            refresh(pr[a[i]]+1,-1);
        }
        int tmp=sum(pl[r]);
        rep(i,1,k+1){
            int LCA=lca(r,a[i]);
            f[i]=sum(pl[a[i]])+tmp-2*sum(pl[LCA])+vis[LCA]-1;///减去自己
        }
        rep(i,1,k+1){
            vis[a[i]]=0;
            refresh(pl[a[i]],-1);
            refresh(pr[a[i]]+1,1);
        }
        if(f[k]>=m) {puts("0");continue;}
        sort(f+1,f+1+k);
        mst(dp,0),dp[0]=1;
        rep(i,1,k+1) for(int j=min(i,m);j>=0;j--){
            if(j<=f[i]) dp[j]=0;
            else dp[j]=((ll)dp[j-1]+(ll)dp[j]*(j-f[i])%mod)%mod;
        }
        ll ans=0;rep(i,1,m+1) (ans+=dp[i])%=mod;
        printf("%lld\n",ans);
    }
    return 0;
}