打开代码随想录Day12

今天准备结束回溯的学习。首先遇到的就是一个hard，但是其实并不难，只是开始对题的理解有了偏差浪费了很多时间，最终3个小时才完成。

1.重新安排行程（力扣332）

本题首先注意同一个行程可能在给定数组出现了多次，对于这种关系到频率的要用map存放，保证不重复用，其次由于返回的答案要是字典排序的最小值，我们首先要对给定数组进行排序，这样一来得到的第一个满足要求的结果就是最终结果。

List<String> res = new ArrayList<>();//存放最终结果
List<List<String>> list = new ArrayList<>();//存放中间产生的路径
List<List<String>> list1 = new ArrayList<>();//存放结果候选集
HashMap<List<String>,Integer> hashMap = new HashMap();//防止重复
public List<String> findItinerary(List<List<String>> tickets) {
    for (int i = 0; i < tickets.size(); i++) {
        hashMap.put(tickets.get(i),hashMap.getOrDefault(tickets.get(i),0)+1);
    }
    Collections.sort(tickets, new Comparator<List<String>>() {
        @Override
        public int compare(List<String> o1, List<String> o2) {
            for (int i = 0; i < o1.size(); i++) {
                if(o1.get(i).compareTo(o2.get(i))!=0)
                    return o1.get(i).compareTo(o2.get(i));
            }
            return 0;
        }
    });
    reSort(tickets,0);
    return list1.get(0);
}
public void reSort(List<List<String>> tickets,int index){
    //由于排过序，找到的第一个即为答案
    if (list1.size() == 1)
        return;
    if(list.size() == tickets.size())
    {
        for (int i = 0; i < list.size(); i++) {
            res.add(list.get(i).get(0));
        }
        res.add(list.get(list.size()-1).get(1));
        list1.add(res);
        return;
    }
    if(tickets.size() == index)
        return;
    for (int i = 0; i < tickets.size(); i++) {
        if(list.size() == 0 && !tickets.get(i).get(0).equals("JFK"))
            continue;
        if (hashMap.get(tickets.get(i))==0)
            continue;
        if(list.size() == 0)
        {
            hashMap.put(tickets.get(i),hashMap.get(tickets.get(i))-1);
            list.add(tickets.get(i));
            reSort(tickets,index+1);
            list.remove(list.size()-1);
            hashMap.put(tickets.get(i),hashMap.get(tickets.get(i))+1);
        }
        if(list.size()>0 && list.get(list.size()-1).get(1).equals(tickets.get(i).get(0)))
        {
            hashMap.put(tickets.get(i),hashMap.get(tickets.get(i))-1);
            list.add(tickets.get(i));
            reSort(tickets,index+1);
            list.remove(list.size()-1);
            hashMap.put(tickets.get(i),hashMap.get(tickets.get(i))+1);
        }
    }
}

2.N皇后问题（力扣51）

对于题的理解不到位依然浪费了时间导致没能做出来，该题的目标是保证皇后在同一行、同一列、同一对角线只能有一个。

List<List<String>> res = new ArrayList<>();
public List<List<String>> solveNQueens(int n) {
    char[][] chars = new char[n][n];
    for (char[] c:chars
         ) {
        Arrays.fill(c,'.');
    }
    search(n,0,chars);
    return res;
}
public void search(int n, int row, char[][] chars){
    if (row == n) {
        List<String> list = new ArrayList<>();
        for (char[] c : chars) {
            list.add(String.copyValueOf(c));
        }
        res.add(list);
        return;
    }
    for (int col = 0;col < n; col++) {
        if (isValid (row, col, n, chars)) {
            chars[row][col] = 'Q';
            search(n, row+1, chars);
            chars[row][col] = '.';
        }
    }
}
public boolean isValid(int row, int col, int n, char[][] chars){
    //保证所在列没有皇后
    for (int i = 0; i < row; i++) {
        if(chars[i][col] == 'Q')
            return false;
    }
    //保证所位置左侧45度没有皇后
    for (int i = row-1,j = col-1; i >=0  && j >= 0; i--,j--) {
        if(chars[i][j] == 'Q')
            return false;
    }
    //保证所位置右侧45度没有皇后
    for (int i = row-1,j = col+1; i >= 0 && j <= n-1; i--,j++) {
        if(chars[i][j] == 'Q')
            return false;
    }
    return true;
}

3.N皇后问题2（力扣52）

本题较上题简单，不用将符合的结果列出，只用返回符合的结果的数量。就当作对N皇后问题的复习。

int res = 0;
List<String> list = new ArrayList<>();
public int totalNQueens(int n) {
    char[][] chars = new char[n][n];
    for (char[] c:
         chars) {
        Arrays.fill(c,'.');
    }
    search(n,0,chars);
    return res;
}
public void search(int n, int row, char[][] chars){
    if(row == n){
        res++;
        return;
    }
    for (int col = 0; col < n; col++) {
        if(isValid(n,row,col,chars)){
            chars[row][col] = 'Q';
            search(n,row+1,chars);
            chars[row][col] = '.';
        }
    }
}
public boolean isValid(int n, int row, int col, char[][] chars){
    //保证一列只有一个皇后
    for (int i = 0; i < row; i++) {
        if(chars[i][col] == 'Q')
            return false;
    }
    //保证左上对角线上没有皇后
    for (int i = row-1,j=col-1; i >=0&&j>=0 ; i--,j--) {
        if(chars[i][j] == 'Q')
            return false;
    }
    //保证右上对角线上没有皇后
    for (int i = row-1,j=col+1; i >= 0 && j <= n-1 ; i--,j++) {
        if(chars[i][j] == 'Q')
            return false;
    }
    return true;
}

