1.
import java.io.BufferedReader;
import java.io.InputStreamReader;

/**
* FWP, Ausgewählte Probleme aus dem ACM Programming Contest, SS11
* Problem: 147 Dollars
* Link: http://uva.onlinejudge.org/external/1/147.pdf
*
* @author Rolf Schirm
* @version 1.0, 04/06/2011
*
* Method : Ad-Hoc
* Status : Accepted
* Runtime: 0.700
*/
public class Main {
public static void main(String... args) throws Exception {
final BufferedReader scan = new BufferedReader(new
InputStreamReader(System.in));

final int length = 30000/5 + 1;

/**
* Anzahl der Kombinationen bei denen mindestens einmal die
* Münze 10 vorkommt und zugleich 10 die höchste Münze ist.
*/
final long[] f10 = new long[length];

/**
* Anzahl der Kombinationen bei denen mindestens einmal die
* Münze 25 vorkommt und zugleich 25 die höchste Münze ist.
*/
final long[] f20 = new long[length];

/**
* Anzahl der Kombinationen bei denen mindestens einmal die
* Münze 50 vorkommt und zugleich 50 die höchste Münze ist.
*/
final long[] f50 = new long[length];

/**
* Anzahl der Kombinationen bei denen mindestens einmal die
* Münze 100 vorkommt und zugleich 100 die höchste Münze ist.
*/
final long[] f100 = new long[length];

/**
* Anzahl der Kombinationen bei denen mindestens einmal die
* Münze 200 vorkommt und zugleich 100 die höchste Münze ist.
*/
final long[] f200 = new long[length];

/**
* Anzahl der Kombinationen bei denen mindestens einmal die
* Münze 500 vorkommt und zugleich 500 die höchste Münze ist.
*/
final long[] f500 = new long[length];

/**
* Anzahl der Kombinationen bei denen mindestens einmal die
* Münze 1000 vorkommt und zugleich 1000 die höchste Münze
ist.
*/
final long[] f1000 = new long[length];

/**
* Anzahl der Kombinationen bei denen mindestens einmal die
* Münze 2000 vorkommt und zugleich 2000 die höchste Münze
ist.
*/
final long[] f2000 = new long[length];

/**
* Anzahl der Kombinationen bei denen mindestens einmal die
* Münze 5000 vorkommt und zugleich 5000 die höchste Münze
ist.
*/
final long[] f5000 = new long[length];

/**
* Anzahl der Kombinationen bei denen mindestens einmal die
* Münze 10000 vorkommt und zugleich 10000 die höchste
Münze ist.
*/
final long[] f10000 = new long[length];

/**
* Anzahl der Gesamten Kombinationen aus 1, 5, 10, 25 und 50
* ist die Summe aus f1 (= 1), f5 (= i), f10, f25 und f50.
*/
final long[] fsum = new long[length];

for(int i = 2; i < length; i++) {
f10[i] = 1 + f10[i-2];
}

for(int i = 4; i < length; i++) {
f20[i] = 1 + f10[i-4] + f20[i-4];
}

for(int i = 10; i < length; i++) {
f50[i] = 1 + f10[i-10] + f20[i-10] + f50[i-10];
}

for(int i = 20; i < length; i++) {
f100[i] = 1 + f10[i-20] + f20[i-20] + f50[i-20] +
f100[i-20];
}

for(int i = 40; i < length; i++) {
f200[i] = 1 + f10[i-40] + f20[i-40] + f50[i-40] +
f100[i-40] + f200[i-40];
}

for(int i = 100; i < length; i++) {
f500[i] = 1 + f10[i-100] + f20[i-100] + f50[i-100] +
f100[i-100] + f200[i-100] + f500[i-100];
}

for(int i = 200; i < length; i++) {
f1000[i] = 1 + f10[i-200] + f20[i-200] + f50[i-200] +
f100[i-200] + f200[i-200] + f500[i-200] +
f1000[i-200];
}

for(int i = 400; i < length; i++) {
f2000[i] = 1 + f10[i-400] + f20[i-400] + f50[i-400] +
f100[i-400] + f200[i-400] + f500[i-400] + f1000[i-400]
+ f2000[i-400];
}

for(int i = 1000; i < length; i++) {
f5000[i] = 1 + f10[i-1000] + f20[i-1000] + f50[i-1000]
+ f100[i-1000] + f200[i-1000] + f500[i-1000] +
f1000[i-1000] + f2000[i-1000] + f5000[i-1000];
}

for(int i = 2000; i < length; i++) {
f10000[i] = 1 + f10[i-2000] + f20[i-2000] +
f50[i-2000] + f100[i-2000] + f200[i-2000] +
f500[i-2000] + f1000[i-2000] + f2000[i-2000] +
f5000[i-2000] + f10000[i-2000];
}

for(int i = 0; i < length; i++) {
fsum[i] = 1 + f10[i] + f20[i] + f50[i] + f100[i] +
f200[i] + f500[i] + f1000[i] + f2000[i] + f5000[i]
+ f10000[i];
}

String line;

while((line = scan.readLine()) != null &&
!line.equals("0.00")) {
String result =
Long.toString(fsum[(int)(Double.parseDouble(line)*20)]);

// Eingabe bis 6 Zeichen vorne mit Leerzeichen auffüllen
for(int i = line.length(); i < 6; i++) {
line = " " + line;
}

// Ergebnis bis 17 Zeichen vorne mit Leerzeichen
auffüllen
for(int i = result.length(); i < 17; i++) {
result = " " + result;
}

System.out.println(line + result);
}
}
}




