题解（我们考虑求出每条边不再是桥的时刻）

很复杂的图论，据说是最难的 OI 题，我觉得至少是我做过最难的图论题。

以下称层内边为横边，层间边为竖边。

引理 1：每条边是桥的层数是一个前缀（有可能一直是桥）。

我们考虑求出每条边不再是桥的时刻 tim
​
，有了 tim 之后问题就解决了，因为只需要处理 a
​
=0.9
序列的前缀和即可，注意如果 tim
​
=∞ 根据等比数列求和，它的贡献是 10w
​
。

引理 2：最多在 O(n) 层之后，所有的边要么一直是桥，要么一直不是桥。

所以我们考虑快速找到每一层有哪些边不再是桥。

从第一层开始，先对第一层横边图进行边双缩点，得到一个边双森林，此时边双内的横边都不会再作为桥了。

接下来考虑将第二层增量地考虑进来。

引理 3：如果在某一个连通块内有两条及以上竖边，那么这些竖边不再是桥。

这个引理没有上面两个平凡，证明如下：

注意到题目保证图连通，所以只看第一层，任意两个连通块一定可以经过第二层及之后的层连通，根据这张图的重复性，第 i 层任意两个连通块一定可以经过 i+1 层及以后的层连通。

假设 x 连向了下一层的 y,z，那么 y,z 一定可以通过之后层到达下一层的 x，所以无论删掉 x→y/z 都不会影响连通性。所以根据引理 3，如果一个连通块出现了两条竖边，那么这两条竖边的出发点 u,v 和边双树上 u,v 路径上所有的边双都在同一个边双内，可以把 u,v 路径上所有边双合并起来，并且这两条竖边的结束点 x,y 间接通过当前及之前的层连通，所以相当于在下一层 x,y 之间加了一条边。

根据上述步骤，最后不断合并边双，直到该连通块所有的竖边从一个边双出发，不妨设这个边双为这个连通块边双树的根。

因为图连通，所以所有连通块至少有一个竖边，因此所有连通块都可以通过上述方法确定根。

考虑给下一层 x,y 加的边。

如果这条边在一个连通块内，那么 x,y 的树上路径和这条边构成了一个环，所以继续把这个环上所有点合并起来。

如果这条边在不同连通块内，这条边合并了这两个连通块，因为每个连通块的根都有一条竖边，所以新连通块有至少两个竖边，继续迭代地进行下去。不断进行上述步骤，直到不再合并连通块为止。

所有边的 tim
i
​
可以在合并边双的时候确定。

