hpu2014周赛一

最新推荐文章于 2019-08-18 15:51:20 发布

qfht

最新推荐文章于 2019-08-18 15:51:20 发布

阅读量592

点赞数

分类专栏： HDU

本文链接：https://blog.csdn.net/u010211389/article/details/22601849

版权

HDU 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

Problem A

Time Limit : 300/100ms (Java/Other) Memory Limit : 65535/32768K (Java/Other)

Total Submission(s) : 6 Accepted Submission(s) : 6

Font: Times New Roman | Verdana | Georgia

Font Size: ← →

Problem Description

　　细心的同事发现，小Ｑ最近喜欢乘电梯上上下下，究其原因，也许只有小Ｑ自己知道：在电梯里经常可以遇到他心中的女神HR。
　　电梯其实是个很暧昧的地方，只有在电梯里，小Q才有勇气如此近距离接近女神，虽然觉得有点不自在，但次数多了，女神也习惯了小Ｑ的存在，甚至熟悉到仿佛不说上句话自己也都觉得不合适了。可是，他们的谈话也仅仅限于今天天气不错啊或是你吃了吗之类的，往往在对方微笑点头后就再次陷入难堪的沉默之中。于是，小Ｑ便在陪伴女神的同时，也关注着电梯中显示的楼层数字，并且他注意到电梯每向上运行一层需要６秒钟，向下运行一层需要4秒钟，每开门一次需要５秒（如果有人到达才开门），并且每下一个人需要加１秒。
　　特别指出，电梯最开始在０层，并且最后必须再回到０层才算一趟任务结束。假设在开始的时候已知电梯内的每个人要去的楼层，你能计算出完成本趟任务需要的总时间吗?
　　这是个很简单的问题，要知道，小Q已经修炼到快速心算出结果的境界，现在你来编程试试吧！

Input

输入首先包含一个正整数C，表示有C组测试用例。
接下来C行每行包含一组数据，每组数据首先是一个正整数N，表示本次乘坐电梯的人数，然后是N个正整数Ai，分别表示大家要去的楼层。

[Technical Specification]
C<=100
N<=15
Ai<=100

Output

请计算并输出完成一趟任务需要的时间，每组数据输出占一行。

Sample Input

2
4 2 4 3 2 
3 10 10 10

Sample Output

59
108

import java.util.Arrays;
import java.util.Scanner;

public class Main {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int C=sc.nextInt();
		while(C-->0){
			int N=sc.nextInt();
			int[] arr=new int[N];
			for(int i=0;i<N;i++)
				arr[i]=sc.nextInt();
			Arrays.sort(arr);
			int count=6*arr[0]+5+1;
			for(int i=1;i<N;i++){
				if(arr[i]==arr[i-1])
					count+=1;
				else {
					count+=6*(arr[i]-arr[i-1])+5+1;
				}
			}
			count+=arr[N-1]*4;
			System.out.println(count);
		}

	}

}

Problem C

Time Limit : 2000/1000ms (Java/Other) Memory Limit : 65536/32768K (Java/Other)

Total Submission(s) : 13 Accepted Submission(s) : 9

Font: Times New Roman | Verdana | Georgia

Font Size: ← →

Problem Description

Contest time again! How excited it is to see balloons floating around. But to tell you a secret, the judges' favorite time is guessing the most popular problem. When the contest is over, they will count the balloons of each color and find the result.

This year, they decide to leave this lovely job to you.

Input

Input contains multiple test cases. Each test case starts with a number N (0 < N <= 1000) -- the total number of balloons distributed. The next N lines contain one color each. The color of a balloon is a string of up to 15 lower-case letters.

A test case with N = 0 terminates the input and this test case is not to be processed.

Output

For each case, print the color of balloon for the most popular problem on a single line. It is guaranteed that there is a unique solution for each test case.

Sample Input

5
green
red
blue
red
red
3
pink
orange
pink
0

Sample Output

red
pink

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Map.Entry;

