(file) Return to acm2.cpp CVS log (file) (dir) Up to [RizwankCVS] / acm

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

version 1.12, 2005/02/16 10:27:53 version 1.14, 2005/02/16 21:17:10
Line 4 
Line 4 
 #include<string> #include<string>
 #include <queue> #include <queue>
 #include <stack> #include <stack>
   #include <vector>
 #include <stdio.h> #include <stdio.h>
 // yes I could use just one i/o lib // yes I could use just one i/o lib
 using namespace std; using namespace std;
Line 19 
Line 20 
 #define MAX_ITEMS 65536 #define MAX_ITEMS 65536
 //the above bound comes from the fixed value for the boolean array TODO REMOVE LIMITATION //the above bound comes from the fixed value for the boolean array TODO REMOVE LIMITATION
  
   #define EARLYSKIP
   
 typedef long ITEM_MASS; typedef long ITEM_MASS;
 typedef long INDEX_TYPE; typedef long INDEX_TYPE;
  
Line 33 
Line 36 
 public: public:
 //      float getRatio(); //      float getRatio();
         ITEM_MASS getWeight();         ITEM_MASS getWeight();
     ITEM_MASS getCost();  
 //      ITEM_MASS getNumber(); //      ITEM_MASS getNumber();
         void setData(ITEM_MASS);         void setData(ITEM_MASS);
 private: private:
         ITEM_MASS weight;         ITEM_MASS weight;
         ITEM_MASS cost;  
 //      float ratio; //      float ratio;
 //      ITEM_MASS number; //      ITEM_MASS number;
 }; };
Line 68 
Line 69 
         float getBound();         float getBound();
         bool checkItem(INDEX_TYPE);         bool checkItem(INDEX_TYPE);
         ITEM_MASS getWeight();         ITEM_MASS getWeight();
         ITEM_MASS getValue();          void makeDone();
 private: private:
         void calcBound();         void calcBound();
         bool inserted[MAX_ITEMS];         bool inserted[MAX_ITEMS];
         INDEX_TYPE nextitem;         INDEX_TYPE nextitem;
         ITEM_MASS cur_weight;         ITEM_MASS cur_weight;
         ITEM_MASS cur_value;  
         float upper_bound;         float upper_bound;
         backpack *myBackpack;         backpack *myBackpack;
 }; };
Line 131 
Line 131 
         this->myBackpack = theCaller;         this->myBackpack = theCaller;
         this->nextitem=0;         this->nextitem=0;
         this->cur_weight=0;         this->cur_weight=0;
         this->cur_value=0;  
         this->calcBound();         this->calcBound();
           for ( int i = 0; MAX_ITEMS > i; i++) {
                   this->inserted[i] = 0;
           }
 } }
  
 // ****************************************************************** // ******************************************************************
Line 154 
Line 156 
 void key::addCurItem(){ void key::addCurItem(){
         nextitem--;         nextitem--;
         this->inserted[this->nextitem]=1;         this->inserted[this->nextitem]=1;
         this->cur_value  += (this->myBackpack->get_Item(this->nextitem)).getCost();  
         this->cur_weight += (this->myBackpack->get_Item(this->nextitem)).getWeight();         this->cur_weight += (this->myBackpack->get_Item(this->nextitem)).getWeight();
         nextitem++;         nextitem++;
         this->calcBound();         this->calcBound();
Line 168 
Line 169 
         return ( this->myBackpack->get_totalItems() == this->nextitem );         return ( this->myBackpack->get_totalItems() == this->nextitem );
 } }
  
   void key::makeDone(){
           this->nextitem = this->myBackpack->get_totalItems();
   }
   
 // ****************************************************************** // ******************************************************************
 // * FUNCTION : getBound                IN : CLASS key                                          * // * FUNCTION : getBound                IN : CLASS key                                          *
 // * Returns the bound.                                                                                         * // * Returns the bound.                                                                                         *
