【LEETCODE】59、数组分类，适中级别，题目：39、48、64

package y2019.Algorithm.array.medium;

import java.util.*;

/**
 * @ProjectName: cutter-point
 * @Package: y2019.Algorithm.array.medium
 * @ClassName: CombinationSum
 * @Author: xiaof
 * @Description: TODO 39. Combination Sum
 * Given a set of candidate numbers (candidates) (without duplicates) and a target number (target),
 * find all unique combinations in candidates where the candidate numbers sums to target.
 * The same repeated number may be chosen from candidates unlimited number of times.
 *
 * Input: candidates = [2,3,6,7], target = 7,
 * A solution set is:
 * [
 *   [7],
 *   [2,2,3]
 * ]
 *
 * @Date: 2019/7/18 9:02
 * @Version: 1.0
 */
public class CombinationSum {

    public List<List<Integer>> solution(int[] candidates, int target) {
        //这个题类似探索类，就是不断探索下一个元素是那个，那么我们就用递归做吧
        //为了避免递归的时候，吧上一层用过的递归数据再次使用，这里可以用排序,因为还可以放同一元素，所以下一层开始的位置可以是当前位置
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(candidates);
        findNum(res, new ArrayList<>(), candidates, target, 0);
        return res;
    }

    public void findNum(List<List<Integer>> res, List<Integer> curList, int[] nums, int target, int start) {
        if(target < 0) {
            //递归过深
            return;
        } else if(target == 0) {
            //成功,递归到最后一层了
            res.add(new ArrayList<>(curList));
        } else {
            //正常数据获取
            for(int i = start; i < nums.length; ++i) {
                //依次获取数据,因为是从小的往大的数据递归，那么比start位置小的已经递归过了
                curList.add(nums[i]);
                //递归进入下一层
                findNum(res, curList, nums, target - nums[i], i);
                //但是递归下层完毕，获取下一个数据的时候，我们把末尾的数据去掉
                curList.remove(curList.size() - 1); //因为有<0的情况，所以不一定就是当前的这个数据

            }
        }
    }

    public static void main(String[] args) {
        int data[] = {9,6,8,11,5,4};
        int n = 34;
        CombinationSum fuc = new CombinationSum();
        System.out.println(fuc.solution(data, n));
        System.out.println();
    }


}

package y2019.Algorithm.array.medium;

/**
 * @ProjectName: cutter-point
 * @Package: y2019.Algorithm.array.medium
 * @ClassName: Rotate
 * @Author: xiaof
 * @Description: TODO 48. Rotate Image
 * You are given an n x n 2D matrix representing an image.
 * Rotate the image by 90 degrees (clockwise).
 *
 * 给定一个 n × n 的二维矩阵表示一个图像。
 * 将图像顺时针旋转 90 度。
 *
 * Given input matrix =
 * [
 *   [1,2,3],
 *   [4,5,6],
 *   [7,8,9]
 * ],
 *
 * rotate the input matrix in-place such that it becomes:
 * [
 *   [7,4,1],
 *   [8,5,2],
 *   [9,6,3]
 * ]
 *
 * 学习大神操作：https://leetcode-cn.com/problems/rotate-image/solution/yi-ci-xing-jiao-huan-by-powcai/
 *
 * 像旋转数组的话，如果是90°旋转
 *
 * 1 2 3        7 4 1
 * 4 5 6  =》     8 5 2
 * 7 8 9     9 6 3
 * 计算公式：
 * (i, j)            ———————————->  (j, n - i - 1)
 *   ↑                                     |
 *   |                                     ↓
 * (n - j -1, i)     <———————————-  (n - i - 1, n - j - 1)
 *
 * @Date: 2019/7/18 10:00
 * @Version: 1.0
 */
public class Rotate {

    public void solution(int[][] matrix) {
        int n = matrix.length;
        for (int i = 0; i < n/2; i++ ) {
            for (int j = i; j < n - i - 1; j ++ ){
                int tmp = matrix[i][j];
                matrix[i][j] = matrix[n-j-1][i];
                matrix[n-j-1][i] = matrix[n-i-1][n-j-1];
                matrix[n-i-1][n-j-1] = matrix[j][n-i-1];
                matrix[j][n-i-1] = tmp;
            }
        }
    }

    public static void main(String[] args) {
        int data[][] = { {1,2,3}, {4,5,6}, {7,8,9}};
        Rotate fuc = new Rotate();
        fuc.solution(data);
        System.out.println();
    }
}

package y2019.Algorithm.array.medium;

/**
 * @ProjectName: cutter-point
 * @Package: y2019.Algorithm.array.medium
 * @ClassName: MinPathSum
 * @Author: xiaof
 * @Description: TODO 64. Minimum Path Sum
 *
 * Given a m x n grid filled with non-negative numbers,
 * find a path from top left to bottom right which minimizes the sum of all numbers along its path.
 *
 * Input:
 * [
 *   [1,3,1],
 *   [1,5,1],
 *   [4,2,1]
 * ]
 * Output: 7
 * Explanation: Because the path 1→3→1→1→1 minimizes the sum
 *
 * 说明：每次只能向下或者向右移动一步。
 *
 * 明显就是动态规划了
 * a{i,j} = min{a{i-1, j}, a{i, j - 1}}
 *
 * @Date: 2019/7/18 10:31
 * @Version: 1.0
 */
public class MinPathSum {

    public int solution(int[][] grid) {
        if(grid == null || grid.length <= 0 || grid[0].length <= 0) {
            return -1;
        }
        //动态规划数组
        int[][] res = new int[grid.length][grid[0].length];
        int r = grid.length, c = grid[0].length;
        res[0][0] = grid[0][0];
        //初始化第一条路,最开始的横向与纵向
        for(int i = 1; i < c; ++i) {
            res[0][i] = grid[0][i] + res[0][i - 1];
        }
        for(int j = 1; j < r; ++j) {
            res[j][0] = res[j - 1][0] + grid[j][0];
        }

        //开始线性规划
        for(int i = 1; i < r; ++i) {
            for(int j = 1; j < c; ++j) {
                res[i][j] = Math.min(res[i - 1][j], res[i][j - 1]) + grid[i][j];
            }
        }

        return res[r - 1][c - 1];

    }

}