算法-猴子运香蕉，看谁剩的多，N种解法

最新推荐文章于 2023-01-16 10:43:33 发布
最新推荐文章于 2023-01-16 10:43:33 发布
阅读量4.6k 收藏
点赞数 3
分类专栏： 香菜聊游戏 文章标签： 1024程序员节 算法 java go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/perfect2011/article/details/120929946
版权

 一个猴子身带100个香蕉，他距离家50米。这个猴子要带香蕉回去，但是他一次最多只能背50个香蕉，而且，每走一米他就要吃掉一个香蕉（往 回走也要吃香蕉）。这个猴子最后最多可以带多少个香蕉到家？？

第一种解法

package monkey
 
import "fmt"
 
var bagSize_ int
var roadLength_ int
var totalBanana_ int
var costPerStep_ int
 
func Play(roadLength int, bagSize int, totalBanana int, costPerStep int){
   bagSize_ = bagSize
   roadLength_ = roadLength
   totalBanana_ = totalBanana
   costPerStep_ = costPerStep
 
   //初始化道路
   road = make([]int, roadLength + 1)
   road[0] = totalBanana
 
   monkey_ := monkey{}
 
   defer func() {
      if err := recover(); err != nil {
         fmt.Println(err)
         fmt.Println(monkey_)
         fmt.Println(road)
      }
   }()
 
   move(&monkey_)
 
   fmt.Println("road info: ", road)
   fmt.Println("banan at home: ", road[roadLength])
}
 
func move(monkey *monkey){
   monkey.release()
   fmt.Println("road map >>> ", road)
    
   if monkey.shouldBack() {
      monkey.back()
   } else {
      if(monkey.position == roadLength_){
         //猴子到家
         return
      }
      monkey.pickUp()
      monkey.forward()
   }
   move(monkey)
}
 
var road []int
 
type monkey struct {
   position int
   bag int
}
 
//拾起
func (monkey *monkey) pickUp() {
   here := road[monkey.position]
   if here <= 0 {
      return
   }
   pickUpCount := here - monkey.bag
   if (pickUpCount + monkey.bag) > bagSize_ {
      pickUpCount = bagSize_ - monkey.bag
   }
   //填充猴子背包
   monkey.bag = monkey.bag + pickUpCount
   //扣减路上的香蕉
   road[monkey.position] = here - pickUpCount
}
 
//放下香蕉
func (monkey *monkey) release(){
   road[monkey.position] = road[monkey.position] + monkey.bag
   monkey.bag = 0
}
 
 
//前进
func (monkey *monkey) forward(){
   cost := 1*costPerStep_
   monkey.bag = monkey.bag - cost
   monkey.position = monkey.position + cost
   if monkey.bag < 0 {
      panic("no enough banana to home, die ...")
   }
}
 
//后退
func (monkey *monkey) back()  {
   cost := 1*costPerStep_
   //退回之前如果背包里没有香蕉，先补充一个
   if monkey.bag < cost {
      monkey.bag = cost
      road[monkey.position] = road[monkey.position] - cost
   }
   monkey.bag = monkey.bag - cost
   monkey.position = monkey.position - cost
}
 
//应该后退吗
func (monkey *monkey) shouldBack() bool {
   //前面还有多少
   if monkey.position == 0 {
      return false
   }
   left := road[monkey.position - 1]
   //最多可以拾起数量
   var canPick int
   if left >= bagSize_ {
      canPick = bagSize_
   } else {
      canPick = left
   }
   //退一步拾起，耗费两个香蕉
   profits := canPick - 2*costPerStep_
   return profits > 0
}

第二种解法

public class Mb {
   public static void main(String... arg) {
      recursiveMove(100, 50, 50, 1);
      move(100, 50, 50, 1);
      //recursiveMove(3000, 1000, 1000, 1);
   }
 
