Program week14 work&experiment

最新推荐文章于 2020-06-06 14:21:55 发布

Maroon°

最新推荐文章于 2020-06-06 14:21:55 发布

阅读量879

点赞数

分类专栏： work

本文链接：https://blog.csdn.net/qq_45050487/article/details/105934702

版权

work 专栏收录该内容

29 篇文章 0 订阅

订阅专栏

A - Q老师与石头剪刀布（必做）

每一个大人曾经都是一个小孩，Q老师也一样。

为了回忆童年，Q老师和 Monika 玩起了石头剪刀布的游戏，游戏一共 n 轮。无所不知的 Q老师知道每一轮 Monika 的出招，然而作为限制， Q老师在这 n 轮游戏中必须恰好出 a 次石头，b 次布和 c 次剪刀。

如果 Q老师赢了 Monika n/2(上取整) 次，那么 Q老师就赢得了这场游戏，否则 Q老师就输啦！

Q老师非常想赢，他想知道能否可以赢得这场游戏，如果可以的话，Q老师希望你能告诉他一种可以赢的出招顺序，任意一种都可以。

Input
第一行一个整数 t(1 ≤ t ≤ 100)表示测试数据组数。然后接下来的 t 组数据，每一组都有三个整数：

第一行一个整数 n(1 ≤ n ≤ 100)
第二行包含三个整数 a, b, c(0 ≤ a, b, c ≤ n)。保证 a+b+c=n
第三行包含一个长度为 n 的字符串 s，字符串 s 由且仅由 ‘R’, ‘P’, ‘S’ 这三个字母组成。第 i 个字母 s[i] 表示 Monika 在第 i 轮的出招。字母 ‘R’ 表示石头，字母 ‘P’ 表示布，字母 ‘S’ 表示剪刀
Output
对于每组数据：

如果 Q老师不能赢，则在第一行输出 “NO”(不含引号)
否则在第一行输出 “YES”(不含引号)，在第二行输出 Q老师的出招序列 t。要求 t 的长度为 n 且仅由 ‘R’, ‘P’, ‘S’ 这三个字母构成。t 中需要正好包含 a 个 ‘R’，b 个 ‘P’ 和 c 个 ‘S’
“YES”/"NO"是大小写不敏感的，但是 ‘R’, ‘P’, ‘S’ 是大小写敏感的。

Example
Input
2
3
1 1 1
RPS
3
3 0 0
RPS
Output
YES
PSR
NO

思路

对于每一个对局，如果剩余的次数里面有能赢的话，就直接出，赢的次数++
如果不能就从空余的里面任意出一个最后看是否符合条件

Answer

#include<iostream>
#include<string.h>
#include<cmath>
using namespace std;
const int maxn=110;
int t,n,r,p,s;
char c,a[maxn];
int main(){
	cin>>t;
	while(t--){
		cin>>n;
		cin>>r>>p>>s;
		int sum=0,i=0,tmp=ceil(n/2.0);
		while(n--){
			cin>>c;
			if(c=='R'&&p>0){p--;sum++;a[i++]='P';}
			else if(c=='P'&&s>0){s--;sum++;a[i++]='S';}
			else if(c=='S'&&r>0){r--;sum++;a[i++]='R';}
			else a[i++]='N';
		}
		if(sum<tmp)cout<<"NO"<<endl;
		else{
			cout<<"YES"<<endl;
			for(int j=0;j<i;j++){
				if(a[j]!='N')cout<<a[j];
				else {
					if(r>0){r--;cout<<'R';}
					else if(p>0){p--;cout<<'P';}
					else if(s>0){s--;cout<<'S';}
				}
			}
			cout<<endl;
		}
	}
	return 0;
}

B - Q老师与十字叉（必做）

Q老师得到一张 n 行 m 列的网格图，上面每一个格子要么是白色的要么是黑色的。

Q老师认为失去了十字叉的网格图莫得灵魂. 一个十字叉可以用一个数对 x 和 y 来表示, 其中 1 ≤ x ≤ n 并且 1 ≤ y ≤ m, 满足在第 x 行中的所有格子以及在第 y 列的所有格子都是黑色的

例如下面这5个网格图里都包含十字叉

在这里插入图片描述

第四个图有四个十字叉，分别在 (1, 3), (1, 5), (3, 3) 和 (3, 5).

