acm/acm2.cpp - diff

Return to acm2.cpp CVS log

Up to [RizwankCVS] / acm

Diff for /acm/acm2.cpp between version 1.3 and 1.12

version 1.3, 2005/02/16 07:19:57

version 1.12, 2005/02/16 10:27:53

Line 1

#include<stdlib.h>

#include<iostream>

#include<fstream>

#include<string>

#include <queue>

#include <stack>

#include <stdio.h>

// yes I could use just one i/o lib

using namespace std;

// As per specification, the project has to be able to grow to an

// arbitrary amount of items. MAX_ITEMS describes the size of the

Line 8

Line 16

// their parent object was in the priority queue, so static sized

// arrays were used

#define MAX_ITEMS 55

#define MAX_ITEMS 65536

//the above bound comes from the fixed value for the boolean array TODO REMOVE LIMITATION

typedef long ITEM_MASS;

typedef long INDEX_TYPE;

using namespace std;

Line 18

Line 31

// ******************************************************************

class item {

public:

float getRatio();

// float getRatio();

unsigned short getWeight();

ITEM_MASS getWeight();

unsigned short getCost();

ITEM_MASS getCost();

unsigned short getNumber();

// ITEM_MASS getNumber();

void setData(unsigned short,unsigned short,unsigned short);

void setData(ITEM_MASS);

private:

unsigned short weight;

ITEM_MASS weight;

unsigned short cost;

ITEM_MASS cost;

float ratio;

// float ratio;

unsigned short number;

// ITEM_MASS number;

};

// ******************************************************************

Line 53

Line 66

void addCurItem();

bool doneItems();

float getBound();

bool checkItem(unsigned short);

bool checkItem(INDEX_TYPE);

unsigned short getWeight();

ITEM_MASS getWeight();

unsigned short getValue();

ITEM_MASS getValue();

private:

void calcBound();

bool inserted[MAX_ITEMS];

unsigned short nextitem;

INDEX_TYPE nextitem;

unsigned short cur_weight;

ITEM_MASS cur_weight;

unsigned short cur_value;

ITEM_MASS cur_value;

float upper_bound;

backpack *myBackpack;

};

Line 72

Line 85

// ******************************************************************

struct item_comparator {

bool operator()( item left, item right ) const

{ return ( left.getRatio() < right.getRatio() ) ; }

// { return ( left.getRatio() < right.getRatio() ) ; }

{ return 0 ; } //same ratio to all, don't actually do a compare!

} ;

// ******************************************************************

Line 90

Line 104

// ******************************************************************

class backpack {

public:

void initBackpack(unsigned short, unsigned short);

void initBackpack(INDEX_TYPE, ITEM_MASS);

void putItem(unsigned short, unsigned short);

void putItem(ITEM_MASS);//, ITEM_MASS);

void store_item_array();

void branch_and_bound();

void branch_and_bound(int,ITEM_MASS);

unsigned short get_totalItems();

ITEM_MASS get_totalItems();

unsigned short get_maxWeight();

ITEM_MASS get_maxWeight();

item get_Item(unsigned short);

item get_Item(INDEX_TYPE);

private:

priority_queue< item, vector<item> , item_comparator> item_queue;

item *item_array;

priority_queue< key, vector<key>, key_comparator> key_queue;

unsigned short totalItems;

INDEX_TYPE totalItems;

unsigned short maxWeight;

ITEM_MASS maxWeight;

long addnodeCount, worknodeCount;

};

Line 175

Line 189

}

else {

temp = (float)((this->myBackpack->get_maxWeight()) - cur_weight);

temp = temp * (this->myBackpack->get_Item(this->nextitem)).getRatio();

// temp = temp * (this->myBackpack->get_Item(this->nextitem)).getRatio(); (ratio = 1!)

}

this->upper_bound = cur_value + temp;

Line 190

Line 204

// * FUNCTION : checkItem IN : CLASS key *

// * Checks if a given item is listed as inserted. *

// ******************************************************************

