带通配符的字符串匹配问题

/*
不使用c，c++库，？表示任意一个，*表示>=0任意，匹配规则要求匹配最大的字符子串，例如a*d ，匹配abbdd而非abbd,即最大匹配字符串
input ：abcadefg
reule : a?c
ouput : abc

input : newsadfanewfdsdsf
rule　：new
output: new new（最后一个不带空格，中间用空格分隔）

input : breakfastfood
rule  : f*d
output: fastfood

input : aaa
rule  :aa
outpur: aa

input : asdfgsdf
rule  :*
output :asdfgsdf
方法有两种，一种采用递归的方法，最大匹配函数，然后用调用给匹配算法，该函数都返回匹配个数，不匹配返回-1，以input的第一个开始算起，不匹配直接
-1，然后顺序遍历方法。
方法二：采用dp解决，dp问题dp[i][j]表示字符串1和字符串2分别以i和j结尾匹配最大长度
*/

#include <iostream>
#include <string>
using namespace std;

int strleng(const char * A)
{
    if(A==NULL)
        return 0;
    const char * p=A;
    while(*p!='')
    {
        p++;
    }
    return int(p-A);
}

void strcpn(char * a,const char * b,int len)           //注意b里没有‘’，a的长度实际为len+1,多了''
{
    while(len>0)
    {
        *a=*b;
        a++;
        b++;
        len--;
    }
    *a='';
}

char * strjoin(const char * a, const char * b,int lenb)
{
    char * tmp;
    int lena=strleng(a);
    if(a==NULL)
    {
        tmp= new char[lenb+1];
        strcpn(tmp,b,lenb);
    }
    else
    {
        tmp=new char[lena+lenb+2];              //长度为 lena加lenb多了一个空格和一个''
        strcpn(tmp,a,lena);
        *(tmp+lena)=' ';
        strcpn(tmp+lena+1,b,lenb);
        delete[] a;
    }
    return tmp;
}
    
int canMatch(const char * input ,const char * rule)            //返回最大匹配个数，递归函数
{
    if(*rule=='')                       //rule必须在input的前面判断啊，啊啊啊啊
        return 0;
    if(*input=='')
        return -1;
    int r=-1,may;                    //r为该次返回值，may没往后的递归返回值，r根据may最中取值
    if(*rule=='*')
    {
        r=canMatch(input,rule+1);
        if(*input!='')
        {
            may=canMatch(input+1,rule);
            if(may>=0&&++may>r)
                r=may;
        }
    }
    if(*rule=='?'||*rule==*input)
    {
        may=canMatch(input+1,rule+1);
        if(may>=0&&++may>r)
            r=may;
    }
    return r;
}

char * my_find(const char * input ,const char * rule)
{
    int len=strleng(input);
    int * match=new int[len];        //match[i],记录匹配数例如：input:aabbddf rule:a*d output:aabbdd match为：6，5，-1，-1，-1，-1，-1，所以要记录最大的
    int maxpos=0;    
    char * result=NULL;
    for(int i=0;i<len;i++)
    {
        match[i]=canMatch(input+i,rule);
        if(match[i]>match[maxpos])
            maxpos=i;
    }
    if(match[maxpos]<=0)              //不存在匹配,必须的有才行，开始都错了
    {
        result=new char;
        result[0]='';
        return result;
    }
    for(int i=0;i<len;)
    {
        if(match[i]==match[maxpos])   //用相等好，因为有可能有多个match[i]等于最大值，用maxpos就错了
        {
            result=strjoin(result,input+i,match[maxpos]);
            i+=match[maxpos];               //这样就直接跳过了后面匹配的，例如:a(1)a(2)a(3) a(1)a(2),匹配完aa后直接跳过a(2),到a（3）
//            i++;                                       //这样就会是aa aa ，题目的跳过匹配的原来就是这个意思啊
        }
        else
            i++;
    }
    delete[] match;
    return result;
}

/*
方法二：采用动态规划方法dp[i][j]表示字符串1和字符串2分别以i和j结尾匹配的最大长度
例如：input：abccde  rule：a?c
       a  ?  c
    0  1  2  3 （rule） 
  0 0 -1 -1 -1  
a 1 0  1 -1 -1
b 2 0 -1  2 -1
c 3 0 -1 -1  3
c 4 0 -1 -1 -1
d 5 0 -1 -1 -1
e 6 0 -1 -1 -1
（input）
找最后一列的最大的数，即找出以rule最后一个结尾匹配的最大值（例如abccd 和*c,所以要最大值），解决时注意，记录起点和多个的情况
*/

char * my_find2(const char * input,const char * rule)
{
    if(input==NULL||rule==NULL)
        return NULL;
    int len_input=strleng(input);
    int len_rule=strlen(rule);
    int ** dp=new int * [len_input+1];
    int may;
    for(int i=0;i<=len_input;i++)
        dp[i]=new int[len_rule+1];
    for(int i=1;i<=len_rule;i++)
        dp[0][i]=-1;
    for(int i=0;i<=len_input;i++)
        dp[i][0]=0;
    for(int i=1;i<=len_input;i++)
        for(int j=1;j<=len_rule;j++)
        {
            if(rule[j-1]=='*')                  //注意是j-1而不是i-1
            {
                dp[i][j]=-1;                      //a*c 和bfc这种情况
                if(dp[i-1][j-1]!=-1)
                    dp[i][j]=dp[i-1][j-1]+1;
                if(dp[i-1][j]!=-1&&dp[i-1][j]+1>dp[i][j])
                    dp[i][j]=dp[i-1][j]+1;
            }
            else if(rule[j-1]=='?')
            {
                if(dp[i-1][j-1]!=-1)
                    dp[i][j]=dp[i-1][j-1]+1;
                else
                    dp[i][j]=-1;
            }
            else
            {
                if(dp[i-1][j-1]!=-1&&input[i-1]==rule[j-1])
                    dp[i][j]=dp[i-1][j-1]+1;
                else
                    dp[i][j]=-1;
            }
        }
        int m=-1;
        int count_ans=0;
        int * ans=new int[len_input];
        char * result=NULL;
        for(int i=1;i<=len_input;i++)
        {
            if(dp[i][len_rule]>m)
            {
                count_ans=0;                       //因为要找最大的，所以每次发现都将count_ans置为0
                m=dp[i][len_rule];
                ans[count_ans++]=i-m;             //更新ans[0]的值,然后count_ans等于1
            }
            else if(dp[i][len_rule]!=-1&&dp[i][len_rule]==m)            //有多个等于m的情况，说明有多个
            {
                ans[count_ans++]=i-m;                  //count_ans更新，并且记录起始位置
            }
        }
        if(count_ans!=0) 
        {
            for(int i=0;i<count_ans;i++)
            {
                result=strjoin(result,ans[i]+input,m);
            }

        }
        else          //说明没有匹配的，返回空字符串
        {
            result=new char;
            result[0]='';
        }
        for(int i=0;i<=len_input;i++)
            delete[] dp[i];
        delete[] dp;
        return result;
}

int main()
{
    //char  *input="newsadfanewfdadsf";
    //char * rule="new";
    string input[]={"abcadefg","newsadfanewfdadsf","breakfastfood","asdfasdf","aaaaaaa"};
    string rule[]={"a?c","new","f*d","adfe","a"};
    int n=5;
    for(int i=0;i<n;i++)
    {
        cout<<my_find2(input[i].c_str(),rule[i].c_str())<<endl;
    }
    //cout<<my_find(input,rule)<<endl;
    system("pause");
}