11月2日模拟赛题解

T1 黑白图像压缩

简单模拟题 略

T2 校门外的区间

题意

解法：

线段树

问题可以转化为线段树区间赋(0/1)值，区间取反操作

对于开闭区间的处理，可以转化为将每两个点中间加一个点，表示“这两个点之间的区间”的问题。

注意对于懒标记的(pushdown)的处理问题

错因：

主要原因是做题太过慌张，导致自己题目都还没有读清楚就开始做题了。以后必须避免类似的错误再次发生。

其次，对于线段树懒标记的理解还不够深刻，懒标记是只对一个节点的儿子节点产生作用，但叶子节点的懒标记是不会被下传的，对于这两点理解清楚了，按照我的写法，这道题就会变得很容易写出来了。

代码：

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
#define maxn 70010
char ch[20], op[10];
int pos;
int add[maxn * 4], tag[maxn * 4];
void pushdown(int k, int l, int r)
{
	if(tag[k] == 1)
	{
		if(add[k << 1] == -1) tag[k << 1] ^= 1;
		else add[k << 1] ^= 1;
		if(add[k << 1 | 1] == -1) tag[k << 1 | 1] ^= 1;
		else add[k << 1 | 1] ^= 1;
		tag[k] = 0;
	}
	if(add[k] == -1) return;
	add[k << 1] = add[k];
	add[k << 1 | 1] = add[k];
	add[k] = -1;
	return;
}
void modify(int k, int l, int r, int x, int y, int v)
{
	if(x <= l && r <= y)
	{
		add[k] = v;
		return;
	}
	pushdown(k, l, r);
	int mid = (l + r) >> 1;
	if(mid >= x) modify(k << 1, l, mid, x, y, v);
	if(mid < y) modify(k << 1 | 1, mid + 1, r, x, y, v);
	return;
}
void update(int k, int l, int r, int x, int y)
{
	if(x <= l && r <= y)
	{
		if(add[k] == -1) tag[k] ^= 1;
		else add[k] ^= 1;
		return;
	}
	pushdown(k, l, r);
	int mid = (l + r) >> 1;
	if(mid >= x) update(k << 1, l, mid, x, y);
	if(mid < y) update(k << 1 | 1, mid + 1, r, x, y);
	return;
}
int query(int k, int l, int r, int x)
{
	if(l == r)
	{
		if(add[k] == -1) return tag[k];
		else return add[k];
	}
	pushdown(k, l, r);
	int mid = (l + r) >> 1;
	if(mid >= x) return query(k << 1, l, mid, x);
	if(mid < x) return query(k << 1 | 1, mid + 1, r, x);
}
int main()
{
	memset(add, -1, sizeof(add));
	int l, r;
	int n = 65535;
	while(scanf("%s", op + 1) != EOF)
	{
		scanf("%s", ch + 1); 
		int len = strlen(ch + 1);
		for(int i = 1; i <= len; i++) if(ch[i] == ',') pos = i;
		l = r = 0;
		for(int i = 2; i < pos; i++) l = l * 10 + ch[i] - '0'; 
		for(int i = pos + 1; i < len; i++) r = r * 10 + ch[i] - '0';
		if(ch[1] == '[') l = l * 2 + 1; else l = l * 2 + 2;
		if(ch[len] == ')') r = r * 2; else r = r * 2 + 1;
		if(op[1] == 'U') modify(1, 1, 2 * (n + 1), l, r, 1);
		if(op[1] == 'I')
		{
		    if(l != 1) modify(1, 1, 2 * n + 2, 1, l - 1, 0);
		    if(r != 2 * n + 2) modify(1, 1, 2 * n + 2, r + 1, 2 * n + 2, 0);
	    }
		if(op[1] == 'D') modify(1, 1, 2 * n + 2, l, r, 0);
		if(op[1] == 'C') 
		{
			update(1, 1, 2 * n + 2, 1, 2 * n + 2);
		    if(l != 1) modify(1, 1, 2 * n + 2, 1, l - 1, 0);
		    if(r != 2 * n + 2) modify(1, 1, 2 * n + 2, r + 1, 2 * n + 2, 0);
		}
		if(op[1] == 'S')
		{
			update(1, 1, 2 * n + 2, l, r);
		}
	}
	int lst = 1;
	int pd = 0; int now = 0;
	while(query(1, 1, 2 * n + 2, lst) == 0 && lst <= 2 * n + 1) lst++;
	now = lst;
	while(now <= 2 * n + 1)
	{
	    int x = query(1, 1, n * 2 + 2, now + 1);
		if(x == 0)
		{
			if(lst % 2 == 1)
			{
				printf("[%d,", lst / 2);
			} else printf("(%d,", (lst - 1) / 2);
			if(now % 2 == 1)
			{
				printf("%d]", now / 2);
			} else printf("%d)", now / 2);
		    pd = 1; printf(" ");
			lst = now + 1;
			while(query(1, 1, 2 * n + 2, lst) == 0 && lst <= (n * 2 + 1)) lst++; 
			now = lst + 1;
		}	
		else 
		{
			now++;
		    continue;
		}
	}
	if(!pd) printf("empty set
");
	return 0; 
}

T3 Sue的小球

题意：在一个平面直角坐标系里，(Sue)在(x)轴的一个点，(Sue)可以沿(x)轴的正方向或负方向移动，有(n)个彩蛋，分别位于

((x_i), (y_i))，下落速度为(v_i)，(Sue)的移动速度是(1)单位距离每单位时间。求最高得分。

解法:

(dp)

引自论文: 在常规动态规划问题中，我们面临当前状态时“行动”造成的花费往往与这个 状 态 是 同 时 计 算 的 。 例如在经典的石子合并问题中， 规划方程为(f[i][j]=max{f[i][k]+f[k+1][j]}+w(i,j))当我们计算 (f[i][j])时，才会把将 i 到 j 的石子全部 合并到一起这一“行动”的费用加进去。这很符合我们的思维习惯。 然而近年来频繁出现一类动态规划问题，在这类问题中，当前“行动”的费用的一部分需要在之前决策时被计算并以状态的形式对当前状态造成影响。造成这 一独特的计算的原因就是当前的决策会对未来的“行动”费用造成影响。这类问题 构造方程往往比较困难，需要仔细分析原题，找到矛盾所在。

对应在这道题中，是指我们在写(dp)方程时，当前的时间(t)会对以后的计算产生影响，所以我们直接把(t)给算到(dp)值也就是所对应的花费中，这样就可以保证算法的正确性了。

我们先把纵坐标全部加起来，然后就不用管纵坐标了，问题被转化成了求最小花费。

(dp)状态的写法：

用(f[i][j])表示跑了(i)到(j)这段距离并且最后位于(i)的最小花费，(g[i][j])表示最后位于(j)的最小花费

首先肯定要对横坐标进行排序，对于起点的处理，我们只需要把它也加入排序中，然后把它的(dp)值设为(0)就可以了。

错因分析：

首先，对于”费用提前计算“的思想还不够熟悉，虽然自己之前做过类似的题，但在比赛中却忘记用这种思想了。

其次，太拘泥于对于起点的处理，导致自己想出(dp)方程的难度变大，对于这种含起点的区间(dp)问题，把起点对应的(dp)值设为(0)，其它设为正无穷应该是很常见的做法，我却没有想到。

#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
#define maxn 1010
int n, m;
int f[maxn][maxn], g[maxn][maxn];
struct node
{
	int x, y, v;
}egg[maxn];
bool cmp(node a, node b)
{
	return a.x < b.x;
}
int cnt, sum[maxn], x0, pos;
int main()
{
	memset(f, 0x3f, sizeof(f));
	memset(g, 0x3f, sizeof(g));
	scanf("%d%d", &n, &x0);
	for(int i = 1; i <= n; i++) scanf("%d", &egg[i].x);
	for(int i = 1; i <= n; i++){scanf("%d", &egg[i].y); cnt += egg[i].y;}
	for(int i = 1; i <= n; i++) scanf("%d", &egg[i].v);
	egg[n + 1].x = x0; egg[n + 1].y = 0; egg[n + 1].v = 0;
	sort(egg + 1, egg + n + 1 + 1, cmp);
	for(int i = 1; i <= n + 1; i++)
	{
		sum[i] = sum[i - 1] + egg[i].v;
		if(egg[i].x == x0) pos = i;
    }
	f[pos][pos] = g[pos][pos] = 0;
	for(int len = 1; len <= n + 1; len++)
	{
		for(int i = 1; len + i - 1 <= n + 1; i++)
		{
			int j = len + i - 1;
			f[i][j] = min(f[i][j],
                          f[i + 1][j] + (egg[i + 1].x - egg[i].x) * (sum[n + 1] - sum[j] + sum[i]));
			f[i][j] = min(f[i][j], 
                          g[i + 1][j] + (egg[j].x - egg[i].x) * (sum[n + 1] - sum[j] + sum[i]));
			g[i][j] = min(g[i][j], 
                          f[i][j - 1] + (egg[j].x - egg[i].x) * (sum[n + 1] - sum[j - 1] + sum[i - 1]));
			g[i][j] = min(g[i][j], 
                          g[i][j - 1] + (egg[j].x - egg[j - 1].x) * (sum[n + 1] - sum[j - 1] + sum[i - 1]));
		}
	}
	double ans, tmp = 1000; ans = cnt - min(f[1][n + 1], g[1][n + 1]); ans = ans / tmp; 
	printf("%0.3lf
", ans);
	return 0;
}