NOIP 2018 简要题解
从这里开始
Day 1
Problem A
考虑贪心地选取极大非 0 段减少。
如果两次操作有交，并且不是包含关系，那么把其中一次操作的，但另一次没有操作的移过去，然后就变成了上面那个贪心了。
Code
#include <iostream>
#include <cstdlib>
#include <cstdio>
using namespace std;
typedef bool boolean;
const int N = 1e5 + 5;
int n;
int res = 0;
int ar[N];
inline void init() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", ar + i);
}
inline void solve() {
int lst = 0;
for (int i = 1; i <= n; i++) {
if (ar[i] > lst)
res += ar[i] - lst;
lst = ar[i];
}
printf("%d\n", res);
}
int main() {
freopen("road.in", "r", stdin);
freopen("road.out", "w", stdout);
init();
solve();
return 0;
}
Problem B
考虑从小到达确定 $b$ 中的面额。不难发现：
- $b$ 一定是 $a$ 的子集。
- $a$ 中一种面值不在 $b$ 中当且仅当它能被除掉它之后的面额表示出来。
Code
#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;
const int N = 105, M = 25005;
int T;
int n, m;
int a[N];
bitset<M> f;
void solve() {
scanf("%d", &n);
m = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
m = max(m, a[i]);
}
sort(a + 1, a + n + 1);
f.reset();
f.set(0);
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!f.test(a[i])) {
for (int j = a[i]; j <= m; j++) {
if (f.test(j - a[i])) {
f.set(j);
}
}
ans++;
}
}
printf("%d\n", ans);
}
int main() {
freopen("money.in", "r", stdin);
freopen("money.out", "w", stdout);
scanf("%d", &T);
while (T--) {
solve();
}
return 0;
}
Problem C
考虑二分答案。考虑在每个子树内决策，每个子树内最多有一条未完成的路径对父节点有贡献。
首先需要最大化数量，不难证明这样不会更劣。
首先已经满足条件的可以直接算入答案，没有满足条件考虑两两配对。这个从大的开始考虑，每次和最小的能够匹配的配对。
考虑如何在数量最大的情况下，最大化对父节点的贡献。考虑最大没有匹配的路径，考虑用它替换掉某组匹配中的较大值。
时间复杂度 $O(n\log V\log n)$。
Code
#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <vector>
using namespace std;
typedef bool boolean;
template <typename T>
void pfill(T* pst, const T* ped, T val) {
for ( ; pst != ped; *(pst++) = val);
}
typedef class Edge {
public:
int ed, nx, w;
Edge(int ed = 0, int nx = 0, int w = 0):ed(ed), nx(nx), w(w) { }
}Edge;
typedef class MapManager {
public:
int ce;
int* h;
Edge* es;
MapManager() : ce(-1), h(NULL), es(NULL) { }
MapManager(int n, int m) : ce(-1) {
h = new int[(n + 1)];
es = new Edge[(m + 1)];
pfill(h, h + n + 1, -1);
}
void addEdge(int u, int v, int w) {
es[++ce] = Edge(v, h[u], w);
h[u] = ce;
}
Edge& operator [] (int p) {
return es[p];
}
}MapManager;
template <typename T>
class Pool {
public:
int sz;
T *p;
T *tp;
Pool(int sz) : sz(sz) {
p = new T[sz + 1];
tp = p;
}
void reset() {
tp = p;
}
T* alloc(int len) {
T* rt = tp;
tp += len;
// cerr << tp - p << '\n';
return rt;
}
};
typedef pair<int, int> pii;
const int N = 5e4 + 3;
int n, m;
int deg[N];
MapManager g;
Pool<int> pl1(N << 2);
Pool<pii> pl2(N << 2);
Pool<boolean> pl3(N << 2);
inline void init() {
scanf("%d%d", &n, &m);
g = MapManager(n, n << 1);
pfill(deg + 1, deg + n + 1, 0);
for (int i = 1, u, v, w; i < n; i++) {
scanf("%d%d%d", &u, &v, &w);
g.addEdge(u, v, w);
g.addEdge(v, u, w);
deg[u]++, deg[v]++;
}
}
//int cnt;
pii dfs(int p, int fa, int mid) {
int* a = pl1.alloc(deg[p] + 1);
pii* m = pl2.alloc(deg[p] + 1);
boolean* vis = pl3.alloc(deg[p] + 1);
// cerr << ++cnt << '\n';
int rt = 0, tp = 0;
for (int i = g.h[p], e; ~i; i = g[i].nx) {
if ((e = g[i].ed) == fa)
continue;
pii x = dfs(e, p, mid);
rt += x.first, a[++tp] = (x.second + g[i].w);
}
sort(a + 1, a + tp + 1);
while (tp && a[tp] >= mid)
tp--, rt++;
if (!tp)
return pii(rt, 0);
for (int i = 0; i <= tp; i++)
vis[i] = false;
int l = 1, r = tp, _tp = 0;
while (l < r) {
while (l < r && a[l] + a[r] < mid)
l++;
if (l < r) {
m[++_tp] = pii(a[l], a[r]);
vis[l] = vis[r] = true;
l++, r--, rt++;
}
}
while (r && vis[r])
r--;
if (!r)
return pii(rt, 0);
int b = a[r];
for (int i = _tp; i; i--)
if (m[i].first + b >= mid)
return pii(rt, m[i].second);
return pii(rt, b);
}
boolean check(int mid) {
// cnt = 0;
pl1.reset();
pl2.reset();
pl3.reset();
return dfs(1, 0, mid).first >= m;
}
inline void solve() {
int l = 1, r = 5e8, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid))
l = mid + 1;
else
r = mid - 1;
}
printf("%d\n", l - 1);
}
int main() {
freopen("track.in", "r", stdin);
freopen("track.out", "w", stdout);
init();
solve();
return 0;
}
Day 2
Problem A
暴力枚举断掉环上的哪一条边。
Code
#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <stack>
using namespace std;
typedef bool boolean;
const int N = 5005;
int n, m;
int tp;
int ans[N];
int cmp[N];
vector<int> g[N];
inline void init() {
scanf("%d%d", &n, &m);
for (int i = 1, u, v; i <= m; i++) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
}
namespace tree {
void dfs(int p, int fa) {
ans[++tp] = p;
for (int i = 0, e; i < (signed) g[p].size(); i++)
if ((e = g[p][i]) ^ fa)
dfs(e, p);
}
inline void solve() {
tp = 0;
for (int i = 1; i <= n; i++)
sort(g[i].begin(), g[i].end());
dfs(1, 0);
for (int i = 1; i <= n; i++)
printf("%d%c", ans[i], (i == n) ? ('\n') : (' '));
}
}
namespace circle {
stack<int> s;
boolean vis[N];
vector<int> cir;
boolean dfs1(int p, int fa) {
if (vis[p]) {
int cur;
do {
cur = s.top();
s.pop();
cir.push_back(cur);
} while (cur != p);
return true;
}
s.push(p), vis[p] = true;
for (int i = 0, e; i < (signed) g[p].size(); i++)
if (((e = g[p][i]) ^ fa) && dfs1(e, p))
return true;
s.pop();
return false;
}
void dfs(int p, int fa, int banu, int banv) {
cmp[++tp] = p;
// cerr << p << " " << tp << '\n';
boolean sgn1 = (p == banu || p == banv);
for (int i = 0, e; i < (signed) g[p].size(); i++) {
e = g[p][i];
if ((e ^ fa) && !(sgn1 && (e == banu || e == banv)))
dfs(e, p, banu, banv);
}
}
boolean check_update() {
for (int i = 1; i <= n; i++)
if (ans[i] ^ cmp[i])
return cmp[i] < ans[i];
return false;
}
inline void solve() {
for (int i = 1; i <= n; i++)
sort(g[i].begin(), g[i].end());
dfs1(1, 0);
signed int s = (signed) cir.size();
tp = 0;
dfs(1, 0, cir[0], cir[1]);
for (int j = 1; j <= n; j++)
ans[j] = cmp[j];
for (int i = 1; i < s; i++) {
// cerr << cir[i] << '\n';
tp = 0;
dfs(1, 0, cir[i], cir[(i + 1) % s]);
if (check_update())
for (int j = 1; j <= n; j++)
ans[j] = cmp[j];
}
for (int i = 1; i <= n; i++)
printf("%d%c", ans[i], (i == n) ? ('\n') : (' '));
}
}
int main() {
freopen("travel.in", "r", stdin);
freopen("travel.out", "w", stdout);
init();
if (n == m)
circle :: solve();
else
tree :: solve();
return 0;
}
好像校内 oj 上测，最慢一个点 978ms，Emm......
其实考虑在环上每一个位置往回走的下一个标号是确定的。然后就能 $O(n\log n)$ 了。
最近手残得比较厉害，sad.....
Code
#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;
const int N = 5e3 + 5;
int n, m;
vector<int> ans;
vector<int> G[N];
void dfs(int p, int fa, vector<int> &ans = ::ans) {
ans.push_back(p);
for (int _ = 0, e; _ < (signed) G[p].size(); _++) {
if ((e = G[p][_]) ^ fa) {
dfs(e, p);
}
}
}
boolean vis[N];
vector<int> cir;
boolean findcir(int p, int fa) {
if (vis[p]) {
vector<int>::iterator it = --cir.end();
while (*it ^ p)
it--;
cir.erase(cir.begin(), it);
return true;
}
vis[p] = true;
cir.push_back(p);
for (int _ = 0, e; _ < (signed) G[p].size(); _++) {
if (((e = G[p][_]) ^ fa) && findcir(e, p)) {
return true;
}
}
cir.pop_back();
return false;
}
void finderase(vector<int>& a, int x) {
vector<int>::iterator it = a.begin();
while (*it ^ x)
it++;
a.erase(it);
}
int main() {
freopen("travel.in", "r", stdin);
freopen("travel.out", "w", stdout);
scanf("%d%d", &n, &m);
for (int i = 1, u, v; i <= m; i++) {
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; i++)
sort(G[i].begin(), G[i].end());
if (n == m) {
findcir(1, 0);
int nxt = *upper_bound(G[cir[0]].begin(), G[cir[0]].end(), cir[1]);
for (int i = 1, x, y; ; i++) {
x = cir[i];
if (x >= nxt) {
y = cir[i - 1];
finderase(G[x], y);
finderase(G[y], x);
// cerr << x << " " << y << " " << nxt << '\n';
break;
}
vector<int>::iterator it = upper_bound(G[x].begin(), G[x].end(), cir[i + 1]);
if (it != G[x].end() && *it == cir[i - 1])
it++;
if (it != G[x].end())
nxt = *it;
}
}
dfs(1, 0, ans);
for (int i = 0; i < n; i++)
printf("%d ", ans[i]);
return 0;
}
Problem B
请欣赏神仙行为：
- 早上教练发题，神仙 jerome_wei 说难道这题能做，下午发成绩，rk 1 cdqz-wyp 100 100 100 300
- 早上教练发题，神仙 jerome_wei 说咕了咕了，下午发成绩，rk 1 cdqz-wyp 100 100 100 300
- 一天，神仙 jerome_wei 看到了这道题，说这什么鬼题，跑了跑了，不久之后博客上出现了详细题解和证明
不难发现 $a_{x, y} \geqslant a_{x - 1, y + 1}$。
考虑一处不合法的路径，如果存在一定是字典序相邻的一对，这样话就是考虑把最后一个不在最后一行的 R 替换成 D，大概是这样的：
你发现如果第二个位置相等，由于在另一条路径下方的权值一定是小于等于它的，由此可以推出它们字典序相等。那么右下角的大矩形内每一对 $x + y$ 相等的 $a_{x, y}$ 都是相同的。
随便 dp 一下应该能拿到 65 分的好成绩。（枚举 $x + y$ 的值，状压一下当前的满足 $a_{x, y} = a_{x - 1, y + 1}$ 以及横纵坐标和等于 $x + y + 1$ 的状态）
不难注意到，当 $m$ 比较大的时候，中间的有效状态只有常数个，考虑 $x = 0, 1$ 总是可行的，当 $x \geqslant 3, y \geqslant 2$ 的时候，这些格子必须满足 $a_{x, y} = a_{x - 1, y + 1}$。因为：
因为红格子和蓝格子以及蓝格子和黄格子不可能同时都不同。
理论上中间暴力 dp 能过，不过写个矩乘快速幂怎么都能过，我好像有地方写菜了，然后好像就过不了？因为我非常地懒，众所周知，打表可得当 $m \geqslant n + 1$ 的时候当 $m$ 每增加 1，答案乘上 3。
如果我 csp 后没退役再来填这个规律的坑好了。
Code
#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;
#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 = 1e9 + 7;
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 boolean 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;
#define pii pair<int, int>
const int N = 1e6 + 10;
int n, m;
int Lx[N], Rx[N];
map<pii, Zi> G[N];
int opt(int sum, int s, int x) {
if (x <= Lx[sum] || x > Rx[sum])
return s;
return s | (1 << x);
}
Zi dp(int sum, int s0, int s1) {
if (sum == n + m - 2)
return 2;
if (G[sum].count(pii(s0, s1))) {
return G[sum][pii(s0, s1)];
}
Zi rt = 0;
int ns0 = s1;
for (int i = Lx[sum]; i <= Rx[sum]; i++) {
if ((s0 >> i) & 1) {
ns0 = opt(sum + 1, ns0, i);
ns0 = opt(sum + 1, ns0, i + 1);
}
}
for (int i = Lx[sum]; i <= Rx[sum] + 1; i++) {
if ((s0 >> i) & 1)
continue;
int ns1 = 0;
for (int j = Lx[sum] + 1; j <= i && j <= Rx[sum]; j++)
ns1 = opt(sum + 2, ns1, j + 1);
for (int j = i + 2; j <= Rx[sum]; j++)
ns1 = opt(sum + 2, ns1, j + 1);
rt += dp(sum + 1, ns0, ns1);
}
// cerr << sum << " " << s0 << " " << s1 << " " << rt.v << '\n';
return G[sum][pii(s0, s1)] = rt;
}
Zi solve(int n, int m) {
if (n > m)
swap(n, m);
if (n == m || m == n + 1) {
::n = n, ::m = m;
for (int i = 0; i < m + 10; i++) {
Lx[i] = 20, Rx[i] = 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
Lx[i + j] = min(Lx[i + j], i);
Rx[i + j] = max(Rx[i + j], i);
}
}
return dp(0, 0, 0);
}
if (n == 1)
return qpow(2, m);
return solve(n, n + 1) * qpow(3, m - n - 1);
}
int main() {
freopen("game.in", "r", stdin);
freopen("game.out", "w", stdout);
scanf("%d%d", &n, &m);
printf("%d\n", solve(n, m).v);
return 0;
}
Problem C
ddp 板题。
考察选手能否熟练地敲打 ddp 板子。
Code
#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;
const int N = 1e5 + 5;
#define ll long long
template <typename T>
T smin(T a, T b) {
return min(a, b);
}
template <typename T, typename ...Q>
T smin(T a, const Q &...args) {
return min(a, smin(args...));
}
const ll llf = 1e12;
typedef class Data {
public:
ll a[2][2];
Data() { }
Data(ll x) {
a[0][0] = llf, a[0][1] = 0;
a[1][0] = x, a[1][1] = x;
}
Data(ll x, ll y, ll z, ll w) {
a[0][0] = x, a[0][1] = y;
a[1][0] = z, a[1][1] = w;
}
Data get() {
ll g = min(a[0][0], a[0][1]);
ll f = min(a[1][0], a[1][1]);
g = min(g, f);
return Data(f, f, g, g);
}
ll* operator [] (int p) {
return a[p];
}
friend Data operator * (Data a, Data b) {
Data rt;
rt[0][0] = min(a[0][0] + b[0][0], a[0][1] + b[1][0]);
rt[0][1] = min(a[0][0] + b[0][1], a[0][1] + b[1][1]);
rt[1][0] = min(a[1][0] + b[0][0], a[1][1] + b[1][0]);
rt[1][1] = min(a[1][0] + b[0][1], a[1][1] + b[1][1]);
return rt;
}
friend Data operator + (Data a, Data b) {
Data rt;
rt[0][0] = a[0][0] + b[0][0];
rt[0][1] = a[0][1] + b[0][1];
rt[1][0] = a[1][0] + b[1][0];
rt[1][1] = a[1][1] + b[1][1];
return rt;
}
friend Data operator - (Data a, Data b) {
Data rt;
rt[0][0] = a[0][0] - b[0][0];
rt[0][1] = a[0][1] - b[0][1];
rt[1][0] = a[1][0] - b[1][0];
rt[1][1] = a[1][1] - b[1][1];
return rt;
}
ll get_ans() {
ll rt = smin(a[0][0], a[0][1], a[1][0], a[1][1]);
return (rt >= llf) ? (-1) : (rt);
}
} Data;
typedef class SegTreeNode {
public:
Data d;
SegTreeNode *fa;
SegTreeNode *l, *r;
void push_up() {
d = l->d * r->d;
}
} SegTreeNode;
typedef class Chain {
public:
SegTreeNode *st;
int len, top;
Chain() { }
Chain(int top);
void update(int, Data, Data);
} Chain;
SegTreeNode pool[N << 1];
SegTreeNode *_top = pool;
int S[N];
Data dat[N];
int tp;
Chain *ch[N];
SegTreeNode *tr[N];
void build(SegTreeNode*& p, int l, int r) {
p = _top++;
if (l == r) {
p->d = dat[S[l]];
tr[S[l]] = p;
return;
}
int mid = (l + r) >> 1;
build(p->l, l, mid);
build(p->r, mid + 1, r);
p->push_up();
p->l->fa = p;
p->r->fa = p;
}
Chain::Chain(int top) : st(_top), len(tp), top(top) {
reverse(S + 1, S + tp + 1);
build(st, 1, len);
for (int i = 1; i <= len; i++) {
ch[S[i]] = this;
}
if (top) {
dat[top] = dat[top] + st->d.get();
}
}
void Chain::update(int x, Data old_d, Data new_d) {
Data nold_d = st->d.get();
tr[x]->d = tr[x]->d - old_d + new_d;
for (SegTreeNode *p = tr[x]->fa; p; p = p->fa)
p->push_up();
if (top) {
ch[top]->update(top, nold_d, st->d.get());
}
}
int n, m;
int p[N];
int sz[N], zson[N];
vector<int> G[N];
void dfs1(int p, int fa) {
int mx = 0, &id = zson[p];
sz[p] = 1;
for (auto e : G[p]) {
if (e ^ fa) {
dfs1(e, p);
sz[p] += sz[e];
if (mx < sz[e]) {
mx = sz[e];
id = e;
}
}
}
}
void dfs2(int p, int fa) {
if (zson[p]) {
for (auto e : G[p]) {
if ((e ^ fa) && (e ^ zson[p])) {
dfs2(e, p);
new Chain(p);
}
}
dfs2(zson[p], p);
} else {
tp = 0;
}
S[++tp] = p;
}
int main() {
freopen("defense.in", "r", stdin);
freopen("defense.out", "w", stdout);
scanf("%d%d%*s", &n, &m);
for (int i = 1, x; i <= n; i++) {
scanf("%d", &x);
dat[i] = x;
p[i] = x;
}
for (int i = 1, u, v; i < n; i++) {
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
dfs1(1, 0);
dfs2(1, 0);
new Chain(0);
int a, x, b, y;
while (m--) {
scanf("%d%d%d%d", &a, &x, &b, &y);
Data olda = p[a], oldb = p[b];
Data na = Data(llf * (1 - x)), nb = Data(llf * (1 - y));
ch[a]->update(a, olda, na);
ch[b]->update(b, oldb, nb);
ll ans = ch[1]->st->d.get_ans() + olda[1][0] * x + oldb[1][0] * y;
ch[a]->update(a, na, olda);
ch[b]->update(b, nb, oldb);
printf("%lld\n", ans);
}
return 0;
}
浙公网安备 33010602011771号