public class Main {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		while (true) {
			int N = sc.nextInt();
			if (N == 0)
				break;
			Map<String, Integer> map = new HashMap<String, Integer>();
			for (int i = 0; i < N; i++) {
				String s = sc.next();
				if (map.containsKey(s) == false) {
					map.put(s, 1);
				} else {
					int temp = map.get(s);
					temp++;
					map.put(s, temp);
				}
			}
			List<Map.Entry<String, Integer>> info = new ArrayList<Map.Entry<String, Integer>>(
					map.entrySet());
			Collections.sort(info,
					new Comparator<Map.Entry<String, Integer>>() {

						@Override
						public int compare(Entry<String, Integer> o1,
								Entry<String, Integer> o2) {
							// TODO Auto-generated method stub
							return o2.getValue() - o1.getValue();
						}

					});
			System.out.println(info.get(0).getKey());
		}
	}

}

Problem D

Time Limit : 10000/5000ms (Java/Other) Memory Limit : 65536/32768K (Java/Other)

Total Submission(s) : 29 Accepted Submission(s) : 12

Font: Times New Roman | Verdana | Georgia

Font Size: ← →

Problem Description

Given an integer N(0 ≤ N ≤ 10000), your task is to calculate N!

Input

One N in one line, process to the end of file.

Output

For each N, output N! in one line.

Sample Input

1
2
3

Sample Output

1
2
6

import java.util.Scanner;

public class Main {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		while (N-- > 0) {
			String s = sc.next();
			int time1 = F(s);
			s = sc.next();
			int time2 = F(s);
			int time = time1 - time2;
			while (time < 0) {
				time += 3600 * 12;
			}
			int HH = time / 3600;
			time %= 3600;
			int MM = time / 60;
			int SS = time % 60;
			System.out.println(String.format("%02d:%02d:%02d", HH, MM, SS));
		}
	}

	private static int F(String s) {
		// TODO Auto-generated method stub
		String[] str = s.split(":");
		int hh = Integer.parseInt(str[0]);
		int mm = Integer.parseInt(str[1]);
		int ss = Integer.parseInt(str[2]);
		return 60 * 60 * hh + 60 * mm + ss;
	}

}

Problem D

Time Limit : 10000/5000ms (Java/Other) Memory Limit : 65536/32768K (Java/Other)

Total Submission(s) : 31 Accepted Submission(s) : 13

Font: Times New Roman | Verdana | Georgia

Font Size: ← →

Problem Description

Given an integer N(0 ≤ N ≤ 10000), your task is to calculate N!

Input

One N in one line, process to the end of file.

Output

For each N, output N! in one line.

Sample Input

1
2
3

Sample Output

1
2
6

import java.util.Scanner;

public class Main {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		while (sc.hasNext()) {
			int N = sc.nextInt();
			if (N == 0 || N == 1) {
				System.out.println(1);
				continue;
			}
			int[] arr = new int[100000];
			arr[0] = 1;
			int k = 0;
			int count = 1;
			for (int i = 2; i <= N; i++) {
				k = 0;
				for (int j = 0; j < count; j++) {
					arr[j] = arr[j] * i + k;
					k = arr[j] / 10;
					arr[j] = arr[j] % 10;
				}
				while (k != 0) {
					arr[count++] = k % 10;
					k /= 10;
				}
			}
			for (int i = count - 1; i >= 0; i--) {
				System.out.print(arr[i]);
			}
			System.out.println();
		}
	}

}

Problem B

Time Limit : 20000/10000ms (Java/Other) Memory Limit : 65535/65535K (Java/Other)

Total Submission(s) : 0 Accepted Submission(s) : 0

Font: Times New Roman | Verdana | Georgia

Font Size: ← →

Problem Description

The great Mr.Smith has invented a hyperspace particle generator. The device is very powerful. The device can generate a hyperspace. In the hyperspace, particle may appear and disappear randomly. At the same time a great amount of energy was generated.
However, the device is in test phase, often in a unstable state. Mr.Smith worried that it may cause an explosion while testing it. The energy of the device is related to the maximum manhattan distance among particle.
Particles may appear and disappear any time. Mr.Smith wants to know the maxmium manhattan distance among particles when particle appears or disappears.

