qbxt国庆水题记day2

qbxt国庆水题记

day2

---

//100 + 0 + 0 = 100
//除了超水题以外其他的都不会

---

Problem 1. video

Input file: video.in
Output file: video.out
Time limit: 1s
Memory limit: 256M
pluto 喜欢看片，现在他的硬盘里有 n 部片，但是由于他还要把妹，所以看片时间有限，他只能挑出
其中的 k 部片来看，他想知道有多少种不同的选片方案。方案数可能很大，答案 mod 1000000007 输出。
Input
输入文件第一行一个整数 N, 表示这个星球上的总人口。
接下来 N 行，每行一个正整数，表示每个居民的姓名。
Output
输出文件一行一个整数，表示这个星球的价值。
Example
video.in
6 2
video.out
15
Scoring
• 对于 30% 的数据，n ≤10
• 对于 60% 的数据，n ≤3000
• 对于 100% 的数据，n ≤2 ×105

排列组合
根据公式求阶乘，在求下逆元即可

代码

#include<iostream>#include<cstdio>using namespace std;#define ll long longconst int inf = 1000000007;int n,m;ll p,q;void exgcd(ll a,ll b,ll &d,ll &x,ll &y) {    if(!b) {d = a, x = 1, y = 0;return;}    exgcd(b,a%b,d,y,x);    y -= x * (a / b);}ll inv(ll a, ll b) {    ll d,x,y;    exgcd(a,b,d,x,y);    return (x % b + b) % b;}int main() {    freopen("video.in","r",stdin);    freopen("video.out","w",stdout);    cin>>n>>m;    m = min(m, n-m);    p = 1, q = 1;    for(int i = 1; i <= m; i++) p = (p * i) % inf;    q = inv(p,inf);    for(int i = n; i >= n - m + 1; i--) q = (q * i) % inf;    cout<<q<<endl;    return 0;}

---

Problem 2. chance

