POJ-1018-Communication System

Communication System

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 30545		Accepted: 10853

Description

We have received an order from Pizoor Communications Inc. for a special communication system. The system consists of several devices. For each device, we are free to choose from several manufacturers. Same devices from two manufacturers differ in their maximum bandwidths and prices.
By overall bandwidth (B) we mean the minimum of the bandwidths of the chosen devices in the communication system and the total price (P) is the sum of the prices of all chosen devices. Our goal is to choose a manufacturer for each device to maximize B/P.

Input

The first line of the input file contains a single integer t (1 ≤ t ≤ 10), the number of test cases, followed by the input data for each test case. Each test case starts with a line containing a single integer n (1 ≤ n ≤ 100), the number of devices in the communication system, followed by n lines in the following format: the i-th line (1 ≤ i ≤ n) starts with mi (1 ≤ mi ≤ 100), the number of manufacturers for the i-th device, followed by mi pairs of positive integers in the same line, each indicating the bandwidth and the price of the device respectively, corresponding to a manufacturer.

Output

Your program should produce a single line for each test case containing a single number which is the maximum possible B/P for the test case. Round the numbers in the output to 3 digits after decimal point.

Sample Input

1 3
3 100 25 150 35 80 25
2 120 80 155 40
2 100 100 120 110

Sample Output

0.649

                                 Java中的static关键字（可用于修饰类的成员、成员方法以及代码块）

（1）静态变量

（2）静态方法

（3）静态代码块

在一个静态方法中只能访问用static修饰的成员，原因在于没有被static修饰的成员需要先创建对象才能访问，而静态方法在被调用时可以不创建任何对象。

                                                                            内部类

在Java中，允许在一个类的内部定义类，这样的类称作内部类，这个内部类所在的类称作外部类。根据内部类的位置、修饰符、和定义的方式可分为成员内部类、静态内部类、方法内部类。

成员内部类

在一个类中除了可以定义成员变量、成员方法，还可以定义类，这样的类被称作成员内部类。在成员内部类中可以访问外部类的所有成员。

静态内部类

使用static关键字来修饰一个成员内部类，该内部类被称作静态内部类，它可以在不创建外部类对象的情况下被实例化。

（1）在静态内部类中只能访问外部类的静态成员

（2）在静态内部类中可以定义静态的成员，而在非静态的内部类中不允许定义静态的成员

方法内部类

方法内部类是指在成员方法中定义的类，它只能在当前方法中被使用。

一个Java源程序文件中定义几个类和接口，则编译该文件后生成几个以.class为后缀的字节码文件

import java.util.*;
import java.lang.Math;
public class Main
{
	int n;
	int []flag;
	int []sum=new int[105];
	Node [][]a=new Node[105][105];
	public static void main(String args[])
	{new Main().run();}

       void run()
	{
		Scanner cin=new Scanner(System.in);
		int t=cin.nextInt();
		while(t-->0)
		{
			flag=new int[1005];
			int minbw=0x3f3f3f3f,maxbw=0;
			n=cin.nextInt();
			for(int i=0;i<n;i++)
			{
				sum[i]=cin.nextInt();
				for(int j=0;j<sum[i];j++)
				{
					int s1=cin.nextInt();
					int s2=cin.nextInt();
					a[i][j]=new Node(s1,s2);
					flag[a[i][j].bw]=1;
					minbw=Math.min(minbw,s1);
					maxbw=Math.max(maxbw,s1);
				}
			}
			float ans=0;
			for(int i=minbw;i<=maxbw;i++)
			{
				int count=0;
				if(flag[i]!=1)continue;
				for(int j=0;j<n;j++)
				{
					int minp=0x3f3f3f3f;
					for(int k=0;k<sum[j];k++)
					{
						if(a[j][k].bw>=i)
						minp=Math.min(minp,a[j][k].p);
					}
					count+=minp;
				}
				ans=Math.max(ans,(float)i/count);
			}
			System.out.printf("%.3f\n",ans);
		}
	}

	class Node
	{
		int bw,p;
		Node(int bw,int p)
		{
			this.bw=bw;
			this.p=p;
		}
	}
}

import java.util.*;
import java.lang.Math;
class Node
{
	int bw,p;
	Node(int bw,int p)
	{
		this.bw=bw;
		this.p=p;
	}
}
public class Main
{
	public static void main(String args[])
	{
		Scanner cin=new Scanner(System.in);
		int n;
		int []flag;
		int []sum=new int[105];
		Node [][]a=new Node[105][105];
		int t=cin.nextInt();
		while(t-->0)
		{
			flag=new int[1005];
			int minbw=0x3f3f3f3f,maxbw=0;
			n=cin.nextInt();
			for(int i=0;i<n;i++)
			{
				sum[i]=cin.nextInt();
				for(int j=0;j<sum[i];j++)
				{
					int s1=cin.nextInt();
					int s2=cin.nextInt();
					a[i][j]=new Node(s1,s2);
					flag[a[i][j].bw]=1;
					minbw=Math.min(minbw,s1);
					maxbw=Math.max(maxbw,s1);
				}
			}
			float ans=0;
			for(int i=minbw;i<=maxbw;i++)
			{
				int count=0;
				if(flag[i]!=1)continue;
				for(int j=0;j<n;j++)
				{
					int minp=0x3f3f3f3f;
					for(int k=0;k<sum[j];k++)
					{
						if(a[j][k].bw>=i)
						minp=Math.min(minp,a[j][k].p);
					}
					count+=minp;
				}
				ans=Math.max(ans,(float)i/count);
			}
			System.out.printf("%.3f\n",ans);
		}
	}

}