Input

The input contains several test cases, terminated by EOF.
In each case: In the first line, there are two integer q(number of particle appear and disappear event, ≤60000) and k(dimensions of the hyperspace that the hyperspace the device generated, ≤5). Then follows q lines. In each line, the first integer ‘od’ represents the event: od = 0 means this is an appear
event. Then follows k integer(with absolute value less then 4 × 10 ⁷). od = 1 means this is an disappear event. Follows a integer p represents the disappeared particle appeared in the pth event.

Output

Each test case should contains q lines. Each line contains a integer represents the maximum manhattan distance among paticles.

Sample Input

10 2
0 208 403
0 371 -180
1 2
0 1069 -192
0 418 -525
1 5
1 1
0 2754 635
0 -2491 961
0 2954 -2516

Sample Output

Problem E

Time Limit : 30000/10000ms (Java/Other) Memory Limit : 32768/32768K (Java/Other)

Total Submission(s) : 16 Accepted Submission(s) : 6

Font: Times New Roman | Verdana | Georgia

Font Size: ← →

Problem Description

给你一个m×n的整数矩阵，在上面找一个x×y的子矩阵，使子矩阵中所有元素的和最大。

Input

输入数据的第一行为一个正整数T，表示有T组测试数据。每一组测试数据的第一行为四个正整数m,n,x,y（0<m,n<1000 AND 0<x<=m AND 0<y<=n），表示给定的矩形有m行n列。接下来这个矩阵，有m行，每行有n个不大于1000的正整数。

Output

对于每组数据，输出一个整数，表示子矩阵的最大和。

Sample Input

1
4 5 2 2
3 361 649 676 588
992 762 156 993 169
662 34 638 89 543
525 165 254 809 280

Sample Output

Problem F

Time Limit : 3000/1000ms (Java/Other) Memory Limit : 65535/32768K (Java/Other)

Total Submission(s) : 9 Accepted Submission(s) : 2

Font: Times New Roman | Verdana | Georgia

Font Size: ← →

Problem Description

　　小明和他的好朋友小西在玩一个新的游戏，由小西给出一个由小写字母构成的字符串，小明给出另一个比小西更长的字符串，也由小写字母组成，如果能通过魔法转换使小明的串和小西的变成同一个，那么他们两个人都会很开心。这里魔法指的是小明的串可以任意删掉某个字符，或者把某些字符对照字符变化表变化。如：
　　　　小西的串是 abba;
　　　　小明的串是 addba;
　　　　字符变化表 d b （表示d能转换成b）。
　　那么小明可以通过删掉第一个d，然后将第二个d转换成b将串变成abba。

　　现在请你帮忙判断：他们能不能通过魔法转换使两个人的串变成一样呢？

Input

　　首先输入T，表示总共有T组测试数据(T <= 40)。
　　接下来共T组数据，每组数据第一行输入小西的字符串，第二行输入小明的字符串（数据保证字符串长度不超过1000，小明的串的长度大于等于小西的，且所有字符均为小写字母）。接着输入字母表，先输入m，表示有m个字符变换方式（m< = 100），接着m行每行输入两个小写字母，表示前一个可以变为后一个（但并不代表后一个能变成前一个）。

Output

　　对于每组数据，先输出Case数。
　　如果可以通过魔法转换使两个人的串变成一样，输出“happy”，
　　否则输出“unhappy”。
　　每组数据占一行，具体输出格式参见样例。

Sample Input

2
abba
addba 
1
d b
a
dd
0

Sample Output

Case #1: happy
Case #2: unhappy

qfht

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
hpu2014周赛一

Problem A Time Limit : 300/100ms (Java/Other) Memory Limit : 65535/32768K (Java/Other)Total Submission(s) : 6 Accepted Submission(s) : 6Font: Times New Roman | Verdana | GeorgiaFont Size:
复制链接

扫一扫