AtCoder Grand Contest 058 简要题解

从这里开始

Problem A Make it Zigzag

  考虑使 $1, 3, 5, 7, \cdots, 2n - 3$ 这些位置后三个中的最大值在中间,最后再处理一下最后两个位置就行了。

Code

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

const int N = 2e5 + 5;

int n;
int a[N];
vector<int> ans;

int maxp(int a, int b, int c) {
  if (c > max(a, b)) return 2;
  if (b > max(a, c)) return 1;
  return 0;
}

int main() {
  scanf("%d", &n);
  for (int i = 1; i <= (n << 1); i++) {
    scanf("%d", a + i);
  }
  for (int i = 1; i <= (n << 1) - 2; i += 2) {
    int d = maxp(a[i], a[i + 1], a[i + 2]);
    if (d != 1) {
      ans.push_back(min(i + d, i + 1));
      swap(a[i + d], a[i + 1]);
    }
  }
  int n2 = n << 1;
  if (a[n2 - 1] > a[n2]) {
    ans.push_back(n2 - 1);
  }
  printf("%d\n", (signed) ans.size());
  for (auto x : ans) {
    printf("%d ", x);
  }
  return 0;
}

Problem B Adjacent Chmax

  考虑其实问题相当于一个较大数可以把较小数覆盖掉。

  依次考虑原序列每个数在最终序列中占了多长一段。容易发现只需要满足占的那一段里没有比它大的数就可以。

  然后就是个简单 dp。

Code

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

#define ll long long

void exgcd(int a, int b, int& x, int& y) {
	if (!b) {
		x = 1, y = 0;
	} else {
		exgcd(b, a % b, y, x);
		y -= (a / b) * x;
	}
}

int inv(int a, int n) {
	int x, y;
	exgcd(a, n, x, y);
	return (x < 0) ? (x + n) : (x);
}

const int Mod = 998244353;

template <const int Mod = :: Mod>
class Z {
	public:
		int v;

		Z() : v(0) {	}
		Z(int x) : v(x){	}
		Z(ll x) : v(x % Mod) {	}

		friend Z operator + (const Z& a, const Z& b) {
			int x;
			return Z(((x = a.v + b.v) >= Mod) ? (x - Mod) : (x));
		}
		friend Z operator - (const Z& a, const Z& b) {
			int x;
			return Z(((x = a.v - b.v) < 0) ? (x + Mod) : (x));
		}
		friend Z operator * (const Z& a, const Z& b) {
			return Z(a.v * 1ll * b.v);
		}
		friend Z operator ~(const Z& a) {
			return inv(a.v, Mod);
		}
		friend Z operator - (const Z& a) {
			return Z(0) - a;
		}
		Z& operator += (Z b) {
			return *this = *this + b;
		}
		Z& operator -= (Z b) {
			return *this = *this - b;
		}
		Z& operator *= (Z b) {
			return *this = *this * b;
		}
		friend bool operator == (const Z& a, const Z& b) {
			return a.v == b.v;
		} 
};

Z<> qpow(Z<> a, int p) {
	Z<> rt = Z<>(1), pa = a;
	for ( ; p; p >>= 1, pa = pa * pa) {
		if (p & 1) {
			rt = rt * pa;
		}
	}
	return rt;
}

typedef Z<> Zi;

const int N = 5005;

template <typename T>
bool vmax(T& a, T b) {
  return a < b ? (a = b, true) : false;
}

int n;
int vis[N];
int a[N], fa[N];
Zi f[N], g[N];

void build(int l, int r, int v) {
  if (l > r) {
    return;
  }
  int mx = -1, mxp = 0;
  for (int i = l; i <= r; i++) {
    if (vmax(mx, a[i])) {
      mxp = i;
    }
  }
  fa[mxp] = v;
  build(l, mxp - 1, mxp);
  build(mxp + 1, r, mxp);
}

