牛客小白月赛96（待F）

比赛链接：牛客小白月赛96

---

赛时感受

赛时在前面卡的时间有点长，C题没开longlong wa了n发，D题没考虑负数又wa了n发，然后来写E的时候时间就不长了，匆忙写一次交一发。

---

A

思路

当其中一个人解题数达到6时，则不可能使得令一方反超，输出-1，其他情况只需要另一方多解除两个题目即可反超。

题解

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
#define ll long long

int n;

int main() {
  string s1, s2;
  cin >> s1 >> s2;
  int len1 = s1.length(), len2 = s2.length();
  if (len1 == 6 || len2 == 6)
    cout << -1 << endl;
  else
    cout << abs(len1 - len2) + 1 << endl;

  return 0;
}

---

B

思路

考虑000111的情况时需要现将000111变为000011，000000的情况不需要操作。则其他的情况如：0和1的个数相同时：010101，直接取[1, 5]，[1, 6]即可满足条件，0和1的个数不同时：0011101，直接取[1, 7]

代码

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
#define ll long long

int n;

int main() {
  cin >> n;
  string s;
  cin >> s;

  int len = s.length(), count1 = 0, count0 = 0;
  for (int i = 0; i < len; i++) {
    if (s[i] == '0')
      count0++;
    else
      count1++;
  }

  if (count0 == count1) {
    if (len == 2) {
      cout << -1 << endl;
    } else {
      cout << 2 << endl;
    }
  } else if (n != 1 && count1 && count0) {
    cout << 1 << endl;
  } else {
    cout << 0 << endl;
  }

  return 0;
}

---

C

思路

枚举j + 1的数组下标，然后二分优化找出能满足条件的i的最大值maxi，然后此时小于当前maxi的所有i值都能满足题目的山峰数组，即为枚举j + 1时的所有maxi之和就是答案，当枚举j + 1之后，此时的a[3] > a[1] + a[2]时不可能枚举出一个i使得a[1] < a[2] > a[3]，所以退出循环。

题解

#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
#define ll long long

ll n;
ll p[N], sum[N];
int main() {
  cin >> n;
  for (int i = 1; i <= n; i++) {
    cin >> p[i];
    sum[i] = sum[i - 1] + p[i];
  }

  ll ans = 0;
  for (int j = n; j >= 1; j--) {
    ll l = 0, r = j - 1, mid, res = 0, a3 = sum[n] - sum[j - 1];
    if (a3 > sum[j - 1]) break;
    while (l <= r) {
      mid = (l + r) >> 1;
      ll a2 = sum[j - 1] - sum[mid];
      if (a2 > sum[mid] && a2 > a3) {
        res = mid;
        l = mid + 1;
      } else {
        r = mid - 1;
      }
    }
    if (res == 0) break;
    ans += res;
  }

  cout << ans << endl;

  return 0;
}

---

D

思路

考虑a,当a小于0的时候，把所有的奇偶性相同的节点之间能形成的最大连接条数全部连起来，再考虑需不需要取一个奇数点和一个偶数点连起来，当b小于0的时候，把所有奇偶性不同的节点之间能形成的最大连接条数连接起来。

题解

#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
#define ll long long

