EOJ 2月月赛补题

bok_choy_

于 2021-02-09 14:54:15 发布

阅读量176

点赞数

本文链接：https://blog.csdn.net/bok_choy_/article/details/113770600

版权

文章目录

EOJ 2月月赛补题

EOJ 2月月赛补题

~~总之就是非常爆炸~~

A-昔我往矣

题意： 现在有一棵树，每条边有边权，并且给你 $5$ 个点 $a, b, c, d, e$ 。如果从任一点出发能到达其它所有的点，求最小的边权和。

思路： 很明显，是个 $L C A$ 。~~但是当时不会做~~。看了题解后才明白。五个点的公共祖先就是 $d f s$ 序最大和最小的两个点的的 $L C A$ 。至于为什么呢？，按我的理解就是：在用 $d f s + R M Q$ 求 $L C A$ 时，求得是这两个点的dfs序之间深度最小的节点，而这里多个点时，就是找这五个点形成的最大的 $d f s$ 区间中深度最小的点。

但是我写的时候是用倍增写的。~~顺带发现我那个常数优化过的倍增求LCA的板子好像裂了…这两天就去补~~ 。

先将 $d f s$ 序最大和最小的点的最短距离加起来，然后对剩下的点，分别与已经加上的点求 $L C A$ ，找到深度最深的点，就能得到多出来的那一部分链的权值。直到全部加完。

代码：

#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<stack>
#include<cmath>
#include<map>
#include<cstring>
#include<string>
#include<algorithm>
#define fi first
#define se second
//#include<stdlib.h>
//#include <time.h>
//srand((unsigned)time(NULL));
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int INF = 0x3f3f3f3f;
using namespace std;
const int N = 1e6 + 10;
int n, m, root;
struct edge{
    int u, v;
    int cost;
    edge() {}
    edge(int _u, int _v, int _c) {
        u = _u; v = _v;
        cost = _c;
    }
};
vector<edge> G[N];
int fa[N][32], dep[N], lg[N]; //这里的lg是二进制位数
int L[N], R[N], dfsn[N]; //dfs序
int dis[N]; //节点i到根节点的距离
int dfs_cnt = 0;
void add_edge(int u, int v, int c) {
    G[u].push_back(edge(u, v, c));
    G[v].push_back(edge(v, u, c));
}
//void init(int _n) {
//    dep[0] = 0; dis[0] = 0;
//    dfs_cnt = 0;
//    for (int i = 0; i <= _n; i++)
//        G[i].clear();
//
//    lg[0] = 0;
//    for (int i = 1; i <= 20; i++)
//        lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
//}
void dfs(int u, int last) {
    fa[u][0] = last;
    dep[u] = dep[last] + 1; //计算深度
    L[u] = ++dfs_cnt; //dfs序
    dfsn[dfs_cnt] = u;
    for (int i = 1; i < 32; i++)
        fa[u][i] = fa[fa[u][i - 1]][i - 1];
    for (int i = 0; i < (int)G[u].size(); i++) {
        int v = G[u][i].v;
        if (v == last) continue;
        dis[v] = dis[u] + G[u][i].cost;
        dfs(v, u);
    }
    R[u] = dfs_cnt;
}
int lca(int x, int y) {
    if (dep[x] < dep[y]) swap(x, y);
//    while (dep[x] > dep[y])
//        x = fa[x][lg[dep[x] - dep[y]] - 1];
    for (int i = 31; i >= 0; i--)
        if (dep[fa[x][i]] >= dep[y]) x = fa[x][i];

    if (x == y) return x;

    for (int i = 31; i >= 0; i--)
        if (fa[x][i] != fa[y][i])
            x = fa[x][i], y = fa[y][i];
    return fa[x][0];
}
bool cmp(int x, int y) {
    return L[x] < L[y];
}
int main() {
    scanf("%d", &n);
    for (int i = 1; i < n; i++) {
        int u, v, c;
        scanf("%d%d%d", &u, &v, &c);
        u++, v++;
        add_edge(u, v, c);
    }
    dfs(1, 0);
    int q;
    scanf("%d", &q);
    while (q--) {
        vector<int> p;
        for (int i = 0; i < 5; i++) {
            int x; scanf("%d", &x); x++;
            p.push_back(x);
        }
        sort(p.begin(), p.end(), cmp);
//        for (int i = 0; i < 5; i++)
//            cout << dis[p[i]] << " ";
//        cout << "\n";
        int xp = lca(p[0], p[4]); //5个点的lca
        int ans = dis[p[0]] + dis[p[4]] - 2 * dis[xp];
        vector<int> now;
        now.push_back(p[0]);
        now.push_back(p[4]);
        for (int i = 1; i < 4; i++) {
            int dot = 0;
            for (int j = 0; j < (int)now.size(); j++) {
                int nx = lca(p[i], now[j]);
                if (dot == 0 || dep[nx] > dep[dot])
                    dot = nx;
            }
            ans += dis[p[i]] - dis[dot];
            now.push_back(p[i]);
        }
        printf("%d\n", ans);
    }
    return 0;
}

