ACM_编程与调试重点记录（八）

1.       每个字符在内存中占用一个字节，存储它的ASCII码——也就是说，每个字符都有相应的ASCII码；

2.       #include"stdio.h"

void fun(int k);

int main(void)

{

       int k;

       for(k=1;k<=3;k++)

       fun(k);

       return 0;

}

 

void fun(int k)

{

       static int a;[GP1] //静态局部变量默认的初始值为0

       printf("%d,",a);

       a+=k;

}

运行结果：0,1,3,请按任意键继续. . .

但是程序执行完成后，a的值是6

3.  #include"stdio.h"

int main()

{

    int i,j;

    static int b[4][3]={1,2,3,0,0,0,4,5};[GP2] 

    for (i=0;i<4;i++)

        for (j=0;j<3;j++)

            printf("%d,",b[i][j]);

}

运行结果如下

1,2,3,0,0,0,4,5,0,0,0,0,请按任意键继续. . .

4. //用于求字符串的匹配，求一个字符串是否是另一个字符串的子串！——KMP

#include <iostream>

#include <string>

 

using namespace std;

 

string s,t;

//s为匹配串，t为目标串

 

void GetNext(int *next)

{

       int j,k;

 

       j=0; k=-1; next[0]=-1;

 

       while (j<s.length()-1)

       {

              if (k==-1 || s[j]==s[k])

              {

                     j++; k++;

                     next[j]=k;

              }

              else k=next[k];

       }

       for (j=0;j<s.length();j++) cout<<next[j]<<' ';

       cout<<endl;

}

 

int KMP(int next[])

{

       int i,j;

 

 

       i=0; //目标串的指针

       j=0; //匹配串的指针

 

       while (i<t.length() && j<s.length())

       {

              if (j==-1 || t[i]==s[j])

              {

                     i++;

                     j++;

              }

              else j=next[j];

       }

       //返回的匹配成功的开始位置不对！因为i变为0了！

       if (j>=s.length()) return i-s.length();

       else return -1;

}

 

int main()

{

       int next[1000];

       int k;

 

       while (cin>>s>>t)

       {

              GetNext(next);

              k=KMP(next);

              if (k==-1) cout<<"No"<<endl;

              else cout<<"Yes!  "<<k<<endl;

       }

 

       return 0;

}

5. HDOJ1029寻找多元素算法，（内有关于该算法的详细过程，不仅是对于该题）

 

多元素即在数列中出现次数多于n/2的元素

我们很容易的看出来，在一个序列中如果去掉2个不同的元素，那么原序列中的多元素，在新的序列中还是多元素，

因此我们只要按照序列依次扫描，先把A[0]赋值给c，增加个计数器，count = 1；然后向右扫描，如果跟c相同，则count++，不同，那么count --，这个真是我们从上面那个结论里得出的，一旦count == 0了，那么必定c不是多元素，这个时候把c赋值为A[i+1],count = 1；，重复该过程，知道结束，这个时候，c就是多元素，这个的时间复杂度为n，

该题本来可以用数组保存每个元素，然后递归上述过程，可是，用数组超内存，因此我们可以直接按照上述过程计算

具体代码如下

#include<iostream>

using namespace std;

 

 

int main()

{

    int i,c,num,count;

    bool flag = true;

    int N;

    while(cin >> N)

    {   

        for( i = 1; i <= N; i ++)

        {

            getchar();

            scanf("%d",&num);

            if(flag == true)

            {

                c = num;

                flag = false;

                count = 1;

                continue;

            }

            if( count > 0 )

            {

                if(num == c)

                    count ++;

                else

                    count --;

            }

            if( count == 0)

            {

                flag = true;

            }

 

        }

        flag = true;

        printf("%d/n",c);

    }

    return 0;

}

 

6. //最大子串匹配,复杂度O(mn)

//返回最大匹配值,传入两个串和串的长度,重载返回一个最大匹配

//注意做字符串匹配是串末的'/0'没有置!

//可更改元素类型,更换匹配函数和匹配价值函数

//例如说：abcde  和 atcdef  匹配的结果是：acde，尽可能的匹配，而不是字符段匹配

#include <iostream>

#include <string>

using namespace std;

 

#define MAXN 100

#define max(a,b) ((a)>(b)?(a):(b))

#define _match(a,b) ((a)==(b))

#define _value(a,b) 1

typedef char elem_t;

 

int str_match(int m,elem_t* a,int n,elem_t* b){

       int match[MAXN+1][MAXN+1],i,j;

       memset(match,0,sizeof(match));

       for (i=0;i<m;i++)

              for (j=0;j<n;j++)

                     match[i+1][j+1]=max(max(match[i][j+1],match[i+1][j]),

                                                 (match[i][j]+_value(a[i],b[i]))*_match(a[i],b[j]));

       return match[m][n];

}

 

int str_match(int m,elem_t* a,int n,elem_t* b,elem_t* ret){

       int match[MAXN+1][MAXN+1],last[MAXN+1][MAXN+1],i,j,t;

       memset(match,0,sizeof(match));

       for (i=0;i<m;i++)

              for (j=0;j<n;j++){

                     match[i+1][j+1]=(match[i][j+1]>match[i+1][j]?match[i][j+1]:match[i+1][j]);

                     last[i+1][j+1]=(match[i][j+1]>match[i+1][j]?3:1);

                     if ((t=(match[i][j]+_value(a[i],b[i]))*_match(a[i],b[j]))>match[i+1][j+1])

                            match[i+1][j+1]=t,last[i+1][j+1]=2;

              }

       for (;match[i][j];i-=(last[t=i][j]>1),j-=(last[t][j]<3))

              ret[match[i][j]-1]=(last[i][j]<3?a[i-1]:b[j-1]);

       return match[m][n];

}

 

int main()

{

    char a[1000],b[1000],ret[1000];

    int i,m,n,k;

   

    while (cin>>m>>n)

    {

        for (i=0;i<m;i++)

                cin>>a[i];

        for (i=0;i<n;i++)

                cin>>b[i];

       

        k=str_match(m,a,n,b,ret);

        cout<<k<<endl;

        for (i=0;i<k;i++)

        cout<<ret[i];

        cout<<endl;

    }   

   

    return 0;

}    

7. 函数—操作—方法—

8. 排序—分类—

---

 [GP1]不等同于int a=0;

 [GP2]static int b[4][3]={1,2,3,0,0,0,4,5};等价于static int b[4][3]={ 1,2,3,0,0,0,4,5,0,0,0,0,};