USACO_2_3_Longest Prefix

我用动态规划，下面主要讲一下怎么去思考这个题。

在我的《通过金矿模型介绍动态规划》一文中我提到思考动态规划可以分为9个步骤，其实这9步中第一步是最重要的，就是如何模拟这个过程。

拿到这道题的时候，我们可以这样想，假如我有一张条纸，上面写了一个串s，我需要从前面开始剪掉一个前缀，但是每次剪下来的子串都必须是P集合中的元素，我需要知道剪掉的前缀最长可以有多长。

现在来思考问题的最后一步。如果最多可以剪掉长度为k的前缀，那么最后一步就是在s的k前缀中我需要从末尾剪掉哪一个子串，而这个字串必须是p中的元素。

那我到底剪掉p中的哪一个呢？我一个一个的试（选择），比如我选择p1，此时我的子问题就是这去掉了p1的k前缀能不能用p中的元素组合而得，可见出现了“子问题重叠”。

可见如果去掉了p1的k前缀能够用p中的元素组合而得，那么k前缀就能够用p中的元素组合而得，这叫“最优子结构”。

如果s的长度为length，p中有n个字串，那么就有length个前缀（问题数），对每个前缀有n种选择，算法的复杂度为O(length * n)

 

/**//*
ID: sdjllyh1
PROG: prefix
LANG: JAVA
complete date: 2008/12/16
complexity: O(length * n) n是子片段的个数，length是s的长度
author: LiuYongHui From GuiZhou University Of China
more article: www.cnblogs.com/sdjls
*/

import java.io.*;
import java.util.*;

public class prefix
{
    private static String s;
    private static String[] primitives;//输入中给出的小字符串
    private static boolean[] canBeComposed;//canBeComposed[k]=true 表示s的k前缀可以用给定的小字符串来组成
    private static int longestLength;//最多能够表示的长度，也就是我们要求的答案

    public static void main(String[] args) throws IOException
    {
        init();
        run();
        output();
        System.exit(0);
    }

    private static void run()
    {
        //判断s的i前缀能不能由primitives组成
        for (int i = 0; i < s.length(); i++)
        {
            //选择最后减去的子串
            for (int j = 0; j < primitives.length; j++)
            {
                //如果这个字串是i前缀的后缀
                if (isSuffix(s, primitives[j], i - primitives[j].length() + 1))
                {
                    //且s的i-length前缀能够由primitives组成，length为选择的字串长度
                    if ((i - primitives[j].length() + 1 == 0) || (canBeComposed[i - primitives[j].length()]))
                    {
                        //s的i前缀能够由primitives组成
                        canBeComposed[i] = true;
                        break;
                    }
                }
            }
        }
        //获得最长的能够被匹配的前缀的长度
        longestLength = calcLongestLength();
    }

    //计算suffix是否是matching的k前缀的后缀，startIndex是开始比较的地方，k是比较结束的地方
    private static boolean isSuffix(String matching, String suffix, int startIndex)
    {
        if (startIndex<0)
        {
            return false;
        }
        for (int i = 0; i < suffix.length(); i++)
        {
            if (matching.charAt(startIndex + i) != suffix.charAt(i))
            {
                return false;
            }
        }
        return true;
    }

    private static int calcLongestLength()
    {
        int retLength = 0;
        for (int i = 0; i < canBeComposed.length; i++)
        {
            if (canBeComposed[i])
            {
                retLength = i + 1;
            }
        }
        return retLength;
    }

    private static void init() throws IOException
    {
        BufferedReader f = new BufferedReader(new FileReader("prefix.in"));

        String[] tmpPrimitives = new String[200];
        int primitivesCounter = 0;

        StringTokenizer st;
        String readLine = f.readLine();
        while (!readLine.equals("."))
        {
            st = new StringTokenizer(readLine);
            while (st.hasMoreTokens())
            {
                tmpPrimitives[primitivesCounter] = st.nextToken();
                primitivesCounter++;
            }
            readLine = f.readLine();
        }
        primitives = new String[primitivesCounter];
        for (int i = 0; i < primitivesCounter; i++)
        {
            primitives[i] = tmpPrimitives[i];
        }


        StringBuffer tmpS = new StringBuffer();
        String readLine2 = f.readLine();
        while (readLine2 != null)
        {
            tmpS.append(readLine2);
            readLine2 = f.readLine();
        }
        s = tmpS.toString();

        f.close();

        canBeComposed = new boolean[s.length()];
    }

    private static void output() throws IOException
    {
        PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("prefix.out")));
        out.println(longestLength);
        out.close();
    }
}