逐月信息学 2024 提高组 #5

合集 - 逐月信息学 2024 提高组(6)

1.逐月信息学 2024 提高组 #12024-07-012.逐月信息学 2024 提高组 #22024-07-053.逐月信息学 2024 提高组 #32024-07-064.逐月信息学 2024 提高组 #42024-07-07

5.逐月信息学 2024 提高组 #52024-07-02

6.逐月信息学 2024 提高组 #62024-07-05

收起

$\mathtt{\text{A. 党同伐异}}$

题目描述

有 $N$ 个候选人，每个候选人都有一个不同的政治倾向 $c_i$，进行 $N-1$ 次选举。每轮选举中，所有未被淘汰的候选人给另一个没被淘汰的候选人。每一个候选人会将票投给 $c_i$ 与自己差的绝对值最大的候选人。如果有多个这样的候选人，选择 $c_i$ 更大的那个。每一轮中获得票最多的人淘汰，如果有多个这样的候选人，选择 $c_i$ 更大的那个。问最后剩下哪个候选人。

思路

首先对 $c_i$ 排序，因为每次淘汰的都是 $c_i$ 最小或最大的人，所以剩余的候选人都是一个区间 $[l,r]$。对于每一轮，二分最后一个 $c_i-c_l\le c_r-c_i$ 的 $i$，则 $[l,i]$ 内的人全部投票给 $r$，$[i+1,r]$ 的人投票给 $l$，比较一下即可。

空间复杂度 $O(N)$，时间复杂度 $O(N\log N)$。

代码

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

const int MAXN = 1000001;

struct Node {
  int x, id;
}a[MAXN];

int n, s = 1, t;

int Binary_Search() {
  int l = s, r = t;
  for(; l < r; ) {
    int mid = (l + r + 1) >> 1;
    (a[mid].x - a[s].x <= a[t].x - a[mid].x ? l = mid : r = mid - 1);
  }
  return l;
}

int main() {
  ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  cin >> n;
  t = n;
  for(int i = 1; i <= n; ++i) {
    cin >> a[i].x;
    a[i].id = i;
  }
  sort(a + 1, a + n + 1, [](const Node &a, const Node &b) { return a.x < b.x; });
  for(int i = 1; i < n; ++i) {
    int x = Binary_Search();
    (x - s + 1 < t - x ? s++ : t--);
  }
  cout << a[s].id;
  return 0;
}

总结

水题。

$\mathtt{\text{B. 混乱谜团}}$

题目描述

定义两个数字 $x,y$ 在排列 $A$ 中的距离为 $|i-j|(A_i=x,A_j=y)$，一个排列 $A$ 的混乱程度为 $1,2$ 的距离、$2,3$ 的距离、$\dots$、$n-1,n$ 的距离之和。给定 $N,K$，请构造一个长度为 $N$，混乱程度为 $K$ 的排列。

思路

我们先看一个混乱度为 $N-1$ 的序列：$[1,2,3,\dots ,N]$。怎么让它的混乱度增加呢？

如果反转 $[2,3,\dots ,N]$，混乱度加 $N-2$。

如果反转 $[3,4,\dots ,N]$，混乱度加 $N-3$;

$⋮$

由于反转是相互独立的，所以我们可以枚举每种反转看是否需要。

空间复杂度 $O(N)$，时间复杂度 $O(N)$。

代码

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

const int MAXN = 100001;

int n, a[MAXN];
ll k;

int main() {
  ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  cin >> n >> k;
  a[1] = 1, k -= n - 1;
  int l = 2, r = n;
  for(int i = 2; l != r; ++i) {
    if(n - i <= k) {
      k -= n - i;
      a[r] = i;
      if(r > l) {
        r--;
      }else {
        r++;
      }
      swap(l, r);
    }else {
      a[l] = i;
      if(r < l) {
        l--;
      }else {
        l++;
      }
    }
  }
  a[l] = n;
  for(int i = 1; i <= n; ++i) {
    cout << a[i] << " ";
  }
  return 0;
}

总结

比较简单，但要记得 long long，而且考场上没做出来。

$\mathtt{\text{C. 固若金汤}}$

题目描述

有一排士兵，每个士兵都有一个默契值 $c_i$。现在要从中挑出一个子序列，使得子序列任意相邻三项按位与均不为 $0$。求最多能选多少士兵。

