2024初秋集训——提高组 #39

B. 启发式图染色问题

题目描述

有这样一个问题：给定一个 \(N\) 个点 \(M\) 条边的无向图，你要对其中的点进行染色，使得任意边的两个端点颜色不同，求最少颜色数量。

现在你要 hack 以下算法：从前往后贪心的每次将点染成最小需要的颜色，代码如下：

void solve() {
    int n, m;
    std::cin >> n >> m;
    std::vector<int> col(n + 1);
    std::vector<std::vector<int> > g(n + 1);

    for(int i = 1, u, v; i <= m; i ++) {
        std::cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
    }

    for(int i = 1; i <= n; i ++) {
        std::set<int> s;
        for(int j : g[i]) 
          if(j < i)
            s.insert(col[j]);
      
        std::vector<int> v(s.begin(), s.end());
        col[i] = v.size() + 1;
        for(int j = 0; j < v.size(); j ++)
            if(v[j] != j + 1) {
                col[i] = j + 1;
                break;
            }
        std::cout << col[i] << " \n"[i == n];
    }
    std::cout << "total = " << *std::max_element(col.begin(), col.end()) << "\n";
}

你要构造一个图，使得你只需要 \(c\) 种颜色，而此代码需要 \(c+k\) 种颜色。点的数量 \(\le 1024\)。

思路

我们考虑令 \(c=2\) 该怎么构造。

在这张图上每个点都有你的的颜色和错误算法的颜色两种，我们试着先把错误算法凑到 \(3\)：

虽然凑到了 \(3\)，但此时你的颜色为 \(2\)，也就是不能直接用它跟之前的凑，因为 \(1,2\) 凑起来就变成 \(3\) 了，所以我们还要构造一个你的颜色为 \(1\) 的 \(3\)，可以把之前 \(1,2\) 反过来来凑就行了：

而之前我们凑出来的 \((3,2)\) 继续凑后面的即可。

总之就是对于每种错误算法的颜色，你都要凑出 \(1,2\) 两遍，每个点都连向之前的与自己构造的颜色不同的连边。

时空复杂度均为 \(O(k^2)\)。

代码

#include<bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;

const int MAXN = 1025;

int k, n;
vector<pii> edge;

int main() {
  ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  cin >> k;
  n = (2 + k) * 2;
  for(int i = 3; i <= n; ++i) {
    for(int j = 1; j < i / 2 * 2; ++j) {
      if((j & 1) ^ (i & 1)) {
        edge.emplace_back(i, j);
      }
    }
  }
  cout << n << " " << edge.size() << " 2\n";
  for(int i = 1; i <= n; ++i) {
    cout << !(i % 2) + 1 << " \n"[i == n];
  }
  for(auto [x, y] : edge) {
    cout << x << " " << y << "\n";
  }
  return 0;
}

C. 自由组队

题目描述

有 \(N\) 个人要进行分组，要满足以下条件：

• 每名学生恰好属于一个团队。
• 第 \(i\) 名学生属于的团队大小在 \([l_i,r_i]\) 间。

一个大小为 \(x\) 的团队的效率为 \(w_x\)，求分成的团队效率总和最大值。

思路

由于此题 \(N\le 60\)，且其不关心团队中的人而只关心大小，也就是可以看作一个多重集合，可以证明这样的集合数量是可接受的。所以考虑状压。

我们记录哪些学生已经加入了团队，并从大到小枚举团队大小。我们可以贪心地每次尽可能让 \(l\) 更大的进入该团队。状压 dp 即可。

时空复杂度均未知但可过。

代码

#include<bits/stdc++.h>
using namespace std;
using ll = long long;

const int MAXN = 61;

int t, n, l[MAXN], r[MAXN], w[MAXN];
map<ll, int> dp;

void Solve() {
  cin >> n;
  for(int i = 1; i <= n; ++i) {
    cin >> l[i] >> r[i];
  }
  for(int i = 1; i <= n; ++i) {
    cin >> w[i];
  }
  dp.clear();
  dp[0] = 0;
  for(int i = n; i >= 1; --i) {
    map<ll, int> now;
    vector<int> ve;
    for(int j = 1; j <= n; ++j) {
      if(l[j] <= i && r[j] >= i) {
        ve.emplace_back(j);
      }
    }
    sort(ve.begin(), ve.end(), [](int a, int b) -> bool {
      return l[a] > l[b];
    });
    for(auto [s, val] : dp) {
      int res = n - __builtin_popcountll(s), cnt = 0;
      ll k = s;
      if(res < i) {
        continue;
      }
      now[k] = (!now.count(k) ? val : max(now[k], val));
      for(int x : ve) {
        if(!((s >> (x - 1)) & 1)) {
          k |= (1ll << (x - 1));
          if(++cnt == i) {
            cnt = 0;
            now[k] = (!now.count(k) ? (val += w[i]) : max(now[k], (val += w[i])));
          }
        }
      }
    }
    swap(now, dp);
    for(auto [a, b] : now){
      dp[a] = (!dp.count(a) ? b : max(dp[a], b));
    }
  }
  if(dp.count((1ll << n) - 1)) {
    cout << dp[(1ll << n) - 1] << "\n";
  }else {
    cout << "impossible\n";
  }
}

int main() {
  ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  for(cin >> t; t--; Solve()) {
  }
  return 0;
}