实现很复杂，我的实现用一个队列来存储加边事件，为了动态合并边双，使用树上并查集维护所有边双树，因为还要找到树上两点路径，所以可以维护深度，然后类似树剖 LCA 的方法找到这条路径。

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#define x first
#define y second
using namespace std;
typedef pair<int, int> PII;
typedef long double ld;
const int N = 3e5 + 10, M = 1e6 + 10, INF = 1e9;
bool Mst;
int n, m1, m2, m, w[M], dfn[N], low[N], timestamp, stk[N], scc, top, id[N], u[M], v[M];
bool ins[N];
ld pw[N];
vector<PII> g1[N], g2[N], G[N];
void tarjan(int u, int faw) {
    dfn[u] = low[u] = ++ timestamp, stk[++ top] = u;
    ins[u] = 1;
    for(auto v : g1[u]) {
    if(v.y == faw) continue;
    if(!dfn[v.x]) tarjan(v.x, v.y), low[u] = min(low[u], low[v.x]);
    else low[u] = min(low[u], dfn[v.x]);
    }
    if(low[u] == dfn[u]) {
    int y = -1; scc ++;
    while(y != u) {
    y = stk[top --];
    ins[y] = 0, id[y] = scc;
    }
    }
}
int fa[N], downe[N], dep[N], root[N];
int find(int x) {
    return fa[x] == x ? x : fa[x] = find(fa[x]);
}
void merge(int a, int b) {
    int x = find(a), y = find(b);
    if(x ^ y) fa[x] = y;
}
struct qwq {
    int flor, u, v;
};
namespace Tr {
    int fa[N];
    int find(int x) {
        return fa[x] == x ? x : fa[x] = find(fa[x]);
    }
    void merge(int a, int b) {
        int x = find(a), y = find(b);
        if(x ^ y) fa[x] = y;
    }
};
int rfa[N], rw[N], tim[M];
void dfs(int u, int ft) {
    Tr::fa[u] = u, rfa[u] = ft, dep[u] = dep[ft] + 1;
    for(auto v : G[u]) {
        if(v.x == ft) continue;
        rw[v.x] = v.y, dfs(v.x, u);
    }
}
void updtime(int x, int v) {
    tim[x] = min(tim[x], v);
}
void access(int T, int u) {
    while(u) {
        u = Tr::find(u);
        if(rfa[u] == 0) break;
        updtime(rw[u], T);
        Tr::merge(u, rfa[u]);
    }
}
bool Med;
signed main() {
    ios::sync_with_stdio(0), cin.tie(0);
    cerr << abs(&Mst - &Med) / 1048576.<< "Mb\n";
    cin >> n >> m1 >> m2;
    pw[0] = 1;
    for(int i = 1; i < N; i ++) pw[i] = pw[i - 1] * 0.9;
    for(int i = 1; i < N; i ++) pw[i] += pw[i - 1];
    for(int i = 1, a, b, c; i <= m1; i ++) {
    cin >> a >> b >> c, g1[a].push_back({b, i}), g1[b].push_back({a, i}); 
    w[i] = c;
    }
    for(int i = 1, a, b, c; i <= m2; i ++) {
    cin >> a >> b >> c; 
    u[i] = a, v[i] = b;
    w[i + m1] = c;
    }
    m = m1 + m2;
    for(int i = 1; i <= n; i ++) if(!dfn[i]) tarjan(i, 0);
    for(int i = 1; i <= scc; i ++) fa[i] = i;
    queue<qwq> q;
    memset(tim, 0x3f, sizeof tim);
    for(int i = 1; i <= n; i ++)
        for(auto j : g1[i]) {
            if(i > j.x) continue; 
            int x = find(id[i]), y = find(id[j.x]);
            if(x != y) G[id[i]].push_back({id[j.x], j.y}), G[id[j.x]].push_back({id[i], j.y}), fa[x] = y;
            else tim[j.y] = -1;
        }
    for(int i = 1; i <= m2; i ++) {
        int x = find(id[u[i]]);
        if(downe[x] == 0) downe[x] = i, root[x] = id[u[i]];
        else q.push({0, id[v[downe[x]]], id[v[i]]});
    }
    for(int i = 1; i <= scc; i ++) if(fa[i] == i) {
        dfs(root[i], 0);
    }
    for(int i = 1; i <= m2; i ++) {
        int x = find(id[u[i]]);
        if(downe[x] != i) updtime(downe[x] + m1, -1), updtime(i + m1, -1), access(-1, id[u[i]]);
    }
    while(q.size()) {
        auto t = q.front(); q.pop();
        int x = find(t.u), y = find(t.v);
        if(x == y) {
            x = Tr::find(t.u), y = Tr::find(t.v);
            while(x ^ y) {
                if(dep[x] < dep[y]) swap(x, y);
                updtime(rw[x], t.flor);
                Tr::merge(x, rfa[x]);
                x = Tr::find(x);
            }
        }
        else {
            x = Tr::find(t.u), y = Tr::find(t.v);
            access(t.flor, x), access(t.flor, y);
            x = find(x), y = find(y);
            fa[x] = y;
            Tr::fa[root[x]] = root[y];
            updtime(downe[x] + m1, t.flor), updtime(downe[y] + m1, t.flor);
            q.push({t.flor + 1, id[v[downe[x]]], id[v[downe[y]]]});
        }
    }
    ld ans = 0;
    for(int i = 1; i <= m; i ++) {
        if(tim[i] == -1) continue;
        if(tim[i] < INF) ans += pw[tim[i]] * w[i];
        else ans += 10 * w[i];
    }
    printf("%.2Lf\n", ans);
    return 0;
}