[2021 CSP-S提高组] 题解（廊桥分配+括号序列+回文+交通规划）

最新推荐文章于 2023-04-05 17:51:39 发布
最新推荐文章于 2023-04-05 17:51:39 发布
阅读量3k 收藏 9
点赞数 2
分类专栏： 模拟 贪心/反悔贪心/延迟贪心 # 区间DP 文章标签： 模拟 贪心算法 前缀和优化区间dp 最短路优化网络流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Emm_Titan/article/details/120948499
版权

2021 CSP-S 题解

配合👉CSP-S游记 食用更佳哦~

【雷】：只是在民间数据过了，不保证一定正确。仅供参考！！！
【雷】：只是在民间数据过了，不保证一定正确。仅供参考！！！
【雷】：只是在民间数据过了，不保证一定正确。仅供参考！！！

廊桥分配

problem

题目链接

solution

显然暴力就是枚举国内的廊桥数量，然后模拟一遍， O ( n 2 ) O(n^2) O(n2)。

正解就是加速这个过程。

设 f 1 [ i ] : f_1[i]: f1​[i]: 国内有 i i i 个廊桥能承载的飞机数量， f i [ i ] : f_i[i]: fi​[i]: 国外的。

最后就是 max ⁡ { f 1 [ i ] + f 2 [ n − i ] } \max\Big\{f_1[i]+f_2[n-i]\Big\} max{f1​[i]+f2​[n−i]}

考虑将 n n n 个廊桥看成 n n n 个桶，对于国内飞机，尽量地往前停，否则就再开一个廊桥停这个飞机，用前缀和就能求得 f 1 [ i ] / f 2 [ i ] f_1[i]/f_2[i] f1​[i]/f2​[i]。

可以通过 set \text{set} set 维护，迅速找到每架飞机着陆前空的廊桥。

code

#include <set>
#include <cstdio>
#include <iostream>
using namespace std;
#define maxn 100005
set < pair < int, int > > s;
int f1[maxn], f2[maxn];
int n, m1, m2;

void calc( int m, int *f ) {
	s.clear();
	for( int i = 1, x, y;i <= m;i ++ ) {
		scanf( "%d %d", &x, &y );
		s.insert( { x, y } );
	}
	for( int i = 1;i <= m;i ++ ) {
		auto it = s.begin();
		while( it != s.end() ) {
			f[i] ++;
			int k = it -> second;
			s.erase( it );
			it = s.lower_bound( { k + 1, 0 } );
		}
		f[i] += f[i - 1];
	}
}

int main() {
	scanf( "%d %d %d", &n, &m1, &m2 );
	calc( m1, f1 );
	calc( m2, f2 );
	int ans = 0;
	for( int i = 0;i <= n;i ++ )
		ans = max( ans, f1[i] + f2[n - i] );
	printf( "%d\n", ans );
	return 0;
}

括号序列

problem

题目链接

solution

这道题难就难在 **()** 是不合法的。

为了知道左右的信息，我们选择区间 d p dp dp。

设 g [ l , r ] : [ l , r ] g[l,r]:[l,r] g[l,r]:[l,r] 能否全为 ∗ * ∗

设 f [ l , r ] : [ l , r ] f[l,r]:[l,r] f[l,r]:[l,r] 强制 l − r l-r l−r 括号匹配的方案数

设 d p [ l , r ] : [ l , r ] dp[l,r]:[l,r] dp[l,r]:[l,r] 为超级完美序列的方案数，不要求 l − r l-r l−r 一定匹配

转移很简单，就是将合法的规则翻译成方程式即可。

  • (***(...)) 枚举左边连续一段 ∗ * ∗
  • ((...)***) 枚举右边连续一段 ∗ * ∗
  • ((...)) 直接嵌套一个匹配括号对
  • ()**() l − r l-r l−r 与不同的括号匹配，中间要么为 ∅ \empty ∅ 要么为连续的 ∗ * ∗

主要是 d p − f dp-f dp−f 之间相互转移， g g g 是预处理做的。

