题目

题目链接：
https://www.nowcoder.com/practice/650b68dfa69d492d92645aecd7da9b21

思路

动态规划

     动态规划算法通过迭代遍历输入数组，维护一个额外的数组 dp 
     来记录截止到每个位置的最大连续子数组和，
     并利用一个变量 max_num 实时更新全局最大子数组和的值。

    算法的核心思想在于，通过比较当前元素和前一个元素的最大子数组和是否大于零，
    来决定是否将当前元素加入前一个子数组或者从当前元素重新开始形成子数组。最终，
    返回 max_num 作为最大子数组和的解。

    初始化dp：dp[i]表示前i个元素最大的连续子数组和
    状态转移：如果dp[i-1] > 0, dp[i] = dp[i-1] + nums[i],
    否则dp[i] = nums[i](分类讨论)
    初始换状态：dp[0] = nums[0]
    最优解：max(dp)

Java代码

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head ListNode类 
     * @return int整型
     */
    public int FindGreatestSumOfSubArray (ListNode head) {
        //动态规划
        int pre = head.val;
        int ans = head.val;
        head = head.next;
        while(head!=null){
            int p1 = head.val;
            int p2 = head.val+pre;

            int cur = Math.max(p1,p2);
            ans = Math.max(ans,cur);
            pre = cur;
            head=head.next;
        }
        return ans;
    }
}

Go代码

package main
import . "nc_tools"
/*
 * type ListNode struct{
 *   Val int
 *   Next *ListNode
 * }
 */

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param head ListNode类 
 * @return int整型
*/
func FindGreatestSumOfSubArray( head *ListNode ) int {
    //动态规划
    pre:=head.Val
    ans:=head.Val
    head = head.Next
    for head!=nil {
        p1:=head.Val
        p2:=head.Val+pre 

        cur:=p1 
        if cur < p2 {
            cur =p2 
        }

        if ans < cur{
            ans = cur 
        }


        pre = cur 
        head =head.Next
    }
    return ans 
}

PHP代码

<?php

/*class ListNode{
    var $val;
    var $next = NULL;
    function __construct($x){
        $this->val = $x;
    }
}*/

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param head ListNode类 
 * @return int整型
 */
function FindGreatestSumOfSubArray( $head )
{
    //动态规划
    $pre = $head->val;
    $ans = $head->val;
    $head =$head->next;

    while($head!=null){
        $p1 = $head->val;
        $p2 = $head->val+$pre;

        $cur = $p1;
        if($cur < $p2){
            $cur = $p2;
        }

        if($ans < $cur){
            $ans = $cur;
        }

        $pre = $cur;
        $head = $head->next;
    }
    return $ans;
}

C++ 代码

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head ListNode类 
     * @return int整型
     */
    int FindGreatestSumOfSubArray(ListNode* head) {
        //动态规划
        int pre = (*head).val;
        int ans = (*head).val;
        head =(*head).next;
        while(head !=nullptr){
            int p1 = (*head).val;
            int p2 =(*head).val+pre;
            int cur = p1;
            if(cur < p2){
                cur = p2;
            }

            if(ans < cur){
                ans = cur;
            }

            pre = cur;
            head=(*head).next;
        }
        return ans;
    }
};