Programma C++ per il problema dello zaino frazionario - GeeksforGeeks

Blog

Prerequisito: Problema dello zaino frazionario



Dato due array il peso[] e profitto[] il pesi e profitto di n oggetti, dobbiamo mettere questi oggetti in uno zaino di capacità IN prendere il massimo valore totale nello zaino.

Nota: A differenza dello zaino 0/1, puoi rompere l'oggetto.



Esempi:

_Inserimento: _ peso[] = {10, 20, 30}, profitto[] = {60, 100, 120}, N= 50



l'app cash non mi permette di inviare denaro

_Produzione: _ Guadagno massimo guadagnato = 240

_Spiegazione: _

Rapporto p/w decrescente[] = {6, 5, 4}

_Riprendendo i valori di peso 10, 20, (2 / 3) * 30 _

Profitto = 60 + 100 + 120 * (2 / 3) = 240

_Inserimento: _ peso[] = {10, 40, 20, 24}, profitto[] = {100, 280, 120, 120}, N = 60

_Produzione: _ Massimo profitto guadagnato = 440

Spiegazione:

Rapporto p/w decrescente[] = {10, 7, 6, 5}

_Riprendendo i valori di peso 10, 40, (1 / 2) * 120 _

Profitto = 100 + 280 + (1 / 2) * 120 = 440

Metodo 1 – senza usare STL : L'idea è di usare Approccio avido . Di seguito sono riportati i passaggi:

  1. Trova il rapporto valore/peso per ogni articolo e ordinare la voce sulla base di tale rapporto.
  2. Scegli l'elemento con il rapporto più alto e aggiungili fino a quando non possiamo aggiungere l'elemento successivo nel suo insieme.
  3. Alla fine, aggiungi l'elemento successivo il più possibile.
  4. Stampa il profitto massimo dopo i passaggi precedenti.

Di seguito è riportata l'implementazione dell'approccio di cui sopra:

C++

filter_none

modificare

play_arrow

luminosità_4

// C++ program to solve fractional

// Knapsack Problem

#include

**using** **namespace** std;

// Structure for an item which stores

// weight & corresponding value of Item

**struct** Item {

**int** value, weight;

// Constructor

Item(``**int** value, **int** weight)

: value(value), weight(weight)

{

}

};

// Comparison function to sort Item

// according to val/weight ratio

**bool** cmp(``**struct** Item a, **struct** Item b)

{

**double** r1 = (``**double**``)a.value / a.weight;

la volpe di fuoco non si apre

**double** r2 = (``**double**``)b.value / b.weight;

**return** r1 > r2;

}

// Main greedy function to solve problem

**double** fractionalKnapsack(``**struct** Item arr[],

**int** N, **int** size)

{

// Sort Item on basis of ratio

sort(arr, arr + size, cmp);

// Current weight in knapsack

generatore di pattern di sfondo css

**int** curWeight = 0;

// Result (value in Knapsack)

**double** finalvalue = 0.0;

// Looping through all Items

**for** (``**int** i = 0; i

// If adding Item won't overflow,

// add it completely

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

curWeight += arr[i].weight;

finalvalue += arr[i].value;

}

// If we can't add current Item,

// add fractional part of it

**else** {

**int** remain = N - curWeight;

finalvalue += arr[i].value

* ((``**double**``)remain

/ arr[i].weight);

**break**``;

}

}

// Returning final value

**return** finalvalue;

}

// Driver Code

**int** main()

{

// Weight of knapsack

**int** N = 60;

// Given weights and values as a pairs

Item arr[] = { { 100, 10 },

nodo js richiesta ajax

{ 280, 40 },

{ 120, 20 },

{ 120, 24 } };

**int** size = **sizeof**``(arr) / **sizeof**``(arr[0]);

// Function Call

cout << 'Maximum profit earned = '

<< fractionalKnapsack(arr, N, size);

**return** 0;

}

#programmi c++ #programmazione competitiva #greedy #fraction #greedy algoritmi #knapsack #stl

www.geeksforgeeks.org

Programma C++ per il problema dello zaino frazionario - GeeksforGeeks

Un portale di informatica per geek. Contiene articoli di informatica e programmazione ben scritti, ben pensati e ben spiegati, quiz e pratiche/competitivi.