您的位置: 首页  >  文章  >  10/26测试

10/26测试

分类: 文章 • 2024-05-28 13:23:58
  • 该来的总会来，该走的也无法挽留。

比如毕姥爷的神奇考试题 摊平/ 今下午简直是意识流做题 允悲

蓝鹅虽然题目极为鬼畜，还是有大佬拿了250%%%%%%%

目录

T1 没有君子，不养艺人

T2雷霆雨露，俱是天恩

T3既食君禄，替君分忧

T1 没有君子，不养艺人

10/26测试

每次做毕姥爷的题就超想吐槽他的第一句话嗯……

看到题就是十分懵逼，高斯整数是什么鬼？意识流回想了一下，没啥头绪就跳过了

然后把T2解决了看时间还充裕再回来做的

先暴力打表枚举了一下p的幂，然后发现，我们一定可以把x和y的二进制位从低到高依次调整成0。

每次右移，然后判断最后一位的奇偶，这题可以每次/p，然后判断实部和虚部的和的奇偶。

因为高斯整数一定能表示成−1±i进制的形式，摊手/

B君给的题解(简明的一句话题解)是：

10/26测试

给个题目参考资料：复数进制  嗯，B君出题灵感的罪恶来源

代码：（用的是complex类瞎搞的）

#pragma GCC optimize (2)
#include<bits/stdc++.h>
#define LL long long

using namespace std;
//瞎搞一波 

const int maxn=1000+10;

LL x,y;
int ans[maxn];

complex<LL >n,p,cplx;

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

int main()
{
	int cnt=0,res=0;
	scanf("%lld%lld",&x,&y);
	n=complex<LL >(x,y);
	p=complex<LL >(-1,-1);
	while(n!=complex<LL >(0,0))
	{
		if((n.real()+n.imag())%2!=0)
		{
			ans[++cnt]=res;
			n-=complex<LL >(1,0);//
		}
		//printf("real:%lld  imag:%lld\n",n.real(),n.imag()) ;
		n/=p;
		res++;
	}
	printf("%d\n",cnt);
	for(int i=1;i<=cnt;i++)
	{
		printf("%d\n",ans[i]);
	}

	return 0;
}

%毕姥爷的代码QAQ：

#include <bits/stdc++.h>
using namespace std;
long long x, y;
int a[200], c, i;
int main() {
	cin >> x >> y;
	while (x != 0 || y != 0) {
		if ((x + y) & 1) {
			a[c++] = i;
			x--;
		}
		// (x + yi) * (-1 + i) / 2
		// (-x -y, x - y) / 2
		long long nx = (-x - y) / 2;
		long long ny = (x - y) / 2;
		x = nx;
		y = ny;
		i++;
	}
	printf("%d\n", c);
	for (int i = 0; i < c; i++) {
		printf("%d\n", a[i]);
	}
	return 0;
}

 

T2雷霆雨露，俱是天恩

10/26测试

又是毫无头绪的一道题 给自己鼓掌/太菜了

发了一会儿呆就开始猜结论，各种瞎蒙，最后发现是求数列的非升子序列？？？

于是怀着忐忑的心情就开始瞎写了，心想万一碰对了呢？

用的树状数组，然后信仰一交，最后发现有五十分~鼓掌鼓掌，太不容易了我

不过神奇的是如果用define mod 10/26测试就会得到一个神奇的答案？？？一脸懵逼

#pragma GCC optimize (2)
#include<cstdio>
#include<cstring>
#include<iostream>
#include<cstdlib>
#include<vector>
#include<queue>
#include<stack>
#include<algorithm>
#include<deque>
#include<cmath>
#include<cctype>
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1

using namespace std;

const int maxn=250000+7;
const int mod=1000000000+7;

int n,m;
int tree[maxn];
int a[maxn],b[maxn];

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

bool cmp(int a,int b)
{
	return a<b;
}

int getrnk(int x)
{
	return lower_bound(b+1,b+n+1,x)-b;
}

struct TRAR
{
	int lowbit(int x)
	{
		return x&(-x);
	}
	
	void add(int x,int value)
	{
		for(int i=x;i<=n+1;i+=lowbit(i))
		{
			(tree[i]+=value)%=mod;
		}
	}
	
