模拟赛20181031 雅礼 Wearry 养花 折射 画作

% Day1 Solution
% Wearry
% Stay determined!

养花

  
考虑当 $k$ 确定的时候如何求答案,
显然对于所有形如 $[ak, (a+1)k)$ 的值域区间, 最大值一定是最优的.

  
进一步观察发现, 这样的区间总个数只有 $k \ln k$ 个.
考虑分块, 那么我们可以在 $O(n + k \ln k)$ 的时间复杂度内处理出一个块对于任意 $k$ 的答案.
询问时复杂度是 $O(mS)$ 的, 取 $S = \sqrt{k \ln k}$ 可以达到最优复杂度 $O(n \sqrt{k \ln k})$.

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
const int B = 1000;
int n, m, A[MAXN+5], ans[MAXN/B+5][MAXN+5], b[MAXN+5];
int main ()
{
	scanf("%d%d", &n, &m);
	for(int i = 0; i < n; i++)
		scanf("%d", &A[i]);
	int blks = (n-1)/B+1;
	for(int i = 0; i < blks; i++)
	{
		memset(b, 0, sizeof b);
		for(int j = i*B; j < B*(i+1) && j < n; j++) b[A[j]] = A[j];
		for(int j = 1; j <= MAXN; j++) if(!b[j]) b[j] = b[j-1];
		for(int j = 1; j <= MAXN; j++) for(int k = 0; k <= MAXN; k += j) ans[i][j] = max(ans[i][j], b[min(k+j-1,MAXN)]-k);
	}
	int x, y, z, a, b, Ans;
	while(m--)
	{
		scanf("%d%d%d", &x, &y, &z), x--, y--;
		a = x/B + 1, b = y/B, Ans = 0;
		if(a > b) for(int i = x; i <= y; i++) Ans = max(Ans, A[i]%z);
		else
		{
			for(int i = x; i < a*B; i++) Ans = max(Ans, A[i]%z);
			for(int i = b*B; i <= y; i++) Ans = max(Ans, A[i]%z);
			for(int i = a; i < b; i++) Ans = max(Ans, ans[i][z]);
		}
		printf("%d\n", Ans);
	}
}

折射

  
若将所有点按照 $y_i$ 的顺序转移, 有上界和下界两个限制, 难以优化.

  
考虑按照 $x_i$ 排序转移, 并记录 $f_{i, 0/1}$ 表示以第 $i$ 个点为顶端接下来向左或向右的折线方案数.
从左到右加点, 考虑前 $i$ 个点构成的包含 $i$ 点的折线. 由于新点横坐标最大, 所以只可能在折线的第一位或第二位:

1. $\forall y_j < y_i, f_{i, 0} \leftarrow f_{j, 1}$

2. $\forall y_j > y_i, f_{j, 1} \leftarrow f_{k, 0} \mid x_k > x_j \,\, \mathrm{and} \,\, y_k < y_i$

  
第二种情况可以前缀和优化, 复杂度 $O(n^2)$.

#include <bits/stdc++.h>
using namespace std;
#define file(x) freopen(x".in", "r", stdin);freopen(x".out", "w", stdout);
#define pii pair<int,int>
namespace IO
{
    inline void read(int &num)
    {
        char ch; int flag = 1;
        while(!isdigit(ch=getchar()))if(ch=='-')flag=-flag;
        for(num=ch-'0';isdigit(ch=getchar());num=num*10+ch-'0');
        num *= flag;
    }
}
using namespace IO;
const int MAXN = 100005;
const int mod = 1e9+7;
int n, dp[MAXN][2];
pii p[MAXN];
int main ()
{
    read(n);
    for(int i = 1; i <= n; i++)
        read(p[i].first), read(p[i].second);
    sort(p + 1, p + n + 1);
    int Ans = 0;
    for(int i = 1; i <= n; i++)
    {
        dp[i][0] = dp[i][1] = 1;
        for(int j = i-1; j; j--)
            if(p[j].second < p[i].second)
                (dp[i][0] += dp[j][1]) %= mod;
            else (dp[j][1] += dp[i][0]) %= mod;
    }
    for(int i = 1; i <= n; i++) (Ans += (dp[i][0] + dp[i][1]) % mod) %= mod;
    printf("%d\n", (Ans+mod-n)%mod);
}

画作

  
不难证明猜到一个这样的结论: 存在一种最优方案使得每次操作的区域是上一次的子集且颜色与上一次相反.

  
考虑归纳证明, 记 $S$ 为当前所有操作区域的并, $T$ 为接下来一步的操作区域, 我们有:

1. $T$ 与 $S$ 有交的情况一定可以转化成 $T$ 被 $S$ 包含的情况.

2. $T$ 与 $S$ 交集为空时, 可以找一个连接 $S$ 和 $T$ 的集合 $M$ 并操作 $S \cup T \cup M$,
   并将之前的所有操作连接到更外的层以及外层的连接部分同时操作, 特殊处理最外层和第二层的情况.

3. $T$ 被 $S$ 包含时, $T$ 落在某个完整区域内时等价于情况二,
   否则一定连接若干个同色块, 这些块可以同时处理, 步数一定不会更劣.

  
知道这个结论就比较好做了, 我们可以枚举最后被修改的区域,
这时答案就是将同色边边权当作 $0$, 异色边边权当作 $1$ 后距离这个点最远的黑色点的距离, 对所有点取最小值即可.

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 55, MAXM = 55;
#define pii pair<int,int>
#define mp make_pair
#define X first
#define Y second
int dx[4] = { 0, 0, 1, -1 };
int dy[4] = { 1, -1, 0, 0 };
char s[MAXN][MAXM];
int dis[MAXN][MAXM], n, m;
deque<pii>q;

inline bool chkmin(int &A, int B) { return B < A ? A = B, 1 : 0; }
inline bool chkmax(int &A, int B) { return B > A ? A = B, 1 : 0; }

int bfs(int u, int v)
{
	memset(dis, -1, sizeof dis);
	int ret = -1;
	dis[u][v] = 0; q.push_back(mp(u, v));
	while(!q.empty())
	{
		pii tp = q.front(); q.pop_front();
		if(s[tp.X][tp.Y] == '1') chkmax(ret, dis[tp.X][tp.Y]);
		for(int i = 0; i < 4; i++)
			if((u=tp.X+dx[i]) >= 1 && (v=tp.Y+dy[i]) >= 1 && u <= n && v <= m && dis[u][v] == -1)
			{
				if(s[tp.X][tp.Y] == s[u][v])
					dis[u][v] = dis[tp.X][tp.Y], q.push_front(mp(u, v));
				else dis[u][v] = dis[tp.X][tp.Y] + 1, q.push_back(mp(u, v));
			}
	}
	return ret;
}

int main()
{
	scanf("%d%d", &n, &m);
	for(int i = 1; i <= n; i++)
		scanf("%s", s[i]+1);
	int Ans = 0x7f7f7f7f;
	for(int i = 1; i <= n; i++)
		for(int j = 1; j <= m; j++)
			chkmin(Ans, bfs(i, j));
	printf("%d\n", Ans+1);
}