最大利润-城市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：无