zoukankan      html  css  js  c++  java
  • Data Structure and Algorithm

    • new climb stairs

      step: 1 2 3, two adjacent steps cannot be the same.

    • 120. Triangle

      Given a triangle array, return the minimum path sum from top to bottom.

      For each step, you may move to an adjacent number of the row below. More formally, if you are on index i on the current row, you may move to either index i or index i + 1 on the next row.

      Example 1:

      Input: triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
      Output: 11
      Explanation: The triangle looks like:
         2
        3 4
       6 5 7
      4 1 8 3
      The minimum path sum from top to bottom is 2 + 3 + 5 + 1 = 11 (underlined above).
      

      Example 2:

      Input: triangle = [[-10]]
      Output: -10
      

      Constraints:

      • 1 <= triangle.length <= 200
      • triangle[0].length == 1
      • triangle[i].length == triangle[i - 1].length + 1
      • -104 <= triangle[i][j] <= 104

      Follow up: Could you do this using only O(n) extra space, where n is the total number of rows in the triangle?

      // division: problem(i,j) = min(sub(i+1,j),sub(i+1,j+1)) + a[i,j]
      // dp array: f[i,j]
      // dp equation: f[i][j] = Math.min(f[i+1][j], f[i+1][j+1]) + a[i][j]
      class Solution {
          public int minimumTotal(List<List<Integer>> triangle) {
              int n = triangle.size();
              int[] dp = new int[n];
              for (int i = 0; i < n; i++) {
                  dp[i] = triangle.get(n-1).get(i);
              }
              for (int i = n-2; i >= 0; i--) {
                  for (int j = 0; j <= i; j++) {
                      dp[j] = triangle.get(i).get(j) + Math.min(dp[j], dp[j+1]);
                  }
              }
              return dp[0];
          }
      }
      
      // memo dfs
      
    • 152. Maximum Product Subarray

      Given an integer array nums, find a contiguous non-empty subarray within the array that has the largest product, and return the product.

      It is guaranteed that the answer will fit in a 32-bit integer.

      A subarray is a contiguous subsequence of the array.

      Example 1:

      Input: nums = [2,3,-2,4]
      Output: 6
      Explanation: [2,3] has the largest product 6.
      

      Example 2:

      Input: nums = [-2,0,-1]
      Output: 0
      Explanation: The result cannot be 2, because [-2,-1] is not a subarray.
      

      Constraints:

      • 1 <= nums.length <= 2 * 104
      • -10 <= nums[i] <= 10
      class Solution {
          public int maxProduct(int[] nums) {
              int res = nums[0];
              int min = nums[0], max = nums[0];
              for (int i = 1; i < nums.length; i++) {
                  int t = min;
                  min = Math.min(Math.min(nums[i], nums[i] * min), nums[i] * max);
                  max = Math.max(Math.max(nums[i], nums[i] * max), nums[i] * t);
                  res = Math.max(res, max);
              }
              return res;
          }
      }
      
    • 322. Coin Change

      You are given an integer array coins representing coins of different denominations and an integer amount representing a total amount of money.

      Return the fewest number of coins that you need to make up that amount. If that amount of money cannot be made up by any combination of the coins, return -1.

      You may assume that you have an infinite number of each kind of coin.

      Example 1:

      Input: coins = [1,2,5], amount = 11
      Output: 3
      Explanation: 11 = 5 + 5 + 1
      

      Example 2:

      Input: coins = [2], amount = 3
      Output: -1
      

      Example 3:

      Input: coins = [1], amount = 0
      Output: 0
      

      Example 4:

      Input: coins = [1], amount = 1
      Output: 1
      

      Example 5:

      Input: coins = [1], amount = 2
      Output: 2
      

      Constraints:

      • 1 <= coins.length <= 12
      • 1 <= coins[i] <= 231 - 1
      • 0 <= amount <= 104
      // recur over time
      class Solution {
          int res = Integer.MAX_VALUE;
          public int coinChange(int[] coins, int amount) {
              bfs(coins, amount, 0);
              return res == Integer.MAX_VALUE ? -1 : res;
          }
      
          private void bfs(int[] coins, int amount, int num) {
              if (amount < 0) return ; 
              if (amount == 0) {
                  res = Math.min(res, num);
                  return ;
              }
              for (int coin : coins) {
                  bfs(coins, amount - coin, num + 1);
              }
          }
      }
      
      // DP
      // subproblems: problem[i] = 1 + min(sub(i-coin1),sub(i-coin2),...)
      // dp array: f(n) = min(f(n-k), fpr k in [1,2,5]) + 1
      // dp equation
      class Solution {
          public int coinChange(int[] coins, int amount) {
              int max = amount + 1;
              int[] dp = new int[amount + 1];
              Arrays.fill(dp, max);
              dp[0] = 0;
              for (int i = 1; i <= amount; i++) {
                  for (int coin : coins) {
                      if (coin <= i) {
                          dp[i] = Math.min(dp[i], dp[i - coin] + 1);
                      }
                  }
              }
              return dp[amount] > amount ? -1 : dp[amount];
          }
      }
      
    • 198. House Robber

      You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security systems connected and it will automatically contact the police if two adjacent houses were broken into on the same night.

      Given an integer array nums representing the amount of money of each house, return the maximum amount of money you can rob tonight without alerting the police.

      Example 1:

      Input: nums = [1,2,3,1]
      Output: 4
      Explanation: Rob house 1 (money = 1) and then rob house 3 (money = 3).
      Total amount you can rob = 1 + 3 = 4.
      

      Example 2:

      Input: nums = [2,7,9,3,1]
      Output: 12
      Explanation: Rob house 1 (money = 2), rob house 3 (money = 9) and rob house 5 (money = 1).
      Total amount you can rob = 2 + 9 + 1 = 12.
      

      Constraints:

      • 1 <= nums.length <= 100
      • 0 <= nums[i] <= 400
      class Solution {
          public int rob(int[] nums) {
              if (nums.length == 1) return nums[0];
              nums[1] = Math.max(nums[0], nums[1]);
              for (int i = 2; i < nums.length; i++) {
                  nums[i] = Math.max(nums[i] + nums[i-2], nums[i-1]);
              }
              return nums[nums.length - 1];
          }
      }
      
      class Solution {
          public int rob(int[] nums) {
              if (nums.length == 1) return nums[0];
              int[][] dp = new int[nums.length][2];
              dp[0][0] = 0; // not rob
              dp[0][1] = nums[0]; // rob
              for (int i = 1; i < nums.length; i++) {
                  dp[i][0] = Math.max(dp[i-1][1], dp[i-1][0]);
                  dp[i][1] = dp[i-1][0] + nums[i];
              }
              return Math.max(dp[nums.length - 1][0], dp[nums.length - 1][1]);
          }
      }
      
  • 相关阅读:
    (十三)子查询
    (十二)多表查询
    MFC读写配置ini文件
    (十一)分组函数(多行函数)
    Django(二十一)组合搜索
    Django(二十)model中的 class Meta
    (十)单行函数
    (九)逻辑运算,order by,desc
    类作为成员变量
    内部类——匿名内部类
  • 原文地址:https://www.cnblogs.com/peng8098/p/algorithm10.html
Copyright © 2011-2022 走看看