获得更好的阅读体验
1001.Pandaemonium Asphodelos: The First Circle (Savage)
题意
给定一个初始权值全部为0的区间，每次可以对区间进行如下操作
- 1 x c 1\ \ x\ \ c 1 x c 给距离 x x x位置距离最近的 2 c 2c 2c个点赋予一个新的属性
- 2 x y 2\ \ x\ \ y 2 x y把第 x x x位置上的属性赋给 y y y所在的块
- 3 x v 3\ \ x\ \ v 3 x v把颜色为 x x x块的权值统一增加 v v v
- 4 x 4\ \ x 4 x求第 x x x位置的权值
思路
经典珂朵莉树，用珂朵莉树维护区间属性，线段树维护点的权值，线段树可使用标记永久化降低代码难度。使用 a d d add add数组记录每个属性增加的权值，每次改变区间属性时都相当于给区间增加 a d d [ l a s ] − a d d [ n o w ] add[las]-add[now] add[las]−add[now]的权值，这样询问单点时只需要将线段树上的单点求和加上该点属性的 a d d add add即可
#ifdef ONLINE_JUDGE
#pragma GCC diagnostic error "-std=gnu++1y"
#pragma GCC target("popcnt")
#endif
int n, m, cnt, root;
ll add[N];
struct node {
int l, r; ll sum;
}tr[N << 2];
void New(int& now) {
now = ++cnt;
tr[now].sum = tr[now].l = tr[now].r = 0;
}
void update(int& now, int l, int r, int L, int R, ll d) {
if (!now) New(now);
if (L <= l && r <= R) {
tr[now].sum += d;
return;
}
int mid = l + r >> 1;
if (L <= mid) update(tr[now].l, l, mid, L, R, d);
if (R > mid) update(tr[now].r, mid + 1, r, L, R, d);
}
ll query(int& now, int l, int r, int pos) {
if (!now) return 0;
int mid = l + r >> 1;
ll res = tr[now].sum;
if (pos <= mid) res += query(tr[now].l, l, mid, pos);
else res += query(tr[now].r, mid + 1, r, pos);
return res;
}
struct Ctholly {
struct node {
int l;
mutable int r;
mutable ll v;
node(int L, int R = -1, ll V = 0) :l(L), r(R), v(V) {}
bool operator<(const node& o) const {
return l < o.l;
}
};
set<node> s;
auto split(int pos) {
auto it = s.lower_bound(node(pos));
if (it != s.end() && it->l == pos) return it;
it--;
if (it->r < pos) return s.end();
ll l = it->l;
ll r = it->r;
ll v = it->v;
s.erase(it);
s.insert(node(l, pos - 1, v));
return s.insert(node(pos, r, v)).first;
}
void assign(int l, int r, ll val = 0) {
auto itr = split(r + 1), itl = split(l);
for (auto it = itl; it != itr; it = s.erase(it))
update(root, 1, n, it->l, it->r, add[it->v]);
s.insert(node(l, r, val));
}
auto find(int pos) {
return prev(s.upper_bound(node(pos)));
}
}Tr;
int main() {
int T;
cin >> T;
while (T--) {
cin >> n >> m;
Tr.s.clear(); cnt = 0; root = 0;
Tr.s.insert(Ctholly::node(1, n, 0));
int lasans = 0, x, y, c, op;
int col = 0;
while (m--) {
cin >> op;
if (op == 1) {
cin >> x >> c;
x = ((x - 1) ^ lasans) % n + 1;
c = ((c - 1) ^ lasans) % ((n - 1) / 2) + 1;
int l = max(1, x - c), r = l + 2 * c;
if (r > n) l = n - 2 * c, r = n;
//区间修改为新颜色
Tr.assign(l, r, ++col);
}
else if (op == 2) {
cin >> x >> y;
x = ((x - 1) ^ lasans) % n + 1;
y = ((y - 1) ^ lasans) % n + 1;
auto p = Tr.find(x), l = Tr.find(y);
if (p->v == l->v) continue;
//区间颜色更新
update(root, 1, n, l->l, l->r, add[l->v] - add[p->v]);
l->v = p->v;
//注意!! 将前后与其属性相同的合并
while (next(l) != Tr.s.end() && l->v == next(l)->v)
l->r = next(l)->r, Tr.s.erase(next(l));
while (l != Tr.s.begin() && l->v == prev(l)->v)
prev(l)->r = l->r, l = prev(l), Tr.s.erase(next(l));
}
else if (op == 3) {
ll w;
cin >> x >> w;
x = ((x - 1) ^ lasans) % n + 1;
add[Tr.find(x)->v] += w;
//属性标记增加
}
else {
cin >> x;
x = ((x - 1) ^ lasans) % n + 1;
ll ans = query(root, 1, n, x) + add[Tr.find(x)->v];
//节点的值+属性赋值
cout << ans << endl;
lasans = ans & 1073741823;
}
}
memset(add, 0, (cnt + 1) * 8);
}
return 0;
}
1003.Slipper
题意
给定一棵树，初始在 s s s点，要到达 t t t点，每次可以沿着边走，花费为边权，也可以直接跳到 ∣ d e p + k ∣ |dep+k| ∣dep+k∣或 ∣ d e p − k ∣ |dep-k| ∣dep−k∣层的任意一点，并花费 p p p,求到达 t t t点的最小花费
思路
经典最短路问题，新建 2 ∗ m a x d e p 2*maxdep 2∗maxdep个节点，对于每层，一个节点表示入点，另一个点表示出点，每层的点都指向这一层的入点，边权为 0 0 0，每层的入点指向和它层数差为 k k k的层数的出点，并且边权为 p p p，每层的出点指向该层的每一个点，边权为 0 0 0，然后跑最短路就好了。
struct edge {
int to, next;
ll w;
}a[N * 4];
int head[N], cnt, n, m, k, s, t, dep[N], mx, p;
ll dis[N];
void add(int x, int y, ll w) {
a[++cnt] = { y,head[x],w };
head[x] = cnt;
}
void dfs(int x, int fa) {
dep[x] = dep[fa] + 1, mx = max(mx, dep[x]);
for (int i = head[x]; i; i = a[i].next) {
int y = a[i].to;
if (y == fa) continue;
dfs(y, x);
}
}
bool vis[N];
void dij(int s) {
for (int i = 0; i <= n + mx + mx + 2; i++) dis[i] = INF, vis[i] = 0;
dis[s] = 0;
priority_queue<pll> q;
q.push({ 0,s });
while (q.size()) {
ll now = q.top().second;
q.pop();
if (vis[now]) continue;
vis[now] = 1;
for (int i = head[now]; i; i = a[i].next) {
int y = a[i].to;
if (dis[y] > dis[now] + a[i].w) {
dis[y] = dis[now] + a[i].w;
q.push({ -dis[y],y });
}
}
}
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
mx = 0; cnt = 0;
for (int i = 1; i < n; i++) {
int x, y; ll z;
scanf("%d%d%lld", &x, &y, &z);
add(x, y, z); add(y, x, z);
}
scanf("%d%d", &k, &p);
dfs(1, 0);
for (int i = 1; i <= n; i++) {
add(i, n + dep[i], 0);
add(n + dep[i] + mx, i, 0);
}
for (int i = 1; i <= mx; i++) {
if (i + k > mx) break;
add(i + n, i + k + n + mx, p);
add(i + k + n, i + n + mx, p);
}
scanf("%d%d", &s, &t);
dij(s);
cout << dis[t] << endl;
for (int i = 0; i <= n + mx + mx + 10; i++) head[i] = 0, dep[i] = 0;
}
return 0;
}
1006.BBQ
题意
给定一个字符串，求将其转化成每四个字符的形式都是 a b b a abba abba的最小修改次数，修改可以删除/插入一个字符，或将一个字符变为另一个字符。
思路
对于每7个连续的字符，都有一个状态我们用 a b b a abba abba这种方式表示，对于每个这样的串，我们先暴力求出每个状态转变为合法状态的最小次数，然后再进行dp求解。
int dp[8][5], t[10], f[N], w[N];
string s;
void dfs(int x, int tot, int _hash) {
int res = inf;
for (int i = 1; i <= 7; i++) {
for (int j = 1; j <= 7; j++) {
int p[5] = { 0,i,j,j,i };
memset(dp, 0x3f, sizeof dp);
for (int k = 0; k <= 4; k++) dp[0][k] = k;
for (int k = 0; k <= 7; k++) dp[k][0] = k;
for (int k1 = 1; k1 <= x; k1++) {
for (int k2 = 1; k2 <= 4; k2++) {
dp[k1][k2] = min(min(dp[k1 - 1][k2] + 1, dp[k1 - 1][k2 - 1] + (t[k1] != p[k2])), dp[k1][k2 - 1] + 1);
}
}
res = min(res, dp[x][4]);
}
}
w[_hash] = res;
if (x == 7) return;
for (int i = 1; i <= tot; i++) {
t[x + 1] = i;
dfs(x + 1, tot, _hash * 8 + i);
}
t[x + 1] = tot + 1;
dfs(x + 1, tot + 1, _hash * 8 + t[x + 1]);
}
int Hash(int l, int r) {
vector<int> vis(27, 0);
int cnt = 0, res = 0;
for (int i = l; i <= r; i++) {
int tmp;
if (!vis[s[i] - 'a']) tmp = vis[s[i] - 'a'] = ++cnt;
else tmp = vis[s[i] - 'a'];
res = res * 8 + tmp;
}
return res;
}
int main() {
t[1] = 1;
dfs(1, 1, 1);
int T;
cin >> T;
while (T--) {
cin >> s;
s = " " + s;
int n = s.size() - 1;
memset(f, 0x3f, 4 * (n + 20));
f[0] = 0;
for (int i = 1; i <= n; i++) {
f[i] = min(f[i], f[i - 1] + 1);
vector<int> vis(27, 0);
int status = 0, cnt = 0;
for (int j = 0; j < 7 && i + j <= n; j++) {
if (!vis[s[i + j] - 'a']) vis[s[i + j] - 'a'] = ++cnt;
status = status * 8 + vis[s[i + j] - 'a'];
f[i + j] = min(f[i + j], f[i - 1] + w[status]);
}
}
cout << f[n] << endl;
}
return 0;
}
1012.Buy Figurines
题意
有一个商店，有 m m m个收银台，有 n n n个客人，每个客人都有个到达收银台的时间 a i a_i ai和结账需要花费的时间 s i s_i si，客人会优先去人少的那个收银台，若人数一样多则会优先去编号小的那个收银台，问什么时间可以完成 n n n个客人的结账
思路
使用优先队列模拟时间， s e t set set维护每个收银台的人数。
pii a[N];
int n, m;
ll sum[N], r[N];
struct node {
ll tim, thing, id;
bool operator<(const node A)const {
if (tim == A.tim) thing < A.thing;
return tim > A.tim;
}
};
int main() {
int T;
cin >> T;
while (T--) {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i].first >> a[i].second;
sort(a + 1, a + 1 + n);
priority_queue<node> q;
for (int i = 1; i <= n; i++) q.push({ a[i].first,0,a[i].second });
set<pll> gt;
for (int i = 1; i <= m; i++) gt.insert({ 0,i });
ll ans = 0;
while (q.size()) {
auto now = q.top();
q.pop();
if (now.thing == 0) {
auto g = gt.begin();
ll tot = g->first, idx = g->second;
gt.erase(g);
tot++;
r[idx] = tot;
gt.insert({ tot,idx });
q.push({ max(now.tim,sum[g->second]) + now.id,1,g->second });
sum[g->second] = max(now.tim, sum[g->second]) + now.id;
ans = max(ans, sum[g->second]);
}
else {
gt.erase({ r[now.id],now.id });
r[now.id]--;
gt.insert({ r[now.id],now.id });
}
}
cout << ans << endl;
for (int i = 0; i <= m; i++) sum[i] = r[i] = 0;
}
return 0;
}
645
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
