Ural 1971(Graphics Settings-延迟计算)

1971. Graphics Settings

Time limit: 2.0 second

Memory limit: 64 MB

给定n个选项,m个操作,问the image generation speed=p/(W*H*∏ki(第i个选项开启))在哪个区间。

Input

第一行为 n (0 ≤ n ≤ 100 000). 接下来第i行分别有指令名 si,  和整数 ki(2
≤ ki ≤ 100),指令名为长度在[1,10]的小写字母字符串,下一行为 WH,和 p (320 ≤ W ≤ 2 560; 200 ≤ H ≤ 1 600; 1 ≤ p ≤ 109).
They are the initial width and height of the screen in pixels and the clock rate of the GPU in cycles per second. 最初选项全开. 接下来为指令数 m (1 ≤ m ≤ 100 000) . 接下来 m 行有如下的指令:

  • “On s” — 开启 s;
  • “Off s” — 关闭 s;
  • “Resolution w h” — set the screen resolution to w × h pixels (320 ≤ w ≤ 2 560; 200 ≤ h≤ 1 600).

保证选项只在开启时关闭,只在关闭时开启.

Output

The first line should describe the performance of the game before changes in the settings. Then nextm lines should describe the performance of the game after each change in the settings. Output
“Slideshow” if the image generation speed is less than 10 frames per second, “Perfect” if it is 60 frames per second or greater, and “So-so” otherwise.

Sample

input output
1
vsync 10
640 480 10000000
2
Off vsync
Resolution 320 240
Slideshow
So-so
Perfect

Problem Author: Denis Dublennykh

Problem Source: Ural Sport Programming Championship 2013

Tags: none  (

hide tags for unsolved problems
)

Difficulty: 406    Printable version    Submit solution    Discussion
(9)

My submissions    All submissions (2909)    All
accepted submissions (309)
   Solutions rating (198)

本题思路不难理解,问题在于∏ki(第i个选项开启)会溢出

所以我们用队列存储,延迟它的计算,防止溢出

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<functional>
#include<iostream>
#include<cmath>
#include<cctype>
#include<ctime>
#include<map>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=pre[x];p;p=next[p])
#define Lson (x<<1)
#define Rson ((x<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,127,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (2139062143)
#define F (100000007)
#define MAXN (100000+10)
#define MAXKi (100+10)
#define MAXLen (10+10)
#define MAXW (2560+10)
#define MAXH (1600+10)
#define MINW (320+10)
#define MINH (200+10)
#define MAXP (1000000000)
#define MAXM (100000+10)
long long mul(long long a,long long b){return (a*b)%F;}
long long add(long long a,long long b){return (a+b)%F;}
long long sub(long long a,long long b){return (a-b+(a-b)/F*F+F)%F;}
typedef long long ll;
map<string,int> h;
int n,m,val[MAXN],q[MAXM],head=1,tail=0;
bool inq[MAXM]={0};
ll W,H,p,res=1; //res表示当前∏k
//题意:image generation speed(v)=p/res/W/H<10 / >=60 => res*W*H*10>p res*W*H*60<=p
void print()
{
	while (res*W*H*10<=p&&head<=tail)
	{
		int now=q[head++];
		if (!inq[now]) continue;
		inq[now]=0;res*=val[now];
	}
	if (p<res*W*H*10) printf("Slideshow\n");
	else if (p<res*W*H*60) printf("So-so\n");
	else printf("Perfect\n");

}
int main()
{
//	freopen("ural1971.in","r",stdin);
//	freopen(".out","w",stdout);
	cin>>n;
	For(i,n)
	{
		string s;
		cin>>s>>val[i];
		h[s]=i;
		q[++tail]=i;inq[i]=1;
	}
	cin>>W>>H>>p;
	cin>>m;

	print();
	For(i,m)
	{
		char s[20];
		scanf("%s",s);
		switch (s[1])
		{
			case'n':
				{
					string s;
					cin>>s;
					int p=h[s];
					inq[p]=1;q[++tail]=p;
					break;
				}
			case'f':
				{
					string s;
					cin>>s;
					int p=h[s];
					if (inq[p]) inq[p]=0;
					else res/=val[p];
					break;
				}
			default:
				{
					cin>>W>>H;
				}
		}
		print();
	}

	return 0;
}

Ural 1971(Graphics Settings-延迟计算)

时间: 2024-10-05 03:14:15

Ural 1971(Graphics Settings-延迟计算)的相关文章

11.3.1.2 Haskell 的延迟计算策略

在延迟计算策略(lazy evaluation strategy)中,函数的参数值,在函数调用时不会计算,直到后来用到这个值时才计算.我们回到前面的例子: TestAndCalculate(Calculate(10)); 在这里,Haskell 直接跳转到TestAndCalculate 函数主体.Haskell 会记住参数值的名字叫 num,如果在后面需要 num 值,就会运行 Calculate(10),然后,继续执行,得到 TestCondition的结果.如果这个函数返回true,表示需