这就是妥妥的 O ( n 4 ) O(n^4) O(n4) 的转移。

正解就是在这个基础上进行了前缀和/后缀和的优化。

code-65’

#include <cstdio>
#define maxn 505
#define int long long
#define mod 1000000007
int n, m;
char s[maxn];
int f[maxn][maxn], dp[maxn][maxn];
bool g[maxn][maxn];

signed main() {
	scanf( "%lld %lld %s", &n, &m, s + 1 );
	for( int i = 1;i <= n;i ++ ) {
		if( s[i] == '*' or s[i] == '?' ) g[i][i] = 1;
		g[i][i - 1] = 1;
	}
	for( int len = 2;len <= m;len ++ )
		for( int i = 1;i + len - 1 <= n;i ++ ) {
			int j = i + len - 1;
			if( s[i] == '*' or s[i] == '?' ) g[i][j] |= g[i + 1][j];
			if( s[j] == '*' or s[j] == '?' ) g[i][j] |= g[i][j - 1];
		}
	for( int i = 1;i < n;i ++ )
		if( s[i] == ')' or s[i] == '*' or s[i + 1] == '(' or s[i + 1] == '*' ) continue;
		else f[i][i + 1] = dp[i][i + 1] = 1;
	for( int len = 3;len <= n;len ++ ) 
		for( int i = 1;i + len - 1 <= n;i ++ ) {
			int j = i + len - 1;
			if( s[i] == ')' or s[i] == '*' or s[j] == '(' or s[j] == '*' ) continue;
			f[i][j] = ( f[i][j] + dp[i + 1][j - 1] ) % mod;
			if( j - 1 - ( i + 1 ) + 1 <= m ) f[i][j] = ( f[i][j] + g[i + 1][j - 1] ) % mod;
			for( int k = i + 2;k < j - 1;k ++ ) 
				if( k - 1 - ( i + 1 ) + 1 > m ) break;
				else f[i][j] = ( f[i][j] + g[i + 1][k - 1] * dp[k][j - 1] ) % mod;
			for( int k = j - 2;k > i + 1;k -- )
				if( ( j - 1 ) - ( k + 1 ) + 1 > m ) break;
				else f[i][j] = ( f[i][j] + g[k + 1][j - 1] * dp[i + 1][k] ) % mod;
			for( int k = i + 1;k < j - 1;k ++ ) 
				for( int t = 0;t <= m;t ++ )
					if( k + t + 1 >= j ) break;
					else dp[i][j] = ( dp[i][j] + f[i][k] * dp[k + t + 1][j] * g[k + 1][k + t] ) % mod;
			dp[i][j] = ( dp[i][j] + f[i][j] ) % mod;
				
		}
	printf( "%lld\n", dp[1][n] );
	return 0;
}

code-100‘

#include <cstdio>
#include <iostream>
using namespace std;
#define int long long
#define mod 1000000007
#define maxn 505
int f[maxn][maxn], g[maxn][maxn], h[maxn][maxn];
char s[maxn];
int n, m;

bool is( int x, char c ) {
	if( x < 1 or x > n ) return 0;
	else return s[x] == '?' or s[x] == c;
}

signed main() {
	scanf( "%lld %lld %s", &n, &m, s + 1 );
	for( int i = 2;i <= n;i ++ ) f[i][i - 1] = 1;
	for( int l = n;l;l -- )
		for( int r = l;r <= n;r ++ ) {
			if( is( l, '(' ) and is( r, ')' ) ) {
				f[l][r] = f[l + 1][r - 1];
				for( int i = l + 2;i <= min( l + m + 1, r ) and is( i - 1, '*' );i ++ )
					f[l][r] = ( f[l][r] + f[i][r - 1] ) % mod;
				for( int i = r - 2;i >= max( l + 1, r - m - 1 ) and is( i + 1, '*' );i -- )
					f[l][r] = ( f[l][r] + f[l + 1][i] ) % mod;
			}
			h[l][r] = g[l][r] = f[l][r];
			for( int i = r - 1;i >= r - m and is( i + 1, '*' );i -- ) 
				g[l][r] = ( g[l][r] + h[l][i] ) % mod;
			for( int i = l;i < r;i ++ ) 
				f[l][r] = ( f[l][r] + g[l][i] * f[i + 1][r] ) % mod;

		}
	printf( "%lld\n", f[1][n] );
	return 0;
}

