Leetcode - 数组

1. 数组

1.1 寻找两个正序数组的中位数

寻找两个正序数组的中位数

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int n1 = nums1.length;
        int n2 = nums2.length;
        int[] nums = new int[n1 + n2];
        System.arraycopy(nums1, 0, nums, 0, n1);
        System.arraycopy(nums2, 0, nums, n1, n2);
        Arrays.sort(nums);
        int n = nums.length;
        if (n % 2 == 0) {
            return (nums[(n/2)-1] + nums[n/2])/2.0;
        } else {
            return nums[n/2];
        }
    }
}

1.2 二分查找

二分查找

class Solution {
    public int search(int[] nums, int target) {
        int start = 0;
        int end = nums.length-1;
        int mid = -1;
        while(start <= end){
            mid = (end-start)/2+start;
             if(nums[mid] == target){
                 return mid;
             }
             if(nums[mid] > target){
                 end = mid -1;
             }
             if(nums[mid]<target){
                 start=mid+1;
             }
        }
        return -1;
    }
}

1.3 跳跃游戏

跳跃游戏
这题应该可以采用动态规划的思想，但参考了其他方法.

class Solution {
    public boolean canJump(int[] nums) {
        if (nums == null){
            return false;
        }
        int k = 0;
        int n =nums.length;//数组的长度
        for(int i = 0; i<n ;i++){
            if(i>k){
                return false;
            }
            k = Math.max(k,i+nums[i]);
        }
        return true;
    }
}

2. 数组 - 动态规划

2.1 裴波那契数列

裴波那契数列

裴波那契数列的变形题有：

1. 第 N 个泰波那契数(1137)
2. 爬楼梯(70)

class Solution {
    public int fib(int n) {
        int[] dp = new int[n + 100];
        dp[0] = 0;
        dp[1] = 1;
        for(int i = 2;i<=n;i++){
            dp[i] = dp[i-1] + dp[i-2];
        }
        return dp[n];
    }
}

2.2 打家劫舍——线形

打家劫舍

类似题：
按摩师

class Solution {
    public int rob(int[] nums) {
        int n =nums.length;
        if(n == 0) return 0;
        if(n == 1) return nums[0];
        int[] arr = new int[n+1];
        arr[0] = nums[0];
        arr[1] = Math.max(nums[0],nums[1]);
        for(int i=2;i<n;i++){
            arr[i] = Math.max(arr[i-1],arr[i-2]+nums[i]);
        }
        return arr[n-1];
    }
}

2.3 打家劫舍——环形

打家劫舍

解法思路： 环状排列意味着第一个房子和最后一个房子中只能选择一个偷窃，因此可以把此环状排列房间问题约化为两个单排排列房间子问题：

1. 在不偷窃第一个房子的情况下（即 nums[1:]nums[1:]nums[1:]），最大金额是 p1p_1p1​
2. 在不偷窃最后一个房子的情况下（即 nums[:n−1]nums[:n-1]nums[:n−1]），最大金额是 p2p_2p2​ * 综合偷窃最大金额： 为以上两种情况的较大值，即 max(p1,p2)max(p1,p2)max(p1,p2)

另外，需要特别介绍Java中的Arrays.copyOfRange()方法,要引用 import java.util.Arrays

1. 这个方法主要是用来进行数组的复用，我遇到这个方法是在递归函数的调用中，这个方法比较的普遍，能够优化代码的结构。
2. array=Arrays.copyOfRange(oringinal,int from, int to) 此时要注意下标的变化，array拷贝original数组从from下标开始，一直到to下标结束，注意包含from下标，不包含to下标，是左闭右开区间。

class Solution {
    public int rob(int[] nums) {
        int n = nums.length;
        if(n == 0) return 0;
        if(n == 1) return nums[0];
        return Math.max(x_rob(Arrays.copyOfRange(nums, 0, n - 1)),
                       x_rob(Arrays.copyOfRange(nums, 1, nums.length)) );

    }
    public int x_rob(int[] nums) {
        int n =nums.length;
        if(n == 0) return 0;
        if(n == 1) return nums[0];
        int[] arr = new int[n+1];
        arr[0] = nums[0];
        arr[1] = Math.max(nums[0],nums[1]);
        for(int i=2;i<n;i++){
            arr[i] = Math.max(arr[i-1],arr[i-2]+nums[i]);
        }
        return arr[n-1];
    }
}

2.4 零钱兑换

零钱兑换
思路：

首先：贪心算法未必能拿到最优解

解题的思路是动态规划：

1. 定义数组 dp[] ,其中 dp[i] 表示金额的最优解，即为组成金额 i 最少使用的钞票数量
2. 计算金额 amount 的最优解，则需要 dp 数组的长度为 amount+1，从而表示 0 到金额 amount 的最优解
3. 最初dp数组所有元素初始化为 -1 ，dp[0] 为金额 0 的最优解初始化为 0，完成 dp 数组的计算后，将金额 amount 的最优解 dp[amount] 返回

class Solution {
    public int coinChange(int[] coins, int amount) {
        int n = coins.length;
        int[] dp = new int[amount + 1];
        Arrays.fill(dp, amount+1);
        dp[0] = 0;
        for (int i = 1; i <= amount; i++) {
            for (int j = 0; j < n; j++) {
                if (coins[j] <= i) {
                    dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1);
                }
            }
        }
        return dp[amount] > amount ? -1 : dp[amount];
    }
}

2.5 删除并获得点数

删除并获得点数

class Solution {
    public int deleteAndEarn(int[] nums) {
        int n = nums.length;
        if(n == 0) return 0;
        if(n == 1) return nums[0];
        //找出数组里的最大数
        int max = nums[0];
        for(int i = 1;i<n;i++){
            max = Math.max(max,nums[i]);
        }
        //构造新的数组dp
        int[] sum = new int[ max + 1 ];
        for (int item : nums) {
            sum[item] ++;
        }
        //动态规划
        int[] dp = new int[max + 1];
        dp[1] = sum[1] * 1;
        dp[2] = Math.max(dp[1], sum[2] * 2);
        for (int i = 2; i <= max; ++i) {
            dp[i] = Math.max(dp[i - 1], dp[i - 2] + i * sum[i]);
        }
        return dp[max];
    }
}

2.6 最大子数组和

最大子数组和

class Solution {
    public int maxSubArray(int[] nums) {
        // f(i)=max{f(i−1)+nums[i],nums[i]}
        int n = nums.length;
        //int[] dp = new int[n+1];
        int pre = 0,maxAns = nums[0];
        for(int i = 0;i<n;i++){
            pre = Math.max(pre+nums[i],nums[i]);
            maxAns = Math.max(maxAns,pre);
        }
        return maxAns;
    }
}

2.7 买卖股票的最佳时机

买卖股票的最佳时机

class Solution {
    public int maxProfit(int[] prices) {
        if(prices.length <= 1)
            return 0;
        int min = prices[0], max = 0;
        for(int i = 1; i < prices.length; i++) {
            //记录最小买入值
            min = Math.min(min, prices[i]);
            //记录利润最大值
            max = Math.max(max, prices[i] - min);
        }
        return max;
    }
}

2.8 最佳观光组合

最佳观光组合

class Solution {
    public int maxScoreSightseeingPair(int[] values) {
        int n = values.length,mx = values[0] + 0,ans = 0;
        for(int j = 1; j < n; j++){
            ans = Math.max(ans , mx + values[j] - j);
            mx = Math.max(mx, values[j] + j);
        }
        return ans;
    }
}