bool key::checkItem(unsigned short num) {

bool key::checkItem(INDEX_TYPE num) {

return (this->inserted[num]);

}

Line 198

Line 212

// * FUNCTION : getValue IN : CLASS key *

// * Gets the Value of the current key. *

// ******************************************************************

unsigned short key::getValue(){

ITEM_MASS key::getValue(){

return this->cur_value;

}

Line 206

Line 220

// * FUNCTION : getWeight IN : CLASS key *

// * Gets the Weight of the current key. *

// ******************************************************************

unsigned short key::getWeight(){

ITEM_MASS key::getWeight(){

return this->cur_weight;

}

Line 214

Line 228

// * FUNCTION : getRatio IN : CLASS item *

// * Gets the Ratio for the current item. *

// ******************************************************************

float item::getRatio(){

//float item::getRatio(){

return ratio;

// return ratio;

}

//}

// ******************************************************************

// * FUNCTION : getWeight IN : CLASS item *

// * Gets the Weight of the current item. *

// ******************************************************************

unsigned short item::getWeight(){

ITEM_MASS item::getWeight(){

return this->weight;

}

Line 230

Line 244

// * FUNCTION : getCost IN : CLASS item *

// * Gets the Value of the current item. *

// ******************************************************************

unsigned short item::getCost(){

ITEM_MASS item::getCost(){

return this->cost;

}

Line 238

Line 252

// * FUNCTION : getNumber IN : CLASS item *

// * Gets the Index of the current item. *

// ******************************************************************

unsigned short item::getNumber(){

//ITEM_MASS item::getNumber(){

return this->number;

// return this->number;

}

//}

// ******************************************************************

// * FUNCTION : setData IN : CLASS item *

// * Sets all the data for an item. *

// ******************************************************************

void item::setData(unsigned short weightage, unsigned short costage, unsigned short numerage){

void item::setData(ITEM_MASS weightage){ //, ITEM_MASS costage, ITEM_MASS numerage){

this->cost = costage;

this->cost = weightage; //costage;

this->weight = weightage;

this->ratio = ( (float)(cost)/(float)(weight) );

// this->ratio = ( (float)(cost)/(float)(weight) );

this->number = numerage;

// this->ratio = 1; //ratio = 1

// this->number = numerage;

}

Line 258

Line 273

// * FUNCTION : initBackpack IN : CLASS backpack *

// * Initalizes the backpack values and creates the item array *

// ******************************************************************

void backpack::initBackpack(unsigned short total, unsigned short max){

void backpack::initBackpack(INDEX_TYPE total, ITEM_MASS max){

this->totalItems = total;

this->maxWeight = max;

item_array = new item[total];

Line 270

Line 285

// * FUNCTION : putItem IN : CLASS backpack *

// * Creates an item and places it into the priority queue *

// ******************************************************************

void backpack::putItem(unsigned short weight, unsigned short cost){

void backpack::putItem(ITEM_MASS weight){ //, ITEM_MASS cost){

item temp_item;

temp_item.setData(weight,cost,(int)(this->item_queue.size())+1);

temp_item.setData(weight);//,cost);//,(int)(this->item_queue.size())+1); // sometimes this starts at 2000?

this->item_queue.push(temp_item);

}

Line 292

Line 307

// * FUNCTION : get_totalItems IN : CLASS backpack *

// * Returns the number of items for consideration. *

// ******************************************************************

unsigned short backpack::get_totalItems(){

ITEM_MASS backpack::get_totalItems(){

return this->totalItems;

}

Line 300

Line 315

// * FUNCTION : get_maxWeight IN : CLASS backpack *

// * Returns the maximum weight for this backpack. *

// ******************************************************************

unsigned short backpack::get_maxWeight(){

ITEM_MASS backpack::get_maxWeight(){

return this->maxWeight;

}

Line 308

Line 323

// * FUNCTION : get_Item IN : CLASS backpack *

// * Returns a particular item from the item array *

// ******************************************************************

item backpack::get_Item(unsigned short index){

item backpack::get_Item(INDEX_TYPE index){

return ( this->item_array[index] );

}

Line 329

Line 344

// * possible solution for this knapsack. *

// * Fetch all the information and print it out. *

// ******************************************************************

void backpack::branch_and_bound(){

void backpack::branch_and_bound(int DEBUG_MODE, ITEM_MASS targetvalue){

key temp_key;

temp_key.initKey(this);

Line 360

Line 375

while (onwards);

if (DEBUG_MODE) {

printf("Case n=%2d Total possible nodes in thie state space tree is 2^%2d-1\n",this->totalItems,this->totalItems);

printf(" Number of nodes placed in the priority queue: %6d\n",this->addnodeCount);

printf(" Number of nodes examined/split: %6d\n",this->worknodeCount);

/* printf("\nObjects Chosen \n");

printf("\t\tWeights\tValues\n");

int totalitemsinserted = 0;

for (int i = 0; this->totalItems > i; i++) {

if ( temp_key.checkItem(i) ) {

printf("\t\t%4.2f\t%4.2f\n", this->item_array[i].getWeight(), this->item_array[i].getCost());

totalitemsinserted++; // this->item_array[i].getNumber(), removed

}

printf("======================================================\n");

printf("Totals:\t%3d\t%4.2f\t%4.2f\n",totalitemsinserted, temp_key.getWeight(), temp_key.getValue());

// printf("Ratio : %2.5f\n", ((float)temp_key.getValue()/(float)temp_key.getWeight())); */

}

printf("\nObjects Chosen \n");

printf(" Objects Weights Values\n");

if ( temp_key.getWeight() == targetvalue ) {

int totalitemsinserted = 0;

int first=1;

for (int i = 0; this->totalItems > i; i++) {

if ( temp_key.checkItem(i) ) {

printf(" %2d %2d %2d\n", this->item_array[i].getNumber(), this->item_array[i].getWeight(), this->item_array[i].getCost());

if (first==0) { printf(","); }

totalitemsinserted++;

else {first = 0;} // there has GOT to be a better way!

printf("%d", this->item_array[i].getWeight());

}

printf("======================================================\n");

}

printf("Totals: %2d %2d %2d\n",totalitemsinserted, temp_key.getWeight(), temp_key.getValue());

else { printf("CANNOT FILL PALLET\n"); }

printf("Ratio : %2.5f\n", ((float)temp_key.getValue()/(float)temp_key.getWeight()));

}

// have to deal with non int #s

int intcomp (const void * a, const void * b)

{

return ( *(int*)a - *(int*)b );

}*/

void syntaxmsg(){

printf("Usage:\n");

printf("<program name> <input filename> <D/d>\n");

printf("input contains a series of integers [A], comma delimited,\n\t followed by a CR and an int [B]\n");

printf("program outputs a comma delimited list of elements of A that sum to B,\n\t or CANNOT FILL PALLET\n");

printf("Program written for the UCLA ACM Feb 2005 Coding Competition\n");

printf("If the second argument is a D or d, verbose debugging mode will be enabled\n\n");

return;

}

// ******************************************************************

Line 390

Line 437

int main(int argc, char *argv[])

{

item temp_item;

printf("CS331_Project 4, by Rizwan Kassim.\n");

int DEBUG_MODE = 0;

printf("Version 3\n");

printf("All compiled / source code are (C) Rizwan Kassim 2003\n\n");

if ( argc < 2 ) { syntaxmsg(); return 2;}

if ( argc > 4 ) { syntaxmsg(); return 3;}

if ( argc == 3 ) {

if ( argv[2][0] == 'D' || argv[2][0] == 'd' ) {

printf("Debug switch caught, outputing debug messages\n");

DEBUG_MODE =1;

} else { syntaxmsg(); return 4;}

}

printf("============================ KNAPSACK ONE ================================\n");

if (DEBUG_MODE) {

backpack knapsackOne;

printf("Entry into UCLA ACM Feb. 2005 Coding Competition\n");

printf("Based on code developed (myself) for CS331 Project 4 at CSU Pomona\n");

printf("Version 4\n");

printf("All compiled / source code are (C) Rizwan Kassim 2005\n\n");

}

knapsackOne.initBackpack(25,200); // 5 total items, 17 total weight

knapsackOne.putitem(70,70);

INDEX_TYPE max_inventory;

knapsackOne.putitem(76,76);

knapsackOne.putitem(55,55);

knapsackOne.putitem(17,17);

knapsackOne.putitem(70,70);

knapsackOne.putitem(77,77);

knapsackOne.putitem(52,52);

knapsackOne.putitem(81,81);

knapsackOne.putitem(11,11);

knapsackOne.putitem(31,31);

knapsackOne.putitem(57,57);

knapsackOne.putitem(47,47);

knapsackOne.putitem(93,93);

knapsackOne.putitem(53,53);

knapsackOne.putitem(83,83);

knapsackOne.putitem(33,33);

knapsackOne.putitem(1,1);

knapsackOne.putitem(59,59);

knapsackOne.putitem(29,29);

knapsackOne.putitem(33,33);

knapsackOne.putitem(78,78);

knapsackOne.putitem(79,79);

knapsackOne.putitem(37,37);

knapsackOne.putitem(26,26);

knapsackOne.putitem(83,83);

ifstream inputfs;

inputfs.open (argv[1]);

if (!inputfs.is_open())

{ printf("File open of %s failed!\n", argv[1]);

syntaxmsg();

return 1; }

if (DEBUG_MODE) {

printf("File %s Open!\n",argv[1]);

}

knapsackOne.store_item_array();

INDEX_TYPE length;

inputfs.seekg (0, ios::end);

length = inputfs.tellg();

inputfs.seekg (0, ios::beg);

max_inventory= 1 + length/2; // Elements cannot be more than this amount

char * read_buffer = (char *) malloc (length);

ITEM_MASS * inventory = (ITEM_MASS *) malloc (length);

// could use stack instead of array --- doesn't require malloc, more 'safe' avoids overflows, esp if

// input file is funky --- its better software engineering, but its slower. Given that this is a pretty

// small system, I'll stick with the array

inputfs.getline (read_buffer, length-1);

for ( int i = 0; knapsackOne.get_totalItems() > i; i++){

char * theToken; INDEX_TYPE index = 0;

temp_item=knapsackOne.get_Item(i);

theToken=strtok(read_buffer,",");

printf("Item Number %2d : %2d cost for %2d weight at ratio %2.3f\n", temp_item.getNumber(), temp_item.getCost(), temp_item.getWeight(), temp_item.getRatio());

// assume 1+ items

while ( theToken != NULL ) {

//printf("tokendebug %d %f\n",theToken,theToken);

inventory[index] = atol(theToken);

//printf("index %d, token %s, value %d\n",index,theToken,inventory[index]);

index++;

theToken = strtok (NULL,",");

}

printf("\n");

knapsackOne.branch_and_bound();

INDEX_TYPE size_inventory = index; //remember this is 1 based, not 0

int SUPER_MODE = 0;

if (inventory[0]==1) { SUPER_MODE=0;}

if (DEBUG_MODE) {

printf("Line 1 read - %d products from warehouse\n", size_inventory);

if (SUPER_MODE) printf("Working in Superincreasing mode!\n");

}

// qsort ( inventory, size_inventory, sizeof(int), intcomp); // we now have a sorted list

// NEED TRY/CATCH error handling for possible segfault locations

inputfs.getline (read_buffer, length-1);

ITEM_MASS palette_size=atoi(read_buffer);

if (DEBUG_MODE) {

printf("Line 2 read - %d weight units can fit onto palette\n",palette_size);

}

inputfs.close();

free(read_buffer);

// ckeanup, release memeory, close files here

// I could use a class to extrapolate out the file loading function like my 499 project....

backpack knapsackOne;

knapsackOne.initBackpack(size_inventory,palette_size);

if (DEBUG_MODE) {

printf("init %d, %d\n",size_inventory,palette_size);

}

for ( INDEX_TYPE store_index=0; size_inventory>store_index;store_index++ ) {

knapsackOne.putItem(inventory[store_index]);

if (DEBUG_MODE) {

printf("insert %d\n",inventory[store_index]);

}

knapsackOne.store_item_array();

free(inventory);

knapsackOne.branch_and_bound(DEBUG_MODE,palette_size);

printf("\n");

}

void super ( ITEM_MASS target_value , INDEX_TYPE size_inventory, int DEBUG_MODE ) {

// input, a super increasing set, lowest to highest.

// the number of elements in the list [1-ordinal]

// a target value.

//debugmode

// need to output values that sum to target

// need another place to store. --- not another array, need LIFO structure. A stack of course.

// we have to count downwards during super increasing, or we could qsort the list. (not going to do that)

stack<ITEM_MASS> packages_to_load;

if (DEBUG_MODE) {

printf("Extracting values, highest to lowest, doing reduction\n");

}

for ( INDEX_TYPE store_index=size_inventory-1; size_inventory<=0;store_index-- ) {

if (DEBUG_MODE) {

printf("value %d, is it smaller than %d? If so, subtract and store.\n",inventory[store_index],target_value);

}

if ( inventory[store_index] <= target_value ) {

target_value = target_value - inventory[store_index];

packages_to_load.push(inventory[store_index]);

}

if ( target_value == 0 ) {

int first = 1;

while ( ! packages_to_load.empty() ) {

if (first==0) { printf(","); }

else {first = 0;} // there has GOT to be a better way!

printf("%d",packages_to_load.top());

packages_to_load.pop();

}

else { printf("CANNOT FILL PALLET\n"); }

}

Modifications to the original branch-and-bound algorithim/approach

Line 471

Line 616

And lets try with a random set of 25 numbers!

70,76,55,17,70,77,52,81,11,31,57,47,93,53,83,33,1,59,29,33,78,79,37,26,83 ==> 200

Chose:

1 70 70

3 55 55

24 26 26

23 37 37

17 1 1

9 11 11

2^25-1 worst case, 142 nodes, 115 split!

real 0m0.036s

user 0m0.030s

sys 0m0.030s

then 50:

186,130,132,108,112,39,90,88,105,172,50,46,125,79,22,192,139,132,77,195,21,129,134,76,179,89,32,55,61,160,49,191,153,86,45,16,196,109,1,178,51,104,40,88,135,100,108,182,30,48 => 1470

2^50 worst case, 1826 nodes, 1443 splits

real 0m0.044s

user 0m0.062s

sys 0m0.000s

Now, lets really ramp it up so that we can see optimzation effects

n=2500! won't even care to list the numbers, no point!

Wait, we exceeded 3 minutes there (our weight size was just a guess, btw, might not actually ahve a value)

Oh, our memory bound was maxed out so it hit a loop ... it actually completed in less than a sec! God bless my processor :)

Lets bump it up to 5k,

Case n=5000 Total possible nodes in thie state space tree is 2^5000-1

Number of nodes placed in the priority queue: 35037

Number of nodes examined/split: 34942

real 0m2.810s

user 0m1.843s

sys 0m0.062s

Given that this is about the largest we can hope to achieve before INTMAX because a massive issue (we should really typedefine the container class), lets see what optimizations we can make to this code!

must do 1 -

move all the ITEM_MASSs to (other)

the ITEM_MASSs are now ITEM_TYPE, a def earlier on (we could have done typedef here too, of course)

real 0m2.928s

user 0m1.999s

sys 0m0.061s

Slight increase.

Bad things happen when we try to make it into floats, I just tired. floats can't be [] contents for an array ;p

Doing unsigned long for now.

goal 1 = stop ratio calculation and comparisons if at all possible!

real time shot up!

real 0m3.994s

user 0m2.390s

sys 0m0.046s

(that being said, timse don't seem to be consistent. CVS is storing our versions, lets plow on)

remove the comparator in the structcomparator

real 0m2.830s

user 0m2.030s

sys 0m0.015s

remove the printout of the items as inserted

real 0m1.423s

user 0m1.436s

sys 0m0.015s

remove the tracking of the item "number", we don't need to deal with it with this project.

after moved all unsigned ints to typedefs,

typedef float ITEM_MASS;

typedef long INDEX_TYPE;

and modified the printfs to handle floating !

real 0m1.591s

user 0m1.562s

sys 0m0.000s

inserting a float does :

acm2.cpp: In function `int main(int, char**)':

acm2.cpp:410: error: no matching function for call to `backpack::putItem(

double, int, int)'

acm2.cpp:279: error: candidates are: void backpack::putItem(float, float)

make: *** [acm2] Error 1

(and it locks up if we have a decimal in seeked value)

ok we move onwards to remove weight,value calls and replace them with just weight

we also use notepad/sed to remove half the sample knapsack calls

we realize in doing this that we've actually got 7009 elements! modifiying appropraite values!

real 0m2.627s

user 0m2.624s

sys 0m0.000s

but now it uses all 17.

Lets try an appropriately high value instead of the 50000ish we're using now. Lets say, we want ...

600 elements of 7000, at avg value of 5000 3000000ish?

Case n=6998 Total possible nodes in thie state space tree is 2^6998-1

Number of nodes placed in the priority queue: 70797

Number of nodes examined/split: 69811

Totals: 114 509283.00 509283.00

then...

============================ KNAPSACK ONE ================================

Case n=6998 Total possible nodes in thie state space tree is 2^6998-1

Number of nodes placed in the priority queue: 108848

Number of nodes examined/split: 96391

Totals: 1002 5091283.00 5091283.00

real 0m9.526s

user 0m9.249s

sys 0m0.203s

I'm actually pretty happy with this. We havent tested a few conditions, but its time we got the file loading routine in

todo

1) when it doesnt work

2) when its already reached stop

3) float

For superincreasing sets, its INCREDIBLY easy to do

Sort it.

if (current value < pallete size), palletsize-current value, current_value on board.

repeat until end

=== loading file now

make input float ok

reverted to base type of non float --- making the stored value float did badthings to atoi / atof (they didnt work)

we could really move the pqueue to a queue --- although don't we want to push bigger items to the top to fill it up faster?

goal 1 - lets remove the double call to the creator function, weight=value ratio=1

Legend:

Removed from v.1.3
changed lines
	Added in v.1.12

Rizwan Kassim