首页 > 其他分享> > 2020.12.26 模拟赛题解

2020.12.26 模拟赛题解

2020-12-29 19:02:50 作者：互联网

0x00 前言

~~一些吐槽。~~

考得很变态诶，看每道题平均两秒的时限就知道了。。。

T1 降智了想到优化懒得打。

T2 口胡了假优化，结果和暴力分一样？？

T3 黑题还绑点？？

沦为平民了www。

0x01 T1

一道好题。

题目描述不在赘述，Link。这道题抽象概括出模型后反而更复杂））

首先，不难往 \(dp\) 方向去想。

我们定义 \(dp[i][j]\) 表示处理到第 \(i\) 个语句时，第 \(i\) 个语句处在第 \(j\) 个缩进时的总共方案数。

找边界，你会发现只有 for 语句能贡献新的缩进，即有多少个 for 语句就最多有多少个缩进，故我们记 for 语句的个数为为 \(m\)。

如果第 \(i-1\) 个语句是一个 for 语句，则当前语句一定在上一个语句的下一个缩进。

这很显然吧，毕竟 for 语句一定不能在整个代码的最后一个。这个时候更新就很简单了。

\(dp[i][j] = dp[i - 1][j - 1] (\forall j, 1 \leq j \leq m)\)。

那如果不是 for 语句呢？

我们想一想一个缩进的性质，如果上一个语句可以处于第 \(j\) 个缩进，则当前语句处于 \(i,0 \leq i \leq j\) 都是合法的。

因为如果上一个语句处于第 \(j\) 个缩进，则一定能在上面找到对应的使它合法的 for（当然如果 \(j = 0\) 就找不到），那么在下面再接一个语句都是没问题的，相当于我们在我们找到的那个 for 下再接了一个语句。

这样就很明朗了。

\(dp[i][j] = \sum_{k = j}^m dp[i - 1][k]\)。

当然，你会发现这里其实有个后缀和，那么每次维护上一个状态的后缀和就可以实现优化。

注意，这道题玄学卡前缀和（或许是卡 long long？？），我下来调就是因为这个 \(80pt\) 的。

实现就按以上转移即可。注意取模。

#include <cstdio>

typedef long long LL;
const int MAXN = 5e3 + 5;
const LL mod = (LL)1e9 + 7;
int a[MAXN];
LL dp[MAXN][MAXN], sum[MAXN];
// 第 i 个数，当前 j 个缩进。 

int main() {
	int n, m = 0;
	scanf ("%d", &n);
	for(int i = 1; i <= n; i++) {
		char st[5];
		scanf ("%s", &st);
		if(st[0] == 's')
			a[i] = 0;
		else 
			a[i] = 1;
		m += a[i];
	}
	m++;
	dp[1][0] = 1;
	for(int i = 2; i <= n; i++) {
		sum[m + 1] = 0;
		for(int j = m; j >= 0; j--)
			sum[j] = (sum[j + 1] % mod + dp[i - 1][j] % mod) % mod;
		if(a[i] == 0) {		
			if(a[i - 1] == 1) {
				for(int j = 1; j <= m; j++)
					dp[i][j] = dp[i - 1][j - 1] % mod;
				continue;
			}				
			for(int j = 0; j <= m; j++)	
				dp[i][j] = sum[j] % mod; 
		}
		else {
			if(a[i - 1] == 1) {
				for(int j = 1; j <= m; j++)
					dp[i][j] = dp[i - 1][j - 1] % mod;
				continue;
			}
			for(int j = 0; j <= m; j++)	
				dp[i][j] = sum[j] % mod;
		}
	} 
	LL ans = 0;
	for(int i = 0; i <= m; i++)
		ans = (ans % mod + dp[n][i] % mod) % mod; 
	printf("%lld\n", ans);
	return 0;
}

0x03 T3

众所周知，水是黑的。

洛谷上的链接link，原题来自 BZOJ 水壶，OJ 上的题显然是喵喵喵根据「AnOI 2020」格式改的。。

首先，我们来证明一个性质：