int main() {
  scanf("%d", &n);
  for (int i = 1; i <= n; i++) {
    scanf("%d", a + i);
  }
  a[0] = N, a[n + 1] = N;
  f[0] = 1;
  for (int i = 1; i <= n; i++) {
    int l = i, r = i;
    while (a[l - 1] < a[i]) l--;
    while (a[r + 1] < a[i]) r++;
    Zi s = 0;
    for (int j = l; j <= r; j++) {
      g[j] += (s += f[j - 1]);
    }
    for (int j = 0; j <= n; j++) {
      g[j] += f[j];
      f[j] = g[j];
      g[j] = 0;
    }
  }
  printf("%d\n", f[n].v);
  return 0;
}

Problem C Planar Tree

  差点不会这题,感觉好毒瘤啊。

  如果只有 1, 2 这个题瞎做就好了。

  注意到如果奇数和偶数都能连,就是只有 1, 2 的情况,可是 1, 4 不能连。考虑先把这两个烦人的东西干掉。

  考虑 $(1, 2)$,$(3, 4)$ 相邻的时候直接连起来,然后分别当做只有一个点 2 或者 3。假如原问题有解且不存在这条边,那么显然这条边可以加上去,然后环上随便删一条边就行了。因此原问题和新问题有解性等价。

  注意到如果有连续两个数是相同的,那么可以在其中 1 个连边的时候,两个一起连。考虑把这两个缩一起。和上面同样的方法证明两个问题有解性等价,只是可以加边的原因略有不同。

  现在问题变成 1 不和 2 相邻,4 不和 3 相邻,相邻的数不同,目标把所有的 1, 4 连到别的点上。可以发现,树上不跨过 4 的 $(1, 2)$ 相连会导致至少 1 个 $3$ 不能继续和 4 相连。(如果有跨过 4 的话就考虑这个 $(3, 4)$,这样处理下去可能会得到不跨过 2 的 $(3, 4)$ 相连,但和这个情形是相似的)这样的情况一定是 $(1, 3, 2)$,考虑把这个缩成 $2$,继续这个操作。所以每消去一个 1 就会减少一个 3,每消去一个 4 就会减少一个 2。

  如果不存在 $(1, 3, 2)$ 也不存 $(4, 2, 3)$,那么说明不存在 $(2, 3)$ 相邻的情况,此时可以得到 $4$ 的数量大于等于 $2$ 的数量, $3$ 的数量大于等于 $1$ 的数量(等于是因为可能都没有),此时显然不可能。

  相反如果满足 $2$ 的数量加上 $3$ 的数量大于 $1$ 的数量加上 $4$ 的数量,同时 1 的数量大于等于 3 的数量,4 的数量大于等于 2 的数量,因为每次两个数量和同时减少,所以不可能出现不存在 $(2, 3)$ 相邻的情形。因此只用处理一下,然后数数量就可以了。

Code

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

const int N = 3e5 + 5;

int T, n;
int a[N], stk[N], cnt[5];

int merge(int x, int y) {
  if (x > y) swap(x, y);
  if (x == y) {
    return x;
  }
  if (x + 1 == y && x != 2) {
    return x == 1 ? y : x;
  }
  return 0;
}

void solve() {
  scanf("%d", &n);
  for (int i = 1; i <= n; i++) {
     scanf("%d", a + i);
  }
  int pos = 1, top = 1;
  while (a[pos] == a[1]) pos++;
  rotate(a + 1, a + pos, a + n + 1);
  stk[top] = a[1];
  for (int i = 2, x; i <= n; i++) {
    x = merge(stk[top], a[i]);
    if (x) {
      stk[top] = x;
    } else {
      stk[++top] = a[i];
    }
  }
  int frt = 1, tmp;
  while (frt < top && (tmp = merge(stk[frt], stk[top]))) {
    stk[top] = tmp;
    frt++;
  }
  memset(cnt, 0, sizeof(cnt));
  for (int i = frt; i <= top; i++) {
    cnt[stk[i]]++;
  }
  if (cnt[4] <= cnt[2] && cnt[1] <= cnt[3] && cnt[1] + cnt[4] < cnt[2] + cnt[3]) {
    puts("Yes");
  } else {
    puts("No");
  }
}

