【代码随想录二刷】Day53-动态规划-Go

代码随想录二刷Day53

今日任务

1143.最长公共子序列
1035.不相交的线
53.最大子序和
语言：Go

1143. 最长公共子序列

链接：https://leetcode.cn/problems/longest-common-subsequence/

func max(i, j int) int {
    if i < j {
        return j
    } else {
        return i
    }
}

func longestCommonSubsequence(text1 string, text2 string) int {
    //dp[i][j]表示以text1[i]结尾的字符串和以text2[j]结尾的字符串的最大公共子序列长度为dp[i][j]
    dp := make([][]int, len(text1))
    for i := 0; i < len(text1); i++ {
        dp[i] = make([]int, len(text2))
    }
    for i := 0; i < len(text1); i++ {
        if text1[i] == text2[0] {
            for j := i; j < len(text1); j++ {
                dp[j][0] = 1
            }
        }
        break
    }
    for i := 0; i < len(text2); i++ {
        if text2[i] == text1[0] {
            for j := i; j < len(text2); j++ {
                dp[0][j] = 1
            }
        }
        break
    }
    for i := 1; i < len(text1); i++ {
        for j := 1; j < len(text2); j++ {
            if text1[i] == text2[j] {
                dp[i][j] = dp[i - 1][j - 1] + 1
            } else {
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
            }
        }
    }
    return dp[len(text1) - 1][len(text2) - 1]
}

/*
        a   c   e
    a   1   1   1
    b   1   1   1
    c   1   2   2
    d   1   2   2
    e   1   2   3
*/

1035. 不相交的线

链接：https://leetcode.cn/problems/uncrossed-lines/
不相交意味着不改变相对顺序

func max(i, j int) int {
    if i < j {
        return j
    } else {
        return i
    }
}

func maxUncrossedLines(nums1 []int, nums2 []int) int {
    //dp[i][j]表示以nums1[i]结尾，以nums2[j]结尾的点可以绘制的最大连线数为dp[i][j]
    dp := make([][]int, len(nums1))
    for i := 0; i < len(nums1); i++ {
        dp[i] = make([]int, len(nums2))
    }
    for i := 0; i < len(nums1); i++ {
        if nums1[i] == nums2[0] {
            for j := i; j < len(nums1); j++ {
                dp[j][0] = 1
            }
            break
        }
    }
    for i := 0; i < len(nums2); i++ {
        if nums2[i] == nums1[0] {
            for j := i; j < len(nums2); j++ {
                dp[0][j] = 1
            }
            break
        }
    }
    for i := 1; i < len(nums1); i++ {
        for j := 1; j < len(nums2); j++ {
            if nums1[i] == nums2[j] {
                dp[i][j] = dp[i - 1][j - 1] + 1
            } else {
                dp[i][j] = max(dp[i][j - 1], dp[i - 1][j])
            }
        }
    }
    return dp[len(nums1) - 1][len(nums2) - 1]
}

/*
        10  5   2   1   5   2
    2   0   0   1   1   1   1
    5   0   1   1   1   2   2
    1   0   1   1   2   2   2
    2   0   1   2   2   2   3
    5   0   1   1   2   3   3

        2   2   3   3
    3   0   0   1   1
    3   0   0   1   2
    3   0   0   1   2
    1   0   0   1   2
*/

53. 最大子序和

链接：https://leetcode.cn/problems/maximum-subarray/

func max(i, j int) int {
    if i < j {
        return j
    } else {
        return i
    }
}

func maxSubArray(nums []int) int {
    res := nums[0]
    //dp[i]表示以nums[i]为结尾的子数组中和最大为dp[i]
    dp := make([]int, len(nums))
    dp[0] = nums[0]
    for i := 1; i < len(nums); i++ {
        dp[i] = max(dp[i - 1] + nums[i], nums[i])
        if res < dp[i] {
            res = dp[i]
        }
    }
    return res
}