Codeforces Round #732 (Div. 2)

狂刷CF的时机到了，开干开干~~
2021/7/16，第2场，奥里给！！！
第一场：Educational Codeforces Round 111 (Rated for Div. 2)
第三场：Codeforces Round #731 (Div. 3)

A. AquaMoon and Two Arrays

题意：
T次询问，T大小为100.
给定两个序列a和b，长度为n，n大小为100，a和b大小为0~100.
可以对序列a进行操作1若干次，直到a和b序列相等。如果可以，输出每次的操作，否则，输出-1
操作1：每次选择两个下标i和j所在的数字，ai+1，aj-1。

解决：
如果两序列和相等，那么可行
因为只能给某一个数加1，给另一个数减1，那么，若ai大于bi，则每次减1，直到相等。若ai小于bi，每次加1，直到相等。

int n;
int a[N], b[N], c[N];
void work()
{
  memset(c, 0, sizeof c);
  cin >> n;
  int s1 = 0, s2 = 0;
  for (int i = 1; i <= n; i ++ )
  {
    cin >> a[i];
    s1 += a[i];
  }
  for (int i = 1; i <= n; i ++ )
  {
    cin >> b[i];
    s2 += b[i];
  }
  if (s1 != s2)
  {
    cout << "-1" << "\n";
    return;
  }
  int m = 0;
  for (int i = 1; i <= n; i ++ )
  {
    c[i] = a[i] - b[i];
    if (c[i] > 0) m += c[i];
  }
  cout << m << endl;
  for (int i = 1, j = 1; i <= n && j <= n;)
  {
    //c[i]大于0，说明需要减
    while (c[i] <= 0 && i <= n) i ++;
    //c[j]小于0，说明需要加
    while (c[j] >= 0 && j <= n) j ++;
    if (i == j) break;
    // printf("i = %d, c[i] = %d, j = %d, c[j] = %d\n", i, c[i], j, c[j]);
    // printf("i = %d, j = %d\n", i, j);
    cout << i << " " << j << endl; 
    c[i] --; c[j] ++;
  }
} 

B. AquaMoon and Stolen String

题目：
给定一个n和m，表示给出n个长度为m的字符串，其中，n是奇数， n*m小于1e5。
这n个串可以构建n/2对字符串，每队字符串可以在相应位置做交换，交换对应位置的字符。
然后，在给出n-1个字符串，这是交换后的字符串
现在询问你，没有参与交换的字符串是那个串

解决：
给了交换前和交换后的字符串，那么，只要是参与交换的字符串，对应位置的字符一定是出现了偶数次，那么可以根据这一点，找到每一列的出现的次数，如果是奇数次，就是答案了。
当然，官方题解给的代码更好，通过异或，偶数次的字符都会消去，保留下的就是答案了

#include <bits/stdc++.h>
using namespace std;
char s[100005];
char ans[100005];
void work()
{
  int n, m; cin >> n >> m;
  for (int i = 0; i <= m; i ++ ) ans[i] = 0;
  for (int i = 1; i < n << 1; i ++ )
  {
    scanf("%s", s);
    for (int j = 0; j < m; j ++ )
      ans[j] ^= s[j];
  }
  for (int i = 0; i < m; i ++ )
    printf("%c", ans[i]);
    // putchar(ans[i]);
  puts("");
}
int main()
{
  int T; cin >> T;
  while(T -- )
  {
    work();
  }
  return 0;
}

C. AquaMoon and Strange Sort

题目：
T组测试数据，T大小为50，T组n的总和不超过1e5
给定一个长度为n的数组a，a大小为1e5.。我们可以进行操作1，通过最少次数使a数组为升序，问每个数的方向是否可以都指向有方向。
操作1：初始时，每个数字都有一个方向向右。每次可以交换相邻两个数字的位置，同时他们所拥有的方向也会翻转。

