[题解]对！我是狗！
\[\color{red}{\textsf{小游者，真神人也，左马桶，右永神，会执利笔破邪炁，何人当之？}} \\
\begin{array}{|}
\hline
\color{pink}{\text{A small swimmer is a God.}} \\
\color{pink}{\text{The left toilet and the right eternal God}} \\
\color{pink}{\text{can break the evil energy with a sharp pen.}} \\
\color{pink}{\text{Who can resist him? }} \\
\hline
\end{array} \\
\begin{array}{|}
\hline
\color{green}{\text{小遊者は、神であり、左便器、右永神であり}} \\
\color{green}{\text{鋭いペンを持って真実を突き刺している。誰が彼に抵抗できるだろうか？ }} \\
\hline
\end{array} \\
\begin{array}{|}
\hline
\color{lightblue}{\text{Petit voyageur, est Dieu aussi, toilettes gauche, Dieu éternel droit,}} \\
\color{lightblue}{\text{peut tenir un stylo tranchant pour briser le mal, qui devrait le faire?}} \\
\hline
\end{array} \\
\begin{array}{|}
\hline
\color{purple}{\text{Der Direktor ist wirklich ein Gott}} \\
\color{purple}{\text{mit einer Toilette links und Yongshen rechts}} \\
\color{purple}{\text{der einen spitzen Stift hält}} \\
\color{purple}{\text{um die Wahrheit zu durchdringen.}} \\
\color{purple}{\text{Wer kann ihm widerstehen? }} \\
\hline
\end{array} \\
\begin{array}{|}
\hline
\color{cyan}{\text{Ein kleiner Schwimmer ist ein Gott.}} \\
\color{cyan}{\text{Die linke Toilette und der rechte ewige Gott können }} \\
\color{cyan}{\text{die böse Energie mit einem scharfen Stift brechen.}} \\
\color{cyan}{\text{Wer sollte es sein?}} \\
\hline
\end{array} \\
\color{red}{\textsf{对曰：“无人，狗欲当之，还请赐教！”}} \\
\newcommand\brak[1]{\left({#1}\right)}
\newcommand\Brak[1]{\left\{{#1}\right\}}
\newcommand\d[0]{\text{d}}
\newcommand\string[2]{\genfrac{\{}{\}}{0pt}{}{#1}{#2}}
\newcommand\down[2]{{#1}^{\underline{#2}}}
\newcommand\ddiv[2]{\left\lfloor\frac{#1}{#2}\right\rfloor}
\newcommand\udiv[2]{\left\lceil\frac{#1}{#2}\right\rceil}
\newcommand\lcm[0]{\operatorname{lcm}}
\newcommand\set[1]{\left\{{#1}\right\}}
\newcommand\ceil[1]{\left\lceil{#1}\right\rceil}
\newcommand\floor[1]{\left\lfloor{#1}\right\rfloor}
\newcommand\rhs[1]{\;\text{Rhs}\;#1}
\newcommand\lhs[1]{\;\text{Lhs}\;#1}
\newcommand\Vec[1]{\vec{\mathbf{#1}}}
\newcommand\rank[0]{\text{rank}}
\newcommand\group[1]{\left\langle\right\rangle}
\newcommand\norm[1]{\left|{#1}\right|}
\newcommand\E[0]{\mathbb{E}}
\newcommand\Pro[0]{\mathbb{P}}
\]
这场考试的题解给咕掉了，但是题目质量很好啊。
No Way Out
一旦别人说你走自己的路时，就走别人的路，让别人无路可走。
当一个人脱离 \(s-t\) 的路径时，它的答案就被确定下来，因此，我们只需要枚举 \(\mathcal O(n)\)（大概是 \(\mathcal \Theta(2n)\)？）个先后手所在的位置，并且看看这一步到底是谁脱离了链，就可以算出来接下来的时间的答案。
人与狗
人以利聚，狗以骨分。
如果没有 \(S\) 的限制，就是朴素的生成树问题。
显然，如果要满足 \(S\) 的限制，相当于所选的边集在 \(S\) 的导出子图中也应是一棵树，换言之，一颗生成树要满足一个 \(S\) 的条件是，在 \(S\) 的导出子图中有 \(\norm S-1\) 条边，对于其他任何条件也是一样。
那么，我们可以重新构建一个图，这个图中满足 \(\displaystyle w(i,j)=\sum_{k=1}^m [i,j\in S_k]\)，在这个重构图中，一颗合法的生成树必须满足 \(\sum w=\sum (\norm S-1)\)，并且，在这个重构图中，所有生成树的权值都不会超过右式，因此，我们可以对这个重构图进行最大生成树计数。具体还看看代码。
/** @author __Elaina__ */
// #pragma GCC optimize("Ofast")
// #pragma GCC optimize("inline")
// #define GCC optimize(2)
// #define GCC optimize(3)
#include <bits/stdc++.h>
using namespace std;
// #define USING_FREAD
// #define NDEBUG
#include <cassert>
namespace Elaina {
/** その可憐な少女は魔女であり、旅人でした。 ―― そう、私です! */
#define rep(i, l, r) for(int i = (l), i##_end_ = (r); i <= i##_end_; ++i)
#define repf(i, l, r) for (int i = (l), i##_end_ = (r); i < i##_end_; ++i)
#define drep(i, l, r) for(int i = (l), i##_end_ = (r); i >= i##_end_; --i)
#define fi first
#define se second
#define mp(a, b) make_pair(a, b)
#define Endl putchar('\n')
#define whole(v) ((v).begin()), ((v).end())
#define bitcnt(s) (__builtin_popcount(s))
/** @warning no forced type conversion */
#define rqr(x) ((x) * (x))
#define y0 FUCK_UP
#define y1 MOTHER_FUCKER
#define masdf(...) fprintf(stderr, __VA_ARGS__)
typedef long long ll;
typedef unsigned long long ull;
typedef std::pair<int, int> pii;
typedef vector<int> vset;
template<class T> inline T fab(T x) { return x < 0 ? -x : x; }
template<class T> inline void chkmin(T& x, const T rhs) { x = std::min(x, rhs); }
template<class T> inline void chkmax(T& x, const T rhs) { x = std::max(x, rhs); }
#ifdef USING_FREAD
inline char qkgetc() {
# define BUFFERSIZE 1 << 20
static char BUF[BUFFERSIZE], *p1 = BUF, *p2 = BUF;
return p1 == p2 && (p2 = (p1 = BUF) + fread(BUF, 1, BUFFERSIZE, stdin), p1 == p2) ? EOF : *p1++;
# undef BUFFERSIZE
}
# define CHARRECEI qkgetc()
#else
# define CHARRECEI ((char)getchar())
#endif
template<class T> inline T readret(T x) {
x = 0; int f = 0; char c;
while (!isdigit(c = CHARRECEI)) if(c == '-') f = 1;
for (x = (c ^ 48); isdigit(c = CHARRECEI); x = (x << 1) + (x << 3) + (c ^ 48));
return f ? -x : x;
}
template<class T> inline void readin(T& x) {
x = 0; int f = 0; char c;
while (!isdigit(c = CHARRECEI)) if (c == '-') f = 1;
for (x = (c ^ 48); isdigit(c = CHARRECEI); x = (x << 1) + (x << 3) + (c ^ 48));
if (f) x = -x;
}
template<class T, class... Args> inline void readin(T& x, Args&... args) {
readin(x), readin(args...);
}
template<class T> inline void writln(T x, char c = '\n') {
if (x < 0) putchar('-'), x = -x;
static int __stk[55], __bit = 0;
do __stk[++__bit] = x % 10, x /= 10; while (x);
while (__bit) putchar(__stk[__bit--] ^ 48);
putchar(c);
}
template<class T> inline T listMax(const T& x) { return x; }
template<class T, class... Args> inline T listMax(const T& x, const Args&... args) {
return max(x, listMax(args...));
}
template<class T> inline T listMin(const T& x) { return x; }
template<class T, class... Args> inline T listMin(const T& x, const Args&... args) {
return min(x, listMin(args...));
}
} // namespace Elaina
using namespace Elaina;
const int Maxn = 500;
const int Maxm = 2000;
const int mod = 998244353;
inline void chkadd(int& x, int y) { if ((x += y) >= mod) x -= mod; }
inline int qkpow(int a, int n) {
int ret = 1;
for (; n > 0; n >>= 1, a = (int)(1ll * a * a % mod))
if (n & 1) ret = (int)(1ll * ret * a % mod);
return ret;
}
int n, qry;
int c[Maxn + 5][Maxn + 5];
int sum;
bitset<Maxm + 5> S[Maxn + 5];
inline void input() {
readin(n, qry);
rep (i, 1, n - 1) rep (j, i + 1, n)
readin(c[i][j]), c[j][i] = c[i][j];
char s[Maxn + 5];
rep (i, 1, qry) {
scanf("%s", s + 1); int cnt = 0;
rep (j, 1, n) S[j][i] = s[j] - '0', cnt += (s[j] == '1');
if (cnt) sum += cnt - 1;
}
}
int w[Maxn + 5][Maxn + 5], m;
struct edge { int u, v, w; } e[Maxn * Maxn + 5];
inline void prelude() {
rep (i, 1, n) rep (j, i + 1, n) {
auto mix = S[i] & S[j];
w[i][j] = w[j][i] = mix.count();
e[++m] = {i, j, -w[i][j]};
}
}
class UFS {
private:
int fa[Maxn + 5];
public:
inline void init(int n) { rep (i, 1, n) fa[i] = i; }
inline int find(int u) {
while (u ^ fa[u]) u = fa[u] = fa[fa[u]];
return u;
}
inline bool linkto(int u, int v) {
u = find(u), v = find(v);
if (u == v) return false;
return fa[u] = v, true;
}
inline bool judge(int u, int v) { return find(u) != find(v); }
} ufs;
class matrixTree {
private:
int a[Maxn + 5][Maxn + 5], id[Maxn + 5], n;
inline int specialDet() {
int ret = 1;
repf (i, 1, n) { // ignore the first row
int cur = -1;
repf (j, i, n) if (a[j][i] != 0) { cur = j; break; }
if (!~cur) return 0;
swap(a[i], a[cur]), ret = (mod - ret) % mod;
ret = (int)(1ll * ret * a[i][i] % mod);
int inv = qkpow(a[i][i], mod - 2);
repf (j, i + 1, n) if (a[j][i]) {
int t = (int)(1ll * a[j][i] * inv % mod);
repf (k, i, n) a[j][k] = (a[j][k] + mod - 1ll * a[i][k] * t % mod) % mod;
}
}
return ret;
}
public:
inline int work(vector<int>& V, vector<edge>& E) {
n = (int)V.size();
repf (i, 0, n) id[V[i]] = i;
repf (i, 0, n) repf (j, 0, n) a[i][j] = 0;
for (auto [u, v, w]: E) {
u = id[u], v = id[v];
chkadd(a[u][v], w);
chkadd(a[v][u], w);
chkadd(a[u][u], (mod - w) % mod);
chkadd(a[v][v], (mod - w) % mod);
}
return specialDet();
}
} Func;
vector<int> vs[Maxn + 5];
vector<edge> es[Maxn + 5];
inline void solve() {
sort(e + 1, e + m + 1, [](const edge& a, const edge& b) {
return a.w < b.w;
});
ufs.init(n);
int cnt = 0, prod = 1;
for (int l = 1, r = 1; l <= m; r = l = r + 1) {
rep (i, 1, n) {
vs[ufs.find(i)] = { ufs.find(i) };
es[i].clear();
}
while (r <= m && e[r].w == e[l].w) {
const auto& [u, v, w] = e[r];
if (ufs.judge(u, v)) {
es[ufs.find(u)].push_back({ufs.find(u), ufs.find(v), c[u][v]});
}
++r;
}
if (r > m || e[r].w != e[l].w) --r;
rep (i, l, r) {
const auto& [u, v, w] = e[i];
if (ufs.judge(u, v)) {
int fu = ufs.find(u), fv = ufs.find(v);
ufs.linkto(u, v);
es[fv].insert(es[fv].end(), es[fu].begin(), es[fu].end());
vs[fv].insert(vs[fv].end(), vs[fu].begin(), vs[fu].end());
es[fu].clear(), vs[fu].clear();
cnt += (-w); // negative attention!
}
}
rep (i, 1, n) {
if (ufs.find(i) == i && !es[i].empty())
prod = (int)(1ll * prod * Func.work(vs[i], es[i]) % mod);
vs[i].clear(), es[i].clear();
}
}
if (cnt < sum) writln(0);
else writln(prod);
}
signed main() {
freopen("treecnt.in", "r", stdin);
freopen("treecnt.out", "w", stdout);
input();
prelude();
solve();
return 0;
}
底线
「做人是要有底线的。」
「我知道，我知道，但是我有个朋友......有个朋友，朋友的请求总不可能拒绝吧，他说他想看......」
「磙。」
从中选出 \(k\) 个，显然导向 wqs 二分啊。不过凸性到现在都还不会证明......
常规操作，先二分一个系数 \(coe\)，然后内层设计 DP 转移，内层设 \(f(i)\) 表示前 \(i\) 个位置都被覆盖完时的最大价值，每个 \(f(i)\) 是一个二元组 \((val,cnt)\)，表示最大价值与此时选择的最多的区间。
做 DP 的时候，枚举一下前一个位置是哪里就行了，不过需要注意的是，我们还要贪心地把那些权值为正的边选上。
注意到可以使用线段树进行优化，于是就优化吧......其实我写这篇题解的目的还是前两道，这一道主要是记录一下 wqs 二分，所以稍微有点略。
/** @author __Elaina__ */
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#include <bits/stdc++.h>
using namespace std;
#define USING_FREAD
#define NDEBUG
#include <cassert>
namespace Elaina {
/** その可憐な少女は魔女であり、旅人でした。 ―― そう、私です! */
#define rep(i, l, r) for(register int i = (l), i##_end_ = (r); i <= i##_end_; ++i)
#define repf(i, l, r) for (register int i = (l), i##_end_ = (r); i < i##_end_; ++i)
#define drep(i, l, r) for(register int i = (l), i##_end_ = (r); i >= i##_end_; --i)
#define fi first
#define se second
#define mp(a, b) make_pair(a, b)
#define Endl putchar('\n')
#define whole(v) ((v).begin()), ((v).end())
#define bitcnt(s) (__builtin_popcount(s))
/** @warning no forced type conversion */
#define rqr(x) ((x) * (x))
#define y0 FUCK_UP
#define y1 MOTHER_FUCKER
#define masdf(...) fprintf(stderr, __VA_ARGS__)
typedef long long ll;
typedef unsigned long long ull;
typedef std::pair<int, int> pii;
typedef vector<int> vset;
template<class T> inline T fab(T x) { return x < 0 ? -x : x; }
template<class T> inline void chkmin(T& x, const T& rhs) { x = std::min(x, rhs); }
template<class T> inline void chkmax(T& x, const T& rhs) { x = std::max(x, rhs); }
#ifdef USING_FREAD
inline char qkgetc() {
# define BUFFERSIZE 1 << 20
static char BUF[BUFFERSIZE], *p1 = BUF, *p2 = BUF;
return p1 == p2 && (p2 = (p1 = BUF) + fread(BUF, 1, BUFFERSIZE, stdin), p1 == p2) ? EOF : *p1++;
# undef BUFFERSIZE
}
# define CHARRECEI qkgetc()
#else
# define CHARRECEI ((char)getchar())
#endif
template<class T> inline T readret(T x) {
x = 0; int f = 0; char c;
while (!isdigit(c = CHARRECEI)) if(c == '-') f = 1;
for (x = (c ^ 48); isdigit(c = CHARRECEI); x = (x << 1) + (x << 3) + (c ^ 48));
return f ? -x : x;
}
template<class T> inline void readin(T& x) {
x = 0; int f = 0; char c;
while (!isdigit(c = CHARRECEI)) if (c == '-') f = 1;
for (x = (c ^ 48); isdigit(c = CHARRECEI); x = (x << 1) + (x << 3) + (c ^ 48));
if (f) x = -x;
}
template<class T, class... Args> inline void readin(T& x, Args&... args) {
readin(x), readin(args...);
}
template<class T> inline void writln(T x, char c = '\n') {
if (x < 0) putchar('-'), x = -x;
static int __stk[55], __bit = 0;
do __stk[++__bit] = x % 10, x /= 10; while (x);
while (__bit) putchar(__stk[__bit--] ^ 48);
putchar(c);
}
template<class T> inline T listMax(const T& x) { return x; }
template<class T, class... Args> inline T listMax(const T& x, const Args&... args) {
return max(x, listMax(args...));
}
template<class T> inline T listMin(const T& x) { return x; }
template<class T, class... Args> inline T listMin(const T& x, const Args&... args) {
return min(x, listMin(args...));
}
} // namespace Elaina
using namespace Elaina;
#define Maxn (100000)
// const int Maxn = 1e5;
const ll inf = 1e8;
int n; ll req;
int val[Maxn + 5];
inline void input() {
readin(n, req);
rep (i, 1, n) readin(val[i]);
}
typedef pair<ll, ll> dptype;
inline dptype operator +(const dptype& lhs, const dptype& rhs) {
return {lhs.fi + rhs.fi, lhs.se + rhs.se};
}
inline dptype& operator +=(dptype& lhs, const dptype& rhs) {
return lhs = {lhs.fi + rhs.fi, lhs.se + rhs.se};
}
inline dptype operator -(const dptype& lhs, const dptype& rhs) {
return {lhs.fi - rhs.fi, lhs.se - rhs.se};
}
inline dptype& operator -=(dptype& lhs, const dptype& rhs) {
return lhs = {lhs.fi - rhs.fi, lhs.se - rhs.se};
}
class sgtre { // none-recursion segment tree
private:
int m;
dptype mx[Maxn << 2 | 2], tag[Maxn << 2 | 2];
inline void add(int i, const dptype& x) { mx[i] += x, tag[i] += x; }
inline void pushup(int i) {
mx[i] = max(mx[i << 1], mx[i << 1 | 1]) + tag[i];
}
public:
inline void init(int n) {
for (m = 1; m < n + 2; m <<= 1);
drep (i, m + n + 2, 1) mx[i] = tag[i] = {0, 0};
}
inline void insert(int i, dptype x) {
for (mx[i + m] = x, i = i + m >> 1; i; i >>= 1) pushup(i);
}
inline void modify(int l, int r, const dptype& x) {
if (l > r) return ;
for (l = m + l - 1, r = m + r + 1; l ^ r ^ 1;) {
if (~l & 1) add(l ^ 1, x);
if (r & 1) add(r ^ 1, x);
pushup(l >>= 1), pushup(r >>= 1);
}
}
inline dptype query(int l, int r) {
dptype ql = {-inf, 0}, qr = {-inf, 0};
if (l > r) return ql;
for (l = m + l - 1, r = m + r + 1; l ^ r ^ 1;) {
if (~l & 1) chkmax(ql, mx[l ^ 1]);
if (r & 1) chkmax(qr, mx[r ^ 1]);
ql += tag[l >>= 1], qr += tag[r >>= 1];
}
for (l >>= 1, chkmax(ql, qr); l; l >>= 1) ql += tag[l];
return ql;
}
} tre;
class mxtre { // only used for interval max, based on none-recursion segment tree
private:
int m;
dptype mx[Maxn << 2 | 2];
inline void pushup(int i) { mx[i] = max(mx[i << 1], mx[i << 1 | 1]); }
public:
inline void init(int n) {
for (m = 1; m < n + 2; m <<= 1);
drep (i, m + n + 2, 1) mx[i] = {0, 0};
}
inline void insert(int i, dptype x) {
for (mx[i + m] = x, i = i + m >> 1; i; i >>= 1) pushup(i);
}
inline dptype query(int l, int r) {
dptype ret = {-inf, 0};
if (l > r) return ret;
for (l = m + l - 1, r = m + r + 1; l ^ r ^ 1; l >>= 1, r >>= 1) {
if (~l & 1) chkmax(ret, mx[l ^ 1]);
if (r & 1) chkmax(ret, mx[r ^ 1]);
}
return ret;
}
} mxqry;
class fenwick { // statistic the positive intervals
private:
int m;
dptype c[Maxn + 5]; int lef[Maxn + 5];
inline int lowbit(int i) { return i & (-i); }
public:
inline void init(int n) {
rep (i, 1, m = n) c[i] = {0, 0}, lef[i] = inf;
}
inline void insert(int i, const dptype& x, int l) {
for (; i; i ^= lowbit(i)) c[i] += x, chkmin(lef[i], l);
}
inline pair<dptype, int> query(int i) {
dptype ret = {0, 0}; int l = inf;
for (; i <= m; i += lowbit(i)) ret += c[i], chkmin(l, lef[i]);
return {ret, l};
}
} bit;
ll pre[Maxn + 5], suf[Maxn + 5], buc[Maxn + 5]; int m;
inline void prelude() {
rep (i, 1, n) pre[i] = pre[i - 1] + val[i];
rep (i, 1, n) suf[i] = pre[n] - pre[i - 1], buc[i] = suf[i];
sort(buc + 1, buc + 1 + n + 1);
m = unique(buc + 1, buc + 1 + n + 1) - buc - 1;
rep (i, 1, n + 1) suf[i] = lower_bound(buc + 1, buc + m + 1, suf[i]) - buc;
}
dptype dp[Maxn + 5];
inline dptype work(ll coe) {
tre.init(n), mxqry.init(n), bit.init(m);
rep (i, 1, n) dp[i] = {-inf, 0};
dptype positive = {0, 0}, tmp;
ll mx = -inf; int x, p;
rep (i, 1, n) {
bit.insert(suf[i], {buc[suf[i]], 1}, i);
x = lower_bound(buc + 1, buc + m + 1, buc[suf[i + 1]] - coe) - buc, p;
/** @p x the required index of suffix sum */
/** @p p leftmost endpos of the positive intervals */
auto reci = bit.query(x); // statistic the required positive intervals and the leftmost endpos
tmp = reci.fi, tmp.fi += tmp.se * (coe - buc[suf[i + 1]]);
positive += tmp; // statistic the positive intervals
p = min(i + 1, reci.se); // to avoid that no positive intervals, in which case return inf
mx = max(mx, 0ll) + pre[i] - pre[i - 1];
tre.modify(1, i - 1, {pre[i] - pre[i - 1], 0});
if (i > 1) mxqry.insert(i, dp[i - 1]);
tre.insert(i, dp[i - 1] + dptype{mx + coe, 1});
dp[i] = max(tre.query(1, p - 1), mxqry.query(p, i));
}
return dp[n] + positive;
}
signed main() {
freopen("baseline.in", "r", stdin);
freopen("baseline.out", "w", stdout);
input();
prelude();
ll k = -inf; dptype reci;
for (register ll l = -2e7, r = 2e7, mid = l + r >> 1; l <= r; mid = l + r >> 1) {
reci = work(mid);
if (reci.se < req) l = mid + 1;
else k = mid, r = mid - 1;
}
reci = work(k);
writln(reci.fi - req * k);
return 0;
}
