L2-2 秀恩爱分得快-L2-4哲哲打游戏

最新推荐文章于 2024-05-18 15:19:11 发布

Funing7

最新推荐文章于 2024-05-18 15:19:11 发布

阅读量588

点赞数

文章标签：算法蓝桥杯职场和发展

本文链接：https://blog.csdn.net/funing7/article/details/130170298

版权

L2-2 秀恩爱分得快、

全屏浏览题目

切换布局

作者陈越

单位浙江大学

古人云：秀恩爱，分得快。

互联网上每天都有大量人发布大量照片，我们通过分析这些照片，可以分析人与人之间的亲密度。如果一张照片上出现了 K 个人，这些人两两间的亲密度就被定义为 1/K。任意两个人如果同时出现在若干张照片里，他们之间的亲密度就是所有这些同框照片对应的亲密度之和。下面给定一批照片，请你分析一对给定的情侣，看看他们分别有没有亲密度更高的异性朋友？

输入格式：

输入在第一行给出 2 个正整数：N（不超过1000，为总人数——简单起见，我们把所有人从 0 到 N-1 编号。为了区分性别，我们用编号前的负号表示女性）和 M（不超过1000，为照片总数）。随后 M 行，每行给出一张照片的信息，格式如下：

K P[1] ... P[K]

其中 K（≤ 500）是该照片中出现的人数，P[1] ~ P[K] 就是这些人的编号。最后一行给出一对异性情侣的编号 A 和 B。同行数字以空格分隔。题目保证每个人只有一个性别，并且不会在同一张照片里出现多次。

输出格式：

首先输出 A PA，其中 PA 是与 A 最亲密的异性。如果 PA 不唯一，则按他们编号的绝对值递增输出；然后类似地输出 B PB。但如果 A 和 B 正是彼此亲密度最高的一对，则只输出他们的编号，无论是否还有其他人并列。

输入样例 1：

10 4
4 -1 2 -3 4
4 2 -3 -5 -6
3 2 4 -5
3 -6 0 2
-3 2

输出样例 1：

-3 2
2 -5
2 -6

输入样例 2：

4 4
4 -1 2 -3 0
2 0 -3
2 2 -3
2 -1 2 
-3 2

输出样例 2：

-3 2

1.需要注意用两个数组来分别存储男女之间的亲密度，因为负数不能作为下标（在其他数据结构中挣扎很久想用一个来存还是没有实现）

2.用字符串读入，整数对于0和-0无法区分（奇怪的测试点）

3.最后测试的那两个人前面可能没有出现过，需要判断一下

4.多使用模块化，封装和复用，能很好地改善代码的可读性已经调试难度（看大佬分享的经验）

(229条消息) L2-028 秀恩爱分得快 (25 分) 两种解法，详细分析_wow_awsl_qwq的博客-CSDN博客

