leetcode寒假刷题---动态规划（1）（Java实现）

---

5.最长回文子串

动态规划思路：

1.定义状态

动态规划实际上就是记录每个状态，每个状态受到之前状态影响。所以，需要定义一个数组（记录每个状态）。这里定义二维数组dp，最小状态dp[i][j]就是记录从第i+1到第j+1的子串是否为回文子串。

2.确定临界状态

很容易就能看出每个字符都相当于一个长度为1的回文子串。所以二维数组对角线元素值都为1。

3.确定状态转移方程

dp[j][i]==（s[i]==s[j]）&&dp[j+1][i-1]

代码如下

	class Solution {
    public String longestPalindrome(String s) {
    if(s.length()==0)
    {
    	return "";
    }
    boolean [][]dp=new boolean[s.length()][s.length()];
    for(int i=0;i<s.length();i++)
    {
    	dp[i][i]=true;//把对角线元素都设为true，因为每个字符也可以当成回文子串
    }
    int maxlen=1;
    int b=0;
    for(int i=0;i<s.length();i++)
    {
    	for(int j=0;j<i;j++)
    	{
    		if(s.charAt(i)==s.charAt(j))
    		{
    			if(i-j>2)
   				 {
   					 dp[j][i]=dp[j+1][i-1];
    			 }
    			else
    			{
    				dp[j][i]=true;
    			}
    		}
    		else
    		{
    			dp[j][i]=false;
    		}
    		if(dp[j][i])
    		{
    			if(i-j+1>maxlen)
    			{
    				b=j;
    				maxlen=i-j+1;
    			}
    		}
    	}
    }
    		return s.substring(b,b+maxlen);//返回最长回文子串
    	}
	}

时间复杂度：O(N^2)

空间复杂度：O(N^2)
)，二维 dp 问题，一个状态得用二维有序数对表示，因此空间复杂度是 O(N^2)。

4.改进

中心扩散

假设字符串的某个字符是回文子串的中心，尝试从此点开始向两端扩散。如果子串是偶数子串，该中心就是这个回文子串的字符间的空隙。若是奇数子串，就是字符。
因此中心扩散法的思路是：遍历每一个索引，以这个索引为中心，利用“回文串”中心对称的特点，往两边扩散，看最多能扩散多远。

代码实现

	public class Solution {

    public String longestPalindrome(String s) {
        int len = s.length();
        if (len < 2) {
            return s;
        }
        int maxLen = 1;
        String res = s.substring(0, 1);
        // 中心位置枚举到 len - 2 即可,因为中心位置只可能是下标1到len-2。下标0和len-1是无法向两端扩散的
        for (int i = 0; i < len - 1; i++) {
            String os = centerSpread(s, i, i);
            String es = centerSpread(s, i, i + 1);
            String maxLenStr = os.length() > es.length() ? os :es;//找到是奇数子串长度长还是偶数子串长度长
            if (maxLenStr.length() > maxLen) {
                maxLen = maxLenStr.length();
                res = maxLenStr;
            }
        }
        return res;
    }

    private String centerSpread(String s, int left, int right) {
        // left = right 的时候，此时回文中心是一个字符，回文串的长度是奇数
        // right = left + 1 的时候，此时回文中心是一个空隙，回文串的长度是偶数
        int len = s.length();
        int i = left;
        int j = right;
        while (i >= 0 && j < len) {
            if (s.charAt(i) == s.charAt(j)) {
                i--;
                j++;
            } else {
                break;
            }
        }
        // 不满足while条件，此时得到的最大满足条件的子串是下标为i+1到j-1的字符组成的，所以，substring方法的两个参数为i+1，j(substring方法不会截取第二个参数所在下标的字符)
        return s.substring(i + 1, j);
    }
	}

时间复杂度：O(N^2)，遍历每个可能的中心时间复杂度为O(N)，而在centerSpread中，向两端扩撒的时间复杂度为O(N)。因此总时间复杂度为 O(N^2)。

空间复杂度：O(1)，只使用到常数个临时变量，与字符串长度无关。

---

53.最大子序和

动态规划思路：

1.定义状态

dp[i]为以下标为i的元素结束的子序中元素相加最大的子序的元素和。

2.确定临界状态

dp[0]=下标为0的元素的值

3.确定状态转移方程

dp[i]=max(dp[i-1]+nums[i],nums[i])//nums[i]为下标为i的元素

代码如下

	class Solution {
    public int maxSubArray(int[] nums) {
        int []dp=new int[nums.length];//定义dp数组记录状态
        dp[0]=nums[0];
        int max=dp[0];
        for(int i=1;i<nums.length;i++)
        {
            dp[i]=Math.max(dp[i-1]+nums[i],nums[i]);//状态转义方程
            max=Math.max(max,dp[i]);
        }
    }
    	return max;
	}

时间复杂度：O(N)

空间复杂度：O(N)

4.改进

动态规划实际上就是空间换时间，所以空间复杂度相对较大。但是一些情况下可以改进空间复杂度，如本题而言，由于状态转移方程为max(dp[i-1]+nums[i],nums[i]),每个状态都和前一个状态相关。那么，就可以定义一个变量记录前一状态的值（dp[i-1]）。这样空间复杂度就由O(N)变为了O(1)。

	class Solution {
    public int maxSubArray(int[] nums) {
        int ans = nums[0];
        int sum = 0;
        for(int num: nums) {
            if(sum > 0) {//即dp[i-1]+nums[i]>nums[i]
                sum += num;
            } else {
                sum = num;
            }
            ans = Math.max(ans, sum);
        }
        	return ans;
    }
	}

时间复杂度：O(N)

空间复杂度：O(1)

---

62.不同路径

动态规划思路：

1.定义状态

dp[i][j]表示从起点到第i+1行j+1列路径数

2.定义临界状态

由题意可知，从某点开始行进只能向下或向右走（只能从一个点的左边或上边来到该点）。而在第一行，只能从其左边的点走至该点。在第一列，只能从该点上面的点来到此点。
所以对于第一行元素dp[0][i],都有dp[0][i]=1,对应的，对于第一列元素dp[i][0]，都有dp[i][0]=1。

3.定义状态转换方程

dp[i][j]=dp[i-1][j]+dp[i]j-1

代码如下

	class Solution {
    public int uniquePaths(int m, int n) {//n为行数，m为列数
        int [][]dp=new int[n][m];
        for(int i=0;i<m;i++)
        {
            dp[0][i]=1;
        }
        for(int i=0;i<n;i++)
        {
            dp[i][0]=1;
        }
        for(int i=1;i<n;i++)
        {
            for(int j=1;j<m;j++)
            {
                dp[i][j]=dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[n-1][m-1];
    }
	}

时间复杂度：O(m*n)

空间复杂度：O(m*n)