回文

problem

题目链接

solution

这道题比前面的题可能还要简单一点。

会发现，每次选择最左端或者最右端的数字，连续选择对应在中间的序列也必须是连续的。

i.e.

1....213....3 选最左边的 1 1 1，接着选最右边的 3 3 3， b b b 序列里面就是 13...，为了最后的回文，最后几次操作必须是选 3 3 3 后立马选 1 1 1。

那会不会是 1...123....3 这种呢，123 貌似可以不相邻成为两端。

显然不可能，先选的 13... 之后才选择 2 2 2 ，那么回文就必须先选 2 2 2，再选 31，而 2 2 2 都被 1 1 1 和 3 3 3 堵死了。

所以这就是一个贪心模拟的过程。

优先从左边选择开始模拟。

code

#include <cstdio>
#define maxn 1000005
int T, n, flag;
int a[maxn], ans[maxn];
int pos[2][maxn];

void print() {
	int l = 1, r = n << 1;
	for( int i = 1;i <= ( n << 1 );i ++ )
		if( ans[i] == l ) printf( "L" ), l ++;
		else printf( "R" ), r --;
	printf( "\n" );
}

void solve( int l, int r, int L, int R ) {
	for( int i = 2;i <= n;i ++ ) {
		if( l < L ) {
			if( pos[1][a[l]] == L - 1 ) { ans[i] = l ++, ans[(n << 1 | 1) - i] = -- L; continue; }
			if( pos[1][a[l]] == R + 1 ) { ans[i] = l ++, ans[(n << 1 | 1) - i] = ++ R; continue; }
		}
		if( r > R ) {
			if( pos[0][a[r]] == L - 1 ) { ans[i] = r --, ans[(n << 1 | 1) - i] = -- L; continue; }
			if( pos[0][a[r]] == R + 1 ) { ans[i] = r --, ans[(n << 1 | 1) - i] = ++ R; continue; }
		}
		flag = 0;
		return;
	}
}

int main() {
	scanf( "%d", &T );
	while( T -- ) {
		scanf( "%d", &n );
		for( int i = 1;i <= n;i ++ ) pos[0][i] = pos[1][i] = 0;
		for( int i = 1;i <= ( n << 1 );i ++ ) {
			scanf( "%d", &a[i] );
			if( ! pos[0][a[i]] ) pos[0][a[i]] = i;
			else pos[1][a[i]] = i;
		}
		flag = 1;
		ans[1] = 1, ans[n << 1] = pos[1][a[1]];
		solve( 2, n << 1, pos[1][a[1]], pos[1][a[1]] );
		if( flag ) { print(); continue; }
		flag = 1;
		ans[1] = n << 1, ans[n << 1] = pos[0][a[n << 1]];
		solve( 1, (n << 1) - 1, pos[0][a[n << 1]], pos[0][a[n << 1]] );
		if( flag ) { print(); continue; }
		printf( "-1\n" );
	}
	return 0;
}

交通规划

problem

题目链接

solution

只能黑白染色，然后端点颜色不同的边就会计算贡献。

如果想到了，就是非常明显的网络流。

这种平面图般的网络流是很经典的有最短路优化——BZOJ上有一题网络流的经典“狼抓兔子”。

就算不会最短路优化也是可以暴力上网络流硬跑前 6 0 ′ 60' 60′ 的部分分。

code-60‘

#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
#define inf 1e18
#define maxn 505
#define Maxn 260000
#define maxm 1200000
#define int long long
queue < int > q;
struct node { int to, nxt, flow; }E[maxm];
int n, m, T, cnt, N, s, t, k;
int head[Maxn], cur[Maxn], dis[Maxn];
int a[maxn][maxn], b[maxn][maxn];