   /**
    * 循环算法
    * @param total 总数量
    * @param capacity 每次最多搬多少个
    * @param distance 距离
    * @param eatNum 每走一米吃的数量
    * @return 到家剩余的数量
    **/
   public static void move(int total, int capacity, int distance, int eatNum) {
 
      // 已经搬到的位置, 即搬了几米
      int location = 0;
 
      // 每次搬运起始点剩的数量
      int currentStartNum = total;
 
      // 每次搬运终点剩的数量
      int currentEndNum = 0;
 
      // 所有剩余香蕉移动一个位置
      while (location < distance && currentStartNum > eatNum) {
         System.out.println("当前所在位置" + location + "剩下" + currentStartNum + "个香蕉");
 
         // 每筐香蕉移动一个位置， 是移动一个位置的具体细节
         // 如果搬运起点还剩2个，返回去已经没有意义
         while (currentStartNum > eatNum * 2) {
 
            if (currentStartNum > capacity) {
               moveOnePosition(location, location + 1, capacity, eatNum);
               currentStartNum -= capacity;
               currentEndNum += capacity - eatNum;
            } else {
               moveOnePosition(location, location + 1, currentStartNum, eatNum);
               // 直接向前走
               currentEndNum += currentStartNum - eatNum;
               currentStartNum = 0;
            }
 
            // 需不需要搬起点剩下的, 即需不需要返回
            if (currentStartNum > eatNum * 2) {
               moveOnePosition(location + 1, location, -1, eatNum);
               currentEndNum -= eatNum;
            }
         }
 
         currentStartNum = currentEndNum;
         currentEndNum = 0;
         location++;
      }
 
      if (location < distance) {
         System.out.println("---猴子爬不到终点，饿死了---");
      } else {
         System.out.println("成功走到终点, 剩余" + currentStartNum + "个");
      }
   }
 
   /**
    * 递归算法
    * @param total 总数量
    * @param capacity 每次最多搬多少个
    * @param distance 距离
    * @param eatNum 每走一米吃的数量
    * @return 到家剩余的数量
    **/
   public static void recursiveMove(Integer total, Integer capacity, Integer distance, Integer eatNum) {
 
      // 已经搬到的位置
      Integer location = 0;
 
      // 每次搬运起始点剩的数量
      Integer currentStartNum = total;
 
      // 每次搬运终点剩的数量
      Integer currentEndNum = 0;
 
      stepMove(location, distance, capacity, currentStartNum, currentEndNum, eatNum);
   }
 
   private static void stepMove(int location, int distance, int capacity, int currentStartNum, int currentEndNum, int eatNum) {
      if (location < distance && currentStartNum > eatNum) {
         // 所有剩余香蕉移动一个位置
         System.out.println("当前所在位置" + location + "剩下" + currentStartNum + "个香蕉");
 
         // 每筐香蕉移动一个位置， 是移动一个位置的具体细节
         // 如果搬运起点还剩2个，返回去已经没有意义
         currentEndNum = miniStep(location, distance, capacity, currentStartNum, currentEndNum, eatNum);
 
         // 向前挪一步
         currentStartNum = currentEndNum;
         currentEndNum = 0;
         location++;
 
         stepMove(location, distance, capacity, currentStartNum, currentEndNum, eatNum);
      } else {
         if (location < distance) {
            System.out.println("---猴子爬不到终点，饿死了---");
         } else {
            System.out.println("成功走到终点, 剩余" + currentStartNum + "个");
         }
      }
   }
 
   private static int miniStep(int location, int distance, int capacity, int currentStartNum, int currentEndNum, int eatNum) {
      if (currentStartNum > eatNum * 2) {
 
         if (currentStartNum > capacity) {
            moveOnePosition(location, location + 1, capacity, eatNum);
            currentStartNum -= capacity;
            currentEndNum += capacity - eatNum;
         } else {
            moveOnePosition(location, location + 1, currentStartNum, eatNum);
            // 直接向前走
            currentEndNum += currentStartNum - eatNum;
            currentStartNum = 0;
         }
 
         // 需不需要搬起点剩下的, 即需不需要返回
         if (currentStartNum > eatNum * 2) {
            moveOnePosition(location + 1, location, -1, eatNum);
            currentEndNum -= eatNum;
         }
 
         return miniStep(location, distance, capacity, currentStartNum, currentEndNum, eatNum);
      } else {
         return currentEndNum;
      }
   }
 
