Matching In Multiplication（HDU 6073）

Matching In Multiplication

Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 524288/524288 K (Java/Others)

Total Submission(s): 1658    Accepted Submission(s): 500

Problem Description

In the mathematical discipline of graph theory, a bipartite graph is a graph whose vertices can be divided into two disjoint sets  U  and  V  (that is,  U  and  V  are each independent sets) such that every edge connects a vertex in  U  to one in  V . Vertex sets  U  and  V  are usually called the parts of the graph. Equivalently, a bipartite graph is a graph that does not contain any odd-length cycles. A matching in a graph is a set of edges without common vertices. A perfect matching is a matching that each vertice is covered by an edge in the set.



Little Q misunderstands the definition of bipartite graph, he thinks the size of  U  is equal to the size of  V , and for each vertex  p  in  U , there are exactly two edges from  p . Based on such weighted graph, he defines the weight of a perfect matching as the product of all the edges' weight, and the weight of a graph is the sum of all the perfect matchings' weight.

Please write a program to compute the weight of a weighted ''bipartite graph'' made by Little Q.

 

Input

The first line of the input contains an integer  T(1≤T≤15) , denoting the number of test cases.

In each test case, there is an integer  n(1≤n≤300000)  in the first line, denoting the size of  U . The vertex in  U  and  V  are labeled by  1,2,...,n .

For the next  n  lines, each line contains  4  integers  vi,1,wi,1,vi,2,wi,2(1≤vi,j≤n,1≤wi,j≤109) , denoting there is an edge between  Ui  and  Vvi,1 , weighted  wi,1 , and there is another edge between  Ui  and  Vvi,2 , weighted  wi,2 .

It is guaranteed that each graph has at least one perfect matchings, and there are at most one edge between every pair of vertex.

 

Output

For each test case, print a single line containing an integer, denoting the weight of the given graph. Since the answer may be very large, please print the answer modulo  998244353 .

 

Sample Input

  
  

   
   1
2
2 1 1 4
1 4 2 3
  
  

 

Sample Output

  
  

   
   16
  
  

 //题意：一张二分图，左边每个点都是2个出度（即左边每个点都和右边的点有2条边），右边就不一定了。每2个点连一条边（一个点在左边，一个点在右边），若包含左右所有顶点，就是完美匹配。一个完美匹配的值是各边权值的乘积。现在要求所有完美匹配的值之和。

//思路：很显然，如果一个点只有1条边连向它，那么要构成完美匹配的话，这条边就一定是其中一条，（即这个点的配对点是唯一的）。且这种点一定出现在右边。先把这种情况都找出来，对于后面所有情况来说，都要包含这条边。

设满足这个条件的所有边的乘积为res。

把上述条件的那些边删去后，剩下的每个点（包括左右）必定有2条边经过。但现在的图中可能有多个环。但我们知道，在一个环中只有2种情况，设一种情况的值是v1,另一种是v2，那这个环的值就是v1+v2。我们要找出所有环，把所有环的值相乘，设为ans。

那么答案就是（ans*res）%mod 。

给几组我调试的数据：

3
1 1 2 2
1 3 3 4
1 5 3 6
输出：76

4
1 4 2 1
1 4 2 3
3 4 4 1
3 4 4 3
输出：256

4
1 2 2 2
2 1 3 2
2 1 4 2
2 1 4 2
输出：16

6
1 2 2 3
2 1 3 2
2 2 3 4
3 3 4 2
5 1 6 4
5 3 6 2
输出：448

3
1 2 2 3
2 4 3 5
1 6 3 7

输出：146

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;

const int MAX = 600005;
const int mod = 998244353;

typedef struct {
	int val, to;
}Point;

int n;
long long sum;
vector<Point>map[MAX];
int vis[MAX];
int vis2[MAX];
int point[MAX];

void work()
{
	for (int i = 1; i <= n; i++)
		vis[i] = 1;

	//计算并删去只有1条边经过的点的情况
	int ok;
	while (true)
	{
		int i;
		ok = 0;
		for (i = n + 1; i <= 2 * n; i++)
		{
			if (map[i].size() == 1)
			{
				ok = 1;
				int v = map[i][0].to;
				vis[v] = 0;
				sum = (sum * 1LL * map[i][0].val) % mod;
				map[i].clear();
				for (int j = 0; j < map[v].size(); j++)
				{
					if (map[v][j].to != i)
					{
						int u = map[v][j].to;
						for (int k = 0; k < map[u].size(); k++)
						{
							if (map[u][k].to == v)
							{
								map[u].erase(map[u].begin() + k);
								break;
							}
						}
						break;
					}
				}
				map[v].clear();
			}
		}
		if (ok == 0)
			break;
	}


	while (true)
	{
		queue<int>q;
		long long ans = 0, cnt;
		int w, i;

		for (i = 1; i <= n; i++)
		{
			if (vis[i] == 1)
			{
				w = i;
				vis[i] = 0;
				break;
			}
		}
		if (i == n + 1)
			break;

		//找环
		int num = 0;
		point[num++] = w;
		q.push(w);
		memset(vis2, 0, sizeof(vis2));
		while (!q.empty())
		{
			int now = q.front();
			q.pop();
			for (i = 0; i < map[now].size(); i++)
			{
				if (map[now][i].to <= n && vis[map[now][i].to]==1)
				{
					vis[map[now][i].to] = 0;
					point[num++] = map[now][i].to;
					q.push(map[now][i].to);
				}
				else if (map[now][i].to > n && vis2[map[now][i].to - n] == 0)
				{
					vis2[map[now][i].to - n] = 1;
					q.push(map[now][i].to);
				}
			}
		}

		//计算环值
		for (i = 0; i < map[point[0]].size(); i++)
		{
			cnt = 1;
			cnt = (cnt * 1LL * map[point[0]][i].val) % mod;
			int xx = map[point[0]][i].to;
			int aim = point[0];
			while (true)
			{
				int now, temp;
				for (int j = 0; j < map[xx].size(); j++)
				{
					if (map[xx][j].to != aim)
					{
						now = map[xx][j].to;
						break;
					}
				}
				if (now == point[0])
					break;
				for (int j = 0; j < map[now].size(); j++)
				{
					if (map[now][j].to != xx)
					{
						cnt = (cnt * 1LL * map[now][j].val) % mod;
						temp = map[now][j].to;
					}
				}
				aim = now;
				xx = temp;
			}
			ans = (ans + cnt) % mod;
		}

		sum = (sum*ans) % mod;
	}
}

int main()
{
	int T;
	scanf("%d", &T);
	while (T--)
	{
		scanf("%d", &n);
		for (int i = 0; i <= 2*n; i++)
			map[i].clear();
		int v1, w1, v2, w2;
		for (int i = 1; i <= n; i++)
		{
			scanf("%d%d%d%d", &v1, &w1, &v2, &w2);

			//边是无向边，右边的点设为n+i
			Point a;
			a.val = w1;
			a.to = v1 + n;
			map[i].push_back(a);
			a.to = i;
			map[v1 + n].push_back(a);

			a.val = w2;
			a.to = v2 + n;
			map[i].push_back(a);
			a.to = i;
			map[v2 + n].push_back(a);

		}
		sum = 1;
		work();
		printf("%lld\n", sum%mod);
	}
	return 0;
}