使用状态压缩优化复杂度

前排提醒：题目是状态压缩，不是状压DP

前言

前几天看到有个同学在做P1558 色板游戏，于是我凑过去看了一眼，直接秒了（（（

写完之后看了看题解，发现大部分都是写的开30棵线段树。

于是想起来了去年做过的一道题目，也是用了状压优化的思想。

P1558 色板游戏

题目描述

阿宝上学了，今天老师拿来了一块很长的涂色板。

色板长度为L，L是一个正整数，所以我们可以均匀地将它划分成L块1厘米长的小方格。并从左到右标记为1, 2, ... L。

现在色板上只有一个颜色，老师告诉阿宝在色板上只能做两件事：

"C A B C" 指在A到 B 号方格中涂上颜色 C。
"P A B" 指老师的提问：A到 B号方格中有几种颜色。
学校的颜料盒中一共有 T 种颜料。为简便起见，我们把他们标记为 1, 2, ... T. 开始时色板上原有的颜色就为1号色。 面对如此复杂的问题，阿宝向你求助，你能帮助他吗？

输入格式

第一行有3个整数 L (1 <= L <= 100000), T (1 <= T <= 30) 和 O (1 <= O <= 100000)。 在这里O表示事件数。
接下来 O 行, 每行以 "C A B C" 或 "P A B" 得形式表示所要做的事情(这里 A, B, C 为整数, 可能A> B，这样的话需要你交换A和B)

输出格式

对于老师的提问，做出相应的回答。每行一个整数。

输入输出样例

输入 #1

2 2 4
C 1 1 2
P 1 2
C 2 2 2
P 1 2

输出 #1

2
1

思路

区间修改、区间查询......这看起来像是个线段树+懒标记的题。

不妨先考虑T=1的时候咋做。不难发现这变成了一个非常简单的区间赋值+区间求和的问题（（（

然后比较暴力的思路就是开T棵线段树，每棵树分别维护一种颜色，修改/查询的时候每棵树上跑一遍

而且这个做法甚至能过

注意到T最大只有30，如果状压的话一个int正好能存下。

做法

把区间的颜色状态压缩起来，每个颜色一位；

查询的时候就求区间的颜色状态，然后统计这个状态里有多少个颜色（这个状态所对应的二进制数有多少个1）；

区间颜色状态可以用线段树维护，两个子区间的状态按位或起来就是大区间的状态；

修改就普通的区间赋值，记得打懒标记要不然会tle。

参考代码

#include "cstdio"

#define re register
#define il inline
#define tt template<class T>
#define gc getchar
#define pc putchar

typedef long long ll;

tt il void read(T &x)
{
  re bool f = false;
  re char c = gc();
  while ((c < '0' || c > '9') && c != '-') c = gc();
  if (c == '-') f = true, c = gc();
  x = 0;
  while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = gc();
  f && (x = -x);
}

tt void print(T x)
{
  (x < 0) && (pc('-'), x = -x);
  if (x >= 10) print(x / 10);
  pc(x % 10 + '0');
}

tt il void prisp(T x)
{
  print(x);
  pc(' ');
}

tt il void priln(T x)
{
  print(x);
  pc('
');
}

const int N = 100005;

int n, t, m;
int sum[N << 2], laz[N << 2];

inline void update(int x)
{
  sum[x] = sum[x << 1] | sum[x << 1 | 1];
  if (laz[x])
  {
    sum[x] = laz[x];
  }
}

inline void pushdown(int x)
{
  if (!laz[x]) return;
  laz[x << 1] = laz[x << 1 | 1] = laz[x];
  sum[x << 1] = laz[x];
  sum[x << 1 | 1] = laz[x];
  laz[x] = 0;
}

void init(int x, int l, int r)
{
  if (l == r)
  {
    sum[x] = 1;
    return;
  }
  int mid = l + r >> 1;
  init(x << 1, l, mid);
  init(x << 1 | 1, mid + 1, r);
  update(x);
}

void add(int x, int l, int r, int ll, int rr, int c)
{
  if (ll <= l && rr >= r)
  {
    laz[x] = c;
    sum[x] = c;
    return;
  }
  pushdown(x);
  int mid = l + r >> 1;
  if (ll <= mid) add(x << 1, l, mid, ll, rr, c);
  if (rr > mid) add(x << 1 | 1, mid + 1, r, ll, rr, c);
  update(x);
}

int query(int x, int l, int r, int ll, int rr)
{
  if (ll <= l && rr >= r)
  {
    return sum[x];
  }
  pushdown(x);
  int mid = l + r >> 1, ans = 0;
  if (ll <= mid) ans |= query(x << 1, l, mid, ll, rr);
  if (rr > mid) ans |= query(x << 1 | 1, mid + 1, r, ll, rr);
  return ans;
}

int main()
{
  read(n);
  read(t);
  read(m);
  init(1, 1, n);
  while (m--)
  {
    char op = gc();
    while (op != 'C' && op != 'P') op = gc();
    if (op == 'C')
    {
      int l, r, c;
      read(l);
      read(r);
      read(c);
      if (l > r) l ^= r ^= l ^= r;
      add(1, 1, n, l, r, 1 << (c - 1));
    }
    else
    {
      int l, r;
      read(l);
      read(r);
      if (l > r) l ^= r ^= l ^= r;
      int ans = query(1, 1, n, l, r), cnt = 0;
      while (ans) ++cnt, ans &= ans - 1;
      priln(cnt);
    }
  }
}