2019牛客暑期多校训练营（第一场）

最新推荐文章于 2020-08-04 21:37:38 发布
最新推荐文章于 2020-08-04 21:37:38 发布
阅读量153 收藏
点赞数
分类专栏： 多校训练
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liexss/article/details/96835431
版权

A B C E F H I J 已补   D G未补

A.Equivalent Prefixes

赛场上n^2过掉，简直不可思议。正确的解法就是维护当前这对数能影响的左右位置的区间范围。这可以用笛卡尔树或者单调栈实现。

笛卡尔树版:

#include <iostream>
#include <map>
#include <cstring>
#include <queue>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;
#define min(a,b) ((a)<(b)?(a):(b))
const int N = 100010;
int n;
int ax[100010];
int bn[100010];
struct Cartesian_Tree {
	struct node {
		int id, val, fa;
		int son[2];
		node() {}
		node(int id, int val, int fa) : id(id), val(val), fa(fa) {
			son[0] = son[1] = 0;
		}
	}t[N];
	int root,l[N],r[N];
	void init() {
		t[0] = node(0, 0, 0);
	}
	void build(int n, int *a) {
		for (int i = 1; i <= n; ++i) {
			t[i] = node(i, a[i], 0);
		}
		for (int i = 1; i <= n; ++i) {
			int k = i - 1;
			while (t[k].val > t[i].val) {
				k = t[k].fa;
			}
			t[i].son[0] = t[k].son[1];
			t[k].son[1] = i;
			t[i].fa = k;
			t[t[i].son[0]].fa = i;
		}
		root = t[0].son[1];
	}
	int DFS(int u) {
		if (u == 0) return 0;
		l[t[u].id] = DFS(t[u].son[0]);
		r[t[u].id] = DFS(t[u].son[1]);
		return l[t[u].id] + r[t[u].id] + 1;
	}
};
Cartesian_Tree t1,t2;
int check(int x) {
	t1.init();
	t1.build(x, ax);
	t2.init();
	t2.build(x, bn);
	t1.DFS(t1.root);
	t2.DFS(t2.root);
	for (int i = 1; i <= x; i++) {
		if (t1.l[i] != t2.l[i] || t1.r[i] != t2.r[i]) {
			return 0;
		}
	}
	return 1;
}
int main(void) {
	while (scanf("%d", &n) != EOF) {
		for (int i = 1; i <= n; i++) {
			scanf("%d", &ax[i]);
		}
		for (int i = 1; i <= n; i++) {
			scanf("%d", &bn[i]);
		}
		int left = 1;
		int right = n;
		while (left <= right) {
			int mid = (left + right) / 2;
			if (check(mid)) {
				left = mid + 1;
			}
			else {
				right = mid - 1;
			}
		}
		printf("%d\n", left - 1);
	}
}

单调栈标程:

#include <iostream>
#include <map>
#include <cstring>
#include <queue>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;
#define min(a,b) ((a)<(b)?(a):(b))

std::vector<int> read(int n) {
	std::vector<int> result(n);
	std::vector<std::pair<int, int>> stack;
	stack.emplace_back(0, -1);
	for (int i = 0, a; i < n; ++i) {
		scanf("%d", &a);
		while (stack.back().first > a) {
			stack.pop_back();
		}
		result[i] = stack.back().second;
		stack.push_back(make_pair(a, i));
	}
	return result;
}

int main() {
	int n;
	while (scanf("%d", &n) == 1) {
		auto a = read(n);
		auto b = read(n);
		int length = 0;
		while (length < n && a[length] == b[length]) {
			length++;
		}
		printf("%d\n", length);
	}
}

B:

简单推公式，因为我们无法处理相乘的式子的积分，因为只有相加的式子才可以分开积分，所以首先我们要将式子拆分开，推出一般式，然后再简单的换元一下即可。