下面的图里没有十字叉

在这里插入图片描述

Q老师得到了一桶黑颜料，他想为这个网格图注入灵魂。 Q老师每分钟可以选择一个白色的格子并且把它涂黑。现在他想知道要完成这个工作，最少需要几分钟？

input：
第一行包含一个整数 q (1 ≤ q ≤ 5 * 10^4) — 表示测试组数

对于每组数据：

第一行有两个整数 n 和 m (1 ≤ n, m ≤ 5 * 10^4, n * m ≤ 4 * 10^5) — 表示网格图的行数和列数

接下来的 n 行中每一行包含 m 个字符 — ‘.’ 表示这个格子是白色的， ‘*’ 表示这个格子是黑色的

保证 q 组数据中 n 的总和不超过 5 * 10^4， n*m 的总和不超过 4 * 10^5

output：
答案输出 q 行, 第 i 行包含一个整数 — 表示第 i 组数据的答案

思路

首先数据范围直接开二维数组会爆所以只能动态输入
一开始思路又有点偏，去dfs去了，但其实只需要顺序遍历，找黑色格子最多的某一行和最多的某一列，ans=（n-最多的行中的个数）+（m-最多的列中的个数）
但如果行列交叉处是 . 那么需要ans–，因为ans会多计一个格

Answer

#include<iostream>
#include<cstdio>
#include<string.h>
#include<vector> 
using namespace std;
const int maxn=5e4+100;
int t,n,m,a[maxn],b[maxn];
char s[maxn];
vector<int> v[maxn];
int main(){
	cin>>t;
	while(t--){ 
		memset(a,0,sizeof a);
		memset(b,0,sizeof b);
		cin>>n>>m;
		for(int i=0;i<n;i++)
			v[i].clear();
		int maxx=0,maxy=0;
		for(int i=0;i<n;i++){
			cin>>s;
			for(int j=0;j<m;j++)
			if(s[j]=='*'){
				v[i].push_back(j);
				a[i]++;
				b[j]++;
				maxy=max(b[j],maxy);
			}
			maxx=max(a[i],maxx);
		}
		int ans=(n-maxx)+(m-maxy); 
		bool goon=0;
		for(int i=0;i<n&&!goon;i++){
			if(a[i]!=maxx) continue;
			for(int j=0;j<m&&!goon;j++){
				if(b[j]!=maxy) continue;
				bool flag=0;
				for(int k=0;k<v[i].size();k++)
					if(v[i][k]==j){
						flag=1;
						break;
					}
				if(!flag){
					ans--;
					goon=1;
				}
			}
		}
		cout<<ans<<endl;
	}
	return 0;
}

C - Q老师的考验（必做）

Q老师对数列有一种非同一般的热爱，尤其是优美的斐波那契数列。

这一天，Q老师为了增强大家对于斐波那契数列的理解，决定在斐波那契的基础上创建一个新的数列 f(x) 来考一考大家。数列 f(x) 定义如下：

当 x < 10 时，f(x) = x；
当 x ≥ 10 时，f(x) = a0 * f(x-1) + a1 * f(x-2) + a2 * f(x-3) + …… + a9 * f(x-10)，ai 只能为 0 或 1。

Q老师将给定 a0～a9，以及两个正整数 k m，询问 f(k) % m 的数值大小。

聪明的你能通过 Q老师的考验吗？

Input
输出文件包含多组测试用例，每组测试用例格式如下：

第一行给定两个正整数 k m。（k < 2e9, m < 1e5）

第二行给定十个整数，分别表示 a0～a9。

Output
对于每一组测试用例输出一行，表示 f(k) % m 的数值大小。

Sample Input
10 9999
1 1 1 1 1 1 1 1 1 1
20 500
1 0 1 0 1 0 1 0 1 0
Sample Output
45
104

思路

矩阵快速幂例题
转移矩阵如下：
在这里插入图片描述
具体做法就是标准的快速幂，要注意转移矩阵的次数为k-9,最后得到的结果也要去一次模
还要注意矩阵乘法运算符的重载，构造与复制构造函数
时间复杂度为log(k)

Answer

