Problem 1: Optimal File Merge Patterns

#include <stdio.h>

#include <stdlib.h>

struct Node {

int weight;

};

struct MinHeap {

int size;

int capacity;

struct Node* array;

};

struct Node* newNode(int weight) {

struct Node* node = (struct Node*)malloc(sizeof(struct Node));

node->weight = weight;

return node;

struct MinHeap* createMinHeap(int capacity) {

struct MinHeap* minHeap = (struct MinHeap*)malloc(sizeof(struct MinHeap));

minHeap->size = 0;

minHeap->capacity = capacity;

minHeap->array = (struct Node*)malloc(capacity * sizeof(struct Node));

return minHeap;

}
void swapNodes(struct Node** a, struct Node** b) {

struct Node* temp = *a;

*a = *b;

*b = temp;

void minHeapify(struct MinHeap* minHeap, int idx) {

int smallest = idx, left = 2 * idx + 1, right = 2 * idx + 2;

if (left < minHeap->size && minHeap->array[left].weight < minHeap->array[smallest].weight)

smallest = left;

if (right < minHeap->size && minHeap->array[right].weight < minHeap->array[smallest].weight)

smallest = right;

if (smallest != idx) {

swapNodes(&minHeap->array[idx], &minHeap->array[smallest]);

minHeapify(minHeap, smallest);

void insertMinHeap(struct MinHeap* minHeap, struct Node* node) {

++minHeap->size;

int i = minHeap->size - 1;

while (i > 0 && node->weight < minHeap->array[(i - 1) / 2].weight) {

minHeap->array[i] = minHeap->array[(i - 1) / 2];

i = (i - 1) / 2;

minHeap->array[i] = *node;
}

struct Node* extractMin(struct MinHeap* minHeap) {

struct Node* temp = &minHeap->array[0];

minHeap->array[0] = minHeap->array[minHeap->size - 1];

--minHeap->size;

minHeapify(minHeap, 0);

return temp;

int optimalMerge(int size[], int n) {

struct MinHeap* minHeap = createMinHeap(n);

for (int i = 0; i < n; ++i)

insertMinHeap(minHeap, newNode(size[i]));

int count = 0;

while (minHeap->size > 1) {

struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));

newNode->weight = extractMin(minHeap)->weight + extractMin(minHeap)->weight;

count += newNode->weight;

insertMinHeap(minHeap, newNode);

return count;

int main() {
 int size[] = {2, 3, 4, 5, 6, 7};

int n = sizeof(size) / sizeof(size[0]);

int result = optimalMerge(size, n);

printf("%d\n", result);

return 0;

Problem 2: The Knapsack Problem

#include <stdio.h>

#include <stdlib.h>

struct Item {

int value, weight;

};

int cmp(const void* a, const void* b) {

double r1 = (double)(((struct Item*)b)->value) / (((struct Item*)b)->weight);

double r2 = (double)(((struct Item*)a)->value) / (((struct Item*)a)->weight);

return r1 > r2 ? 1 : -1;

double fractionalKnapsack(int W, struct Item arr[], int n) {

qsort(arr, n, sizeof(struct Item), cmp);

int curWeight = 0;

double finalValue = 0.0;

for (int i = 0; i < n; i++) {

 if (curWeight + arr[i].weight <= W) {

curWeight += arr[i].weight;

finalValue += arr[i].value;

} else {

int remain = W - curWeight;

finalValue += arr[i].value * ((double)remain / arr[i].weight);

break;

return finalValue;

int main() {

int W = 50;

struct Item arr[] = {{60, 10}, {100, 20}, {120, 30}};

int n = sizeof(arr) / sizeof(arr[0]);

printf("%.2f\n", fractionalKnapsack(W, arr, n));

return 0;