int main() {
  scanf("%d", &T);
  while (T--) {
    solve();
  }
  return 0;
}

Problem D Yet Another ABC String

  这种题比那种无聊的猜结论题有意思多了。

  朴素容斥的话相当于硬点若干个位置,然后这个位置起始长度为 3 的子串不合法。有重叠的话不好处理,主要因为 3 种字符的数量有限制。

  考虑让硬点的位置后面一定不和它相连。就是 ABC 后面不是 A。相当于就是对每个这样连续的 ABCABCAB 末做一个子集容斥。

  然后就是个简单组合计数。

Code

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

#define ll long long

void exgcd(int a, int b, int& x, int& y) {
	if (!b) {
		x = 1, y = 0;
	} else {
		exgcd(b, a % b, y, x);
		y -= (a / b) * x;
	}
}

int inv(int a, int n) {
	int x, y;
	exgcd(a, n, x, y);
	return (x < 0) ? (x + n) : (x);
}

const int Mod = 998244353;

template <const int Mod = :: Mod>
class Z {
	public:
		int v;

		Z() : v(0) {	}
		Z(int x) : v(x){	}
		Z(ll x) : v(x % Mod) {	}

		friend Z operator + (const Z& a, const Z& b) {
			int x;
			return Z(((x = a.v + b.v) >= Mod) ? (x - Mod) : (x));
		}
		friend Z operator - (const Z& a, const Z& b) {
			int x;
			return Z(((x = a.v - b.v) < 0) ? (x + Mod) : (x));
		}
		friend Z operator * (const Z& a, const Z& b) {
			return Z(a.v * 1ll * b.v);
		}
		friend Z operator ~(const Z& a) {
			return inv(a.v, Mod);
		}
		friend Z operator - (const Z& a) {
			return Z(0) - a;
		}
		Z& operator += (Z b) {
			return *this = *this + b;
		}
		Z& operator -= (Z b) {
			return *this = *this - b;
		}
		Z& operator *= (Z b) {
			return *this = *this * b;
		}
		friend bool operator == (const Z& a, const Z& b) {
			return a.v == b.v;
		} 
};

Z<> qpow(Z<> a, int p) {
	Z<> rt = Z<>(1), pa = a;
	for ( ; p; p >>= 1, pa = pa * pa) {
		if (p & 1) {
			rt = rt * pa;
		}
	}
	return rt;
}

typedef Z<> Zi;

const int N = 3e6 + 5;

int A, B, C, S;

Zi fac[N], _fac[N], pw2[N];

void init(int n) {
  fac[0] = 1;
  for (int i = 1; i <= n; i++) {
    fac[i] = fac[i - 1] * i;
  }
  _fac[n] = ~fac[n];
  for (int i = n; i; i--) {
    _fac[i - 1] = _fac[i] * i;
  }
  pw2[0] = 1;
  for (int i = 1; i <= n; i++) {
    pw2[i] = pw2[i - 1] * 2;
  }
}

void cswap(int& a, int& b) {
  if (a > b) {
    swap(a, b);
  }
}

Zi comb(int n, int m) {
  return n < m ? 0 : fac[n] * _fac[m] * _fac[n - m];
}

int main() {
  scanf("%d%d%d", &A, &B, &C);
  S = A + B + C;
  cswap(B, C), cswap(A, B), cswap(B, C);
  init(S);
  Zi ans = 0, tmp;
  for (int i = 0; i <= A; i++) {
    // the last one isn't included
    int rest = S - 3 * i;
    tmp = comb(rest + i - 1, i) * pw2[i] * fac[rest] * _fac[A - i] * _fac[B - i] * _fac[C - i];
    // the last one is included
    if (i) {
      tmp += comb(rest + i - 1, i - 1) * pw2[i - 1] * 3 * fac[rest] * _fac[A - i] * _fac[B - i] * _fac[C - i];
    }
    if (i & 1) {
      ans -= tmp;
    } else {
      ans += tmp;
    }
  }
  printf("%d\n", ans.v);
  return 0;
}