#include<iostream>
#include<cstdio>
#include<string.h>
using namespace std;
const int N=11;
int k,m,a[N];
struct Matrix{
	long long x[N][N];
	Matrix operator *(const Matrix &t){
		Matrix ret;
		for(int i=1;i<=10;i++)
		  for(int j=1;j<=10;j++)
		    for(int k=1;k<=10;k++){
			    ret.x[i][j]=ret.x[i][j]+((x[i][k]%m)*(t.x[k][j]%m))%m;
			    ret.x[i][j]%=m; 
			}
		return ret;
	}
	Matrix(){memset(x,0,sizeof(x));}
	Matrix(const Matrix& t){memcpy(x,t.x,sizeof(x));}
};
int main(){
	while(scanf("%d %d",&k,&m)!=EOF){
		for(int i=1;i<=10;i++)
			cin>>a[i];
		Matrix b;
		for(int i=1;i<=10;i++)
			b.x[1][i]=a[i];
		for(int i=2;i<=10;i++)
			b.x[i][i-1]=1;
		Matrix ans;
		for(int i=1;i<=10;i++)
			ans.x[i][i]=1;
		if(k<10){
			cout<<k<<endl;
			continue;
		}
		k-=9;
		while(k){
			if(k&1)ans=ans*b;
			b=b*b;
			k>>=1;
		}
		long long Ans=0;
		for(int i=1;i<=10;i++)
			Ans=(Ans+ans.x[1][i]*(10-i))%m;
		cout<<Ans<<endl;
	}
	return 0;
}

exp A - 猫睡觉问题

众所周知，TT家里有一只魔法喵。这只喵十分嗜睡。一睡就没有白天黑夜。喵喵一天可以睡多次！！每次想睡多久就睡多久╭(╯^╰)╮

喵睡觉的时段是连续的，即一旦喵喵开始睡觉了，就不能被打扰，不然喵会咬人哒[○･｀Д´･ ○]

可以假设喵喵必须要睡眠连续不少于 A 个小时，即一旦喵喵开始睡觉了，至少连续 A 个小时内（即A*60分钟内）不能被打扰！

现在你知道喵喵很嗜睡了，它一天的时长都在吃、喝、拉、撒、睡，换句话说要么睡要么醒着滴！

众所周知，这只魔法喵很懒，和TT一样懒，它不能连续活动超过 B 个小时。

猫主子是不用工作不用写代码滴，十分舒适，所以，它是想睡就睡滴。

但是，现在猫主子有一件感兴趣的事，就是上BiliBili网站看的新番。

新番的播放时间它已经贴在床头啦（每天都用同一张时间表哦），这段时间它必须醒着！！

作为一只喵喵，它认为安排时间是很麻烦的事情，现在请你帮它安排睡觉的时间段。

Input
多组数据，多组数据，多组数据哦，每组数据的格式如下：

第1行输入三个整数，A 和 B 和 N (1 <= A <= 24, 1 <= B <= 24, 1 <= n <= 20)

第2到N+1行为每日的新番时间表，每行一个时间段，格式形如 hh:mm-hh:mm (闭区间)，这是一种时间格式，hh:mm 的范围为 00:00 到 23:59。注意一下，时间段是保证不重叠的，但是可能出现跨夜的新番，即新番的开始时间点大于结束时间点。
保证每个时间段的开始时间点和结束时间点不一样，即不可能出现类似 08:00-08:00 这种的时间段。时长的计算由于是闭区间所以也是有点坑的，比如 12:00-13:59 的时长就是 120 分钟。
不保证输入的新番时间表有序。

Output
我们知道，时间管理是一项很难的活，所以你可能没有办法安排的那么好，使得这个时间段满足喵喵的要求，即每次睡必须时间连续且不少于 A 小时，每次醒必须时间连续且不大于 B 小时，还要能看完所有的番，所以输出的第一行是 Yes 或者 No，代表是否存在满足猫猫要求的时间管理办法。

然后，对于时间管理，你只要告诉喵喵，它什么时候睡觉即可。
即第2行输出一个整数 k，代表当天有多少个时间段要睡觉
接下来 k 行是喵喵的睡觉时间段，每行一个时间段，格式形如 hh:mm-hh:mm (闭区间)，这个在前面也有定义。注意一下，如果喵喵的睡眠时段跨越当天到达了明天，比如从23点50分睡到0点40分，那就输出23:50-00:40，如果从今晚23:50睡到明天早上7:30，那就输出23:50-07:30。

