HGOI 20190708 题解

Problem A 拿出勇气吧

幸运数字每一位是$4$或者$7$，现在给出一个数字每位数位上数的和为n，求出最小的幸运数n

对于100%的数据，$n\leq 10^6$

Sol : 显然本题要求数的长度尽可能短，于是显然是先放$7$放$4$并且$7$放在较低位。

这就等价于求不定方程$4x + 7y = n $的最小整数解x，然后只要延续输出x个4，y个7即可。

只需要做一次exgcd就可以求出。

复杂度应该是答案的长度 $O(length)$

# include <bits/stdc++.h>
# define int long long
using namespace std;
struct node {
    int x,y; bool flag;
};
int exgcd(int a,int b,int &x,int &y)
{
    if (b==) {
        x=;y=;
        return a;
    }
    int g=exgcd(b,a%b,x,y);
    int t=x;x=y;y=t-a/b*x;
    return g;
}
node getmin(int a,int b,int c)
{
    int x,y; int g=exgcd(a,b,x,y);
    if (c%g!=) return (node){-,-,false};
    int k=c/g,ga=a/g,gb=b/g;
    x=(x*k%gb+gb)%gb;
    y=(c-a*x)/b;
    return (node){x,y,true};
}
signed main()
{
    int n;scanf("%d",&n);
    node t=getmin(,,n);
    for (int i=;i<=t.x;i++) printf("");
    for (int i=;i<=t.y;i++) printf("");
    return ;
}

Courage.cpp

Problem B 生死之对决

幸运数字每一位是$4$或者$7$，给出$ p \in [pl,pr] \in Z,v \in [vl,vr] \in Z $ 且$p,v$ 在所属区间等概率出现。

求出区间$[min\{v,p\} , max \{v,p\}]$包含幸运数字恰好是$k$个的概率。

对于100%的数据$1 \leq ql \leq qr \leq 10^9,1 \leq vl \leq vr \leq 10^9,1 \leq k \leq 10^3 $

Sol :首先在$[1,10^9]$的幸运数字是$2^1 + 2^2 + ... + 2^9 = 1022$个，所以我们可以基于枚举每一个幸运数字对答案造成的贡献（用乘法原理）来进行计数。

设排序后的幸运数字为$p_i (1\leq i \leq 1022)$ 那么我们枚举第$p_i $到$p_{i+k-1}$这$k$个幸运数字在$[min\{v,p\} , max\{v,p\}]$区间内。

所以有$min\{p,v\} \in [p_{i-1} +1 , p_i] ,max\{p,v\} \in [p_{i+k-1},p_{i+k}-1]$

为了拆掉$min,max$所以我们要讨论$p,v$的大小关系。

当$p \leq v$ 时显然有 $p \in  [p_{i-1} +1 , p_i]  , v \in  [p_{i+k-1},p_{i+k}-1] $

当$p \geq v$ 时显然有 $v \in [p_{i-1} +1 , p_i] , p \in [p_{i+k-1},p_{i+k}-1]  $

注意到上述我们在$p = v $的时候可能会重复计算，而且当且仅当$ k = 1$的时候出现，所以需要特判。

# pragma GCC optimize()
# include <bits/stdc++.h>
# define int long long
using namespace std;
const int N=2e3+;
int p[N];
int n;
void getlucky(int num,int lim)
{
    if (num>lim) return;
    if (num!=) p[++n]=num;
    getlucky(num*+,lim);
    getlucky(num*+,lim);
}
signed main()
{
    getlucky(,2e9); int pl,pr,vl,vr,k;
    scanf("%lld%lld%lld%lld%lld",&pl,&pr,&vl,&vr,&k);
    sort(p+,p++n);
    p[n+]=2e9+; int ans=;
    for (int i=;i<=n;i++) {
        if (min(p[i],pr)-max(p[i-]+,pl)+>=&&min(p[i+k]-,vr)-max(p[i+k-],vl)+>=) {
            ans+=(min(p[i],pr)-max(p[i-]+,pl)+)*(min(p[i+k]-,vr)-max(p[i+k-],vl)+);
        }
        if (min(p[i+k]-,pr)-max(p[i+k-],pl)+>=&&min(p[i],vr)-max(p[i-]+,vl)+>=) {
            ans+=(min(p[i+k]-,pr)-max(p[i+k-],pl)+)*(min(p[i],vr)-max(p[i-]+,vl)+);
        }
    }
    if (k==) {
        for (int i=;i<=n;i++)
         if (p[i]>=vl&&p[i]<=vr&&p[i]>=pl&&p[i]<=pr) ans--;
    }
    printf("%.12lf\n",(double)ans/(double)(vr-vl+)/(double)(pr-pl+));
    return ;
}

Match.cpp

Problem C 最后的结局

一棵树上的点和父亲之间可能是存在魔法边和普通边，定义合法三元组$(i,j,k)$表示从$i$出发到$j$路径上和$i$出发到$k$路径上都至少存在一条魔法边。

注意到不同的$(i,j,k)$都算不同的合法三元组。计算这棵树中合法三元组的数目。

对于100%的数据 $ 1 \leq n \leq 10^5 $

Sol : 直接树形DP即可，设$f_u$ 表示节点 $u$ 跑到所有节点的路径中含有魔法边的节点个数。

第一次跑dfs从儿子更新到父亲，转移方程是 $f_{u}= \sum\limits_{v \in u_{son}} \left\{\begin{matrix} size_{v}&(u,v) \ is \ magic \ edge  \\  f_{v}&  (u,v) \ isn't \ magic \ edge  \end{matrix}\right.$

第二次跑dfs从父亲更新到儿子，转移方程是$f_v = \left\{\begin{matrix} f_u & (u,v)\  isn't \ magic \ edge\\  n-size_v & (u,v) \ is \ magic \ edge \end{matrix}\right.$

　　复杂度$O(n)$

# pragma GCC optimize()
# include<bits/stdc++.h>
# define int long long
using namespace std;
const int N=1e5+;
struct rec{
    int pre,to,w;
}a[N<<];
int f[N],tot,head[N],size[N],n;
bool check(int x) {
    while (x) {
        if (!(x%==||x%==)) return false;
        x/=;
    }
    return true;
}
void adde(int u,int v,int w)
{
    a[++tot].pre=head[u];
    a[tot].to=v;
    a[tot].w=w;
    head[u]=tot;
}
void dfs1(int u,int fa)
{
    size[u]=; f[u]=;
    for (int i=head[u];i;i=a[i].pre) {
        int v=a[i].to; if (v==fa) continue;
        dfs1(v,u);  size[u]+=size[v];
        if (a[i].w==) f[u]+=size[v];
        else f[u]+=f[v];
    }
}
void dfs2(int u,int fa)
{
    for (int i=head[u];i;i=a[i].pre) {
        int v=a[i].to; if (v==fa) continue;
        if (a[i].w==) f[v]+=n-size[v];
        else f[v]=f[u];
        dfs2(v,u);
    }
}
signed main()
{
//  freopen("ending.in","r",stdin);
//  freopen("ending.out","w",stdout);
    scanf("%lld",&n);
    for (int i=;i<n;i++) {
        int u,v,w; scanf("%lld%lld%lld",&u,&v,&w);
        if (check(w)) adde(u,v,),adde(v,u,);
        else adde(u,v,),adde(v,u,);
    }
    dfs1(,); dfs2(,);
    int ans=;
    for (int i=;i<=n;i++) ans+=(long long)f[i]*(f[i]-);
    printf("%lld\n",ans);
    return ;
 }

Ending.cpp