文章目录
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 裴波那契数列
裴波那契数列的变形题有:
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 打家劫舍——环形
解法思路: 环状排列意味着第一个房子和最后一个房子中只能选择一个偷窃,因此可以把此环状排列房间问题约化为两个单排排列房间子问题:
- 在不偷窃第一个房子的情况下(即
nums[1:]nums[1:]nums[1:]
),最大金额是p1p_1p1
- 在不偷窃最后一个房子的情况下(即
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
- 这个方法主要是用来进行数组的复用,我遇到这个方法是在递归函数的调用中,这个方法比较的普遍,能够优化代码的结构。
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 零钱兑换
零钱兑换
思路:
首先:贪心算法未必能拿到最优解
解题的思路是动态规划:
- 定义数组
dp[]
,其中dp[i]
表示金额的最优解,即为组成金额i
最少使用的钞票数量- 计算金额
amount
的最优解,则需要dp
数组的长度为amount+1
,从而表示0
到金额amount
的最优解- 最初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;
}
}