Line 183 
Line 188 
 // * If the weight is over max_weight, set the bound to 0                       * // * If the weight is over max_weight, set the bound to 0                       *
 // ****************************************************************** // ******************************************************************
 void key::calcBound(){ void key::calcBound(){
         float temp;          ITEM_MASS temp;
         if (this->doneItems()) {         if (this->doneItems()) {
                 temp = 0;                 temp = 0;
         }         }
         else {         else {
                 temp = (float)((this->myBackpack->get_maxWeight()) - cur_weight);                  temp = ((this->myBackpack->get_maxWeight()) - cur_weight);
 //              temp = temp * (this->myBackpack->get_Item(this->nextitem)).getRatio(); (ratio = 1!) //              temp = temp * (this->myBackpack->get_Item(this->nextitem)).getRatio(); (ratio = 1!)
         }         }
         this->upper_bound = cur_value + temp;          this->upper_bound = cur_weight + temp;
  
         // What about if the bag is overloaded?         // What about if the bag is overloaded?
         if (this->cur_weight > this->myBackpack->get_maxWeight()){         if (this->cur_weight > this->myBackpack->get_maxWeight()){
Line 212 
Line 217 
 // * FUNCTION : getValue                IN : CLASS key                                          * // * FUNCTION : getValue                IN : CLASS key                                          *
 // * Gets the Value of the current key.                                                         * // * Gets the Value of the current key.                                                         *
 // ****************************************************************** // ******************************************************************
 ITEM_MASS key::getValue(){  //ITEM_MASS key::getValue(){
         return this->cur_value;  //      return this->cur_value;
 }  //}
  
 // ****************************************************************** // ******************************************************************
 // * FUNCTION : getWeight               IN : CLASS key                                          * // * FUNCTION : getWeight               IN : CLASS key                                          *
Line 244 
Line 249 
 // * FUNCTION : getCost                 IN : CLASS item                                         * // * FUNCTION : getCost                 IN : CLASS item                                         *
 // * Gets the Value of the current item.                                                        * // * Gets the Value of the current item.                                                        *
 // ****************************************************************** // ******************************************************************
 ITEM_MASS item::getCost(){  ///ITEM_MASS item::getCost(){
         return this->cost;  ///     return this->cost;
 }  ///}
  
 // ****************************************************************** // ******************************************************************
 // * FUNCTION : getNumber               IN : CLASS item                                         * // * FUNCTION : getNumber               IN : CLASS item                                         *
Line 261 
Line 266 
 // * Sets all the data for an item.                                                                     * // * Sets all the data for an item.                                                                     *
 // ****************************************************************** // ******************************************************************
 void item::setData(ITEM_MASS weightage){ //, ITEM_MASS costage, ITEM_MASS numerage){ void item::setData(ITEM_MASS weightage){ //, ITEM_MASS costage, ITEM_MASS numerage){
         this->cost = weightage; //costage;  //      this->cost = weightage; //costage;
         this->weight = weightage;         this->weight = weightage;
 //      this->ratio = ( (float)(cost)/(float)(weight) ); //      this->ratio = ( (float)(cost)/(float)(weight) );
 //      this->ratio = 1; //ratio = 1 //      this->ratio = 1; //ratio = 1
Line 352 
Line 357 
         this->addnodeCount++;         this->addnodeCount++;
  
         bool onwards = 1;         bool onwards = 1;
   
         do         do
         {         {
                 temp_key = key_queue.top();                 temp_key = key_queue.top();
                 this->key_queue.pop();                 this->key_queue.pop();
   /*Early skip here -- MASSIVE speed improvements */
                   if ( temp_key.getWeight() == targetvalue ) {
                           printf("Early value acquired! %d\n",temp_key.getWeight() );
                           goto early; // yes thats a go to. Its the only way to leave and keep the context right. I know its horrible
                   }
                 if ( temp_key.doneItems() ) {                 if ( temp_key.doneItems() ) {
                         onwards = 0;                         onwards = 0;
                 }                 }
Line 365 
Line 374 
             temp_key.flagNext();             temp_key.flagNext();
                 this->key_queue.push(temp_key);                 this->key_queue.push(temp_key);
                                 this->addnodeCount++;                                 this->addnodeCount++;
   
   
                                   // try this --- compare quicksorted before and after because of greedy grabbing largest
                                   //should find other comparator for weight with sub data like ... pct done
   
   
   
   
                         temp_key.addCurItem();                         temp_key.addCurItem();
                         if (temp_key.getBound() != 0){                         if (temp_key.getBound() != 0){
                                 this->key_queue.push(temp_key);                                 this->key_queue.push(temp_key);
                                 this->addnodeCount++;                                 this->addnodeCount++;
                         }                         }
                 }                 }
   //              if ((this->addnodeCount % 1000) == 0) {printf("10000!");}
         }         }
         while (onwards);         while (onwards);
  
           early:  if (DEBUG_MODE) {
         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("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 placed in the priority queue: %6d\n",this->addnodeCount);
                 printf("          Number of nodes examined/split:               %6d\n",this->worknodeCount);                 printf("          Number of nodes examined/split:               %6d\n",this->worknodeCount);
Line 409 
Line 426 
         else { printf("CANNOT FILL PALLET\n"); }         else { printf("CANNOT FILL PALLET\n"); }
 } }
  
 /*  
 // have to deal with non int #s // have to deal with non int #s
  
 int intcomp (const void * a, const void * b)  void super_increase_algo ( vector<ITEM_MASS> inventory, ITEM_MASS target_value , INDEX_TYPE size_inventory, int DEBUG_MODE ) {
 {          stack<ITEM_MASS> packages_to_load;
   return ( *(int*)a - *(int*)b );  
 }*/          if (DEBUG_MODE) {
                   printf("Extracting values, highest to lowest, doing reduction from index %d\n",size_inventory);
           }
           for ( INDEX_TYPE store_index=size_inventory-1; store_index>=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();
                   }
                   printf("\n");
           }
           else { printf("CANNOT FILL PALLET\n"); }
   }
   
  
 void syntaxmsg(){ void syntaxmsg(){
         printf("Usage:\n");         printf("Usage:\n");
Line 428 
Line 468 
         return;         return;
 } }
  
   
   ITEM_MASS masscomp (const void * a, const void * b)
   {
     return ( *(ITEM_MASS*)a - *(ITEM_MASS*)b );
   }
   
   
 // ****************************************************************** // ******************************************************************
 // * FUNCTION : main                                                                                            * // * FUNCTION : main                                                                                            *
 // * Initalizes the backpack and the items inside.                                      * // * Initalizes the backpack and the items inside.                                      *
