2014多益网络笔试题

1.求最大子矩阵和

转帖：http://blog.csdn.net/clearriver/article/details/4451493

最大子矩阵问题：
问题描述：(具体见http://acm.pku.edu.cn/JudgeOnline/showproblem?problem_id=1050 )
   给定一个n*n(0 Example：
 0 -2 -7  0 
 9  2 -6  2 
-4  1 -4  1 
-1  8  0 -2 
其中左上角的子矩阵：
 9 2 
-4 1 
-1 8 
此子矩阵的值为9+2+(-4)+1+(-1)+8=15。
  我们首先想到的方法就是穷举一个矩阵的所有子矩阵，然而一个n*n的矩阵的子矩阵的个数当n比较大时时一个很大的数字 O(n^2*n^2)，显然此方法不可行。
  怎么使得问题的复杂度降低呢？对了，相信大家应该知道了，用动态规划。对于此题，怎么使用动态规划呢？

  让我们先来看另外的一个问题(最大子段和问题)：
    给定一个长度为n的一维数组a，请找出此数组的一个子数组,使得此子数组的和sum＝a[i]+a[i+1]+……+a[j]最大，其中i>=0,i=i,j    31 -41 59 26 -53  58 97 -93 -23 84
 子矩阵59+26-53+58+97=187为所求的最大子数组。
第一种方法－直接穷举法:
   maxsofar=0;
   for i = 0 to n
   {
       for  j = i to n 
       {
            sum=0;
            for k=i to j 
                sum+=a[k] 
            if (maxsofar>sum)
               maxsofar=sum;
       }
   }

第二种方法－带记忆的递推法：
   cumarr[0]=a[0]
   for i=1 to n      //首先生成一些部分和
   {
        cumarr[i]=cumarr[i-1]+a[i];       
   }

   maxsofar=0
   for i=0 to n
   {
       for  j=i to n     //下面通过已有的和递推
       {
           sum=cumarr[j]-cumarr[i-1]
           if(sum>maxsofar)
               maxsofar=sum
       }
   }
显然第二种方法比第一种方法有所改进，时间复杂度为O(n*n)。

下面我们来分析一下最大子段和的子结构，令b[j]表示从a[0]~a[j]的最大子段和，b[j]的当前值只有两种情况，(1) 最大子段一直连续到a[j]  (2) 以a[j]为起点的子段，不知有没有读者注意到还有一种情况，那就是最大字段没有包含a[j]，如果没有包含a[j]的话，那么在算b[j]之前的时候我们已经算出来了，注意我们只是算到位置为j的地方，所以最大子断在a[j]后面的情况我们可以暂时不考虑。
由此我们得出b[j]的状态转移方程为：b[j]=max{b[j-1]+a[j],a[j]},
所求的最大子断和为max{b[j],0<=j 得出的算法如下：
    int maxSubArray(int n,int a[])
    {
        int b=0,sum=-10000000;
        for(int i=0;i         {
             if(b>0) b+=a[i];
             else b=a[i];
             if(b>sum) sum=b;  
        }
        return sum;
    }
这就是第三种方法－动态规划。

  现在回到我们的最初的最大子矩阵的问题,这个问题与上面所提到的最大子断有什么联系呢？
  假设最大子矩阵的结果为从第r行到k行、从第i列到j列的子矩阵，如下所示(ari表示a[r][i],假设数组下标从1开始)：
  | a11 …… a1i ……a1j ……a1n |
  | a21 …… a2i ……a2j ……a2n |
  |  .     .     .    .    .     .    .   |
  |  .     .     .    .    .     .    .   |
  | ar1 …… ari ……arj ……arn |
  |  .     .     .    .    .     .    .   |
  |  .     .     .    .    .     .    .   |
  | ak1 …… aki ……akj ……akn |
  |  .     .     .    .    .     .    .   |
  | an1 …… ani ……anj ……ann |

 那么我们将从第r行到第k行的每一行中相同列的加起来，可以得到一个一维数组如下：
 (ar1+……+ak1, ar2+……+ak2, ……,arn+……+akn)
 由此我们可以看出最后所求的就是此一维数组的最大子断和问题，到此我们已经将问题转化为上面的已经解决了的问题了。

  1 #include
  2 using namespace std;
  3
  4 int ** a;
  5 int **sum;
  6 int max_array(int *a,int n)
  7 {
  8         int *c = new int [n];
  9         int i =0;
 10         c[0] = a[0];
 11         for(i=1;i
 12         {
 13                 if(c[i-1]<0)
 14                         c[i] = a[i];
 15                 else
 16                         c[i] = c[i-1]+a[i];
 17         }
 18         int max_sum = -65536;
 19         for(i=0;i
 20                 if(c[i]>max_sum)
 21                         max_sum = c[i];
 22         delete []c;
 23         return max_sum;
 24
 25 }
 26 int max_matrix(int n)
 27 {
 28         int i =0;
 29         int j = 0;
 30         int max_sum = -65535;
 31         int * b = new int [n];
 32
 33         for(i=0;i
 34         {
 35                 for(j=0;j
 36                         b[j]= 0;
 37                 for(j=i;j//把数组从第i行到第j行相加起来保存在b中，在加时，自底向上，首先计算行间隔(j-i)等于1的情况，然后计算j-i等于
    2的情况，一次类推,在小间隔的基础上一次累加，避免重复计算
 38                 {
 39                         for(int k =0;k<=n;k++)
 40                                 b[k] += a[j][k];
 41                         int sum = max_array(b,n);
 42                         if(sum > max_sum)
 3                                 max_sum = sum;
 44                 }
 45         }
 46         delete []b;
 47         return max_sum;
 48 }
 49 int main()
 50 {
 51         int n;
 52         cin >> n;
 53
 54         a = new int *[n];
 55         sum = new int *[n];
 56         int i =0;
 57         int j =0;
 58         for(i=0;i
 59         {
 60                 sum[i] = new int[n];
 61                 a[i] = new int[n];
 62                 for(j=0;j
 63                 {
 64                         cin>>a[i][j];
 65                         sum[i][j] =0 ;//sum[r][k]表示起始和结尾横坐标分别为r,k时的最大子矩阵
 66                         //sum[r][k] = max{sum (a[i][j]):r<=i<=k}:0<=k<=n-1
 67                 }
 68         }
 69         /*
 70         int b[10]={31,-41,59,26,-53,58,97,-93,-23,84};
 71         cout << max_array(b,10) << endl;
 72         */
 73         cout << max_matrix(n);
 74 }

2.求最长回文字串

转帖：http://bbs.dlut.edu.cn/bbstcon.php?board=Competition&gid=23474

题目描述

给定一个字符串，找出该字符串的最长回文子串。回文字符串指的就是从左右两边看都一样的字符串，如aba，cddc都是回文字符串。字符串abbacdc存在的回文子串有abba和cdc，因此它的最长回文子串为abba。

一个容易犯的错误

初看这个问题可能想到这样的方法：对字符串S逆序得到新的字符串S'，再求S和S'的最长公共子串，这样求出的就是最长回文子串。

如S="caba", S'="abac"，则S和S'的最长公共子串为aba，这个是正确的。

但是如果S = “abacdfgdcaba”, S’ = “abacdgfdcaba”，则S和S'的最长公共子串为abacd，显然这不是回文字符串。因此这种方法是错误的。

 

判定一个字符串是否是回文字符串

要找出最长回文子串，首先要解决判断一个字符串是否是回文字符串的问题。最显而易见的方法是设定两个变量i和j，分别指向字符串首部和尾部，比较是否相等，然后i++，j--，直到i >= j为止。下面的代码是判断字符串str[i, j]是不是回文字符串，即字符串str从i到j的这一段子串是否是回文字符串，在后面会用到这个方法。

 bool isPalindrome(string str, int start, int end)
 {
     while (start < end) {
         if (str[start] != str[end])
             return false;
         ++start, --end;
     }
     return true;
 }

蛮力法求最长回文子串

蛮力法通过对字符串所有子串进行判断，如果是回文字符串，则更新最长回文的长度。因为长度为N的字符串的子串一共可能有(1+N)*N/2个，每次判断子串需要O(N)的时间，所以一共需要O(N^3)时间来求取最长回文子串。

 string longestPalindrome(string str)
 {
     int len = str.length(), max = 1;
     int start=0;
         /*遍历字符串所有的子串，若子串为回文字符串则更新最长回文的长度*/
         for (int i=0; i
         for (int j=i; j
             if (isPalindrome(str, i, j)) { //如果str[i,j]是回文，则判断其长度是否大于最大值，大于则更新长度和位置
                 int pLen = j - i + 1;
                 if (pLen > max) {
                     start = i;  //更新最长回文起始位置
                     max = pLen; //更新最长回文的长度
                 }
             }
         }
     }
     return str.substr(start, max);
 }

动态规划法求最长回文子串

因为蛮力法判定回文的时候需要很多重复的计算，所以可以通过动态规划法来改进该算法。假定我们知道“bab”是回文，则“ababa”也一定是回文。

 定义P[i, j] = true 如果子串S[i, j]是回文字符串。
 则 P[i, j] <- (P[i+1, j-1] && S[i]==S[j])。

Base Case如下：

 P[ i, i ] ← true
 P[ i, i+1 ] ← ( Si = Si+1 )

据此动态规划方法的代码如下, 该方法的时间复杂度为O(N^2)，空间复杂度为O(N^2)。

 string longestPalindromeDP(string s)
 {
     int n = s.length();
     int longestBegin = 0, maxLen = 1;
     bool table[1000][1000] = {false};
     for (int i=0; i
         table[i][i] = true;
     for (int i=0; i
         if (s[i] == s[i+1]) {
             table[i][i+1] = true;
             longestBegin = i;
             maxLen = 2;
         }
     }
         /*依次求table[i][i+2]...table[i][i+n-1]等*/
     for (int len=3; len<=n; ++len) {
         for (int i=0; i
             int j = i + len - 1;
             if (s[i]==s[j] && table[i+1][j-1]) {
                 table[i][j] = true;
                 longestBegin = i;
                 maxLen = len;
             }
         }
     }
     return s.substr(longestBegin, maxLen);
 }

 

中心法求最长回文子串

还有一个更简单的方法可以使用O(N^2)时间、不需要额外的空间求最长回文子串。我们知道回文字符串是以字符串中心对称的，如abba以及aba等。一个更好的办法是从中间开始判断，因为回文字符串以字符串中心对称。一个长度为N的字符串可能的对称中心有2N-1个，至于这里为什么是2N-1而不是N个，是因为可能对称的点可能是两个字符之间，比如abba的对称点就是第一个字母b和第二个字母b的中间。因此可以依次对2N-1个中心点进行判断，求出最长的回文字符串即可。根据该思路可以写出下面的代码。

 string expandAroundCenter(string s, int l, int r)
 {
     int n = s.length();
     while (l>=0 && r<=n-1 && s[l]==s[r]) {
         l--, r++;
     }
     return s.substr(l+1, r-l-1);
 }

 string longestPalindrome3(string s)
 {
     int n = s.length();
     if (n == 0) return "";
     string longest = s.substr(0, 1);
     for (int i=0; i
         string p1 = expandAroundCenter(s, i, i); //以位置i为中心的最长回文字符串
         if (p1.length() > longest.length())
             longest = p1;

         string p2 = expandAroundCenter(s, i, i+1); //以i和i+1之间的位置为中心的最长回文字符串
         if (p2.length() > longest.length())
             longest = p2;
     }
     return longest;
 }

转帖: http://bbs.dlut.edu.cn/bbstcon.php?board=Competition&gid=23474

 首先：大家都知道什么叫回文串吧，这个算法要解决的就是一个字符串中最长的回文子串有多长。这个算法可以在O（n）的时间复杂度内既线性时间复杂度的情况下，求出以每个字符为中心的最长回文有多长，
    这个算法有一个很巧妙的地方，它把奇数的回文串和偶数的回文串统一起来考虑了。这一点一直是在做回文串问题中时比较烦的地方。这个算法还有一个很好的地方就是充分利用了字符匹配的特殊性，避免了大量不必要的重复匹配。
    算法大致过程是这样。先在每两个相邻字符中间插入一个分隔符，当然这个分隔符要在原串中没有出现过。一般可以用‘#’分隔。这样就非常巧妙的将奇数长度回文串与偶数长度回文串统一起来考虑了（见下面的一个例子，回文串长度全为奇数了），然后用一个辅助数组P记录以每个字符为中心的最长回文串的信息。P［id］记录的是以字符str［id］为中心的最长回文串，当以str［id］为第一个字符，这个最长回文串向右延伸了P［id］个字符。
    原串：    w aa bwsw f d
    新串：   # w # a # a # b # w # s # w # f # d #
辅助数组P：  1 2 1 2 3 2 1 2 1 2 1 4 1 2 1 2 1 2 1
    这里有一个很好的性质，P［id］-1就是该回文子串在原串中的长度（包括‘#’）。如果这里不是特别清楚，可以自己拿出纸来画一画，自己体会体会。当然这里可能每个人写法不尽相同，不过我想大致思路应该是一样的吧。
    好，我们继续。现在的关键问题就在于怎么在O（n）时间复杂度内求出P数组了。只要把这个P数组求出来，最长回文子串就可以直接扫一遍得出来了。
    由于这个算法是线性从前往后扫的。那么当我们准备求P［i］的时候，i以前的P［j］我们是已经得到了的。我们用mx记在i之前的回文串中，延伸至最右端的位置。同时用id这个变量记下取得这个最优mx时的id值。（注：为了防止字符比较的时候越界，我在这个加了‘#’的字符串之前还加了另一个特殊字符‘$’，故我的新串下标是从1开始的）
好，到这里，我们可以先贴一份代码了。
复制代码void pk()
{
    int i;
    int mx = 0;
    int id;
    for(i=1; i
    {
        if( mx > i )
            p[i] = MIN( p[2*id-i], mx-i );        
        else
            p[i] = 1;
        for(; str[i+p[i]] == str[i-p[i]]; p[i]++)
            ;
        if( p[i] + i > mx )
        {
            mx = p[i] + i;
            id = i;
        }
    }
}
 


    代码是不是很短啊，而且相当好写。很方便吧，还记得我上面说的这个算法避免了很多不必要的重复匹配吧。这是什么意思呢，其实这就是一句代码。


if( mx > i )
    p[i] = MIN( p[2*id-i], mx-i );


就是当前面比较的最远长度mx>i的时候，P［i］有一个最小值。这个算法的核心思想就在这里，为什么P数组满足这样一个性质呢?
   （下面的部分为图片形式）




以上都是翻译部分，这里在贴一个poj3974的AC代码，果然是瞬秒啊。
#include
#include
#include
#include
using namespace std;
const int MAXN=1000010;
char str[MAXN],s[MAXN*2];
int n,p[MAXN*2],ans,cases=1;
void rebuild()
{
    s[0]='$',s[1]='#';
    n=strlen(str);
    for(int i=0;i
    s[2*i+2]=str[i],s[2*i+3]='#';
    s[n=n*2+2]=0;
}
void solve()
{
    int mx=0,id,ans=1;
    for(int i=0;i
    {
        if(mx>i)p[i]=min(p[2*id-i],mx-i);
        else p[i]=1;
        for(;s[i-p[i]]==s[i+p[i]];p[i]++);
        if(p[i]+i>mx)mx=p[i]+i,id=i;
        ans=max(ans,p[i]);
    }
    printf("Case %d: %d\n",cases++,ans-1);
}
int main()
{
    while(scanf("%s",str),str[0]-'E')
    {
        rebuild();
        solve();
    }
    return 0;
}

即如：
用O(n)的思想居然也可以解决，算法思路就是利用一个P数组辅助记录，P[id]记录为以str[id]为中心，向右扩展p[id]。这里由于在字符串中添加了#,所以最长回文的长度刚好是P[id]-1,如果按照常规的应该是P[id]*2-1，但是由于在每两个字符之间加了#,所以刚好抵消了。 由于这个算法是线性从前往后扫的。那么当我们准备求P［i］的时候，i以前的P［j］我们是已经得到了的。我们用mx记在i之前的回文串中，延伸至最右端的位置。同时用id这个变量记下取得这个最优mx时的id值。（注：为了防止字符比较的时候越界，我在这个加了‘#’的字符串之前还加了另一个特殊字符‘$’，故我的新串下标是从1开始的）

 void pk()
 {
     int i;
     int mx = 0;
     int id;
     for(i=1; i
     {
         if( mx > i )
             p[i] = MIN( p[2*id-i], mx-i );
         else
             p[i] = 1;
         for(; str[i+p[i]] == str[i-p[i]]; p[i]++)
             ;
         if( p[i] + i > mx )
         {
             mx = p[i] + i;
             id = i;
         }
     }
 }



 3. 第三题是告诉我们有M个相同的怪物，N个相同的副本，每个副本可能有多个怪物，并且假设2，2，2，3，3和3，3，2，2，2这是一种情况，则问我们总共有多少种？

             这一题是这样子求得的，第一个问是M=11，N=7时，求有多少种？

            第二个问是编写代码和思路。