【20210807奇安信】java编程题

第一题：从数组中找出三个数字为排序的子数组的个数，三个数字组成的子数组可以为降序或者升序

import java.util.ArrayList;
import java.util.List;

/**
 * @create 2021-08-07 16:25
 */
public class Solution1 {
    public static void main(String[] args) {
        int[] nums = {1,5,3,2,4};
        Solution1 solution1 = new Solution1();
        solution1.TeamNums(nums);
        System.out.println(list.size());
    }

    /**
     * 从数组中找出三个数字 为排序的子数组的个数
     * 输入：[1,5,3,2,4]
     * 输出：3
     * 说明：（1,3,4），（1,2,4），（5,3,2）
     * @param height
     * @return
     */
    static List<ArrayList<Integer>> list = new ArrayList<>();
    public int TeamNums (int[] height) {
        // write code here
        if (height == null || height.length <3){
            return 0;
        }
        int count = 0;//满足条件的队伍数量
        //回溯法取3个，取出来的判断是否为排序
        dfs(0,height,new ArrayList<Integer>());
        return list.size();
    }

    public void dfs(int index, int[] height, ArrayList<Integer> sublist){
        if(sublist.size() == 3){
            //判断是不是排序数组
            if (sublist.get(0) < sublist.get(1) && sublist.get(1) < sublist.get(2)){
                list.add(new ArrayList<>(sublist));
            }else if (sublist.get(0) > sublist.get(1) && sublist.get(1) > sublist.get(2)){
                list.add(new ArrayList<>(sublist));
            }
            return;
        }

        for (int i = index; i < height.length; i++) {
            int num = height[i];
            sublist.add(num);
            dfs(++index,height,sublist);
            sublist.remove(sublist.size()-1);
        }
    }
}

第二题：迷宫问题，给一个二维数组，0表示障碍不能走，数字表示要收集的资源，可以从任意不为0的位置开始收集，不走回头路，可上下左右收集，问可以收集到的最大资源是多少。

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * @create 2021-08-07 16:41
 */
public class Solution2 {
    public static void main(String[] args) {
        int[][] grid = {{0,6,0},{5,8,7},{0,9,0}};
//        int[][] grid = {{1,0,7},{2,0,6},{3,4,5},{0,3,0},{9,0,20}};
        Solution2 solution2 = new Solution2();
        int maximumResource = solution2.getMaximumResource(grid);
        System.out.println(maximumResource);
    }


    /**
     * 数组中总和最大的通路，不走回头路,利益最大化，不走0,0就是障碍
     * 输入：[[0,6,0],[5,8,7],[0,9,0]]
     * 输出：24
     * 收集线路为7->8->9
     *
     * [[1,0,7],[2,0,6],[3,4,5],[0,3,0],[9,0,20]]
     * 28
     * 说明：1,2,3,4,5,6,7
     * @param grid
     * @return
     */
    public int getMaximumResource (int[][] grid) {
        // write code here
        if (grid.length == 0 || grid[0].length == 0){
            return 0;
        }
        int maxValue = 0;//保存可走通路径的最大值
        int rows = grid.length;
        int cols = grid[0].length;
        boolean[][] visited = new boolean[rows][cols];//访问数组
        //每一个不为0的数字都可以作为开始
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (grid[i][j] != 0){
//                    maxV = 0;//也不用置零
//                    res = 0;//每次回溯结束res都会被减到0
                    //返回以每个非0数字开始的通路的最大值
                    dfs(grid, visited, i, j);
                    maxValue = Math.max(maxValue, maxV);
                }
            }
        }
        return maxValue;
    }

    private static int maxV = 0;//最大值
    private static int res = 0;//路经总和
    public void dfs(int[][] grid, boolean[][] visited, int row, int col){
        //超出边界时就可以比较并保存最大值
        if (row<0||row>=grid.length|| col<0||col>=grid[0].length){
            maxV = Math.max(maxV,res);
            return;
        }
        if(visited[row][col]|| grid[row][col]==0){
            return;
        }
        visited[row][col] = true;
        res += grid[row][col];
        dfs(grid,visited,row+1,col);
        dfs(grid,visited,row,col+1);
        dfs(grid,visited,row-1,col);
        dfs(grid,visited,row,col-1);
        res -= grid[row][col];
        visited[row][col] = false;
    }
}