标签：sum ext 最大 double else 最大值 head time cstring
题目链接(逃)
现在有一棵树，共 \(N\) 个节点。
规定：根节点为 \(1\) 号节点，且每个节点有一个点权。
现在，有 \(M\) 个操作需要在树上完成，每次操作为下列三种之一：
\(1 \ x \ a\)：操作 \(1\)，将节点 \(x\) 点权增加 \(a\)。
\(2 \ x \ a\)：操作 \(2\)，将以节点 \(x\) 为根的子树中所有点的权值增加 \(a\)。
\(3 \ x\)：操作 \(3\)，查询节点 \(x\) 到根节点的路径中所有点的点权和。
对于 \(100\%\) 的数据：\(N , M \leq 10 ^ 5\)。
保证所有输入数据绝对值不超过 \(10 ^ 6\)。
显然可以树剖。时间复杂度 \(O(m \log_2 n)\)。
也可以把所有操作放在节点上，\(dfs\) 遍历，遍历到的时候修改，遍历完一棵子树后回溯；
单点改整个子树答案加 \(a\)，否则子树 \(u\) 里点 \(v\) 答案增加 \(dep_v \times a - (dep_u - 1) \times a\)。
时间复杂度 \(O(m \log_2 n)\)。
#include <cstdio>
#include <cstring>
#include <algorithm>
int in() {
int x = 0; char c = getchar(); bool f = 0;
while (c < '0' || c > '9')
f |= c == '-', c = getchar();
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return f ? -x : x;
}
template<typename T>inline void chk_min(T &_, T __) { _ = _ < __ ? _ : __; }
template<typename T>inline void chk_max(T &_, T __) { _ = _ > __ ? _ : __; }
const int N = 1e5 + 5;
struct edge {
int next, to;
} e[N << 1];
int ecnt = 1, head[N];
int n, m, w[N];
inline void add_edge(const int u, const int v) {
e[++ecnt] = (edge){head[u], v}, head[u] = ecnt;
e[++ecnt] = (edge){head[v], u}, head[v] = ecnt;
}
struct segment_tree {
long long sum[N << 2];
long long lazy[N << 2];
inline void push_up(const int p) {
sum[p] = sum[p << 1] + sum[p << 1 | 1];
}
inline void spread(const int p, const int tl, const int tr, const int mid) {
sum[p << 1] += lazy[p] * (mid - tl + 1);
sum[p << 1 | 1] += lazy[p] * (tr - mid);
lazy[p << 1] += lazy[p];
lazy[p << 1 | 1] += lazy[p];
lazy[p] = 0;
}
void modify(int l, int r, int k, int tl = 1, int tr = n, int p = 1) {
if (l <= tl && tr <= r) {
sum[p] += 1ll * k * (tr - tl + 1);
lazy[p] += k;
return ;
}
int mid = (tl + tr) >> 1;
if (lazy[p])
spread(p, tl, tr, mid);
if (mid >= l)
modify(l, r, k, tl, mid, p << 1);
if (mid < r)
modify(l, r, k, mid + 1, tr, p << 1 | 1);
push_up(p);
}
long long query(int l, int r, int tl = 1, int tr = n, int p = 1) {
if (l <= tl && tr <= r)
return sum[p];
int mid = (tl + tr) >> 1;
if (lazy[p])
spread(p, tl, tr, mid);
if (mid < l)
return query(l, r, mid + 1, tr, p << 1 | 1);
if (mid >= r)
return query(l, r, tl, mid, p << 1);
return query(l, r, tl, mid, p << 1) + query(l, r, mid + 1, tr, p << 1 | 1);
}
} T;
//heavy-light decomposition begin
int siz[N], hson[N], fa[N], fro[N], dfn[N];
void dfs1(const int u) {
siz[u] = 1;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (v == fa[u])
continue;
fa[v] = u;
dfs1(v);
siz[u] += siz[v];
if (siz[v] > siz[hson[u]])
hson[u] = v;
}
}
void dfs2(const int u, const int tp) {
fro[u] = tp;
dfn[u] = ++dfn[0];
if (hson[u])
dfs2(hson[u], tp);
for (int i = head[u]; i; i = e[i].next)
if (e[i].to != fa[u] && e[i].to != hson[u])
dfs2(e[i].to, e[i].to);
}
//heavy-light decomposition end
long long query(int u) {
long long ret = 0;
while (u) {
ret += T.query(dfn[fro[u]], dfn[u]);
u = fa[fro[u]];
}
return ret;
}
int main() {
//freopen("in", "r", stdin);
freopen("tree.in", "r", stdin);
freopen("tree.out", "w", stdout);
n = in(), m = in();
for (int i = 1; i <= n; ++i)
w[i] = in();
for (int i = 1; i < n; ++i)
add_edge(in(), in());
dfs1(1), dfs2(1, 1);
for (int i = 1; i <= n; ++i)
T.modify(dfn[i], dfn[i], w[i]);
while (m--) {
int typ = in(), x = in(), a;
if (typ == 1) {
a = in();
T.modify(dfn[x], dfn[x], a);
} else if (typ == 2) {
a = in();
T.modify(dfn[x], dfn[x] + siz[x] - 1, a);
} else {
printf("%lld\n", query(x));
}
}
return 0;
}题目链接(逃)
有一个无向图：共 \(n\) 个节点，编号分别为 \(1\)~\(n\)，同时有 \(m\) 条无向边。
不同于他研究的树，图中边和点都有各自的权值，第 \(i\) 条边的边权为 \(w_i\)，第 \(i\) 个点的点权为 \(c_i\)。
从点 \(s\) 经过若干条边到点 \(t\) 的花费定义为：两点之间经过边的边权之和，加上经过的所有点 (包括 \(s\) 和 \(t\)) 的点权的最大值。
现在 Makik 将给出 \(k\) 次询问，每次给出两个整数 \(s,t\)，询问从 \(s\) 到 \(t\) 的最小花费。
请设计算法帮助 Makik 快速求解答案。
注：图中可能有两点之间存在多条边的情况，但不存在自环。
\(1 \leq n \leq 250, 1 \leq m<=10000, 1 \leq k \leq 10000\)；
\(1 \leq a, b, s, t \leq n, 1 \leq c, w \leq 100000, s \ne t\)。
把点按点权从小到大排序，枚举起点并加入图，跑单源最短路，只能走已经加入的点；
再将该点当作中间点 \(x\)，更新 \(f_{u,v}\) (\(u,v\) 之间的答案)：
\(f_{u,v} = \max \{ dis_{u,x} + dis{x,v} + c_x \}\)，其中 \((u, x)\)，\((x, v)\) 必须在当前的图中可达。
时间复杂度 \(O(n^3)\)。
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
int in() {
int x = 0; char c = getchar(); bool f = 0;
while (c < '0' || c > '9')
f |= c == '-', c = getchar();
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return f ? -x : x;
}
template<typename T>inline void chk_min(T &_, T __) { _ = _ < __ ? _ : __; }
template<typename T>inline void chk_max(T &_, T __) { _ = _ > __ ? _ : __; }
const int N = 255, M = 1e4 + 5;
int n, m, k;
int c[N], id[N];
int dis[N][N], e[N][N], f[N][N];
bool ok[N];
inline bool cmp(const int &i, const int &j) {
return c[i] < c[j];
}
void dijkstra(const int s, int *d) {
static int vis[N];
d[s] = 0;
for (int i = 1, u; i < n; ++i) {
u = 0;
for (int v = 1; v <= n; ++v)
if (ok[v] && vis[v] != s && ~d[v] && (!~d[u] || d[u] > d[v]))
u = v;
if (!u)
break;
vis[u] = s;
for (int v = 1; v <= n; ++v)
if (ok[v] && ~e[u][v]) {
if (!~d[v])
d[v] = d[u] + e[u][v];
else
chk_min(d[v], d[u] + e[u][v]);
}
}
}
inline void init() {
memset(dis, -1, sizeof(dis));
memset(f, -1, sizeof(f));
memset(e, -1, sizeof(e));
}
int main() {
//freopen("in", "r", stdin);
freopen("roadtoll.in", "r", stdin);
freopen("roadtoll.out", "w", stdout);
init();
n = in(), m = in(), k = in();
for (int i = 1; i <= n; ++i)
c[i] = in(), id[i] = i;
for (int i = 1, u, v, w; i <= m; ++i) {
u = in(), v = in(), w = in();
if (!~e[u][v])
e[u][v] = w;
else
chk_min(e[u][v], w);
e[v][u] = e[u][v];
}
std::sort(id + 1, id + 1 + n, cmp);
for (int i = 1; i <= n; ++i) {
ok[id[i]] = 1, dijkstra(id[i], dis[id[i]]);
for (int j = 1; j <= n; ++j)
dis[j][id[i]] = dis[id[i]][j];
for (int u = 1; u <= n; ++u)
if (~dis[u][id[i]])
for (int v = u + 1; v <= n; ++v)
if (~dis[id[i]][v]) {
if (!~f[u][v])
f[u][v] = dis[u][id[i]] + dis[id[i]][v] + c[id[i]];
else
chk_min(f[u][v], dis[u][id[i]] + dis[id[i]][v] + c[id[i]]);
}
}
for (int u = 1; u <= n; ++u)
for (int v = u + 1; v <= n; ++v)
f[v][u] = f[u][v];
while (k--)
printf("%d\n", f[in()][in()]);
return 0;
}题目链接(逃)
Makik 有一张详细的城市地图,地图标注了 L 个景区,编号为 1~L。而景区与景区之间建有单向高速通道。
这天,Makik 要去逛景区,他可以任选一个景区开始一天行程,且只能通过单向高速通道进入其他景区。
至少要参观两个景区，游玩最后要回到起始景区。
如果 Makik 参观了第 \(i\) 个景区，会获得一个乐趣值 \(F_i\)。且参观过得景区不会再获得乐趣值。
对于第 \(i\) 条单向高速通道，需要消耗 \(T_i\) 的时间，能够从 \(L1_i\) 到达 \(L2_i\)。
为了简化问题，参观景区不需要花费时间，Makik 想要最终单位时间内获得的乐趣值最大。
请你写个程序，帮 Makik 计算一下他能得到的最大平均乐趣值。
\(2 \leq L \leq 1000, 2 \leq P \leq 5000, 1 \leq F_i \leq 1000, 1 \leq T_i \leq 1000\)。
显然 \(01\) 分数规划，故二分 (迭代好像不好写)。
设二分出 \(mid\)，则 \(mid\) 可行当且仅当存在环满足：
\[
\frac{\sum f_i }{\sum e_i} \geq mid \iff
\sum f_i >= mid \geq e_i \iff
\sum f_i - \sum mid \cdot e_i \geq 0
\]
判正环即可。
时间复杂度 \(O(G(n,m) \log_2 ans)\)，其中 \(G(n,m)\) 为判负环复杂度，可以认为是 \(O(nm)\)。
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
typedef double db;
int in() {
int x = 0; char c = getchar(); bool f = 0;
while (c < '0' || c > '9')
f |= c == '-', c = getchar();
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return f ? -x : x;
}
template<typename T>inline void chk_min(T &_, T __) { _ = _ < __ ? _ : __; }
template<typename T>inline void chk_max(T &_, T __) { _ = _ > __ ? _ : __; }
const int N = 1e3 + 5;
const double eps = 1e-4;
struct edge {
int next, to;
double w;
} e[N * 5];
int ecnt = 1, head[N];
int f[N];
int n, m;
db d[N];
bool vis[N];
bool dfs(int u, db mid) {
if (vis[u])
return 1;
vis[u] = 1;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
db w = f[v] - mid * e[i].w;
if (d[v] <= d[u] + w) {
d[v] = d[u] + w;
if (dfs(v, mid))
return 1;
}
}
vis[u] = 0;
return 0;
}
bool chk(db mid) {
for (int i = 1; i <= n; ++i)
d[i] = vis[i] = 0;
for (int i = 1; i <= n; ++i)
if (dfs(i, mid))
return 1;
//std::queue<int> q;
//static int tim[N];
//for (int i = 1; i <= n; ++i)
// q.push(i), tim[i] = vis[i] = 1, d[i] = 0;
//while (!q.empty()) {
// int u = q.front(); q.pop();
// vis[u] = 0;
// if (tim[u] > n)
// return 1;
// for (int i = head[u]; i; i = e[i].next) {
// int v = e[i].to;
// db w = f[v] - mid * e[i].w;
// if (d[v] <= d[u] + w) {
// d[v] = d[u] + w;
// if (!vis[v])
// q.push(v), vis[v] = 1, ++tim[v];
// }
// }
//}
return 0;
}
db binary_search(db l, db r) {
while (r - l > eps) {
db mid = (l + r) / 2;
if (chk(mid))
l = mid;
else
r = mid;
}
return l;
}
int main() {
//freopen("in", "r", stdin);
freopen("travel.in", "r", stdin);
freopen("travel.out", "w", stdout);
n = in(), m = in();
for (int i = 1; i <= n; ++i)
f[i] = in();
while (m--) {
int u = in(), v = in(), w = in();
e[++ecnt] = (edge){head[u], v, 1.0 * w}, head[u] = ecnt;
}
printf("%.2lf\n", binary_search(0, 500));
return 0;
}标签：sum ext 最大 double else 最大值 head time cstring
原文地址：https://www.cnblogs.com/15owzLy1-yiylcy/p/11768804.html
