首页 > 专题系列 > Java解POJ > POJ 2487 Stamps [解题报告] Java
2013
11-11

POJ 2487 Stamps [解题报告] Java

Stamps

问题描述 :

Background

Everybody hates Raymond. He’s the largest stamp collector on planet earth and because of that he always makes fun of all the others at the stamp collector parties. Fortunately everybody loves Lucy, and she has a plan. She secretly asks her friends whether they could lend her some stamps, so that she can embarrass Raymond by showing an even larger collection than his.

Problem

Raymond is so sure about his superiority that he always tells how many stamps he’ll show. And since Lucy knows how many she owns, she knows how many more she needs. She also knows how many friends would lend her some stamps and how many each would lend. But she’d like to borrow from as few friends as possible and if she needs too many then she’d rather not do it at all. Can you tell her the minimum number of friends she needs to borrow from?

输入:

The first line contains the number of scenarios. Each scenario describes one collectors party and its first line tells you how many stamps (from 1 to 1000000) Lucy needs to borrow and how many friends (from 1 to 1000) offer her some stamps. In a second line you’ll get the number of stamps (from 1 to 10000) each of her friends is offering.

输出:

The output for every scenario begins with a line containing “Scenario #i:”, where i is the number of the scenario starting at 1. Then print a single line with the minimum number of friends Lucy needs to borrow stamps from. If it’s impossible even if she borrows everything from everybody, write impossible. Terminate the output for the scenario with a blank line.

样例输入:

3
100 6
13 17 42 9 23 57
99 6
13 17 42 9 23 57
1000 3
314 159 265

样例输出:

Scenario #1:
3

Scenario #2:
2

Scenario #3:
impossible

解题代码:

import java.io.BufferedInputStream;   
import java.util.Scanner;   
  
/**  
 *  
 *poj2487  
 * @author NC  
 */  
public class Main {   
  
    private static int partition(int[] array, int low, int high) {   
        int key = array[low];   
        while (low < high) {  
            while (low < high && array[high] >= key) {   
                high--;    
            }   
            array[low] = array[high];    
            while (low < high && array[low] <= key) {   
                low++; 
            }   
            array[high] = array[low];    
        }   
        array[low] = key; 
        return low;   
    }   
  
    private static void qSort(int[] array, int low, int high) {   
        int pivotloc;   
        if (low < high) {  
            pivotloc = partition(array, low, high); 
            qSort(array, low, pivotloc - 1);    
            qSort(array, pivotloc + 1, high); 
        }   
    }   
  
    private static void quickSort(int[] array) {   
        int n = array.length - 1;   
        qSort(array, 1, n);   
    }   
  
    public static void main(String[] args) {   
        Scanner scan = new Scanner(new BufferedInputStream(System.in));   
        if (scan.hasNext()) {   
            int n = scan.nextInt();   
            for (int i = 1; i <= n; i++) {   
                int stamps = scan.nextInt();   
                int friends = scan.nextInt();   
                int[] fs = new int[friends + 1];   
                for (int j = 1; j <= friends; j++) {   
                    fs[j] = scan.nextInt();   
                }   
                quickSort(fs);   
                int count = 0;   
                int sum = 0;   
                for (int k = friends; k >= 1; k--) {   
                    if (sum < stamps) {   
                        sum = sum + fs[k];   
                        count++;   
                    } else {   
                        break;   
                    }   
                }   
                if (sum < stamps) {   
                    System.out.println("Scenario #" + i + ":");   
                    System.out.println("impossible");   
                    System.out.println();   
                } else {   
                    System.out.println("Scenario #" + i + ":");   
                    System.out.println(count);   
                    System.out.println();   
                }   
  
            }   
        }   
    }   
}

  1. [email protected]

  2. simple, however efficient. A lot of instances it is difficult to get that a??perfect balancea?? among usability and appearance. I must say that youa??ve done a exceptional task with this. Also, the blog masses quite fast for me on Web explore.

  3. 在方法1里面:

    //遍历所有的边,计算入度
    for(int i=0; i<V; i++)
    {
    degree = 0;
    for (j = adj .begin(); j != adj .end(); ++j)
    {
    degree[*j]++;
    }
    }

    为什么每遍历一条链表,要首先将每个链表头的顶点的入度置为0呢?
    比如顶点5,若在顶点1、2、3、4的链表中出现过顶点5,那么要增加顶点5的入度,但是在遍历顶点5的链表时,又将顶点5的入度置为0了,那之前的从顶点1234到顶点5的边不是都没了吗?

  4. 5.1处,反了;“上一个操作符的优先级比操作符ch的优先级大,或栈是空的就入栈。”如代码所述,应为“上一个操作符的优先级比操作符ch的优先级小,或栈是空的就入栈。”