-----------------------------------------------------------

1.


/** * FWP, Ausgewählte Probleme aus dem ACM Programming Contest, SS10
* * Problem: 147 - Dollars
* * Link: http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=3&page=show_problem&problem=83
* * Savkina Ekaterina
* * @version 1.0, 06/17/2010
* *Method : Ad-Hoc
* * Status : Accepted
* * Runtime: 1.636 */
package dollars;

import java.text.DecimalFormat;
import java.util.Scanner;

public class Main {

public static int[] coins = { 10000, 5000, 2000, 1000, 500, 200, 100, 50,
20, 10, 5 };

public static void main(String... args) {
Scanner sc = new Scanner(System.in);
int v = 11;
long mway[] = new long[30000 + 1];
mway[0] = 1;
for (int i = 0; i < v; i++) {
int c = coins[i];
for (int j = c; j <= 30000; j++) {
mway[j] += mway[j - c];
}
}
DecimalFormat f = new DecimalFormat("#0.00");

while (true) {
int money = (int) (sc.nextDouble() * 100 + 0.5);
if (money == 0)
break;
System.out.printf("%6.2f%17d\n", money / 100.0, mway[money]);

}
return;

}

}


2.

package acm_147_dollars;

import java.util.Scanner;

/**
* FWP, Ausgew¦hlte Probleme aus dem ACM Programming Contest, SS10
* Problem: acm_147_dollars
* Link:
*
* @author Martin Lambeck
* @version 1.0, 01.09.2010
*
* Method : dp
* Status : Accepted
* Runtime: 1.316
*/


public class Main
{
static Scanner sc = new Scanner(System.in);

final static int MAX = 30000;

static long[] w = new long[MAX+1];

public static void main(String... args)
{
w[0] = 1;

dp(5);
dp(10);
dp(20);
dp(50);
dp(100);
dp(200);
dp(500);
dp(1000);
dp(2000);
dp(5000);
dp(10000);

while (testcase())
;
}

public static boolean testcase()
{
String str = sc.nextLine();
int price = (int) ((Double.parseDouble(str)) * 100 + 0.5);

if (price == 0)
return false;

System.out.printf("%6s%17s%n", str, "" + w[price]);

return true;
}

static void dp(int c)
{
for (int i = 0; i <= MAX; i++)
{
if (i+c > MAX)
return;

w[i+c] += w[i];
}
}
}