4.解数独（37）

由于在数组全部填充完成时才能返回，因此用Boolean作为回溯方法的返回值，其次由于本题中二维数组的每一行每一列都有需要填的值，因此要用两个for循环才能满足填充。

public void solveSudoku(char[][] board) {
    search(board);
}
public boolean search(char[][] board){
    for (int i = 0; i < board.length; i++) {
        for (int j = 0; j < board[i].length; j++) {
            if(board[i][j] != '.')
                continue;
            for (char k = '1'; k <= '9'; k++) {
                if(isValid(board,i,j,k)){
                    board[i][j] = k;
                    if(search(board))
                        return true;
                    board[i][j] = '.';
                }
            }
            //本位置不能填充时直接返回false
            return false;
        }
    }
    return true;
}
public boolean isValid(char[][] board,int row,int col,char val){
    //保证本行不重复
    for (int i = 0; i < board[row].length; i++) {
        if (board[row][i] == val){
            return false;
        }
    }
    //保证本列不重复
    for (int i = 0; i < board.length; i++) {
        if (board[i][col] == val){
            return false;
        }
    }
    //保证在3*3方格只出现一次
    int startRow = (row / 3) * 3;
    int startCol = (col / 3) * 3;
    for (int i = startRow; i < startRow + 3; i++){
        for (int j = startCol; j < startCol + 3; j++){
            if (board[i][j] == val){
                return false;
            }
        }
    }
    return true;
}

5.分发饼干（力扣455）

以本题作为学习贪心算法的入门。

public int findContentChildren(int[] g, int[] s) {
    int count = 0;
    Arrays.sort(g);
    Arrays.sort(s);
    for (int i = 0,j = 0; i < g.length && j< s.length;) {
        if(g[i] <= s[j]){
            count++;
            i++;
            j++;
        }
        else {
            j++;
        }
    }
    return count;
}

6.摆动序列（力扣376）

本题一直没有思路，直至看了题解豁然开朗，用两个变量记录上次和本次差值，符合条件则count++以及把cur赋值给pre，继续循环。

public int wiggleMaxLength(int[] nums) {
    if(nums.length <=1 )
        return nums.length;
    //记录当前差值
    int cur = 0;
    //记录上一次的差值
    int pre = 0;
    int count = 1;
    for (int i = 1; i < nums.length; i++) {
        cur = nums[i] - nums[i-1];
        //pre有可能等于零是因为初始化为0了，而cur不能为零，因为差要严格正或负
        if((cur > 0 && pre <= 0) || (cur < 0 && pre >= 0)){
            count++;
            pre = cur;
        }
    }
    return count;
}

*7.最大子数组和（力扣53）

本题用count来统计子数组和，res存放和的最大值，当count为负时下一轮重置为0（因为加上负的只会让和更小）。负数只会拖累总和。需要有这样的思想！

public int maxSubArray(int[] nums) {
    if(nums.length == 1)
        return nums[0];
    int res = Integer.MIN_VALUE;
    int count = 0;
    for (int i = 0; i < nums.length; i++) {
        count += nums[i];
        if(count > res)
            res = count;
        if (count <= 0){
            count = 0;
        }
    }
    return res;
}

8.买卖股票的最佳时机2（力扣122）

如果后一天股价高则今天买，若后一天股价低则今天卖，最后都没卖时最后卖，最后都没买时就不买。或者直接将利润分解为每一天的，若每一天利润为正的则收集，负的不管。

//    public int maxProfit(int[] prices) {
//        int count = 0;
//        //-1代表还没有买，买了之后buy记录购买那天的下标
//        int buy = -1;
//        for (int i = 1; i < prices.length ; i++) {
//            //如果比前一天高但还没买，就在前一天买
//            if(prices[i] - prices[i-1] > 0 && buy == -1){
//                buy = i-1;
//            }
//            //如果比前一天低但还没卖，就在前一天卖
//            if(prices[i] - prices[i-1] < 0 && buy != -1){
//                count += prices[i-1] - prices[buy];
//                buy = -1;
//            }
//            //到最后还没有卖，最后卖掉
//            if(i == prices.length-1 && buy!=-1){
//                count += prices[prices.length-1] - prices[buy];
//            }
//        }
//        return count;
//    }
    public int maxProfit(int[] prices) {
        int result = 0;
        for (int i = 1; i < prices.length; i++) {
            result += Math.max(prices[i] - prices[i - 1], 0);
        }
        return result;
    }

9.跳跃游戏（力扣55）

换一种思想，用能到达的范围算。

public boolean canJump(int[] nums) {
    if(nums.length == 1)
        return true;
    //记录每次能到达最远的范围，一旦范围达到或超过最后一个下标则返回true
    int range = 0;
    for (int i = 0; i <= range; i++) {
        if(range < i + nums[i])
            range = i + nums[i];
        if(range >= nums.length-1)
            return true;
    }
    return false;
}