【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;
}

【BZOJ4899】记忆的轮廓

猜你喜欢