11.3.3 用函数模拟延迟计算

在F# 和C# 中计算顺序是提前的:作为给函数参数使用的表达式,在函数自身开始执行之前就计算好了.在C# 和F# 中,我们可以使用函数值模拟延迟计算,另外,F# 甚至有一个专门的关键字,支持延迟计算. 但首先,对于提前计算规则有一个例外,你肯定知道,并经常使用,但只是因为太常用,反而可能没有意识到它的特别.有些特定的C# 运算符,比如,逻辑或(||).逻辑与(&&).条件运算符(?:),以及空合并运算符(null-coalescing,??),能实现短路径(short-circuiting

2019年10月1日 实现延迟计算功能

class Lazyproperty: def __init__(self,func): print('>>>>>',func) self.func=func def __get__(self, instance, owner):#self 是Lazyproperty()生成的对象 print('get方法') if instance is None: return self #如果instance 是None,就返回Lazyproperty(area)也就是self res

[py]函数中yield多次返回,延迟计算特性-杨辉三角

搞清什么是杨辉三角 每行是一个数组, 第一行: [1] 第二行: [1, 1] 第三行: [1, 2, 2, 1] ... 画的好看点就是,不过没啥卵用 1 / 1 1 / \ / 1 2 1 / \ / \ / 1 3 3 1 / \ / \ / \ / 1 4 6 4 1 / \ / \ / \ / \ / 1 5 10 10 5 1 打印杨辉三角 首先要解决一个函数,多次返回值, 我们知道py函数返回多个值,没啥问题. 但是要多次返回值呢?需要借助生成器来完成, 生成器的好处是可以保留现场

光迁PING值延迟计算!以及到中国最快的美国机房是哪个机房?

美国圣安娜KT机房/美国KT机房/美国KT服务器 KT机房是美国直达大陆最快的机房,ping值一般为195MS,是做web服务器的首选机房,深受中小站长的欢迎! 我们平时测试美国服务器的速度,都是通过ping值判断的.(ping美国一台服务器,数据请求过去,再回来,所需要的时间,就是我们常说的ping值), 但是,有一些idc提供商在那吹嘘他的ping是小于100的,首先,我可以肯定的告诉你 只要是说的他的ping值小于100的美国服务器绝对是在忽悠你.中美距离是半个地球, 光一秒钟30万公里,

11.4.2.1 使用延迟值进行缓存

11.4.2.1 使用延迟值进行缓存 应用程序中最重要的部分是,应用程序启动时执行的代码,找到指定目录中的所有文件,并创建有关每个文件信息的数组:这些信息包含文件名,和为了展示调整大小而计算的延迟值.清单 11.21 是为此而创建的数据结构. 清单 11.21 创建有关图片信息的集合 (F#) open System.IO open System.Drawing type ImageInfo = { Name : string; Preview :Lazy<Bitmap> }   [1] le

C#中基于GDI+(Graphics)图像处理系列之前言

前言 图像处理工具类的全部源码 完整示例程序源码下载 示例程序截图 前言 图像处理是开发工程师们学习某种语言入门时就会遇到的问题,笔者刚开始接触C#使用GDI+进行图像处理,觉得太简单了,就没有深入研究,随着工作经验的积累,踏遍若干坑以后突然觉得还是有必要将这块的知识好好总结一下,毕竟还是有一些比较冷门的知识在实际应用中给我们的程序带来更多的灵活性,比如将图片保存成jpeg时进一步控制图片的质量.怎样获取任意角度旋转后的图像.怎样获取透明图像等等. 本文后面将直接放出图像处理工具类的全部源码和示

11.3.5 为 C# 实现延迟值

11.3.5 为 C# 实现延迟值 在 11.3.3 节,我们使用函数来表示 C# 中的延迟计算.我们刚才在 F# 中探讨了Lazy<T> 类型,它为计算过的值,添加了缓存功能.从Visual Studio 2010 开始,在核心的 .NET 库下的System.Lazy <T> 就有了这种类型,因此,我们不必自己实现. 清单 11.18 是简化的 Lazy<T> 类.代码在许多方面做了简化,它不是线程安全的,不处理任何异常,只表达了核心概念. [ 清单的序号终于正常了

RDD:基于内存的集群计算容错抽象

本文转载:http://shiyanjun.cn/archives/744.html 摘要 本文提出了分布式内存抽象的概念——弹性分布式数据集(RDD,Resilient Distributed Datasets),它具备像MapReduce等数据流模型的容错特性,并且允许开发人员在大型集群上执行基于内存的计算.现有的数据流系统对两种应用的处理并不高效:一是迭代式算法,这在图应用和机器学习领域很常见:二是交互式数据挖掘工具.这两种情况下,将数据保存在内存中能够极大地提高性能.为了有效地实现容错,