最大利润-城市A和B

1，问题描述

jack每天同时只能在A和B其中一个城市工作赚钱，假设两个城市间的交通费为m。已知每天在A 和 B 能赚到多少钱，那么jack怎么选择每天工作的城市才能赚到最大利润。

比如 moneyA = {1，2，3，4，3，1}；moneyB = {2，1，3，4，2，1}；m = 1。

2，边界条件：无

3，思路：假设某一天jack在A城市工作，那么接下来怎么选择到最后一个才能赚到最多，在B城市类似。然后形成递归。

4，代码实现

1）简单递归

     public static void main(String[] args) {
         int[] cityA = {1,2,4,5,6,3,1};
         int[] cityB = {2,3,4,5,1,1,2};
         int res = Math.max(mostMoney(cityA, cityB, 1, 0), mostMoney(cityB, cityA, 1, 0));
         System.out.println("res: " + res);
     }

     public static int mostMoney(int[] curCity, int[] nextCity, int m, int idx) {
         if (idx >= curCity.length) {
             return 0;
         }

         int moneyCur = mostMoney(curCity, nextCity, m, idx + 1);
         int moneyNext = mostMoney(nextCity, curCity, m, idx + 1) - m;
         return curCity[idx] + Math.max(moneyCur, moneyNext);
     }

2）其实在递归时在某一个点能获取的最大利润重复计算，所以获得该最大利润后需记录下来cache，下次直接用，这就是动态规划DP。

     private static int[] recA;
     private static int[] recB;
     public static void main(String[] args) {
         int[] cityA = {1,2,4,5,6,3,1};
         int[] cityB = {2,3,4,5,1,1,2};
         recA = new int[cityA.length];
         recB = new int[cityB.length];
         recA[0] = mostMoney(cityA, cityB, true, 1, 0);
         recB[0] = mostMoney(cityB, cityA, false, 1, 0);
         int res = Math.max(recA[0], recB[0]);
         System.out.println("res: " + res);
         System.out.println("recA: " + Arrays.toString(recA));
         System.out.println("recB: " + Arrays.toString(recB));
     }

     public static int mostMoney(int[] curCity, int[] nextCity, boolean isCityA, int m, int idx) {
         if (idx >= curCity.length) {
             return 0;
         }
         if (isCityA && recA[idx] != 0) {
             return recA[idx];
         } else if (recB[idx] != 0) {
             return recB[idx];
         }

         int moneyCur = mostMoney(curCity, nextCity, isCityA, m, idx + 1);
         int moneyNext = mostMoney(nextCity, curCity, !isCityA, m, idx + 1) - m;
         int mostCur = curCity[idx] + Math.max(moneyCur, moneyNext);
         if (isCityA == true) {
             recA[idx] = mostCur;
         } else {
             recB[idx] = mostCur;
         }

         return  mostCur;
     }

3）记录下来之后，写成非递归形式

     private static int[] recA;
     private static int[] recB;
     public static void main(String[] args) {
         int[] cityA = {1,2,4,5,6,3,1};
         int[] cityB = {2,3,4,5,1,1,2};
         int m = 1;
         recA = new int[cityA.length];
         recB = new int[cityB.length];
         recA[cityA.length - 1] = cityA[cityA.length - 1];
         recB[cityB.length - 1] = cityB[cityB.length - 1];
         for (int i = cityA.length - 2; i >= 0; i--) {
             recA[i] = cityA[i] + Math.max(recA[i + 1], recB[i + 1] - m);
             recB[i] = cityB[i] + Math.max(recA[i + 1] - m, recB[i + 1]);
         }
         int res = Math.max(recA[0], recB[0]);
         System.out.println("res: " + res);
         System.out.println("recA: " + Arrays.toString(recA));
         System.out.println("recB: " + Arrays.toString(recB));
     }

5，时间复杂度：非递归形式是O（n）

6，api：无