#include <iostream>
#include <map>
#include <cstring>
#include <queue>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;
#define min(a,b) ((a)<(b)?(a):(b))
const int mod = 1e9 + 7;
long long ax[1100];
long long pow_mod(long long a, long long n, long long m){
	if (n == 0) return 1;
	long long x = pow_mod(a, n / 2, m);
	long long ans = (long long)x * x % m;
	if (n % 2 == 1) ans = ans * a % m;
	return ans;
}
int main(void) {
	int n;
	while (scanf("%d", &n) != EOF) {
		for (int i = 0; i < n; i++) {
			scanf("%lld", &ax[i]);
		}
		long long ans = 0;
		for (int i = 0; i < n; i++) {
			long long v = 2 * ax[i]%mod;
			long long cnt = 1;
			for (int z = 0; z < n; z++) {
				if (i == z) continue;
				cnt = cnt * ((ax[z] * ax[z] % mod - ax[i] * ax[i]%mod) % mod+mod)%mod;
			}
			ans =( ans + pow_mod(cnt*v%mod, mod - 2, mod)%mod)%mod;
		}
		printf("%lld\n", ans);
	}
}

C

可以构造出一个拉格朗日函数，但是无奈我看不懂题解，无法将这个n元的函数求解。所以换了别人的思路，首先我们要知道当n大于0时，每当n越大，n减少一点带来的n^2贡献也会越大，这样就很明显了，我们现在总共只有1的费用，所以我们肯定会贪心的让整个序列n^2的最大值尽可能小。所以只要维护一个前缀和，寻找尽可能的最大值即可。

#include <iostream>
#include <map>
#include <cstring>
#include <queue>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;
#define maxn 10050
long long ax[maxn];
long long gcd(long long a, long long b){
	long long r;
	while (b > 0){
		r = a % b;
		a = b;
		b = r;
	}
	return a;
}

int main(void) {
	int n, m;
	while (scanf("%d%d", &n, &m) != EOF) {
		for (int i = 0; i < n; i++) {
			scanf("%lld", &ax[i]);
		}
		sort(ax, ax + n);
		long long sum = ax[n - 1];
		int i;
		long long suma = 0;
		long long sumb = 0;
		for (i = n - 2; i >= 0; i--) {
			if (sum - (n - 1 - i)*ax[i] > m) {
				break;
			}
			else if (sum - (n - 1 - i)*ax[i] <= m) {
				sum += ax[i];
			}
		}
		sum = sum - m;
		suma = suma + sum * sum;
		sumb = n - 1 - i;
		for (; i >= 0; i--) {
			suma = suma + ax[i] * ax[i] * sumb;
		}
		sumb = sumb * m * m;
		long long h = gcd(suma, sumb);
		suma /= h;
		sumb /= h;
		if (sumb == 1||suma==0) {
			printf("%lld\n", suma);
		}
		else printf("%lld/%lld\n", suma, sumb);
	}
	return 0;
}

D.

据说是FWT  未补

E.

因为你在当前位置放下的A会对之前放下的B和之后放下的B产生贡献，当前放下的B会对之前放下的A和之后放下的A产生贡献，所以就可以按照这种方式进行DP。

你在当前位置能放下A，是因为构成AB的数量不够或者构成BA的数量不够。

你在当前位置能放下B，是因为构成BA的数量不够或者构成AB的数量不够。

按照这种方式递推即可，懒得写递推式了。

#include <iostream>
#include <map>
#include <cstring>
#include <queue>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;
#define maxn 10050
const int mod = 1e9 + 7;
long long dp[2200][2200];
int main(void) {
	int n, m;
	while (scanf("%d%d", &n, &m) != EOF) {
		for (int i = 0; i <= n + m; i++) {
			for (int z = 0; z <= n + m; z++) {
				dp[i][z] = 0;
			}
		}
		dp[0][0] = 1;
		for (int i = 0; i <=(n + m); i++) {
			for (int z = 0; z <=(n + m); z++) {
				if (i < n || i - n < z) {
					dp[i + 1][z] += dp[i][z];
					dp[i + 1][z] %= mod;
				}
				if (z < m || z - m < i) {
					dp[i][z + 1] += dp[i][z];
					dp[i][z + 1] %= mod;
				}
			}
		}
		printf("%lld\n", dp[n+m][m+n]);
	}
}

F.

在三角形内随机取点，求三角形分割的最大面积的期望。

答案是11/36*S。可以积分求出

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
#include<stack>
#include<set>
#include<vector>
#include<map>
#include<cmath>
using namespace std;
typedef long long LL;
 
double p,s;
 
 
 