	int getsum(int x)
	{
		int sum=0;
		for(int i=x;i;i-=lowbit(i))
		{
			(sum+=tree[i])%=mod;
		}
		return sum;
	}
}T;

int main()
{
	n=read();
	for(int i=1;i<=n;i++)
	{
		b[i]=a[i]=read();
	}
	sort(b+1,b+n+1,cmp);
	T.add(n+1,1);
	for(int i=1;i<=n;i++)
	{
		int pos=getrnk(a[i]);
		T.add(pos,(T.getsum(n+1)-T.getsum(pos-1)+mod)%mod);
	}
	//for(int i=1;i<=n+1;i++) printf("%d ",tree[i]);
	int ans=(T.getsum(n)-n+mod)%mod;
	printf("%d\n",ans);
	
	return 0;
}

至于为什么只有五十，因为10/26测试还需要组合数中没有2333的倍数，所以实际上只得了ai≤2333的部分分，可喜可贺。

正解是二维的树状数组，用到了10/26测试定理；

因为对于10/26测试,所以表示成2333进制最多有2位，然后就信仰瞎搞吧

#pragma GCC optimize (2)
#include<bits/stdc++.h>
#define LL long long

using namespace std;

const int maxn=2333;
const int INF=0x7fffffff;
const int mod=1000000000+7;

int n;
int tree[maxn+7][maxn+7];

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

struct TRAR
{
	int lowbit(int x)
	{
		return x&(-x);
	}
	
	void add(int x,int y,int value)
	{
		for(int i=x;i<=maxn;i+=lowbit(i))
		{
			for(int j=y;j<=maxn;j+=lowbit(j))
			{
				(tree[i][j]+=value) %= mod;
			}
		}            
	}
	
	int getsum(int x,int y)
	{
		int res=0;
		for(int i=x;i;i-=lowbit(i))
		{
			for(int j=y;j;j-=lowbit(j))
			{
				(res += tree[i][j]) %= mod;
			}
		}
		return res;
	}
}T;

int main()
{
	n=read();
	int ans=0;
	while(n--)
	{
		int x,y;
		x=read();
		y=maxn-x%maxn; x=maxn-x/maxn;
		int t=T.getsum(x,y);
		(ans+=t)%=mod;
		T.add(x,y,t+1);
	}
	printf("%d\n",ans);

	return 0;
}

题目灵感：二进制，枚举子集的一个版本

 

T3既食君禄，替君分忧

10/26测试

emmmmm不会做的一道题；

不过想通了就好理解√

动态规划：

               10/26测试表示只考虑点集10/26测试中的边，使得点集10/26测试连通的方案数；10/26测试表示把点集10/26测试10/26测试划分成10/26测试个集合的方案数。

B君的标程↓↓↓：

#include <bits/stdc++.h>
using namespace std;
int p = 1000000007;
int n, m, k;
int b[1020], c[65537], f[17][65537];
int main() {
	scanf("%d%d%d", &n, &m, &k);
	for (int i = 0; i < m; i++) {
		int x, y;
		scanf("%d%d", &x, &y);
		x--;
		y--;
		c[(1 << x) | (1 << y)]++;
	}
	for (int i = b[0] = 1; i < 1010; i++) {
		b[i] = b[i - 1] * 2 % p;
	}
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < 1 << n; j++) {
			if (j >> i & 1) {
				c[j] += c[j ^ (1 << i)];
			}
		}
	}
	for (int i = 1; i < 1 << n; i++) {
		int ii = i & (i - 1);
		int t = 0;
		for (int j = ii; j > 0; j = (j - 1) & ii) {
			t = (t + (long long)f[1][i ^ j] * b[c[j]]) % p;
		}
		f[1][i] = (b[c[i]] - t + p) % p;
	}
	for (int i = 2; i <= k; i++) {
		for (int j = 1; j < 1 << n; j++) {
			int jj = j & (j - 1);
			for (int k = jj; k > 0; k = (k - 1) & jj) {
				f[i][j] = (f[i][j] + (long long)f[i - 1][k] * f[1][j ^ k]) % p;
			}
		}
	}
	printf("%d\n", f[k][(1 << n) - 1]);
	return 0;
}

总体来说今天考试发挥一般化QAQ，全程意识流做题。

相关推荐