剪绳子问题

class Solution:
    def cuttingRope(self, n: int) -> int:
        # # dp法一
        # dp = [0] *(n+1)
        # dp[2] = 1
        # for i in range(3,n+1):
        #     for j in range(1,i//2+1):
        #         dp[i] = max(max(dp[i],max(j * dp[i-j],j*(i-j))),(i-j)*dp[j])
        # return dp[n]

        # # 改良法一
        # if n == 2:
        #     return 1
        # if n == 3:
        #     return 2
        # dp[2] = 2
        # dp[3] = 3
        # for i in range(4,n+1):
        #     for j in range(2,i//2+1):
        #         dp[i] = max(dp[i],dp[i-j]*dp[j])
        # return dp[n]

        # 贪心
        res = 1
        if n < 4:
            return n-1
        while n > 4:
            res *= 3
            n -= 3
        return res *n
        

java

class Solution {
    public int cuttingRope(int n) {
        // 动态规划
        int dp[] = new int[n+1];
        if (n<4){
            return n-1;
        }
        dp[2] = 2;
        dp[3] = 3;
        for(int i = 0;i < n+1;i++){
            for(int j = 2;j < i/2 +1;j++){
                dp[i] = Math.max(dp[i],dp[j]*dp[i-j]);
            }
        }
        return dp[n];
        // // 贪心
        // if (n<4){
        //     return n-1;
        // }
        // int result = 1;
        // while (n > 4){
        //     n =n-3;
        //     result = result*3;
        
        // }
        // return n * result;
    }
}

go

func cuttingRope(n int) int {
    dp := make([]int,n+1)
    if n < 4{
        return n-1
    }
    dp[2] = 2
    dp[3] = 3
    for i:= 4;i<n+1;i++{
        for j:=2;j<i/2+1;j++{
            if dp[i] < dp[j] * dp[i-j]{
                dp[i] = dp[j] * dp[i-j]
            }
        }
    }
    return dp[n]
    // res := 1
    // if n < 4{
    //     return n-1
    // }
    // res := 1

    // for{
    //     if n <= 4{
    //         break
    //     }
    //     n -= 3
    //     res *= 3

    // }

    // return res * n

}