Input file: chance.in
Output file: chance.out
Time limit: 1s
Memory limit: 256M
pluto 去找妹子 ×××约会，然后×××要求和 pluto 玩一个游戏，pluto 赢了才能获得和 ×××
约会的机会。游戏内容为：现在有 N 个袋子 (你可以认为它是哆啦 A 梦的口袋，每个袋里面放着一些
，所以容量十分大，第 i 个袋里面放着编号为 Li 到 Ri 的球 (除编号外完全相同)，pluto 需要从每个
袋里面摸出一个球，第 i 个袋子任何一个球被摸到的概率是 1/(Ri −Li + 1)，如果 pluto 摸出的球中
有 K% 或以上的球的编号的第一位是 1(比如 11,121,199 的第一位是 1, 而 21,233 第一位就不是 1)，那
么 pluto 就将赢得与 ×××约会的机会。现在 pluto 想知道他能人生中第一次与妹子约会的概率有多大。
Input
第一行两个整数 N, K
接下来 N 行，每个两个整数，Li 和 Ri
Output
一行一个实数（保留 7 位⼩数）表示答案
绝对误差不超过 10−6 即视为正确
Example
chance.in
2 50
1 2
9 11
chance.out
0.833333333333333

Scoring
• 对于 100% 的数据，0 ≤k ≤100，0 < Li ≤Ri
• 对于 30% 的数据，n ≤10，Li ≤Ri ≤100
• 对于 60% 的数据，n ≤500，Li ≤Ri ≤2000
• 对于 100% 的数据，n ≤2000，Li ≤Ri ≤1018

首先判断出每个袋子里拿到第一个数字为1的球的概率为pi(很巧妙的判断见”pd()”)
dp[i][j] 表示前i个袋子里取到了j个第一个数字为1的球的概率
dp[i][j] = dp[i - 1][j - 1] * pi + dp[i - 1][j] * (1 - pi)
然后根据K%求出至少要多少人，相加即可

//为什么这么多dp
//啊啊啊啊啊

代码

#include<iostream>#include<cstdio>#include<cmath>using namespace std;const int maxn = 2000 + 100;int n;long long l,r;double k,pi[maxn],f[maxn][maxn];long long pd(long long x) {    long long num = 1,sum = 1;    if(!x) return 0;    for(int i = 2; i <= 20; i++) {        num *= 10;        if(num > x) return sum;        if(num * 2 > x) return sum + x - num + 1;        sum += num;    }}int pp(double p) {    if(p - (int)p == 0) return (int)p;    else{         return (int)(p + 1);    }}int main() {    freopen("chance.in","r",stdin);    freopen("chance.out","w",stdout);    cin>>n>>k;    for(int i = 1; i <= n; i++) {        scanf("%lld%lld",&l,&r);        pi[i] = (double)(pd(r) - pd(l-1)) / (double)(r - l + 1);    }    f[0][0] = 1;    for(int i = 1; i <= n; i++) {        for(int j = 0; j <= i; j++) {            f[i][j] += f[i-1][j] * (1 - pi[i]);            if(j) f[i][j] += f[i-1][j-1] * pi[i];        }    }    k /= 100;    int t = pp(n*k);    double ans = 0;    for(int i = t; i <= n; i++) {        ans += f[n][i];    }     printf("%.7f\n",ans);    return 0;}

---

Problem 3. plutotree

Input file: plutotree.in
Output file: plutotree.out
Time limit: 2s
Memory limit: 256M
有一棵 n 个节点的树，节点编号为 1 到 n，i 号节点的权值为 Wi。这棵树有些奇怪，它的每一个
叶子节点都是根节点的夫亲 (表示每个叶子节点与根节点之间有一条边权为 0 的边)。我们称这样的树为
pluto 树，根节点编号为 1。我们需要最小化从 u 到 v 的路径 (每条边只能经过一次) 上的节点权值之和，
并且在最小化节点权值之和的同时求这个路径上可能的最大权值。
Input
第一行两个整数 n 和 q，n 表示节点个数，q 表示询问个数。
第二行 n −1 个整数 Ai，表示 i + 1 号节点的夫亲为 Ai
第三行 n 个整数 Wi 表示 i 号节点的权值为 Wi
接下来 q 行，每行两个整数 u，v，表示一组询问
Output
对于每组询问输出两个整数 x, y
x 表⽰ u 到 v 的权值和最小的路径的权值和，y 表⽰这条路径上点权最大值。如果有多个相同权值
和的路径，输出那个点权最大值最大的。
Example
plutotree.in
5 1
1 2 3 4
413 127 263 869 960
1 5
plutotree.out
1373 960

Scoring
• 对于 30% 的数据，n ≤300，q ≤1000
• 对于 50% 的数据，n ≤2000，q ≤10000
• 对于 100% 的数据，n ≤100000，q ≤100000

//树上dp
//不会，暴力也不会打

来自题解
30% 把图建建出来 floyd
60% 把floyd换成spfa或者dijkstra
100% 树形dp
首先答案可能有三种情况：
1.不走叶子到根的边， 那就是一个简单的树上的问题， 两点之间有且仅有一条路径，树上倍增一下就可以把两个问题都解决， 或者闲着蛋疼的可以用树剖

2.从u走到叶子，从叶子到根，从根到v （这种情况要把u、v调换再做一次）
3.从u走到叶子，从叶子到根，从根到另一个叶子节点，再从叶子节点到v

对于第二种、三种情况， 其实关键在于求出每个点到离他最近的叶子的路径，这样的路径有两种可能，一种是向下下走到叶子， 一种是先向上（有可能经过根也可能不经过）走，最终到达叶子
首先树形dp出每个节点向下到离它最近的叶子节点的距离，并同时记录这个路径上的最大值，设为down[i], (down[i]为二元组，<路径权值和， 路径上最大权值>) down[i] 可以从 i号节点的所有儿子转移过来， 转移方程很显然
有了down[i], 就可以dp出我们需要的每个点到最近的叶子节点的路径了，将这个记为dp[i], dp[i]同样是一个二元组，和down[i]一样。 首先dp[1]我们是知道的，就是从根直接走到某一个叶子节点， 其余的dp[i]初值都是down[i], dp[i]可以从i号节点的父亲转移过来，所以这是一个自上而下的dp

考虑到可能爆栈的情况， 建议使用bfs处理树形dp

具体状态如何转移可以参考std

代码std

#include <iostream>#include <cstdio>#include <cstring>#include <algorithm>#include <vector>using namespace std;const int N = 111111;const int inf = 1 << 20;int fa[N][20], n, m, maximum[N][20], leaf[N], weight[N];int dist[N],dep[N];pair<int, int> dp[N], down[N];vector<int> adj[N];void update(pair<int, int> &x, pair<int, int> y) {    if (x.first != y.first) {        x = min(x, y);    } else {        x = max(x, y);    }}void build() {    vector<int> queue;    queue.push_back(1);    fa[1][0] = 0;    dep[1] = 1;    dist[1] = weight[1];    for (int head = 0; head < (int)queue.size(); head++) {        int now = queue[head];        for (int i = 0; i < (int)adj[now].size(); i++) {            queue.push_back(adj[now][i]);            dep[adj[now][i]] = dep[now] + 1;            dist[adj[now][i]] = dist[now] + weight[adj[now][i]];        }    }    for (int j = 1; j <= 18; j++) {        for (int i = 1; i <= n; i++) {            fa[i][j] = fa[fa[i][j - 1]][j - 1];            maximum[i][j] = max(maximum[i][j - 1], maximum[fa[i][j - 1]][j - 1]);        }    }    for (int i = (int)queue.size() - 1; i >= 0; i--) {        int x = queue[i];        update(down[fa[x][0]], make_pair(down[x].first + weight[fa[x][0]], max(down[x].second, weight[fa[x][0]])));    }}void DP() {    vector<int> queue;    queue.push_back(1);     update(dp[1], down[1]);    for (int head = 0; head < (int)queue.size(); head++) {        int now = queue[head];        for (int i = 0; i < (int)adj[now].size(); i++) {            int to = adj[now][i];            dp[to] = down[to];            update(dp[to], make_pair(dp[now].first + weight[to], max(weight[to], dp[now].second)));            queue.push_back(to);        }    }}pair<int, int> query(int x, int y) {    if (dep[x] < dep[y]) swap(x, y);    int fx = x, fy = y;    int maxd;    int ret1 = 0, ret2 = 0;    for (maxd = 0; (1 << maxd) <= dep[x]; maxd++);    maxd--;    ret1 = max(maximum[x][0], maximum[y][0]);    for (int i = maxd; i >= 0; i--) {        if (dep[fa[x][i]] >= dep[y]) {            ret1 = max(ret1, maximum[x][i]);            x = fa[x][i];        }    }    ret1 = max(ret1, maximum[x][0]);    ret1 = max(ret1, maximum[y][0]);    if (x == y) {        ret2 = dist[fx] - dist[fy] + weight[fy];         return make_pair(ret1, ret2);    }    for (int i = maxd; i >= 0; i--) {        if (fa[x][i] != 0 && fa[x][i] != fa[y][i]) {            ret1 = max(ret1, maximum[x][i + 1]);            ret1 = max(ret1, maximum[y][i + 1]);            x = fa[x][i];            y = fa[y][i];        }    }    ret1 = max(ret1, maximum[x][0]);    ret1 = max(ret1, maximum[y][0]);    ret1 = max(ret1, maximum[fa[x][0]][0]);    ret2 = dist[fx] + dist[fy] - dist[fa[x][0]] * 2 + weight[fa[x][0]];    return make_pair(ret1, ret2);}void add(int x, int y) {    adj[x].push_back(y);}void solve() {    scanf("%d%d", &n, &m);    for (int i = 1; i <= n; i++) adj[i].clear();    for (int i = 1; i <= n - 1; i++) {        int x;        scanf("%d", &x);        add(x, i + 1);        fa[i + 1][0] = x;    }    for (int i = 1; i <= n; i++) {        if (adj[i].size() == 0) leaf[i] = 1;        else leaf[i] = 0;    }    for (int i = 1; i <= n; i++) {        scanf("%d", &weight[i]);        maximum[i][0] = weight[i];    }    for (int i = 1; i <= n; i++) {        dp[i] = make_pair(inf, 0);        down[i] = make_pair(inf, 0);    }    for (int i = 1; i <= n; i++) {        if (leaf[i]) {            down[i] = make_pair(weight[i], weight[i]);            update(dp[1], make_pair(weight[1] + weight[i], max(weight[1], weight[i])));        }    }    build();        DP();    for (int i = 1; i <= m; i++) {        pair<int, int> tmp, ans;        int u, v;        scanf("%d%d", &u, &v);        tmp = query(u, v);        ans = make_pair(tmp.second, -tmp.first);        tmp = make_pair(dp[u].first + dist[v], -max(dp[u].second, maximum[v][18]));        ans = min(ans, tmp);        tmp = make_pair(dp[v].first + dist[u], -max(dp[v].second, maximum[u][18]));        ans = min(ans, tmp);        tmp = make_pair(dp[u].first + dp[v].first + weight[1], -max(max(dp[u].second, dp[v].second), weight[1]));        ans = min(ans, tmp);        printf("%d %d\n", ans.first, -ans.second);    } }int main() {    freopen("plutotree.in", "r", stdin);    freopen("plutotree.out", "w", stdout);    int tests = 1;    for (int i = 1; i <= tests; i++) {        solve();    }    return 0;}