#include <bits/stdc++.h>
using namespace std;
const int N=1005;
int n,m,k,kk,xb[N],a[505],p,x,y;
double g[N][N];
string ct[N],t;
int toi(string s){//将字符串转化为正整数 
	int x=0;
	if(s[0]=='-')for(int i=1;i<s.size();++i)x*=10,x+=s[i]-'0';
	else for(int i=0;i<s.size();++i)x*=10,x+=s[i]-'0';
	return x;
}
int main(){
	cin>>n>>m;
	while(m--){
		cin>>k;kk=k;p=0;
		while(kk--){
			cin>>t;int tn=toi(t);
			if(t[0]=='-')xb[tn]=1;
			else xb[tn]=2;
			a[p++]=tn;
		}
		double k1=1.0/k;
		for(int i=0;i<k-1;++i){
			for(int j=i+1;j<k;++j){
				if(xb[a[i]]==xb[a[j]])continue;
				g[a[i]][a[j]]+=k1;g[a[j]][a[i]]=g[a[i]][a[j]];
			}
		}
	}
	cin>>t;x=toi(t);
	if(t[0]=='-')xb[x]=1;else xb[x]=2;
	cin>>t;y=toi(t);
	if(t[0]=='-')xb[y]=1;else xb[y]=2;
	for(int i=0;i<n;++i)if(xb[i]==1)ct[i]="-";else ct[i]="";//ct[i]存储编号i的人的性别符合，方便输出 
	double ma=0,mb=0;//x,y的最大亲密度 
	for(int i=0;i<n;++i)if(xb[i]!=xb[x])ma=max(ma,g[x][i]);
	for(int i=0;i<n;++i)if(xb[i]!=xb[y])mb=max(mb,g[y][i]);
	if(ma==mb&&g[x][y]==ma)cout<<ct[x]<<x<<" "<<ct[y]<<y<<endl;
	else {
		for(int i=0;i<n;++i)if(g[x][i]==ma&&xb[x]!=xb[i])cout<<ct[x]<<x<<" "<<ct[i]<<i<<endl;
		for(int i=0;i<n;++i)if(g[y][i]==mb&&xb[y]!=xb[i])cout<<ct[y]<<y<<" "<<ct[i]<<i<<endl;
	}	
	return 0;
}

L2-1 红色警报

全屏浏览题目

切换布局

作者陈越

单位浙江大学

战争中保持各个城市间的连通性非常重要。本题要求你编写一个报警程序，当失去一个城市导致国家被分裂为多个无法连通的区域时，就发出红色警报。注意：若该国本来就不完全连通，是分裂的k个区域，而失去一个城市并不改变其他城市之间的连通性，则不要发出警报。

输入格式：

输入在第一行给出两个整数N（0 < N ≤ 500）和M（≤ 5000），分别为城市个数（于是默认城市从0到N-1编号）和连接两城市的通路条数。随后M行，每行给出一条通路所连接的两个城市的编号，其间以1个空格分隔。在城市信息之后给出被攻占的信息，即一个正整数K和随后的K个被攻占的城市的编号。

注意：输入保证给出的被攻占的城市编号都是合法的且无重复，但并不保证给出的通路没有重复。

输出格式：

对每个被攻占的城市，如果它会改变整个国家的连通性，则输出Red Alert: City k is lost!，其中k是该城市的编号；否则只输出City k is lost.即可。如果该国失去了最后一个城市，则增加一行输出Game Over.。

输入样例：

输出样例：

City 1 is lost.
City 2 is lost.
Red Alert: City 0 is lost!
City 4 is lost.
City 3 is lost.
Game Over.

利用并查集

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define x first
#define y second
const int N = 550;
const int M = 5050;
int n, m, k,fa[N],cnt,ans,vis[N];
pair <int, int> p[M];//存储边的信息
void init()//初始化
{
	for (int i = 0; i <= 500; i++)fa[i] = i;
}
int find(int x)
{
	if (fa[x] == x)return fa[x];
	return fa[x] = find(fa[x]);
}
void unity(int x, int y)
{
	fa[find(x)] = find(y);
}
int count()//计算回路
{
	int num = 0;
	for (int i = 0; i < n; i++)
	{
		if (fa[i] == i&&!vis[i])num++;
	}
	return num;
}
int main() 
{
	cin >> n >> m;
	init();
	for (int i = 1; i <= m; i++)
	{
		cin >> p[i].x >> p[i].y;
		unity(p[i].x, p[i].y);
	}
	cnt = count();//计算有几个回路
	cin >> k;
	for(int l=1;l<=k;l++)
	{
		int num;
		cin >> num;
		vis[num] = 1;//标记为已经攻占
		init();//初始化方便计算回路
		for (int i = 1; i <= m; i++)//在题目中已经有的边中判断连通性
		{
			if (!vis[p[i].x] && !vis[p[i].y])//第i条边的两个顶点p[i].x和p[i].y如果没有被攻占，就还可以合并
				unity(p[i].x, p[i].y);
		}
		ans = count();//计算攻占后的回路数
		if (ans <= cnt)
			printf("City %d is lost.\n", num);
		else
			printf("Red Alert: City %d is lost!\n", num);
		cnt = ans;//更新
	}
	if (n == k)
		printf("Game Over.");
}