解决：
其实，拿到题目，就是向求出来，每个数字交换的次数是奇数次还是偶数次。
这时很显然的，但是，比赛的时候没有做出来，因为自己一直在那里死扣树状数组求逆序对，妄想通过这样来算出来，最后没有成功，我也i没有证明出来，逆序对来接这个题的错误性在哪里，但是，看了题解后才发现是真的简单。
我们将数组交换前的每个元素通过下标对2取模，得到他是位于奇数位置，还是偶数位置。然后我们再给他排个序，排好序后就是我们的终止状态了。那么，这个时候，我们再来标记一下他是在奇数位置还是偶数位置。如果当前元素他即在奇数位置出现过，又在偶数位置出现过，说明他的交换次数一定是奇数次，那么一定就是非法的。

#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n;
int a[N], cnt[N][2];
void work()
{
  memset(cnt, 0, sizeof cnt);
  scanf("%d", &n);
  for (int i = 1; i <= n; i ++ )
    scanf("%d", &a[i]), ++ cnt[a[i]][i % 2];
  sort(a + 1, a + 1 + n);
  for (int i = 1; i <= n; i ++ )
    -- cnt[a[i]][i % 2];
  for (int i = 1; i <= n; i ++ )
    if (cnt[a[i]][0] != 0 && cnt[a[i]][1] != 0)
    {
      puts("NO");
      return;
    }
  puts("YES");
}
int main()
{
  int T; cin >> T;
  while (T -- ) work();
  return 0;
}

D. AquaMoon and Chess

做题地址： Codeforces Round #732 (Div. 2)的D. AquaMoon and Chess

题意：
有T组测试数据，T的大小为10000
每组测试数据有一个长度为n的0/1的字符串，n的大小为1e5，T组数据n的总长度为1e5.
可以执行多次操作1（可以0次），问最多可以得到多少组不同的0/1串
操作1：
如果位置i是1，位置i+1也是1，位置i+2是0，那么，位置i的1，可以与i+2位置的0交换位置。
如果位置i是1，位置i-1也是1，位置i-2也是0，那么，位置i的1，可以与i-2位置的0交换位置。

解决：
先说结论，计算0的个数n，按照规则1计算1的个数m，公式为C(n, n + m)或者C(m, n + m)
规则1，连续的1的个数为k，那么m+=k/2（k是要下取整的）
我看了好多篇题解，都是通过观察出特征，找到规律写的，没怎么有证明正确性的，我尝试证明一下正确性，当然，不一定准确严谨。

证明：
由操作1我们知道，0和1是怎么交换的，那我们可以将此题等价变形，变为0可以填充到1的个数。
根据操作1可知，如果当前位置为0，下一个位置为1，同方向再下一个位置也为1，那么，0就可以走到第二个1的位置，经过迭代，我们可以得出，对于一个0来说，0可达的位置，需要每次跳过两个连续的1才行。那么，对于每个1来说，都满足此规律。不管0是往左走还是往右走，他所能插入的1的，一定是两个1进行打包后的位置。那么，对于不管是奇数个还是偶数个，都是除以2下取整个对数。【加强论证，如果计入后效性，也就是0位置走动后，会对连续的1的长度产生影响。那么，产生的影响，一定是分隔为一个奇长度，和一个偶长度，或者两个偶长度，不可能出现两个奇长度。这也就保证了，我们的连续两个1的对数，在静态的初始状态就是确定好了的，不会随着0的走动而发生更改，那么我们的0的位置的安放，对我们来说就是一个组合问题了】
这是一个组合问题，对于m个0来说，先放到n+m个位置，然后将1填进去就行了，和顺序无关，公式为C (m, n + m).

#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n;
int a[N], cnt[N][2];
void work()
{
  memset(cnt, 0, sizeof cnt);
  scanf("%d", &n);
  for (int i = 1; i <= n; i ++ )
    scanf("%d", &a[i]), ++ cnt[a[i]][i % 2];
  sort(a + 1, a + 1 + n);
  for (int i = 1; i <= n; i ++ )
    -- cnt[a[i]][i % 2];
  for (int i = 1; i <= n; i ++ )
    if (cnt[a[i]][0] != 0 && cnt[a[i]][1] != 0)
    {
      puts("NO");
      return;
    }
  puts("YES");
}
int main()
{
  int T; cin >> T;
  while (T -- ) work();
  return 0;
}