Line 473 
Line 520 
         length = inputfs.tellg();         length = inputfs.tellg();
         inputfs.seekg (0, ios::beg);         inputfs.seekg (0, ios::beg);
  
         max_inventory= 1 + length/2;    // Elements cannot be more than this amount  
   
         char * read_buffer = (char *) malloc (length);         char * read_buffer = (char *) malloc (length);
         ITEM_MASS * inventory = (ITEM_MASS *) malloc (length);          vector<ITEM_MASS> inventory;
                 // could use stack instead of array --- doesn't require malloc, more 'safe' avoids overflows, esp if                 // 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                 // 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                  // small system, I'll stick with the array --- oh even better -- a vector!
                   //http://theory.stanford.edu/~amitp/rants/c++-vs-c/ Vector speed sorting is optimized by using vector!
         inputfs.getline (read_buffer, length-1);         inputfs.getline (read_buffer, length-1);
  
         char * theToken; INDEX_TYPE index = 0;         char * theToken; INDEX_TYPE index = 0;
Line 487 
Line 533 
         // assume 1+ items         // assume 1+ items
         while ( theToken != NULL ) {         while ( theToken != NULL ) {
                 //printf("tokendebug %d %f\n",theToken,theToken);                 //printf("tokendebug %d %f\n",theToken,theToken);
                 inventory[index] = atol(theToken);                  inventory.push_back(atol(theToken));
                 //printf("index %d, token %s, value %d\n",index,theToken,inventory[index]);                 //printf("index %d, token %s, value %d\n",index,theToken,inventory[index]);
                 index++;                 index++;
                 theToken = strtok (NULL,",");                 theToken = strtok (NULL,",");
                 }                 }
  
         INDEX_TYPE size_inventory = index; //remember this is 1 based, not 0          INDEX_TYPE size_inventory = inventory.size(); //remember this is 1 based, not 0
  
         int SUPER_MODE = 0;         int SUPER_MODE = 0;
         if (inventory[0]==1) { SUPER_MODE=0;}          if (inventory[0]==1) { SUPER_MODE=1;}
  
         if (DEBUG_MODE) {         if (DEBUG_MODE) {
                 printf("Line 1 read - %d products from warehouse\n", size_inventory);                 printf("Line 1 read - %d products from warehouse\n", size_inventory);
                 if (SUPER_MODE) printf("Working in Superincreasing mode!\n");                 if (SUPER_MODE) printf("Working in Superincreasing mode!\n");
         }         }
  
 //      qsort ( inventory, size_inventory, sizeof(int), intcomp);       // we now have a sorted list  //      qsort ( inventory, size_inventory, sizeof(ITEM_MASS), masscomp);        // we now have a sorted list
   //      sort (inventory.begin(), inventory.end(),std::greater<ITEM_MASS>() );
           sort (inventory.begin(), inventory.end());
                   // sorts array in reverse order, biggest elements first (
         // NEED TRY/CATCH error handling for possible segfault locations         // NEED TRY/CATCH error handling for possible segfault locations
         inputfs.getline (read_buffer, length-1);         inputfs.getline (read_buffer, length-1);
         ITEM_MASS palette_size=atoi(read_buffer);         ITEM_MASS palette_size=atoi(read_buffer);