   /**
    * @param from 起始位置
    * @param to 目标位置
    * @param count 搬的数量
    * @param eatNum 搬一米吃的数量
    */
   private static void moveOnePosition(int from, int to, int count, int eatNum) {
      if (count != -1) {
         System.out.println("从位置" + from + "搬" + count + "个到位置" + to + ", 吃掉" + eatNum + "个");
      } else {
         System.out.println("从位置" + from + "返回到位置" + to + ", 吃掉 " + eatNum + "个");
      }
   }
 
}

第三种解法

public class recursion {
 private static Monkey monkey = new Monkey();
 // 需要搬运的香蕉
 static final int TOTAL_BANANA = 3000;
 // 路途漫漫
 static final int DISTANCE = 1000;
 // 猴子能搬运的容量
 private static final int POWER = 1000;
 // 小笔记本
 static LinkedList<Integer[]> NOTE = new LinkedList();
 public static void main(String args[]) {
  int remainBanana = getBanana(TOTAL_BANANA, 0, 0.00F);
  System.out.println("运输路线如下");
  for (Integer integ[] : NOTE) {
   System.out.printf("%d 米可用 %d 个香蕉，丢弃 %d 个香蕉", integ[0], integ[1], integ[2]);
   System.out.print("========");
  }
  System.out.printf("最后剩下了：%d 个香蕉", remainBanana);
  System.out.println();
 }
 static int getBanana(int bananaNum, int position, float rate) {
  // 香蕉数不够到达目的地
  if (bananaNum < DISTANCE) {
   Integer recode[] = {position, bananaNum};
   NOTE.add(recode);
   return -1;
  }
  int remainingBanana = bananaNum % POWER;
  int copies = bananaNum / POWER + (remainingBanana > 0 ? 1 : 0);
  int carryTimes;
  // 计算需要来回几次 carryTimes
  if (remainingBanana == 0 || remainingBanana > 2) {
   carryTimes = copies * 2 - 1;
  } else {
   carryTimes = (copies - 1) * 2 - 1;
   bananaNum = bananaNum - remainingBanana;
  }
  // 可以一次运送过去
  if ((POWER > DISTANCE - position) && carryTimes == 1) {
   Integer recode[] = {position, bananaNum, remainingBanana};
   NOTE.add(recode);
   return bananaNum - (DISTANCE - position);
  }
  int nextBananaNum = bananaNum - carryTimes;
  // 计算斜率，每单位消耗的香蕉数
  float nextRate = 1F / (bananaNum - nextBananaNum);
  if (nextRate > rate) {
   Integer recode[] = {position, bananaNum, remainingBanana};
   NOTE.add(recode);
  }
  return getBanana(nextBananaNum, position + 1, nextRate);
 }
}

第四种解法

public class Test {
 
   // 总数
   private static int total = 100;
   // 单次运送最大数
   private static int max = 50;
   // 总距离
   private static int length = 50;
   // 每次消耗
   private static int per = 1;
   // 最大值
   private static int mod = -1;
 
   public static void main(String[] args) {
      if (length * per > max || length * per > total) {
         System.out.println("无法完成");
         return;
      }
      count(length, total);
      System.out.println(mod);
   }
 