int main(void) {
    LL x1,y1, x2, y2, x3, y3;
    while (cin>>x1>>y1>>x2>>y2>>x3>>y3)
    {
        LL a=x2-x1,b=y2-y1;
        LL c=x3-x1,d=y3-y1;
        LL ans=abs(a*d-b*c);
        printf("%lld\n", ans*11 );
    }
    return 0;
}

 

G.

未补

 

H.

求序列内的所有集合异或和等于0的集合大小和

看了好多题解，第一次接触线性基，费力理解。

首先集合大小和可以转换为序列中每个元素的参与贡献和。

第一步:我们先求出整个序列的线性基(大小为r)，对于线性基外的元素，他们的每个集合的异或和都可以用线性基内的元素表示出来，每个元素参与贡献为2^(n-r-1).总贡献为（n-r)*2^(n-r-1).

第二步:算线性基里面元素的贡献，对于线性基里面的一个数，如果他能被另外n-1个数表示出来，那就证明存在另外一个线性基（线性基大小相等），而它是处于线性基外的元素，贡献也为2^(n-r-1)。依次判断线性基内的每个元素即可。

#include <iostream>
#include <map>
#include <cstring>
#include <queue>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;
typedef long long LL;
#define maxn 100010
const int mod = 1e9 + 7;
struct Linear_Basis{
	LL b[63], nb[63], tot;

	void init(){
		tot = 0;
		memset(b, 0, sizeof(b));
		memset(nb, 0, sizeof(nb));
	}

	bool ins(LL x){
		for (int i = 62; i >= 0; i--)
			if (x&(1LL << i)){
				if (!b[i]) { b[i] = x; tot++; break; }
				x ^= b[i];
			}
		return x > 0;
	}

	LL Max(LL x){
		LL res = x;
		for (int i = 62; i >= 0; i--)
			res = max(res, res^b[i]);
		return res;
	}

	LL Min(LL x){
		LL res = x;
		for (int i = 0; i <= 62; i++)
			if (b[i]) res ^= b[i];
		return res;
	}

	void rebuild(){
		for (int i = 62; i >= 0; i--)
			for (int j = i - 1; j >= 0; j--)
				if (b[i] & (1LL << j)) b[i] ^= b[j];
		for (int i = 0; i <= 62; i++)
			if (b[i]) nb[tot++] = b[i];
	}

	LL Kth_Max(LL k){
		LL res = 0;
		for (int i = 62; i >= 0; i--)
			if (k&(1LL << i)) res ^= nb[i];
		return res;
	}

} LB;
long long pow_mod(long long a, long long n, long long m){
	if (n == 0) return 1;
	long long x = pow_mod(a, n / 2, m);
	long long ans = (long long)x * x % m;
	if (n % 2 == 1) ans = ans * a % m;
	return ans;
}
LL ax[maxn];
int vis[maxn];
vector<LL>v;
int main(void) {
	int n;
	Linear_Basis B1, B2, B3;
	while(scanf("%d",&n)!=EOF){
		v.clear();
		B1.init();
		B2.init();
		B3.init();
		for (int i = 0; i < n; i++) {
			scanf("%lld", &ax[i]);
			vis[i] = 0;
		}
		int cnt = 0;
		LL ans = 0;
		for (int i = 0; i < n; i++) {
			if (B1.ins(ax[i])) {
				vis[i] = 1;
				cnt++;
				v.push_back(ax[i]);
			}
		}
		ans = (ans + (n-cnt)*pow_mod(2,n-cnt-1,mod)%mod) % mod;
		for (int i = 0; i < n; i++) {
			if (!vis[i]) {
				B2.ins(ax[i]);
			}
		}
		for (int i = 0; i < v.size(); i++) {
			B3 = B2;
			for (int z = 0; z < v.size(); z++) {
				if (i == z) continue;
				else {
					B3.ins(v[z]);
				}
			}
			if(!B3.ins(v[i]))
				ans = (ans + pow_mod(2, n - cnt - 1, mod) % mod) % mod;
		}
		printf("%lld\n", ans);
	}
	return  0;
}

I.

队友补的

J.

水

#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<string>
#include<iostream>
#include<map>
#include<vector>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
 
ll x, y, a, b;
 