Line 512 
Line 561 
                 printf("Line 2 read - %d weight units can fit onto palette\n",palette_size);                 printf("Line 2 read - %d weight units can fit onto palette\n",palette_size);
         }         }
  
           if (SUPER_MODE) {
                    super_increase_algo (inventory, palette_size , size_inventory, DEBUG_MODE );
                    return 0;
            }
   
         inputfs.close();         inputfs.close();
         free(read_buffer);         free(read_buffer);
  
         if  
   
   
         // ckeanup, release memeory, close files here  
   
   
 // I could use a class to extrapolate out the file loading function like my 499 project.... // I could use a class to extrapolate out the file loading function like my 499 project....
  
         backpack knapsackOne;         backpack knapsackOne;
Line 538 
Line 586 
  
         }         }
         knapsackOne.store_item_array();         knapsackOne.store_item_array();
         free(inventory);          inventory.clear();
         knapsackOne.branch_and_bound(DEBUG_MODE,palette_size);         knapsackOne.branch_and_bound(DEBUG_MODE,palette_size);
  
         printf("\n");         printf("\n");
Line 547 
Line 595 
  
  
  
 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"); }  
   
   
         }  
  
  
  
Line 768 
Line 780 
 goal 1 - lets remove the double call to the creator function, weight=value ratio=1 goal 1 - lets remove the double call to the creator function, weight=value ratio=1
  
  
   large set time :
   103,199,67,119,152,119,181,85,74,73,130,82,79,98,99,95,101,81,54,129,157,88,177,97,122,74,46,77,142,39,61,13,86,173,83,180,49,196,144,101,43,28,3,139,127,149,64,194,18,168,75,89,110,113,113,183,124,4,143,61,70,162,161,101,75,47,51,28,4,149,44,58,131,36,53,18,118,89,37,12,99,38,189,98,164,65,109,190,103,113,160,51,113,130,113,50,26,138,153,196,80,193,40,197,52,195,190,97,108,111,141,2,180,5,125,139,38,21,60,148,191,158,169,50,155,167,152,25,154,3,11,1
   
   real    1m14.327s
   user    1m11.530s
   sys     0m0.421s
   
   with goto removed.
   
   
   largeset time with early leave!
   Early value acquired! 13273
   133,103,105,199,33,67,119,119,181,85,74,73,26,130,82,79,98,99,95,101,81,54,129,157,88,177,97,122,74,46,77,142,39,61,13,86,173,83,180,49,196,144,101,43,28,3,139,127,149,64,194,18,168,75,89,110,113,113,183,124,4,143,61,70,162,161,101,75,47,51,28,4,149,44,58,131,36,53,18,118,89,37,12,99,38,189,98,164,65,109,190,103,113,160,51,113,130,113,50,26,138,153,196,80,193,40,197,52,195,190,97,108,111,141,2,180,5,53,125,139,38,21,60,148,191,158,169,50,155,167,25,86,24,3,10
   
   real    0m2.594s
   user    0m2.093s
   sys     0m0.468s
   
   Case n=4555 Total possible nodes in thie state space tree is 2^4555-1
             Number of nodes placed in the priority queue:  45994
             Number of nodes examined/split:                45381
   
   real    1m5.247s
   user    1m3.374s
   sys     0m0.327s
   after a presort. What about decsending sort?
   
   note, removing -g only kills a 1 second or something
   
   real    0m2.446s
   user    0m2.186s
   sys     0m0.203s
   
   with presort and early out
   
                 */                 */
  

Legend:
Removed from v.1.12  
changed lines
  Added in v.1.14
Rizwan Kassim
 Powered by
ViewCVS 0.9.2