/*
6
4 0 4
0 1 2
1 3 9
3 5 1
3 2 5
*/

B-杨柳依依

题意： 已知一个图，图上有 $k$ 个人，每个人从点 $a_i$ 到点 $b_i$ 。并且每次必定是走最短路径，若有多条最短路径，等概率选择一条。定义 $E_i(w)$ 表示第 $i$ 个人经过 $w$ 的概率，现在要求出 $\sum_{i=0}^{k-1}E(w)$ 最大的点 $w$ 。

思路： 对于每一对起点和终点都 $b f s$ 一次，求出最短路长度以及个数。然后对于图上每一个点 $p$ ，判断起点到点 $p$ 的距离加上终点到点 $p$ 的概率是否与起点到终点距离相等，若相等，就说明这个点在最短路径上，然后这个点的总概率加上 $\frac{\text{起点到点p的最短路径数} \times \text{终点到点p的最短路径数}}{\text{起点到终点的最短路径数}}$

最后遍历一遍所有点，找到最大的点就是答案。

代码：

#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<stack>
#include<cmath>
#include<map>
#include<cstring>
#include<string>
#include<algorithm>
#define fi first
#define se second
//#include<stdlib.h>
//#include <time.h>
//srand((unsigned)time(NULL));
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int INF = 0x3f3f3f3f;
using namespace std;
const int N = 2e5 + 10;
const int M = 2e5 + 10;
typedef pair<int, int> pii;
int cnt[2][N], d[2][N];
int n, m;
vector<int> G[N];
void add_edge(int u, int v) {
    G[u].push_back(v);
    G[v].push_back(u);
}
void bfs(int s, int t, int cnt[], int d[]) {
    for (int i = 0; i <= n; i++) {
        cnt[i] = 0;
        d[i] = INF;
    }
    d[s] = 0; cnt[s] = 1;
    queue<pii> q;
    q.push({0, s});
    while (q.size()) {
        pii now = q.front(); q.pop();
        int dd = now.first, u = now.second;
        if (dd > d[u]) continue;
        for (int v : G[u]) {
            if (d[v] > d[u] + 1) { //更新最短路
                d[v] = d[u] + 1;
                cnt[v] = cnt[u];
                q.push({d[v], v});
            }
            else if (d[v] == d[u] + 1) {
                cnt[v] += cnt[u];
            }
        }
    }
}
double E[N];
int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= m; i++) {
        int u, v;
        scanf("%d%d", &u, &v);
        add_edge(u, v);
    }
    int k;
    scanf("%d", &k);
    while (k--) {
        int a, b;
        scanf("%d%d", &a, &b);
        bfs(a, b, cnt[0], d[0]); //起点到终点
        bfs(b, a, cnt[1], d[1]); //终点到起点
        if (d[0][b] == INF) continue;
        for (int i = 0; i < n; i++) {
            if (d[0][i] + d[1][i] == d[0][b])
                E[i] += 1.0 * cnt[0][i] * cnt[1][i] / cnt[0][b];
        }
    }
    double mmax = -INF;
    int pos = -1;
    for (int i = 0; i < n; i++) {
        if (E[i] > mmax) {
            mmax = E[i];
            pos = i;
        }
    }
    printf("%d\n", pos);
    return 0;
}

C-今我来思（sì）

题意： 原本有一个 $0$ 到 $n - 1$ 的全排列，但是现在你不知道，你可以多次询问一段区间的最小值，判断是否有符合这样条件的排列，若有多种，只需要输出一种即可。

思路：

一开始我想用线段树来得到所有位置的下界，然后先按下界从大到小排序，将每一段下界相同的位置选一个置为该下界，然后从大到小将剩下的数填入空处。最后判断一下每一个数是否符合下界。然鹅，这个思路只过了两个点，~~痛苦面具~~ 应该是后面的构造有问题。