void addedge( int u, int v, int flow ) {
	E[cnt] = { v, head[u], flow };
	head[u] = cnt ++;
	E[cnt] = { u, head[v], flow };
	head[v] = cnt ++;
}

bool bfs() {
	memset( dis, 0, sizeof( dis ) );
	dis[s] = 1, q.push( s );
	while( ! q.empty() ) {
		int u = q.front(); q.pop();
		for( int i = cur[u] = head[u];~ i;i = E[i].nxt ) {
			int v = E[i].to;
			if( ! dis[v] and E[i].flow ) {
				dis[v] = dis[u] + 1;
				q.push( v );
			}
		}
	}
	return dis[t];
}

int dfs( int u, int cap ) {
	if( u == t or ! cap ) return cap;
	int flow = 0;
	for( int i = cur[u];~ i;i = E[i].nxt ) {
		cur[u] = i; int v = E[i].to;
		if( dis[v] == dis[u] + 1 ) {
			int w = dfs( v, min( cap, E[i].flow ) );
			if( ! w ) continue;
			E[i ^ 1].flow += w;
			E[i].flow -= w;
			flow += w;
			cap -= w;
			if( ! cap ) break;
		}
	}
	return flow;
}

int dinic() {
	int ans = 0;
	while( bfs() ) ans += dfs( s, inf );
	return ans;
}

int id( int i, int j ) { return ( i - 1 ) * m + j; }

