【最小生成树计数】【下标】

#include <iostream> //hdu 4408
#include <cstring>
#include <cmath>
#include <queue>
#include <stack>
#include <list>
#include <map>
#include <set>
#include <string>
#include <cstdlib>
#include <cstdio>
#include <algorithm>
using namespace std;

#define rep(i,a,n) for (int i=a;i<n;i++)
#define per(i,a,n) for (int i=n-1;i>=a;i--)
#define mp push_back

typedef long long LL;

const int MAXN = 110;
const int MAXM = 1010;
struct Edge
{
	int u,v,w;
}edge[MAXM];
int probef[MAXN]; //
int truef[MAXN]; //
int vis[MAXN]; //
vector<int> V[MAXN]; //
LL C[MAXN][MAXN]; //
LL g[MAXN][MAXN];
int cmp(Edge a,Edge b)
{
	return a.w < b.w;
}
LL gauss(LL a[][MAXN],int n,LL mod)
{
    for(int i=0; i<n; i++)  
        for(int j=0; j<n; j++)  
            a[i][j]%=mod;  
    LL ret=1;  
    for(int i=1; i<n; i++)  
    {  
        for(int j=i+1; j<n; j++)  
            while(a[j][i])  
            {  
                LL t=a[i][i]/a[j][i];  
                for(int k=i; k<n; k++)  
                    a[i][k]=(a[i][k]-a[j][k]*t)%mod;  
                for(int k=i; k<n; k++)  
                    swap(a[i][k],a[j][k]);  
                ret=-ret;  
            }  
        if(a[i][i]==0)  
            return 0;  
        ret=ret*a[i][i]%mod;  
    }  
    return (ret+mod)%mod;  
}
LL det(LL a[][MAXN],int n,LL mod)//生成树计数:Matrix-Tree定理  
{  
    for(int i=0; i<n; i++)  
        for(int j=0; j<n; j++)  
            a[i][j]%=mod;  
    int ret=1;  
    for(int i=1; i<n; i++)  
    {  
        for(int j=i+1; j<n; j++)  
            while(a[j][i])  
            {  
                int t=a[i][i]/a[j][i];  
                for(int k=i; k<n; k++)  
                    a[i][k]=(a[i][k]-a[j][k]*t)%mod;  
                for(int k=i; k<n; k++)  
                    swap(a[i][k],a[j][k]);  
                ret=-ret;  
            }  
        if(a[i][i]==0)  
            return 0;  
        ret=ret*a[i][i]%mod;  
    }  
    return (ret+mod)%mod;  
}  
int n,m;
LL MOD;
int find(int x,int F[MAXN])
{
	return F[x] == x ? x : find(F[x],F);
}

void Solve()
{
	sort(edge,edge+m,cmp);
	for(int i=1;i<=n;i++)
	{
		truef[i] = i;
		vis[i] = 0;
	}

	LL prelen = -1;
	LL ret = 1;
	//
/*	for(int i=1;i<=n;i++)
	{
		probef[i] = truef[i] = i;
		vis[i] = false;
		V[i].clear();
	}
*/


	
	for(int k=0;k<=m;k++)
	{
		if(k == m || edge[k].w != prelen)
		{
			for(int i=1;i<=n;i++)
			{
				if(vis[i])
				{
					LL u = find(i,probef);
					V[u].push_back(i);
					vis[i] = false;
				}
			}

			for(int i=1;i<=n;i++)
			{
				if(V[i].size() <= 1) continue;
				for(int a=1;a<=n;a++)
				{
					for(int b=1;b<=n;b++)
					{
						C[a][b] = 0;
					}
				}

				int len = V[i].size();
				for(int a=0;a<len;a++)
					for(int b=a+1;b<len;b++)
					{
						int a1 = V[i][a];
						int b1 = V[i][b];
						C[a][b] -= g[a1][b1];
						C[b][a] = C[a][b];
						C[a][a] += g[a1][b1];
						C[b][b] += g[a1][b1];
					}
				LL tmp = (LL)det(C,len,MOD);
				ret = ret * tmp % MOD;
				for(int a=0;a<len;a++)
				{
					truef[V[i][a]] = i;
				}
			}
			for(int i=1;i<=n;i++)
			{
				probef[i] = truef[i] = find(i,truef);
				V[i].clear();
			}

			prelen = edge[k].w;
			if(k == m) break;
			
		}
		Edge e = edge[k];
		int fu = find(e.u,truef);
		int fv = find(e.v,truef);
		if(fu != fv)
		{
			probef[find(fu,probef)] = find(fv,probef);
			vis[fu] = vis[fv] = true;
			g[fu][fv] ++;
			g[fv][fu] ++;
		}
		
	}
	bool flag = false;
	for(int i=2;i<=n;i++)
	{
		if(probef[i] != probef[i-1])
		{
			flag = true;
		}
	}
	//cout << flag << endl;
	//cout << ret << endl;
	if(m == 0 ) flag = true;
	printf("%I64d\n",flag? 0 : ret % MOD);
}


int main()
{
	freopen("in.txt","r",stdin);
	while(scanf("%d%d%I64d",&n,&m,&MOD))
	{
		
		if(n == 0 && m == 0 && MOD == 0) break;
		for(int i=1;i<=n;i++)
		{
			probef[i] = truef[i] = i;
			vis[i] = false;
			V[i].clear();
		}
		memset(g,0,sizeof(g));
		for(int tx=1;tx<=n;tx++)
			{
				for(int ty=1;ty<=n;ty++)
				{
					C[tx][ty] = 0;
				}
			}
		memset(g,0,sizeof(g));

        for(int i=1; i<=n; i++)  
            V[i].clear();  
		for(int i=0;i<m;i++)
		{
			scanf("%d%d%d",&edge[i].u,&edge[i].v,&edge[i].w);
		}
		sort(edge,edge+m,cmp);
		Solve();

	}
}