现在来讲一个正确的解法：先将询问中所有对某个 $x$ 的限制区间进行分类，然后从大到小，若该数 $x$ 无区间限制，就将它先存起来，继续下一个数；否则，将该数 $x$ 的所有区间的交集求出来（用了一下差分），在该区间找一个未确定的位置，赋为当前的数，然后区间中剩下的位置因为最小是当前的数 $x$ ，一次必须要用比 $x$ 大的数来赋值，因此要用到之前没有区间限制的数来赋值。若无法将交集区间全部填满，就说明不存在。

#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<stack>
#include<cmath>
#include<map>
#include<cstring>
#include<string>
#include<algorithm>
#include<iomanip>
#define fi first
#define se second
//#include<stdlib.h>
//#include <time.h>
//srand((unsigned)time(NULL));
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int INF = 0x3f3f3f3f;
using namespace std;
const double eps = 1e-7;
const int N = 2e5 + 10;

struct node{
    int l, r;
    node() {}
    node(int _l, int _r) {
        l = _l; r = _r;
    }
}a[N];
int have[N];
int top = 0;
int f[N];
vector<node> vc[N];
int main() {
    int n, q;
    scanf("%d%d", &n, &q);
    vector<int> ans(n, -1);
    vector<int> pos(n, -1);
    for (int i = 0; i < q; i++) {
        int l, r, x;
        scanf("%d%d%d", &l, &r, &x);
        vc[x].push_back(node(l, r));
    }
    bool ff = true;
    for (int i = n - 1; i >= 0 && ff; i--) {
        if (vc[i].size() == 0) { //没有对i的限制
            have[++top] = i;
            continue;
        }
//        for (int j = top; j > 0; j--)
//            printf("%d ", have[j]);
//        printf("\n");
        //用差分寻找交集
        int L = INF, R = -1;

        for (int j = 0; j < (int)vc[i].size(); j++) {
            node now = vc[i][j];
            L = min(L, now.l);
            R = max(R, now.r);
            f[now.l]++; f[now.r + 1]--;
//            cout <<  now.l << " " << now.r << "\n";
        }
        for (int j = L + 1; j <= R + 1; j++)
            f[j] += f[j - 1];
//        for (int j = 0; j < n; j++)
//            printf("%d ", f[j]);
//        printf("\n");
        int cnt = vc[i].size(); //对i限制的区间个数为cnt
        for (int j = L; j <= R; j++) {
            if (f[j] == cnt && ans[j] == -1) {
                ans[j] = i;
                pos[i] = j;
                break;
            }
        }
        //如果没有交集或者交集的位置都已经被更大的数放满了
        if (pos[i] == -1) {
            ff = false;
            break;
        }
        for (int j = L; j <= R && ff; j++) { //这个区间的最小值是i，必须拿>=i的数填满
            if (f[j] = cnt && ans[j] == -1) {
                if (top == 0) ff = false;
                else { //因为i是从n-1开始向下遍历的，所以数组内的数字一定比i大
                    ans[j] = have[top];
                    pos[have[top]] = j;
                    top--;
                }
            }
        }
        //清空差分数组
        for (int j = L; j <= R + 1; j++)
            f[j] = 0;
    }
//    for (int i = 1; i <= top; i++)
//        printf("%d ", have[i]);
//    printf("\n");
    for (int i = 0; i < n && ff; i++) {
        if (ans[i] == -1) {
            if (top == 0) ff = false;
            else {
                ans[i] = have[top];
                pos[ans[i]] = i;
                top--;
            }
        }
    }
    if (ff) {
        for (int i = 0; i < n; i++) {
            printf("%d%c", ans[i], i == n - 1 ? '\n' : ' ');
        }
    }
    else {
        for (int i = 0; i < n; i++) {
            printf("%d%c", -1, i == n - 1 ? '\n' : ' ');
        }
    }
    return 0;
}

D- 雨雪霏霏

待补

bok_choy_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
EOJ 2月月赛补题

文章目录EOJ 2月月赛补题A-昔我往矣B-杨柳依依C-今我来思（sì）D- 雨雪霏霏EOJ 2月月赛补题总之就是非常爆炸A-昔我往矣题意：现在有一棵树，每条边有边权，并且给你 555 个点 a,b,c,d,ea,b,c,d,ea,b,c,d,e 。如果从任一点出发能到达其它所有的点，求最小的边权和。思路：很明显，是个 LCALCALCA 。但是当时不会做。看了题解后才明白。五个点的公共祖先就是 dfsdfsdfs 序最大和最小的两个点的的 LCALCALCA。至于为什么呢？，按我的理解就是：
复制链接

扫一扫