669 · 换硬币
LintCode原题链接：669 · 换硬币
题目分析
设f[i]为需要多少硬币来凑出i，以最后一个硬币硬币为突破口，假设最后一个硬币值为a,则只需算出f[i-a]的值为多少，加一即可，是一个典型的动态规划问题，若凑不出来则置为-1。
源码
public class Solution {
/**
* @param coins: a list of integer
* @param amount: a total amount of money amount
* @return: the fewest number of coins that you need to make up
*/
public int coinChange(int[] coins, int amount) {
// write your code here
int n = coins.length;
int[] dp = new int[amount + 1];
//初始化
dp[0] = 0;
for (int i = 1; i <= amount; i++) {
dp[i] = Integer.MAX_VALUE;
for (int j = 0; j < n; j++) {
if (i >= coins[j] && dp[i - coins[j]] != Integer.MAX_VALUE)
dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1);
}
}
return dp[amount] == Integer.MAX_VALUE ? -1 : dp[amount];
}
}
114 · 不同的路径
LintCode原题链接：114 · 不同的路径
题目分析
到达某一点的路径数目等于到达该点左边和上边的点的路径的数目之和，即状态转移方程为f[i][j] = f[i - 1][j] + f[i][j - 1],初始化f[1][1] = 1
源码
public class Solution {
/**
* @param m: positive integer (1 <= m <= 100)
* @param n: positive integer (1 <= n <= 100)
* @return: An integer
*/
public int uniquePaths(int m, int n) {
// write your code here
int[][] f = new int[m + 1][n + 1];
f[1][1] = 1;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if(i == 1 && j == 1) continue;
f[i][j] = f[i - 1][j] + f[i][j - 1];
}
}
return f[m][n];
}
}
116 · 跳跃游戏
LintCode原题链接：116 · 跳跃游戏
题目分析
这道题用DP来做时间复杂度为O(N^2)，用贪心来做时间复杂度为O(N)，在能跳到当前位置的情况下，加上步长能到达下一步，则下一步也能到达，转移方程为if(f[j] && j + A[j] >= i) f[i] = true
源码
DP解法
public class Solution {
/**
* @param A: A list of integers
* @return: A boolean
*/
public boolean canJump(int[] A) {
// write your code here
if (A == null && A.length == 0) return false;
int n = A.length;
boolean[] f = new boolean[n];
f[0] = true;
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if(f[j] && j + A[j] >= i)
f[i] = true;
}
}
return f[n - 1];
}
}
贪心解法
// Greedy
public class Solution {
/**
* @param A: A list of integers
* @return: A boolean
*/
public boolean canJump(int[] A) {
// write your code here
if (A == null && A.length == 0) return false;
int n = A.length;
int path = A[0];
for (int i = 0; i < n; i++) {
if(i <= path && i + A[i] >= path) path = i + A[i];
}
return path >= A.length - 1;
}
}
115 · 不同的路径 II
LintCode原题链接：115 · 不同的路径 II
题目分析
这道题承接着115不同的路径，状态转移方程与其一样，唯一变化的是有了限定，在障碍处状态转移方程不适用。
源码
public class Solution {
/**
* @param A: A list of lists of integers
* @return: An integer
*/
public int uniquePathsWithObstacles(int[][] A) {
// write your code here
int n = A.length;
if (n == 0) return 0;
int m = A[0].length;
if (m == 0) return 0;
int[][] f = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (A[i][j] != 1) {
if (i + j == 0) f[i][j] = 1;
if (i != 0) f[i][j] += f[i - 1][j];
if (j != 0) f[i][j] += f[i][j - 1];
}
}
}
return f[n - 1][m - 1];
}
}
515 · 房屋染色
LintCode原题链接：515 · 房屋染色
题目分析
这是一个序列性的动态规划，与前面坐标型的动态规划问题不同。我们有三种染色的方式。突破口在于，最后一栋房子染色时，前面的染色方式所花费的价值最小，但我们并不知道i - 1栋房子染成哪种颜色，因此我们将三种颜色的染色方式都保存下来，最后我们再比较三种染色方式所花费的价值的大小。
源码
public class Solution {
/**
* @param costs: n x 3 cost matrix
* @return: An integer, the minimum cost to paint all houses
*/
public int minCost(int[][] costs) {
// write your code here
int n = costs.length;
int[][] f = new int[n + 1][3];
//初始化
f[0][0] = f[0][1] = f[0][2] = 0;
for(int i = 1; i <= n; i++) {
f[i][0] = Math.min(f[i - 1][1] + costs[i - 1][0], f[i - 1][2] + costs[i - 1][0]);
f[i][1] = Math.min(f[i - 1][0] + costs[i - 1][1], f[i - 1][2] + costs[i - 1][1]);
f[i][2] = Math.min(f[i - 1][0] + costs[i - 1][2], f[i - 1][1] + costs[i - 1][2]);
}
return Math.min(Math.min(f[n][0], f[n][1]), f[n][2]);
}
}
516 · 房屋染色 II
LintCode原题链接：516 · 房屋染色 II
题目分析
本题是 515 房屋染色的进阶，总体思路一样，在k种染色情况下，很容易用O(N*K^2)的时间复杂度解出问题，但在计算最小值时出现了大量的重复计算，当去除最小值时，最小值为次小值，否则则为最小值这样可以优化到O(N*K)的时间复杂度。
源码
O(N*K^2)
public class Solution {
/**
* @param costs: n x k cost matrix
* @return: an integer, the minimum cost to paint all houses
*/
public int minCostII(int[][] costs) {
// write your code here
int n = costs.length;
if (n == 0) return 0;
int k = costs[0].length;
if (k == 0) return 0;
if (k == 1) return costs[0][0];
int[][] f = new int[n + 1][k];
for (int i = 0; i < k; i++) f[0][i] = 0;
for (int i = 1; i <= n; i++) {
for (int key = 0; key < k; key++) {
int ans = 0xfffff;
for (int j = 0; j < k; j++) {
if (key != j) {
ans = Math.min(f[i - 1][j] + costs[i - 1][key],ans);
}
}
f[i][key] = ans;
}
}
int res = f[n][0];
for (int i = 0; i < k; i++) {
res = Math.min(res, f[n][i]);
}
return res;
}
}
O(N*K)
public class Solution {
/**
* @param costs: n x k cost matrix
* @return: an integer, the minimum cost to paint all houses
*/
public int minCostII(int[][] costs) {
// write your code here
int n = costs.length;
if (n == 0) return 0;
int k = costs[0].length;
if (k == 0) return 0;
if (k == 1) return costs[0][0];
int[][] f = new int[n + 1][k];
int min1, min2;
int j1 = 0, j2 = 0;
for (int i = 0; i < k; i++) f[0][i] = 0;
for (int i = 1; i <= n; i++) {
min1 = min2 = Integer.MAX_VALUE;
int ans = 0xfffff;
for (int j = 0; j < k; j++) {
if (f[i - 1][j] < min1) {
min2 = min1;
j2 = j1;
min1 = f[i - 1][j];
j1 = j;
} else {
if (f[i - 1][j] < min2) {
min2 = f[i - 1][j];
j2 = j;
}
}
}
for (int j = 0; j < k; j++) {
if(j != j1) f[i][j] = f[i - 1][j1] + costs[i - 1][j];
else f[i][j] = f[i - 1][j2] + costs[i - 1][j];
}
}
int res = f[n][0];
for (int i = 0; i < k; i++) {
res = Math.min(res, f[n][i]);
}
return res;
}
}
512 · 解码方法
LintCode原题链接：512 · 解码方法
题目分析
突破口依旧在于最后的位置，如果最后一个字符满足1~9的条件，则f[i + 1] += f[i],如果最后两位满足，则f[i + 1] += f[i - 1]
源码
public class Solution {
/**
* @param s: a string, encoded message
* @return: an integer, the number of ways decoding
*/
public int numDecodings(String s) {
// write your code here
char[] ss = s.toCharArray();
int n = ss.length;
if (n == 0) return 0;
int[] f = new int[n + 1];
f[0] = 1;
for (int i = 0; i < n; i++) {
int t = ss[i] - '0';
if (t >= 1 && t <= 9) f[i + 1] += f[i];
if (i >= 1) {
t = (ss[i - 1] - '0') * 10 + ss[i] - '0';
if (t >= 10 && t <= 26) f[i + 1] += f[i - 1];
}
}
return f[n];
}
}
397 · 最长上升连续子序列
LintCode原题链接：397 · 最长上升连续子序列
题目分析
两个方向分别遍历一次，按递增或者递减的顺序遍历，遍历过程中保存序列的长度，取两个不同顺序长度的最大值。
源码
public class Solution {
/**
* @param A: An array of Integer
* @return: an integer
*/
public int longestIncreasingContinuousSubsequence(int[] A) {
// write your code here
if(A == null || A.length == 0) return 0;
int n = A.length;
int ans = 1;
int len = 1;
for (int i = 1; i < n; i++) {
if (A[i] > A[i - 1]) len++;
else len = 1;
ans = Math.max(ans, len);
}
len = 1;
for (int i = n - 2; i >= 0; i--) {
if (A[i + 1] < A[i]) len++;
else len = 1;
ans = Math.max(ans, len);
}
return ans;
}
}
110 · 最小路径和
LintCode原题链接：110 · 最小路径和
题目分析
源码
public class Solution {
/**
* @param grid: a list of lists of integers
* @return: An integer, minimizes the sum of all numbers along its path
*/
public int minPathSum(int[][] grid) {
int n = grid.length;
int m = grid[0].length;
int[][] f = new int[n][m];
//处理边界
f[0][0] = grid[0][0];
for (int i = 1; i < n; i++) f[i][0] = f[i - 1][0] + grid[i][0];
for (int j = 1; j < m; j++) f[0][j] = f[0][j - 1] + grid[0][j];
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) {
f[i][j] += Math.min(f[i - 1][j], f[i][j - 1]) + grid[i][j];
}
}
return f[n - 1][m - 1];
}
}
public class Solution {
/**
* @param grid: a list of lists of integers
* @return: An integer, minimizes the sum of all numbers along its path
*/
public int minPathSum(int[][] a) {
int n = a.length;
int m = a[0].length;
int[][] f = new int[n + 1][m + 1];
for (int i = 1; i <= n; i++) {
f[i][0] = 0xffff;
for (int j = 1; j <= m; j++) {
f[i][j] = a[i - 1][j - 1];
f[0][j] = 0xfff;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if(i == 1 && j == 1) continue;
f[i][j] += Math.min(f[i - 1][j], f[i][j - 1]);
}
}
return f[n][m];
}
}
553 · 炸弹袭击
LintCode原题链接：553 · 炸弹袭击
题目分析
DP的做法不好想，比较好想的是暴力枚举，如果要用DP来做的话，就要摆脱只能在0处放炸弹的限制。开辟一个二维数组f,f[i][j]表示该点放置炸弹能击杀的敌人的数量，以向上的方向为例，假如这一点为墙 if (grid[i][j] == 'W') f[i][j] = 0,这一点为敌人if (grid[i][j] == 'E') f[i][j] = 1,其他情况下f[i][j] += f[i - 1][j],用另外一个二维数组保存结果，result[i][j] += f[i][j],其他三个方向的处理也是一样的。
源码
public class Solution {
/**
* @param grid: Given a 2D grid, each cell is either 'W', 'E' or '0'
* @return: an integer, the maximum enemies you can kill using one bomb
*/
public int maxKilledEnemies(char[][] grid) {
// write your code here
if (grid == null || grid.length == 0 || grid[0].length == 0) {
return 0;
}
int m = grid.length;
int n = grid[0].length;
int[][] f = new int[m][n];
int[][] result = new int[m][n];
//up
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (grid[i][j] == 'W') f[i][j] = 0;
else {
f[i][j] = 0;
if (grid[i][j] == 'E') f[i][j] = 1;
if (i - 1 >= 0) f[i][j] += f[i - 1][j];
}
result[i][j] += f[i][j];
}
}
//down
for (int i = m - 1; i > 0; i--) {
for (int j = 0; j < n; j++) {
if (grid[i][j] == 'W') f[i][j] = 0;
else {
f[i][j] = 0;
if (grid[i][j] == 'E') f[i][j] = 1;
if (i + 1 < m) f[i][j] += f[i + 1][j];
}
result[i][j] += f[i][j];
}
}
//left
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (grid[i][j] == 'W') f[i][j] = 0;
else {
f[i][j] = 0;
if (grid[i][j] == 'E') f[i][j] = 1;
if (j - 1 >= 0) f[i][j] += f[i][j - 1];
}
result[i][j] += f[i][j];
}
}
//right
for (int i = 0; i < m; i++) {
for (int j = n - 1; j >= 0; j--) {
if (grid[i][j] == 'W') f[i][j] = 0;
else {
f[i][j] = 0;
if (grid[i][j] == 'E') f[i][j] = 1;
if (j + 1 < n) f[i][j] += f[i][j + 1];
}
result[i][j] += f[i][j];
}
}
int max = 0;
for (int i = 0; i < m; i++) {
for (int j = n - 1; j >= 0; j--) {
if (grid[i][j] == '0') max = Math.max(max, result[i][j]);
}
}
return max;
}
}
664 · 数 1
LintCode原题链接：664 · 数 1
题目分析
解法一
看一组例子：
0 0 0
1 1 1
2 10 1
3 11 2
4 100 1
f[1] = f[0] + 1 % 2
f[2] = f[1] + 2 % 2
f[3] = f[1] + 3 % 2
.....
f[i] = f[i >> 2] + i % 2
解法二
n & (n - 1)可以去掉一个1
源码
public class Solution {
/**
* @param num: a non negative integer number
* @return: an array represent the number of 1's in their binary
*/
public int[] countBits(int num) {
// write your code here
int[] f = new int[num + 1];
f[0] = 0;
for (int i = 1; i <= num; i++) {
f[i] = f[i >> 1] + i % 2;
}
return f;
}
}
public class Solution {
/**
* @param num: a non negative integer number
* @return: an array represent the number of 1's in their binary
*/
public int[] countBits(int num) {
// write your code here
int[] f = new int[num + 1];
f[0] = 0;
for (int i = 1; i <= num; i++) {
f[i] = cnt(i);
}
return f;
}
public int cnt(int n) {
int cnt = 0;
while (n != 0) {
n = n & (n - 1);
cnt++;
}
return cnt;
}
}
392 · 打劫房屋
LintCode原题链接：392 · 打劫房屋
题目分析
与房屋染色问题一样，这是一个序列性的动态规划问题，f[n]表示前n项的一种结果。
首先开辟一个二维数组f[][]，初始化f[0][0] = f[0][1] = 0 f[i][0]表示不打劫第i个房子，f[i][1]表示打劫第i个房子，若不打劫第i个房子，则可以打劫第i - 1个房子，也可以不打劫，则f[i][0] = max(f[i - 1][0], f[i - 1][1])，若打劫第i个房子，则不可以打劫第i - 1个房子，f[i][1] = f[i - 1][0] + v[i - 1]，最后在对f[n][0] f[n][1]取max
源码
public class Solution {
/**
* @param A: An array of non-negative integers
* @return: The maximum amount of money you can rob tonight
*/
public long houseRobber(int[] A) {
// write your code here
if (A == null || A.length == 0) return 0;
int n = A.length;
long[][] f = new long[n + 1][2];
// 0 rob 1 not rob
f[0][0] = f[0][1] = 0;
for (int i = 1; i <= n; i++) {
f[i][0] = Math.max(f[i - 1][0], f[i - 1][1]);
f[i][1] = f[i - 1][0] + A[i - 1];
}
return Math.max(f[n][1], f[n][0]);
}
}
public class Solution {
/**
* @param A: An array of non-negative integers
* @return: The maximum amount of money you can rob tonight
*/
public long houseRobber(int[] A) {
// write your code here
if (A == null || A.length == 0) return 0;
int n = A.length;
long[] f = new long[n + 1];
f[0] = 0;
f[1] = A[0];
for (int i = 2; i <= n; i++) {
f[i] = Math.max(f[i - 1], f[i - 2] + A[i - 1]);
}
return f[n];
}
}
534 · 打劫房屋 II
LintCode原题链接：534 · 打劫房屋 II
题目分析
若选择第一个房子，则第n个不能选，不选择第一个房子，则第n个可以选，两种情况分别考虑，可以将一个圈断开成两个序列。
源码
public class Solution {
/**
* @param nums: An array of non-negative integers.
* @return: The maximum amount of money you can rob tonight
*/
public int houseRobber2(int[] nums) {
// write your code here
if (nums == null || nums.length == 0) return 0;
int n = nums.length;
if (n == 1) return nums[0];
int[] f = new int[n + 1];
int v1, v2;
//rob first
f[0] = 0;
f[1] = nums[0];
for (int i = 2; i < n; i++) {
f[i] = Math.max(f[i - 1], f[i - 2] + nums[i - 1]);
}
v1 = f[n - 1];
//not rob first
f[1] = 0;
f[2] = nums[1];
for (int i = 3; i <= n; i++) {
f[i] = Math.max(f[i - 1], f[i - 2] + nums[i - 1]);
}
v2 = f[n];
return Math.max(v1, v2);
}
}
149 · 买卖股票的最佳时机
LintCode原题链接：149 · 买卖股票的最佳时机
题目分析
可以暴力枚举所有的起点和终点。也可以依次遍历取得每次遍历的最小的起点，并更新最大利润。
源码
public class Solution {
/**
* @param prices: Given an integer array
* @return: Maximum profit
*/
public int maxProfit(int[] prices) {
// write your code here
if (prices == null || prices.length == 0) return 0;
int n = prices.length;
int min = Integer.MAX_VALUE;
int profit = 0;
for (int i : prices) {
min = Math.min(i, min);
profit = Math.max(i - min, profit);
}
return profit;
}
}
150 · 买卖股票的最佳时机 II
LintCode原题链接：150 · 买卖股票的最佳时机 II
题目分析
多次购买，只要下一天价格高于今天，就加上差值，即为所求。
源码
public class Solution {
/**
* @param prices: Given an integer array
* @return: Maximum profit
*/
public int maxProfit(int[] prices) {
// write your code here
if (prices == null || prices.length == 0) return 0;
int n = prices.length;
int profit = 0;
for (int i = 0; i < n - 1; i++) {
if (prices[i] < prices[i + 1])
profit += prices[i + 1] - prices[i];
}
return profit;
}
}
476 · 石子归并
LintCode原题链接：476 · 石子归并
题目分析
区间DP,用前缀和来优化计算合并两堆石子所需要的代价。第一行枚举区间长度，接着枚举起点，中点和终点，由于要求最小代价，故应初始化f[][]足够大。最后f[1][n]即为所求结果。
源码
public class Solution {
/**
* @param a: An integer array
* @return: An integer
*/
public int stoneGame(int[] a) {
// write your code here
if (a == null || a.length == 0) return 0;
int n = a.length;
int[][] f = new int[n + 1][n + 1];
int[] s = new int[n + 1];
for (int i = 1; i <= n; i++) {
s[i] = a[i - 1];
s[i] += s[i - 1];
}
for (int len = 2; len <= n; len++) {
for (int i = 1; i + len - 1 <= n; i++) {
int j = i + len - 1;
f[i][j] = 0xffffff;
for (int k = i; k < j; k++) {
f[i][j] = Math.min(f[i][j], f[i][k] + f[k + 1][j] + s[j] - s[i - 1]);
}
}
}
return f[1][n];
}
}
4776
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
