mirror of
https://github.com/TheAlgorithms/Java.git
synced 2025-07-07 17:56:02 +08:00
@ -0,0 +1,40 @@
|
||||
package com.thealgorithms.greedyalgorithms;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Comparator;
|
||||
|
||||
// Problem Link: https://en.wikipedia.org/wiki/Activity_selection_problem
|
||||
|
||||
public class ActivitySelection {
|
||||
// Function to perform activity selection
|
||||
public static ArrayList<Integer> activitySelection(int startTimes[], int endTimes[]) {
|
||||
int n = startTimes.length;
|
||||
int activities[][] = new int[n][3];
|
||||
|
||||
// Create a 2D array to store activities and their start/end times.
|
||||
// Each row: [activity index, start time, end time]
|
||||
|
||||
for (int i = 0; i < n; i++) {
|
||||
activities[i][0] = i; // Assign activity index
|
||||
activities[i][1] = startTimes[i]; // Assign start time
|
||||
activities[i][2] = endTimes[i]; // Assign end time
|
||||
}
|
||||
|
||||
// Sort activities by their end times in ascending order.
|
||||
Arrays.sort(activities, Comparator.comparingDouble(activity -> activity[2]));
|
||||
int lastEndTime;
|
||||
ArrayList<Integer> selectedActivities = new ArrayList<>();
|
||||
selectedActivities.add(activities[0][0]);
|
||||
lastEndTime = activities[0][2];
|
||||
|
||||
// Iterate through sorted activities to select compatible ones.
|
||||
for (int i = 1; i < n; i++) {
|
||||
if (activities[i][1] >= lastEndTime) {
|
||||
selectedActivities.add(activities[i][0]);
|
||||
lastEndTime = activities[i][2];
|
||||
}
|
||||
}
|
||||
return selectedActivities;
|
||||
}
|
||||
}
|
@ -0,0 +1,35 @@
|
||||
package com.thealgorithms.greedyalgorithms;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Comparator;
|
||||
|
||||
// Problem Link : https://en.wikipedia.org/wiki/Change-making_problem
|
||||
|
||||
public class CoinChange {
|
||||
// Function to solve the coin change problem
|
||||
public static ArrayList<Integer> coinChangeProblem(int amount) {
|
||||
// Define an array of coin denominations in descending order
|
||||
Integer coins[] = {1, 2, 5, 10, 20, 50, 100, 500, 2000};
|
||||
|
||||
// Sort the coin denominations in descending order
|
||||
Arrays.sort(coins, Comparator.reverseOrder());
|
||||
|
||||
int count = 0; // Variable to keep track of the total number of coins used
|
||||
ArrayList<Integer> ans = new ArrayList<>(); // List to store selected coins
|
||||
|
||||
// Iterate through the coin denominations
|
||||
for (int i = 0; i < coins.length; i++) {
|
||||
// Check if the current coin denomination can be used to reduce the remaining amount
|
||||
if (coins[i] <= amount) {
|
||||
// Repeatedly subtract the coin denomination from the remaining amount
|
||||
while (coins[i] <= amount) {
|
||||
count++; // Increment the count of coins used
|
||||
ans.add(coins[i]); // Add the coin to the list of selected coins
|
||||
amount -= coins[i]; // Update the remaining amount
|
||||
}
|
||||
}
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
}
|
@ -0,0 +1,41 @@
|
||||
package com.thealgorithms.greedyalgorithms;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Comparator;
|
||||
|
||||
// Problem Link: https://en.wikipedia.org/wiki/Continuous_knapsack_problem
|
||||
|
||||
public class FractionalKnapsack {
|
||||
// Function to perform fractional knapsack
|
||||
public static int fractionalKnapsack(int weight[], int value[], int capacity) {
|
||||
// Create a 2D array to store item indices and their value-to-weight ratios.
|
||||
double ratio[][] = new double[weight.length][2];
|
||||
|
||||
// Populate the ratio array with item indices and their value-to-weight ratios.
|
||||
for (int i = 0; i < weight.length; i++) {
|
||||
ratio[i][0] = i; // Assign item index.
|
||||
ratio[i][1] = value[i] / (double) weight[i]; // Calculate and assign value-to-weight ratio.
|
||||
}
|
||||
|
||||
// Sort items by their value-to-weight ratios in descending order.
|
||||
Arrays.sort(ratio, Comparator.comparingDouble(o -> o[1]));
|
||||
|
||||
int finalValue = 0; // Variable to store the final knapsack value.
|
||||
double current = capacity; // Variable to track the remaining capacity of the knapsack.
|
||||
|
||||
// Iterate through the sorted items to select items for the knapsack.
|
||||
for (int i = ratio.length - 1; i >= 0; i--) {
|
||||
int index = (int) ratio[i][0]; // Get the item index.
|
||||
if (current >= weight[index]) {
|
||||
// If the entire item can fit in the knapsack, add its value.
|
||||
finalValue += value[index];
|
||||
current -= weight[index];
|
||||
} else {
|
||||
// If only a fraction of the item can fit, add a proportionate value.
|
||||
finalValue += ratio[i][1] * current;
|
||||
break; // Stop adding items to the knapsack since it's full.
|
||||
}
|
||||
}
|
||||
return finalValue;
|
||||
}
|
||||
}
|
@ -0,0 +1,65 @@
|
||||
package com.thealgorithms.greedyalgorithms;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collections;
|
||||
|
||||
// Problem Link: https://en.wikipedia.org/wiki/Job-shop_scheduling
|
||||
|
||||
public class JobSequencing {
|
||||
|
||||
// Define a Job class that implements Comparable for sorting by profit in descending order
|
||||
static class Job implements Comparable<Job> {
|
||||
char id;
|
||||
int deadline;
|
||||
int profit;
|
||||
|
||||
// Compare jobs by profit in descending order
|
||||
@Override
|
||||
public int compareTo(Job otherJob) {
|
||||
return otherJob.profit - this.profit;
|
||||
}
|
||||
|
||||
public Job(char id, int deadline, int profit) {
|
||||
this.id = id;
|
||||
this.deadline = deadline;
|
||||
this.profit = profit;
|
||||
}
|
||||
}
|
||||
|
||||
// Function to print the job sequence
|
||||
public static String findJobSequence(ArrayList<Job> jobs, int size) {
|
||||
Boolean[] slots = new Boolean[size];
|
||||
Arrays.fill(slots, false);
|
||||
|
||||
int result[] = new int[size];
|
||||
|
||||
// Iterate through jobs to find the optimal job sequence
|
||||
for (int i = 0; i < size; i++) {
|
||||
for (int j = jobs.get(i).deadline - 1; j >= 0; j--) {
|
||||
if (!slots[j]) {
|
||||
result[j] = i;
|
||||
slots[j] = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Create a StringBuilder to build the job sequence string
|
||||
StringBuilder jobSequenceBuilder = new StringBuilder();
|
||||
jobSequenceBuilder.append("Job Sequence: ");
|
||||
for (int i = 0; i < jobs.size(); i++) {
|
||||
if (slots[i]) {
|
||||
jobSequenceBuilder.append(jobs.get(result[i]).id).append(" -> ");
|
||||
}
|
||||
}
|
||||
|
||||
// Remove the trailing " -> " from the job sequence
|
||||
if (jobSequenceBuilder.length() >= 4) {
|
||||
jobSequenceBuilder.setLength(jobSequenceBuilder.length() - 4);
|
||||
}
|
||||
|
||||
// Return the job sequence as a string
|
||||
return jobSequenceBuilder.toString();
|
||||
}
|
||||
}
|
Reference in New Issue
Block a user