Problem E Nearer Permutation

  感觉这种题和码农题一样无聊,反正顺着思路做就完了,每步难度不大,就是思考的过程特别长。虽然也有可能是因为我菜。

  考虑怎么找出 $z$。

  首先考虑怎么算 $d(x, z)$,相当于将 $x$ 第一个位置上的数,在 $z$ 中改为 $1$,第二位置上的数,在 $z$ 中改为 $2$,然后求 $z'$ 的逆序对数。

  这个显然相当于 $i$ 在两个排列中出现的位置构成的有序二元组的逆序对数。

  那么现在有 2 列二元组,每列二元组只知道其中 1 个数,从小到大把 $1$ 到 $n$ 填进去,每次尽可能填较小的数对应的二元组。

  现在问题变成判定把剩下的填进来其中 1 列的逆序对数是否不超过另一列的逆序对数。

  可以发现,只有每对 $i$ 在 $x$ 和 $y$ 中出现的位置构成的有序二元组的逆序对会对差有贡献,并且贡献为 $+1$ 或者 $-1$。(其实这个逆序对其实就是 $i$ 在 $x$ 中出现的位置 $p_i$ 的逆序对)如果 $p_i > p_j (i < j)$ 并且 $(p_i, ?)$ 被先填上数,那么会产生 $+1$ 的差。(最终需要差小于等于 0)我们下面称违反一个逆序对 $(i, j) (i < j, p_i > p_j)$ 指先在 $(p_i, ?)$ 填数。

  因此我们可以至多违反逆序对总数除以 $2$ 向下取整个逆序对。

  然后很容易得到一个明确的求 $z$ 的做法:假设当前在确定第 $i$ 个位置上的数,找尽量小的 $j$ 满足上一条限制,然后填上 $(p_j, i)$。

  现在回到原问题。

  现在我们要填 $p_1, \cdots, p_n$,题目指定了上面做法填 $(p_i, ?)$ 的顺序。

  当我们填了一个 $(p_i, ?)$  且前面有没有填的 $(p_j, ?)$ 时相当于限制此时能违反的数量小于填 $(p_j, ?)$ 会违反的数量。考虑每次填的过程,允许违反的数量每次单调不增,后者至多减少 1。所以如果下一次填的位置 $(p_k, ?)$ 满足 $k < i$,那么意味着上面这个差是刚好变为 $0$,所以填完 $(p_k, ?)$ 后不能再违反任何逆序对。这之后只能每次填 $p$ 最小的没填的位置。

  我们将 $p_i$ 分为 4 类:

  • 第一类位置:满足 $i = z_i$
  • 第三类位置:第一个满足 $z_i > z_{i + 1}$ 的 $z_{i + 1}$
  • 第二类位置:设第三类位置为 $z_t$,那么在 $z_1, \cdots, z_{t - 1}$ 中满足 $z_i > i$ 的为第二类位置
  • 第四类位置:剩下的

  容易发现对于第一类位置没有限制。如果一个现在要填的位置 $p_i$,之前还有没有填的位置 $p_j$,那么一定满足 $p_i < p_j$,否则能违反的限制数一定满足能先填 $p_j$。因此在不考虑第三类位置的情况下,第二类位置的限制在处理出第四类位置的 $p$ 的相对顺序后就已知了。

  我们希望使得逆序对数减去 2 倍被违反的逆序对数为 $0$ 或者 $1$。我们先考虑这个东西的最小值。注意到每产生一个被违反的逆序对的时候对这个值的贡献为 $-1$。

  在不考虑第三类位置的时候,最优方案为第一类位置依次填 $n, n - 1, \cdots$,第一个第二类位置填能填最大的数(能违反的逆序对数到这里的时候最大值就是这个位置上的限制)剩下按顺序填最小的数。

  注意到你可以连续地把这个值加上 1,所以如果第三类位置在第一个第二类位置的后面就做完了。

  考虑第三类位置在所有第二类位置之前的情形。

  如果第三类位置填上后后面有 $x$ 个数比它小,那么到这个位置的时候允许违反的逆序对数也是 $x$。第三类位置对于倒数第 $i$ 个被填上的第二类位置有一个限制:这后面至多有 $i - 1$ 个数比它小(注意求 $z$ 的过程运行到这里的时候允许违反的逆序对数是 $x$)。此时显然最优的话把第一个第二类位置填能填的最大的,剩下的没填的按顺序填能填的最小的。因此我们只用求一下最大可能的 $x$ 即可。(注意这里所有的第二类位置都对这个第三类位置有限制,因为经过第一个第二类位置后,允许违反的逆序对数是 $x$ 不是 $0$)。

