1455G Forbidden Value（数据结构优化dp+启发式合并）

最新推荐文章于 2021-02-12 15:54:27 发布

未已优

最新推荐文章于 2021-02-12 15:54:27 发布

阅读量430

点赞数 1

分类专栏：个人题解文章标签： 1455G Forbidden Value 数据结构动态规划启发式合并

本文链接：https://blog.csdn.net/qq_41765114/article/details/110509443

版权

个人题解专栏收录该内容

32 篇文章 0 订阅

订阅专栏

1455G Forbidden Value（数据结构优化dp+启发式合并）

Educational Codeforces Round 99 (Rated for Div. 2)

G. Forbidden Value

题面：Forbidden Value

题意：给一个初始值为 $0$ 的变量 $x$ 以及一段只包含 $s e t 、 i f 、 e n d$ 的简易代码段，代码 “ $s e t y v$ ” 表示将 $x$ 赋值为 $y$ ，或者花费 $v$ 的代价不执行该语句，代码块 $i f y . . . e n d$ 为条件语句块，当 $x$ 的值等于 $y$ 时才会进入该代码块，代码块可以嵌套。在程序的运行过程当中一旦 $x$ 的值变成了 $s$ 就会立马崩溃，现在问至少要花费多少的代价才能让程序正常跑完。

范围： $\le n \le 2e5, 1 \le s \le 2e5, 0 \le y \le 2e5, 1 \le v \le 1e9$ 。

分析：可以先考虑基本的 $d p$ ， $dp_{ij}$ 表示执行完第 $i$ 条语句后 $x$ 的值为 $j$ 所需要的最小代价。若代码段中只存在 $s e t$ 语句的话这个 $d p$ 很好写，只需要注意进行离散化。现在考虑 $i f . . . e n d$ 语句块，可以发现处理语句块内部只是与本道题本质相同规律减少的子问题，因此我们可以对该问题进行递归的求解，假设进入内部 $i f . . . e n d$ 语句块所需要的代价为 $c o s t$ ，那么在处理完内部 $inner\_dp$ 后与外部 $outer\_dp$ 进行合并时 $outer\_dp_{ij} = min(outer\_dp_{ij}, cost + inner\_dp_{ij})$ 即可，总体的时间复杂度为 $O(n^2)$ ，考虑进行优化。

两个大方向可以进行优化：

① 对于一条 $s e t y v$ 语句，除了 $j = = y$ 其余所有的 $j$ 为了保持原来的值都需要增加 $v$ 的代价，而 $j = = y$ 在这条语句过后一定会保持 $j = = y$ ，因此在这条语句之前 $j$ 可以是任何值，所以我们应当取其中代价最小的。注意到每次只有一个 $j$ 的变化不同，其他 $j$ 的变化都相同，因此我们可以设置一个偏移量 $o f f s e t$ 保存所有 $j$ 的变化量，只修改一个 $j = = y$ 的值，这里我们需要一个快速单点修改以及求全局最小值的功能，STL 中的容器 $S e t$ 可以满足，时间复杂度从 $O (n)$ 降低为 $O (l o g n)$ 。

② 上述的朴素 $d p$ 合并方式的时间复杂度为 $O(n^2)$ ，这里可以使用启发式合并的方式，每次合并的时候都是 $s i z e$ 较小的 $d p$ 合并至 $s i z e$ 较大的 $d p$ ，时间复杂度从 $O(n^2)$ 降低为 $O (n l o g n)$ ，不过这里我们需要维护 $S e t$ 等数据结构，时间复杂度为 $O (n l o g n l o g n)$ 。

通过上述的优化，数据结构 $s e t$ 与 $m a p$ 优化的 $d p$ 配合启发式合并，将时间复杂度减小到 $O(nlog^2n)$ ，足以通过本题。

Code：

#include <bits/stdc++.h>
#define int long long
#define double long double
using namespace std;
 
inline int read()
{
    int s = 0, w = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9')
    {
        if (ch == '-')
            w = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9')
        s = s * 10 + ch - '0', ch = getchar();
    return s * w;
}
 
const int MAXN = 2e5 + 10;
const int INF = 1e18;
const int MOD = 1e9 + 7;
const double eps = 1e-9;
const double PI = acos(-1.0);
 
int n, s;
 
struct Node
{
	int offset;
	map<int, int> mp;
	multiset<int> ms;
};
 
vector<Node> vec;
 
void update(Node &node, int y, int v)
{
	if (node.mp.count(y))
	{
		node.ms.erase(node.ms.find(node.mp[y]));
	}
	node.mp[y] = v;
	node.ms.insert(v);
}
 
signed main()
{
    n = read(), s = read();
    int skip = 0;
    vec.push_back({});
    vec.back().offset = 0;
    vec.back().mp[0] = 0;
    vec.back().ms.insert(0);
    for (int i = 0; i < n; i++)
    {
    	string op;
    	int y, v;
    	cin >> op;
    	if (op[0] == 's')
    	{
    		y = read(), v = read();
    		if (skip) continue;
    		int minV = *vec.back().ms.begin() - v;
    		vec.back().offset += v;
    		if (y != s)
    		{
    			update(vec.back(), y, minV);
    		}
    	}
    	else if (op[0] == 'i')
    	{
    		y = read();
    		if (!skip && vec.back().mp.count(y))
    		{
    			int val = vec.back().mp[y] + vec.back().offset;
    			vec.back().ms.erase(vec.back().ms.find(vec.back().mp[y]));
    			vec.back().mp.erase(y);
    			vec.push_back({});
    			vec.back().offset = 0;
    			update(vec.back(), y, val);
    		}
    		else
    		{
    			skip++;
    		}
    	}
    	else
    	{
    		if (skip) skip--;
    		else
    		{
    			if (vec[vec.size() - 1].mp.size() > vec[vec.size() - 2].mp.size())
    			{
    				swap(vec[vec.size() - 1], vec[vec.size() - 2]);
    			}
    			auto &outer = vec[vec.size() - 2];
    			for (auto x : vec.back().mp)
    			{
    				if (!outer.mp.count(x.first) || (outer.offset + outer.mp[x.first] > vec.back().offset + x.second))
    				{
    					int val = vec.back().offset + x.second - outer.offset;
    					update(outer, x.first, val);
    				}
    			}
    			vec.pop_back();
    		}
    	}
    }
    cout << vec.back().offset + *vec.back().ms.begin() << endl;
    return 0;
}