C ++ - program vir die fraksionele rugsakprobleem - GeeksforGeeks

Blog

Voorvereiste: Fraksionele rugsakprobleem



Gegee twee skikkings gewig [] en wins [] die gewigte en wins van N. items, moet ons hierdie items in 'n rugsak hou IN die te kry maksimum totale waarde in die rugsak.

Let wel: Anders as 0/1 rugsak, mag u die item breek.



Voorbeelde:

_Invoer: _ gewig [] = {10, 20, 30}, wins [] = {60, 100, 120}, N = 50



hoe u sonder 'n telefoonnommer in die kontant -app -rekening kan inskakel

_Uitvoer: _ Maksimum wins verdien = 240

_ Verduideliking: _

Afnemende p/w -verhouding [] = {6, 5, 4}

_ Opneem van die gewigwaardes 10, 20, (2/3) * 30 _

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

_Invoer: _ gewig [] = {10, 40, 20, 24}, wins [] = {100, 280, 120, 120}, N = 60

_Uitvoer: _ Maksimum wins verdien = 440

Verduideliking:

Afnemende p/w -verhouding [] = {10, 7, 6, 5}

_ Opname van die gewigwaardes 10, 40, (1/2) * 120 _

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

Metode 1 - sonder om te gebruik STL : Die idee is om te gebruik Gulsige benadering . Hieronder is die stappe:

  1. Vind die verhouding waarde/gewig vir elke item en sorteer die item op grond van hierdie verhouding.
  2. Kies die item met die hoogste verhouding en voeg dit by totdat ons nie die volgende item in sy geheel kan byvoeg nie.
  3. Voeg uiteindelik die volgende item soveel as moontlik by.
  4. Druk die maksimum wins uit na die bogenoemde stappe.

Hieronder is die implementering van bogenoemde benadering:

C ++

filter_nie

wysig

play_arrow

helderheid_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;

dataverwerking in python

**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

jupyter notaboek cheat sheet

**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 },

ag-rooster ry styl

{ 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;

}

#c ++ programme #mededingende programmering #gulsige #breuk #gulsige algoritmes #rugsak #stl

www.geeksforgeeks.org

C ++ - program vir die fraksionele rugsakprobleem - GeeksforGeeks

'N Rekenaarwetenskap -portaal vir geeks. Dit bevat goedgeskrewe, deurdagte en goed uiteengesit rekenaarwetenskaplike en programmeringsartikels, vasvrae en oefening/mededingend.