L2-3 插松枝

全屏浏览题目

切换布局

作者陈越

单位浙江大学

人造松枝加工场的工人需要将各种尺寸的塑料松针插到松枝干上，做成大大小小的松枝。他们的工作流程（并不）是这样的：

每人手边有一只小盒子，初始状态为空。
每人面前有用不完的松枝干和一个推送器，每次推送一片随机型号的松针片。
工人首先捡起一根空的松枝干，从小盒子里摸出最上面的一片松针 —— 如果小盒子是空的，就从推送器上取一片松针。将这片松针插到枝干的最下面。
工人在插后面的松针时，需要保证，每一步插到一根非空松枝干上的松针片，不能比前一步插上的松针片大。如果小盒子中最上面的松针满足要求，就取之插好；否则去推送器上取一片。如果推送器上拿到的仍然不满足要求，就把拿到的这片堆放到小盒子里，继续去推送器上取下一片。注意这里假设小盒子里的松针片是按放入的顺序堆叠起来的，工人每次只能取出最上面（即最后放入）的一片。
当下列三种情况之一发生时，工人会结束手里的松枝制作，开始做下一个：

（1）小盒子已经满了，但推送器上取到的松针仍然不满足要求。此时将手中的松枝放到成品篮里，推送器上取到的松针压回推送器，开始下一根松枝的制作。

（2）小盒子中最上面的松针不满足要求，但推送器上已经没有松针了。此时将手中的松枝放到成品篮里，开始下一根松枝的制作。

（3）手中的松枝干上已经插满了松针，将之放到成品篮里，开始下一根松枝的制作。

现在给定推送器上顺序传过来的 N 片松针的大小，以及小盒子和松枝的容量，请你编写程序自动列出每根成品松枝的信息。

输入格式：

输入在第一行中给出 3 个正整数：N（≤103），为推送器上松针片的数量；M（≤20）为小盒子能存放的松针片的最大数量；K（≤5）为一根松枝干上能插的松针片的最大数量。

随后一行给出 N 个不超过 100 的正整数，为推送器上顺序推出的松针片的大小。

输出格式：

每支松枝成品的信息占一行，顺序给出自底向上每片松针的大小。数字间以 1 个空格分隔，行首尾不得有多余空格。

输入样例：

8 3 4
20 25 15 18 20 18 8 5

输出样例：

20 15
20 18 18 8
25 5

又臭又长看起来很难的一道题......

看懂题目意思，理清几个临界条件，用栈和队列模拟就行了。