   private static void count(int length, int total) {
      // 最后多次完成
      if (length == 0) {
         if (total > mod) {
            mod = total;
         }
         return;
      }
      // 最后一次完成
      if (max > total && max > length * per) {
         if ((total - length * per) > mod) {
            mod = total - length * per;
         }
         return;
      }
 
      // i单次到达距离
      for (int i = length; i > 0; i--) {
         if (total - i * per > 0 && 2 * per * i > max) {
            continue;
         }
 
         int times;
         if (total % max == 0) {
            times = (total / max - 1) * 2 + 1;
         } else {
            if (total % max > 2 * per * i) {
               times = (total / max) * 2 + 1;
            } else {
               // 最后一次剩余不够消耗则丢弃
               times = (total / max - 1) * 2 + 1;
               total = total - total % max;
            }
         }
         int mod = total - times * i * per;
         if (mod < (length - i) * per) {
            return;
         }
 
         count(length - i, mod);
      }
   }
}

第五种解法

## 无路径版本
 
 
``` java
public class MonkeyMoveBanana2 {
 
   public static void main(String[] args) {
      int lastLeave = move(1000, 50, 50, 2);
      System.out.println("最后剩余：" + lastLeave);
   }
 
   /**
    * @param num 香蕉总数
    * @param length 距离
    * @param max 最大搬运量
    * @param per 每米消耗数
    */
   static int move(int num, int length, int max, int per) {
 
      for (int i = 0; i < length; i++) {
 
         if (num < length - i) {
            num = -1;
            break;
         }
         if (num <= max) {
            num = num - (length - i);
            break;
         }
         int n = num / max;
         int lastNum = num % max;
         if (lastNum > 2 * per) {
            n = num / max + 1;
         } else {
            num -= lastNum;
         }
         num -= (per + (n - 1) * 2 * per);
      }
 
      if (num < 0) {
         num = -1;
      }
 
      return num;
   }
}
```
 
 
## 有路径信息版本
``` java
 
public class MonkeyMoveBanana3 {
 
   public static void main(String[] args) {
      int lastLeave = move(1000, 50, 50, 1);
      if (lastLeave >= 0) {
         System.out.println("最后剩余：" + lastLeave);
      }
   }
 
   static Map<Integer, Integer> numInPos = new LinkedHashMap<>();
 
   /**
    * @param num 香蕉总数
    * @param length 距离
    * @param max 最大搬运量
    * @param per 每米消耗数
    */
   static int move(int num, int length, int max, int per) {
 
      numInPos.put(0, num);
 
      for (int i = 0; i < length; i++) {
 
         if (num < length - i) {
            num = -1;
            break;
         }
         if (num <= max) {
            go(i, length - i, per, num);
            num = num - (length - i);
            break;
         }
         int n = num / max;
         int lastNum = num % max;
         if (lastNum > 2 * per) {
            n = num / max + 1;
         } else {
            num -= lastNum;
            lastNum = 0;
         }
         num -= (per + (n - 1) * 2 * per);
 
         goMetre(i, per, max, n, lastNum);
      }
 
      if (num < 0) {
         num = -1;
         System.out.println("monkey die");
      }
 
      return num;
   }
 
 
   static void goMetre(int pos, int per, int max, int n, int lastMove) {
      for (int i = 0; i < n - 1; i++) {
         go(pos, 1, per, max);
         back(pos + 1, 1, per, 1);
      }
      if (lastMove == 0) {
         go(pos, 1, per, max);
      } else {
         go(pos, 1, per, lastMove);
      }
   }
 
   /**
    * 向前走
    *
    * @param pos 起点
    * @param distance 前进距离
    * @param per 每米消耗
    * @param payload 起点携带数量
    */
   static void go(int pos, int distance, int per, int payload) {
      int newPos = pos + distance;
      int cost = distance * per;
      int surplus = payload - cost;
 
      for (int i = 0; i < pos; i++) {
         System.out.print(" ");
      }
      for (int i = 0; i < distance; i++) {
         System.out.print(">");
      }
 
      if (!numInPos.containsKey(newPos)) {
         numInPos.put(newPos, 0);
      }
      numInPos.put(pos, numInPos.get(pos) - payload);
      numInPos.put(newPos, numInPos.get(newPos) + surplus);
 
      System.out.format("\t [%d->%d] 带%d个，进%d米，吃%d个，剩%d个。\t", pos, newPos, payload, distance, cost, surplus);
      printNumInPos();
   }
 
   /**
    * 往回走
    *
    * @param pos 起点
    * @param distance 前进距离
    * @param per 每米消耗
    * @param payload 起点携带数量
    */
   static void back(int pos, int distance, int per, int payload) {
      int newPos = pos - distance;
      int cost = distance * per;
      int surplus = payload - cost;
 
      for (int i = 0; i < newPos; i++) {
         System.out.print(" ");
      }
      for (int i = 0; i < distance; i++) {
         System.out.print("<");
      }
      numInPos.put(pos, numInPos.get(pos) - payload);
      numInPos.put(newPos, numInPos.get(newPos) + surplus);
 
      System.out.format("\t [%d<-%d] 带%d个，退%d米，吃%d个，剩%d个。\t", newPos, pos, payload, distance, cost, surplus);
      printNumInPos();
   }
 
   static void printNumInPos() {
      for (Integer key : numInPos.keySet()) {
         if (numInPos.get(key) != 0) {
            System.out.format("pos[%d]=%d\t", key, numInPos.get(key));
         }
      }
      System.out.println();
   }
 
}
```

