Analyse et conception d'algorithmes : échange de pièces

Table des matières

Description du problème

Idées de conception d'algorithmes

 Code

Algorithme exécutant les résultats et analyse de la complexité du temps de calcul

---

Description du problème:

Il existe plusieurs pièces de 1 cent, 2 cents, 5 cents, 10 cents, 50 cents et 100 cents. Vous souhaitez maintenant utiliser ces pièces pour payer des yuans W. Veuillez concevoir un algorithme gourmand pour le compléter avec le moins de pièces possible comportement de paiement. Il existe plusieurs pièces de 1 cent, 2 cents, 5 cents, 10 cents, 50 cents et 100 cents. Vous souhaitez maintenant utiliser ces pièces pour payer des yuans W. Veuillez concevoir un algorithme gourmand pour le compléter avec le moins de pièces possible comportement de paiement.

Idées de conception d'algorithme :

Concevez une boucle for pour effectuer des opérations, et le nombre de boucles est en fait lié au nombre de feuilles. Définissez la condition, si ww>arr[i] (la plus grande dénomination actuellement acceptée), i-- ne sera pas exécuté, peut-être que la dénomination peut être réduite une fois. S'il ne peut pas être réduit, exécutez i--, laissez la prochaine plus petite dénomination essayer, et ainsi de suite. Enfin, si ww=0, le résultat peut être sorti.

 Code:

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

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		while (sc.hasNext()) {
			double w = sc.nextDouble();
			int ww = (int)(w*100);//把元单位转换为分
			int arr[] = new int[6];
			for (int i = 0; i < 6; i++) {//输入硬币的几种面额
				int a = sc.nextInt();
				arr[i] = a;
			}
//		Arrays.sort(arr);//若是乱序，则需要排序
			int num = 0;//存储使用张数
			for (int i = 5; i >= 0;) {//因为排序默认从小到大，所以这里要从后往前
				if (ww >= arr[i]) {
					ww = ww - arr[i];
//				i++;
					num++;//每使用一张，加1
				} else {
					i--;//把i--安排在这里，上面只要最大的面额还能用，就不减；不能用了，就执行i--
				}
				if (ww == 0) {
					System.out.println(num);//输出张数
					break;
				}
			}
		}
	}
}

Résultats de l'exécution de l'algorithme et analyse de la complexité du temps de calcul :

Si un tri est nécessaire, la complexité temporelle est T(n)=O(nlogn)

Si aucun tri n'est requis, la complexité temporelle est T(n)=O(n)