20200728 SCOI模拟T2（状压dp）

T2 P6622 [省选联考 2020 A/B 卷] 信号传递

思路：
发现对答案产生影响的实质是边的经过次数 $cn{t}_{i,j}$
令 $i$ 的位置为 $po{s}_i$
则一条边 $i,j$ 对答案的贡献为
$$\{\begin{array}{l}po{s}_j-po{s}_i(po{s}_i<po{s}_j)\\ k(po{s}_i+po{s}_j)(po{s}_i>po{s}_j)\end{array}$$
考虑 $状压dp$
$d{p}_S$ 表示前面的数集为 $S$ 时的时间消耗
枚举新加入的数，考虑贡献在与前后数的边上

• 对于一个前面的数 $j,j\in S$，从 $i$ 到 $j$ 产生的代价是：${\text{pos}}_i\cdot k\cdot {\text{cnt}}_{i,j}$
• 对于一个前面的数 $j,j\in S$，从 $j$ 到 $i$ 产生的代价是：${\text{pos}}_i\cdot {\text{cnt}}_{i,j}$
• 对于一个后面的数 $j,j\notin S,j\ne i$，从 $i$ 到 $j$ 产生的代价是：$-{\text{pos}}_i\cdot {\text{cnt}}_{i,j}$
• 对于一个后面的数 $j,j\notin S,j\ne i$，从 $j$ 到 $i$ 产生的代价是：${\text{pos}}_i\cdot k\cdot {\text{cnt}}_{j,i}$
  于是有转移方程：
  $$dp[S|i]\leftarrow dp[S]+po{s}_i\cdot \sum _{j\in S}(k\cdot cnt[i][j]+cnt[j][i])+po{s}_i\cdot \sum _{j\notin (S|i)}(-cnt[i][j]+k\cdot cnt[j][i])$$
  考虑优化
  预处理：
  $$\sum _{j\in S}(k\cdot cnt[i][j]+cnt[j][i])+\sum _{j\notin (S|i)}(-cnt[i][j]+k\cdot cnt[j][i])$$
  为 $cost(i,j)$
  有
  $$dp[S|i]\leftarrow dp[S]+po{s}_i\cdot cost(S,i)$$
  预处理和转移的时间复杂度为：$O(m\times 2^m)$
  但是 $cost$ 数组的空间为 $m\times 2^m$
  考虑优化空间
  发现转移 $S\to S^{\prime }$ 最多一位改变，于是可以只维护当前转移需要用的 $cost$
  可以用队列维护

代码：

#include <bits/stdc++.h>
using namespace std;
namespace IO {
char _buf[1 << 21], *_p1 = _buf, *_p2 = _buf;
#define ch()                                                                 \
  (_p1 == _p2 &&                                                             \
           (_p2 = (_p1 = _buf) + fread(_buf, 1, 1 << 21, stdin), _p1 == _p2) \
       ? EOF                                                                 \
       : *_p1++)
inline int in() {
  int s = 0, f = 1;
  char x = ch();
  while (x < '0' || x > '9') {
    if (x == '-') f = -1;
    x = ch();
  }
  while (x >= '0' && x <= '9') {
    s = (s * 10) + (x & 15);
    x = ch();
  }
  return f == 1 ? s : -s;
}
char _buf_[1 << 21];
int _p1_ = -1;
inline void flush() {
  fwrite(_buf_, 1, _p1_ + 1, stdout);
  _p1_ = -1;
  return;
}
inline void pc(char x) {
  if (_p1_ == (1 << 21) - 1) flush();
  _buf_[++_p1_] = x;
  return;
}
inline void out(int x) {
  if (!x) pc('0');
  char k[20];
  int tot = 0;
  if (x < 0) {
    pc('-');
    x = -x;
  }
  while (x) {
    k[++tot] = (x % 10) | 48;
    x /= 10;
  }
  for (int i = tot; i; i--) pc(k[i]);
  return;
}
inline void out(string x) {
  int len = x.size();
  for (int i = 0; i < len; i++) pc(x[i]);
  return;
}
}  // namespace IO
using namespace IO;

const int N = 24;
const int A = 2e5 + 5;
const int INF = 1e9;
int n, m, K;
int to[A], rd[N][N];
struct Cost {
  int pn;
  int val[N];
} p1, p2;
queue<Cost> q;
int id[1 << N], fm[1 << N], dp[1 << N];

inline int lowbit(int x) { return x & (-x); }

signed main() {
  n = in(), m = in(), K = in();
  for (int i = 1; i <= n; i++) to[i] = in() - 1;
  for (int i = 1; i < n; i++) rd[to[i]][to[i + 1]]++;
  p1.pn = 0;
  for (int i = 0; i < m; i++) {
    p1.val[i] = 0;
    for (int j = 0; j < m; j++) {
      if (i != j) {
        p1.val[i] -= rd[i][j];
        p1.val[i] += K * rd[j][i];
      }
    }
  }
  q.push(p1);
  int all = (1 << m) - 1;
  for (int i = 1; i <= all; i++) {
    dp[i] = INF;
    fm[i] = fm[i >> 1] + (i & 1);
  }
  for (int i = 1; i <= m; i++) id[1 << i] = i;
  while (!q.empty()) {
    p1 = q.front();
    q.pop();
    int now = fm[p1.pn] + 1;
    for (int i = all ^ p1.pn; i; i -= lowbit(i)) {
      int j = id[lowbit(i)];
      int k = dp[p1.pn];
      int pnt = (p1.pn | (1 << j));
      k += now * p1.val[j];
      dp[pnt] = min(dp[pnt], k);
    }
    for (int i = 0; i < m; i++) {
      if ((p1.pn >> i) & 1) break;
      p2.pn = (p1.pn | (1 << i));
      for (int j = all ^ p2.pn; j; j -= lowbit(j)) {
        int k = id[lowbit(j)];
        p2.val[k] =
            p1.val[k] + (K * rd[k][i] + rd[i][k]) - (-rd[k][i] + K * rd[i][k]);
      }
      q.push(p2);
    }
  }
  out(dp[all]);
  flush();
  return 0;
}
  for (int i = 1; i <= m; i++) id[1 << i] = i;
  while (!q.empty()) {
    p1 = q.front();
    q.pop();
    int now = fm[p1.pn] + 1;
    for (int i = all ^ p1.pn; i; i -= lowbit(i)) {
      int j = id[lowbit(i)];
      int k = dp[p1.pn];
      int pnt = (p1.pn | (1 << j));
      k += now * p1.val[j];
      dp[pnt] = min(dp[pnt], k);
    }
    for (int i = 0; i < m; i++) {
      if ((p1.pn >> i) & 1) break;
      p2.pn = (p1.pn | (1 << i));
      for (int j = all ^ p2.pn; j; j -= lowbit(j)) {
        int k = id[lowbit(j)];
        p2.val[k] =
            p1.val[k] + (K * rd[k][i] + rd[i][k]) - (-rd[k][i] + K * rd[i][k]);
      }
      q.push(p2);
    }
  }
  IO::out(dp[all]);
  IO::flush();
  return 0;
}