Generator zoj2619

这题和hdu3058要求差不多，只不过只有一个终止串，但正因为如此，生成的串长度期望也增加了，long double精度也不够了，之后网上看到解集全部是整数（为什么还没想通），所以可以用整数消元。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>
#include<iomanip>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::fixed;
using std::setprecision;

typedef long long LL;
typedef unsigned long long ULL;
typedef unsigned UNS;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(15);
//const int SIGMA_SIZE(26);
const int MAXM(110);
const int MAXE(4000010);
const int MAXH(18);
const int INFI((INT_MAX-1) >> 1);
const double EPS(1e-11);
const int MOD(10007);
const ULL LIM(1000000000000000ull);

typedef long long ll;

inline bool EZ(double temp)
{
    return fabs(temp) < EPS;
}

template<typename T>
T ABS(const T &op)
{
	return op < 0? -op: op;
}

LL gcd(LL op1, LL op2)
{
	LL temp;
	while(op2)
	{
		temp = op1%op2;
		op1 = op2;
		op2 = temp;
	}
	return op1;
}

LL lcm(LL op1, LL op2)
{
	return op1/gcd(op1, op2)*op2;
}

struct MAT
{
    int r, c;
    LL arr[MAXN][MAXN];
    MAT(int tr, int tc): r(tr), c(tc)
    {}
    MAT()
    {}
    void reset()
    {
        for(int i = 0; i < r; ++i)
            for(int j = 0; j < c; ++j)
                arr[i][j] = 0;
    }
    void identity()
    {
        reset();
        for(int i = 0; i < r; ++i)
            arr[i][i] = 1;
    }
    
    /* 模2方程组消元
    int XOR_eliminate()
    {
        int rank = 0, temp;
        for(int i = 0; i < r; ++i)
        {
            temp = i;
            for(int k = i; k < r; ++k)
                if(arr[k][i]){temp = k; break;}
            if(arr[temp][i] == 0) 
            { is_free[i] = true; continue;}
            is_free[i] = false;
            ++rank;
            if(temp != i) 
                for(int k = 0; k < c; ++k) 
                    swap(arr[i][k], arr[temp][k]);
            for(int k = i+1; k < r; ++k)
                if(arr[k][i])
                    for(int k2 = i; k2 < c; ++k2)
                        arr[k][k2] ^= arr[i][k2];
        }
		if(rank < r)
			return rank;
        for(int i = r-1; i >= 0; --i)
        {
            for(int j = i+1; j < c-1; ++j)
                arr[i][c-1] ^= arr[j][c-1]&arr[i][j];
            if(arr[i][i] == 0 && arr[i][c-1] != 0)
                return -1;                      //有矛盾解
        }
        return rank; //返回矩阵的秩
    }
	*/

	bool gaussInt()
	{
		int temp;
		LL mmi;
		for(int i = 0; i < r; ++i)
		{
			mmi = ABS(arr[i][i]);
			temp = i;
			for(int j = i+1; j < r; ++j)
				if(ABS(arr[j][i]) < mmi && arr[j][i])
				{
					mmi = ABS(arr[j][i]);
					temp = j;
				}
			if(temp != i)
				for(int j = 0; j < c; ++j)
					swap(arr[i][j], arr[temp][j]);
			for(int j = i+1; j < r; ++j)
				if(arr[j][i])
				{
					LL lc = lcm(arr[j][i], arr[i][i]);
					LL l1, l2;
					l1 = lc/arr[j][i];
					l2 = lc/arr[i][i];
					for(int k = i; k < c; ++k)
						arr[j][k] = arr[j][k]*l1-arr[i][k]*l2;
				}
		}
		for(int i = r-1; i >= 0; --i)
		{
			for(int j = i+1; j < c-1; ++j)
				arr[i][c-1] -= arr[j][c-1]*arr[i][j];
			arr[i][c-1] /= arr[i][i];
		}
		return true;
	}
	/*
	void gauss_eliminate()
    {
        int temp;
        long double mmx;
        for(int i = 0; i < r; ++i)
        {
            temp = i;
            mmx = fabs(arr[i][i]);
            for(int j = i+1; j < r; ++j)
                if(fabs(arr[j][i]) > mmx)
                {
                    mmx = fabs(arr[j][i]);
                    temp = j;
                }
            if(temp != i) for(int j = 0; j < c; ++j) swap(arr[temp][j],arr[i][j]);
            for(int j = c-1; j >= i; --j)
                for(int k = i+1; k < r; ++k)
                    arr[k][j] -= arr[k][i]/arr[i][i]*arr[i][j];
        
        }
        for(int i = r-1; i >= 0; --i)
        {
            for(int j = i+1; j < c-1; ++j)
                arr[i][c-1] -= arr[j][c-1]*arr[i][j];
            arr[i][c-1] /= arr[i][i];
        }
    }


    void gauss_jordan()
    {
        int temp;
        for(int i = 0; i < r; ++i)
        {
            temp = i;
            for(int j = i+1; j < r; ++j)
                if(fabs(arr[j][i]) > fabs(arr[temp][i])) temp = j;
            if(EZ(arr[temp][i])) continue;
            if(temp != i)
                for(int j = 0; j < c; ++j)
                    swap(arr[temp][j], arr[i][j]);
            for(int j = 0; j < r; ++j)
                if(j != i)
                    for(int k = c-1; k >= i; --k)
                        arr[j][k] -= arr[j][i]/arr[i][i]*arr[i][k];
        }
    }*/
};

