HDU4035 Maze

嘟嘟嘟


这题卡精度！，我对拍了近1w组数据都没拍出来，辛亏最后看了HDU的讨论版。


首先对于每一个房间，令\(x_u\)表示从这个点出发的期望步数，很容易列出方程：\(x_u = K_i * x_1 + (1 - K_i - E_i) * (1 + \sum x_v)\)。
当我快快乐乐的写完了高斯消元后，发现这个\(n\)有点大啊……
然后我就想这题有啥特别的地方，毕竟以前做图的这种题，高斯消元都是可以过的。
仔细一想，发现这是一棵树，对没错，它是树！这样每一个节点的方程只和他的父亲、儿子、以及根节点有关。而叶子节点就只和他的父亲和根节点有关。所以对于叶子节点，可以用他的父亲和根节点表示，然后代入到父亲的方程中，这样父亲的方程中的未知数只剩他自己和根节点了！这样一路递归上去，根节点的方程就只有他自己一个未知数了，此题得解。时间复杂度\(O(n)\)。


（精度至少要设成1e-9……）

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
#include<assert.h>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define In inline
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-10;
const int maxn = 1e4 + 5;
In ll read()
{
  ll ans = 0;
  char ch = getchar(), last = ' ';
  while(!isdigit(ch)) last = ch, ch = getchar();
  while(isdigit(ch)) ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
  if(last == '-') ans = -ans;
  return ans;
}
In void write(ll x)
{
  if(x < 0) x = -x, putchar('-');
  if(x >= 10) write(x / 10);
  putchar(x % 10 + '0');
}
In void MYFILE()
{
#ifndef mrclr
  freopen("random.in", "r", stdin);
  freopen("ac.out", "w", stdout);
#endif
}

int n, du[maxn], K[maxn], E[maxn];
struct Edge
{
  int nxt, to;
}e[maxn << 1];
int head[maxn], ecnt = -1;
In void addEdge(int x, int y)
{
  ++du[y];
  e[++ecnt] = (Edge){head[x], y};
  head[x] = ecnt;
}

struct Node
{
  db a, b, d;  //a * x1, b * xfa, d
}t[maxn];

db f[maxn];
In void dfs(int now, int _f)
{
  for(int i = head[now], v; ~i; i = e[i].nxt)
    if((v = e[i].to) ^ _f) dfs(v, now);
  db tp = (100.0 - K[now] - E[now]) / 100.0;
  f[now] = 1; f[n + 1] = tp;
  if(now ^ 1) f[1] = -K[now] / 100.0;
  for(int i = head[now]; ~i; i = e[i].nxt)
    f[e[i].to] += -tp * 1.0 / du[now];
  for(int i = head[now], v; ~i; i = e[i].nxt)
    {
      if((v = e[i].to) == _f) continue;
      f[1] += t[v].a * f[v];
      f[now] += t[v].b * f[v];
      f[n + 1] -= t[v].d * f[v];
      f[v] = 0;
    }
  t[now].a = -f[1] / f[now];
  if(_f ^ 1) t[now].b = -f[_f] / f[now];
  t[now].d = f[n + 1] / f[now];
  if(now ^ 1) f[1] = f[now] = f[n + 1] = f[_f] = 0;
}

In void init()
{
  Mem(head, -1); ecnt = -1;
  Mem(f, 0), Mem(du, 0);
  for(int i = 1; i <= n; ++i) t[i] = (Node){0, 0, 0};
}

int main()
{
  MYFILE();
  int TT = read();
  for(int T = 1; T <= TT; ++T)
    {
      n = read();
      init();
      for(int i = 1; i < n; ++i)
	{
	  int x = read(), y = read();
	  addEdge(x, y), addEdge(y, x);
	}
      for(int i = 1; i <= n; ++i) K[i] = read(), E[i] = read();
      dfs(1, 0);
      printf("Case %d: ", T);
      if(f[1] < eps) puts("impossible");
      else printf("%.8lf\n", f[n + 1] / f[1]);
    }
  return 0;
}