leetcode刷题（三）java

7.递归与动态规划

动态规划可以看成是把递归结果存放下来，在下次调用时直接取出即可的形式，一般可用于每一步都是离散的，与上一步有关，深度优先搜索等类似题目中。

动态规划解背包问题时注意：

如果求组合数，不同顺序是同一种组合，则循环时物品在外，背包容量在内

如果求排列数，不同顺序是不同结果，则反之。

找零钱

import java.util.*;
public class questionNine {
    public static int change(int amount, int[] coins) {
        int ans =0;
        int[] d =new int[5003];
        d[0]=1;
        Arrays.sort(coins);
        for(int i=0;i<coins.length;i++)
        {
            for(int j=1;j<=amount;j++)
            {
                if(j>=coins[i])
                {
                    d[j]=d[j]+d[j-coins[i]];
                }
            }
        }
        return d[amount];
    }
    public static void main(String[] args) {
        int a=5;
        int[] b={1,2};
        System.out.println(change(a,b));
    }
}

8.回文子串

给定一个字符串，你的任务是计算这个字符串中有多少个回文子串。

具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。

class Solution {
    public static boolean f(String b)
    {
        if(b.length()==1)
        {
            return true;
        }
        int i=0,j=b.length()-1;
        while(i<=j)
        {
            if(b.charAt(i)==b.charAt(j))
            {
                i=i+1;
                j=j-1;
            }
            else
            {
                return false;
            }
            
        }
        return true;
    }
    public int countSubstrings(String s) {
        int ans=0;
        int n=s.length();
        for(int i=0;i<n;i++)
        {
            for(int j=i;j<n;j++)
            {
                if(f(s.substring(i,j+1)))
                {
                    ans=ans+1;
                }
            }
        }
        return ans;

    }
}

9.找不同

给定两个字符串 s 和 t，它们只包含小写字母。

字符串 *t* 由字符串 *s* 随机重排，然后在随机位置添加一个字母。

请找出在 t 中被添加的字母。

class Solution {
    public char findTheDifference(String s, String t) {
        int m=s.length(),n=t.length();
        char[] a=s.toCharArray();
        char[] b=t.toCharArray();
        Arrays.sort(a);
        Arrays.sort(b);
        for(int i=0;i<m;i++)
        {
            if(a[i]!=b[i])
            {
                return b[i];
            }
        }
        return b[m];
    
    }
}