需要把这道题从brute force 分析， 然后找到重复的计算， 然后一步步优化， 一直到 一维dp. 
分析时间复杂度


https://www.youtube.com/watch?v=_MYkrCfFb4M


LeetCode wants to give one of its best employees the option to travel among N cities to collect algorithm problems. But all work and no play makes Jack a dull boy, you could take vacations in some particular cities and weeks. Your job is to schedule the traveling to maximize the number of vacation days you could take, but there are certain rules and restrictions you need to follow.
Rules and restrictions:

1. You can only travel among N cities, represented by indexes from 0 to N-1. Initially, you are in the city indexed 0 on Monday.
2. The cities are connected by flights. The flights are represented as a N*N matrix (not necessary symmetrical), called flights representing the airline status from the city i to the city j. If there is no flight from the city i to the city j, flights[i][j] = 0; Otherwise, flights[i][j] = 1. Also, flights[i][i] = 0 for all i.
3. You totally have K weeks (each week has 7 days) to travel. You can only take flights at most once per day and can only take flights on each week's Monday morning. Since flight time is so short, we don't consider the impact of flight time.
4. For each city, you can only have restricted vacation days in different weeks, given an N*K matrix called days representing this relationship. For the value of days[i][j], it represents the maximum days you could take vacation in the city i in the week j.

You're given the flights matrix and days matrix, and you need to output the maximum vacation days you could take during K weeks.
Example 1:

Input:flights = [[0,1,1],[1,0,1],[1,1,0]], days = [[1,3,1],[6,0,3],[3,3,3]]
Output: 12
Explanation: 
Ans = 6 + 3 + 3 = 12. 
One of the best strategies is:
1st week : fly from city 0 to city 1 on Monday, and play 6 days and work 1 day. 
(Although you start at city 0, we could also fly to and start at other cities since it is Monday.) 
2nd week : fly from city 1 to city 2 on Monday, and play 3 days and work 4 days.
3rd week : stay at city 2, and play 3 days and work 4 days.

Example 2:

Input:flights = [[0,0,0],[0,0,0],[0,0,0]], days = [[1,1,1],[7,7,7],[7,7,7]]
Output: 3
Explanation: 
Ans = 1 + 1 + 1 = 3. 
Since there is no flights enable you to move to another city, you have to stay at city 0 for the whole 3 weeks. 
For each week, you only have one day to play and six days to work. 
So the maximum number of vacation days is 3.

Example 3:

Input:flights = [[0,1,1],[1,0,1],[1,1,0]], days = [[7,0,0],[0,7,0],[0,0,7]]
Output: 21
Explanation:
Ans = 7 + 7 + 7 = 21
One of the best strategies is:
1st week : stay at city 0, and play 7 days. 
2nd week : fly from city 0 to city 1 on Monday, and play 7 days.
3rd week : fly from city 1 to city 2 on Monday, and play 7 days.





Naive DFS -> DFS w/ memo -> 2D-DP -> 1D-DP
https://leetcode.com/problems/maximum-vacation-days/discuss/159704/Naive-DFS-greater-DFS-w-memo-greater-2D-DP-greater-1D-DP



class Solution {
    public int maxVacationDays(int[][] flights, int[][] days) {
        
    }
}

Solution 1. DFS. The idea is just try each possible city for every week and keep tracking the max vacation days. Time complexity O(N^K). Of course it will TLE....
Input:flights = [[0,1,1],[1,0,1],[1,1,0]], days = [[1,3,1],[6,0,3],[3,3,3]]
Output: 12
Explanation: 
Ans = 6 + 3 + 3 = 12. 

One of the best strategies is:
1st week : fly from city 0 to city 1 on Monday, and play 6 days and work 1 day. 
(Although you start at city 0, we could also fly to and start at other cities since it is Monday.) 
2nd week : fly from city 1 to city 2 on Monday, and play 3 days and work 4 days.
3rd week : stay at city 2, and play 3 days and work 4 days.
    
    
                city
    flights = [[0,1,1],
               [1,0,1],
               [1,1,0]],


        week
days = [[1,3,1],
  city  [6,0,3],
        [3,3,3]]
    
    


S1. Naive DFS(TLE)
            
            // you start at city 0, 

class Solution {
    int max;
    public int maxVacationDays(int[][] flights, int[][] days) {
        int city = days.length, week = days[0].length;
        helper(flights, days, 0, 0, 0, city, week);
        return maxx;
    }
    public void helper(int[][] flights, int[][] days, int curWeek, int curPos, int sum, int city, int week){
        if(curWeek == week){ // how many levels ? number of weeks level, for every week , we can stay at different cities  
            max = Math.max(max, sum);
            return;
        }
        for(int i = 0; i < city; i++){
            if(curPos == i || flights[curPos][i] == 1){
                helper(flights, days, curWeek + 1, i, sum + days[i][curWeek], city, week);
            }
            
        }
    }
}



    
                city
    flights = [[0,1,1],
               [1,0,1],
               [1,1,0]],


        week
days = [[1,3,1],
  city  [6,0,3],
        [3,3,3]]

Then use memo array to pruning

