Sereja and Salesman

Problem Link: SEAKAM

Topic: Bitmask Dp

Explanation: GKCS

implementation:

	#include <bits/stdc++.h>
	using namespace std;
	#define INF 1<<30
	#define endl '\n'
	#define maxn 100005
	#define tc printf("Case %d: ", cs)
	#define tcn printf("Case %d:\n", cs);
	#define FASTIO ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
	typedef long long ll;
	const double PI = acos(-1.0);
	#define dbg1(x) cerr << #x << " = " << x << endl;
	#define dbg2(x, y) cerr << #x << " = " << x << ", " << #y << " = " << y << endl;
	#define dbg3(x, y, z) cerr << #x << " = " << x << ", " << #y << " = " << y << ", " << #z << " = " << z << endl;
	#define dbg4(w,x, y, z) cerr << #w << " = " << w << ", " <<#x << " = " << x << ", " << #y << " = " << y << ", " << #z << " = " << z << endl;
	template < typename F, typename S >
	ostream& operator << ( ostream& os, const pair< F, S > & p ) {
	return os << "(" << p.first << ", " << p.second << ")";
	}
	template < typename T >
	ostream &operator << ( ostream & os, const vector< T > &v ) {
	os << "{";
	for (auto it = v.begin(); it != v.end(); ++it) {
	if ( it != v.begin() ) os << ", ";
	os << *it;
	}
	return os << "}";
	}
	template < typename T >
	ostream &operator << ( ostream & os, const set< T > &v ) {
	os << "[";
	for (auto it = v.begin(); it != v.end(); ++it) {
	if ( it != v.begin()) os << ", ";
	os << *it;
	}
	return os << "]";
	}
	template < typename F, typename S >
	ostream &operator << ( ostream & os, const map< F, S > &v ) {
	os << "[";
	for (auto it = v.begin(); it != v.end(); ++it) {
	if ( it != v.begin() ) os << ", ";
	os << it -> first << " = " << it -> second ;
	}
	return os << "]";
	}
	#define dbg(args...) do {cerr << #args << " : "; faltu(args); } while(0)
	clock_t tStart = clock();
	#define timeStamp dbg("Execution Time: ", (double)(clock() - tStart)/CLOCKS_PER_SEC)
	void faltu () { cerr << endl; }
	template <typename T>
	void faltu( T a[], int n ) {
	for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
	cerr << endl;
	}
	template <typename T, typename ... hello>
	void faltu( T arg, const hello &... rest) { cerr << arg << ' '; faltu(rest...); }
	// Program showing a policy-based data structure.
	#include <ext/pb_ds/assoc_container.hpp> // Common file
	#include <ext/pb_ds/tree_policy.hpp>
	#include <functional> // for less
	#include <iostream>
	using namespace __gnu_pbds;
	using namespace std;
	// GNU link : https://goo.gl/WVDL6g
	typedef tree<int, null_type, less_equal<int>, rb_tree_tag,
	tree_order_statistics_node_update>
	new_data_set;
	/**___________________________________________________**/
	const ll N = 1e5 + 10;
	const ll mod = 1e9 + 7;
	ll n, m, t;
	map<pair<ll, ll> , ll> edge;
	vector<ll> faulty_nodes;
	ll mark_faulty[N], dp[1 << 15][15][15];
	ll fact[N], inv_fact[N];
	ll power(ll a, ll b) //a is base, b is exponent
	{
	if (b == 0)
	return 1;
	if (b == 1)
	return a;
	if (b % 2 == 1)
	return (power(a, b - 1) * a) % mod;
	ll q = power(a, b / 2);
	return (q * q) % mod;
	}
	void calc()
	{
	fact[0] = inv_fact[0] = 1;
	for (ll i = 1; i < N; i++) {
	fact[i] = (fact[i - 1] * i) % mod;
	inv_fact[i] = power(fact[i], mod - 2);
	//dbg(inv_fact[i]);
	}
	}
	ll nCr(ll n, ll r)
	{
	if (n < r) return 0;
	ll ret = fact[n];
	ret = (1ll * ret * inv_fact[r]) % mod;
	ret = (1ll * ret * inv_fact[n - r]) % mod;
	return ret;
	}
	int main()
	{
	FASTIO
	///*
	#ifndef ONLINE_JUDGE
	freopen("in.txt", "r", stdin);
	freopen("out.txt", "w", stdout);
	freopen("error.txt", "w", stderr);
	#endif
	//*/
	ll T;
	//scanf("%d", &T);
	T = 1;
	calc();
	cin >> T;
	for (ll cs = 1; cs <= T; cs++) {
	edge.clear();
	faulty_nodes.clear();
	memset(mark_faulty, 0, sizeof mark_faulty);
	memset(dp, 0, sizeof dp);
	cin >> n >> m;
	for (ll i = 1; i <= m; i++) {
	ll u, v;
	cin >> u >> v;
	if (!mark_faulty[u]) {
	faulty_nodes.push_back(u);
	mark_faulty[u] = 1;
	}
	if (!mark_faulty[v]) {
	faulty_nodes.push_back(v);
	mark_faulty[v] = 1;
	}
	edge[ {u, v}] = 1;
	edge[ {v, u}] = 1;
	}
	ll normal_nodes = n - (ll)faulty_nodes.size();
	ll ans = 0;
	for (ll i = 0; i < (ll)faulty_nodes.size(); i++)
	dp[1 << i][i][0] = 1;
	for (ll mask = 1; mask < (1 << (ll)faulty_nodes.size()); mask++) {
	for (ll first_node = 0; first_node < (ll) faulty_nodes.size(); first_node++) {
	for (ll number_tied = 0; number_tied < (ll) faulty_nodes.size(); ++number_tied) {
	if (dp[mask][first_node][number_tied] > 0) {
	for (ll nw_first = 0; nw_first < (ll)faulty_nodes.size(); nw_first++) {
	if ((mask & (1 << nw_first)) == 0) {
	ll new_mask = mask ^ (1 << nw_first);
	ll edge_exists = edge[ {faulty_nodes[nw_first], faulty_nodes[first_node]}];
	dp[new_mask][nw_first][number_tied + edge_exists] = (dp[new_mask][nw_first][number_tied + edge_exists] + dp[mask][first_node][number_tied]) % mod;
	}
	}
	}
	if (mask == (1 << (ll)faulty_nodes.size()) - 1) {
	ll val = dp[mask][first_node][number_tied];
	ll get = (1ll * val * nCr(n - number_tied, (int)faulty_nodes.size())) % mod;
	get = (1ll * get * fact[normal_nodes]) % mod;
	ans = (ans + get) % mod;
	}
	}
	}
	}
	if (m == 0) ans = fact[n];
	cout << ans << endl;
	}
	return 0;
	}

view raw SEAKAM.cpp hosted with ❤ by GitHub

Share: