标签：语句 26 int 题解 flag 2020.12 ans MAXN now
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
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。