#include<bits/stdc++.h>
using namespace std;
const int N = 1e3;
int n, m, k;
queue <int> q;
stack <int> s;
deque <int> v;
void print()//输出松枝信息
{
	while (v.size())
	{
		if (v.size() == 1)
			printf("%d\n", v.front());
		else
			printf("%d ", v.front());
		v.pop_front();
	}
}
int main()
{
	cin >> n >> m >> k;
	for (int i = 1; i <= n; i++)
	{
		int u; cin >> u;
		q.push(u);
	}
	v.push_back(q.front());//初始化第一片松针
	q.pop();
	while (s.size() || q.size()) {//当小盒子和推送器上都有松针
		while (v.size() < k) {//松枝上松针数小于最大数量
			if (s.size()&&s.size() < m)//小盒子里面有松针且还能放松针
			{
				if (v.empty() || s.top() <= v.back())//小盒子顶部松针小于松枝松针
				{
					v.push_back(s.top());
					s.pop();
				}
				else if (s.top() > v.back())//小盒子顶部松针大于于松枝松针
				{
					if (q.size())//如果推送器上还有松针
					{
						if (v.empty() || q.front() <= v.back())//推送器前部松针小于松枝松针
						{
							v.push_back(q.front());
							q.pop();
						}
						else  if (v.size() && q.front() > v.back())
						{
							s.push(q.front());
							q.pop();
						}
					}
					else if (!q.size())//推送器没有松针就打印信息
					{
						print();
					}
				}
			}
			else if (s.size() && s.size() == m)//小盒子里面有松针但不能放松针
			{
				if (v.empty() || s.top() <= v.back())
				{
					v.push_back(s.top());
					s.pop();
				}
				else if (s.top() > v.back())
				{
					if (q.size())
					{
						if (v.empty() || q.front() <= v.back())
						{
							v.push_back(q.front());
							q.pop();
						}
						else  if (v.size() && q.front() > v.back())
						{
							print();

						}
					}
					else if (!q.size())
					{
						print();
					}
				}
			}
			else if (q.size())//推送器上有松针
			{
				if (v.empty()||q.front() <= v.back())//推送器前部松针小于松枝松针
				{
					v.push_back(q.front());
					q.pop();
				}
				else if (v.size() && q.front() > v.back())//推送器前部松针大于松枝松针
				{
					if (s.size() < m)//小盒子里还能放松针
					{
						s.push(q.front());
						q.pop();
					}
					else if (s.size() >= m)//小盒子里不能放松针，输出信息
					{
						print();
					}
				}
			}
			else if (s.empty() && q.empty())//小盒子和推送器都没有松针（不加这句话会死循环）
			{
				print();
				return 0;
			}
		}
		print();//松枝上松针数量大于k,打印信息
	}
	print();//小盒子和推送器都没有松针但松枝上还有松针
	return 0;
}

L2-4 哲哲打游戏

全屏浏览题目

切换布局

作者 DAI, Longao

单位杭州百腾教育科技有限公司

哲哲是一位硬核游戏玩家。最近一款名叫《达诺达诺》的新游戏刚刚上市，哲哲自然要快速攻略游戏，守护硬核游戏玩家的一切！

为简化模型，我们不妨假设游戏有 N 个剧情点，通过游戏里不同的操作或选择可以从某个剧情点去往另外一个剧情点。此外，游戏还设置了一些存档，在某个剧情点可以将玩家的游戏进度保存在一个档位上，读取存档后可以回到剧情点，重新进行操作或者选择，到达不同的剧情点。

为了追踪硬核游戏玩家哲哲的攻略进度，你打算写一个程序来完成这个工作。假设你已经知道了游戏的全部剧情点和流程，以及哲哲的游戏操作，请你输出哲哲的游戏进度。

输入格式：

输入第一行是两个正整数 N 和 M (1≤N,M≤105)，表示总共有 N 个剧情点，哲哲有 M 个游戏操作。

接下来的 N 行，每行对应一个剧情点的发展设定。第 i 行的第一个数字是 Ki，表示剧情点 i 通过一些操作或选择能去往下面 Ki 个剧情点；接下来有 Ki 个数字，第 k 个数字表示做第 k 个操作或选择可以去往的剧情点编号。

最后有 M 行，每行第一个数字是 0、1 或 2，分别表示：

0 表示哲哲做出了某个操作或选择，后面紧接着一个数字 j，表示哲哲在当前剧情点做出了第 j 个选择。我们保证哲哲的选择永远是合法的。
1 表示哲哲进行了一次存档，后面紧接着是一个数字 j，表示存档放在了第 j 个档位上。
2 表示哲哲进行了一次读取存档的操作，后面紧接着是一个数字 j，表示读取了放在第 j 个位置的存档。

约定：所有操作或选择以及剧情点编号都从 1 号开始。存档的档位不超过 100 个，编号也从 1 开始。游戏默认从 1 号剧情点开始。总的选项数（即 ∑Ki）不超过 106。

输出格式：

对于每个 1（即存档）操作，在一行中输出存档的剧情点编号。

最后一行输出哲哲最后到达的剧情点编号。

