1049. 最後一塊石頭的重量 II
已解答
中等
相關標籤
相關企業
提示
有一堆石頭，用整數陣列 stones 表示。其中 stones[i] 表示第 i 塊石頭的重量。
每一回合，從中選出任意兩塊石頭，然後將它們一起粉碎。假設石頭的重量分別為 x 和 y，且 x <= y。那麼粉碎的可能結果如下：
- 如果
x == y，那麼兩塊石頭都會被完全粉碎； - 如果
x != y，那麼重量為x的石頭將會完全粉碎，而重量為y的石頭新重量為y-x。
最後，最多隻會剩下一塊 石頭。返回此石頭 最小的可能重量 。如果沒有石頭剩下，就返回 0。
示例 1：
輸入：stones = [2,7,4,1,8,1]
輸出：1
解釋：
組合 2 和 4，得到 2，所以陣列轉化為 [2,7,1,8,1]，
組合 7 和 8，得到 1，所以陣列轉化為 [2,1,1,1]，
組合 2 和 1，得到 1，所以陣列轉化為 [1,1,1]，
組合 1 和 1，得到 0，所以陣列轉化為 [1]，這就是最優值。示例 2：
輸入：stones = [31,26,33,21,40]
輸出：5
提示：
1 <= stones.length <= 301 <= stones[i] <= 100
func lastStoneWeightII(stones []int) int {
//dp[i] 石頭總量, sum(stones)/2
//遞推公式， d[i] = max(dp[i],dp[i-w[i]]+v[i])
//初始化 dp[i] = 第一個石頭的重量
//從右向前
//輸出，就是總值- 一半容量的最大值
varsumStonesint
fori := 0; i < len(stones); i++ {
sumStones += stones[i]
}
halfStone := sumStones / 2
dp := make([]int, halfStone+1)
fori := 0; i < len(dp); i++ {
if i >= stones[0] {
dp[i] = stones[0]
}
}
fori := 1; i < len(stones); i++ {
forj := halfStone; j >= 0; j-- {
if j-stones[i] >= 0 && dp[j] < dp[j-stones[i]]+stones[i] {
dp[j] = dp[j-stones[i]] + stones[i]
}
}
}
return sumStones - 2*dp[halfStone]
}
474. 一和零
已解答
中等
相關標籤
相關企業
給你一個二進位制字串陣列 strs 和兩個整數 m 和 n 。
請你找出並返回 strs 的最大子集的長度，該子集中 最多 有 m 個 0 和 n 個 1 。
如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。
示例 1：
輸入：strs = ["10", "0001", "111001", "1", "0"], m = 5, n = 3
輸出：4
解釋：最多有 5 個 0 和 3 個 1 的最大子集是 {"10","0001","1","0"} ，因此答案是 4 。
其他滿足題意但較小的子集包括 {"0001","1"} 和 {"10","1","0"} 。{"111001"} 不滿足題意，因為它含 4 個 1 ，大於 n 的值 3 。示例 2：
輸入：strs = ["10", "0", "1"], m = 1, n = 1
輸出：2
解釋：最大的子集是 {"0", "1"} ，所以答案是 2 。
提示：
1 <= strs.length <= 6001 <= strs[i].length <= 100strs[i]僅由'0'和'1'組成1 <= m, n <= 100
func findMaxForm(strs []string, m int, n int) int {
//dp[i][j] i個0值，j個1值，最多的資料
//遞推公式 dp[i][j] = dp[i-z[i]][j-o[i]]
//初始化 dp[0][0] = 0
//從左到右，從上到下
//輸出
dp := make([][]int, m+1)
fori := 0; i < len(dp); i++ {
dp[i] = make([]int, n+1)
}
fori := 0; i < len(strs); i++ {
varone, zeroint
for_, v := range strs[i] {
if v == '1' {
one++
} else {
zero++
}
}
forrow := m; row >= 0; row-- {
forcol := n; col >= 0; col-- {
if row-zero >= 0 && col-one >= 0 && dp[row][col] < dp[row-zero][col-one]+1 {
dp[row][col] = dp[row-zero][col-one] + 1
}
}
}
}
return dp[m][n]
}
494. 目標和
已解答
中等
相關標籤
相關企業
給你一個非負整數陣列 nums 和一個整數 target 。
向陣列中的每個整數前新增 '+' 或 '-' ，然後串聯起所有整數，可以構造一個 表示式 ：
- 例如，
nums = [2, 1]，可以在2之前新增'+'，在1之前新增'-'，然後串聯起來得到表示式"+2-1"。
返回可以透過上述方法構造的、運算結果等於 target 的不同 表示式 的數目。
示例 1：
輸入：nums = [1,1,1,1,1], target = 3
輸出：5
解釋：一共有 5 種方法讓最終目標和為 3 。
-1 + 1 + 1 + 1 + 1 = 3
+1 - 1 + 1 + 1 + 1 = 3
+1 + 1 - 1 + 1 + 1 = 3
+1 + 1 + 1 - 1 + 1 = 3
+1 + 1 + 1 + 1 - 1 = 3示例 2：
輸入：nums = [1], target = 1
輸出：1
提示：
1 <= nums.length <= 200 <= nums[i] <= 10000 <= sum(nums[i]) <= 1000-1000 <= target <= 1000
func findTargetSumWays(nums []int, target int) int {
varsumTargetint
fori := 0; i < len(nums); i++ {
sumTarget += nums[i]
}
ifabs(target) > sumTarget {
return0
}
sumTarget = sumTarget + target
if sumTarget%2 == 1 {
return0
}
packages := sumTarget / 2
dp := make([]int, packages+1)
//dp[i] , 裝滿i的總數量
//遞推公式， dp[i] = for dp[i-1]+dp[i-1],dp[]
//初始化 dp[0] = 1
//從右向左
//遍歷，輸出最後
dp[0] = 1
fori := 0; i < len(nums); i++ {
forj := packages; j >= 0; j-- {
if j-nums[i] >= 0 {
dp[j] += dp[j-nums[i]]
}
}
}
return dp[packages]
}
func abs(x int) int {
returnint(math.Abs(float64(x)))
}