第六种

第一种：
package com.example.sbpracdemo.houzi;
 
 
public class Test3 {
 
   public static void main(String[] args) {
      int bananaNum = 100;//香蕉总数量 150
      int carryBanana = 50;//能运多少香蕉
      int distance = 50; //距离家多远1
 
      int remainingTotalAmount = bananaNum;//剩余香蕉总数量
      //搬不走的香蕉数量
      int notCarryBanana = bananaNum - carryBanana;
      //搬走香蕉的剩余数量
      int remainingCarryBanana = carryBanana;
      //搬走香蕉
      int carryNum = carryBanana;
 
      for (int i = 1; i <= distance; i++) {
         System.out.print("走" + i + "米,搬走香蕉" + carryNum);
         remainingCarryBanana--;//走一米要吃掉一个香蕉
         remainingTotalAmount = remainingCarryBanana + notCarryBanana;
         System.out.println(",搬走香蕉的剩余数量:" + remainingCarryBanana + ",搬不走的香蕉数量:" + notCarryBanana + ",剩余香蕉总数量:" + remainingTotalAmount);
 
         //如果剩余数量小于等于能拖的数量，直接回家
         if(remainingTotalAmount<=carryBanana){
            carryNum = remainingCarryBanana;
            notCarryBanana = 0;
            continue;
         }
         //香蕉剩余数量要能够走回家
         if(remainingTotalAmount>(distance-i)){
            int temp = (int) Math.ceil((double) notCarryBanana / (double) carryBanana);
            if (temp > 1) {
               int ss=notCarryBanana;
               for (int j = 0; j < temp; j++) {
                  carryNum = carryBanana;
                  if(j==temp-1){
                     carryNum=ss-carryBanana*(temp-1);
                  }
                  //回去要吃掉一个香蕉
                  remainingCarryBanana--;
                  //背在原地的香蕉
                  notCarryBanana--; //49
                  remainingTotalAmount = remainingCarryBanana + notCarryBanana;
 
                  if (remainingTotalAmount > carryBanana) {
                     notCarryBanana = remainingTotalAmount - carryBanana;
                     remainingCarryBanana = remainingTotalAmount - notCarryBanana;
                  } else {
                     remainingCarryBanana = remainingTotalAmount;
                     notCarryBanana = 0;
                  }
                  System.out.println("回走,搬走香蕉" + carryNum + ",剩余香蕉总数量:" + remainingTotalAmount);
               }
            } else {
               if (notCarryBanana != 0) {
                  carryNum = notCarryBanana;
                  remainingCarryBanana--;//回去要吃掉一个香蕉 48
                  //背在原地的香蕉
                  notCarryBanana--; //49
                  remainingTotalAmount = remainingCarryBanana + notCarryBanana;
 
                  if (remainingTotalAmount > carryBanana) {
                     notCarryBanana = remainingTotalAmount - carryBanana;
                     remainingCarryBanana = remainingTotalAmount - notCarryBanana;
                  } else {
                     remainingCarryBanana = remainingTotalAmount;
                     notCarryBanana = 0;
                  }
                  System.out.println("回走,搬走香蕉" + carryNum + ",剩余香蕉总数量:" + remainingTotalAmount);
               }
            }
         }
         carryNum = remainingCarryBanana;
      }
      System.out.println("猴子最后最多可以带" + remainingTotalAmount + "个香蕉到家");
   }
}
 
 
 