MAT mat;

int SIGMA_SIZE;
int que[MAXN];
int front, back;

struct AC
{
    int ch[MAXN][27];
    int f[MAXN];
    bool val[MAXN];
    int size;
    
    void init()
    {
        memset(ch[0], 0, sizeof(ch[0]));
        f[0] = 0;
        val[0] = false;
        size = 1;
    }
    inline int idx(char temp)
    {
        return temp-'A';        
    }
    
    void insert(char *S)
    {
        int u = 0, id;
        for(; *S; ++S)
        {
            id = idx(*S);
            if(!ch[u][id])
            {
                memset(ch[size], 0, sizeof(ch[size]));
                val[size] = false;
                ch[u][id] = size++;
            }
            u = ch[u][id];
        }
        val[u] = true;
    }  
    void construct()
    {
        front = back = 0;
        int cur, u;
        for(int i = 0; i < SIGMA_SIZE; ++i)
        {
            u = ch[0][i];
            if(u)
            {
                que[back++] = u;
                f[u] = 0;
            }
        }
        while(front < back)
        {
            cur = que[front++];
            for(int i = 0; i < SIGMA_SIZE; ++i)
            {
                u = ch[cur][i];
                if(u)
                {
                    que[back++] = u;
                    f[u] = ch[f[cur]][i];
                    val[u] |= val[f[u]];
                }
                else
                    ch[cur][i] = ch[f[cur]][i];
            }
        }
    }
};

AC ac;

bool vis[MAXN];

void dfs(int cur)  //列方程时两边同时乘上SIGMA_SIZE,这样就可以避免处以SIGMA_SIZE，否则精度损失较大，G++也过不了
{
    if(vis[cur])
        return;
    vis[cur] = true;
    mat.arr[cur][cur] = SIGMA_SIZE;
    if(ac.val[cur])
        mat.arr[cur][ac.size] = 0;
    else
        mat.arr[cur][ac.size] = SIGMA_SIZE;   
    for(int i = 0; i < SIGMA_SIZE; ++i)
    {
        int tv = ac.ch[cur][i];
        if(!ac.val[cur])
			mat.arr[cur][tv] -= 1;
        dfs(tv);
    }
}

char str[15];

int main()
{
    int TC, n_case(0);
    scanf("%d", &TC);
    while(TC--)
    {
        scanf("%d", &SIGMA_SIZE);
        ac.init();
        scanf("%s", str);
        ac.insert(str);
        ac.construct();
        mat.r = ac.size;
        mat.c = ac.size+1;
        mat.reset();
        memset(vis, 0, sizeof(vis));
        dfs(0);
		mat.gaussInt();
		if(n_case)
			cout << "\n";
		cout << "Case " << ++n_case << ":\n";
		cout << mat.arr[0][ac.size] << "\n";
    }
    return 0;
}