CF453(Div1 简单题解)

A .Little Pony and Expected Maximum

pro：给定M，N，表示一个M面的骰子，甩N次，问出现的最大的数的期望。

sol：容斥，f(i)表示最大数<=i的期望，那么最大数=x的期望就是f(x)-f(x-1);

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;i++)
using namespace std;
const int maxn=;
double dp[maxn];
double qpow(double a,int x)
{
    double res=1.0;while(x){
        if(x&) res=res*a;
        a=a*a; x>>=;
    } return res;
}
int main()
{
    int M,N; double ans=.;
    scanf("%d%d",&M,&N);
    rep(i,,M) dp[i]=qpow(1.0*i/M,N);
    rep(i,,M) ans+=(dp[i]-dp[i-])*i;
    printf("%.10lf\n",ans);
    return ;
}

B .Little Pony and Harmony Chest

pro：给定数组a[]，求一个两两互质的b[]，使得abs(a[]-b[])最小，输出一个方案。 N<=100，a[]<=30

sol：两两互质，表示之前出现的素因子不能出现，而我们发现>60不可能，因为差值会变很大。 所以我们记录<=60的素数，然后状压DP，记录一下来源，最后倒回去输出即可。

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;i++)
using namespace std;
const int maxn=;
const int maxm=;
int a[maxn],p[maxn],vis[maxn],tot,cnt;
int pre[maxn][maxm],now[maxn][maxm],dp[maxn][maxm],fac[maxn];
vector<int>G[maxm];
void dfs(int pos,int Now)
{
    if(pos==) return ;
    dfs(pos-,pre[pos][Now]);
    printf("%d ",now[pos][Now]);
}
int main()
{
    int N,M,ans=,P;
    memset(dp,0x3f,sizeof(dp)); dp[][]=;
    rep(i,,) {
        if(!vis[i]){
            p[tot++]=i;
            for(int j=i+i;j<=;j+=i) vis[j]=;
        }
    }
    rep(i,,){
        rep(j,,tot-){
            if(i%p[j]==){
                fac[i]|=(<<j);
            }
        }
    }
    M=(<<tot)-;
    rep(i,,M) rep(j,,)
      if(!(fac[j]&i)) G[i].push_back(j),cnt++;
    scanf("%d",&N);
    rep(i,,N) scanf("%d",&a[i]);
    rep(i,,N){
        rep(j,,M) {
            for(int k=;k<G[j].size();k++){
                int v=G[j][k];
                if(dp[i][j|fac[v]]>dp[i-][j]+abs(a[i]-v)){
                    dp[i][j|fac[v]]=dp[i-][j]+abs(a[i]-v);
                    pre[i][j|fac[v]]=j;
                    now[i][j|fac[v]]=v;
                }
            }
        }
    }
    rep(i,,M) if(dp[N][i]<ans) ans=dp[N][i],P=i;
    dfs(N,P);
    return ;
}

C .Little Pony and Summer Sun Celebration

pro：给定N点M边的无向图（不一定连通），然后给没给点限制一个0或1，表示经过点的奇偶，让你找一条路径，满足路径长度<=N*4，而且满足奇偶要求。

sol：我们DFS，如果儿子的奇偶性未满足，满足我们再走一遍（fa->son->fa）即可，发现一定可以构造好。。。然后就是要求的奇数的点一定要连通。

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;i++)
using namespace std;
const int maxn=;
int Laxt[maxn],Next[maxn],To[maxn],d[maxn],cnt;
int a[maxn],b[maxn],tot,vis[maxn],t[maxn],F=;
void add(int u,int v)
{
    Next[++cnt]=Laxt[u]; Laxt[u]=cnt; To[cnt]=v;
}
void dfs(int u,int f)
{
    vis[u]=; t[u]^=;
    for(int i=Laxt[u];i;i=Next[i]){
        int v=To[i];
        if(v!=f&&!vis[v]){
            tot++; a[tot]=u; b[tot]=v;
            dfs(v,u);
            tot++; a[tot]=v; b[tot]=u; t[u]^=;
            if(d[v]!=t[v]){
                tot++; a[tot]=u; b[tot]=v; t[v]^=;
                tot++; a[tot]=v; b[tot]=u; t[u]^=;
            }
        }
    }
}
int main()
{
    int N,M,u,v,root=-;
    scanf("%d%d",&N,&M);
    rep(i,,M){
        scanf("%d%d",&u,&v);
        add(u,v); add(v,u);
    }
    rep(i,,N) scanf("%d",&d[i]);
    rep(i,,N) if(d[i]==) root=i;
    if(root==-) return puts(""),;// root=1;
    dfs(root,);
    rep(i,,N) if(!vis[i]&&d[i]==) F=;
    if(!F) return puts("-1"),;
    if(t[root]!=d[root]) tot--;
    printf("%d\n",tot+);
    printf("%d ",root);
    rep(i,,tot) printf("%d ",b[i]);
    return ;
}