Code

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

template <typename T>
bool vmin(T& a, T b) {
  return a > b ? (a = b, true) : false;
}

const int N = 3e5 + 5;

typedef class Fenwick {
  public:
    int n;
    int a[N];

    void init(int n) {
      this->n = n;
      fill(a, a + n + 1, 0);
    }
    
#define lowbit(_) ((_) & -(_)) 
    void add(int idx, int val) {
      for ( ; idx <= n; idx += lowbit(idx)) {
        a[idx] += val;
      }
    }
    int query(int idx) {
      int ret = 0;
      for ( ; idx; idx -= lowbit(idx)) {
        ret += a[idx];
      }
      return ret;
    }
    int query(int l, int r) {
      return query(r) - query(l - 1);
    }
} Fenwick;

int T, n;
Fenwick fen;
int a[N], les[N];

void solve() {
  scanf("%d", &n);
  for (int i = 1; i <= n; i++) {
    scanf("%d", a + i);
  }
  int p1, p2;
  for (p1 = 1; p1 <= n && a[p1] == p1; p1++);
  if (p1 >= n) {
    puts("Yes");
    return;
  }
  for (p2 = p1 + 1; p2 <= n && a[p2] > a[p2 - 1]; p2++);
  
  long long dif = -1ll * (n + n - p1) * (p1 - 1) / 2;   
  fen.init(n);
  for (int i = n; i >= p1; i--) {
    int p = a[i];
    dif += fen.query(p);
    fen.add(p, 1);
  }
  for (int i = 1; i <= n; i++) {
    les[i] = n + 1;
  }
  fen.init(n);
  for (int i = p2; i <= n; i++) {
    int p = a[i];
    if (i != p2) {
      les[p] = fen.query(p, n);
    }
    fen.add(p, 1);
  }
  if (a[p2] > a[p1]) {
    int lim = n + 1;
    for (int i = p1; i <= a[p1]; i++) {
      vmin(lim, les[i]);
    }
    dif -= lim + (p2 - p1 - 1);
  } else {
    int lim = n - a[p2] - (p2 - p1);
    for (int i = 2; i <= n; i++) {
      vmin(les[i], les[i - 1]);
    }
    for (int i = p1; i < p2; i++) {
      vmin(lim, les[a[i]] + p2 - i - 1);
    }
    vmin(lim, les[a[p2]] - 1);
    dif -= lim + p2 - p1 - 1;
  }
  puts((dif < 2) ? "Yes" : "No");
}

int main() {
  scanf("%d", &T);
  while (T--) {
    solve();
  }
  return 0;
}

