HDU2254_奥运_矩阵_图论应用

这道题目把矩阵跟图论完美地结合在了一起，矩阵与图论，本来就是难舍难分。能一下子想到相关知识，还是比较有难度

要看多点书嘞。

/*
*题目大意：
*        他知道中国有很多的名胜古迹，他知道自己在t1 到 t2天内不可能把所有的
*        地方都玩遍，所以他决定指定两个地方v1,v2，如果参赛员能计算出在t1到t2天
*        （包括t1,t2）内从v1到v2共有多少种走法(每条道路走需要花一天的时间，且不
*        能在某个城市停留,且t1=0时的走法数为0)，那么他就会获得相应数量的金牌，
*        城市的总数<=30,两个城市间可以有多条道路，每条都视为是不同的。
*解题思路：
*        以每两个点之间路径的数量建立邻接矩阵A，然后邻接矩阵的l次幂就代表两个点之间
*        路径长度为l的数量。而当算A^1 + A^2 + A^3 + A^4 + …… + A^l时，就代表邻接矩阵
*        中任意两点的长度为1~l的数量。来到这里，就足够解决该题了。
*/

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <map>

#define MAX_DIMENSION 31 

using namespace std;

typedef int MATRIX_TYPE;
typedef int MAX_INT_TYPE; 
typedef MATRIX_TYPE Matrix[MAX_DIMENSION][MAX_DIMENSION];
int ndim=MAX_DIMENSION;
int mod = 2008;

void m_zero(Matrix  x)
{
    memset(x, 0, sizeof(MATRIX_TYPE)*MAX_DIMENSION*MAX_DIMENSION);
}

void m_one(Matrix  x)
{
    int i;
    m_zero(x);
    for(i=0;i<ndim;++i)x[i][i]=1;
}

void m_copy(Matrix  src,Matrix  dest)
{
    memcpy(dest,src, sizeof(MATRIX_TYPE)*MAX_DIMENSION*MAX_DIMENSION);
}

//z=x+y;
void m_add(Matrix  x,Matrix  y,Matrix  z)
{
    int i,j;
    for(i=0;i<ndim;i++)
        for(j=0;j<ndim;j++)
            if(mod<=1)z[i][j]=x[i][j]+y[i][j];
            else z[i][j]=(x[i][j]+(MAX_INT_TYPE)y[i][j])%mod;//module
}


//c=a*b
void m_multiple(Matrix  a,Matrix b,Matrix c)
{
    int i,j,k;
    MAX_INT_TYPE t;

    for(i=0;i<ndim;i++)
        for(j=0;j<ndim;j++)
        {
            t=0;
            if(mod<=1)
                for(k=0;k<ndim;k++) t+=a[i][k]*b[k][j];//module
            else
                for(k=0;k<ndim;k++){
                    t+=(a[i][k]*(MAX_INT_TYPE)b[k][j])%mod;
                    t%=mod;
                }//module
            c[i][j]=t;
        }
}

//根据已经算出来的x^1 x^2 x^4 ...去求矩阵的幂y=x^n
void m_pow_with_saved(Matrix  x_p[],unsigned int n, Matrix y)
{
    Matrix temp;
    m_one(y);
    for(int k=1;n;++k,n>>=1)
    {
        if ((n & 1) != 0)
        {
            m_multiple(x_p[k],y,temp);
            m_copy(temp,y);
        }
    }
}

//计算根据已经算出来的x^1 x^2 x^4 ...去求矩阵的幂和y=sum(x^n)
void m_pow_sum1(Matrix  x_p[],unsigned int n, Matrix y)
{
    m_zero(y);
    if(n==0)return;
    if(n==1) m_copy(x_p[1],y);
    else
    {
        Matrix temp;
        //calculate x^1+...+^(n/2)
        m_pow_sum1(x_p,n>>1,temp);
        //add to y
        m_add(temp,y,y);
        //calculate x^(1+n/2)+...+x^n
        Matrix temp2;
        m_pow_with_saved(x_p,n>>1,temp2);
        Matrix temp3;
        m_multiple(temp,temp2,temp3);
        //add to y
        m_add(temp3,y,y);
        if(n&1)
        {
            //calculate x^(n-1)
            m_multiple(temp2,temp2,temp3);
            //calculate x^n
            m_multiple(temp3,x_p[1],temp2);
            //add x^n
            m_add(temp2,y,y);
        }
    }

}

//计算x^1 x^2 x^4 ...，然后调用求幂和的地方
void m_pow_sum(Matrix x, unsigned int n, Matrix y)
{
    //calculate x^1 x^2 x^4 ... x^logn
    unsigned int i=0,logn,n2=n;
    for(logn=0,n2=n;n2;logn++,n2 >>= 1);
    Matrix *pow_arry=new Matrix[logn==0?2:(logn+1)];
    m_one(pow_arry[0]);
    m_copy(x,pow_arry[1]);
    for(i=1;i<logn;i++)
    {
        m_multiple(pow_arry[i],pow_arry[i],pow_arry[i+1]);
    }

    m_pow_sum1(pow_arry,n,y);
    delete []pow_arry;
}

int main(void)
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif

    map<int, int> index;
    int n;
    while(scanf("%d", &n) == 1)
    {
        index.clear();
        int ind = 0;
        Matrix a;
        m_zero(a);
        for(int i = 0; i < n; i++)
        {
            int u, v;
            scanf("%d %d", &u, &v);
            if(!index.count(u))
                index[u] = ind++;
            if(!index.count(v))
                index[v] = ind++;
            a[index[u]][index[v]]++;
        }
        ndim = ind;

        int m;
        scanf("%d", &m);
        for(int i = 0; i < m; i++)
        {
            int u, v, t1, t2;
            scanf("%d %d %d %d", &u, &v, &t1, &t2);
            //防止u,v未出现过。
            if(!index.count(u) || !index.count(v))
            {
                printf("0\n");
                continue;
            }
            u = index[u], v = index[v];
            if(t1 > t2)
            {
                t1 = t1 ^ t2;
                t2 = t1 ^ t2;
                t1 = t1 ^ t2;
            }
            if(!t2)
            {
                printf("0\n");
                continue;
            }
            Matrix presum, tolsum;
            if(t1 > 1)
            {
                m_pow_sum(a, t1 - 1, presum);
                m_pow_sum(a, t2, tolsum);
                printf("%d\n", ((tolsum[u][v] - presum[u][v]) % mod + mod) % mod);
            }
            else
            {
                m_pow_sum(a, t2, tolsum);
                printf("%d\n", ((tolsum[u][v] % mod) + mod) % mod);
            }
        }
    }
    return 0;
}