【BZOJ4899】记忆的轮廓

【题目链接】

• 点击打开链接

【思路要点】

• 预处理出$cost_{i,j}$表示存档点$i,j$之间不存在其它存档点时，从$i$走到$j$的期望步数。

• 问题可以由DP解决：记$dp_{i,j}$表示从初始状态到第一次达到已经设置了$i$个存档点，第$i$个存档点设置在了$j$处的期望步数。

• 显然有

  $dp_{1,1}=0,dp_{1,i}=+\infty(i>1)$

  $dp_{i,j}=min_{k=1}^{j-1}\{dp_{i-1,k}+cost_{k,j}\}(i>1)$

• 我们发现$cost$数组是满足四边形不等式的，

  即对于任意$j<k<i<r$，有$cost_{j,r}+cost_{k,i}>cost_{j,i}+cost_{k,r}$。

• 考虑第$x$层的决策点$j,k$，若对于$i$而言，决策点$k$已经优于决策点$j$，

  即$dp_{x-1,j}+cost_{j,i}>dp_{x-1,k}+cost_{k,i}$

  那么$cost_{j,i}-cost_{k,i}>dp_{x-1,k}-dp_{x-1,j}$

  又由$cost_{j,r}+cost_{k,i}>cost_{j,i}+cost_{k,r}$

  因此$cost_{j,r}-cost_{k,r}>cost_{j,i}-cost_{k,i}$

  因此$cost_{j,r}-cost_{k,r}>dp_{x-1,k}-dp_{x-1,j}$

  即$dp_{x-1,j}+cost_{j,r}>dp_{x-1,k}+cost_{k,r}$

  因此此时对于任何$r>i$，决策点$k$均优于决策点$j$。

• 用决策单调性分治优化DP即可。

• 时间复杂度$O(N^2LogN+M)$。

【代码】

#include<bits/stdc++.h>

using namespace std;
const int MAXN = 705;
const int MAXM = 1505;
const double INF = 1e99;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
  x = 0; int f = 1;
  char c = getchar();
  for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
  for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
  x *= f;
}
template <typename T> void write(T x) {
  if (x < 0) x = -x, putchar('-');
  if (x > 9) write(x / 10);
  putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
  write(x);
  puts("");
}
int n, m, p;
vector <int> a[MAXM];
double steps[MAXM], cost[MAXN][MAXN], dp[MAXN][MAXN];
void solve(int depth, int l, int r, int sl, int sr) {
  int mid = (l + r) / 2, home = sl;
  dp[depth][mid] = INF;
  for (int i = sl; i <= min(sr, mid - 1); i++) {
      double tmp = dp[depth - 1][i] + cost[i][mid];
      if (tmp < dp[depth][mid]) {
          dp[depth][mid] = tmp;
          home = i;
      }
  }
  if (l < mid) solve(depth, l, mid - 1, sl, home);
  if (mid < r) solve(depth, mid + 1, r, home, sr);
}
void work(int pos, int fa) {
  if (pos <= n) {
      steps[pos] = a[pos].size() + 1;
      for (unsigned i = 0; i < a[pos].size(); i++) {
          work(a[pos][i], pos);
          steps[pos] += steps[a[pos][i]];
      }
  } else {
      if (a[pos].size() == 1) {
          steps[pos] = 1;
          return;
      }
      steps[pos] = 0;
      for (unsigned i = 0; i < a[pos].size(); i++)
          if (a[pos][i] != fa) {
              work(a[pos][i], pos);
              steps[pos] += steps[a[pos][i]] + 1;
          }
      steps[pos] /= a[pos].size() - 1;
  }
}
int main() {
  int T; read(T);
  while (T--) {
      read(n), read(m), read(p);
      for (int i = 1; i <= m; i++)
          a[i].clear();
      for (int i = n + 1; i <= m; i++) {
          int x, y; read(x), read(y);
          a[x].push_back(y);
          a[y].push_back(x);
      }
      for (int i = 1; i <= n; i++)
          work(i, 0);
      for (int i = 1; i <= n; i++) {
          cost[i][i] = 0;
          for (int j = i + 1; j <= n; j++) {
              cost[i][j] = cost[i][j - 1] + 1;
              for (unsigned k = 0; k < a[j - 1].size(); k++)
                  cost[i][j] += cost[i][j - 1] + 1 + steps[a[j - 1][k]];
          }
      }
      dp[1][1] = 0;
      for (int i = 2; i <= n; i++)
          dp[1][i] = INF;
      for (int i = 2; i <= p; i++)
          solve(i, 1, n, 1, n);
      printf("%.4lf\n", dp[p][n]);
  }
  return 0;
}