输入样例：

输出样例：

样例解释：

简单给出样例中经过的剧情点顺序：

1 -> 4 -> 3 -> 7 -> 8 -> 3 -> 5 -> 9 -> 10。

档位 1 开始存的是 1 号剧情点；档位 2 存的是 3 号剧情点；档位 1 后来又存了 9 号剧情点。

玩的是橙光游戏？

#include <bits/stdc++.h>

using namespace std;
const int N=100005;
int dan[105],p;
vector<int> v[N];
int n,m,t=1;
int main()
{
	cin>>n>>m;
	for(int i=1;i<=n;++i)
	{
		int k;cin>>k;
		for(int j=1;j<=k;++j)
		{
			int x;cin>>x;
			if(v[i].size()==0)v[i].push_back(0);
			v[i].push_back(x); 
		}
	}
	for(int i=1;i<=m;++i)
	{
		int k,x;cin>>k>>x;
		if(k==0)
		{
			t=v[t][x];
		}
		else if(k==1)
		{
			dan[x]=t;
			cout<<t<<endl;
		}
		else if(k==2)
		{
			t=dan[x];
		}
	}
	cout<<t;
	return 0;
}

L2-040 哲哲打游戏 (25 分)动态数组纯模拟 - 林动 - 博客园 (cnblogs.com)

帅到没朋友

当芸芸众生忙着在朋友圈中发照片的时候，总有一些人因为太帅而没有朋友。本题就要求你找出那些帅到没有朋友的人。

输入格式：
输入第一行给出一个正整数N（≤100），是已知朋友圈的个数；随后N行，每行首先给出一个正整数K（≤1000），为朋友圈中的人数，然后列出一个朋友圈内的所有人——为方便起见，每人对应一个ID号，为5位数字（从00000到99999），ID间以空格分隔；之后给出一个正整数M（≤10000），为待查询的人数；随后一行中列出M个待查询的ID，以空格分隔。

注意：没有朋友的人可以是根本没安装“朋友圈”，也可以是只有自己一个人在朋友圈的人。虽然有个别自恋狂会自己把自己反复加进朋友圈，但题目保证所有K超过1的朋友圈里都至少有2个不同的人。

输出格式：
按输入的顺序输出那些帅到没朋友的人。ID间用1个空格分隔，行的首尾不得有多余空格。如果没有人太帅，则输出No one is handsome。

注意：同一个人可以被查询多次，但只输出一次。

输入样例1：
3
3 11111 22222 55555
2 33333 44444
4 55555 66666 99999 77777
8
55555 44444 10000 88888 22222 11111 23333 88888
输出样例1：
10000 88888 23333
输入样例2：
3
3 11111 22222 55555
2 33333 44444
4 55555 66666 99999 77777
4
55555 44444 22222 11111
输出样例2：
No one is handsome
难点：
1.输出ID格式；

2.朋友圈只有一个时的处理？题意？

3.使用二维数组会超时，用数组标记法；

原文链接：https://blog.csdn.net/weixin_44153125/article/details/88826682

#include <stdio.h>
#include <stdlib.h>
int a[100000]={0};
 
int main()
{
    int n,i,x,j,m,k,t;
    int sum=0;
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        scanf("%d",&x);
        for(j=0;j<x;j++)
        {
            scanf("%d",&m);
            if(x!=1)
            {
                a[m]=1;
            }
        }
    }
    scanf("%d",&k);
    for(i=0;i<k;i++)
    {
        scanf("%d",&t);
        if(a[t]==0)
        {
            if(sum!=0) printf(" ");
            printf("%05d",t);
            sum++;
            a[t]=-1;
        }
    }
    if(sum==0) printf("No one is handsome\n");
    return 0;
}

L1-7 连续因子

一个正整数 N 的因子中可能存在若干连续的数字。例如 630 可以分解为 3×5×6×7，其中 5、6、7 就是 3 个连续的数字。给定任一正整数 N，要求编写程序求出最长连续因子的个数，并输出最小的连续因子序列。

