2014 amazon 在线 面试题目 爬山问题：打印出从A点到B点的距离

关于那个爬山距离问题的代码说明。

1）题目要求从A(0.0)到B(0,100)的距离，其中要爬过许多山。

  用<起点，终点，高度> 来表示一座山。如果是别的数值，请修改它。

2）一座山的坐标中startpoin和endpoint是否可以跟别的山可以重合成一样？

  这个问题在题目里没有明确说，而且从它给的测试用例看是不重合的，故在该程序中假设没有这种重复节点的情况。

 

3）测试用例输入格式，我记得原题的输入输出格式如下（我没有记得在哪里给出了B点的坐标）。

 

  //input format

    3             //表示有3座山

　1,3,1   //第一座山的坐标是起点1，终点3, 高度1。

    2,4,2  //第二座山的坐标是起点2，终点4, 高度2。

   7,8,3   //第三座山的坐标是起点7，终点8, 高度3。

//output

     110     //从A点到B点，需要110步

我的这个代码测试用例和执行过程为：

./amazon_climb_mountain

3

1,3,1  

2,4,2  

7,8,3  

110 

//从A(0.0) 点到B(100.0)点，需要110步。

/*
 somebody go from A (0,0) to B (0,D) via many mountains which use tri-tuple <startx,endx,height>.
 * this guy must be walk up  when arriving at mountains and climb down when leave this mountain.
 * Here 这里山的坐标会交叉或者重叠。
   questions: how many steps after he cross these mountains from starting point (0,0).  
 * 
 *|
 * input:
         3  //total  mountain's number
   mountain1:  <startx1,endx1,height1>
 mountain2:   <startx2,endx2,height2>
 mountain3:  <startx3,endx3,height3>

 * output:
 *     steps
 * 
 * Solution:
 *  1） 垂直方向的steps 就是 把各个合体山（几个起点或终点坐标有交差重叠的山）的最高高度乘以2倍，再把这些数值加起来。
 *      如果合体山的起始点与前面的合体山的终点是一样的，则要注意特殊处理
 *  2） 水平方向的steps 就是最远点的坐标点
 */
#include <cmath>
#include <cstdio>
#include <vector>
#include <map>
#include <stack>
#include <list>
#include <iostream>
#include <algorithm>
#include <cstring>
 
//must include it for strlen() in some compilers
using namespace std;

class Node {
private:
 long PointValue;
 long height;
 bool Isstartpoint; 
 public:
     Node(long value, long height, bool Isstartpoint){
         this->PointValue=value;
         this->height=height;
         this->Isstartpoint=Isstartpoint;
     }
     virtual ~Node(){
         ;
     }
     
     long getPointValue() {
         return PointValue;
     }
     long getheight() {
         return height;
     };
     bool IsStartPoint() {
         return this->Isstartpoint;
     }
     
     bool operator <( const Node& rt) const {  
        cout<<"call this operator <"<<endl;
       return ( PointValue < rt.PointValue);  
  }  
     bool operator >( const Node& rt) const{  
         cout<<"call this operator >"<<endl;
       return (PointValue > rt.PointValue);  
   }  
};

bool isSpace(char x){
    return x == ' ' || x == '\r' || x == '\n' || x == '\r' || x == '\b' || x == '\t';
}

char * rightTrim(char *str){
      long len = strlen(str);
    while(--len>=0){
        if(isSpace(str[len])){
            str[len] = '\0';
        }else{
            break;
        }
    }
    return str;
}

char * getInputLine(char *buffer,   long length){
    if(fgets(buffer,length, stdin)==NULL){
        return NULL;
    }
    rightTrim(buffer);
    if(strlen(buffer)<=0){
        return NULL;
    }
    return buffer;
}

//array saves data delimited by ',' parsed from one line.
//return the total number of data
long splitAndConvert(char* strings, long *array){
    char* tokenPtr = strtok(strings,",");
      long i=0;
    while(tokenPtr != NULL){
        array[i] = atol(tokenPtr);
        i++;
        tokenPtr=strtok(NULL,",");
    }
    return i;
}
  /*
      | ------ |
   ------------------    
   |                 |
 -----------------------
   */
  long process_data(vector<Node>& datavector){
      //sort data point increasingly
     sort(datavector.begin(),datavector.end(),less<Node>());
     //sort data point decreasingly
     //sort(datavector.begin(),datavector.end(),greater<Node>());
    
     long steps=0;
     long current_height=0;
     long lastMountheight=0;
     bool mountainconnected=false;
     
     int accumulate=0; //用于找到合体山，即起始点和终止点个数一样。
     
     // 垂直方向的steps 就是把各个合体山的高度的2倍加起来。
     
     for(int len=0; len <datavector.size();len++ ){
         if(datavector[len].IsStartPoint()) 
             accumulate++;
         else 
             accumulate--;
         
         //find the highest height of this complicated mountain
         if(datavector[len].getheight() > current_height)
             current_height=datavector[len].getheight();
                          
         //find the complete complicated mountain
         if(accumulate==0) {
             //if this mountain is connected to former mountain
             if(mountainconnected==true){
                 if(lastMountheight < current_height) {
                     steps += 2*(current_height - lastMountheight);
                 } 
                 //if lastMountheight  > current, nothing to do
             } 
             else {
                 steps += (2*current_height);
             }
             
            lastMountheight=current_height;
            current_height=0;   
             
            //check whether this mountain is connected the next mountain, that is,its endpoint is the same as the start point of next mountain.
            if(len <(datavector.size()-1)) {
                if(datavector[len].getPointValue()==datavector[len+1].getPointValue()){
                    mountainconnected=true;
                }
                else  {
                    mountainconnected=false; 
                }
            }
         }
     }
     //水平方向的steps 就是最远点的坐标点
     //datavector.front()to get this first element;
     steps += datavector.back().getPointValue(); //get this furthest point value
     return steps;
  }
  
int main(int argc, char** argv) {
    char *line=new char[1000];
    cout<<"input number of mountains:"<<endl;
    getInputLine(line,1000);
    long number[1];
    long NumberLength = splitAndConvert(line,number);
  
    if(NumberLength != 1) {
        cout<<"error"<<endl;
        return 0;
    }
    cout<<"input mountains <start,end,height>"<<endl;;	
    //save all input int data one by one
    vector<Node> datavector;
    int index=0;
    while(index<number[0]){
        //get trip tuple<startpoint,endpoint, height> for each mountain data from stdin one line by line
         getInputLine(line, 1000); 
         long data[3];
         long len=splitAndConvert(line,data);
       //valid check for array
       if(len !=3 ){
         cout<<" input parameter error, exit "<<endl;
         return 0;   
        }  
      index++;
      
      Node mnode1(data[0],data[2],true); //start point
      datavector.push_back(mnode1);
      Node mnode2(data[1],data[2],false); //end point
      datavector.push_back(mnode2);
    }
    cout<<process_data(datavector)<<endl;
    cout <<"completes successfully, exit"<<endl;         
    return 0;
}