Codeforces Round 954 (Div. 3)

A. X Axis
题意：在一条x轴上给定三个点，找到一个点，使得:${\sum }_{i=1}^3|x-ai|$最大。

解：注意到: $0<=x<=10$，故遍历每个点计算即可。

B. Matrix Stabilization
题意：给定一个$n\ast m$的矩阵，找到某个单元格$(i,j)$，与它相邻的单元格的值严格小于它的值，然后将该单元格的值一直减小直到不满足严格小于的条件；若有多个这样的单元格，从左到右、从上到下执行。问最后的矩阵如何。

解：若有这样一个单元格，那么这个单元格一定会变成与它相邻的单元格中的最大值。
顺序检查修改即可。

C. Update Queries
题意：给定长度为$n$的字符串$s$和$m$个整数$in{d}_i$，其中$in{d}_i$对应$s$中的索引，以及长度为$m$的字符串$c$，可以任意排列$ind$数组，按照顺序执行：$s[in{d}_i]=c[i]$，问可以得到字典序最小的字符串$s$。

解：首先可以对字符串$c$按照字典序排序，因为$ind$数组可以任意打乱。字符串$s$中只有$in{d}_i$位置上会改变，按照排序后的字符串依次放入即可。需要注意的是我们需要对$ind$数组去重，因为存在覆盖关系。

AC代码：

void solve()
{
      int n, m; cin >> n >> m;
      string s; cin >> s;
      vector<int> ind(m);
      forn (i, 0, m) cin >> ind[i];
      set<int> pos;
      forn (i, 0, m) pos.insert(ind[i]);
      string c; cin >> c;
      sort(all(c)); int cnt = 0;
      for(auto i : pos) {
            s[i - 1] = c[cnt++];
      }
      cout << s << endl;
}

D. Mathematical Problem
题意：给定长度为$n$的字符串，向其中插入$n-2$个$+$或$\times$，使得运算式结果最小。

解：因为插入$n-2$个符号，那么一定有一个两位数 (但值可能只有一位)，那么我们可以枚举两位数。我们可以贪心的将每个不为$1$的数加入到结果中，将每个$1$不计入（使用乘号），需要注意的是当我们枚举的这个数为 $01$时，需要对答案减一，因为我们可以使用乘号忽略本身。

AC代码：

void solve()
{
      int n; cin >> n;
      string s; cin >> s;
      if(n == 2) {
            cout << stoll(s) << endl;
            return;
      } else {
            forn (i, 0, n) {
                  if(s[i] == '0') {
                        if(n != 3 || i != 1) {
                              cout << 0 << endl;
                              return;
                        }
                  }
            }
            int ans = 1e9;
            forn (i, 2, n + 1) {
                  string c = "";
                  c.push_back(s[i - 2]), c.push_back(s[i - 1]);
                  int num = stoll(c);
                  int flag = 0;
                  if(num == 1) num = 0, flag = 1;
                  forn (j, 0, n) {
                        if(j == i - 2 || j == i - 1) continue;
                        if(s[j] == '1') {
                              if(flag) {num += 1; continue;}
                              else continue;
                        }
                        num += s[j] - '0';
                  }
                  ans = min(ans, num);
            }
            cout << ans << endl;
      }
}

E. Beautiful Array
题意：给定一个数组$a$和$k$，做任意次如下操作：$a_i=a_i+k$。定义美丽数组：对于$1\le i\le n$，$b_i=b_{n-i+1}$.问至少多少次操作可以将数组$a$变为美丽数组。

解：我们需要两两配对，使得$a_i=a_j+xk$，即$a_i\equiv a_j(modk)$，余数相同的可以放入一组中，并记录下$b_i=a_i/k$。若组中元素数量为偶数，那么按大小排序后顺序两两配对为最优，即$b_2-b_1+b_4-b_3...+b_m-b_{m-1}$，$m$为一组中的元素数量；若组中元素数量为奇数，那么有一个无需配对，可以将其删掉并按照偶数的方案计算。可以枚举被删的数字，但如果我们每次都按照这个方案计算，时间复杂度为$O(n^2)$，我们无法接受。观察可知，删除第奇数个一定优于删掉第偶数个，如图：

我们可以考虑前缀和来减低复杂度：创建一个$d$数组，$d_i=b_i-b_{i-1}$,创建$s1$和$s2$数组，对于$1\le i<d.size()$，当$i$为奇数时， $s{1}_{(i+1)/2}=s{1}_{(i-1)/2}+d_i$; 当$i$为偶数时，$s{1}_{i/2}=s{1}_{(i-1)/2}+d_i$，这样得到$d$数组奇数索引下的前缀和以及偶数索引下的前缀和。当我们删除第一个数，得到的结果为$d_2+d_4+...$，即$s{2}_k$,当我们删除第二个数时，得到的结果为$d_1+d_4+...$，即$s{1}_1+(s{2}_k-s{2}_1)$,以此类推取$min$即可。
讨论无解情况：当$n$为偶数时，分组后每个组的元素个数都必须为偶数才能成功配对；当$n$为奇数时，至多一个组的元素个数为奇数，否则无解。

AC代码：

void solve()
{
      int n, k, flag; cin >> n >> k;
      vector<int> a(n);
      forn (i, 0, n) cin >> a[i];
      map<int, int> mr;
      forn (i, 0, n) mr[a[i] % k]++;
      if(n & 1) flag = 1; 
      else flag = 0;
      for(auto &[x, y] : mr) {
            if(y % 2 != 0) flag -= 1;
      }
      if(flag < 0) {
            cout << -1 << endl;
            return;
      }
      ll ans = 0; map<int, vector<int>> mp;
      forn (i, 0, n) {
            mp[a[i] % k].push_back(a[i] / k);
      }
      for(auto &[x, b] : mp) {
            sort(all(b));
            if(b.size() % 2 == 0) {
                  for(int i = 0; i < b.size(); i += 2) {
                        ans += b[i + 1] - b[i];
                  }
            } else {
                  if(b.size() != 1) {
                        vector<int> d(b.size());
                        forn (i, 1, d.size()) d[i] = b[i] - b[i - 1];
                        vector<ll> s1(d.size() / 2 + 1), s2(d.size() / 2 + 1);
                        forn (i, 1, d.size()) {
                              if(i & 1) s1[(i + 1) / 2] = s1[(i - 1) / 2] + d[i];
                              else s2[i / 2] = s2[(i - 1) / 2] + d[i];
                        }
                        ll num = 1e15;
                        for(int i = 0; i < b.size(); i += 2) {
                              int l = i / 2; int r = d.size() / 2;
                              num = min(num, s2[r] - s2[l] + s1[l]);
                        }
                        ans += num;
                  }
            }
      }
      cout << ans << endl;
}