输出要排序吗？（输出打乱是能过的，也就是说，题目对输出的那些时间段间的顺序是没有要求的）

哦对了，喵喵告诉你说，本题是 Special Judge，如果你的输出答案和 Sample 不太一样，也可能是对的，它有一个判题程序来判定你的答案（当然，你对你自己的答案肯定也能肉眼判断）

Sample Input
12 12 1
23:00-01:00
3 4 3
07:00-08:00
11:00-11:09
19:00-19:59
Sample Output
Yes
1
01:07-22:13
No

思路

输入时使用scanf的格式化处理进行输入，并将时间转化为分钟制
若某个时间段横跨零点，则将右端点加上一整天的时间，延伸到第二天；这样的话对于这个右端点和第一个左端点之间的关系则需要特判
然后首先对每个番的长度进行遍历，若某个番的时长大于B乘60直接输出no
然后对每个番按照起始时间排序，然后进行遍历。如果能睡，则直接睡到下个番开始，这里的处理类似于贪心，但是是没有问题的。如果时间间隔小于A乘60，则没法睡觉，必须醒着知道下个番结束，此时判断从上一次醒来到下一段番结束的时间是否大于B*60，如果大于则直接输出no。
另外这题的一个坑是如果k为0，则即使A等于24也直接输出no，因为k为0的话则只能一直处于不睡觉的状态，这样即使A等于24，也不能满足，所以不能

Answer

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <vector>
using namespace std;
const int maxn=1e5+100;
const int oneday = 24 * 60;
struct node{
    int l,r;
}a[maxn],t,tmp;
bool cmp(node x,node y){
    return x.l < y.l;
}
int main(){
    int A,B,N;
    while(scanf("%d %d %d",&A,&B,&N)!=EOF){
    	vector<node>v;
        int l1,l2,r1,r2;
        for(int i = 1;i <= N; i++){
            scanf("%d:%d-%d:%d",&l1,&l2,&r1,&r2);
            int t1 = l1 * 60 + l2;
            int t2 = r1 * 60 + r2;
            if(t2<t1) t2+=oneday;
            a[i]={t1,t2};
        }
        sort(a+1,a+N+1,cmp);
        bool flag=0;
        A*=60,B*=60;
        for(int i=1;i<=N;i++){//判断是否每个番的时间都小于最长不睡觉时间 
            if(a[i].r-a[i].l+1>B){
                flag=1;
                break;
            }
        }
        if(flag == 0){
            t={a[1].l,a[1].r};
            for (int i = 2; i <= N; i++){
                if (a[i].l-(t.r+1) >= A){//每个间隔的长度都可以睡觉 
                    tmp={t.r+1,a[i].l-1};
                    t={a[i].l,a[i].r};
                    if(tmp.l!=tmp.r)v.push_back(tmp);
                }
                else{//如果不能，看是否足以醒着到这个番结束 
                    t.r = a[i].r;
                    if (t.r - t.l + 1 > B){
                        flag = 1;
                        break;
                    }
                }
            }
        }
        if (flag == 0){//特判跨越零点 
            if (a[1].l + oneday - t.r >= A){
                tmp={(t.r + 1) % oneday,(a[1].l + oneday - 1) % oneday};
                if (tmp.l!=tmp.r)v.push_back(tmp);
            }
            else {
                t.r = a[1].r;
                if (t.r - t.l + 1 > B){
                    flag = 1;
                }
            }
        }
        if(v.empty())flag = 1;
        if(flag)cout<<"No"<<endl;
        else{
        	int n=v.size();
        	cout<<"Yes"<<endl;
			cout<<n<<endl;
	        sort(v.begin(),v.end(),cmp);
	        for(int i = 0;i <n; i++){
	            int tl = v[i].l,tr = v[i].r;
	            int l1 = tl/60,l2 = tl - l1 * 60,r1 = tr/60,r2 = tr - r1 * 60;
	            printf("%02d:%02d-%02d:%02d\n",l1,l2,r1,r2);
        	}
		}
        
    }
    return 0;
}

Maroon°

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Program week14 work&experiment

思路Answer具体思路见注释在这里插入代码片思路Answer具体思路见注释在这里插入代码片思路Answer具体思路见注释在这里插入代码片思路Answer具体思路见注释在这里插入代码片...
复制链接

扫一扫