S2. DFS w/ memo
// top down dfs + memo
class Solution {
    public int maxVacationDays(int[][] flights, int[][] days) {
        int city = days.length, week = days[0].length;
        int[][]memo = new int[city][week];
        return helper(flights, days, 0, 0, city, week, memo);
    }
    public int helper(int[][] flights, int[][] days, int curWeek, int curPos,int city, int week, int[][] memo){
        // base case 
        if(curWeek == week){
            return 0;
        }
        if(memo[curPos][curWeek] != 0){
            return memo[curPos][curWeek];
        }
        int res = 0;
        for(int i = 0; i < city; i++){
            if(curPos == i || flights[curPos][i] == 1){
                res = Math.max(res, days[i][curWeek] + helper(flights, days, curWeek + 1, i, city, week, memo));
            }
        }
        memo[curPos][curWeek] = res;
        return res;
    }
}



class Solution {
    public int maxVacationDays(int[][] flights, int[][] days) {
        int city = days.length;
        int week = days[0].length;
        int[][] memo = new int[city][week];
        return dfs(flights, days, 0, 0, city, week, memo);
    }
    private int dfs(int[][] flights, int[][] days, int curWeek, int curCity, int numCity, int numWeek, int[][] memo){
        // base case 
        if(curWeek == numWeek){
            return 0;
        }
        
        if(memo[curCity][curWeek] != 0){
            return memo[curCity][curWeek];
        }
        
        int res = 0;
        for(int i = 0; i < numCity; i++){
            if(i == curCity || flights[curCity][i] == 1){
                // stay in the current city or we can fly to a differnt city 
                res = Math.max(res, days[i][curWeek] + dfs(flights, days, curWeek + 1, i, numCity, numWeek, memo));
            }
        }
        memo[curCity][curWeek] = res;
        return res;
        
    }
}






// longest increasing path in a matrix : this is also dfs + memo
// it's also top down, and use call stack 
// the code format is very similar to the one above 

//  private int dfs(int[][] matrix, int i, int j, int[][] record){
//       int length = 1;
      
//       // base case 
//       if(record[i][j] != 0) return record[i][j];
      
//       // else do regular dfs on 4 dirs and see if the nei is out of boundary and check ifs its increasing 
//       for(int[] dir : dirs){
//         int row = i + dir[0];
//         int col = j + dir[1];
        
//         // check boundary 
//         if(row < 0 || col < 0 || row >= matrix.length || col >= matrix[0].length || matrix[i][j] >= matrix[row][col]) continue;
        
//         // else, it's nei is bigger than the current num at matrix[i][j]
//         int thisDir = dfs(matrix, row, col, record);
//         length = Math.max(length, 1 + thisDir);
//       }
//       record[i][j] = length;
//       return length;
//     }
// }






Solution 2. DP. dp[i][j] stands for the max vacation days we can get in week i staying in city j. It's obvious that dp[i][j] = max(dp[i - 1][k] + days[j][i]) (k = 0...N - 1, if we can go from city k to city j). Also because values of week i only depends on week i - 1, so we can compress two dimensional dp array to one dimension. Time complexity O(K * N * N) as we can easily figure out from the 3 level of loops.

public class Solution {
    public int maxVacationDays(int[][] flights, int[][] days) {
        int N = flights.length;
        int K = days[0].length;
        int[] dp = new int[N];
        Arrays.fill(dp, Integer.MIN_VALUE);
        dp[0] = 0;
        
        for (int i = 0; i < K; i++) {
            int[] temp = new int[N];
            Arrays.fill(temp, Integer.MIN_VALUE);
            for (int j = 0; j < N; j++) {
                for(int k = 0; k < N; k++) {
                    if (j == k || flights[k][j] == 1) {
                        temp[j] = Math.max(temp[j], dp[k] + days[j][i]);
                    }
                }
            }
            dp = temp;
        }
        
        int max = 0;
        for (int v : dp) {
            max = Math.max(max, v);
        }
        
        return max;
    }
}




S3. 2D-DP

Note:
We need to initialize dp array to MIN_VALUE so as to exclude the unconnected flights.

class Solution {
    public int maxVacationDays(int[][] flights, int[][] days) {
        int city = days.length;
        int week = days[0].length;
        int[][]dp = new int[week][city];
        for(int i = 0; i < week; i++){
            Arrays.fill(dp[i], Integer.MIN_VALUE);
        }
        dp[0][0] = 0;
        for(int i = 0; i < week; i++){
            if(i == 0){
                for(int j = 0; j < city; j++){
                    if(i == j || flights[i][j] == 1){
                        dp[i][j] = days[j][i];
                    }
                }
            }else{
                for(int j = 0; j < city; j++){
                    for(int k = 0; k < city; k++){
                        if(j == k || flights[k][j] == 1){
                            dp[i][j] = Math.max(dp[i][j], dp[i-1][k] + days[j][i]);
                        }
                    }
                }
            }
            
        }
        int ans = 0;
        for(int i : dp[week-1]){
            ans = Math.max(ans, i);
        }

        return ans;
    }
}
At last, in dp array, we only need current week and the week before, so we can reduce space complexity to O(n):

S4. 1D-DP

class Solution {
    public int maxVacationDays(int[][] flights, int[][] days) {
        int city = days.length;
        int week = days[0].length;
        int[]dp = new int[city];
        Arrays.fill(dp, Integer.MIN_VALUE);
        dp[0] = 0;
        for(int i = 0; i < week; i++){
            int[]tmp = new int[city];
            Arrays.fill(tmp, Integer.MIN_VALUE);
            for(int j = 0; j < city; j++){
                for(int k = 0; k < city; k++){
                    if(k == j || flights[k][j] == 1){
                        tmp[j] = Math.max(tmp[j], dp[k] + days[j][i]);
                    }
                }
            }
            dp = tmp;
        }
        int ans = 0;
        for(int i : dp){
            ans = Math.max(ans, i);
        }

        return ans;
    }
}