SRM 599 DIV2 950

太弱了。。。。这么简单的题也只能比赛之后写。。。。。

roblem Statement
	Fox Ciel has a list of names on her computer. In this problem, a name is simply a non-empty string of lowercase letters. All names in her list are distinct. One day, when she left her seat, she forgot to lock her computer. Then, Lun the mischievous dog appeared, and randomly shuffled the order of the names in her list. Now, Ciel has to restore the original order of names using her memory. You are given a vector <string>namesand an intL.namescontains all names in the shuffled list in the order they appear.Ldescribes Ciel's memory of the original list. She remembers that, for each i between 0 andL-2, inclusive, the i-th (0-indexed) name in the original list was a prefix of the (i+1)-th name. Let X be the number of possible orders of the names in the original list that are consistent with Ciel's memory. Calculate and return the value (X modulo 1,000,000,007). X can be 0, which means Ciel's memory is inconsistent with the names in the list.
Definition
	Class: SimilarNames2 Method: count Parameters: vector <string>, int Returns: int Method signature: int count(vector <string> names, int L) (be sure your method is public)
Notes
-	A prefix of a string is the result of erasing zero or more characters from the right end of that string.
Constraints
-	nameswill contain between 2 and 50 elements, inclusive.
-	Each element ofnameswill contain between 1 and 50 characters, inclusive.
-	Each character of each element ofnameswill be a lowercase letter ('a'-'z').
-	Elements ofnameswill be distinct.
-	Lwill be between 1 and n, inclusive, where n is the number of elements innames.
Examples
0)
	{"kenta", "kentaro", "ken"} 2 Returns: 3 Here, Ciel's list contains 3 names. She remembers that the 0-th name was a prefix of the 1-st name in the original list. Here are the all possible orders of names in the original list: ken, kenta, kentaro ken, kentaro, kenta kenta, kentaro, ken Note that it is possible that the order of the names in the original list coincides with that of the shuffled list.
1)
	{"hideo", "hideto", "hideki", "hide"} 2 Returns: 6 Again, she remembers that the 0-th name was a prefix of the 1-st name in the original list. The only thing we can be sure is that the 0-th name was "hide".
2)
	{"aya", "saku", "emi", "ayane", "sakura", "emika", "sakurako"} 3 Returns: 24 This time, she remembers not only the fact that the 0-th name was a prefix of the 1-st name, but also the fact that the 1-st name was a prefix of the 2-nd name. The first 3 names should be "saku", "sakura", "sakurako" in this order.
3)
	{"taro", "jiro", "hanako"} 2 Returns: 0 No name is a prefix of another name in this case, so her memory is inconsistent.
4)
	{"alice", "bob", "charlie"} 1 Returns: 6 L= 1 means that she actually remembers nothing.
5)
	{"ryota", "ryohei", "ryotaro", "ryo", "ryoga", "ryoma", "ryoko", "ryosuke", "ciel", "lun", "ryuta", "ryuji", "ryuma", "ryujiro", "ryusuke", "ryutaro", "ryu", "ryuhei", "ryuichi", "evima"} 3 Returns: 276818566

This problem statement is the exclusive and proprietary property of TopCoder, Inc. Any unauthorized use or reproduction of this information without the prior written consent of TopCoder, Inc. is strictly prohibited. (c)2003, TopCoder, Inc. All rights reserved.

#include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <cstring>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>

using namespace std;

const int MOD=1000000007;
int qianzui[100];
int Com[60][60];

void getCom()
{
    Com[0][0]=1;
    for(int i=1;i<=50;i++) Com[i][i]=Com[0][i]=1;
    for(int i=2;i<=50;i++)
    {
        for(int j=1;j<i;j++)
        {
            Com[j][i]=(Com[j-1][i-1]+Com[j][i-1])%MOD;
        }
    }
}

int getC(int l,int z)
{
    if(l>z) return 0;
    if(l==0||l==z) return 1;
    return Com[l][z];
}

class SimilarNames2 {
public:
	int count(vector <string> names, int L)
	{
	    getCom();
	    int n=names.size();
	    memset(qianzui,0,sizeof(qianzui));
	    sort(names.begin(),names.end());
	    ///预处理前缀
	    for(int i=1;i<n;i++)
        {
            int len2;
            for(int j=0;j<i;j++)
            {
                len2=names[j].size();
                if(names[i].substr(0,len2)==names[j])
                {
                    qianzui[i]=max(qianzui[j]+1,qianzui[i]);
                }
            }
        }
        long long int ans=0;
        for(int i=0;i<n;i++)
        {
            ans=(ans+getC(L-1,qianzui[i]))%MOD;
        }
        for(int i=2;i<=n-L;i++)
        {
            ans=(ans*i)%MOD;
        }
        return ans%MOD;
	}
};


///<%:testing-code%>
//Powered by KawigiEdit 2.1.4 (beta) modified by pivanof!
// BEGIN KAWIGIEDIT TESTING