D .Little Pony and Elements of Harmony

FWT，不会，占位。

E .Little Pony and Lord Tirek

题意：N个马，给定了开始的能量值s[]，以及能力上限m[]，以及单位时间的能力上升值r[]。Q次操作，每次给出[L,R]，吸走这个区间的马的能力和sum，求sum，马的能力被吸走后变为0。

思路：想不到线段树就可以做。。。。tql ，注意r可能为0，不要除0，免得RE。

主要一点就是，区间更新，区间时间一样了，我们就可以均摊复杂度了，即tag相同的区间利用预处理，不同的继续下推。

我们先预处理，把每个节点按照达到上限的时间排序，然后得到前缀和，用前缀和来快速得到，这个区间给定时间差后的sum。

时间复杂度O(N(logN)^2)，空间O(NlogN);

#include<bits/stdc++.h>
#define ll long long
#define rep(i,a,b) for(int i=a;i<=b;i++)
using namespace std;
const int maxn=;
const int inf=2e9;
int s[maxn],m[maxn],r[maxn],t[maxn],vis[maxn<<];
int T[][maxn]; ll pre[][maxn],v[][maxn];
struct in{
    int m,r,t;
    in(){}
    in(int mm,int rr,int tt):m(mm),r(rr),t(tt){}
    bool friend operator<(in w,in v){
        return w.t<v.t;
    }
}fcy[maxn];
void build(int dep,int Now,int L,int R)
{
    rep(i,L,R) fcy[i]=in(m[i],r[i],t[i]);
    sort(fcy+L,fcy+R+);
    rep(i,L,R){
        T[dep][i]=fcy[i].t;
        pre[dep][i]=fcy[i].m;
        v[dep][i]=fcy[i].r;
        if(i>L){
            pre[dep][i]+=pre[dep][i-];//满的部分前缀和
            v[dep][i]+=v[dep][i-]; //速度前缀和
        }
    }
    if(L==R){ vis[Now]=; return; }
    vis[Now]=-; int Mid=(L+R)>>;
    build(dep+,Now<<,L,Mid);
    build(dep+,Now<<|,Mid+,R);
}
ll query(int dep,int Now,int L,int R,int ql,int qr,int times)
{
    if(vis[Now]==){
        vis[Now]=times;
        if(s[L]+1LL*times*r[L]>=m[L]) return 1LL*m[L];
        return 1LL*s[L]+times*r[L];
    }
    if(ql<=L&&qr>=R&&vis[Now]>){
        int p=upper_bound(T[dep]+L,T[dep]+R+,times-vis[Now])-T[dep]; p--;
        ll res=((p>=L)?pre[dep][p]:); //满的
        res+=(v[dep][R]-((p>=L)?v[dep][p]:))*(times-vis[Now]); //未满
        vis[Now]=times;
        return res;
    }
    if(vis[Now]>=) vis[Now<<]=vis[Now<<|]=vis[Now];
    int Mid=(L+R)>>; ll res=;
    if(ql<=Mid) res+=query(dep+,Now<<,L,Mid,ql,qr,times);
    if(qr>Mid) res+=query(dep+,Now<<|,Mid+,R,ql,qr,times);
    if(vis[Now<<]==vis[Now<<|])
       vis[Now]=vis[Now<<]; else vis[Now]=-;
    return res;
}
int main()
{
    int N,M,ts,L,R;
    scanf("%d",&N);
    rep(i,,N){
        scanf("%d%d%d",&s[i],&m[i],&r[i]);
        if(!r[i]) t[i]=inf;
        else t[i]=m[i]/r[i]+(m[i]%r[i]?:);
    }
    build(,,,N);
    scanf("%d",&M);
    rep(i,,M){
        scanf("%d%d%d",&ts,&L,&R);
        ll ans=query(,,,N,L,R,ts);
        printf("%lld\n",ans);
    }
    return ;
}