输入格式：

输入在一行中给出一个正整数 N（1<N<231）。

输出格式：

首先在第 1 行输出最长连续因子的个数；然后在第 2 行中按 因子1*因子2*……*因子k 的格式输出最小的连续因子序列，其中因子按递增顺序输出，1 不算在内。

输入样例：

输出样例：

3
5*6*7

1、首先我们要输入n值；

2、然后确定这道题我们要怎么解决；

（1）明确用循环（为什么用循环呢，因为我们的因子都是多次循环才能找到的）

（2）循环要怎么用（求解因子；求解连续因子；我们还要求解连续因子的个数，因为要输出最多连续因子个数的连续因子；我还要求这个连续因子的起点，比如630的最长连续因子是5*6*7，起点是5，然后在递增输出就好了，所以起点我也要知道）

（3）确定用双循环（因为我一边要确定连续因子，我还要确定连续因子个数，求解连续因子我就要一个循环了，那么再加上一个个数我也得套在循环里，更何况还有一个起点呢）

（4）输出格式的限制：我需要先输出最长因子的个数，在输出最长连续因子相乘，乘号有讲究。
原文链接：https://blog.csdn.net/zoroly/article/details/119942889

#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
int n,ans,len,st;
int main()
{
	cin >> n;
	for (int i = 2; i <= sqrt(n); i++)//枚举起点
	{
		int sum = n,cnt = 0;
		for (int j = i; sum % j == 0 && sum != 0; j++)//枚举长度
		{
			sum /= j;
			cnt++;
		}
		if (cnt > len)
		{
			len = cnt;
			st = i;
		}
	}
	if (len == 0)//长度为0，说明只有一个连续因子
		printf("1\n%d", n);
	else
	{
		printf("%d\n", len);
		while (len--)
		{
			printf("%d", st);
			if (st != st+len)
				printf("*");
			st++;
		}
	}
	return 0;
}

L1-4 输出GPLT

全屏浏览题目

切换布局

作者陈越

单位浙江大学

给定一个长度不超过10000的、仅由英文字母构成的字符串。请将字符重新调整顺序，按GPLTGPLT....这样的顺序输出，并忽略其它字符。当然，四种字符（不区分大小写）的个数不一定是一样多的，若某种字符已经输出完，则余下的字符仍按GPLT的顺序打印，直到所有字符都被输出。

输入格式：

输入在一行中给出一个长度不超过10000的、仅由英文字母构成的非空字符串。

输出格式：

在一行中按题目要求输出排序后的字符串。题目保证输出非空。

输入样例：

pcTclnGloRgLrtLhgljkLhGFauPewSKgt

输出样例：

GPLTGPLTGLTGLGLL

#include<bits/stdc++.h>
using namespace std;
vector<char>G;
vector<char>P;
vector<char>L;
vector<char>T;
string str;
int main()
{
    cin >> str;
    for (int i = 0; i < str.size(); i++)
    {
        str[i] = toupper(str[i]);
        if (str[i] == 'G')G.push_back(str[i]);
        else if (str[i] == 'P')P.push_back(str[i]);
        else if (str[i] == 'L')L.push_back(str[i]);
        else if (str[i] == 'T')T.push_back(str[i]);
    }
    while (G.size())
    {
        cout << G.front();
        G.pop_back();
        if (P.size())
        {
            cout << P.front();
            P.pop_back();
        }
        if (L.size())
        {
            cout << L.front();
            L.pop_back();
        }
        if (T.size())
        {
            cout << T.front();
            T.pop_back();
        }
    }
    while (P.size())
    {
        cout << P.front();
        P.pop_back();
        if (L.size())
        {
            cout << L.front();
            L.pop_back();
        }
        if (T.size())
        {
            cout << T.front();
            T.pop_back();
        }
    }
    while (L.size())
    {
        cout << L.front();
        L.pop_back();
        if (T.size())
        {
            cout << T.front();
            T.pop_back();
        }
    }
    while (T.size())
    {
        cout << T.front();
        T.pop_back();
    }
    return 0;
}

