傻瓜笔记之动态规划（二）——最长公共子串

示例字符串：

X = "abcopms"    Y = "opmkabc" , 最长公共子串Z = "abc   opm"

状态转移思路：由于记录的是最长的连续的子串，那么只需要在碰到相同的字符的时候做标记即可，不需要像最长子序列那样做状态转移的记录，即该问题的状态转换方程如下：

Z = 1，  z[i,j] = 0                     i==0 or j == 0

　　2，  z[i,j] = z[i-1,j-1]+1     x[i] == y[j]    解1

　　3，  z[i,j] = 0                     x[i]!=y[j]

解1：匹配到相同的字符的时候，就在两个字符串前面的基数上面增加1，意味着最长子串长度加一（到遍历的目前为止），这个是该方程唯一一个状态转移的过程。

下面贴上全文代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 最长子串
{
    class Program
    {
        public static string s1 = "abcopms";
        public static string s2 = "opmkabc";
        public static int maxLength = 0;        // 记录最长的长度
        public static int [,] c = new int[s1.Length+1, s2.Length+1];
        static void Main(string[] args)
        {
            MaxLength();
            for (int i = 0; i < s1.Length + 1; ++i)
            {
                for (int j = 0; j < s2.Length + 1; ++j)
                {
                    Console.Write(c[i, j]);
                }
                Console.Write("
");
            }
            Console.WriteLine("这是所有子串");
            for(int i = 0;i<s1.Length+1;++i)
            {
                for(int j = 0;j<s2.Length+1;++j)
                {
                    if (c[i, j] == maxLength)
                    {
                        Translate(i, j);
                        Console.Write("
");
                    }
                }
            }
            Console.ReadKey();
        }

        public static void Translate(int x,int y)
        {
            if (c[x, y] == 0) return;
            else
            {
                Translate(x - 1, y - 1);
                //Console.WriteLine("printf");
                Console.Write(s1[x - 1]);
            }
        }

        public static int [,] MaxLength()
        {
            Console.WriteLine("这是状态矩阵");
            Console.WriteLine(s1);
            Console.WriteLine(s2);
            for(int i = 0;i<s1.Length+1;++i)
            {
                for(int j=0;j<s2.Length+1;++j)
                {
                    if (i == 0 || j == 0)
                        c[i, j] = 0;
                    else if (s1[i-1] == s2[j-1])
                    {
                        c[i, j] = c[i - 1, j - 1] + 1;
                        maxLength = Math.Max(maxLength, c[i, j]);
                    }
                    else
                    {
                        c[i, j] = 0;
                    }
                }
            }
            return c;
        }
    }
}

完成状态转移的代码片段如下：

public static int [,] MaxLength()
        {
            Console.WriteLine("这是状态矩阵");
            Console.WriteLine(s1);
            Console.WriteLine(s2);
            for(int i = 0;i<s1.Length+1;++i)
            {
                for(int j=0;j<s2.Length+1;++j)
                {
                    if (i == 0 || j == 0)
                        c[i, j] = 0;
                    else if (s1[i-1] == s2[j-1])
                    {
                        c[i, j] = c[i - 1, j - 1] + 1;
                        maxLength = Math.Max(maxLength, c[i, j]);
                    }
                    else
                    {
                        c[i, j] = 0;
                    }
                }
            }
            return c;
        }

该片段执行完毕之后返回一个二维数组，记录此次转移的过程

完成状态转移数组遍历的代码如下：

for(int i = 0;i<s1.Length+1;++i)
            {
                for(int j = 0;j<s2.Length+1;++j)
                {
                    if (c[i, j] == maxLength)
                    {
                        Translate(i, j);
                        Console.Write("
");
                    }
                }
            }

遍历转移数组的过程中，只有碰到最大值得时候才是最长子串的时候，但是往往最长的子串又不止一个，如果题目规定只有一个最长子串的话，那么只要记录在记录maxLength时同步记录下i，j，即可直接进行输出而不必遍历整个数组。

完成子串输出的代码如下：

public static void Translate(int x,int y)
        {
            if (c[x, y] == 0) return;
            else
            {
                Translate(x - 1, y - 1);
                Console.Write(s1[x - 1]);
            }
        }

总结：没什么好说的，更最长子序列差不多一个模子，而且代码量显然比最长子序列少，因果过程就比它要简单的多。