算法习题1

• Q：一条笔直的公路上安装了N个路灯，从位置0开始安装，路灯之间的距离是100m。每个路灯都有自己的照明半径，请计算第一个路灯和最后一个路灯之间，未照明区间的长度和。
• 输入描述：
  • 第一行为一个数N，表示灯的个数，[1, 100000]
  • 第二行为N个空格分隔的数，表示路灯的照明半径，[1, 100*100000]
• 输出描述：
  • 第一个路灯和最后一个路灯之间，未照明区间的长度和
• A:

   #include <iostream>
   
   // 思路：计算任意两个之间的未照明距离，分别计算左A和右B所有的照明叠加，即计算A，A-1，A-2... 在此段距离的照明半径叠加。
   
   int getShadowLength(int lightNum, int * lightRadium){
   
       int length = 0;
   
       size_t index = 0;
       while (index < lightNum -1 ) {
           bool jump =false;
   
           //计算 r 和 r+1 之间的阴影距离
           if (lightRadium[index] + lightRadium[index + 1] >= 100){//全部照明
               index++;
               continue;
           }
   
           int leftLightlen = lightRadium[index];
           int rightLightlen = lightRadium[index + 1];
   
           int index_l = index - 1;
           while (index_l >= 0) {
               if (lightRadium[index_l] <= 100) {
                   index_l--;
                   continue;
               }
   
               int n = lightRadium[index_l] % 100;
               if (n >= index - index_l) {
                   if (n >= index - index_l + 1) {
                       index += n - (index - index_l);//跳出左循环循环，进入跳步循环
                       jump = true;
                       break;
                   }
   
                   int l = lightRadium[index_l] - 100*(index - index_l);
                   if (l > leftLightlen){
                       leftLightlen = l;
                   }
               }
           }//左循环
           if (jump){
               continue;
           }
   
           if (leftLightlen + lightRadium[index + 1] >= 100){//全部照明
               index++;
               continue;
           }
   
           int index_r = index + 2;
           while (index_r < lightNum) { // r+1 后起 r+2 ->> 最后一个
               if (lightRadium[index_r] <= 100) {
                   index_r++;
                   continue;
               }
   
               int n = lightRadium[index_r] % 100;
               if (n >= index_r - (index+1)) {
                   if (n >= index_r - (index+1) + 1) {
                       index += 2*n;//跳出左循环循环，进入跳步循环
                       jump = true;
                       break;
                   }
   
                   int r = lightRadium[index_r] - 100*(index_r - (index+1));
                   if (r > rightLightlen){
                       rightLightlen = r;
                   }
               }
   
           }//右循环
           
           if (jump) {
               continue;
           }
           
   
           if (leftLightlen + rightLightlen >= 100){
               index ++;
               continue;
           }
   
           length += 100 - leftLightlen - rightLightlen;
           index++;
       }//主循环
   
       return length;
   }
   
   int main(int argc, char* argv[]){
   
       int a[4] = { 50, 30, 150, 60};
   
       int x =  getShadowLength(4, a);
   
       std::cout << "lenth = " << x << std::endl;
   
       return 0;
   }