ll odd[N], even[N], count1, count0;
void solve() {
  ll n, a, b, sum0 = 0, sum1 = 0;
  count1 = count0 = 0;
  cin >> n >> a >> b;
  for (int i = 1; i <= n; i++) {
    ll x;
    cin >> x;
    if (x % 2)
      count1++;
    else
      count0++;
  }

  // 计算所有奇数点之间能形成的最大连线条数，所有偶数点之间能形成的最大连线条数
  ll num = ((count1 - 1) * count1 / 2 + (count0 - 1) * count0 / 2);
  if (count1 == 0 || count0 == 0) {
    // 都是奇数或者偶数
    // 当a小于0时，为了得到最小的代价，将所有奇数点之间能形成的最大连线条数，所有偶数点之间能形成的最大连线条数全部连起来
    if (a < 0) {
      cout << a * num << endl;
    } else {
      cout << a * (n - 1) << endl;
    }
  } else if (a < 0 && b < 0) {
    // 若a和b都小于0，为了得到最小的代价，将所有点之间能形成 的最大连线条数全部连起来
    cout << a * num + (n * (n - 1) / 2 - num) * b << endl;
  } else if (a > b) {
    // 若b小于0，为了得到最小的代价将所有奇偶不同的点之间能形成的最大连线条数全部连起来
    if (b < 0) {
      cout << (n * (n - 1) / 2 - num) * b << endl;
    } else {
      cout << b * (n - 1) << endl;
    }
  } else {
    // a小于0，将奇偶相同的点之间能形成的最大连线条数全部连起来，再将奇数点中任选一个和偶数点中任选一个连接起来
    if (a < 0) {
      cout << a * num + b << endl;
    } else {
      cout << a * (n - 2) + b << endl;
    }
  }
  return;
}
int main() {
  int t;
  cin >> t;
  while (t--) {
    solve();
  }

  return 0;
}

---

E

思路

由于题目需要用到上层节点和下层节点的权值和，所以在输入数据的时候计算每个节点的上层节点和下层节点的权值和，然后一遍dfs()计算每个节点及其子树上的平衡点个数和标记当前节点是否为平衡点和计算每个节点及其上层节点的平衡点个数。

       用未删边的树的平衡点个数来初始化答案res，然后依次枚举所删除的节点，并判断当前节点所有的上层节点是否是平衡点，当前节点不是平衡点时，上面的所有节点都不会是平衡点，所以直接退出时间优化。

题解

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
#define ll long long

// be数组计算当前节点及其子树的权值和和稳定点个数，af数组计算当前节点及其所有祖先节点的权值和和稳定点个数，a数存储节点权值，fa数组存储当前节点的父亲节点
ll n, a[N], fa[N], before_value[N], after_value[N], ans, after_num[N], before_num[N];
bool flag[N];
vector<int>edge[N];
// 计算原树中稳定点的个数和标记原树中是稳定点的节点
void dfs(int x) {
  if (after_value[x] <= a[x] * 2 && a[x] * 2 <= before_value[x])
    after_num[x]++, flag[x] = true;
  ll len = edge[x].size();
  for (int i = 0; i < len; i++) {
    dfs(edge[x][i]);
    after_num[x] += after_num[edge[x][i]];
  }
}

void dfs1(int x) {
  before_num[x] += before_num[fa[x]] + flag[x];
  int len = edge[x].size();
  for (int i = 0; i < len; i++) {
    dfs1(edge[x][i]);
  }
}

int main() {
  cin >> n;
  ll res = 0;
  for (int i = 1; i <= n; i++) {
    cin >> a[i];
    before_value[i] = after_value[i] = a[i];
  }

  for (int i = 1; i <= n; i++) {
    cin >> fa[i];
    edge[fa[i]].push_back(i);
    before_value[i] += before_value[fa[i]];
  }

  for (int i = n; i; i--) {
    after_value[fa[i]] += after_value[i];
  }

  // 枚举删边，计算原树的稳定点个数
  ans = 0;
  dfs(1);
  dfs1(1);
  res = max(res, after_num[1]);
  ll mark = after_num[1];

  for (int i = 2; i <= n; i++) {
    ans = mark - after_num[i] - before_num[fa[i]];
    // 修改当前节点的祖先节点为下标的af数组的权值和，并判断当前节点在删边之后是否是稳定点
    for (int j = fa[i]; j; j = fa[j]) {
      if (after_value[j] - after_value[i] <= a[j] * 2 &&
          a[j] * 2 <= before_value[j]) {
        ans++;
      } else {
        break;
      }
    }
    res = max(res, ans);
  }
  cout << res << endl;

  return 0;
}

---

F

思路

题解