Lineáris programozás segítségével egyszeri módszer az étrend problémájának megoldására adott ételek halmazával

# include algoritmus>

# include iostream>

# include vektor>

# include cstdio>

# include cassert>

névtér használata std;

typedef double ElementType;

typedef vektor> mátrix;

const int NO_MEGOLDÁS = - 1;

const int BOUNDED_SOLUTION = 0;

const int INFINITY_SOLUTION = 1;

const ElementType C_THRESHOLD = 0,0000001;

const ElementType DELTA_RATIO_THRESHOLD = 0; 0,0001;

const ElementType DELTA_COMPARE_EPSILON = 0,0000001;

// megvalósítja a CLRS PIVOT-ját

void pivot (

vektor int> & nonbasics,

vektor int> & alapok,

mátrix & A,

vektor & b,

vektor stb,

ElementType & v,

int l,

int e)

// a CLRS-ben ez N -

vektor int> egyébNem alapok;

for (int n: nem alapismeretek)

ha (n! = e)

egyébNonbasics. visszalépés (n);

// az e & l változók megadják a belépő és kilépő változók indexeit, de

// nem azonosak az A sorban feldolgozandó sorral. A row_l biztosítja ezt a leképezést

// (más néven, az A sora, amely jelenleg az x [l] alapváltozót képviseli)

int sor_l = - 1;

for (méret_t i = 0; i méret (); ++ i)

if (alapok [i] == l)

sor_l = i;

szünet;

// kiszámítja az x [e] új alapváltozó egyenletének együtthatóit.

// más szóval, megoldjuk x [e] -re az l által indexelt kényszert.

// ehhez a korlátozást úgy méretezzük, hogy elosztjuk A [l] [e] -vel, amely meghatározza az együtthatót

// A-ban az l korlátozásban x [e] esetén 1,0-ig, és hatékonyan megoldja azt

b [row_l] = b [row_l]/A [row_l] [e];

for (int j: egyéb alapismeretek)

A [row_l] [j] = A [row_l] [j]/A [row_l] [e];

A [sor_l] [l] = 1,0/A [sor_l] [e];

A [sor_l] [e] = 0,0;

// kiszámítja a fennmaradó korlátok együtthatóit.

// Valójában ez frissíti az l által nem indexelt korlátozásokat

// úgy, hogy az x [e] egyenlet RHS-jét minden korlátba behelyettesítjük

// x [e] minden előfordulásakor

for (méret_t i = 0; i méret (); ++ i)

ha (i == sor_l)

folytatni;

b [i] - = A [i] [e] * b [sor_l];

for (int j: egyéb alapismeretek)

A [i] [j] - = A [i] [e] * A [sor_l] [j];

A [i] [l] = -A [i] [e] * A [sor_l] [l];

A [i] [e] = 0,0;

// kiszámítja az objektív függvényt

// az l korlátozás helyettesítésével (megoldva x [e] -re)

v + = c [e] * b [sor_l];

for (int j: egyéb alapismeretek)

c [j] - = c [e] * A [sor_l] [j];

c [l] = -c [e] * A [sor_l] [l];

c [e] = 0,0;

// az e & l felcserélésével kiszámítja az alapvető és nem alapvető változók új halmazait

for (méret_t n = 0; n méret (); ++ n)

if (nem alapok [n] == e)

nem alapok [n] = l;

szünet;

for (méret_t n = 0; n méret (); ++ n)

if (alapok [n] == l)

alapok [n] = e;

szünet;

Visszatérés;

typedef struct SlackForm

vektor int> nem alapok, alapok;

A mátrix;

b, c vektor;

ElementType v;

> SlackForm;

sablon typename T>

std: ostream és operátor const vektor & v)

ki " < ";

for (méret_t i = 0; i méret (); ++ i)

ki, ha (i! = v. méret () - 1)

ki ",";

ki ">";

visszatérés;

std: ostream & operátor "N =" nem alapok "B =" alapok "A = < ";

for (vektor és sor: s. A)

ki ">" "b =" b "c =" c "v =" v tér vissza;

pár int, vektor> SimplexIterations (SlackForm & slack)

vektor int>

& nonbasics = laza. nem alapismeretek,

& alapok = laza. alapok;

mátrix & A = laza. A;

vektor

& b = laza. b,

& c = laza. c;

ElementType & v = laza. v;

// ez megvalósítja a CLRS SIMPLEX 2–17. sorát

vektor delta (alapok. méret (), std: numeric_limits: végtelen ());

for (vektor: iterátor j = std: max_element (c. kezdet (), c. end ());

* j> C_THRESHOLD;

j = std: max_element (c. kezdet (), c. vég ()))

int e = std: távolság (c. kezdődik (), j);

// válassza az l értéket, a változó indexét, amely a kilépő változó lesz.

// ezt úgy teheti meg, hogy megnézi, melyik korlátozás engedélyezi a legnagyobb értéket

// x [e], miközben nem sérti az x negatív jellegű korlátozásait

for (méret_t i = 0; i méret (); ++ i)

delta [i] = (A [i] [e]> DELTA_RATIO_THRESHOLD)? b [i]/A [i] [e]: std: numerikus_korlátok: végtelen ();

// most keresse meg a "legkisebb" deltát, de van egy fudge tényező a "kapcsolatok" számára. Ha delta [i] =

Jelenleg nem hajthatja végre ezt a műveletet.

Egy másik füllel vagy ablakkal jelentkezett be. Töltse be újra a munkamenet frissítéséhez. Kijelentkezett egy másik fülön vagy ablakban. Töltse be újra a munkamenet frissítéséhez.