L1-8 出生年

全屏浏览题目

切换布局

作者陈越

单位浙江大学

以上是新浪微博中一奇葩贴：“我出生于1988年，直到25岁才遇到4个数字都不相同的年份。”也就是说，直到2013年才达到“4个数字都不相同”的要求。本题请你根据要求，自动填充“我出生于y年，直到x岁才遇到n个数字都不相同的年份”这句话。

输入格式：

输入在一行中给出出生年份y和目标年份中不同数字的个数n，其中y在[1, 3000]之间，n可以是2、或3、或4。注意不足4位的年份要在前面补零，例如公元1年被认为是0001年，有2个不同的数字0和1。

输出格式：

根据输入，输出x和能达到要求的年份。数字间以1个空格分隔，行首尾不得有多余空格。年份要按4位输出。注意：所谓“n个数字都不相同”是指不同的数字正好是n个。如“2013”被视为满足“4位数字都不同”的条件，但不被视为满足2位或3位数字不同的条件。

输入样例1：

1988 4

输出样例1：

25 2013

输入样例2：

1 2

输出样例2：

0 0001

#include<bits/stdc++.h>
using namespace std;
int n, y,ans;
int main()
{
	cin >> y>>n;
	if (n == 4) {
		for (int i = 0; i <= 9; i++)
			for (int j = 0; j <= 9; j++)
				for (int k = 0; k <= 9; k++)
					for (int l = 0; l <= 9; l++)
					{
						if (i != j && i != k && i != l && j != k && j != l && k != l)
						{
							int num = i * 1000 + j * 100 + k * 10 + l;
							if (num >= y)
							{
								ans = num;
								printf("%d %04d", ans - y, ans);
								return 0;
							}
						}
					}
	}
	else if (n == 3)
	{
		for (int i = 0; i <= 9; i++)
			for (int j = 0; j <= 9; j++)
				for (int k = 0; k <= 9; k++)
					for (int l = 0; l <= 9; l++)
					{
						unordered_set<int>st;
						if(!st.count(i))st.insert(i);
						if(!st.count(j))st.insert(j);
						if(!st.count(k))st.insert(k);
						if(!st.count(l))st.insert(l);
						if(st.size()==3){
						int num = i * 1000 + j * 100 + k * 10 + l;
						if (num >= y)
						{
						ans = num;
						printf("%d %04d", ans - y, ans);
						return 0;
						}
					}
					}
	}
	else if (n == 2)
	{
		for (int i = 0; i <= 9; i++)
			for (int j = 0; j <= 9; j++)
				for (int k = 0; k <= 9; k++)
					for (int l = 0; l <= 9; l++)
					{
						unordered_set<int>st;
						if(!st.count(i))st.insert(i);
						if(!st.count(j))st.insert(j);
						if(!st.count(k))st.insert(k);
						if(!st.count(l))st.insert(l);
						if(st.size()==2){
						int num = i * 1000 + j * 100 + k * 10 + l;
						if (num >= y)
						{
						ans = num;
						printf("%d %04d", ans - y, ans);
						return 0;
						}
					}
					}
	}
	return 0;
}

Funing7

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
L2-2 秀恩爱分得快-L2-4哲哲打游戏

全屏浏览题目切换布局作者陈越单位浙江大学古人云：秀恩爱，分得快。互联网上每天都有大量人发布大量照片，我们通过分析这些照片，可以分析人与人之间的亲密度。如果一张照片上出现了 K 个人，这些人两两间的亲密度就被定义为 1/K。任意两个人如果同时出现在若干张照片里，他们之间的亲密度就是所有这些同框照片对应的亲密度之和。下面给定一批照片，请你分析一对给定的情侣，看看他们分别有没有亲密度更高的异性朋友？
复制链接

扫一扫