signed main() {
	scanf( "%lld %lld %lld", &n, &m, &T );
	for( int i = 1;i < n;i ++ ) for( int j = 1;j <= m;j ++ ) scanf( "%lld", &a[i][j] );
	for( int i = 1;i <= n;i ++ ) for( int j = 1;j < m;j ++ ) scanf( "%lld", &b[i][j] );
	while( T -- ) {
		cnt = 0, memset( head, -1, sizeof( head ) );
		scanf( "%lld", &k );
		N = n * m, s = N + k + 1, t = s + 1;
		for( int i = 1;i < n;i ++ ) for( int j = 1;j <= m;j ++ ) addedge( id(i, j), id(i + 1, j), a[i][j] );
		for( int i = 1;i <= n;i ++ ) for( int j = 1;j < m;j ++ ) addedge( id(i, j), id(i, j + 1), b[i][j] );
		for( int i = 1;i <= N;i ++ ) addedge( s, i, 0 ), addedge( i, t, 0 );
		for( int i = 1, w, x, c;i <= k;i ++ ) {
			scanf( "%lld %lld %lld", &w, &x, &c );
			++ N; int pos;
			if( x <= m ) pos = id( 1, x );
			else if( x <= n + m ) pos = id( x - m, m );
			else if( x <= n + m * 2 ) pos = id(n, 2 * m + n - x + 1);
			else pos = id( 2 * ( m + n ) - x + 1, 1 );
			addedge( N, pos, w );
			if( c ) addedge( s, N, w );
			else addedge( N, t, w );
		}
		printf( "%lld\n", dinic() );
	}
	return 0;
}
ikrvxt
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
交通规划（csp最详细题解100分代码---最小最短路径树）
q1430186623的博客
08-26 1072
问题描述 　　G国国王来中国参观后，被中国的高速铁路深深的震撼，决定为自己的国家也建设一个高速铁路系统。 　　建设高速铁路投入非常大，为了节约建设成本，G国国王决定不新建铁路，而是将已有的铁路改造成高速铁路。现在，请你为G国国王提供一个方案，将现有的一部分铁路改造成高速铁路，使得任何两个城市间都可以通过高速铁路到达，而且从所有城市乘坐高速铁路到首都的最短路程和原来一样长。请你告诉G国国王在这些条件下最少要改造多长的铁路。 输入格式 　　输入的第一行包含两个整数n, m，分别表示G国城市的数量和城市间铁路的数
洛谷P7916 [CSP-S 2021]交通规划
菜鸡Jacky0705的CSDN博客
11-15 1221
洛谷P7916 [CSP-S 2021]交通规划Part1 k⩽2k\leqslant 2k⩽2的情况Step1 分析Step2 计算分界线上边权之和 如果你没有学习过对偶图等知识，那么对你来说其他题解可能有点难理解，但这篇题解不会！在阅读这篇题解之前，你不需要掌握任何高深的知识，就可以学会这道题的做法 Part1 k⩽2k\leqslant 2k⩽2的情况 Step1 分析 首先，k=1k=1k=1的情况非常简单，你只需要把所有点染成相同颜色即可，这时候答案为000，显然是最小的 而对于k=2k=2k=2
[CSP-S 2021] 廊桥分配
00后的博客
04-05 886
# [\[CSP2021\]廊桥分配（airport）](https://ac.nowcoder.com/acm/contest/55154/E) # [P7913 \[CSP-S 2021\] 廊桥分配](https://www.luogu.com.cn/problem/P7913) ## 通过题意我们可以知道，预处理对于每个国内和国外机场来说，分配给`1-m`个廊桥进行停放。 ## $$设f[i]: 国内有 i 个廊桥能承载的飞机数量$$ ## $$设g[i]: 国外有 i 个廊桥能承载的飞机数量$$
P7916 交通规划
lzx_xzl_______的博客
12-12 587
题目描述 给定一个平面上nn条水平直线和mm条垂直直线，它们相交形成nn行mm列的网格，从上到下第rr条水平直线和从左到右第cc条垂直直线之间的交点称为格点(r, c)(r,c)。网格中任意两个水平或垂直相邻的格点之间的线段称为一条边，每条边有一个非负整数边权。 进行TT次询问，每次询问形式如下： 给出kk（TT次询问的kk可能不同）个附加点，每个附加点位于一条从网格边缘向外出发的射线上。所有从网格边缘向外出发的射线按左上-右上-右下-左下-左上的顺序依次编号为...
回文(CSP-S-2021-palin)题解
Korloa的博客(A new world for you)
02-06 8313
老规矩，献上题目： 题目描述 给定正整数n和整数序列 a1​,a2​,…,a2n​，在这2 n2n个数中， n1,2,…,n分别各出现恰好2次。现在进行 2n次操作，目标是创建一个长度同样为2n的序列 b1​,b2​,…,b2n​，初始时b为空序列，每次可以进行以下两种操作之一： 将序列a的开头元素加到b的末尾，并从a中移除。 将序列a的末尾元素加到b的末尾，并从a中移除。 我们的目的是让bb成为一个回文数列，即令其满足对所有 1≤i≤n，有 bi...
CSP 交通规划
匿名用户
03-20 243
#include <iostream> #include<cstring> #include<queue> using namespace std; // 想到了方法spfa，但是感觉不知道怎么构造之后那个判断条件，以及不知道这种论证是否成立。 const int N = 2e5 + 10,INF = 0x3f3f3f3f; // 无向图，两倍 int n; // 总点数 int h[N], w[N], e[N], ne[N], idx;
CSP2021提高组复赛解析
QuantAsk
10-30 4983
前言 终于出成绩了我可以写博客辣，官方数据还没出就先放洛谷的题目链接了。 正题 T1-廊桥分配 https://www.luogu.com.cn/problem/P7913 题目大意 有m1m_1m1​种一类飞机，m2m_2m2​种二类飞机，每个飞机有一个占用时间的区间。要给两类飞机分配恰好nnn个廊桥。 如果对于一类飞机当它来到时如果有空的它这一类的廊桥就会分配给他。 求最多能容纳多少飞机。 1≤n≤105,1≤m1+m2≤1051\leq n\leq 10^5,1\leq m_1+m_2\leq 1
2021-CSP-S(提高组)认证第一轮试题.pdf
11-09
2021-CSP-S(提高组)认证第一轮试题 全新整理
2021-CSP-S-提高组初赛
08-24
2021-CSP-S-提高组初赛试题解析 本文将对 2021-CSP-S 提高组初赛试题进行详细解析，涵盖 Linux 系统、算法、数据结构、程序设计等多个领域。 单项选择题 1. 在 Linux 系统终端中，用于列出当前目录下所含的文件和...
2019-2021 CSP-J CSP-S 第一轮成绩及分数线汇总.pdf
05-17
2021年CSP-J和CSP-S认证考试的难度较高，需要考生具备扎实的计算机基础知识和编程能力。 四、CSP-J和CSP-S认证考试备考心得 1. 坚持每天学习，逐步提高计算机基础知识和编程能力。 2. 多做练习题，熟悉考试题型和...
专题资料（2021-2022年）城市道路交通规划设计规范(1).doc
10-08
专题资料
信息学奥赛一本通2081：【21CSPS提高组】交通规划(traffic)
04-25
信息学奥赛一本通2081：【21CSPS提高组】交通规划(traffic)
2019 2020 CSP-J CSP-S组 第1轮 初赛 答案+解析.rar
09-04
2019 2020 CSP-J CSP-S组 第1轮 初赛 答案+解析.rar
2019 CSP-S组 第1轮 初赛 答案+解析 好--13页.pdf
09-02
"2019 CSP-S组 第1轮 初赛 答案+解析" 本文档提供了2019年CCF非专业级别软件能力认证第一轮（CSP-S）提高级C++语言试题A卷的答案和解析。该试卷共有10页，满分100分，包含单项选择题15题，每题2分。 试题1：x+a%3*...
CSP-S 2021 题解
Plozia 的小窝
10-25 1308
只有 T1 和 T3，另外两题鸽子了。
CSP-S2021复赛 游记
bright_XZJ的博客
10-26 763
热烈祝贺Bright__XZJ AFO了（不出意外的话，正式退役记也就这几天了） 这次主要还是写一篇关于CSP-S2021复赛的游记 在临退役，吐槽一番 一·廊桥分配 这也是我唯一认真做了的一道题了 第一次看题，没有读完，以为是一道贪心问题，类似于排表演的那个题，我不禁在考场陷入忏悔，本菜鸡没有认真学习贪心，压根不会。 后来认真读了题，发现了先来先占，然后用暴力枚举了一遍，就是把国内和国际分配的所有可能性都算一遍，然后取最大值 然后三个样例点都AC了，别提在考场上的我有多兴奋了。 下来在洛谷
关于CSP-S2021
LuckZY_的博客
09-19 1261
CSP-S考后感 总体来讲发挥比较正常吧（就只能到这个水平了） 考笛卡尔树的CCF就是屑！ CCF把RMQ问题转化成了RMQ问题 不可逆还叫编码嘛？！ vis[]畜了还可以桂林嘛？！ r不用还写他干嘛？？！！ LCAU化不用深度还要用权值嘛？！ 看完最后一题AFO已经开始写了 屑! ...
2021 CSP-S2 题解（完整版）
Code_Shark的博客
10-25 2727
[CSP-S 2021] 廊桥分配 一句话题意： 为国内航班和国际航分配廊桥的数量，使得最终停在廊桥的飞机总数最大。廊桥的使用原则是先到先得。 关键点： 廊桥是先到先得，不是自由分配！ 所有的时间点是不同的（这是树状数组优化的前提） 数据量10510^5105, 复杂度确定为nlgnnlgnnlgn级别，排序是必须的，则剩余的处理大致是一个O(n), 或加一个logn优化。 分析 由于先到先得，所以按照区间起点排序。 先不考虑廊桥的数量，单纯从为每个飞机分配廊桥的角度出发。通过随手画几个数据例子可
廊桥分配题解-CSP-S2021
u011706613的博客
10-22 351
廊桥
csp-s2提高组2021第二轮题解
最新发布
09-25
CSP-S2提高组是中国计算机学会(CCF)主办的一项全国性计算机竞赛，旨在挑选出优秀的高中生并为他们提供提高计算机科学和...以上就是CSP-S2提高组2021第二轮题解的简要概述。希望这些解题思路对参与竞赛的同学有所帮助！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值