int main()
{
    while (scanf("%lld %lld %lld %lld", &x, &a, &y, &b) != EOF)
    {
        ll fz = b * x - a * y;
        ll fm = a * b;
        if (fz == 0)
        {
            printf("=\n");
        }
        else if (fm > 0 && fz > 0 || fm < 0 && fz < 0)
        {
            printf(">\n");
        }
        else
        {
            printf("<\n");
        }
    }
 
    return 0;
}

 

liexss
关注
专栏目录
2019年牛客多校第一场B题 Integration 数学
Dillonh的博客
07-18 750
题目链接 传送门 思路 首先我们对∫0∞1∏i=1n(ai2+x2)dx\int_{0}^{\infty}\frac{1}{\prod\limits_{i=1}^{n}(a_i^2+x^2)}dx∫0∞​i=1∏n​(ai2​+x2)1​dx进行裂项相消： 1∏i=1n(ai2+x2)=1(a12+x2)(a22+x2)×1∏i=3n(ai2+x2)=1a22+a12×(1a12+x2−1a22+...
题解 | RNGs-2019牛客暑期多校训练营第四场H题
lastbye的博客
09-02 258
题目来源于牛客竞赛：https://ac.nowcoder.com/acm/contest/discuss 题目描述： typedef unsigned int u32; typedef unsigned long long u64; struct RNG { virtual void srand(u32 seed)=0; virtual bool gen()=0; }; struct RNG0...
2019 牛客多校 第一场
dicuan6029的博客
07-21 90
题目链接：https://ac.nowcoder.com/acm/contest/881#question 链接 A： 　　题意：就是两个数组，找最大的p，使对于1到p的所有子区间都保证最小值的下标相同 　　题解：每次往后加一个值（第i+1位）都会多出 i 个区间，当a[i+1] 大于max（a[1] ...a[i]) 时没有影响，当a[i]小于max（a[1] ...a[i...
2019牛客多校第一场
qq_29904713的博客
07-18 245
A题 正解：笛卡尔树 师兄做法：二分/线段树， 首先二分答案，判断答案是否合法时，先找整个区间的最小值是否索引相同，再找最小值分成的两个小区间是否符合这样一直分下去。。。（写线段树好麻烦的说） 我做的暴力：从左到右，对于第i行查找后面第一个比该行数字小的下标，相同就继续第i+1行，不相同则说明后面的那几行不满足条件删去 #include<bits/stdc++.h> usin...
2019 牛客多校第一场 F
binarycopycode
07-19 343
题目传送门：https://ac.nowcoder.com/acm/contest/881#question 考场上看到输出36E，且保证36E是整数，然后想起整点三角形，面积一定是x/2，那么可以猜出期望是三角形面积的x/18。 理性分析，期望肯定大于1/2，不会超过2/3，或者超过一点，于是盲猜一发11/18过了。 然后看到了正解，其实好像还挺好算了。。。。不过求图形期望这种没什么经验，...
2019牛客多校第一场 H XOR
binarycopycode
07-20 375
题目链接：https://ac.nowcoder.com/acm/contest/881/H 复习线性基复习了好久。。。 这题的关键是把异或为0的集合的大小之和转化为一个数字会在多少个异或为0的集合中出现，然后每个数字的这个值加起来就行。 先求一个线性基，其中插入了r个数字，那么剩下的n-r个数字的任意组合异或都可以由线性基中的一些数异或表示，那么它们异或起来就为0. 考虑线性基外的一个数...
题解 | Checkers-2019牛客暑期多校训练营第九场G题
lastbye的博客
09-07 226
题目来源于牛客竞赛：https://ac.nowcoder.com/acm/contest/discuss 题目描述： 输入描述： 输出描述： 示例1： 题解： 代码： #include <bits/stdc++.h> #include <ext/pb_ds/assoc_container.hpp> #include <ext/pb_ds/tree_poli...
题解 | Blackjack-2019牛客暑期多校训练营第十场A题
lastbye的博客
09-09 235
题目来源于牛客竞赛：https://ac.nowcoder.com/acm/contest/discuss 题目描述： 输入描述： 输出描述： 示例1： 示例2： 题解： 代码： #include<bits/stdc++.h> using namespace std; typedef double db; const int maxn=505; int d[maxn],n...
题解 | Move-2019牛客暑期多校训练营第六场D题
lastbye的博客
09-04 250
题目来源于牛客竞赛：https://ac.nowcoder.com/acm/contest/discuss 题目描述： 输入描述： 输出描述： 示例1： 题解： 代码： // // Created by Wu Junjie on 2019-06-30. // #include <bits/stdc++.h> const int MAXN = 1010; int n, k...
2020牛客暑期多校训练营（第八场）G Game SET
张洪基
08-04 229
string tmp[5][5]{{"one","two","three"},{"diamond","squiggle","oval"},{"solid","striped","open"},{"red","green","purple"}}; map<string,int>id; char s[100]; int n,a[300][10]; void solve(){ for(int i=1;i<=n;i++) for(int j=i+1;j<=n;j+..
2019牛客多校 第一场 9/10
BPM136(BPMThor)
07-21 170
A 考虑最小值把区间疯狂划分，那就是说明笛卡尔树相同啦 /* *********************************************** Author :BPM136 Created Time :7/18/2019 12:10:03 PM File Name :A.cpp *****************************************...
2019 牛客多校 第一场 B、Integration
JZK-Keven 的博客
07-19 271
已知，求在模1e9+7意义下的值。 保证都是正整数，并且 各不相同。 ----------------------------------------- 先解里面的式子，裂项相消。 ------------------------------------ 所以原式等于 ----------------------...
2019牛客多校第一场A题
binarycopycode
07-20 332
传送门https://ac.nowcoder.com/acm/contest/881/A 比赛的时候二分答案，然后用单调栈统计每个数字统治的区间只要相同那么这个答案就是可行的 后来看到牛逼网友的做法，直接O(n)单调栈扫一遍，然后只要判断统治区间(在这区间内最小)的左端相不相同，找到第一个不相同的位置，那里就是不行的。理性分析一下，因为右端是随便截取的，假设前i个可以，那么增加第i+1个时，新...
2019牛客暑期多校训练营（第一场）B Integration 裂项相消 + 积分
还我笑颜
07-18 497
题目链接：https://ac.nowcoder.com/acm/contest/881/B 题解：裂项相消， 以此类推，对于每一项，都是这样的形式，分母上常数项 是其他项的系数减去该项的系数 的乘积 积分化简 ： #include <bits/stdc++.h> using namespace std; typedef long long ll; c...
Integration【2019牛客暑期多校训练营（第一场）B】【待定系数法】
既然弱小，就只顾变强就是了
07-18 1047
链接：https://ac.nowcoder.com/acm/contest/881/B 来源：牛客网 题目描述 Bobo knows that ∫∞011+x2dx=π2.∫0∞11+x2dx=π2. Given n distinct positive integers a1,a2,…,ana1,a2,…,an, find the value of 1π∫∞01∏ni=1(a2i+x...
作业之考试n
GameDesigher的博客
07-13 88
暴力枚举。建表贮存输赢关系。 我从0开始贮存，为的是在第z次时能用z%NA来表示A出拳是啥，好比较。 #include<bits/stdc++.h> using namespace std; int i,j,l,m,n; int ha[5][5],q[210],w[210]; int main(){ // freopen("rps.in","r",stdin); // freope...
2019牛客暑期第一场 A Equivalent Prefixes（单调栈）
error311的博客
07-18 553
题目描述 Two arrays u and v each with m distinct elements are called equivalent if and only if RMQ(u,l,r)=RMQ(v,l,r)for all 1≤l≤r≤mwhere RMQ(w,l,r)RMQ(w,l,r) denotes the index of the minimum element among...
2019牛客暑期多校训练营（第一场）A Equivalent Prefixes 单调栈
还我笑颜
07-18 807
题目链接：https://ac.nowcoder.com/acm/contest/881/A 题意：求最大的p，满足[1, p] 任何区间的最小值的下标都相等 题解：假设前面的都符合了，在判断到第i个时，判断前面第一个比a[i], b[i] 小的位置k1, k2是否相同，因为在这个范围内，是a[i]和b[i]小，k1 k2 往前就是已经符合好的了 #include<bits/stdc...
2020牛客暑期多校训练营第一场题解：关键技术与方法总结
2020牛客多校暑期集训营第一场题解包含了多种计算机科学中的重要知识点，主要围绕C++编程语言和一些高级算法进行讲解。以下是这些知识点的详细解释： 1. **B-Suffix Array (B-后缀数组)**: B-Suffix Array 是一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值