思路

定义 $d{p}_{i,j}$ 表示子序列末尾选择 $\dots ,j,i$ 的最长长度。但这样的状态是 $O(N^2)$ 的，转移是 $O(N)$ 的，时间爆掉了。

由于状态不能优化，所以考虑优化转移：定义 $f_{i,x}$ 表示以 $i$ 结尾的末两个数按位且第 $x$ 位为一的子序列长度最大值。

这个 $f_{i,x}$ 在 dp 时处理就行了。这时，我们发现转移时就不需要 $j$ 了，于是就 $\mathtt{\text{AC}}$ 了。

时空复杂度均为 $O(N^2)$。

代码

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

const int MAXN = 2001;

int n, a[MAXN], dp[MAXN][MAXN], f[MAXN][32], ans = 1;

int main() {
  ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  cin >> n;
  for(int i = 1; i <= n; ++i) {
    cin >> a[i];
  }
  for(int i = 1; i <= n; ++i) {
    dp[i][0] = 1;
  }
  for(int i = 1; i <= n; ++i) {
    for(int j = 0; j < i; ++j) {
      for(int k = 0; k < 32; ++k) {
        if(!j || (((a[i] & a[j]) >> k) & 1)) {
          f[i][k] = max(f[i][k], dp[i][j]);
        }
      }
      ans = max(ans, dp[i][j]);
    }
    for(int j = i + 1; j <= n; ++j) {
      for(int k = 0; k < 32; ++k) {
        if((a[j] >> k) & 1) {
          dp[j][i] = max(dp[j][i], f[i][k] + 1);
        }
      }
    }
  }
  cout << ans;
  return 0;
}

总结

这道题需要一些思考，考场上未做出。

$\mathtt{\text{D. 替身使者}}$

题目描述

在 $\mathtt{\text{IOI}}$ 中，$\mathtt{\text{HPY}}$ 十分有信心已经 $\mathtt{\text{AK}}$，但为了保险，他准备雇佣 $N$ 个替身中的一些。每个替身都需要 $x_i$ 元的费用，并且要求电脑至少升级到 $k_i$ 级。$\mathtt{\text{HPY}}$ 的电脑原来是 $0$ 级，每升一级需要 $b$ 元。第 $i$ 个替身会 $m_i$ 道题，分别是 $A_{i,1},A_{i,2},\dots ,A_{i.m_i}$，问 $\mathtt{\text{HPY}}$ 至少需要多少钱来保证每道题都至少有一个替身会写？

若不可能则输出 $-1$。

思路

这道题如果去掉电脑升级就十分简单，所以我们来考虑如何去掉这个限制。

我们可以对每个人要求的级数进行排序，这样要求最大的一定是最后一个人。所以就可以省掉这个状态了。

dp：$d{p}_{i,s}$ 表示在前 $i$ 个中选，会的题目集合为 $s$ 时的最少钱数。

加个降维优化就可以了。

空间复杂度 $O(N+2^M)$，时间复杂度 $O(N{2}^M)$。

代码

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

const int MAXN = 101, MAXV = (1 << 21);
const ll INF = (ll)(2e18);

struct Node {
  int x, k, res;
}s[MAXN];

int n, m, b;
ll dp[MAXV], ans = INF;

int main() {
  ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  cin >> n >> m >> b;
  for(int i = 1, k; i <= n; ++i) {
    cin >> s[i].x >> s[i].k >> k;
    for(int j = 1, x; j <= k; ++j) {
      cin >> x;
      s[i].res |= (1 << (x - 1));
    }
  }
  sort(s + 1, s + n + 1, [](const Node &a, const Node &b) { return a.k < b.k; });
  for(int i = 1; i < (1 << m); ++i) {
    dp[i] = INF;
  }
  dp[0] = 0;
  for(int i = 1; i <= n; ++i) {
    for(int j = (1 << m) - 1; j >= 0; --j) {
      dp[j | s[i].res] = min(dp[j | s[i].res], dp[j] + s[i].x);
    }
    ans = min(ans, dp[(1 << m) - 1] + 1ll * s[i].k * b);
  }
  cout << (ans == INF ? -1 : ans);
  return 0;
}

总结

需要注意 long long，$-1$ 等问题。