字符串匹配问题

//字符串匹配问题
public class StringMatch2{
	
	//判断字符串是否有效
	public static boolean isValid(char[]s,char[]exp)
	{
		for(int i=0;i<s.length;i++)
		{
			if(s[i]=='.'||s[i]=='*')
			{
				return false;
			}
		}
		for(int i=0;i<exp.length;i++)
		{
			if(exp[i]=='*'&&(i==0||exp[i-1]=='*'))
			{
				return false;
			}
		}
		return true;
	}

	//(1)递归的方法解决
    public  static boolean isMatch(String s, String e)
    {
      if(s==null||e==null)
      {
      	return false;
      }
      char[]str=s.toCharArray();
      char[]exp=e.toCharArray();
      return isValid(str,exp)?process(str,exp,0,0):false;
    }
     //递归函数
    public static boolean process(char[]s,char[]e,int si,int ei)
    {
        if(ei==e.length)
        {
        	return si==s.length;
        }
        if(ei+1==e.length||e[ei+1]!='*')
        {
        	return si!=s.length&&(e[ei]==s[si]||e[ei]=='.')
        	                   &&process(s,e,si+1,ei+1);
        }
        while(si!=s.length&&(e[ei]==s[si]||e[ei]=='.'))
        {
        	if(process(s,e,si,ei+2))
        	{
        		return true;
        	}
        	si++;
        }

        return process(s,e,si,ei+2);
    }
	//(2)动态规划的方法解决
    public static boolean isMatch2(String s, String e)
    {
      if(s==null||e==null)
      {
      	return false;
      }
      char[]str=s.toCharArray();
      char[]exp=e.toCharArray();
      if(!isValid(str,exp))
      {
        return false;
      }
      //初始化动态规划矩阵
      boolean[][]dp=initDpMap(str,exp);
      for(int i=str.length-1;i>=0;i--)
      {
        for(int j=exp.length-2;j>-1;j--)
        {
           if(exp[j+1]!='*')
           {
             dp[i][j]=(str[i]==exp[j]||exp[j]=='.')&&dp[i+1][j+1];
           }else{
             int si=i;
             while(si!=str.length&&(str[si]==exp[j]||exp[j]=='.'))
             {
               if(dp[si][j+2])
               {
                  dp[i][j]=true;
                  break;
               }
               si++;
             }
             if(dp[i][j]!=true)
             {
              dp[i][j]=dp[si][j+2];
             }
           }
        }
      }
      
      return dp[0][0];
    }

    //初始化动态规划矩阵
    public static boolean[][] initDpMap(char[]s,char[]e)
    {
              int slen=s.length;
              int elen=e.length;
              boolean[][]dp=new boolean[slen+1][elen+1];
              dp[slen][elen]=true;

              for(int j=elen-2;j>-1;j=j-2)
              {
                 if(e[j]!='*'&&e[j+1]=='*')
                 {
                    dp[slen][j]=true;
                 }
                 else
                 {
                  break;
                 }

              }
              if(slen>0&&elen>0)
              {
                if(e[elen-1]=='.'||s[slen-1]==e[elen-1])
                {
                  dp[slen-1][elen-1]=true;
                }
              }

              return dp;
    }

	public static void main(String[]args)
	{
     // System.out.println("Hello");
		String str="abcd";
		String exp=".*";
		System.out.println(isMatch(str,exp));
               System.out.println(isMatch2(str,exp));
		String str2="abcd";
		String exp2="..";
		System.out.println(isMatch(str2,exp2));
                System.out.println(isMatch2(str2,exp2));

	}
}