EOJ 2月月赛补题

总之就是非常爆炸

A-昔我往矣

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

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

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

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

代码：

#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个点的lcaint 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-杨柳依依

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

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

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

代码：

#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ì）

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

思路：

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

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

#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限制的区间个数为cntfor (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- 雨雪霏霏

待补