对于一个图，其中任意两个点间的路径我们记为 \(p\)。每个路径上最大的权值为 \(q\)。则满足 \(q\) 最小的路径 \(p_0\) 一定在原图的最小生成树（森林）上。

我们设这颗最小生成树（森林）为 \(T\)，两点间路径 \(p\) 上的最大值为 \(\max(p)\)。假设 \(p\) 不是 \(T\) 上的路径，则一定存在一条路径 \(p_1\) 使得 \(\max(p_1)\) 比 \(\max(p)\) 更小。我们考虑将 \(p_1\) 加入 \(T\)。

将这个路径加入后，一定会在原树上出现一个环，而这个环上的最大值一定为 \(\max(p)\)。

你会惊讶的发现，如果删掉那条权值为 \(\max(p)\) 的边，你会得到一颗新的树，而明显这才是真正的最小生成树。

推出矛盾！原性质得证。

那么我们现在得到了这样一个性质，抽象概括出来也就是说我们的答案一定在原图的 最小生成树（森林） 上，因为树上两点路径唯一，所以答案就是两点间路径上的最大边。这显然可以 树上倍增 解决。

最后讲讲预处理，也就是如何去建图。很显然，暴力 BFS 是不可取的。于是我们考虑更高效的预处理方法。

其实还是 BFS，类双向 BFS。我们首先将所有的城市装入 BFS 的队列，然后同时开始进行扩展。对一个点我们打两种标记：\(flag\) 表示这个点是由哪个城市第一次走到的，\(ans\) 表示第一个走到这个点的城市到它的距离。那么对于当前扩展到的节点，它的标记有两种情况。

假设上一个点为 \(v\)，当前点为 \(u\)。

\(ans_u\) 里没有值，也就是说当前是第一次走到，更新 \(flag_u\) 继续扩展即可。

ans[u] = ans[v] + 1;
flag[u] = flag[v];

ans 里有值，也就是说之前有城市扩展到了，那么就可以将当前这个城市和之前扩展的城市进行连边，权值就是上一个点和这个点的 \(ans\) 之和。

Add_Edge(flag[u], flag[v], ans[u] + ans[v]);

然后按正常 BFS 继续遍历即可，完结撒花。

（代码略显冗长，仅供参考。

#include <cstdio>
#include <queue>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;

int read() {
    int k = 1, x = 0;
    char s = getchar();
    while (s < '0' || s > '9') {
        if (s == '-')
            k = -1;
        s = getchar();
    }
    while (s >= '0' && s <= '9') {
        x = (x << 3) + (x << 1) + s - '0';
        s = getchar();
    }
    return x * k;
}

void write(int x) {
    if(x < 0) {
    	putchar('-');
		x = -x;
    }
    if(x > 9)
		write(x / 10);
    putchar(x % 10 + '0');
}

void print(int x, char s) {
	write(x);
	putchar(s);
}

int Max(int x, int y) { return x > y ? x : y; }
int Min(int x, int y) { return x < y ? x : y; }
void Swap(int &X, int &Y) {
    int t = X;
    X = Y;
    Y = t;
}

const int MAXN = 2e3 + 5;
const int MAXL = 4e6 + 5;
int mp[MAXN][MAXN], h, w, p;
char s[MAXN];

struct node {
    int x, y;
    node() {}
    node(int X, int Y) {
        x = X;
        y = Y;
    }
};

struct edge {
    int u, v, w;
    edge() {}
    edge(int U, int V, int W) {
        u = U;
        v = V;
        w = W;
    }
} e[MAXL];
int len = 0;

int dx[4] = { 1, -1, 0, 0 };
int dy[4] = { 0, 0, 1, -1 };
int ans[MAXN][MAXN], flag[MAXN][MAXN];
queue<node> q;

void bfs() {
    while (!q.empty()) {
        node now = q.front();
        q.pop();
        for (int i = 0; i < 4; i++) {
            int cx = now.x + dx[i];
            int cy = now.y + dy[i];
            if (cx < 1 || cx > h)
                continue;
            if (cy < 1 || cy > w)
                continue;
            if (mp[cx][cy])
                continue;
            if (ans[cx][cy] == -1) {
                ans[cx][cy] = ans[now.x][now.y] + 1;
                flag[cx][cy] = flag[now.x][now.y];
                q.push(node(cx, cy));
            } else if (flag[cx][cy] != flag[now.x][now.y])
                e[++len] = edge(flag[now.x][now.y], flag[cx][cy], ans[cx][cy] + ans[now.x][now.y]);
        }
    }
}