第二种
package com.example.sbpracdemo.houzi;
 
/**
 * 密级别：classify:p2#- User: Jinlili Date: 2018/8/2322:46 Description:
 */
public class Test2 {
 
   public static void main(String[] args) {
      System.out.println(walk(100, 50, 50));
   }
 
   /**
    * @param bananaNum 总共多少根
    * @param carryBanana 每次拖多少根
    * @param distance 离家多少米
    */
   public static int walk(int bananaNum, int carryBanana, int distance) {
      int[] gj = new int[distance + 1];
      for (int i = 1; i <= distance; i++) {
         gj[i] = bananaNum;
         bananaNum = bananaNum - ((int) Math.ceil((double) bananaNum / (double) carryBanana) * 2 - 1);
         if (bananaNum < 0) {
            bananaNum = 0;
            System.out.println("不可达");
            break;
         }
      }
      return bananaNum;
   }
}

香菜+
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
基础算法-python猴子选大王
11-06
python猴子选大王 #!/usr/bin/python # -*- coding: utf-8 -*- N=int(input()) ls=[i for i in range(1,N+1)] step=2 #步长 ptr=1 while len(ls) > 1: #ptr表示列表中第几个元素,没有第0个元素,只有下标为0的元素 ptr=(ptr+step-1)%len(ls)+1 #ptr 是 下一个开始的位数 del ls[ptr-1] print(ls[0])
猴子摘香蕉问题
AABond的博客
09-23 2970
猴子摘香蕉问题，人工智能经典题，广州大学计算机学院的人工智能实验一，保证看懂
【每日一道智力题】之猴子搬香蕉
睿的博客
01-16 1227
【每日一道智力题】之猴子搬香蕉
猴子搬香蕉问题。
热门推荐
xiaomin98的专栏
01-10 1万+
一个小猴子边上有100根香蕉，它要走过50米才能到家，每次它最多搬50根香蕉，（多了就被压死了），它每走1米就要吃掉一根，请问它最多能把多少根香蕉搬到家里。（提示：他可以把香蕉放下往返的走，但是必须保证它每走一米都能有香蕉吃。也可以走到n米时，放下一些香蕉，拿着n根香蕉走回去重新搬50根。）看了很多文章。好像分析的不是很清楚。只好自己动手了。解析：这种试题通常有一个迷惑点，让人看不懂题目的
猴子背100根香蕉问题程序实现
一屋不扫 何以笙箫默
07-28 5070
问题描述：有只猴子在树林采了100根香蕉堆成一堆，猴子家离香蕉堆50米，猴子打算把香蕉背回家， 每次最多能背50根，可是猴子嘴馋，每背一米要吃一根香蕉，问猴子最多能背回家几根香 蕉？我的理解是返回背香蕉时 不吃香蕉 （否则这个问题没法解决） 在网上看到一个上述小学题目，据说挺火的，想了一下得到每次走25m的答案，网上评论一看，大多是这个思路，但我觉得不只一种答案，于是在刚好在学java，就随手写了下来
[益智]：猴子搬香蕉
AngelDg的博客
10-07 2159
题目描述 一个小猴子边上有100根香蕉，它要走过50米才能到家，每次它最多搬50根香蕉，（多了就被压死了），它每走1米就要吃掉一根，请问它最多能把多少根香蕉搬到家里。（提示：他可以把香蕉放下往返的走，但是必须保证它每走一米都能有香蕉吃。也可以走到n米时，放下一些香蕉，拿着n根香蕉走回去重新搬50根。） 题目解答 这种试题通常有一个迷惑点，让人看不懂题目的意图。 此题迷惑点在于： 走一米吃一根香蕉，一共走50米，那不是把50根香蕉吃完了吗？ 如果要回去搬另外50根香蕉，则往回走的时候也要吃香蕉，这样每走一米
猴子运香蕉
逗题博客
06-04 1589
题面： 一个小猴子边上有100根香蕉，它要走过50米才能到家，每次它最多搬50根香蕉，（多了就被压死了），它每走1米就要吃掉一根，请问它最多能把多少根香蕉搬到家里。 提示：他可以把香蕉放下往返的走，但是必须保证它每走一米都能有香蕉吃。也可以走到n米时，放下一些香蕉，拿着n根香蕉走回去重新搬50根。 题解： 带上3x-1的香蕉走x米的路折返，去时每步吃一个香蕉放2个香蕉在地上，没香蕉
猴子背香蕉最优解问题的程序实现
zdip123的博客
03-02 1371
猴子背香蕉最优解问题的程序实现 问题描述： 有只猴子在树林采了200根香蕉堆成一堆，猴子家离香蕉堆100米，猴子打算把香蕉背回家， 每次最多能背100根，可是猴子嘴馋，每背一米要吃一根香蕉，问猴子最多能背回家几根香蕉？ 个人理解： 每走一米都吃一根香蕉，包括往回走 肯定是一次携带的越多，往返的次数越少，即能省下的才越多，所以需要两次，每次携带100根 目前问题就是走几步往回返才能得到最优解的...
【C++】人工智能实验一 猴子摘香蕉/传教士与野人（含完整代码与状态迁移图）
RouTine
12-29 9863
房内有一个猴子，一个箱子，天花板上挂了一串香蕉，其位置如图1所示，猴子为了拿到香蕉，它必须把箱子搬到香蕉下面，然后再爬到箱子上。
逻辑面试题：猴子搬香蕉
小K算法
05-12 3694
关注下方公众号，分享硬核知识作者 | 小K出品 | 公众号：小K算法 （ID：xiaok365）01故事起源一只小猴子边上有100根香蕉，此地距离它家50米，小猴想搬香蕉回家，但有以下几个...
基础算法-python汉诺塔解法
11-17
汉诺塔问题的解决方法 # 1. 汉诺塔问题：汉诺塔问题是一个经典的数学问题，它源自印度神话中的一个传说。问题的描述是：有三根柱子A、B、C，A柱上有n个不同大小的圆盘，下面的圆盘比上面的圆盘大。目标是将所有圆盘从A柱移动到C柱，期间只能借助B柱，且任意时刻大圆盘不能放在小圆盘上面。 # 2. 解法：汉诺塔问题的解法可以使用递归算法来实现。具体步骤如下： # 当只有一个圆盘时，直接将该圆盘从A柱移动到C柱即可。 # 当有n个圆盘时，将前n-1个圆盘从A柱移动到B柱，再将第n个圆盘从A柱移动到C柱，最后将前n-1个圆盘从B柱移动到C柱。
旅行商问题-旅行商问题的多种解法-模拟退火算法-遗传算法.zip
最新发布
01-24
旅行商问题 旅行商问题_旅行商问题的多种解法_模拟退火算法_遗传算法
基础算法-python猴子吃桃
11-15
【基础算法】-python猴子吃桃 # 猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个第二天早上又将剩下的桃子吃掉一半，又多吃了一个。 # 以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。 # 方法一：递归法 def peach_count(n): if n == 10: return 1 return 2 * (peach_count(n+1) + 1) total_peach = peach_count(1) print("第一天共摘了%d个桃子。" % total_peach)
力扣经典算法题-动态规划算法-golang语言解法
07-26
力扣经典算法题-动态规划算法，求最大最小区域电话线的个数，采用动态规划算法进行计算求解，采用golang语言解法进行求解。
Matlab编写NSGA-2多目标优化算法
02-23
使用matlab编写NSGA-2多目标优化算法： 1）针对测试函数集ZDT1进行的NSGA-Ⅱ算法的编写； 2）本程序有详细的备注解释； 3）包含论文《非支配排序遗传算法（NSGA）的研究与应用》.pdf，用来指导学习NSGA-Ⅱ算法
贪婪算法（合理分配，最大积）
qq_31839461的博客
11-23 1308
Assignment 3 Q1: 代码: 把猴子和香蕉按照从左到右的顺序编号，当每个猴子拿到对应顺序的香蕉的时候所有猴子拿完香蕉花费的时间最少。比如说左起第一个猴子应该拿左起的第一根香蕉，以此类推。 def assignBananasToMonkeys(bananas,monkeys): bananas.sort() monkeys.sort() res = ...
人工智能基础---上机1：猴子摘香蕉
qq_54695558的博客
10-17 1956
人工智能基础上机---猴子摘香蕉
蓝桥杯 算法基础-猴子分香蕉
zlonfe的博客
06-12 716
算法基础-猴子分香蕉 5只猴子是好朋友，在海边的椰子树上睡着了。这期间，有商船把一大堆香蕉忘记在沙滩上离去。 第1只猴子醒来，把香蕉均分成5堆，还剩下1个，就吃掉并把自己的一份藏起来继续睡觉。 第2只猴子醒来，重新把香蕉均分成5堆，还剩下2个，就吃掉并把自己的一份藏起来继续睡觉。 第3只猴子醒来，重新把香蕉均分成5堆，还剩下3个，就吃掉并把自己的一份藏起来继续睡觉。 第4只猴子醒来，重新把香蕉均分成5堆，还剩下4个，就吃掉并把自己的一份藏起来继续睡觉。 第5只猴子醒来，重新把香蕉均分成5堆，哈哈，正好不剩！
第九届蓝桥杯省赛JAVA语言 C组题解_解2 猴子数香蕉
NanyouqiaoMu_的博客
11-09 1383
JAVA语言 C组题解_题1 哪天返回题目解题思路 题目 小明被不明势力劫持。后被扔到x星站再无问津。小明得知每天都有飞船飞往地球，但需要108元的船票，而他却身无分文。 他决定在x星战打工。好心的老板答应包食宿，第1天给他1元钱。 并且，以后的每一天都比前一天多2元钱，直到他有足够的钱买票。 请计算一下，小明在第几天就能凑够108元，返回地球。 解题思路 暴力破解 //java代码 publi...
java算法----求从1到N中，4出现的个数，N=155
06-06
以下是求从1到N中4出现的个数的Java算法实现： ```java public static int countFour(int n) { int count = 0; for (int i = 1; i <= n; i++) { int j = i; while (j != 0) { if (j % 10 == 4) { count++; } j /= 10; } } return count; } // 调用 int n = 155; int count = countFour(n); System.out.println("从1到" + n + "中4出现的个数为：" + count); ``` 算法思路如下： 1. 对于每个数i，将它的每一位数字取出来； 2. 如果这个数字等于4，计数器加1； 3. 继续处理下一位数字，直到所有数字都处理完毕。 时间复杂度为O(NlogN)，空间复杂度为O(1)。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

香菜+

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值