Codeforces Round #726 (Div. 2)

@[toc](Codeforces Round #726 (Div. 2))

A. Arithmetic Array

sum表示n个数字之和，若sum == n，则不用操作，若sum < n我们只需要补一个数就可以达到目标，如果sum>n，需要补sum-n个0

#include <bits/stdc++.h>
using namespace std;
void work()
{
  int n; cin >> n;
  int sum = 0;
  for (int i = 0; i < n; i ++ )
  {
    int x; scanf("%d", &x);
    sum += x;
  }
  if (sum == n) cout << "0" << endl;
  else if (sum < n) cout << "1" << endl;
  else cout << sum - n << endl;
}
int main()
{
  int T; cin >> T;
  while (T -- ) work();
  return 0;
}

B. Bad Boy

如果放在了边界上，就把两点安放到对面边界上。如果放在了其他地方，在两个对顶角上各安放一个

#include <bits/stdc++.h>
using namespace std;
void work()
{
  int n, m, x, y; cin >> n >> m >> x >> y;
  if (x == 1)
  {
    printf("%d %d %d %d\n", n, 1, n, m);
  }
  else if (x == n)
  {
    printf("%d %d %d %d\n", 1, 1, 1, m);
  }
  else if (y == 1)
  {
    printf("%d %d %d %d\n", 1, m, n, m);
  }
  else if (y == m)
  {
    printf("%d %d %d %d\n", 1, 1, n, 1);
  }
  else
  {
    printf("%d %d %d %d\n", 1, 1, n, m);
  }
}
int main()
{
  int T; cin >> T;
  while (T -- ) work();
  return 0;
}

C. Challenging Cliffs

题意： 给定一个长度位n的数组，你可以随意排列，问你最大有多少个正序对，同时要保证第一个元素与最后一个元素要差值最小

做法：先将序列从小到大排个序，使得先在满足第一个条件，正序对最多，找到差值最小的地方，假设差值最小的两个值分别是第x位置，和第x+1的位置，我们先输出位置为x的元素，然后输出大于位置x+1的所有元素，然后输出前面已经输出的和位置x+1的元素，将其他元素都给输出，最后再输出x+1位置的元素

#include <bits/stdc++.h>
using namespace std;
void work()
{
  int n; cin >> n;
  vector<int> v(n);
  for (auto &x : v) cin >> x;
  sort(v.begin(), v.end());
  int m = 1e9, last = -1e9, id = 0;
  for (int i = 0; i < n; i ++ )
  {
    if (v[i] - last < m) m = v[i] - last, id = i - 1;
    last = v[i];
  }
  cout << v[id] << " ";
  vector<int> st(n, 0);
  st[id] = st[id + 1] = true;
  for (int i = 0; i < v.size(); i ++ )
  {
    if (st[i]) continue;
    if (v[i] >= v[id + 1])
    {
      st[i] = true;
      cout << v[i] << " ";
    }
  }
  for (int i = 0; i < n; i ++ )
    if (!st[i]) cout << v[i] << " ";
  cout << v[id + 1] << endl;
}
int main(void)
{
  int n; cin >> n;
  while (n -- ) work();
  return 0;
}

D. Deleting Divisors

首先，我们明白，当n为1或者为素数的时候，先手必败。
然后，我们发现，n为奇数的时候一定是先手必败。
证明：任何一个大于1奇数都可以转化为一个偶数，而且这个偶数一定是大于2的，恰好，它所转移到的状态永远不会失败，所以，他是一个必败状态。再说一下，为啥这里的奇数减去一个他的约数不会是2，因为对于任意的x，x + 2 与x一定是互质的。
最后，我们再看偶数，偶数可以进行三种转移，第一，变成2，这时必败局面，第二，可以变成奇数，（说明除了有2的幂级约数外，还有奇数约数的存在）有我们的第二步知道，这是一种必胜态。第三，只可以变成偶数，（说明，里面没有奇数约数，也就是这个数是一个2的幂级数，那么，不难发现，偶次幂的数必胜，奇次幂必败。（如果是偶次幂，一定可以将当前数变成我们的上一段说的第二种情况，奇数次幂则不行）。

void work()
{
  int n; cin >> n;
  if (n & 1) {puts("Bob");return;}
  int cnt = 0;
  while (true)
  {
    if (n % 2 == 0)
    {
      n /= 2;
      cnt ++;
    }
    else break;
  }
  if (n > 1) cout << "Alice" << endl;
  else if (cnt & 1) cout << "Bob" << endl;
  else cout << "Alice" << endl;
}

E1. Erase and Extend (Easy Version)

1e3大小，暴力枚举两种操作，最后输出最小的情况

#include <bits/stdc++.h>
using namespace std;
int main()
{
  vector<string> v;
  int n, k; cin >> n >> k;
  string s; cin >> s;
  for (int i = 1; i <= n; i ++ )
  {
    string x;
    //剪切
    for (int j = 0; j < i; j ++ )
      x += s[j];
    //粘贴
    string y;
    for (int j = 1; j <= (k + i - 1) / i; j ++ )
      y += x;
    v.push_back(y.substr(0, k));
  }
  sort(v.begin(), v.end());
  cout << v[0] << endl;
  return 0;
}