struct data {
    int ma, fa;
    data() {}
    data(int Ma, int Fa) {
        ma = Ma;
        fa = Fa;
    }
} f[MAXL][25];

int fa[MAXL];

bool cmp(edge x, edge y) { return x.w < y.w; }

void Make_Set(int n) {
    for (int i = 1; i <= n; i++) fa[i] = i;
}

int Find_Set(int x) {
    if (fa[x] == x)
        return x;
    return fa[x] = Find_Set(fa[x]);
}

struct graph {
    int v, w;
    graph() {}
    graph(int V, int W) {
        v = V;
        w = W;
    }
};

vector<graph> g[MAXL];

void Add_Edge(int u, int v, int w) {
    g[u].push_back(graph(v, w));
    g[v].push_back(graph(u, w));
}

void kruskal() {
    Make_Set(p);
    sort(e + 1, e + len + 1, cmp);
    for (int i = 1; i <= len; i++) {
        int S = Find_Set(e[i].u), E = Find_Set(e[i].v);
        if (S == E)
            continue;
        Add_Edge(S, E, e[i].w);
        fa[S] = E;
    }
}

int dep[MAXL];

void dfs(int x, int fa) {
    for (int i = 0; i < g[x].size(); i++) {
        int v = g[x][i].v;
        if (v == fa)
            continue;
        dep[v] = dep[x] + 1;
        f[v][0].fa = x;
        f[v][0].ma = g[x][i].w;
        for (int j = 0; j <= 20; j++) {
            f[v][j + 1].fa = f[f[v][j].fa][j].fa;
            f[v][j + 1].ma = Max(f[v][j].ma, f[f[v][j].fa][j].ma);
        }
        dfs(v, x);
    }
}

int lca(int x, int y) {
    if (dep[x] < dep[y])
        Swap(x, y);
    int ans = 0;
    for (int i = 20; i >= 0; i--)
        if (dep[f[x][i].fa] >= dep[y]) {
            ans = Max(ans, f[x][i].ma);
            x = f[x][i].fa;
        }
    if (x == y)
        return ans;
    for (int i = 20; i >= 0; i--)
        if (f[x][i].fa != f[y][i].fa) {
            ans = Max(ans, f[x][i].ma);
            ans = Max(ans, f[y][i].ma);
            x = f[x][i].fa;
            y = f[y][i].fa;
        }
    ans = Max(ans, f[x][0].ma);
    ans = Max(ans, f[y][0].ma);
    return ans;
}

int main() {
//    freopen("04-04.in", "r", stdin);
//    freopen("ans1.out", "w", stdout);
    int Q;
    h = read(), w = read(), p = read(), Q = read();
    for (int i = 1; i <= h; i++) {
        scanf("%s", s + 1);
        for (int j = 1; j <= w; j++)
            if (s[j] == '.')
                mp[i][j] = 0;
            else
                mp[i][j] = 1;
    }
    memset(ans, -1, sizeof ans);
    for (int i = 1; i <= p; i++) {
        int x = read(), y = read();
        flag[x][y] = i;
        ans[x][y] = 0;
        q.push(node(x, y));
    }
    bfs();
    //	printf("%d\n", len);
    kruskal();
    for (int i = 1; i <= p; i++)
        if (fa[i] == i)
            dfs(i, -1);
    for (int i = 1; i <= Q; i++) {
        int x = read(), y = read();
        if (Find_Set(x) != Find_Set(y))
            print(-1, '\n');
        else
            print(lca(x, y), '\n');
    }
    return 0;
}

标签：语句,26,int,题解,flag,2020.12,ans,MAXN,now
来源： https://www.cnblogs.com/Chain-Forward-Star/p/14208224.html

2020.12.26 模拟赛 题解

0x00 前言

0x01 T1

0x03 T3

2020.12.26 模拟赛题解