笔试常考的算法题 利用动态规划(DP)就能轻松的做出来！(二)

第3题 ：求最大连续子数组和(Maximum Sub_Array)

题目是这样的 加入给定一个数组{6,-3,-2,7,-15,1,2,2},求连续子数组的最大和，也就是8。

状态：
子状态：长度为1，2，3，…,n的子数组和的最大值
//F(i):长度为i的子数组和的最大值，这种定义不能形成递推关系，舍弃
F(i):以array[i]为末尾元素的子数组和的最大值
状态递推：
F(i) = max(F(i-1) + array[i]，array[i])
F(i) = （F(i-1) > 0）? F(i-1) + array[i] : array[i]
初始值：F(0) = array[0]
返回结果：
maxsum：所有F(i)中的最大值
下面我们来看看代码实现：

package com.revision.Algorithm;

/*求最大连续子数组和(Maximum Sub_Array)

        题目是这样的 加入给定一个数组{6,-3,-2,7,-15,1,2,2},求连续子数组的最大和，也就是8。*/

import java.awt.print.PrinterGraphics;
import java.util.Scanner;
import java.util.Vector;

public class Maximum_Sub_Array {
    public static void main(String[] args) {
        Vector<Integer> array = new Vector<>();
        array.add(6);
        array.add(-3);
        array.add(-2);
        array.add(7);
        array.add(-15);
        array.add(1);
        array.add(2);
        array.add(2);

        System.out.println("经计算，此数组的连续子数组最大值为：" + Solution(array));

    }

    private static int Solution(Vector<Integer> array) {
        if (array.isEmpty()) {
            return -1;
        }
        //F(i)初始化
        int sum = array.get(0);
        //maxsum初始化
        int maxsum = array.get(0);
        for (int i = 1; i < array.size(); i++) {
            //F(i) = max(F(i - 1) + array[i],array[i])
            sum = sum > 0 ? sum + array.get(i) : array.get(i);
            //maxnum = max(maxnum,F(i))
            maxsum = sum < maxsum ? maxsum : sum;
        }
        return maxsum;
    }
}

先利用Vector容器 把向量数组存下来，然后sum代表子状态 判断前后数字的关系，获得一个子状态数组的最大值 然后和之前的最大值maxnum进行比较 如果打了就赋值，小或者等于就不变 最后经过遍历就可以获得最大的值了

第4题：字符串分割(Word Break):

给定一个字符串，再给一个dict(字典),确定字符串是否可以由字典里的词组成。
如s = “LeBron James” dict = [“LeBron” , “James”]
那么就return true;
状态：
子状态：前1，2，3，…,n个字符能否根据词典中的词被成功分词
F(i): 前i个字符能否根据词典中的词被成功分词
状态递推：
F(i): true{j <i && F(j) && substr[j+1,i]能在词典中找到} OR false
在j小于i中，只要能找到一个F(j)为true，并且从j+1到i之间的字符能在词典
中找到，则F(i)为true
初始值：
对于初始值无法确定的，可以引入一个不代表实际意义的空状态，作为状态的起始
空状态的值需要保证状态递推可以正确且顺利的进行，到底取什么值可以通过简单
的例子进行验证
F(0) = true
返回结果：F(n)

class Solution{
public:
 bool wordBreak(string s, unordered_set<string> &dict){
 if (s.empty()){
 return false;
 }
 if (dict.empty()){
 return false;
 }
 // 获取词典中的单词的最大长度
 int max_length = 0;
 unordered_set<string>::iterator dict_iter= dict.begin();
 for (; dict_iter != dict.end(); dict_iter++){
 if ((*dict_iter).size() > max_length){
 max_length = (*dict_iter).size();
 }
 }
 vector<bool> can_break(s.size() + 1, false);
 // 初始化F(0) = true
 can_break[0] = true;
 for (int i = 1; i <= s.size(); i++){
 for (int j = i - 1; j >= 0; j--){
 // 如果最小子串长度大于max_length，跳过
 if ((i - j) > max_length){
 break;
 }
 // F(i): true{j <i && F(j) && substr[j+1,i]能在词典中找到} OR false
 // 第j+1个字符的索引为j
 if (can_break[j] && dict.find(s.substr(j, i - j)) != dict.end()){
 can_break[i] = true;
 break;
 }
 }
 }
 return can_break[s.size()];
 }
};