Problem F Authentic Tree DP

  别催了,在路上了.jpg

  不懂就问,这题是给人做的吗?

  (尝试给题解编一个思路)

  显然你需要给这个式子找一个组合意义。看到 $\frac{1}{n}$ 容易想到是选择某个东西。但是这个 $\sum$ 枚举的是边。考虑每条边拆出一个新点,向原来的两个点连边。但这样变成了 $\frac{1}{2n - 1}$。考虑给这样每个新点挂 $P - 1$ 个叶子,这样 $n - 1$ 个新点的贡献就被消掉了。

  这个式子大概是在算一个概率一样的东西,同时注意到枚举的一定是新点,然后将树分成独立的两部分。如果考虑这样得到一个序列,每次在选择在最前的点,可以为这个过程编一个组合意义:求所有新点在序列中的位置在所有邻居前面的概率。

  问题变成一棵树,给定边的定向,问拓扑序方案数。直接对指向根的有向边容斥做背包就完事了。

Code

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

#define ll long long

void exgcd(int a, int b, int& x, int& y) {
	if (!b) {
		x = 1, y = 0;
	} else {
		exgcd(b, a % b, y, x);
		y -= (a / b) * x;
	}
}

int inv(int a, int n) {
	int x, y;
	exgcd(a, n, x, y);
	return (x < 0) ? (x + n) : (x);
}

const int Mod = 998244353;

template <const int Mod = :: Mod>
class Z {
	public:
		int v;

		Z() : v(0) {	}
		Z(int x) : v(x){	}
		Z(ll x) : v(x % Mod) {	}

		friend Z operator + (const Z& a, const Z& b) {
			int x;
			return Z(((x = a.v + b.v) >= Mod) ? (x - Mod) : (x));
		}
		friend Z operator - (const Z& a, const Z& b) {
			int x;
			return Z(((x = a.v - b.v) < 0) ? (x + Mod) : (x));
		}
		friend Z operator * (const Z& a, const Z& b) {
			return Z(a.v * 1ll * b.v);
		}
		friend Z operator ~(const Z& a) {
			return inv(a.v, Mod);
		}
		friend Z operator - (const Z& a) {
			return Z(0) - a;
		}
		Z& operator += (Z b) {
			return *this = *this + b;
		}
		Z& operator -= (Z b) {
			return *this = *this - b;
		}
		Z& operator *= (Z b) {
			return *this = *this * b;
		}
		friend bool operator == (const Z& a, const Z& b) {
			return a.v == b.v;
		} 
};

Z<> qpow(Z<> a, int p) {
	Z<> rt = Z<>(1), pa = a;
	for ( ; p; p >>= 1, pa = pa * pa) {
		if (p & 1) {
			rt = rt * pa;
		}
	}
	return rt;
}

typedef Z<> Zi;

typedef vector<Zi> Poly;

const int N = 5005;

Poly operator * (Poly a, Poly b) {
  int n = a.size(), m = b.size();
  Poly c (n + m - 1, 0);
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
      c[i + j] += a[i] * b[j];
    }
  }
  return c;
}

int n;
Zi Inv[N];
vector<int> G[N];

void init_inv(int n) {
  Inv[1] = 1;
  for (int i = 2; i <= n; i++) {
    Inv[i] = Inv[Mod % i] * (Mod - Mod / i);
  }
}

Poly dfs(int p, int fa) {
  Poly f {0, 1};
  for (auto e : G[p]) {
    if (e ^ fa) {
      Poly g = dfs(e, p);
      for (int i = 1; i < (signed) g.size(); i++) {
        g[i] *= Inv[i];
        g[0] += g[i];
        g[i] = -g[i];
      }
      f = f * g;
    }
  }
  for (int i = 1; i < (signed) f.size(); i++) {
    f[i] *= Inv[i];
  }
  return f;
}

int main() {
  scanf("%d", &n);
  for (int i = 1, u, v; i < n; i++) {
    scanf("%d%d", &u, &v);
    G[u].push_back(v);
    G[v].push_back(u);
  }
  init_inv(n);
  auto f = dfs(1, 0);
  Zi ans = 0;
  for (auto x : f) {
    ans += x;
  }
  printf("%d\n", ans.v);
  return 0;
}

posted @ 2022-08-22 23:59  阿波罗2003  阅读(156)  评论(0编辑  收藏  举报