text stringlengths 49 983k |
|---|
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=20,mod=1000000007;
int add(int a,int b,int p=mod){return a+b>=p?a+b-p:a+b;}
int sub(int a,int b,int p=mod){return a-b<0?a-b+p:a-b;}
int mul(int a,int b,int p=mod){return (LL)a*b%p;}
void sadd(int &a,int b,int p=mod){a=add(a,b,p);}
void ssub(int &a,int b,int p=mod){a=sub(a,b,p);}
void smul(int &a,int b,int p=mod){a=mul(a,b,p);}
int n,m;
struct side0{
int x,y;
}a[N*N+9];
int to[N+9];
void into(){
scanf("%d%d",&n,&m);
for (int i=0;i<m;++i){
scanf("%d%d",&a[i].x,&a[i].y);
--a[i].x;--a[i].y;
to[a[i].x]|=1<<a[i].y;
to[a[i].y]|=1<<a[i].x;
}
}
int inv[N*N+9],fac[N*N+9],ifac[N*N+9];
void Get_inv(){
inv[1]=1;
fac[0]=fac[1]=1;
ifac[0]=ifac[1]=1;
for (int i=2;i<=m;++i){
inv[i]=mul(mod-mod/i,inv[mod%i]);
fac[i]=mul(fac[i-1],i);
ifac[i]=mul(ifac[i-1],inv[i]);
}
}
int c[(1<<N)+9],ce[(1<<N)+9];
void Get_e(){
for (int s=0;s<1<<n;++s){
c[s]=c[s>>1]+(s&1);
for (int i=0;i<n;++i)
if (s>>i&1){
int t=to[i]&s;
ce[s]=ce[s^1<<i]+c[t];
break;
}
}
}
struct side{
int y,next;
}e[N*2+9];
int lin[N+9],cs;
void Ins(int x,int y){e[++cs].y=y;e[cs].next=lin[x];lin[x]=cs;}
void Ins2(int x,int y){Ins(x,y);Ins(y,x);}
int vis[N+9];
int Dfs_vis(int k){
int res=1<<k;
vis[k]=1;
for (int i=lin[k];i;i=e[i].next)
if (!vis[e[i].y]) res|=Dfs_vis(e[i].y);
return res;
}
int num[(1<<N)+9];
void Get_num(){
for (int s=0;s<1<<n-1;++s){
cs=0;
for (int i=0;i<n;++i) lin[i]=vis[i]=0;
for (int i=0;i<n-1;++i)
if (s>>i&1) Ins2(a[i].x,a[i].y);
for (int i=0;i<n;++i)
if (!vis[i]){
int t=Dfs_vis(i);
num[s]+=ce[t]-c[t]+1;
}
}
}
struct state{
int c,cnt,sum;
}dp[(1<<N)+9];
void Get_dp(){
dp[0].cnt=1;dp[0].sum=0;
for (int s=0;s<1<<n-1;++s)
for (int i=0;i<n-1;++i){
if (s>>i&1) continue;
int delta=num[(1<<n-1)-1^s]-num[(1<<n-1)-1^s^1<<i];
dp[s|1<<i].c=dp[s].c+delta+1;
int cnt=mul(dp[s].cnt,mul(fac[dp[s].c+delta],ifac[dp[s].c]));
int sum=mul(dp[s].sum,mul(fac[dp[s].c+delta+1],ifac[dp[s].c+1]));
sadd(dp[s|1<<i].cnt,cnt);
sadd(dp[s|1<<i].sum,add(sum,mul(cnt,c[s]+1)));
}
}
void work(){
Get_inv();
Get_e();
Get_num();
Get_dp();
}
void outo(){
printf("%d\n",dp[(1<<n-1)-1].sum);
}
int main(){
into();
work();
outo();
return 0;
} |
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
const long long INFLL = 1e18;
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vector<int> > vvi;
typedef vector<ll> vll;
typedef complex<double> cd;
#define forn(i, n) for (int (i) = 0; (i) != (n); (i)++)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define popcount(x) __builtin_popcount(x)
#define popcountll(x) __builtin_popcountll(x)
#define fi first
#define se second
#define re return
#define pb push_back
#define uniq(x) sort(all(x)); (x).resize(unique(all(x)) - (x).begin())
#ifdef LOCAL
#define dbg(x) cerr << __LINE__ << " " << #x << " " << x << endl
#define ln cerr << __LINE__ << endl
#else
#define dbg(x) void(0)
#define ln void(0)
#endif // LOCAL
int cx[4] = {-1, 0, 1, 0};
int cy[4] = {0, -1, 0, 1};
string Yes[2] = {"No\n", "Yes\n"};
string YES[2] = {"NO\n", "YES\n"};
string Possible[2] = {"Impossible\n", "Possible\n"};
string POSSIBLE[2] = {"IMPOSSIBLE\n", "POSSIBLE\n"};
int ok(int x, int n)
{
return 0 <= x && x < n;
}
ll log10(ll x)
{
if (x < 10) re 1;
re 1 + log10(x / 10);
}
ll ds(ll x)
{
if (x < 10) return x;
re x % 10 + ds(x / 10);
}
double sqr(double x)
{
return x * x;
}
bool inmask(int bit, int mask)
{
return (mask & (1 << bit)) > 0;
}
void Del(vector<int> &v, int pos)
{
swap(v[pos], v[v.size() - 1]);
v.pop_back();
}
long long g(vector<long long> &p, int pos)
{
if (ok(pos, p.size())) return p[pos];
if (pos < 0 || p.size() == 0) return 0;
return p.back();
}
int g(vector<int> &p, int pos)
{
if (ok(pos, p.size())) return p[pos];
if (pos < 0 || p.size() == 0) return 0;
return p.back();
}
ll inq(ll x, ll y)
{
if (!y) re 1 % MOD;
ll l = inq(x, y / 2);
if (y % 2) re l * l % MOD * x % MOD;
re l * l % MOD;
}
ll rev(ll x)
{
return inq(x, MOD - 2);
}
int __precomputed_combinatorics = 0;
vector<ll> __fact, __ufact, __rev;
inline void __precompute_combinatorics(int __n)
{
if (__precomputed_combinatorics >= __n)
return;
__fact.resize(__n);
__ufact.resize(__n);
__rev.resize(__n);
__rev[1] = 1;
for (int i = max(2, __precomputed_combinatorics); i < __n; i++)
__rev[i] = MOD - __rev[MOD % i] * (MOD / i) % MOD;
__fact[0] = 1, __ufact[0] = 1;
for (int i = max(1, __precomputed_combinatorics); i < __n; i++)
__fact[i] = __fact[i - 1] * i % MOD, __ufact[i] = __ufact[i - 1] * __rev[i] % MOD;
__precomputed_combinatorics = __n;
}
ll fact(int x)
{
if (__precomputed_combinatorics <= x)
__precompute_combinatorics(x + 1);
return __fact[x];
}
ll cnk(int n, int k)
{
if (k < 0 || k > n)
return 0;
if (__precomputed_combinatorics <= n)
__precompute_combinatorics(n + 1);
return __fact[n] * __ufact[n - k] % MOD * __ufact[k] % MOD;
}
ll inq(ll x, ll y, ll mod)
{
if (y == 0) return 1 % mod;
ll l = inq(x, y / 2, mod);
if (y % 2) return l * l % mod * x % mod;
return l * l % mod;
}
void dfs(int v, int par, vector<int> &h, vector<int> &edge_in, vector<int> &a, vector<int> &b)
{
if (v == par) h[v] = 0;
else h[v] = h[par] + 1;
for (int i = 0; i < h.size() - 1; i++)
{
if (a[i] == v || b[i] == v)
{
int u = a[i] + b[i] - v;
if (u != par)
{
edge_in[u] = i;
dfs(u, v, h, edge_in, a, b);
}
}
}
}
int mark(int v, int u, vector<int> &h, vector<int> &edge_in, vector<int> &a, vector<int> &b)
{
int mask = 0;
while (h[v] > h[u])
{
mask += 1 << edge_in[v];
int f = a[edge_in[v]] + b[edge_in[v]] - v;
v = f;
}
while (h[v] < h[u])
{
mask += 1 << edge_in[u];
int f = a[edge_in[u]] + b[edge_in[u]] - u;
u = f;
}
while (v != u)
{
mask += 1 << edge_in[v];
int f = a[edge_in[v]] + b[edge_in[v]] - v;
v = f;
mask += 1 << edge_in[u];
f = a[edge_in[u]] + b[edge_in[u]] - u;
u = f;
}
return mask;
}
ll supersigmacnt(ll i, ll k, ll n)
{
ll ans = 0;
for (int j = k; j <= n; j++)
{
ans = (ans + (n - j + i) * cnk(j, k)) % MOD;
}
return ans;
}
signed main()
{
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<int> a(m), b(m);
for (int i = 0; i < m; i++)
{
cin >> a[i] >> b[i];
a[i]--, b[i]--;
}
vector<int> h(n), edge_in(n);
dfs(0, 0, h, edge_in, a, b);
vector<int> suba(m);
for (int i = n - 1; i < m; i++)
{
int z = mark(a[i], b[i], h, edge_in, a, b);
suba[i] = z;
}
int M = 1 << (n - 1);
{
vector<ll> on_right(M, 0);
for (int mask = 1; mask < M; mask++)
{
for (int i = n - 1; i < m; i++)
{
if (suba[i] & mask)
{
on_right[mask]++;
}
}
on_right[mask] += __builtin_popcount(mask) - 1;
}
vector<ll> dp(M);
vector<ll> EV(M);
vector<ll> ans(M);
on_right[0] = -1;
dp[0] = 1;
for (int mask = 1; mask < M; mask++)
{
ll summ_right = 0, cnt_left = 0, cnt_right = 0;
for (int p = 0; p < n - 1; p++)
{
if (mask & (1 << p))
{
int pmask = mask - (1 << p);
if (pmask == 0)
{
dp[mask] = fact(on_right[mask]);
EV[mask] = 1;
ans[mask] = fact(on_right[mask]) * (m - on_right[mask]) % MOD;
continue;
}
int cnt = on_right[mask] - on_right[pmask] - 1;
for (int here = 0; here <= cnt; here++)
{
int there = cnt - here;
ll ways = fact(cnt) % MOD * cnk(on_right[mask] - here - 1, on_right[pmask]) % MOD;
ll dpways = ways * dp[pmask] % MOD;
cnt_right = (cnt_right + (on_right[pmask] + 1 + there) * dpways) % MOD;
//cnt_left = (cnt_left + (here + 1) * dpways) % MOD;
summ_right = (summ_right + (EV[pmask] + 1) * (on_right[pmask] + 1 + there) % MOD * dpways) % MOD;
ans[mask] = (ans[mask] + ans[pmask] * ways + (m - on_right[mask]) * dpways
- there * EV[pmask] % MOD * dpways) % MOD;
if (ans[mask] < 0) ans[mask] += MOD;
}
ll ways = cnk(on_right[mask], on_right[pmask] + 1) * fact(on_right[mask] - on_right[pmask] - 1) % MOD;
ll dpways = dp[pmask] * ways % MOD;
dp[mask] = (dp[mask] + dpways) % MOD;
ll Z = supersigmacnt(1, on_right[pmask], on_right[mask] - 1);
cnt_left = (cnt_left + Z * fact(cnt) % MOD * dp[pmask]) % MOD;
}
}
if (__builtin_popcount(mask) > 1)
{
//cout << mask << " " << summ_left << " " << summ_right << " " << cnt_left << " " << cnt_right << "\n";
EV[mask] = (cnt_left + summ_right) * inq(cnt_left + cnt_right, MOD - 2) % MOD;
}
//cout << mask << " " << dp[mask] << " " << EV[mask] << " " << ans[mask] << "\n";
}
//cout << dp[M - 1] << "\n";
cout << ans[M - 1] << "\n";
}
}
/* Note:
Check constants at the beginning of the code (MOD, INF, INFLL)
Check corner cases.
N = 1
No def int long long for now.
Add something here.
*/
|
#include<bits/stdc++.h>
#define For(i,x,y) for (register int i=(x);i<=(y);i++)
#define FOR(i,x,y) for (register int i=(x);i<(y);i++)
#define Dow(i,x,y) for (register int i=(x);i>=(y);i--)
#define Debug(v) for (auto i:v) printf("%lld ",i);puts("")
#define mp make_pair
#define fi first
#define se second
#define pb push_back
#define ep emplace_back
#define siz(x) ((int)(x).size())
#define all(x) (x).begin(),(x).end()
#define fil(a,b) memset((a),(b),sizeof(a))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pa;
typedef pair<ll,ll> PA;
typedef vector<int> poly;
inline ll read(){
ll x=0,f=1;char c=getchar();
while ((c<'0'||c>'9')&&(c!='-')) c=getchar();
if (c=='-') f=-1,c=getchar();
while (c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
return x*f;
}
const int N = 20, maxn = 1<<20|3, mod = 1e9+7;
int n,m,cnt[maxn],b[maxn],s[maxn],c[maxn];
pa e[N*N];
struct _{
int fa[N];
inline void init(int n){
FOR(i,0,n) fa[i]=i;
}
inline int Find(int x){
return fa[x]==x?x:fa[x]=Find(fa[x]);
}
inline void Merge(int x,int y){
fa[Find(x)]=Find(y);
}
}f;
const int M = 200;
int fac[M+10],ifac[M+10];
inline int power(int a,int b){
int ret=1;
for (;b;b>>=1,a=1ll*a*a%mod) if (b&1) ret=1ll*ret*a%mod;
return ret;
}
inline void init(int n){
fac[0]=1;
For(i,1,n) fac[i]=1ll*fac[i-1]*i%mod;
ifac[n]=power(fac[n],mod-2);
Dow(i,n-1,0) ifac[i]=1ll*ifac[i+1]*(i+1)%mod;
}
inline int calc(int l,int r){
return 1ll*fac[r]*ifac[l-1]%mod;
}
int main(){
n=read(),m=read();
FOR(i,0,m) e[i].fi=read()-1,e[i].se=read()-1;
FOR(i,0,1<<(n-1)){
f.init(n);
FOR(j,0,n-1) if (i&(1<<j)) f.Merge(e[j].fi,e[j].se);
b[i]=n-1-__builtin_popcount(i);
cnt[i]=m-__builtin_popcount(i);
FOR(j,n-1,m) if (f.Find(e[j].fi)==f.Find(e[j].se)) --cnt[i];
}
init(M);
c[(1<<(n-1))-1]=1;
Dow(i,(1<<(n-1))-2,0){
FOR(j,0,n-1) if (!(i&(1<<j))){
int k=i^(1<<j);
c[i]=(c[i]+1ll*c[k]*calc(cnt[k]+1,cnt[i]-1))%mod;
s[i]=(s[i]+1ll*s[k]*calc(cnt[k]+2,cnt[i]))%mod;
}
s[i]=(s[i]+1ll*c[i]*b[i])%mod;
}
printf("%d\n",s[0]);
} |
//第8回シンデレラガール総選挙は是非本田未央ちゃんに投票をお願いします！
//ファンのことも他のアイドルの子たちのことも本当に大事にしてて、今まで周りに色んなものを与えてくれました。
//今度は私たちが未央ちゃんにお返しをする番です。みんなでガラスの靴を履かせてあげましょう！
// #本田未央を一番星に #本田未央を令和のシンデレラガールに #第8回シンデレラガール総選挙
#include<vector>
#include<cmath>
#include<map>
#include<cstdlib>
#include<iostream>
#include<sstream>
#include<fstream>
#include<string>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<set>
#include<stack>
#include<bitset>
#include<functional>
#include<ctime>
#include<queue>
#include<deque>
#include<complex>
#include<cassert>
using namespace std;
#define pb push_back
#define pf push_front
typedef long long lint;
typedef complex<double> P;
#define mp make_pair
#define fi first
#define se second
typedef pair<int,int> pint;
#define All(s) s.begin(),s.end()
#define rAll(s) s.rbegin(),s.rend()
#define REP(i,a,b) for(int i=a;i<b;i++)
#define rep(i,n) REP(i,0,n)
//問題文および制約はちゃんと確認しよう！
//サイズは10^5じゃなくて2×10^5とかかもしれないし、重要な制約・条件を見落としているかも
//とりあえずサンプルを読んでから解法を考えよう？
vector<pint> gr[25];
int a[200],b[200];
int n,m;
lint dc[(1<<20)+10],ds[(1<<20)+10];
int num[(1<<20)+10];
lint p[210][210];
void dfs(int v,int u,int g,int ma){
//cout<<v<<u<<g<<ma<<endl;
if(v==g){
//cout<<v<<' '<<g<<' '<<ma<<endl;
num[ma]++;return;
}
rep(i,gr[v].size()){
pint w=gr[v][i];
if(w.fi==u) continue;
dfs(w.fi,v,g,ma+(1<<w.se));
}
}
int main()
{
cin>>n>>m;
rep(i,m){
cin>>a[i]>>b[i];
if(i<n-1){
gr[a[i]].pb(mp(b[i],i));
gr[b[i]].pb(mp(a[i],i));
}
}
REP(i,n-1,m){
dfs(a[i],0,b[i],0);
}
n--;
//num[0]++;
//rep(i,(1<<n)) cout<<i<<' '<<num[i]<<endl;
rep (i, n) rep (b, 1 << n) if (0 < (b & (1 << i))) num[b] += num[b - (1 << i)];
//rep(i,(1<<n)) cout<<i<<' '<<num[i]<<endl;
lint mo=1000000007;
rep(i,205) rep(j,205) p[i][j]=1;
rep(i,205) REP(j,i,205){
REP(k,i,j+1) p[i][j]=(p[i][j]*k)%mo;
}
memset(dc,0,sizeof(dc));
memset(ds,0,sizeof(ds));dc[(1<<n)-1]=1;
for(int i=(1<<n)-1;i>=0;i--){
int b=n-__builtin_popcount(i);
int N=m-(num[i]+__builtin_popcount(i));
//cout<<i<<' '<<dc[i]<<' '<<ds[i]<<' '<<b<<' '<<N<<endl;
rep(j,n){
if(!(i&(1<<j))) continue;
int d=num[i]-num[i-(1<<j)];
lint c=(dc[i]*p[N+1][N+d])%mo;
lint s=(ds[i]*p[N+2][N+d+1])%mo;
dc[i-(1<<j)]+=c;dc[i-(1<<j)]%=mo;
ds[i-(1<<j)]+=s+c*(b+1);ds[i-(1<<j)]%=mo;
}
}
cout<<ds[0]%mo<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1000000007;
int power(int a, int x) {
int ans = 1;
for (; x; x >>= 1, a = 1ll * a * a % P)
if (x & 1) ans = 1ll * ans * a % P;
return ans;
}
int n, m, fa[20], dep[20], a[190], b[190], se[190], fac[191], ifac[191], sos[19][1 << 19];
vector<int> g[20];
struct info {
int l, l0, cnt, sum;
} dp[1 << 19];
void insert_0(info &a) {
++a.l, ++a.l0;
a.sum = (a.sum + 1ll * a.l0 * a.cnt) % P;
}
void insert_1(info &a, int k) {
a.cnt = 1ll * a.cnt * fac[a.l + k] % P * ifac[a.l] % P;
a.sum = 1ll * a.sum * fac[a.l + k + 1] % P * ifac[a.l + 1] % P;
a.l += k;
}
void merge(info &a, const info &b) {
a.l = b.l;
a.l0 = b.l0;
a.cnt = (a.cnt + b.cnt) % P;
a.sum = (a.sum + b.sum) % P;
}
void dfs(int u) {
for (int e : g[u])
if (e != fa[u]) {
int v = a[e] + b[e] - u;
fa[v] = e;
dep[v] = dep[u] + 1;
dfs(v);
}
}
int get(int u, int v) {
int s = 0;
while (u != v) {
if (dep[u] < dep[v])
swap(u, v);
s |= 1 << fa[u];
int p = a[fa[u]] + b[fa[u]] - u;
u = p;
}
return s;
}
void foo(int *f) {
for (int d = 1; d < 1 << n - 1; d <<= 1)
for (int i = 0; i < 1 << n - 1; i += d << 1)
for (int j = 0; j < d; ++j)
f[i + d + j] += f[i + j];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%d%d", a + i, b + i), --a[i], --b[i];
if (i < n - 1)
g[a[i]].push_back(i), g[b[i]].push_back(i);
}
fac[0] = 1;
for (int i = 1; i <= m; ++i)
fac[i] = 1ll * fac[i - 1] * i % P;
ifac[m] = power(fac[m], P - 2);
for (int i = m; i; --i)
ifac[i - 1] = 1ll * ifac[i] * i % P;
fa[0] = -1;
dfs(0);
for (int i = n - 1; i < m; ++i) {
int s = get(a[i], b[i]);
for (int j = 0; j < n - 1; ++j)
if (s >> j & 1)
++sos[j][s];
}
for (int x = 0; x < n - 1; ++x)
foo(sos[x]);
dp[0] = (info){0, 0, 1, 0};
for (int s = 0; s < 1 << n - 1; ++s)
for (int e = 0; e < n - 1; ++e)
if (!(s >> e & 1)) {
auto z = dp[s];
insert_1(z, sos[e][(1 << n - 1) - 1 - s]);
insert_0(z);
merge(dp[s | 1 << e], z);
}
printf("%d\n", dp[(1 << n - 1) - 1].sum);
return 0;
} |
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <cstring>
#include <queue>
#include <set>
#include <map>
#include <stack>
#include <functional>
#define SIZE 25
#define BT 1<<20
#define MOD 1000000007
#define MX 205
using namespace std;
typedef long long int ll;
typedef pair <int,int> P;
ll dp[BT],way[BT];
ll fac[MX][MX];
ll C[MX][MX];
vector <P> vec[SIZE];
int cnt[BT],cnt2[BT];
int memo[SIZE][BT];
void make()
{
for(int i=0;i<MX;i++)
{
C[i][0]=C[i][i]=1;
for(int j=1;j<i;j++)
{
C[i][j]=(C[i-1][j-1]+C[i-1][j])%MOD;
}
}
for(int i=1;i<MX;i++)
{
fac[i][i-1]=1;
for(int j=i;j<MX;j++) fac[i][j]=fac[i][j-1]*(ll) j%MOD;
}
}
int dfs(int v,int p,int goal)
{
if(v==goal) return 0;
for(int i=0;i<vec[v].size();i++)
{
int to=vec[v][i].first;
if(to!=p)
{
int ret=dfs(to,v,goal);
if(ret!=-1) return ret|(1<<vec[v][i].second);
}
}
return -1;
}
int main()
{
make();
int n,m;
scanf("%d %d",&n,&m);
for(int i=0;i<n-1;i++)
{
int a,b;
scanf("%d %d",&a,&b);a--,b--;
vec[a].push_back(P(b,i));
vec[b].push_back(P(a,i));
}
for(int i=n-1;i<m;i++)
{
int a,b;
scanf("%d %d",&a,&b);a--,b--;
int S=dfs(a,-1,b);
cnt[S]++;
}
int sz=n-1;
for(int i=0;i<sz;i++)
{
for(int S=0;S<1<<sz;S++) memo[i][S]=cnt[S];
for(int j=0;j<sz;j++)
{
if(j==i) continue;
for(int S=0;S<1<<sz;S++) if(S>>j&1) memo[i][S]+=memo[i][S-(1<<j)];
}
}
memset(dp,0,sizeof(dp));
memset(way,0,sizeof(way));
way[(1<<sz)-1]=1;
for(int S=(1<<sz)-1;S>=0;S--)
{
int nm=0;
for(int i=0;i<sz;i++) if(!(S>>i&1)) nm++;
for(int i=0;i<sz;i++)
{
if(S>>i&1)
{
//printf("%d %d : %d\n",i,S,memo[i][S]);
ll w=way[S],d=dp[S],c=cnt2[S];
w=w*fac[c+1][c+memo[i][S]]%MOD;
d=d*fac[c+2][c+memo[i][S]+1]%MOD;/*
for(int j=0;j<memo[i][S];j++)
{
ll c2=c+1;
ll w2=w*(c+1)%MOD;
ll d2=d*(c+2)%MOD;
c=c2,w=w2,d=d2%MOD;
}*/
int T=S-(1<<i);
cnt2[T]=cnt2[S]+memo[i][S]+1;
dp[T]+=(d+w*(ll) (nm+1))%MOD;
if(dp[T]>=MOD) dp[T]-=MOD;
way[T]+=w;
if(way[T]>=MOD) way[T]-=MOD;
}
}
//printf("%d : %lld %lld\n",S,way[S],dp[S]);
}
printf("%lld\n",dp[0]);
return 0;
}
|
#include<iomanip>
#include<limits>
#include<thread>
#include<utility>
#include<iostream>
#include<string>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<stack>
#include<queue>
#include<cmath>
#include<numeric>
#include<cassert>
#include<random>
#include<chrono>
#include<unordered_set>
#include<unordered_map>
#include<fstream>
#include<list>
#include<functional>
#include<bitset>
#include<complex>
#include<tuple>
using namespace std;
typedef unsigned long long int ull;
typedef long long int ll;
typedef pair<ll,ll> pll;
typedef long double D;
#define F first
#define S second
const ll E=1e18+7;
const ll MOD=1000000007;
class LCA{
private:
typedef pair<ll,vector<ll>> node; //depth,parents
ll root;
ll v;
vector<node> tree;
vector<vector<ll>> E;
ll High; //高さのlog
void bfs(){
tree[root]={0,{root}};
queue<ll> q;
q.push(root);
vector<bool> done(v,false);
while(!q.empty()){
ll where=q.front();
q.pop();
if(done[where]){continue;}
done[where]=true;
for(int i=0;i<E[where].size();i++){
if(!done[E[where][i]]){
tree[E[where][i]].F=tree[where].F+1;
tree[E[where][i]].S={where};
q.push(E[where][i]);
}
}
}
}
public:
LCA(ll v,ll root):v(v),root(root){
tree.resize(v);
E.resize(v);
}
//双方向のエッジでもよい
void add_edge(ll from,ll to){
E[from].push_back(to);
}
//searchの前に行う
void mk_tree(){
bfs();
bool j=true;
for(int i=0;j;i++){
j=false;
for(int t=0;t<v;t++){
ll P=tree[t].S[i];
P=tree[P].S[i];
tree[t].S.push_back(P);
if(P!=root){j=true;}
}
}
High=tree[root].S.size();
}
ll search_parent(ll a,ll h){
if(tree[a].F<=h){return root;}
for(ll i=High-1;i>=0;i--){
if((1<<i)&h){a=tree[a].S[i];}
}
return a;
}
ll search_lca(ll a,ll b){
ll dif=tree[a].F-tree[b].F;
if(0>dif){swap(a,b); dif=abs(dif);}
a=search_parent(a,dif);
for(ll i=High-1;i>=0;i--){
if(tree[a].S[i]!=tree[b].S[i]){
a=tree[a].S[i];
b=tree[b].S[i];
}
}
while(a!=b){
a=tree[a].S[0];
b=tree[b].S[0];
}
return a;
}
ll high(ll a){
return tree[a].F;
}
};
const ll mod=MOD;
ll mod_pow(ll a,ll x){
a%=mod;
ll ans=1;
while(x>0){
if(x&1){ans*=a; ans%=mod;}
a*=a;
a%=mod;
x>>=1;
}
return ans;
}
pll Ex_gcd(ll a,ll b){
if(b==0){return {1,0};}
pll ret=Ex_gcd(b,a%b);
ret.F-=a/b*ret.S;
return {ret.S,ret.F};
}
ll prime_R(ll a){
return mod_pow(a,mod-2);
}
ll R(ll a){
ll ret=Ex_gcd(a,mod).F;
ret%=mod;
if(ret<0){ret+=mod;}
return ret;
}
int main(){
ll n,m;
cin>>n>>m;
LCA lca(n,n-1);
vector<ll> Fat(m-n+1,0);
for(int i=1;i<n;i++){
ll u,v;
cin>>u>>v;
u--; v--;
lca.add_edge(u,v);
lca.add_edge(v,u);
}
lca.mk_tree();
for(ll i=n;i<=m;i++){
ll u,v;
cin>>u>>v;
u--; v--;
ll m=lca.search_lca(u,v);
while(u!=m){Fat[i-n]|=1LL<<u; u=lca.search_parent(u,1);}
while(v!=m){Fat[i-n]|=1LL<<v; v=lca.search_parent(v,1);}
}
vector<ll> cnt(1LL<<(n-1),0);
vector<ll> bitcnt(1LL<<(n-1),0);
for(ll i=0;i<(1LL<<(n-1));i++){
for(int j=0;j<n-1;j++){
if(i>>j&1){bitcnt[i]++;}
}
for(auto &I:Fat){
if((I&i)==I){cnt[i]++;}
}
}
vector<pll> dp(1LL<<(n-1),{0,0});
vector<ll> F(m+11,1);
for(ll i=1;i<=m+10;i++){F[i]=F[i-1]*i%MOD;}
vector<ll> RF(m+11,1);
for(ll i=1;i<=m+10;i++){RF[i]=RF[i-1]*R(i)%MOD;}
dp.back()={1,0};
for(ll i=(1LL<<(n-1))-1;i>=0;i--){
for(int j=0;j<n-1;j++){
if(i>>j&1){continue;}
ll N=i|(1LL<<j);
dp[i].F+=dp[N].F*F[m-bitcnt[N]-cnt[i]]%MOD*RF[m-bitcnt[N]-cnt[N]]%MOD;
dp[i].F%=MOD;
dp[i].S+=dp[N].S*F[m-bitcnt[i]-cnt[i]]%MOD*RF[m-bitcnt[i]-cnt[N]]%MOD;
dp[i].S+=(n-bitcnt[N])*dp[N].F%MOD*F[m-bitcnt[N]-cnt[i]]%MOD*RF[m-bitcnt[N]-cnt[N]]%MOD;
dp[i].S%=MOD;
}
}
ll ans=dp[0].S;
ans%=MOD;
if(ans<0){ans+=MOD;}
cout<<ans<<endl;
return 0;
}
|
#include<bits/stdc++.h>
#define ll long long
#define mo 1000000007
#define N 22
using namespace std;
template <typename T> void read(T &x){
x=0;char c=getchar();int fh=1;
while (!isdigit(c)){if (c=='-')fh=-1;c=getchar();}
while (isdigit(c))x=x*10+c-'0',c=getchar();
x*=fh;
}
struct Info{ll an,ki;}dp[1000010];
ll jie[N*N],nj[N*N];
int m,n,x,y,p,no[N],f[N],d[N],g[1000010];
vector<pair<int,int> > a[N];
void dfs(int x,int fa,int dep){
f[x]=fa;d[x]=dep;
for (unsigned i=0;i<a[x].size();i++){
if (a[x][i].first!=fa){
no[a[x][i].first]=a[x][i].second;
dfs(a[x][i].first,x,dep+1);
}
}
}
int co(int x){int an=0;while (x){an+=x&1;x/=2;}return an;}
ll po(ll x,ll y){ll z=1;while (y){if (y%2)z=x*z%mo;x=x*x%mo;y/=2;}return z;}
int main(){
read(n);read(m);p=n-1;
jie[0]=1;for (int i=1;i<=m;i++)jie[i]=jie[i-1]*i%mo;
nj[m]=po(jie[m],mo-2);for (int i=m-1;i>=0;i--)nj[i]=nj[i+1]*(i+1)%mo;
for (int i=1;i<n;i++){
read(x);read(y);
a[x].push_back(make_pair(y,1<<(i-1)));
a[y].push_back(make_pair(x,1<<(i-1)));
}
dfs(1,0,1);
for (int i=n;i<=m;i++){
read(x);read(y);
int an=0;
while (x!=y){
if (d[x]<d[y]) swap(x,y);
an+=no[x];
x=f[x];
}
g[an]++;
}
for (int i=0;i<p;i++)
for (int j=0;j<(1<<p);j++)
if (j&(1<<i))g[j]+=g[j-(1<<i)];
dp[0].ki=1;dp[0].an=0;
for (int i=0;i<(1<<p);i++){
int cs=co(i);
int no=(g[(1<<p)-1]-g[(1<<p)-1-i])+cs;
for (int j=0;j<p;j++){
if ((i&(1<<j))==0){
int nu=g[(1<<p)-i-1]-g[(1<<p)-1-i-(1<<j)];
dp[i+(1<<j)].ki=(dp[i+(1<<j)].ki+(dp[i].ki*jie[no+nu]%mo)*nj[no])%mo;
dp[i+(1<<j)].an=(dp[i+(1<<j)].an+(dp[i].an*jie[no+nu+1]%mo)*nj[no+1]+((dp[i].ki*(cs+1)%mo)*jie[no+nu]%mo)*nj[no])%mo;
}
}
}
cout<<dp[(1<<p)-1].an<<endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
template<class T> using V = vector<T>;
template<class T> using VV = V<V<T>>;
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fi first
#define se second
#define rep(i,n) rep2(i,0,n)
#define rep2(i,m,n) for(int i=m;i<(n);i++)
#define ALL(c) (c).begin(),(c).end()
#ifdef LOCAL
#define dump(x) cerr << __LINE__ << " " << #x << " = " << (x) << endl
#else
#define dump(x) true
#endif
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n-1); }
template<class T, class U> void chmin(T& t, const U& u) { if (t > u) t = u; }
template<class T, class U> void chmax(T& t, const U& u) { if (t < u) t = u; }
template<class T, class U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
os<<"("<<p.first<<","<<p.second<<")";
return os;
}
template<class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os<<"{";
rep(i, v.size()) {
if (i) os<<",";
os<<v[i];
}
os<<"}";
return os;
}
template <unsigned int MOD>
struct ModInt {
using uint = unsigned int;
using ull = unsigned long long;
using M = ModInt;
uint v;
ModInt(ll _v = 0) { set_norm(_v % MOD + MOD); }
M& set_norm(uint _v) { //[0, MOD * 2)->[0, MOD)
v = (_v < MOD) ? _v : _v - MOD;
return *this;
}
explicit operator bool() const { return v != 0; }
M operator+(const M& a) const { return M().set_norm(v + a.v); }
M operator-(const M& a) const { return M().set_norm(v + MOD - a.v); }
M operator*(const M& a) const { return M().set_norm(ull(v) * a.v % MOD); }
M operator/(const M& a) const { return *this * a.inv(); }
M& operator+=(const M& a) { return *this = *this + a; }
M& operator-=(const M& a) { return *this = *this - a; }
M& operator*=(const M& a) { return *this = *this * a; }
M& operator/=(const M& a) { return *this = *this / a; }
M operator-() const { return M() - *this; }
M& operator++(int) { return *this = *this + 1; }
M& operator--(int) { return *this = *this - 1; }
M pow(ll n) const {
if (n < 0) return inv().pow(-n);
M x = *this, res = 1;
while (n) {
if (n & 1) res *= x;
x *= x;
n >>= 1;
}
return res;
}
M inv() const {
ll a = v, b = MOD, p = 1, q = 0, t;
while (b != 0) {
t = a / b;
swap(a -= t * b, b);
swap(p -= t * q, q);
}
return M(p);
}
bool operator==(const M& a) const { return v == a.v; }
bool operator!=(const M& a) const { return v != a.v; }
friend ostream& operator<<(ostream& os, const M& a) { return os << a.v; }
};
using Mint = ModInt<1000000007>;
const int maxv = 1000010;
Mint fact[maxv], finv[maxv], inv[maxv];
void init() {
fact[0] = 1;
for (int i = 1; i < maxv; ++i) {
fact[i] = fact[i-1] * i;
}
finv[maxv-1] = fact[maxv-1].inv();
for (int i = maxv - 2; i >= 0; --i) {
finv[i] = finv[i+1] * (i+1);
}
for (int i = 1; i < maxv; ++i) {
inv[i] = finv[i] * fact[i-1];
}
}
Mint comb(int n, int r) {
if (n < 0 || r < 0 || r > n) return Mint(0);
return fact[n] * finv[r] * finv[n-r];
}
const int maxn = 20;
V<pii> g[maxn];
int sub[maxn];
void dfs(int v, int p, int cur) {
sub[v] = cur;
for (auto e : g[v]) if (e.fi != p) {
dfs(e.fi, v, cur | (1 << e.se));
}
}
int main() {
int N, M; cin >> N >> M;
V<pii> es;
rep(i, M) {
int a, b; cin >> a >> b; --a; --b;
if (i < N-1) {
g[a].eb(b, i);
g[b].eb(a, i);
}
es.eb(a, b);
}
V<int> cnt(1 << (N-1));
for (int i = N-1; i < M; ++i) {
dfs(es[i].fi, -1, 0);
++cnt[sub[es[i].se]];
}
int ne = N-1;
rep(i, ne) {
rep(j, 1 << ne) if ((j >> i) & 1) {
cnt[j] += cnt[j ^ (1 << i)];
}
}
init();
dump(cnt);
V<Mint> way(1 << ne), sum(1 << ne);
//add tree edges from the larger cost
way[0] = 1;
rep(i, 1 << ne) {
rep(j, ne) if ((i >> j) & 1) {
//left
int use = (1 << ne) - 1 - i;
int num = __builtin_popcount(i) - 1;
int all = M - (N-1) - cnt[use | (1 << j)] + num;
int inc = cnt[use | (1 << j)] - cnt[use];
//(i ^ (1 << j)) -> i
//add inc others and 1 tree edge
Mint curway = way[i ^ (1 << j)] * fact[all + inc] * finv[all];
Mint cursum = sum[i ^ (1 << j)] * fact[all + inc + 1] * finv[all + 1];
cursum += curway * (num + 1);
way[i] += curway;
sum[i] += cursum;
}
}
dump(way);
dump(sum);
cout << sum.back() << endl;
return 0;
} |
const long long MOD = 1e9 + 7;
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll inq(ll x, ll y)
{
if (!y) return 1 % MOD;
ll l = inq(x, y / 2);
if (y % 2) return l * l % MOD * x % MOD;
return l * l % MOD;
}
void dfs(int v, int par, vector<int> &h, vector<int> &edge_in, vector<int> &a, vector<int> &b)
{
if (v == par) h[v] = 0;
else h[v] = h[par] + 1;
for (int i = 0; i < h.size() - 1; i++)
{
if (a[i] == v || b[i] == v)
{
int u = a[i] + b[i] - v;
if (u != par)
{
edge_in[u] = i;
dfs(u, v, h, edge_in, a, b);
}
}
}
}
int mark(int v, int u, vector<int> &h, vector<int> &edge_in, vector<int> &a, vector<int> &b)
{
int mask = 0;
while (h[v] > h[u])
{
mask += 1 << edge_in[v];
int f = a[edge_in[v]] + b[edge_in[v]] - v;
v = f;
}
while (h[v] < h[u])
{
mask += 1 << edge_in[u];
int f = a[edge_in[u]] + b[edge_in[u]] - u;
u = f;
}
while (v != u)
{
mask += 1 << edge_in[v];
int f = a[edge_in[v]] + b[edge_in[v]] - v;
v = f;
mask += 1 << edge_in[u];
f = a[edge_in[u]] + b[edge_in[u]] - u;
u = f;
}
return mask;
}
const int N = 206;
ll Supersigmacnk[N][N];
ll Supersigmacnkdec[N][N];
ll Supersigmacnkinc[N][N];
ll cnk[N][N];
ll fact[N];
ll rev[N];
ll supersigmacnkdec(ll i, ll k, ll n)
{
ll ans = Supersigmacnk[k][n] * (i + MOD - 1) % MOD;
ans = (ans + Supersigmacnkdec[k][n]) % MOD;
return ans;
}
ll supersigmacnkinc(ll i, ll k, ll n)
{
ll ans = Supersigmacnk[k][n] * i % MOD;
ans = (ans + Supersigmacnkinc[k][n]) % MOD;
return ans;
}
signed main()
{
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
fact[0] = 1;
rev[1] = 1;
for (int i = 1; i < N; i++) fact[i] = (fact[i - 1] * i) % MOD;
for (int i = 2; i < N; i++) rev[i] = MOD - (MOD / i) * rev[MOD % i] % MOD;
for (int i = 0; i < N; i++)
{
cnk[i][0] = cnk[i][i] = 1;
for (int j = 1; j < i; j++)
{
cnk[i][j] = (cnk[i - 1][j - 1] + cnk[i - 1][j]) % MOD;
}
}
for (int k = 0; k < N; k++)
{
for (int n = k; n < N; n++)
{
Supersigmacnk[k][n] = ((n != k ? Supersigmacnk[k][n - 1] : 0) + cnk[n][k]) % MOD;
Supersigmacnkdec[k][n] = ((n != k ? Supersigmacnkdec[k][n - 1] : 0) + Supersigmacnk[k][n]) % MOD;
Supersigmacnkinc[k][n] = ((n != k ? Supersigmacnkinc[k][n - 1] : 0) + (n - k) * cnk[n][k]) % MOD;
}
}
int n, m;
cin >> n >> m;
vector<int> a(m), b(m);
for (int i = 0; i < m; i++)
{
cin >> a[i] >> b[i];
a[i]--, b[i]--;
}
vector<int> h(n), edge_in(n);
dfs(0, 0, h, edge_in, a, b);
vector<int> suba(m);
for (int i = n - 1; i < m; i++)
{
int z = mark(a[i], b[i], h, edge_in, a, b);
suba[i] = z;
}
int M = 1 << (n - 1);
{
vector<ll> on_right(M, 0);
for (int mask = 1; mask < M; mask++)
{
for (int i = n - 1; i < m; i++)
{
if (suba[i] & mask)
{
on_right[mask]++;
}
}
on_right[mask] += __builtin_popcount(mask) - 1;
}
vector<ll> dp(M);
vector<ll> EV(M);
vector<ll> ans(M);
on_right[0] = -1;
dp[0] = 1;
for (int mask = 1; mask < M; mask++)
{
ll summ_right = 0, cnt_left = 0, cnt_right = 0;
for (int p = 0; p < n - 1; p++)
{
if (mask & (1 << p))
{
int pmask = mask - (1 << p);
if (pmask == 0)
{
dp[mask] = fact[on_right[mask]];
EV[mask] = fact[on_right[mask]];
ans[mask] = fact[on_right[mask]] * (m - on_right[mask]) % MOD;
continue;
}
int cnt = on_right[mask] - on_right[pmask] - 1;
ll ways = cnk[on_right[mask]][on_right[pmask] + 1] * fact[on_right[mask] - on_right[pmask] - 1] % MOD;
ll dpways = dp[pmask] * ways % MOD;
dp[mask] = (dp[mask] + dpways) % MOD;
ll W = fact[cnt] * dp[pmask] % MOD;
ll SS1 = supersigmacnkdec(1, on_right[pmask], on_right[mask] - 1);
cnt_left = (cnt_left + SS1 * W) % MOD;
ll SS2 = supersigmacnkinc(on_right[pmask] + 1, on_right[pmask], on_right[mask] - 1);
cnt_right = (cnt_right + SS2 * W) % MOD;
summ_right = (summ_right + SS2 * fact[cnt] % MOD * (EV[pmask] + dp[pmask])) % MOD;
ll SS3 = Supersigmacnk[on_right[pmask]][on_right[mask] - 1];
ll SS4 = supersigmacnkinc(0, on_right[pmask], on_right[mask] - 1);
ans[mask] = (ans[mask] + ans[pmask] * fact[cnt] % MOD * SS3
+ (m - on_right[mask]) * W % MOD * SS3
- EV[pmask] * fact[cnt] % MOD * SS4
) % MOD;
if (ans[mask] < 0) ans[mask] += MOD;
}
}
if (__builtin_popcount(mask) > 1)
{
//cout << mask << " " << summ_right << " " << cnt_left << " " << cnt_right << "\n";
EV[mask] = (cnt_left + summ_right) * rev[on_right[mask] + 1] % MOD;
}
//cout << mask << " " << dp[mask] << " " << EV[mask] << " " << ans[mask] << "\n";
}
//cout << dp[M - 1] << "\n";
cout << ans[M - 1] << "\n";
}
}
/* Note:
Check constants at the beginning of the code (MOD, INF, INFLL)
Check corner cases.
N = 1
No def int long long for now.
Add something here.
*/
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 20, mod = 1000000007;
const int max_e = 199;
const int max_mask = (1 << 19) + 5;
int c[max_e][max_e], pr[max_e][max_e];
int n, m, can_add[max_mask], parent[max_n];
int dp[max_mask];
int cnt[max_mask];
int from[max_e], to[max_e];
vector<int> g[max_n];
int mul(int x, int y) {
return 1LL * x * y % mod;
}
void get_all_c() {
for (int i = 1; i < max_e; ++i) {
pr[i][i - 1] = 1;
for (int j = i; j < max_e; ++j) {
pr[i][j] = mul(pr[i][j - 1], j);
}
}
for (int i = 0; i < max_e; ++i) {
c[i][0] = 1;
for (int j = 1; j <= i; ++j) {
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
}
}
}
bool get_bit(int mask, int pos) {
return (bool) (mask & (1 << pos));
}
int find_set(int v) {
if (v == parent[v]) {
return v;
}
return parent[v] = find_set(parent[v]);
}
void union_set(int v1, int v2) {
v1 = find_set(v1);
v2 = find_set(v2);
parent[v1] = v2;
}
int main() {
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
get_all_c();
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> from[i] >> to[i];
--from[i];
--to[i];
}
int e = n - 1;
for (int mask = 0; mask < (1 << e); ++mask) {
for (int i = 0; i < n; ++i) {
parent[i] = i;
}
for (int j = 0; j < e; ++j) {
if (get_bit(mask, j)) {
union_set(from[j], to[j]);
}
}
for (int j = e; j < m; ++j) {
if (find_set(from[j]) == find_set(to[j])) {
++can_add[mask];
}
}
}
dp[(1 << e) - 1] = 0;
cnt[(1 << e) - 1] = 1;
for (int mask = (1 << e) - 1; mask; --mask) {
//cout << mask << ": " << dp[mask] << " " << cnt[mask] << endl;
int bits = e - __builtin_popcount(mask);
for (int last = 0; last < e; ++last) {
if (get_bit(mask, last)) {
const int to = mask ^ (1 << last);
int ce = can_add[mask] - can_add[to];
int cur_e = m - e - can_add[mask] + bits;
const int C = mul(cnt[mask], pr[cur_e + 1][cur_e + ce]);
cnt[to] += C;
cnt[to] %= mod;
int add = mul(dp[mask], pr[cur_e + 2][cur_e + 1 + ce]);
add = (add + mul(C, bits + 1)) % mod;
//cout << "$" << mask << " " << last << ": " << cur_e << " " << ce << ", add = " << add << endl;
dp[to] += add;
dp[to] %= mod;
}
}
}
int ans = dp[0];
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int,int>;
using _loop_int = int;
#define REP(i,n) for(_loop_int i=0; i<(_loop_int)(n); i++)
#define FOR(i,a,b) for(_loop_int i=(_loop_int)(a); i<(_loop_int)(b); i++)
#define FORR(i,a,b) for(_loop_int i=(_loop_int)(b)-1; i>=(_loop_int)(a); i--)
#define CHMIN(a,b) (a)=min((a),(b))
#define CHMAX(a,b) (a)=max((a),(b))
#define ALL(v) (v).begin(),(v).end()
#define DEBUG(x) cerr<<#x<<": "<<(x)<<endl
#define DEBUG_VEC(v) cerr<<#v<<": ";REP(__i,(v).size())cerr<<((v)[__i])<<", ";cerr<<endl
// const ll MOD = 1000000007ll;
#define MOD 1000000007
int n,m;
vector<pii> tree[25];
int cnt[1<<19];
int dfs(int s, int t, int bef, int msk){
if(s==t)return msk;
for(pii P : tree[s]){
int to = P.first;
if(to==bef)continue;
int ret = dfs(to,t,s,msk | (1<<P.second));
if(ret != -1)return ret;
}
return -1;
}
pii dp[1<<19];
int ppc[1<<19];
int main(){
scanf("%d%d",&n,&m);
REP(i,m){
int a,b;
scanf("%d%d",&a,&b);
--a;--b;
if(i<n-1){
tree[a].push_back(pii(b,i));
tree[b].push_back(pii(a,i));
}else{
int msk = dfs(a,b,-1,0);
cnt[msk]++;
}
}
/*REP(i,n)if(n==20 && m==190 && tree[i].size()==19){
puts("581303120"); return 0;
}*/
// a
REP(j,n-1)REP(i,1<<(n-1))if(i&(1<<j))cnt[i]+=cnt[i^(1<<j)];
REP(i,1<<(n-1))ppc[i] = __builtin_popcount(i);
// dp
dp[0] = pii(1,0);
REP(j,m-n+2){
REP(msk,1<<(n-1))if(dp[msk] != pii(0,0)){
ll v = ppc[msk] + j + 1;
// use tree edge
int rmsk = ~msk & ((1<<(n-1))-1);
for(int x=rmsk&-rmsk; x; x=rmsk&(~rmsk+(x<<1))){
int nmsk = msk | x;
dp[nmsk].first += dp[msk].first;
if(dp[nmsk].first >= MOD){
dp[nmsk].first -= MOD;
}
dp[nmsk].second = (dp[nmsk].second + dp[msk].second + 1ll * dp[msk].first * v) % MOD;
}
REP(i,n-1)if(!(msk>>i&1)){
int nmsk = msk | (1<<i);
}
}
if(j==m-n+1)break;
REP(msk,1<<(n-1))if(dp[msk] != pii(0,0)){
// use non-tree edge
dp[msk].first = 1ll * dp[msk].first * (cnt[msk]-j) % MOD;
dp[msk].second= 1ll * dp[msk].second* (cnt[msk]-j) % MOD;
}
}
printf("%d\n",dp[(1<<(n-1))-1].second);
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
ll MOD = 1000000007;
struct UnionFindTree{
int par[22],r[22];
void init(int n = 22){
for(int i = 0 ; i < n ; i ++){
par[i] = i;
r[i] = 0;
}
}
int find(int x){
if(par[x] == x)return x;
return par[x] = find(par[x]);
}
bool same(int x,int y){
return find(x) == find(y);
}
void unit(int x,int y){
if(same(x,y))return;
x = find(x);
y = find(y);
if(r[x] < r[y]){
par[x] = y;
}
else {
par[y] = x;
if(r[x] == r[y]){
r[x] ++;
}
}
}
}uf;
int main(){
int n,m;
int a[200],b[200];
cin >> n >> m;
for(int i = 0 ; i < m ; i ++){
cin >> a[i] >> b[i];
}
static int r[1<<19] = {};
for(int i = 0 ; i < (1<<(n-1)) ; i ++){
uf.init();
for(int j = 0 ; j < n-1 ; j ++){
if((i>>j)&1)uf.unit(a[j],b[j]);
}
for(int j = n-1 ; j < m ; j ++){
if(uf.same(a[j],b[j]))r[i] ++;
}
}
static int d[1<<19] = {};
for(int i = 0 ; i < (1<<(n-1)) ; i ++){
int t = i;
while(t > 0){
d[i] += t&1;
t >>= 1;
}
}
/*for(int i = 0 ; i < 8 ; i ++){
cout << r[i] << " " << d[i] << endl;
}*/
static P dp[2][1<<19];
int t=0,t_=1;
for(int i = 0 ; i < (1<<(n-1)) ; i ++){
dp[t][i] = P(0,0);
}
dp[0][0] = P(1,0);
for(int i = 0 ; i < m ; i ++){
for(int x = 0 ; x < (1<<(n-1)) ; ++x){
dp[t_][x] = P(0,0);
}
for(int x = 0 ; x < (1<<(n-1)) ; ++x){
if(dp[t][x] == P(0,0))continue;
if(r[x]+d[x]-i > 0){
dp[t_][x].first += dp[t][x].first*(r[x]+d[x]-i);
dp[t_][x].second += dp[t][x].second*(r[x]+d[x]-i);
}
int j = ((1<<(n-1))-1)^x;
ll s = dp[t][x].second+(i+1)*dp[t][x].first;
//for(int j = 0 ; j < n-1 ; ++j)
while(j != 0){
int jj = j&-j;
j -= jj;
//if(x&(1<<j))continue;
dp[t_][x+jj].first += dp[t][x].first;
dp[t_][x+jj].second += s;
}
}
for(int x = 0 ; x < (1<<(n-1)) ; ++x){
if(dp[t_][x] != P(0,0)){
if(dp[t_][x].first >= MOD){
dp[t_][x].first %= MOD;
}
if(dp[t_][x].second >= MOD){
dp[t_][x].second %= MOD;
}
}
}
swap(t,t_);
/*cout << i << ":" << endl;
for(int j = 0 ; j < 8 ; j ++){
cout << dp[t][j].first << " " << dp[t][j].second << endl;
}
cout << "======================" << endl;*/
}
cout << dp[t][(1<<(n-1))-1].second << endl;
}
|
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <string>
#include <sstream>
#include <complex>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
#include <functional>
using namespace std;
#define mod 1000000007
#define FOR(x,to) for(int x=0;x<(to);x++)
#define FORR(x,arr) for(auto& x:arr)
#define ALL(a) (a.begin()),(a.end())
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
#define long long long
inline int rei(){int x;cin>>x;return x;}
inline long rel(){long x;cin>>x;return x;}
inline string res(){string x;cin>>x;return x;}
//-------------------------------------------------------
struct Fact{
vector<long> f;
vector<long> rf;
long pow(long N,long K){
if(K == 0){
return 1;
}
else if(K % 2 == 0){
long t = pow(N,K/2);
return t*t%mod;
}
else{
return N*pow(N,K-1)%mod;
}
}
Fact(int N):f(N+1),rf(N+1){
for(int i=0;i<N+1;i++){
if(i == 0){
f[i] = 1;
}
else{
f[i] = (f[i-1]*i)%mod;
}
}
for(int i=N;i>=0;i--){
if(i == N){
rf[i] = pow(f[N],mod-2);
}
else{
rf[i] = rf[i+1]*(i+1)%mod;
}
}
}
long GetFact(int N){
return f[N];
}
long GetPerm(int N,int R){
return f[N] * rf[N-R] % mod;
}
long GetConv(int N,int R){
return ((f[N]*rf[R])%mod*rf[N-R])%mod;
}
long GetRev(int N){
if(N == 0){
return 1;
}
else{
return rf[N] * f[N-1] % mod;
}
}
};
void dfs(int N,vector<int> G[],function<void(int,int,int)> F){
stack<pair<int,int>> sp;
sp.push({0,-1});
while(!sp.empty()){
int v = sp.top().first;
int f = sp.top().second;
sp.pop();
for(int i=0;i<G[v].size();i++){
int t = G[v][i];
if(t != f){
sp.push({t,v});
F(t,v,i);
}
}
}
}
vector<int> G[20];
vector<int> O[20];
int parent[20];
int depth[20];
int familyedge[20];
long C[21][400];
int bitedge[1 << 20];
int bitc[1 << 20];
long DP[1 << 20];
long DP2[1 << 20];
void Calc(){
int N = rei();
int M = rei();
for(int i=0;i<N-1;i++){
int f = rei()-1;
int t = rei()-1;
G[f].push_back(t);
G[t].push_back(f);
O[f].push_back(i);
O[t].push_back(i);
}
function<void(int,int,int)> Fu = [&](int v,int f,int e){
parent[v] = f;
if(f != -1){
depth[v] = depth[f]+1;
familyedge[v] = O[f][e];
}
};
dfs(N,G,Fu);
for(int i=N-1;i<M;i++){
int f = rei()-1;
int t = rei()-1;
int c = 0;
while(depth[f] < depth[t]){
c ^= (1 << familyedge[t]);
t = parent[t];
}
while(depth[f] > depth[t]){
c ^= (1 << familyedge[f]);
f = parent[f];
}
while(f != t){
c ^= (1 << familyedge[f]);
c ^= (1 << familyedge[t]);
f = parent[f];
t = parent[t];
}
bitedge[c]++;
}
for(int i=0;i<N-1;i++){
for(int j=0;j<1<<(N-1);j++){
if((1 << i) & j){
bitedge[j] += bitedge[j - (1 << i)];
}
}
}
for(int i=0;i<1<<(N-1);i++){
int c = 0;
for(int j=0;j<N-1;j++){
if(i & (1 << j)){
c++;
}
}
bitc[i] = c;
}
Fact F(M);
DP2[0] = 1;
for(int i=1;i<1<<(N-1);i++){
long c = 0;
long c2 = 0;
for(int j=0;j<N-1;j++){
if((i & (1 << j)) == 0){
continue;
}
int diff = bitedge[(1 << (N-1)) - 1 - i + (1 << j)] - bitedge[(1 << (N-1)) - 1 - i];
int d = bitc[i - (1 << j)] + (M-N+1 - bitedge[(1 << (N-1)) - 1 - i + (1 << j)]);
long cj = DP[i - (1 << j)] * F.GetFact(diff+d+1) % mod * F.rf[d+1] % mod;
long c2j = DP2[i - (1 << j)] * F.GetFact(diff+d) % mod * F.rf[d] % mod;
cj += bitc[i] * c2j;
cj %= mod;
c += cj;
c2 += c2j;
}
DP[i] = c % mod;
DP2[i] = c2 % mod;
}
cout << DP[(1 << (N-1)) - 1] << endl;
}
int main(int argc,char** argv){
ios::sync_with_stdio(false), cin.tie(0);
cout.tie(0); Calc(); return 0;
} |
#include <bits/stdc++.h>
#define debug(...) fprintf(stderr, __VA_ARGS__)
#ifndef AT_HOME
#define getchar() IO::myGetchar()
#define putchar(x) IO::myPutchar(x)
#endif
namespace IO {
static const int IN_BUF = 1 << 23, OUT_BUF = 1 << 23;
inline char myGetchar() {
static char buf[IN_BUF], *ps = buf, *pt = buf;
if (ps == pt) {
ps = buf, pt = buf + fread(buf, 1, IN_BUF, stdin);
}
return ps == pt ? EOF : *ps++;
}
template<typename T>
inline bool read(T &x) {
bool op = 0;
char ch = getchar();
x = 0;
for (; !isdigit(ch) && ch != EOF; ch = getchar()) {
op ^= (ch == '-');
}
if (ch == EOF) {
return false;
}
for (; isdigit(ch); ch = getchar()) {
x = x * 10 + (ch ^ '0');
}
if (op) {
x = -x;
}
return true;
}
inline int readStr(char *s) {
int n = 0;
char ch = getchar();
for (; isspace(ch) && ch != EOF; ch = getchar())
;
for (; !isspace(ch) && ch != EOF; ch = getchar()) {
s[n++] = ch;
}
s[n] = '\0';
return n;
}
inline void myPutchar(char x) {
static char pbuf[OUT_BUF], *pp = pbuf;
struct _flusher {
~_flusher() {
fwrite(pbuf, 1, pp - pbuf, stdout);
}
};
static _flusher outputFlusher;
if (pp == pbuf + OUT_BUF) {
fwrite(pbuf, 1, OUT_BUF, stdout);
pp = pbuf;
}
*pp++ = x;
}
template<typename T>
inline void print_(T x) {
if (x == 0) {
putchar('0');
return;
}
static int num[40];
if (x < 0) {
putchar('-');
x = -x;
}
for (*num = 0; x; x /= 10) {
num[++*num] = x % 10;
}
while (*num){
putchar(num[*num] ^ '0');
--*num;
}
}
template<typename T>
inline void print(T x, char ch = '\n') {
print_(x);
putchar(ch);
}
inline void printStr_(const char *s, int n = -1) {
if (n == -1) {
n = strlen(s);
}
for (int i = 0; i < n; ++i) {
putchar(s[i]);
}
}
inline void printStr(const char *s, int n = -1, char ch = '\n') {
printStr_(s, n);
putchar(ch);
}
}
using namespace IO;
const int N = 20, M = N * (N - 1) / 2, P = 1000000007;
int n, m;
struct Edge {
int u, v;
} E[M];
struct DSU {
int fa[N];
void init() {
for (int i = 0; i < n; ++i) {
fa[i] = i;
}
}
int find(int x) {
return fa[x] == x ? x : (fa[x] = find(fa[x]));
}
bool merge(int x, int y) {
x = find(x), y = find(y);
if (x == y) {
return true;
}
fa[y] = x;
return false;
}
} D;
int qpow(int a, int b) {
int s = 1;
for (; b; b >>= 1) {
if (b & 1) {
s = 1ll * s * a % P;
}
a = 1ll * a * a % P;
}
return s;
}
int fac[M + 1], inv[M + 1];
void init(int n) {
fac[0] = 1;
for (int i = 1; i <= n; ++i) {
fac[i] = 1ll * fac[i - 1] * i % P;
}
inv[n] = qpow(fac[n], P - 2);
for (int i = n; i; --i) {
inv[i - 1] = 1ll * inv[i] * i % P;
}
}
struct State {
int n, b, c, s;
} f[1 << (N - 1)];
int main() {
read(n), read(m);
for (int i = 0; i < m; ++i) {
read(E[i].u), read(E[i].v);
--E[i].u, --E[i].v;
}
for (int S = 0; S < (1 << (n - 1)); ++S) {
D.init();
f[S].b = n - 1, f[S].n = m;
for (int i = 0; i < n - 1; ++i) {
if (S >> i & 1) {
D.merge(E[i].u, E[i].v);
--f[S].b, --f[S].n;
}
}
for (int i = n - 1; i < m; ++i) {
if (D.find(E[i].u) == D.find(E[i].v)) {
--f[S].n;
}
}
}
init(m);
int U = (1 << (n - 1)) - 1;
f[U].c = 1, f[U].s = 0;
for (int S = U - 1; ~S; --S) {
for (int i = 0; i < n - 1; ++i) {
if (!(S >> i & 1)) {
int T = S | (1 << i);
int k = f[S].n - f[T].n - 1;
int c = 1ll * f[T].c * fac[f[T].n + k] % P * inv[f[T].n] % P;
int s = 1ll * f[T].s * fac[f[T].n + k + 1] % P * inv[f[T].n + 1] % P;
s = (s + 1ll * f[S].b * c) % P;
f[S].c = (f[S].c + c) % P;
f[S].s = (f[S].s + s) % P;
}
}
}
print(f[0].s);
}
|
#include <bits/stdc++.h>
using namespace std;
struct fast_ios { fast_ios(){ cin.tie(0); ios::sync_with_stdio(false); cout << fixed << setprecision(20); }; } fast_ios_;
#define FOR(i, begin, end) for(int i=(begin);i<(end);i++)
#define REP(i, n) FOR(i,0,n)
#define IFOR(i, begin, end) for(int i=(end)-1;i>=(begin);i--)
#define IREP(i, n) IFOR(i,0,n)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define all(v) v.begin(),v.end()
#define SZ(v) ((int)v.size())
#define Lower_bound(v, x) distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) distance(v.begin(), upper_bound(v.begin(), v.end(), x))
#define Max(a, b) a = max(a, b)
#define Min(a, b) a = min(a, b)
#define bit(n) (1LL<<(n))
#define bit_exist(x, n) ((x >> n) & 1)
#define Ans(f, y, n) if(f) cout << y << endl; else cout << n << endl;
#define debug(x) cout << #x << "=" << x << endl;
#define vdebug(v) cout << #v << "=" << endl; REP(i, v.size()){ cout << v[i] << ","; } cout << endl;
#define mdebug(m) cout << #m << "=" << endl; REP(i, m.size()){ REP(j, m[i].size()){ cout << m[i][j] << ","; } cout << endl;}
#define pb push_back
#define f first
#define s second
#define int long long
#define INF 1000000000000000000
using vec = vector<int>;
using mat = vector<vec>;
using Pii = pair<int, int>;
using PiP = pair<int, Pii>;
using PPi = pair<Pii, int>;
using bools = vector<bool>;
using pairs = vector<Pii>;
template<typename T> void readv(vector<T> &a){ REP(i, a.size()) cin >> a[i]; }
void readv_m1(vector<int> &a){ REP(i, a.size()){cin >> a[i]; a[i]--;} }
//int dx[4] = {1,0,-1,0};
//int dy[4] = {0,1,0,-1};
const int mod = 1000000007;
//const int mod = 998244353;
#define Add(x, y) x = (x + (y)) % mod
#define Mult(x, y) x = (x * (y)) % mod
template<long long MOD>
struct ModInt{
using ll = long long;
ll val;
void setval(ll v) { val = v % MOD; };
ModInt(): val(0) {}
ModInt(ll v) { setval(v); };
ModInt operator+(const ModInt &x) const { return ModInt(val + x.val); }
ModInt operator-(const ModInt &x) const { return ModInt(val - x.val + MOD); }
ModInt operator*(const ModInt &x) const { return ModInt(val * x.val); }
ModInt operator/(const ModInt &x) const { return *this * x.inv(); }
ModInt operator-() const { return ModInt(MOD - val); }
ModInt operator+=(const ModInt &x) { return *this = *this + x; };
ModInt operator-=(const ModInt &x) { return *this = *this - x; };
ModInt operator*=(const ModInt &x) { return *this = *this * x; };
ModInt operator/=(const ModInt &x) { return *this = *this / x; };
friend ostream& operator<<(ostream &os, const ModInt &x) { os << x.val; return os; }
friend istream& operator>>(istream &is, ModInt &x) { is >> x.val; x.val = (x.val % MOD + MOD) % MOD; return is; }
ModInt pow(ll n) const {
ModInt a = 1;
if(n == 0) return a;
int i0 = 64 - __builtin_clzll(n);
for(int i = i0 - 1; i >= 0; i--){
a = a * a;
if((n >> i) & 1) a *= (*this);
}
return a;
}
ModInt inv() const { return this->pow(MOD - 2); }
};
using mint = ModInt<mod>; mint pow(mint x, long long n) { return x.pow(n); }
//using mint = double; //for debug
using mvec = vector<mint>;
using mmat = vector<mvec>;
struct Combination{
vector<mint> fact, invfact;
Combination(int N){
fact = vector<mint>({mint(1)});
invfact = vector<mint>({mint(1)});
fact_initialize(N);
}
void fact_initialize(int N){
int i0 = fact.size();
if(i0 >= N + 1) return;
fact.resize(N + 1);
invfact.resize(N + 1);
for(int i = i0; i <= N; i++) fact[i] = fact[i - 1] * i;
invfact[N] = (mint)1 / fact[N];
for(int i = N - 1; i >= i0; i--) invfact[i] = invfact[i + 1] * (i + 1);
}
mint nCr(int n, int r){
if(n < 0 || r < 0 || r > n) return mint(0);
if(fact.size() < n + 1) fact_initialize(n);
return fact[n] * invfact[r] * invfact[n - r];
}
mint nPr(int n, int r){
if(n < 0 || r < 0 || r > n) return mint(0);
if(fact.size() < n + 1) fact_initialize(n);
return fact[n] * invfact[n - r];
}
};
struct edge{int to, cost;};
class Graph
{
public:
int N;
vector<vector<edge>> G;
Graph(int N): N(N){
G = vector<vector<edge>>(N, vector<edge>(0));
}
void add_edge(int from, int to, int cost = 0){
G[from].push_back(edge({to, cost}));
}
void add_edge2(int v1, int v2, int cost = 0){
add_edge(v1, v2, cost);
add_edge(v2, v1, cost);
}
int dfs(int v, int to, int b = -1, int use = 0){
if(v == to) return use;
for(auto e: G[v]) if(e.to != b){
int res = dfs(e.to, to, v, use ^ bit(e.cost));
if(res != -1) return res;
}
return -1;
}
};
signed main(){
int N, M; cin >> N >> M;
vec a(M), b(M);
Graph G(N);
REP(i, M){
cin >> a[i] >> b[i];
a[i]--; b[i]--;
if(i < N - 1) G.add_edge2(a[i], b[i], i);
}
mat zeta(N, vec(bit(N - 1), 0));
vec S(bit(N - 1), 0);
REP(i, M){
zeta[0][G.dfs(a[i], b[i])]++;
}
REP(i, N - 1){
REP(j, bit(N - 1)){
zeta[i + 1][j] += zeta[i][j];
if((j >> i) & 1) zeta[i + 1][j] += zeta[i][j ^ bit(i)];
}
}
REP(i, bit(N - 1)) S[i] = zeta[N - 1][i];
//mdebug(zeta);
//vdebug(S);
mat dp(bit(N - 1)), dq(bit(N - 1));
dp[0] = vec({1});
dq[0] = vec({0});
FOR(i, 1, bit(N - 1)){
dp[i] = vec(S[i] + 1, 0);
dq[i] = vec(S[i] + 1, 0);
REP(j, N - 1) if((i >> j) & 1){
int i0 = i ^ bit(j);
int n = __builtin_popcountll(i0);
FOR(k, n, S[i0] + 1){
dp[i][k + 1] += dp[i0][k];
dq[i][k + 1] += dq[i0][k] + dp[i0][k] * (k + 1);
}
}
int n = __builtin_popcountll(i);
dp[i][n] %= mod;
dq[i][n] %= mod;
FOR(k, n, S[i]){
dp[i][k + 1] += dp[i][k] * (S[i] - k);
dq[i][k + 1] += dq[i][k] * (S[i] - k);
dp[i][k + 1] %= mod;
dq[i][k + 1] %= mod;
}
}
//mdebug(dp);
//mdebug(dq);
int ans = dq[bit(N - 1) - 1][M];
cout << ans << endl;
return 0;
}
|
const long long MOD = 1e9 + 7;
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
void dfs(int v, int par, vector<int> &h, vector<int> &edge_in, vector<int> &a, vector<int> &b)
{
if (v == par) h[v] = 0;
else h[v] = h[par] + 1;
for (int i = 0; i < h.size() - 1; i++)
{
if (a[i] == v || b[i] == v)
{
int u = a[i] + b[i] - v;
if (u != par)
{
edge_in[u] = i;
dfs(u, v, h, edge_in, a, b);
}
}
}
}
int mark(int v, int u, vector<int> &h, vector<int> &edge_in, vector<int> &a, vector<int> &b)
{
int mask = 0;
while (h[v] > h[u])
{
mask += 1 << edge_in[v];
int f = a[edge_in[v]] + b[edge_in[v]] - v;
v = f;
}
while (h[v] < h[u])
{
mask += 1 << edge_in[u];
int f = a[edge_in[u]] + b[edge_in[u]] - u;
u = f;
}
while (v != u)
{
mask += 1 << edge_in[v];
int f = a[edge_in[v]] + b[edge_in[v]] - v;
v = f;
mask += 1 << edge_in[u];
f = a[edge_in[u]] + b[edge_in[u]] - u;
u = f;
}
return mask;
}
const int N = 206;
const int M = (1 << 19) + 2;
ll dp[M];
ll EV[M];
ll ans[M];
int on_right[M];
ll Supersigmacnk[N][N];
ll Supersigmacnkdec[N][N];
ll Supersigmacnkinc[N][N];
ll cnk[N][N];
ll fact[N];
ll rev[N];
ll supersigmacnkdec(ll i, ll k, ll n)
{
ll ans = Supersigmacnk[k][n] * (i + MOD - 1) % MOD;
ans = (ans + Supersigmacnkdec[k][n]) % MOD;
return ans;
}
ll supersigmacnkinc(ll i, ll k, ll n)
{
ll ans = Supersigmacnk[k][n] * i % MOD;
ans = (ans + Supersigmacnkinc[k][n]) % MOD;
return ans;
}
signed main()
{
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
fact[0] = 1;
rev[1] = 1;
for (int i = 1; i < N; i++) fact[i] = (fact[i - 1] * i) % MOD;
for (int i = 2; i < N; i++) rev[i] = MOD - (MOD / i) * rev[MOD % i] % MOD;
for (int i = 0; i < N; i++)
{
cnk[i][0] = cnk[i][i] = 1;
for (int j = 1; j < i; j++)
{
cnk[i][j] = (cnk[i - 1][j - 1] + cnk[i - 1][j]) % MOD;
}
}
for (int k = 0; k < N; k++)
{
for (int n = k; n < N; n++)
{
Supersigmacnk[k][n] = ((n != k ? Supersigmacnk[k][n - 1] : 0) + cnk[n][k]) % MOD;
Supersigmacnkdec[k][n] = ((n != k ? Supersigmacnkdec[k][n - 1] : 0) + Supersigmacnk[k][n]) % MOD;
Supersigmacnkinc[k][n] = ((n != k ? Supersigmacnkinc[k][n - 1] : 0) + (n - k) * cnk[n][k]) % MOD;
}
}
int n, m;
cin >> n >> m;
vector<int> a(m), b(m);
for (int i = 0; i < m; i++)
{
cin >> a[i] >> b[i];
a[i]--, b[i]--;
}
vector<int> h(n), edge_in(n);
dfs(0, 0, h, edge_in, a, b);
vector<int> suba(m);
for (int i = n - 1; i < m; i++)
{
int z = mark(a[i], b[i], h, edge_in, a, b);
suba[i] = z;
}
int M = 1 << (n - 1);
{
for (int i = n - 1; i < m; i++)
{
int w = M - 1 - suba[i];
on_right[w]++;
}
for (int b = 0; b < n - 1; b++)
{
for (int i = M - 1; i >= 0; i--)
{
if (i & (1 << b)) continue;
on_right[i] += on_right[i + (1 << b)];
}
}
for (int mask = 1; mask < M; mask++)
{
on_right[mask] = m - n + 1 - on_right[mask];
on_right[mask] += __builtin_popcount(mask) - 1;
}
on_right[0] = -1;
dp[0] = 1;
for (int mask = 1; mask < M; mask++)
{
ll summ_right = 0, cnt_left = 0;
for (int p = 0; p < n - 1; p++)
{
if (mask & (1 << p))
{
int pmask = mask - (1 << p);
if (pmask == 0)
{
dp[mask] = fact[on_right[mask]];
EV[mask] = fact[on_right[mask]];
ans[mask] = fact[on_right[mask]] * (m - on_right[mask]) % MOD;
continue;
}
int cnt = on_right[mask] - on_right[pmask] - 1;
ll ways = cnk[on_right[mask]][on_right[pmask] + 1] * fact[on_right[mask] - on_right[pmask] - 1] % MOD;
ll dpways = dp[pmask] * ways % MOD;
dp[mask] = (dp[mask] + dpways) % MOD;
ll W = fact[cnt] * dp[pmask] % MOD;
ll SS1 = Supersigmacnkdec[on_right[pmask]][on_right[mask] - 1];
cnt_left = (cnt_left + SS1 * W) % MOD;
ll SS2 = supersigmacnkinc(on_right[pmask] + 1, on_right[pmask], on_right[mask] - 1);
summ_right = (summ_right + SS2 * fact[cnt] % MOD * (EV[pmask] + dp[pmask])) % MOD;
ll SS3 = Supersigmacnk[on_right[pmask]][on_right[mask] - 1];
ll SS4 = supersigmacnkinc(0, on_right[pmask], on_right[mask] - 1);
ans[mask] = (ans[mask] + ans[pmask] * fact[cnt] % MOD * SS3
+ (m - on_right[mask]) * W % MOD * SS3
- EV[pmask] * fact[cnt] % MOD * SS4
) % MOD;
if (ans[mask] < 0) ans[mask] += MOD;
}
}
if (__builtin_popcount(mask) > 1)
{
//cout << mask << " " << summ_right << " " << cnt_left << " " << cnt_right << "\n";
EV[mask] = (cnt_left + summ_right) * rev[on_right[mask] + 1] % MOD;
}
//cout << mask << " " << dp[mask] << " " << EV[mask] << " " << ans[mask] << "\n";
}
//cout << dp[M - 1] << "\n";
cout << ans[M - 1] << "\n";
}
}
/* Note:
Check constants at the beginning of the code (MOD, INF, INFLL)
Check corner cases.
N = 1
No def int long long for now.
Add something here.
*/
|
/* cerberus97 - Hanit Banga */
#include <iostream>
#include <iomanip>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
using namespace std;
#define pb push_back
#define fast_cin() ios_base::sync_with_stdio(false); cin.tie(NULL)
typedef long long ll;
typedef long double ld;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;
const int N = 25, M = 200, S = (1 << 19) + 5;
const int mod = 1e9 + 7;
vector<pii> g[N];
int u[M], v[M], depth[N], par[N], up[N];
int dep[M];
int ctr[S];
ll ways[S], sum[S];
ll prod[M][M];
void dfs(int u, int p);
int main() {
// cout << (2 * sizeof(ways)) / 1e6 << endl;
// return 0;
fast_cin();
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> u[i] >> v[i];
if (i < n - 1) {
g[u[i]].pb({v[i], i});
g[v[i]].pb({u[i], i});
}
}
dfs(1, 0);
for (int i = n - 1; i < m; ++i) {
int eu = u[i], ev = v[i];
if (depth[eu] < depth[ev]) {
swap(eu, ev);
}
while (depth[eu] > depth[ev]) {
dep[i] |= (1 << up[eu]);
eu = par[eu];
}
while (eu != ev) {
dep[i] |= (1 << up[eu]);
dep[i] |= (1 << up[ev]);
eu = par[eu];
ev = par[ev];
}
}
for (int i = 1; i < M; ++i) {
prod[i][i - 1] = 1;
for (int j = i; j < M; ++j) {
prod[i][j] = prod[i][j - 1] * j;
prod[i][j] %= mod;
}
}
int subsets = (1 << (n - 1));
for (int mask = 0; mask < subsets; ++mask) {
// ctr[mask] = __builtin_popcount(mask);
for (int i = n - 1; i < m; ++i) {
if (dep[i] & mask) {
++ctr[mask];
}
}
}
ways[0] = 1;
for (int mask = 0; mask < subsets; ++mask) {
// cout << mask << ' ' << ways[mask] << ' ' << sum[mask] << ' ' << ctr[mask] << endl;
int b = __builtin_popcount(mask), tot = ctr[mask] + b;
for (int i = 0; i < n - 1; ++i) {
if (mask & (1 << i)) {
continue;
}
int new_mask = mask | (1 << i);
int k = ctr[new_mask] - ctr[mask];
ll temp = prod[tot + 1][tot + k] * ways[mask];
temp %= mod;
ways[new_mask] += temp;
ways[new_mask] %= mod;
sum[new_mask] += prod[tot + 2][tot + k + 1] * sum[mask];
sum[new_mask] += temp * (b + 1);
sum[new_mask] %= mod;
}
}
cout << sum[subsets - 1] << endl;
}
void dfs(int u, int p) {
for (auto &e : g[u]) {
int v = e.first, id = e.second;
if (v != p) {
depth[v] = depth[u] + 1;
par[v] = u;
up[v] = id;
dfs(v, u);
}
}
} |
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define N 21
const int mod=1e9+7;
typedef long long ll;
inline ll read(){
ll x=0,f=1;
char c=getchar();
while(c<'0'||c>'9'){
if(c=='-')f=-1;
c=getchar();
}
while(c>='0'&&c<='9'){
x=(x<<1)+(x<<3)+c-'0';
c=getchar();
}
return x*f;
}
int n,m,fac[N*N],ifac[N*N],x[N*N],y[N*N],all;
int qpow(int a,int b){
int ans=1;
while(b){
if(b&1)ans=1LL*ans*a%mod;
a=1LL*a*a%mod;
b>>=1;
}
return ans;
}
void init(int n){
fac[0]=1;
for(int i=1;i<=n;++i){
fac[i]=1LL*fac[i-1]*i%mod;
}
ifac[n]=qpow(fac[n],mod-2);
for(int i=n-1;i>=0;--i){
ifac[i]=1LL*ifac[i+1]*(i+1)%mod;
}
}
struct state{
int n,b,c,s; //序列长度，黑球个数，序列个数，所有序列的黑球位置之和
}dp[1<<N];
struct Union_Set{
int f[N];
void init(int n){
for(int i=1;i<=n;++i){
f[i]=i;
}
}
inline int getf(int x){
return f[x]==x?x:f[x]=getf(f[x]);
}
void Merge(int x,int y){
int fx=getf(x),fy=getf(y);
if(fx==fy)return;
f[fy]=fx;
}
}S;
int main(){
n=read(),m=read(),all=(1<<n-1)-1;
init(m+1);
for(int i=1;i<=m;++i){
x[i]=read(),y[i]=read();
}
for(int i=0;i<=all;++i){
S.init(n);
dp[i].b=n-1,dp[i].n=m;
for(int j=1;j<n;++j){
if((i>>j-1)&1){
S.Merge(x[j],y[j]);
--dp[i].b,--dp[i].n;
}
}
for(int j=n;j<=m;++j){
if(S.getf(x[j])==S.getf(y[j])){
--dp[i].n;
}
}
}
dp[all].c=1;
for(int i=all-1;i>=0;--i){
for(int j=1;j<=n;++j){
if((i>>j-1)&1)continue;
int t=i|(1<<j-1);
int k=dp[i].n-dp[t].n-1;
int c=1LL*dp[t].c*fac[dp[t].n+k]%mod*ifac[dp[t].n]%mod;
int s=(1LL*dp[t].s*fac[dp[t].n+k+1]%mod*ifac[dp[t].n+1]%mod+1LL*dp[i].b*c)%mod;
dp[i].c=(dp[i].c+c)%mod;
dp[i].s=(dp[i].s+s)%mod;
}
}
printf("%d\n",dp[0].s);
return 0;
}
|
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
#include<vector>
#include<ctime>
#include<map>
#include<bitset>
#include<set>
#include<assert.h>
#include<chrono>
#include<random>
#define LL long long
#define mp(x,y) make_pair(x,y)
#define pll pair<long long,long long>
#define pii pair<int,int>
#define SZ(x) ((int)x.size())
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
inline LL read()
{
LL f=1,x=0;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
int stack[20];
template<typename T>inline void write(T x)
{
if(x<0){putchar('-');x=-x;}
if(!x){putchar('0');return;}
int top=0;
while(x)stack[++top]=x%10,x/=10;
while(top)putchar(stack[top--]+'0');
}
template<typename T>inline void pr1(T x){write(x);putchar(' ');}
template<typename T>inline void pr2(T x){write(x);putchar('\n');}
template<typename T>inline void chkmin(T &x,T y){x=x<y?x:y;}
template<typename T>inline void chkmax(T &x,T y){x=x>y?x:y;}
const int MAXMASK=(1<<19);
const int mod=1e9+7;
const int MAXN=25;
int pow_mod(int a,int b)
{
int ret=1;
for(;b;b>>=1,a=1LL*a*a%mod)if(b&1)ret=1LL*ret*a%mod;
return ret;
}
void ad(int &x,int y){x+=y;if(x>=mod)x-=mod;}
vector<int> nxt[MAXN];
void ins(int x,int y){nxt[x].emplace_back(y);}
int f[MAXMASK],g[MAXMASK],E[MAXMASK];
int n,m,bin[25],ex[MAXN*MAXN],ey[MAXN*MAXN],mask[MAXN*MAXN],Log[MAXMASK];
int rt[MAXN];
int findrt(int x){return rt[x]==x?rt[x]:rt[x]=findrt(rt[x]);}
int lowbit(int x){return x&-x;}
int pre[MAXN*MAXN],inv[MAXN*MAXN];
map<int,int> mp[MAXN];
int get_edge(int x,int fa,int ed)
{
if(x==ed)return 0;
for(auto y:nxt[x])if(y^fa)
{
int t=get_edge(y,x,ed);
if(t!=-1)return t|bin[mp[x][y]-1];
}return -1;
}
int H[MAXMASK];
inline void FMT(int *y,int len){for(int i=1;i<len;i<<=1)for(int x=0;x<len;x++)if(!(x&i))ad(y[x|i],y[x]);}
int main()
{
pre[0]=1;for(int i=1;i<MAXN*MAXN;i++)pre[i]=1LL*pre[i-1]*i%mod;
inv[MAXN*MAXN-1]=pow_mod(pre[MAXN*MAXN-1],mod-2);
for(int i=MAXN*MAXN-2;i>=0;i--)inv[i]=1LL*inv[i+1]*(i+1)%mod;
bin[0]=1;for(int i=1;i<=20;i++)bin[i]=bin[i-1]<<1;
for(int i=0;(1<<i)<MAXMASK;i++)Log[1<<i]=i;
n=read();m=read();
for(int i=1;i<=m;i++)
{
ex[i]=read(),ey[i]=read();
if(i<n)ins(ex[i],ey[i]),ins(ey[i],ex[i]),mp[ex[i]][ey[i]]=mp[ey[i]][ex[i]]=i;
}
for(int i=n;i<=m;i++)mask[i]=get_edge(ex[i],0,ey[i]),++H[mask[i]];
FMT(H,bin[n-1]);
for(int i=0;i<bin[n-1];i++)
E[i]=(m-n+1)-H[(bin[n-1]-1)^i];
// for(int j=n;j<=m;j++)E[i]+=(mask[j]&i)>0;
g[0]=1;
for(int i=0;i<bin[n-1];i++)if(g[i])
{
int t=__builtin_popcount(i);
for(int S=(bin[n-1]-1)^i;S;S^=lowbit(S))
{
int u=lowbit(S),newe=E[i|u]-E[i],pree=E[i]+t;
int newg=1LL*g[i]*pre[pree+newe]%mod*inv[pree]%mod;
int newf=1LL*f[i]*pre[pree+newe+1]%mod*inv[pree+1]%mod;
ad(newf,1LL*(t+1)*newg%mod);
ad(g[i|u],newg);ad(f[i|u],newf);
}
}
pr2(f[bin[n-1]-1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int,int>;
#define REP(i,n) for(int i=0; i<(int)(n); i++)
#define MOD 1000000007
int n,m;
vector<pii> tree[25];
int cnt[1<<19];
pii dp[1<<19];
int ppc[1<<19];
int dfs(int s, int t, int bef, int msk){
if(s==t)return msk;
for(pii P : tree[s]){
int to = P.first;
if(to==bef)continue;
int ret = dfs(to,t,s,msk | (1<<P.second));
if(ret != -1)return ret;
}
return -1;
}
int main(){
scanf("%d%d",&n,&m);
n--;
REP(i,m){
int a,b;
scanf("%d%d",&a,&b);
--a;--b;
if(i<n){
tree[a].push_back(pii(b,i));
tree[b].push_back(pii(a,i));
}else{
int msk = dfs(a,b,-1,0);
cnt[msk]++;
}
}
REP(j,n)REP(i,1<<n)if(i&(1<<j))cnt[i]+=cnt[i^(1<<j)];
REP(i,1<<n)ppc[i] = __builtin_popcount(i);
dp[0] = pii(1,0);
REP(j,m-n+1){
REP(msk,1<<n)if(dp[msk] != pii(0,0)){
int v = ppc[msk] + j + 1;
int rmsk = ~msk & ((1<<n)-1);
int add = (dp[msk].second + 1ll*dp[msk].first*v) % MOD;
for(int x=rmsk&-rmsk; x; x=rmsk&(~rmsk+(x<<1))){
(dp[msk | x].first += dp[msk].first) %= MOD;
(dp[msk | x].second += add) %= MOD;
}
}
if(j==m-n)break;
REP(msk,1<<n)if(dp[msk] != pii(0,0)){
dp[msk].first = 1ll*dp[msk].first *(cnt[msk]-j) % MOD;
dp[msk].second= 1ll*dp[msk].second*(cnt[msk]-j) % MOD;
}
}
printf("%d\n",dp[(1<<n)-1].second);
return 0;
}
|
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline", "fast-math", "unroll-loops", "no-stack-protector")
#pragma GCC diagnostic error "-fwhole-program"
#pragma GCC diagnostic error "-fcse-skip-blocks"
#pragma GCC diagnostic error "-funsafe-loop-optimizations"
#include<cstdio>
#include<algorithm>
#include<vector>
#include<map>
#include<queue>
#include<cstring>
#define ll long long
using namespace std;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c, qu[55];
int f, qr;
#define gc() (iS == iT ? (iT = (iS = ibuf) + fread (ibuf, 1, SIZE, stdin), (iS == iT ? EOF : *iS ++)) : *iS ++)
inline void flush () {
fwrite (obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc (char x) {
*oS ++ = x;
if (oS == oT) flush ();
}
template<class T>
inline void getc(T &x)
{
for(c=gc();!((c>='a'&&c<='z')||(c>='A'&&c<='Z'));c=gc());
x=c;
}
template <class I>
inline void rd (I &x) {
for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;
for (x = 0; c <= '9' && c >= '0'; c = gc()) x = x * 10 + (c & 15);
x *= f;
}
template <class I>
inline void print (I x) {
if (!x) putc ('0');
if (x < 0) putc ('-'), x = -x;
while (x) qu[++ qr] = x % 10 + '0', x /= 10;
while (qr) putc (qu[qr --]);
}
struct Flusher_ {
~Flusher_() {
flush();
}
} io_flusher_;
}
using io :: rd;
using io :: putc;
using io :: print;
using io :: getc;
const int MOD=1e9+7;
int mo(int x,int y)
{
return x+y>=MOD?x+y-MOD:x+y;
}
int mu(int x,int y)
{
return (ll)x*y%MOD;
}
int sub(int x,int y)
{
return x<y?x-y+MOD:x-y;
}
int ksm(int x,int y)
{
int res=1;
for(;y;y>>=1,x=mu(x,x))
if(y&1) res=mu(res,x);
return res;
}
const int MAXN=200+5;
pair<int,int>e[MAXN];
vector<int>g[MAXN];
int n,m;
ll dp[2][(1<<20)|1],sum[2][(1<<20)|1];
int els[(1<<20)|1],bin[(1<<20)|1],dep[MAXN],fa[MAXN],id[(1<<20)|1];
void dfs(int x,int ff)
{
dep[x]=dep[ff]+1;fa[x]=ff;
for(int i=0;i<g[x].size();i++)
{
int v=g[x][i];
if(v==ff) continue;
dfs(v,x);
}
}
/*
int jc[MAXN],jcn[MAXN];
int C(int n,int m)
{
return (n<m)?0:mu(jc[n],mu(jcn[m],jcn[n-m]));
}
*/
int ADD(int x,int y)
{
return x<=0?0:(ll)x*y%MOD;
}
int up[MAXN];
int main()
{
rd(n);rd(m);
for(int i=1,x,y;i<=m;i++)
{
rd(x);rd(y);
e[i]=make_pair(x,y);
if(i<=n-1)
{
g[x].push_back(y);
g[y].push_back(x);
}
}
dfs(1,0);
/* for(int i=n,x,y;i<=m;i++)
{
x=e[i].first,y=e[i].second;
while(x!=y)
{
if(dep[x]>dep[y])
{
SL[i]|=(1<<x-1);
x=fa[x];
}
else
{
SL[i]|=(1<<y-1);
y=fa[y];
}
}
}*/
int es=n-1;
for(int S=1;S<(1<<es);S++)
bin[S]=bin[S-(S&(-S))]+1;
for(int i=1;i<=es;i++)
id[(1<<(i-1))]=i;
/*
for(int S=0;S<(1<<es);S++)
{
int nowS=0;
for(int j,i=S,x,y;i;i-=i&(-i))
{
j=id[i&(-i)];
x=e[j].first;y=e[j].second;
nowS|=(dep[x]<dep[y])?(1<<y-1):(1<<x-1);
}
for (int i=n;i<=m;i++)
els[S]+=((SL[i]&nowS)==SL[i]);
// if(cnt) fprintf(stderr,"%d %d\n",S,els[S]);
}*/
for(int i=1,x,y;i<n;i++)
{
x=e[i].first;y=e[i].second;
up[(dep[x]<dep[y])?y:x]=i;
}
for(int i=n,x,y,S;i<=m;i++)
{
S=0;
x=e[i].first,y=e[i].second;
while(x!=y)
{
if(dep[x]>dep[y])
{
S|=(1<<(up[x]-1));
x=fa[x];
}
else
{
S|=(1<<up[y]-1);
y=fa[y];
}
}
++els[S];
}
for(int i=0;i<es;i++)
for(int j=0;j<(1<<es);j++)
if((j>>i)&1)
els[j]+=els[j^(1<<i)];
for(int j=0;j<(1<<es);j++)
els[j]+=bin[j];
/* for(int i=jc[0]=1;i<=m;i++) jc[i]=mu(jc[i-1],i);
jcn[m]=ksm(jc[m],MOD-2);
for(int i=m;i;i--)
jcn[i-1]=mu(jcn[i],i);
*/
// fprintf(stderr,"err");
dp[0][0]=1;int cur=0,nxt=1;
for(int i=1;i<=m;i++)
{
for(register int S=0,v;S<(1<<es);els[S]--,++S)
if(dp[cur][S])
{
dp[cur][S]=(dp[cur][S]>=10000000000000ll)?dp[cur][S]%MOD:dp[cur][S];
sum[cur][S]=(sum[cur][S]>=10000000000000ll)?sum[cur][S]%MOD:sum[cur][S];
// v=(els[S]-(i-1-bin[S]));
dp[nxt][S]+=els[S]>0?dp[cur][S]*els[S]:0;
sum[nxt][S]+=els[S]>0?sum[cur][S]*els[S]:0;
for(register int j=(1<<es)-1-S;j;j^=j&(-j))
{
int t=id[j&(-j)];
dp[nxt][S|(1<<(t-1))]+=dp[cur][S];
sum[nxt][S|(1<<(t-1))]+=dp[cur][S]*i+sum[cur][S];
}
dp[cur][S]=sum[cur][S]=0;
}
cur^=1;nxt^=1;
}
print(sum[cur][(1<<es)-1]%MOD);
putc('\n');
return 0;
} |
#include<bits/stdc++.h>
#define maxn 30
#define N 1100000
#define ll long long
#define mod 1000000007
using namespace std;
int head[maxn], nxt[maxn * 2], a[maxn * 2], edge, id[maxn * 2], path[maxn][maxn];
int sum[N], f[N], g[N], node[N], fac[N], inv[N];
int calc(int a, int k)
{
int ans = 1;
while (k)
{
if (k % 2) ans = (ll)ans * a % mod;
a = (ll)a * a % mod;
k /= 2;
}
return ans;
}
void create(int u, int v, int t)
{
edge++; a[edge] = v; nxt[edge] = head[u]; head[u] = edge; id[edge] = t;
}
void get_val(int u, int fa, int rt, int cur)
{
path[u][rt] = cur;
for (int i = head[u]; i; i = nxt[i])
{
int v = a[i];
if (v != fa) get_val(v, u, rt, cur + (1 << id[i] - 1));
}
}
void get_sum(int *a, int n)
{
for (int l = 2; l <= n; l *= 2)
{
int m = l / 2;
for (int *p = a; p != a + n; p += l)
for (int i = 0; i <= m - 1; i++)
p[i + m] = (p[i + m] + p[i]) % mod;
}
}
void get_trans(int pre, int nxt, int s, int sum)
{
int fa = (ll)g[pre] * fac[s + sum] % mod * inv[s] % mod;
g[nxt] = (g[nxt] + fa) % mod;
int tmp = (ll)f[pre] * fac[s + sum + 1] % mod * inv[s + 1] % mod;
tmp = (tmp + (ll)node[nxt] * fa % mod) % mod;
f[nxt] = (f[nxt] + tmp) % mod;
}
int main()
{
int n, m;
scanf("%d%d", &n, &m);
fac[0] = 1;
for (int i = 1; i <= m + 1; i++)
fac[i] = (ll)fac[i - 1] * i % mod;
inv[m + 1] = calc(fac[m + 1], mod - 2);
for (int i = m; i >= 0; i--)
inv[i] = inv[i + 1] * ((ll)i + 1) % mod;
for (int i = 1; i <= m; i++)
{
int u, v;
scanf("%d%d", &u, &v);
if (i <= n - 1)
{
create(u, v, i);
create(v, u, i);
}
else sum[path[u][v]]++;
if (i == n - 1)
{
for (int j = 1; j <= n; j++)
get_val(j, 0, j, 0);
}
}
get_sum(sum, 1 << n - 1);
f[0] = 0; g[0] = 1;
int full = (1 << n - 1) - 1;
for (int i = 0; i <= full; i++)
for (int j = 1; j <= n - 1; j++)
node[i] += (i >> j - 1) & 1;
for (int i = 0; i <= full; i++)
for (int j = 1; j <= n - 1; j++)
if (((i >> j - 1) & 1) == 0)
{
int nxt = i + (1 << j - 1), tot = m - (n - 1) - sum[full - i] + node[i];
get_trans(i, nxt, tot, sum[full - i] - sum[full - nxt]);
}
printf("%d\n", f[full]);
return 0;
} |
const long long MOD = 1e9 + 7;
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
void dfs(int v, int par, vector<int> &h, vector<int> &edge_in, vector<int> &a, vector<int> &b)
{
if (v == par) h[v] = 0;
else h[v] = h[par] + 1;
for (int i = 0; i < h.size() - 1; i++)
{
if (a[i] == v || b[i] == v)
{
int u = a[i] + b[i] - v;
if (u != par)
{
edge_in[u] = i;
dfs(u, v, h, edge_in, a, b);
}
}
}
}
int mark(int v, int u, vector<int> &h, vector<int> &edge_in, vector<int> &a, vector<int> &b)
{
int mask = 0;
while (h[v] > h[u])
{
mask += 1 << edge_in[v];
int f = a[edge_in[v]] + b[edge_in[v]] - v;
v = f;
}
while (h[v] < h[u])
{
mask += 1 << edge_in[u];
int f = a[edge_in[u]] + b[edge_in[u]] - u;
u = f;
}
while (v != u)
{
mask += 1 << edge_in[v];
int f = a[edge_in[v]] + b[edge_in[v]] - v;
v = f;
mask += 1 << edge_in[u];
f = a[edge_in[u]] + b[edge_in[u]] - u;
u = f;
}
return mask;
}
const int N = 206;
ll Supersigmacnk[N][N];
ll Supersigmacnkdec[N][N];
ll Supersigmacnkinc[N][N];
ll cnk[N][N];
ll fact[N];
ll rev[N];
ll supersigmacnkdec(ll i, ll k, ll n)
{
ll ans = Supersigmacnk[k][n] * (i + MOD - 1) % MOD;
ans = (ans + Supersigmacnkdec[k][n]) % MOD;
return ans;
}
ll supersigmacnkinc(ll i, ll k, ll n)
{
ll ans = Supersigmacnk[k][n] * i % MOD;
ans = (ans + Supersigmacnkinc[k][n]) % MOD;
return ans;
}
signed main()
{
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
fact[0] = 1;
rev[1] = 1;
for (int i = 1; i < N; i++) fact[i] = (fact[i - 1] * i) % MOD;
for (int i = 2; i < N; i++) rev[i] = MOD - (MOD / i) * rev[MOD % i] % MOD;
for (int i = 0; i < N; i++)
{
cnk[i][0] = cnk[i][i] = 1;
for (int j = 1; j < i; j++)
{
cnk[i][j] = (cnk[i - 1][j - 1] + cnk[i - 1][j]) % MOD;
}
}
for (int k = 0; k < N; k++)
{
for (int n = k; n < N; n++)
{
Supersigmacnk[k][n] = ((n != k ? Supersigmacnk[k][n - 1] : 0) + cnk[n][k]) % MOD;
Supersigmacnkdec[k][n] = ((n != k ? Supersigmacnkdec[k][n - 1] : 0) + Supersigmacnk[k][n]) % MOD;
Supersigmacnkinc[k][n] = ((n != k ? Supersigmacnkinc[k][n - 1] : 0) + (n - k) * cnk[n][k]) % MOD;
}
}
int n, m;
cin >> n >> m;
vector<int> a(m), b(m);
for (int i = 0; i < m; i++)
{
cin >> a[i] >> b[i];
a[i]--, b[i]--;
}
vector<int> h(n), edge_in(n);
dfs(0, 0, h, edge_in, a, b);
vector<int> suba(m);
for (int i = n - 1; i < m; i++)
{
int z = mark(a[i], b[i], h, edge_in, a, b);
suba[i] = z;
}
int M = 1 << (n - 1);
{
vector<ll> on_right(M, 0);
for (int mask = 1; mask < M; mask++)
{
for (int i = n - 1; i < m; i++)
{
if (suba[i] & mask)
{
on_right[mask]++;
}
}
on_right[mask] += __builtin_popcount(mask) - 1;
}
vector<ll> dp(M);
vector<ll> EV(M);
vector<ll> ans(M);
on_right[0] = -1;
dp[0] = 1;
for (int mask = 1; mask < M; mask++)
{
ll summ_right = 0, cnt_left = 0;
for (int p = 0; p < n - 1; p++)
{
if (mask & (1 << p))
{
int pmask = mask - (1 << p);
if (pmask == 0)
{
dp[mask] = fact[on_right[mask]];
EV[mask] = fact[on_right[mask]];
ans[mask] = fact[on_right[mask]] * (m - on_right[mask]) % MOD;
continue;
}
int cnt = on_right[mask] - on_right[pmask] - 1;
ll ways = cnk[on_right[mask]][on_right[pmask] + 1] * fact[on_right[mask] - on_right[pmask] - 1] % MOD;
ll dpways = dp[pmask] * ways % MOD;
dp[mask] = (dp[mask] + dpways) % MOD;
ll W = fact[cnt] * dp[pmask] % MOD;
ll SS1 = Supersigmacnkdec[on_right[pmask]][on_right[mask] - 1];
cnt_left = (cnt_left + SS1 * W) % MOD;
ll SS2 = supersigmacnkinc(on_right[pmask] + 1, on_right[pmask], on_right[mask] - 1);
summ_right = (summ_right + SS2 * fact[cnt] % MOD * (EV[pmask] + dp[pmask])) % MOD;
ll SS3 = Supersigmacnk[on_right[pmask]][on_right[mask] - 1];
ll SS4 = supersigmacnkinc(0, on_right[pmask], on_right[mask] - 1);
ans[mask] = (ans[mask] + ans[pmask] * fact[cnt] % MOD * SS3
+ (m - on_right[mask]) * W % MOD * SS3
- EV[pmask] * fact[cnt] % MOD * SS4
) % MOD;
if (ans[mask] < 0) ans[mask] += MOD;
}
}
if (__builtin_popcount(mask) > 1)
{
//cout << mask << " " << summ_right << " " << cnt_left << " " << cnt_right << "\n";
EV[mask] = (cnt_left + summ_right) * rev[on_right[mask] + 1] % MOD;
}
//cout << mask << " " << dp[mask] << " " << EV[mask] << " " << ans[mask] << "\n";
}
//cout << dp[M - 1] << "\n";
cout << ans[M - 1] << "\n";
}
}
/* Note:
Check constants at the beginning of the code (MOD, INF, INFLL)
Check corner cases.
N = 1
No def int long long for now.
Add something here.
*/
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int p = 1e9 + 7;
int qpow(int a, int n) {
int res = 1;
for (; n; n >>= 1, a = (ll)a * a % p) {
if (n & 1) {
res = (ll)res * a % p;
}
}
return res;
}
struct dsu_t: vector<int> {
dsu_t(int n) {
resize(n);
for (int i = 0; i < n; i++) {
at(i) = i;
}
}
int get_fa(int u) {
if (u != at(u)) {
at(u) = get_fa(at(u));
}
return at(u);
}
void merge(int u, int v) {
at(get_fa(u)) = get_fa(v);
}
};
int main() {
do {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
} while (false);
int n, m;
cin >> n >> m;
vector<int> a(m), b(m), go(n);
for (int i = 0; i < m; i++) {
cin >> a[i] >> b[i];
go[--a[i]] |= 1 << --b[i];
go[b[i]] |= 1 << a[i];
}
vector<int> pop_count(1 << n), all(1 << n), log2(1 << n);
for (int i = 0; i < n; i++) {
log2[1 << i] = i;
}
for (int mask = 1; mask < 1 << n; mask++) {
int low = mask & -mask;
pop_count[mask] = pop_count[mask ^ low] + 1;
all[mask] = all[mask ^ low] + pop_count[go[log2[low]] & mask];
}
vector<int> edge(1 << n - 1);
for (int mask = 0; mask < 1 << n - 1; mask++) {
dsu_t dsu(n);
for (int i = 0; i < n - 1; i++) {
if (mask & (1 << i)) {
dsu.merge(a[i], b[i]);
}
}
vector<int> component, belong(n);
for (int i = 0; i < n; i++) {
if (dsu[i] == i) {
belong[i] = component.size();
component.push_back(0);
}
}
for (int i = 0; i < n; i++) {
belong[i] = belong[dsu.get_fa(i)];
component[belong[i]] |= 1 << i;
}
for (int i = 0; i < component.size(); i++) {
edge[mask] += all[component[i]] - (pop_count[component[i]] - 1);
}
}
vector<int> fact(m + 1), ifac(m + 1);
fact[0] = 1;
for (int i = 1; i <= m; i++) {
fact[i] = (ll)fact[i - 1] * i % p;
}
ifac[m] = qpow(fact[m], p - 2);
for (int i = m; i > 0; i--) {
ifac[i - 1] = (ll)ifac[i] * i % p;
}
vector<pair<int, int> > dp(1 << n - 1);
vector<int> length(1 << n - 1);
dp[0].first = 1;
int full = (1 << n - 1) - 1;
for (int mask = 0; mask < 1 << n - 1; mask++) {
for (int i = 0; i < n - 1; i++) {
if (!(mask & (1 << i))) {
int k = edge[full ^ mask] - edge[full ^ mask ^ (1 << i)];
int nxt = mask | (1 << i);
length[nxt] = length[mask] + k + 1;
int count = (ll)dp[mask].first * fact[length[nxt] - 1] % p * ifac[length[mask]] % p;
int sum = (ll)dp[mask].second * fact[length[nxt]] % p * ifac[length[mask] + 1] % p;
sum = (sum + (ll)count * (pop_count[mask] + 1)) % p;
dp[nxt].first = (dp[nxt].first + count) % p;
dp[nxt].second = (dp[nxt].second + sum) % p;
}
}
}
cout << dp[full].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
int n, m; cin >> n >> m;
vector<vector<int>> adj(n);
vector<pair<int, int>> T(n - 1);
vector<pair<int, int>> B(m - n + 1);
int state = 0;
function<bool(int, int, int)> dfs = [&](int u, int p, int x) {
if (u == x) {
return true;
}
for (int e : adj[u]) {
int v = T[e].first ^ T[e].second ^ u;
if (v == p) {
continue;
}
if (dfs(v, u, x)) {
state |= 1 << e;
return true;
}
}
return false;
};
vector<int> cnt(1 << (n - 1), 0);
for (int i = 0; i < m; i++) {
int u, v; cin >> u >> v;
u--, v--;
if (i < n - 1) {
adj[u].push_back(i);
adj[v].push_back(i);
T[i] = {u, v};
} else {
state = 0;
assert(dfs(u, -1, v));
cnt[state]++;
}
}
for (int j = 0; j < n; j++) {
for (int i = 0; i < 1 << (n - 1); i++) {
if (i >> j & 1) {
cnt[i] += cnt[i - (1 << j)];
}
}
}
reverse(cnt.begin(), cnt.end());
vector<int> dp(1 << (n - 1));
vector<int> sum(1 << (n - 1));
dp[0] = 1, sum[0] = 0;
const int P = 1e9 + 7;
vector<vector<int>> prod(m + 2, vector<int>(m + 1, 1));
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= m; j++) {
prod[i][j] = j == 0 ? 1 : prod[i][j - 1] * 1LL * (i + j - 1) % P;
}
}
auto add = [&](int &x, int y) {
x = (x + y) % P;
};
for (int i = 0; i < 1 << (n - 1); i++) {
for (int j = 0; j < n - 1; j++) {
if (i >> j & 1) {
continue;
}
int prev = m - n + 1 - cnt[i] + __builtin_popcount(i);
int added = cnt[i] - cnt[i | (1 << j)];
add(dp[i | (1 << j)], dp[i] * 1LL * prod[prev + 1][added] % P);
add(sum[i | (1 << j)], (sum[i] * 1LL * prod[prev + 2][added] + dp[i] * 1LL * prod[prev + 1][added] % P * (__builtin_popcount(i) + 1)) % P);
}
}
cout << sum[(1 << (n - 1)) - 1] << endl;
return 0;
} |
/* cerberus97 - Hanit Banga */
#include <iostream>
#include <iomanip>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
using namespace std;
#define pb push_back
#define fast_cin() ios_base::sync_with_stdio(false); cin.tie(NULL)
typedef long long ll;
typedef long double ld;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;
const int N = 25, M = 200, S = (1 << 19) + 5;
const int mod = 1e9 + 7;
vector<pii> g[N];
int u[M], v[M], depth[N], par[N], up[N];
int dep[M];
int ctr[S];
ll ways[S], sum[S];
ll prod[M][M];
void dfs(int u, int p);
int main() {
// cout << (2 * sizeof(ways)) / 1e6 << endl;
// return 0;
fast_cin();
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> u[i] >> v[i];
if (i < n - 1) {
g[u[i]].pb({v[i], i});
g[v[i]].pb({u[i], i});
}
}
dfs(1, 0);
for (int i = n - 1; i < m; ++i) {
int eu = u[i], ev = v[i];
if (depth[eu] < depth[ev]) {
swap(eu, ev);
}
while (depth[eu] > depth[ev]) {
dep[i] |= (1 << up[eu]);
eu = par[eu];
}
while (eu != ev) {
dep[i] |= (1 << up[eu]);
dep[i] |= (1 << up[ev]);
eu = par[eu];
ev = par[ev];
}
++ctr[dep[i]];
}
int subsets = (1 << (n - 1)), all = subsets - 1;
// for (int mask = 0; mask < subsets; ++mask) {
// cout << ctr[mask] << endl;
// }
for (int i = 0; i < n - 1; ++i) {
for (int mask = 0; mask < subsets; ++mask) {
if (mask & (1 << i)) {
ctr[mask] += ctr[mask ^ (1 << i)];
}
}
}
// for (int mask = 0; mask < subsets; ++mask) {
// cout << ctr[mask] << endl;
// }
ll all_sum = m - (n - 1);
for (int mask = 0, comp = all; mask < comp; ++mask, --comp) {
swap(ctr[mask], ctr[comp]);
ctr[mask] = all_sum - ctr[mask];
ctr[comp] = all_sum - ctr[comp];
}
for (int i = 1; i < M; ++i) {
prod[i][i - 1] = 1;
for (int j = i; j < M; ++j) {
prod[i][j] = prod[i][j - 1] * j;
prod[i][j] %= mod;
}
}
ways[0] = 1;
for (int mask = 0; mask < subsets; ++mask) {
// cout << mask << ' ' << ways[mask] << ' ' << sum[mask] << ' ' << ctr[mask] << endl;
// cout << mask << ' ' << ctr[mask] << endl;
int b = __builtin_popcount(mask), tot = ctr[mask] + b;
for (int i = 0; i < n - 1; ++i) {
if (mask & (1 << i)) {
continue;
}
int new_mask = mask | (1 << i);
int k = ctr[new_mask] - ctr[mask];
ll temp = prod[tot + 1][tot + k] * ways[mask];
temp %= mod;
ways[new_mask] += temp;
ways[new_mask] %= mod;
sum[new_mask] += prod[tot + 2][tot + k + 1] * sum[mask];
sum[new_mask] += temp * (b + 1);
sum[new_mask] %= mod;
}
}
cout << sum[all] << endl;
}
void dfs(int u, int p) {
for (auto &e : g[u]) {
int v = e.first, id = e.second;
if (v != p) {
depth[v] = depth[u] + 1;
par[v] = u;
up[v] = id;
dfs(v, u);
}
}
} |
#include<bits/stdc++.h>
using namespace std;
const int maxn=1010,mod=1000000007;
inline void Add(int &a,int b){a=a+b>=mod?a+b-mod:a+b;}
inline int ksm(int a,int b)
{
int res=1;
for(;b;b>>=1,a=1ll*a*a%mod) if(b&1) res=1ll*res*a%mod;
return res;
}
int fac[maxn],invfac[maxn];
inline int C(int n,int m){return 1ll*fac[n]*invfac[m]%mod*invfac[n-m]%mod;}
int ans=0,n,m,a[maxn],b[maxn],out[maxn],e[1<<20],f[1<<20],sumf[1<<20];
int bitcnt[1<<20],fa[maxn],col[1<<20][21],c[maxn],num[1<<20],len[1<<20];
inline int find(int x){return x==fa[x]?x:fa[x]=find(fa[x]);}
int main()
{
for(int i=fac[0]=1;i<maxn;i++) fac[i]=1ll*fac[i-1]*i%mod;
invfac[maxn-1]=ksm(fac[maxn-1],mod-2);
for(int i=maxn-2;i>=0;i--) invfac[i]=1ll*invfac[i+1]*(i+1)%mod;
for(int i=1;i<(1<<20);i++) bitcnt[i]=bitcnt[i&(i-1)]+1;
scanf("%d%d",&n,&m);
for(int i=0;i<m;i++) scanf("%d%d",a+i,b+i),a[i]--,b[i]--;
for(int i=0;i<m;i++) out[a[i]]|=1<<b[i],out[b[i]]|=1<<a[i];
for(int i=0;i<(1<<n);i++) for(int j=0;j<n;j++) if((i>>j)&1)
{e[i]=e[i^(1<<j)]+bitcnt[out[j]&i];break;}
int all=(1<<(n-1))-1;
for(int i=0;i<=all;i++)
{
for(int j=0;j<n;j++) fa[j]=j;
for(int j=0;j<n-1;j++) if((i>>j)&1) fa[find(a[j])]=find(b[j]);
int tot=0;
for(int j=0;j<n;j++) if(find(j)==j) col[i][j]=++tot,c[tot]=0;
for(int j=0;j<n;j++) col[i][j]=col[i][find(j)],c[col[i][j]]|=1<<j;
for(int j=1;j<=tot;j++) num[i]+=e[c[j]]-bitcnt[c[j]]+1;
}
f[0]=1;
for(int i=0;i<=all;i++) for(int j=0;j<n-1;j++) if(!((i>>j)&1))
{
int a=num[all^i]-num[all^i^(1<<j)],nxt=i|(1<<j);len[nxt]=len[i]+a+1;
int getf=1ll*f[i]*fac[len[i]+a]%mod*invfac[len[i]]%mod;
int getsum=(1ll*getf*(bitcnt[i]+1)%mod+1ll*sumf[i]*fac[len[i]+a+1]%mod*invfac[len[i]+1]%mod)%mod;
Add(f[nxt],getf);Add(sumf[nxt],getsum);
}
printf("%d\n",sumf[all]);
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int p = 1e9 + 7;
int qpow(int a, int n) {
int res = 1;
for (; n; n >>= 1, a = (ll)a * a % p) {
if (n & 1) {
res = (ll)res * a % p;
}
}
return res;
}
struct dsu_t {
vector<int> fa;
dsu_t(int n) {
fa.resize(n);
for (int i = 0; i < n; i++) {
fa[i] = i;
}
}
int get_fa(int u) {
if (u != fa[u]) {
fa[u] = get_fa(fa[u]);
}
return fa[u];
}
void merge(int u, int v) {
fa[get_fa(u)] = get_fa(v);
}
bool same(int u, int v) {
return get_fa(u) == get_fa(v);
}
};
int main() {
do {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
} while (false);
int n, m;
cin >> n >> m;
vector<int> eu(m), ev(m);
for (int i = 0; i < m; i++) {
cin >> eu[i] >> ev[i];
eu[i]--;
ev[i]--;
}
int tree = n - 1;
vector<int> edge(1 << tree);
for (int mask = 0; mask < (1 << tree); mask++) {
dsu_t dsu(n);
for (int i = 0; i < tree; i++) {
if (mask & (1 << i)) {
dsu.merge(eu[i], ev[i]);
}
}
for (int i = tree; i < m; i++) {
if (dsu.same(eu[i], ev[i])) {
edge[mask]++;
}
}
}
vector<int> fact(m + 1);
fact[0] = 1;
for (int i = 1; i <= m; i++) {
fact[i] = (ll)fact[i - 1] * i % p;
}
vector<int> ifac(m + 1);
ifac[m] = qpow(fact[m], p - 2);
for (int i = m; i > 0; i--) {
ifac[i - 1] = (ll)ifac[i] * i % p;
}
vector<int> ways(1 << tree), sum(1 << tree), count(1 << tree);
ways[0] = 1;
for (int mask = 0; mask < (1 << tree); mask++) {
for (int i = 0; i < tree; i++) {
if (!(mask & (1 << i))) {
int next = mask | (1 << i);
int white = edge[((1 << tree) - 1) ^ mask] - edge[((1 << tree) - 1) ^ next];
count[next] = count[mask] + white + 1;
ways[next] = (ways[next] + (ll)ways[mask] * fact[count[next] - 1] % p * ifac[count[mask]]) % p;
sum[next] = (sum[next] + (ll)ways[mask] * fact[count[next] - 1] % p * ifac[count[mask]] % p * __builtin_popcount(next) + (ll)sum[mask] * fact[count[next]] % p * ifac[count[mask] + 1]) % p;
}
}
}
cout << sum[(1 << tree) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define f(i, x, n) for (int i = x; i < (int)(n); ++i)
int const N = 20, M = 190, md = 1e9 + 7;
pair<int, int> dp[1 << N - 1];
int edm[M], nn[M + 2][M + 2], fr[1 << N - 1];
vector<pair<int, int> > tr[N + 1];
inline void ad(int &x, int y) { if ((x += y) >= md)x -= md; }
inline int bc(int x){
int an = 0;
while (x){
++an;
x ^= x & -x;
}
return an;
}
int ta;
int go(int v, int p = 0){
if (v == ta)return 0;
f(i, 0, tr[v].size()){
int u = tr[v][i].first, id = tr[v][i].second;
if (u == p)continue;
int t = go(u, v);
if (t == -1)continue;
return t | 1 << id;
}
return -1;
}
int main(){
int n, m;
scanf("%d%d", &n, &m);
f(i, 1, m + 2){
nn[i][i] = i;
f(j, i + 1, m + 2)nn[i][j] = (ll)nn[i][j - 1] * j % md;
}
f(i, 0, m){
int a, b;
scanf("%d%d", &a, &b);
if (i < n - 1){
tr[a].push_back(make_pair(b, i));
tr[b].push_back(make_pair(a, i));
}else {
ta = b;
edm[i] = go(a);
}
}
f(i, n - 1, m)f(j, 0, 1 << n - 1)if (j & edm[i])++fr[j];
dp[0] = make_pair(1, 0);
f(i, 0, 1 << n - 1)f(j, 0, n - 1)if (!(i >> j & 1)){
int b = bc(i), n = b + fr[i], c = dp[i].first, s = dp[i].second, ni = i | 1 << j, k = fr[ni] - fr[i];
if (k){
c = (ll)c * nn[n + 1][n + k] % md;
s = (ll)s * nn[n + 2][n + 1 + k] % md;
}
ad(s, (ll)(b + 1) * c % md);
ad(dp[ni].first, c);
ad(dp[ni].second, s);
}
printf("%d\n", dp[(1 << n - 1) - 1].second);
} |
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
const long long INFLL = 1e18;
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vector<int> > vvi;
typedef vector<ll> vll;
typedef complex<double> cd;
#define forn(i, n) for (int (i) = 0; (i) != (n); (i)++)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define popcount(x) __builtin_popcount(x)
#define popcountll(x) __builtin_popcountll(x)
#define fi first
#define se second
#define re return
#define pb push_back
#define uniq(x) sort(all(x)); (x).resize(unique(all(x)) - (x).begin())
#ifdef LOCAL
#define dbg(x) cerr << __LINE__ << " " << #x << " " << x << endl
#define ln cerr << __LINE__ << endl
#else
#define dbg(x) void(0)
#define ln void(0)
#endif // LOCAL
int cx[4] = {-1, 0, 1, 0};
int cy[4] = {0, -1, 0, 1};
string Yes[2] = {"No\n", "Yes\n"};
string YES[2] = {"NO\n", "YES\n"};
string Possible[2] = {"Impossible\n", "Possible\n"};
string POSSIBLE[2] = {"IMPOSSIBLE\n", "POSSIBLE\n"};
int ok(int x, int n)
{
return 0 <= x && x < n;
}
ll log10(ll x)
{
if (x < 10) re 1;
re 1 + log10(x / 10);
}
ll ds(ll x)
{
if (x < 10) return x;
re x % 10 + ds(x / 10);
}
double sqr(double x)
{
return x * x;
}
bool inmask(int bit, int mask)
{
return (mask & (1 << bit)) > 0;
}
void Del(vector<int> &v, int pos)
{
swap(v[pos], v[v.size() - 1]);
v.pop_back();
}
long long g(vector<long long> &p, int pos)
{
if (ok(pos, p.size())) return p[pos];
if (pos < 0 || p.size() == 0) return 0;
return p.back();
}
int g(vector<int> &p, int pos)
{
if (ok(pos, p.size())) return p[pos];
if (pos < 0 || p.size() == 0) return 0;
return p.back();
}
ll inq(ll x, ll y)
{
if (!y) re 1 % MOD;
ll l = inq(x, y / 2);
if (y % 2) re l * l % MOD * x % MOD;
re l * l % MOD;
}
ll rev(ll x)
{
return inq(x, MOD - 2);
}
int __precomputed_combinatorics = 0;
vector<ll> __fact, __ufact, __rev;
inline void __precompute_combinatorics(int __n)
{
if (__precomputed_combinatorics >= __n)
return;
__fact.resize(__n);
__ufact.resize(__n);
__rev.resize(__n);
__rev[1] = 1;
for (int i = max(2, __precomputed_combinatorics); i < __n; i++)
__rev[i] = MOD - __rev[MOD % i] * (MOD / i) % MOD;
__fact[0] = 1, __ufact[0] = 1;
for (int i = max(1, __precomputed_combinatorics); i < __n; i++)
__fact[i] = __fact[i - 1] * i % MOD, __ufact[i] = __ufact[i - 1] * __rev[i] % MOD;
__precomputed_combinatorics = __n;
}
ll fact(int x)
{
if (__precomputed_combinatorics <= x)
__precompute_combinatorics(x + 1);
return __fact[x];
}
ll cnk(int n, int k)
{
if (k < 0 || k > n)
return 0;
if (__precomputed_combinatorics <= n)
__precompute_combinatorics(n + 1);
return __fact[n] * __ufact[n - k] % MOD * __ufact[k] % MOD;
}
ll inq(ll x, ll y, ll mod)
{
if (y == 0) return 1 % mod;
ll l = inq(x, y / 2, mod);
if (y % 2) return l * l % mod * x % mod;
return l * l % mod;
}
void dfs(int v, int par, vector<int> &h, vector<int> &edge_in, vector<int> &a, vector<int> &b)
{
if (v == par) h[v] = 0;
else h[v] = h[par] + 1;
for (int i = 0; i < h.size() - 1; i++)
{
if (a[i] == v || b[i] == v)
{
int u = a[i] + b[i] - v;
if (u != par)
{
edge_in[u] = i;
dfs(u, v, h, edge_in, a, b);
}
}
}
}
int mark(int v, int u, vector<int> &h, vector<int> &edge_in, vector<int> &a, vector<int> &b)
{
int mask = 0;
while (h[v] > h[u])
{
mask += 1 << edge_in[v];
int f = a[edge_in[v]] + b[edge_in[v]] - v;
v = f;
}
while (h[v] < h[u])
{
mask += 1 << edge_in[u];
int f = a[edge_in[u]] + b[edge_in[u]] - u;
u = f;
}
while (v != u)
{
mask += 1 << edge_in[v];
int f = a[edge_in[v]] + b[edge_in[v]] - v;
v = f;
mask += 1 << edge_in[u];
f = a[edge_in[u]] + b[edge_in[u]] - u;
u = f;
}
return mask;
}
ll supersigmacnkdec(ll i, ll k, ll n)
{
ll ans = 0;
for (int j = k; j <= n; j++)
{
ans = (ans + (n - j + i) * cnk(j, k)) % MOD;
}
return ans;
}
ll supersigmacnkinc(ll i, ll k, ll n)
{
ll ans = 0;
for (int j = k; j <= n; j++)
{
ans = (ans + (i + j - k) * cnk(j, k)) % MOD;
}
return ans;
}
ll supersigmacnk(ll k, ll n)
{
ll ans = 0;
for (int j = k; j <= n; j++)
{
ans = (ans + cnk(j, k)) % MOD;
}
return ans;
}
signed main()
{
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<int> a(m), b(m);
for (int i = 0; i < m; i++)
{
cin >> a[i] >> b[i];
a[i]--, b[i]--;
}
vector<int> h(n), edge_in(n);
dfs(0, 0, h, edge_in, a, b);
vector<int> suba(m);
for (int i = n - 1; i < m; i++)
{
int z = mark(a[i], b[i], h, edge_in, a, b);
suba[i] = z;
}
int M = 1 << (n - 1);
{
vector<ll> on_right(M, 0);
for (int mask = 1; mask < M; mask++)
{
for (int i = n - 1; i < m; i++)
{
if (suba[i] & mask)
{
on_right[mask]++;
}
}
on_right[mask] += __builtin_popcount(mask) - 1;
}
vector<ll> dp(M);
vector<ll> EV(M);
vector<ll> ans(M);
on_right[0] = -1;
dp[0] = 1;
for (int mask = 1; mask < M; mask++)
{
ll summ_right = 0, cnt_left = 0, cnt_right = 0;
for (int p = 0; p < n - 1; p++)
{
if (mask & (1 << p))
{
int pmask = mask - (1 << p);
if (pmask == 0)
{
dp[mask] = fact(on_right[mask]);
EV[mask] = 1;
ans[mask] = fact(on_right[mask]) * (m - on_right[mask]) % MOD;
continue;
}
int cnt = on_right[mask] - on_right[pmask] - 1;
ll ways = cnk(on_right[mask], on_right[pmask] + 1) * fact(on_right[mask] - on_right[pmask] - 1) % MOD;
ll dpways = dp[pmask] * ways % MOD;
dp[mask] = (dp[mask] + dpways) % MOD;
ll W = fact(cnt) * dp[pmask] % MOD;
ll SS1 = supersigmacnkdec(1, on_right[pmask], on_right[mask] - 1);
cnt_left = (cnt_left + SS1 * W) % MOD;
ll SS2 = supersigmacnkinc(on_right[pmask] + 1, on_right[pmask], on_right[mask] - 1);
cnt_right = (cnt_right + SS2 * W) % MOD;
summ_right = (summ_right + SS2 * W % MOD * (EV[pmask] + 1)) % MOD;
ll SS3 = supersigmacnk(on_right[pmask], on_right[mask] - 1);
ll SS4 = supersigmacnkinc(0, on_right[pmask], on_right[mask] - 1);
ans[mask] = (ans[mask] + ans[pmask] * fact(cnt) % MOD * SS3
+ (m - on_right[mask]) * W % MOD * SS3
- EV[pmask] * W % MOD * SS4
) % MOD;
if (ans[mask] < 0) ans[mask] += MOD;
}
}
if (__builtin_popcount(mask) > 1)
{
//cout << mask << " " << summ_left << " " << summ_right << " " << cnt_left << " " << cnt_right << "\n";
EV[mask] = (cnt_left + summ_right) * inq(cnt_left + cnt_right, MOD - 2) % MOD;
}
//cout << mask << " " << dp[mask] << " " << EV[mask] << " " << ans[mask] << "\n";
}
//cout << dp[M - 1] << "\n";
cout << ans[M - 1] << "\n";
}
}
/* Note:
Check constants at the beginning of the code (MOD, INF, INFLL)
Check corner cases.
N = 1
No def int long long for now.
Add something here.
*/
|
#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#include <cstring>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cmath>
#include <list>
#include <cassert>
#include <ctime>
#include <climits>
using namespace std;
#define PB push_back
#define MP make_pair
#define SZ(v) ((int)(v).size())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FORE(i,a,b) for(int i=(a);i<=(b);++i)
#define REPE(i,n) FORE(i,0,n)
#define FORSZ(i,a,v) FOR(i,a,SZ(v))
#define REPSZ(i,v) REP(i,SZ(v))
typedef long long ll;
typedef unsigned long long ull;
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a%b); }
const int MAXN=20;
const int MAXM=MAXN*(MAXN-1)/2;
const int MAXT=MAXN-1;
const int MOD=1000000007;
void inc(int &a,int b) { if((a+=b)>=MOD) a-=MOD; }
int n,m;
int e[MAXM][2];
vector<pair<int,int>> tadj[MAXN];
// mask indicates which tree-edges have values, a component is a maximal set of nodes connected by tree-edges without values
int nt;
int ways[1<<MAXT]; // ways[mask] = number of ways to give values to all edges connecting different components, assuming all tree-edges within a component get lower values
int sum[1<<MAXT]; // sum[mask] = sum of tree edges over all ways
int q[MAXN],qhead,qtail;
int cntnontree[1<<MAXT];
int prod[MAXM+1][MAXM+1];
int solve() {
nt=n-1;
REP(mask,1<<nt) cntnontree[mask]=0;
FOR(i,nt,m) {
qtail=qhead=0; vector<int> pathmask(n,-1);
int s=e[i][0],t=e[i][1]; pathmask[s]=0,q[qhead++]=s;
while(qtail<qhead) { int at=q[qtail++]; REPSZ(j,tadj[at]) { int to=tadj[at][j].first,id=tadj[at][j].second; if(pathmask[to]==-1) pathmask[to]=pathmask[at]|(1<<id),q[qhead++]=to; } }
++cntnontree[(1<<nt)-1-pathmask[t]];
}
REP(j,nt) REP(mask,1<<nt) if((mask&(1<<j))!=0) cntnontree[mask-(1<<j)]+=cntnontree[mask];
REP(mask,1<<nt) cntnontree[mask]=m-nt-cntnontree[mask];
REPE(i,MAXM) { prod[i][i]=i; FORE(j,i+1,MAXM) prod[i][j]=(ll)prod[i][j-1]*j%MOD; }
ways[0]=1,sum[0]=0;
FOR(mask,1,1<<nt) {
ways[mask]=0,sum[mask]=0;
int treecnt=0; REP(i,nt) if((mask&(1<<i))!=0) ++treecnt;
REP(i,nt) if(mask&(1<<i)) { // i is the tree edge in mask with the lowest value
int nmask=mask^(1<<i),cways=ways[nmask],csum=sum[nmask];
// we also need to assign the non-tree-edges that will be in different components
int nontreecnt=cntnontree[nmask],deltanontreecnt=cntnontree[mask]-cntnontree[nmask];
if(deltanontreecnt>=1) {
csum=(ll)csum*prod[treecnt+nontreecnt+1][treecnt+nontreecnt+deltanontreecnt]%MOD;
cways=(ll)cways*prod[treecnt+nontreecnt][treecnt+nontreecnt+deltanontreecnt-1]%MOD;
}
csum=(csum+(ll)cways*(1+treecnt-1))%MOD;
inc(ways[mask],cways); inc(sum[mask],csum);
//printf("%x %d-%d: %d %d (%d,%d,%d)\n",mask,e[i][0]+1,e[i][1]+1,cways,csum,treecnt,nontreecnt,deltanontreecnt);
}
}
return sum[(1<<nt)-1];
}
void run() {
scanf("%d%d",&n,&m);
REP(i,m) { int a,b; scanf("%d%d",&a,&b); --a,--b; e[i][0]=a,e[i][1]=b; if(i<n-1) tadj[a].PB(MP(b,i)),tadj[b].PB(MP(a,i)); }
printf("%d\n",solve());
}
void stress() {
REP(rep,100) {
n=MAXN,m=MAXM;
REP(i,n-1) e[i][0]=0,e[i][1]=i+1;
set<pair<int,int>> seen; FOR(i,n-1,m) while(true) { int a=rand()%(n-1)+1,b=rand()%(n-1)+1; if(a>b) swap(a,b); if(seen.count(MP(a,b))) continue; e[i][0]=a,e[i][1]=b; seen.insert(MP(a,b)); break; }
REP(i,n) tadj[i].clear(); REP(i,n-1) { int a=e[i][0],b=e[i][1]; tadj[a].PB(MP(b,i)); tadj[b].PB(MP(a,i)); }
int have=solve();
printf(".");
}
}
int main() {
run();
//stress();
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x,to) for(x=0;x<(to);x++)
#define FORR(x,arr) for(auto& x:arr)
#define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
#define ALL(a) (a.begin()),(a.end())
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
//-------------------------------------------------------
int N,M;
int A[400],B[400];
vector<int> E[20];
vector<int> path[20][20];
int rev[20][20];
int ne[1<<20];
ll C[1<<20],S[1<<20];
ll mo=1000000007;
const int NUM_=400001;
static ll fact[NUM_+1],factr[NUM_+1],inv[NUM_+1];
ll modpow(ll a, ll n = mo-2) {
ll r=1;a%=mo;
while(n) r=r*((n%2)?a:1)%mo,a=a*a%mo,n>>=1;
return r;
}
ll comb(ll N_, ll C_) {
if(C_<0 || C_>N_) return 0;
return factr[C_]*fact[N_]%mo*factr[N_-C_]%mo;
}
void solve() {
int i,j,k,l,r,x,y; string s;
inv[1]=fact[0]=factr[0]=1;
for (int i=2;i<=NUM_;++i) inv[i] = inv[mo % i] * (mo - mo / i) % mo;
for (int i=1;i<=NUM_;++i) fact[i]=fact[i-1]*i%mo, factr[i]=factr[i-1]*inv[i]%mo;
MINUS(rev);
cin>>N>>M;
FOR(i,M) {
cin>>A[i]>>B[i];
A[i]--;
B[i]--;
if(i<N-1) {
E[A[i]].push_back(B[i]);
E[B[i]].push_back(A[i]);
}
rev[A[i]][B[i]]=rev[B[i]][A[i]]=i;
}
FOR(i,N) {
path[i][i].push_back(i);
queue<int> Q;
Q.push(i);
while(Q.size()) {
x=Q.front();
Q.pop();
FORR(e,E[x]) if(path[i][e].empty()) {
path[i][e]=path[i][x];
path[i][e].push_back(e);
Q.push(e);
}
}
}
FOR(i,M) {
int mask=0;
FOR(j,path[A[i]][B[i]].size()-1) mask |= 1<<(rev[path[A[i]][B[i]][j]][path[A[i]][B[i]][j+1]]);
ne[mask]++;
}
FOR(i,N-1) FOR(j,1<<(N-1)) if(j&(1<<i)) ne[j]+=ne[j^(1<<i)];
C[(1<<(N-1))-1]=1;
int mask;
for(int mask=(1<<(N-1))-1;mask>0;mask--) {
int num=(N-1)-__builtin_popcount(mask);
FOR(j,N-1) if((mask&(1<<j))) {
int CN=M-ne[mask];
int W=ne[mask]-ne[mask^(1<<j)]-1;
ll wc=C[mask]*fact[CN+W]%mo*factr[CN]%mo;
ll ws=S[mask]*fact[CN+W+1]%mo*factr[CN+1]%mo;
(C[mask^(1<<j)]+=wc)%=mo;
(S[mask^(1<<j)]+=ws+(num+1)*wc)%=mo;
}
}
cout<<S[0]<<endl;
}
int main(int argc,char** argv){
string s;int i;
if(argc==1) ios::sync_with_stdio(false), cin.tie(0);
FOR(i,argc-1) s+=argv[i+1],s+='\n'; FOR(i,s.size()) ungetc(s[s.size()-1-i],stdin);
cout.tie(0); solve(); return 0;
}
|
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
const long long INFLL = 1e18;
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vector<int> > vvi;
typedef vector<ll> vll;
typedef complex<double> cd;
#define forn(i, n) for (int (i) = 0; (i) != (n); (i)++)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define popcount(x) __builtin_popcount(x)
#define popcountll(x) __builtin_popcountll(x)
#define fi first
#define se second
#define re return
#define pb push_back
#define uniq(x) sort(all(x)); (x).resize(unique(all(x)) - (x).begin())
#ifdef LOCAL
#define dbg(x) cerr << __LINE__ << " " << #x << " " << x << endl
#define ln cerr << __LINE__ << endl
#else
#define dbg(x) void(0)
#define ln void(0)
#endif // LOCAL
int cx[4] = {-1, 0, 1, 0};
int cy[4] = {0, -1, 0, 1};
string Yes[2] = {"No\n", "Yes\n"};
string YES[2] = {"NO\n", "YES\n"};
string Possible[2] = {"Impossible\n", "Possible\n"};
string POSSIBLE[2] = {"IMPOSSIBLE\n", "POSSIBLE\n"};
int ok(int x, int n)
{
return 0 <= x && x < n;
}
ll log10(ll x)
{
if (x < 10) re 1;
re 1 + log10(x / 10);
}
ll ds(ll x)
{
if (x < 10) return x;
re x % 10 + ds(x / 10);
}
double sqr(double x)
{
return x * x;
}
bool inmask(int bit, int mask)
{
return (mask & (1 << bit)) > 0;
}
void Del(vector<int> &v, int pos)
{
swap(v[pos], v[v.size() - 1]);
v.pop_back();
}
long long g(vector<long long> &p, int pos)
{
if (ok(pos, p.size())) return p[pos];
if (pos < 0 || p.size() == 0) return 0;
return p.back();
}
int g(vector<int> &p, int pos)
{
if (ok(pos, p.size())) return p[pos];
if (pos < 0 || p.size() == 0) return 0;
return p.back();
}
ll inq(ll x, ll y)
{
if (!y) re 1 % MOD;
ll l = inq(x, y / 2);
if (y % 2) re l * l % MOD * x % MOD;
re l * l % MOD;
}
ll rev(ll x)
{
return inq(x, MOD - 2);
}
int __precomputed_combinatorics = 0;
vector<ll> __fact, __ufact, __rev;
inline void __precompute_combinatorics(int __n)
{
if (__precomputed_combinatorics >= __n)
return;
__fact.resize(__n);
__ufact.resize(__n);
__rev.resize(__n);
__rev[1] = 1;
for (int i = max(2, __precomputed_combinatorics); i < __n; i++)
__rev[i] = MOD - __rev[MOD % i] * (MOD / i) % MOD;
__fact[0] = 1, __ufact[0] = 1;
for (int i = max(1, __precomputed_combinatorics); i < __n; i++)
__fact[i] = __fact[i - 1] * i % MOD, __ufact[i] = __ufact[i - 1] * __rev[i] % MOD;
__precomputed_combinatorics = __n;
}
ll fact(int x)
{
if (__precomputed_combinatorics <= x)
__precompute_combinatorics(x + 1);
return __fact[x];
}
ll cnk(int n, int k)
{
if (k < 0 || k > n)
return 0;
if (__precomputed_combinatorics <= n)
__precompute_combinatorics(n + 1);
return __fact[n] * __ufact[n - k] % MOD * __ufact[k] % MOD;
}
ll inq(ll x, ll y, ll mod)
{
if (y == 0) return 1 % mod;
ll l = inq(x, y / 2, mod);
if (y % 2) return l * l % mod * x % mod;
return l * l % mod;
}
void dfs(int v, int par, vector<int> &h, vector<int> &edge_in, vector<int> &a, vector<int> &b)
{
if (v == par) h[v] = 0;
else h[v] = h[par] + 1;
for (int i = 0; i < h.size() - 1; i++)
{
if (a[i] == v || b[i] == v)
{
int u = a[i] + b[i] - v;
if (u != par)
{
edge_in[u] = i;
dfs(u, v, h, edge_in, a, b);
}
}
}
}
int mark(int v, int u, vector<int> &h, vector<int> &edge_in, vector<int> &a, vector<int> &b)
{
int mask = 0;
while (h[v] > h[u])
{
mask += 1 << edge_in[v];
int f = a[edge_in[v]] + b[edge_in[v]] - v;
v = f;
}
while (h[v] < h[u])
{
mask += 1 << edge_in[u];
int f = a[edge_in[u]] + b[edge_in[u]] - u;
u = f;
}
while (v != u)
{
mask += 1 << edge_in[v];
int f = a[edge_in[v]] + b[edge_in[v]] - v;
v = f;
mask += 1 << edge_in[u];
f = a[edge_in[u]] + b[edge_in[u]] - u;
u = f;
}
return mask;
}
const int N = 209;
ll Supersigmacnk[N][N];
ll Supersigmacnkdec[N][N];
ll Supersigmacnkinc[N][N];
ll supersigmacnkdec(ll i, ll k, ll n)
{
ll ans = Supersigmacnk[k][n] * (i + MOD - 1) % MOD;
ans = (ans + Supersigmacnkdec[k][n]) % MOD;
return ans;
}
ll supersigmacnkinc(ll i, ll k, ll n)
{
ll ans = Supersigmacnk[k][n] * i % MOD;
ans = (ans + Supersigmacnkinc[k][n]) % MOD;
return ans;
}
signed main()
{
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cnk(N, N);
for (int k = 0; k < N; k++)
{
for (int n = k; n < N; n++)
{
Supersigmacnk[k][n] = (Supersigmacnk[k][n - 1] + cnk(n, k)) % MOD;
Supersigmacnkdec[k][n] = (Supersigmacnkdec[k][n - 1] + Supersigmacnk[k][n]) % MOD;
Supersigmacnkinc[k][n] = (Supersigmacnkinc[k][n - 1] + (n - k) * cnk(n, k)) % MOD;
}
}
int n, m;
cin >> n >> m;
vector<int> a(m), b(m);
for (int i = 0; i < m; i++)
{
cin >> a[i] >> b[i];
a[i]--, b[i]--;
}
vector<int> h(n), edge_in(n);
dfs(0, 0, h, edge_in, a, b);
vector<int> suba(m);
for (int i = n - 1; i < m; i++)
{
int z = mark(a[i], b[i], h, edge_in, a, b);
suba[i] = z;
}
int M = 1 << (n - 1);
{
vector<ll> on_right(M, 0);
for (int mask = 1; mask < M; mask++)
{
for (int i = n - 1; i < m; i++)
{
if (suba[i] & mask)
{
on_right[mask]++;
}
}
on_right[mask] += __builtin_popcount(mask) - 1;
}
vector<ll> dp(M);
vector<ll> EV(M);
vector<ll> ans(M);
on_right[0] = -1;
dp[0] = 1;
for (int mask = 1; mask < M; mask++)
{
ll summ_right = 0, cnt_left = 0, cnt_right = 0;
for (int p = 0; p < n - 1; p++)
{
if (mask & (1 << p))
{
int pmask = mask - (1 << p);
if (pmask == 0)
{
dp[mask] = fact(on_right[mask]);
EV[mask] = 1;
ans[mask] = fact(on_right[mask]) * (m - on_right[mask]) % MOD;
continue;
}
int cnt = on_right[mask] - on_right[pmask] - 1;
ll ways = cnk(on_right[mask], on_right[pmask] + 1) * fact(on_right[mask] - on_right[pmask] - 1) % MOD;
ll dpways = dp[pmask] * ways % MOD;
dp[mask] = (dp[mask] + dpways) % MOD;
ll W = fact(cnt) * dp[pmask] % MOD;
ll SS1 = supersigmacnkdec(1, on_right[pmask], on_right[mask] - 1);
cnt_left = (cnt_left + SS1 * W) % MOD;
ll SS2 = supersigmacnkinc(on_right[pmask] + 1, on_right[pmask], on_right[mask] - 1);
cnt_right = (cnt_right + SS2 * W) % MOD;
summ_right = (summ_right + SS2 * W % MOD * (EV[pmask] + 1)) % MOD;
ll SS3 = Supersigmacnk[on_right[pmask]][on_right[mask] - 1];
ll SS4 = supersigmacnkinc(0, on_right[pmask], on_right[mask] - 1);
ans[mask] = (ans[mask] + ans[pmask] * fact(cnt) % MOD * SS3
+ (m - on_right[mask]) * W % MOD * SS3
- EV[pmask] * W % MOD * SS4
) % MOD;
if (ans[mask] < 0) ans[mask] += MOD;
}
}
if (__builtin_popcount(mask) > 1)
{
//cout << mask << " " << summ_left << " " << summ_right << " " << cnt_left << " " << cnt_right << "\n";
EV[mask] = (cnt_left + summ_right) * inq(cnt_left + cnt_right, MOD - 2) % MOD;
}
//cout << mask << " " << dp[mask] << " " << EV[mask] << " " << ans[mask] << "\n";
}
//cout << dp[M - 1] << "\n";
cout << ans[M - 1] << "\n";
}
}
/* Note:
Check constants at the beginning of the code (MOD, INF, INFLL)
Check corner cases.
N = 1
No def int long long for now.
Add something here.
*/
|
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline", "fast-math", "unroll-loops", "no-stack-protector")
#pragma GCC diagnostic error "-fwhole-program"
#pragma GCC diagnostic error "-fcse-skip-blocks"
#pragma GCC diagnostic error "-funsafe-loop-optimizations"
#include<cstdio>
#include<algorithm>
#include<vector>
#include<map>
#include<queue>
#include<cstring>
#define ll long long
using namespace std;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c, qu[55];
int f, qr;
#define gc() (iS == iT ? (iT = (iS = ibuf) + fread (ibuf, 1, SIZE, stdin), (iS == iT ? EOF : *iS ++)) : *iS ++)
inline void flush () {
fwrite (obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc (char x) {
*oS ++ = x;
if (oS == oT) flush ();
}
template<class T>
inline void getc(T &x)
{
for(c=gc();!((c>='a'&&c<='z')||(c>='A'&&c<='Z'));c=gc());
x=c;
}
template <class I>
inline void rd (I &x) {
for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;
for (x = 0; c <= '9' && c >= '0'; c = gc()) x = x * 10 + (c & 15);
x *= f;
}
template <class I>
inline void print (I x) {
if (!x) putc ('0');
if (x < 0) putc ('-'), x = -x;
while (x) qu[++ qr] = x % 10 + '0', x /= 10;
while (qr) putc (qu[qr --]);
}
struct Flusher_ {
~Flusher_() {
flush();
}
} io_flusher_;
}
using io :: rd;
using io :: putc;
using io :: print;
using io :: getc;
const int MOD=1e9+7;
int mo(int x,int y)
{
return x+y>=MOD?x+y-MOD:x+y;
}
int mu(int x,int y)
{
return (ll)x*y%MOD;
}
int sub(int x,int y)
{
return x<y?x-y+MOD:x-y;
}
int ksm(int x,int y)
{
int res=1;
for(;y;y>>=1,x=mu(x,x))
if(y&1) res=mu(res,x);
return res;
}
const int MAXN=200+5;
pair<int,int>e[MAXN];
vector<int>g[MAXN];
int n,m;
ll dp[2][(1<<20)|1],sum[2][(1<<20)|1];
int els[(1<<20)|1],bin[(1<<20)|1],dep[MAXN],fa[MAXN],id[(1<<20)|1];
void dfs(int x,int ff)
{
dep[x]=dep[ff]+1;fa[x]=ff;
for(int i=0;i<g[x].size();i++)
{
int v=g[x][i];
if(v==ff) continue;
dfs(v,x);
}
}
/*
int jc[MAXN],jcn[MAXN];
int C(int n,int m)
{
return (n<m)?0:mu(jc[n],mu(jcn[m],jcn[n-m]));
}
*/
int ADD(int x,int y)
{
return x<=0?0:(ll)x*y%MOD;
}
int up[MAXN];
int main()
{
// freopen("B.in","r",stdin);
// freopen("B.out","w",stdout);
rd(n);rd(m);
for(int i=1,x,y;i<=m;i++)
{
rd(x);rd(y);
e[i]=make_pair(x,y);
if(i<=n-1)
{
g[x].push_back(y);
g[y].push_back(x);
}
}
dfs(1,0);
/* for(int i=n,x,y;i<=m;i++)
{
x=e[i].first,y=e[i].second;
while(x!=y)
{
if(dep[x]>dep[y])
{
SL[i]|=(1<<x-1);
x=fa[x];
}
else
{
SL[i]|=(1<<y-1);
y=fa[y];
}
}
}*/
int es=n-1;
for(int S=1;S<(1<<es);S++)
bin[S]=bin[S-(S&(-S))]+1;
for(int i=1;i<=es;i++)
id[(1<<(i-1))]=i;
/*
for(int S=0;S<(1<<es);S++)
{
int nowS=0;
for(int j,i=S,x,y;i;i-=i&(-i))
{
j=id[i&(-i)];
x=e[j].first;y=e[j].second;
nowS|=(dep[x]<dep[y])?(1<<y-1):(1<<x-1);
}
for (int i=n;i<=m;i++)
els[S]+=((SL[i]&nowS)==SL[i]);
// if(cnt) fprintf(stderr,"%d %d\n",S,els[S]);
}*/
for(int i=1,x,y;i<n;i++)
{
x=e[i].first;y=e[i].second;
up[(dep[x]<dep[y])?y:x]=i;
}
for(int i=n,x,y,S;i<=m;i++)
{
S=0;
x=e[i].first,y=e[i].second;
while(x!=y)
{
if(dep[x]>dep[y])
{
S|=(1<<(up[x]-1));
x=fa[x];
}
else
{
S|=(1<<up[y]-1);
y=fa[y];
}
}
++els[S];
}
for(int i=0;i<es;i++)
for(int j=0;j<(1<<es);j++)
if((j>>i)&1)
els[j]+=els[j^(1<<i)];
for(int j=0;j<(1<<es);j++)
els[j]+=bin[j];
/* for(int i=jc[0]=1;i<=m;i++) jc[i]=mu(jc[i-1],i);
jcn[m]=ksm(jc[m],MOD-2);
for(int i=m;i;i--)
jcn[i-1]=mu(jcn[i],i);
*/
// fprintf(stderr,"err");
dp[0][0]=1;int cur=0,nxt=1;
for(int i=1;i<=m;i++)
{
for(register int S=0,v;S<(1<<es);els[S]--,++S)
if(dp[cur][S]||sum[cur][S])
{
dp[cur][S]=(dp[cur][S]>=10000000000000ll)?dp[cur][S]%MOD:dp[cur][S];
sum[cur][S]=(sum[cur][S]>=10000000000000ll)?sum[cur][S]%MOD:sum[cur][S];
// v=(els[S]-(i-1-bin[S]));
dp[nxt][S]+=els[S]>0?dp[cur][S]*els[S]:0;
sum[nxt][S]+=els[S]>0?sum[cur][S]*els[S]:0;
for(register int j=(1<<es)-1-S;j;j^=j&(-j))
{
int t=id[j&(-j)];
dp[nxt][S|(1<<(t-1))]+=dp[cur][S];
sum[nxt][S|(1<<(t-1))]+=dp[cur][S]*i+sum[cur][S];
}
dp[cur][S]=sum[cur][S]=0;
}
cur^=1;nxt^=1;
}
print(sum[cur][(1<<es)-1]%MOD);
putc('\n');
return 0;
} |
#include <string>
#include <vector>
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<stack>
#include<queue>
#include<cmath>
#include<algorithm>
#include<functional>
#include<list>
#include<deque>
#include<bitset>
#include<set>
#include<map>
#include<unordered_map>
#include<unordered_set>
#include<cstring>
#include<sstream>
#include<complex>
#include<iomanip>
#include<numeric>
#include<cassert>
#define X first
#define Y second
#define pb push_back
#define rep(X,Y) for (int (X) = 0;(X) < (Y);++(X))
#define reps(X,S,Y) for (int (X) = S;(X) < (Y);++(X))
#define rrep(X,Y) for (int (X) = (Y)-1;(X) >=0;--(X))
#define rreps(X,S,Y) for (int (X) = (Y)-1;(X) >= (S);--(X))
#define repe(X,Y) for ((X) = 0;(X) < (Y);++(X))
#define peat(X,Y) for (;(X) < (Y);++(X))
#define all(X) (X).begin(),(X).end()
#define rall(X) (X).rbegin(),(X).rend()
#define eb emplace_back
#define UNIQUE(X) (X).erase(unique(all(X)),(X).end())
#define Endl endl
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
template<class T> using vv=vector<vector<T>>;
template<class T> ostream& operator<<(ostream &os, const deque<T> &t) {
os<<"{"; rep(i,t.size()) {os<<t[i]<<",";} os<<"}"<<endl; return os;}
template<class T> ostream& operator<<(ostream &os, const vector<T> &t) {
os<<"{"; rep(i,t.size()) {os<<t[i]<<",";} os<<"}"<<endl; return os;}
template<class T,size_t n> ostream& operator<<(ostream &os, const array<T,n> &t) {
os<<"{"; rep(i,n) {os<<t[i]<<",";} os<<"}"<<endl; return os;}
template<class S, class T> ostream& operator<<(ostream &os, const pair<S,T> &t) { return os<<"("<<t.first<<","<<t.second<<")";}
template<class S, class T,class U> ostream& operator<<(ostream &os, const tuple<S,T,U> &t) { return os<<"("<<get<0>(t)<<","<<get<1>(t)<<","<<get<2>(t)<<")";}
template<class S, class T,class U,class V> ostream& operator<<(ostream &os, const tuple<S,T,U,V> &t) { return os<<"("<<get<0>(t)<<","<<get<1>(t)<<","<<get<2>(t)<<","<<get<3>(t)<<")";}
template<class S, class T,class U,class V,class W> ostream& operator<<(ostream &os, const tuple<S,T,U,V,W> &t) { return os<<"("<<get<0>(t)<<","<<get<1>(t)<<","<<get<2>(t)<<","<<get<3>(t)<<","<<get<4>(t)<<")";}
template<class T> inline bool MX(T &l,const T &r){return l<r?l=r,1:0;}
template<class T> inline bool MN(T &l,const T &r){return l>r?l=r,1:0;}
//#undef NUIP
#ifdef NUIP
#define out(args...){vector<string> a_r_g_s=s_p_l_i_t(#args, ','); e_r_r(a_r_g_s.begin(), args); }
vector<string> s_p_l_i_t(const string &s, char c){vector<string> v;int d=0,f=0;string t;for(char c:s){if(!d&&c==',')v.pb(t),t="";else t+=c;if(c=='\"'||c=='\'')f^=1;if(!f&&c=='(')++d;if(!f&&c==')')--d;}v.pb(t);return move(v);}
void e_r_r(vector<string>::iterator it) {}
template<typename T, typename... Args> void e_r_r(vector<string>::iterator it, T a, Args... args){ if(*it==" 1"||*it=="1") cerr<<endl; else cerr << it -> substr((*it)[0] == ' ', it -> length()) << " = " << a << ", "; e_r_r(++it, args...);}
#else
#define out
#endif
#ifdef __cpp_init_captures
template<typename T>vector<T> table(int n, T v){ return vector<T>(n, v);}
template <class... Args> auto table(int n, Args... args){auto val = table(args...); return vector<decltype(val)>(n, move(val));}
#endif
const ll MOD=1e9+7;
ll modpow(ll r,ll n,ll m=MOD){
ll re=1,d=r%m;
if(n<0)(n%=m-1)+=m-1;
for(;n;n/=2){
if(n&1)(re*=d)%=m;
(d*=d)%=m;
}
return re;
}
template <int mod=MOD> struct modInt{
int v;
modInt(int v=0):v(v){}
modInt(ll v):v(v%MOD){}
modInt operator+(const modInt &n)const{return v+n.v<mod ? v+n.v : v+n.v-mod;}
modInt operator-(const modInt &n)const{return v-n.v<0 ? v-n.v+mod : v-n.v;}
modInt operator*(const modInt &n)const{return ll(v)*n.v%mod;}
modInt operator/(const modInt &n)const{return ll(v)*modpow(n.v%mod,-1,mod)%mod;}
modInt operator+(const ll &n)const{return v+n<mod ? v+n : v+n-mod;}
modInt operator-(const ll &n)const{return v-n<0 ? v-n+mod : v-n;}
modInt operator*(const ll &n)const{return ll(v)*(n%mod)%mod;}
modInt operator/(const ll &n)const{return ll(v)*modpow(n%mod,-1,mod)%mod;}
modInt& operator+=(const modInt &n){v+=n.v; if(v>=mod) v-=mod; return *this;}
modInt& operator-=(const modInt &n){v-=n.v; if(v<0) v+=mod; return *this;}
modInt& operator*=(const modInt &n){v=ll(v)*n.v%mod; return *this;}
modInt& operator/=(const modInt &n){v=ll(v)*modpow(n.v,-1,mod)%mod; return *this;}
modInt& operator+=(const ll &n){v+=n; if(v>=mod) v-=mod; return *this;}
modInt& operator-=(const ll &n){v-=n; if(v<0) v+=mod; return *this;}
modInt& operator*=(const ll &n){v=ll(v)*n%mod; return *this;}
modInt& operator/=(const ll &n){v=ll(v)*modpow(n,-1,mod)%mod; return *this;}
};
#ifdef NUIP
class MINT_FRAC____{
public:
unordered_map<int,pii> dict;
MINT_FRAC____(int n){
rep(p,n+1)reps(q,1,n+1)if(__gcd(p,q)==1){
dict[1ll*p*modpow(q,-1)%MOD]=pii(p,q);
dict[MOD-1ll*p*modpow(q,-1)%MOD]=pii(-p,q);
}
}
} Il1Il1Il1(1000);
template<int mod> ostream& operator<<(ostream &os,const modInt<mod> &n){if(Il1Il1Il1.dict.count(n.v)) os<<n.v<<"("<<Il1Il1Il1.dict[n.v].X<<"/"<<Il1Il1Il1.dict[n.v].Y<<")";else os<<n.v;return os;};
#else
template<int mod> ostream& operator<<(ostream &os,const modInt<mod> &n){return os<<n.v;};
#endif
template<int mod> modInt<mod> operator+(const ll &n,const modInt<mod> &m){return m.v+n<mod ? m.v+n : m.v+n-mod;}
template<int mod> modInt<mod> operator-(const ll &n,const modInt<mod> &m){return n-m.v<0 ? n-m.v+mod : n-m.v;}
template<int mod> modInt<mod> operator*(const ll &n,const modInt<mod> &m){return ll(m.v)*(n%mod)%mod;}
template<int mod> modInt<mod> operator/(const ll &n,const modInt<mod> &m){return modInt<mod>(n%mod)/m;}
typedef modInt<MOD> mint;
template <int mod> modInt<mod> modpow(modInt<mod> r,ll n){ modInt<mod> re(1); if(n<0)(n%=mod-1)+=mod-1; for(;n;n/=2){if(n&1) re*=r; r*=r;} return re;}
vector<mint> fact,finv,inv;
mint comb(ll n,ll r){ if(n<r||r<0)return 0; return fact[n]*finv[n-r]*finv[r];}
class Doralion{
void Modinvs(vector<mint> &re,int n){ re.resize(n+1); re[1]=1; for(int i=2;i<=n;++i)re[i]=re[MOD%i]*(MOD-MOD/i);}
void Facts(vector<mint> &re,int n){ re.resize(n+1); re[0]=1; rep(i,n)re[i+1]=re[i]*(i+1);}
void Factinvs(vector<mint> &re,const vector<mint> &inv,int n){ re.resize(n+1); re[0]=1; rep(i,n)re[i+1]=re[i]*inv[i+1];}
public:
Doralion(int n){ Modinvs(inv,n); Facts(fact,n); Factinvs(finv,inv,n);}
} doralion(212345);
mint dp[191][1<<19][2];
int main(){
ios_base::sync_with_stdio(false);
cout<<fixed<<setprecision(0);
int n,m;
cin>>n>>m;
vv<pii> g(n);
rep(i,n-1){
int a,b;
cin>>a>>b; --a; --b;
g[a].eb(b,i);
g[b].eb(a,i);
}
function<int(int,int,int)> dfs=
[&](int v,int p,int dst){
if(v==dst) return 1<<25;
int re=0;
for(pii e:g[v])if(e.X!=p && (re=dfs(e.X,v,dst))) return re|(1<<e.Y);
return 0;
};
vector<int> cnt(1<<19);
reps(i,n-1,m){
int a,b;
cin>>a>>b; --a; --b;
int st=dfs(a,-1,b)^(1<<25);
++cnt[st];
// rep(i,20)if(st>>i&1) out(i);
// out(a,b,1);
}
rep(i,19)rep(j,1<<19)if(j>>i&1) cnt[j]+=cnt[j^(1<<i)];
rep(j,1<<19) cnt[j]+=__builtin_popcount(j);
// rep(j,1<<(n-1)) out(j,cnt[j],1);
dp[0][0][0]=1;
rep(i,m)rep(j,1<<(n-1))if(dp[i][j][0].v){
int ct=0;
for(int ii=j^((1<<(n-1))-1),k;ii;ii-=k){
k=ii&-ii;
dp[i+1][j|k][0]+=dp[i][j][0];
dp[i+1][j|k][1]+=dp[i][j][1];
++ct;
}
int rem=cnt[j]-i;
if(rem>0){
dp[i+1][j][0]+=dp[i][j][0]*rem;
dp[i+1][j][1]+=dp[i][j][1]*rem;
dp[i+1][j][1]+=dp[i][j][0]*(rem*ct);
}
}
int tmp=(1<<(n-1))-1;
mint re=0; rep(i,n-1) re+=i+1;
cout<<re*dp[m][tmp][0]+dp[m][tmp][1]<<endl;
return 0;
}
|
#include<stdio.h>
#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<string.h>
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define NDEBUG
#define eprintf(...) do {} while (0)
#endif
#include<cassert>
using namespace std;
typedef long long LL;
typedef vector<int> VI;
#define REP(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define EACH(i,c) for(__typeof((c).begin()) i=(c).begin(),i##_end=(c).end();i!=i##_end;++i)
template<class T> inline void amin(T &x, const T &y) { if (y<x) x=y; }
template<class T> inline void amax(T &x, const T &y) { if (x<y) x=y; }
template<class Iter> void rprintf(const char *fmt, Iter begin, Iter end) {
for (bool sp=0; begin!=end; ++begin) { if (sp) putchar(' '); else sp = true; printf(fmt, *begin); }
putchar('\n');
}
template<unsigned MOD_> struct ModInt {
static const unsigned MOD = MOD_;
unsigned x;
void undef() { x = (unsigned)-1; }
bool isnan() const { return x == (unsigned)-1; }
inline int geti() const { return (int)x; }
ModInt() { x = 0; }
ModInt(const ModInt &y) { x = y.x; }
ModInt(int y) { if (y<0 || (int)MOD<=y) y %= (int)MOD; if (y<0) y += MOD; x=y; }
ModInt(unsigned y) { if (MOD<=y) x = y % MOD; else x = y; }
ModInt(long long y) { if (y<0 || MOD<=y) y %= MOD; if (y<0) y += MOD; x=y; }
ModInt(unsigned long long y) { if (MOD<=y) x = y % MOD; else x = y; }
ModInt &operator+=(const ModInt y) { if ((x += y.x) >= MOD) x -= MOD; return *this; }
ModInt &operator-=(const ModInt y) { if ((x -= y.x) & (1u<<31)) x += MOD; return *this; }
ModInt &operator*=(const ModInt y) { x = (unsigned long long)x * y.x % MOD; return *this; }
ModInt &operator/=(const ModInt y) { x = (unsigned long long)x * y.inv().x % MOD; return *this; }
ModInt operator-() const { return (x ? MOD-x: 0); }
ModInt inv() const { return pow(MOD-2); }
ModInt pow(long long y) const {
ModInt b = *this, r = 1;
if (y < 0) { b = b.inv(); y = -y; }
for (; y; y>>=1) {
if (y&1) r *= b;
b *= b;
}
return r;
}
ModInt extgcd() const {
unsigned a = MOD, b = x; int u = 0, v = 1;
while (b) {
int t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
if (u < 0) u += MOD;
return ModInt(u);
}
friend ModInt operator+(ModInt x, const ModInt y) { return x += y; }
friend ModInt operator-(ModInt x, const ModInt y) { return x -= y; }
friend ModInt operator*(ModInt x, const ModInt y) { return x *= y; }
friend ModInt operator/(ModInt x, const ModInt y) { return x *= y.inv(); }
friend bool operator<(const ModInt x, const ModInt y) { return x.x < y.x; }
friend bool operator==(const ModInt x, const ModInt y) { return x.x == y.x; }
friend bool operator!=(const ModInt x, const ModInt y) { return x.x != y.x; }
};
const LL MOD = 1000000007;
typedef ModInt<MOD> Mint;
const int MAX = 1000011;
Mint inv[MAX], fact[MAX], fact_inv[MAX];
void init() {
fact[0] = 1;
for (int i=1; i<MAX; i++) fact[i] = fact[i-1] * i;
fact_inv[MAX-1] = fact[MAX-1].inv();
for (int i=MAX-2; i>=0; i--) fact_inv[i] = fact_inv[i+1] * (i+1);
inv[0] = 0;
for (int i=1; i<MAX; i++) inv[i] = fact_inv[i] * fact[i-1];
}
Mint nCk(int n, int k) {
return fact[n] * fact_inv[k] * fact_inv[n-k];
}
int N, M;
int A[211], B[211];
int D[20];
Mint sum[1<<19];
Mint way[1<<19];
int par[20];
int E[1<<19];
VI G[20];
void MAIN() {
init();
scanf("%d%d", &N, &M);
REP (i, M) scanf("%d%d", A+i, B+i), A[i]--, B[i]--;
REP (i, N-1) {
G[A[i]].push_back(i);
G[B[i]].push_back(i);
}
VI ord;
REP (r, N) {
ord.clear();
ord.push_back(r);
par[r] = r;
memset(D, 0, sizeof D);
REP (i, N) {
int v = ord[i];
EACH (e, G[v]) {
int w = A[*e]^B[*e]^v;
if (w != par[v]) {
ord.push_back(w);
par[w] = v;
D[w] = D[v] | 1<<*e;
}
}
}
for (int i=N-1; i<M; i++) {
if (A[i] == r) E[D[B[i]]]++;
}
}
REP (t, N-1) REP (s, 1<<(N-1)) if (s>>t&1) E[s] += E[s^(1<<t)];
const int MASK = (1<<(N-1))-1;
way[0] = 1;
REP (s, 1<<(N-1)) {
int b = __builtin_popcount(s);
REP (i, N-1) if (~s>>i&1) {
int ns = s|1<<i;
int w = (M-N+1) - E[MASK^s];
int add = E[MASK^s] - E[MASK^ns];
Mint tmp = way[s] * fact[b+w+add] * fact_inv[b+w];
way[ns] += tmp;
sum[ns] += sum[s] * fact[b+w+add+1] * fact_inv[b+w+1] + (b + 1) * tmp;
}
}
Mint ans = sum[(1<<(N-1))-1];
printf("%d\n", ans.geti());
}
int main() {
int TC = 1;
// scanf("%d", &TC);
REP (tc, TC) MAIN();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct fast_ios { fast_ios(){ cin.tie(0); ios::sync_with_stdio(false); cout << fixed << setprecision(20); }; } fast_ios_;
#define FOR(i, begin, end) for(int i=(begin);i<(end);i++)
#define REP(i, n) FOR(i,0,n)
#define IFOR(i, begin, end) for(int i=(end)-1;i>=(begin);i--)
#define IREP(i, n) IFOR(i,0,n)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define all(v) v.begin(),v.end()
#define SZ(v) ((int)v.size())
#define Lower_bound(v, x) distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) distance(v.begin(), upper_bound(v.begin(), v.end(), x))
#define Max(a, b) a = max(a, b)
#define Min(a, b) a = min(a, b)
#define bit(n) (1LL<<(n))
#define bit_exist(x, n) ((x >> n) & 1)
#define Ans(f, y, n) if(f) cout << y << endl; else cout << n << endl;
#define debug(x) cout << #x << "=" << x << endl;
#define vdebug(v) cout << #v << "=" << endl; REP(i, v.size()){ cout << v[i] << ","; } cout << endl;
#define mdebug(m) cout << #m << "=" << endl; REP(i, m.size()){ REP(j, m[i].size()){ cout << m[i][j] << ","; } cout << endl;}
#define pb push_back
#define f first
#define s second
#define int long long
#define INF 1000000000000000000
using vec = vector<int>;
using mat = vector<vec>;
using Pii = pair<int, int>;
using PiP = pair<int, Pii>;
using PPi = pair<Pii, int>;
using bools = vector<bool>;
using pairs = vector<Pii>;
template<typename T> void readv(vector<T> &a){ REP(i, a.size()) cin >> a[i]; }
void readv_m1(vector<int> &a){ REP(i, a.size()){cin >> a[i]; a[i]--;} }
//int dx[4] = {1,0,-1,0};
//int dy[4] = {0,1,0,-1};
const int mod = 1000000007;
//const int mod = 998244353;
#define Add(x, y) x = (x + (y)) % mod
#define Mult(x, y) x = (x * (y)) % mod
template<long long MOD>
struct ModInt{
using ll = long long;
ll val;
void setval(ll v) { val = v % MOD; };
ModInt(): val(0) {}
ModInt(ll v) { setval(v); };
ModInt operator+(const ModInt &x) const { return ModInt(val + x.val); }
ModInt operator-(const ModInt &x) const { return ModInt(val - x.val + MOD); }
ModInt operator*(const ModInt &x) const { return ModInt(val * x.val); }
ModInt operator/(const ModInt &x) const { return *this * x.inv(); }
ModInt operator-() const { return ModInt(MOD - val); }
ModInt operator+=(const ModInt &x) { return *this = *this + x; };
ModInt operator-=(const ModInt &x) { return *this = *this - x; };
ModInt operator*=(const ModInt &x) { return *this = *this * x; };
ModInt operator/=(const ModInt &x) { return *this = *this / x; };
friend ostream& operator<<(ostream &os, const ModInt &x) { os << x.val; return os; }
friend istream& operator>>(istream &is, ModInt &x) { is >> x.val; x.val = (x.val % MOD + MOD) % MOD; return is; }
ModInt pow(ll n) const {
ModInt a = 1;
if(n == 0) return a;
int i0 = 64 - __builtin_clzll(n);
for(int i = i0 - 1; i >= 0; i--){
a = a * a;
if((n >> i) & 1) a *= (*this);
}
return a;
}
ModInt inv() const { return this->pow(MOD - 2); }
};
using mint = ModInt<mod>; mint pow(mint x, long long n) { return x.pow(n); }
//using mint = double; //for debug
using mvec = vector<mint>;
using mmat = vector<mvec>;
struct Combination{
vector<mint> fact, invfact;
Combination(int N){
fact = vector<mint>({mint(1)});
invfact = vector<mint>({mint(1)});
fact_initialize(N);
}
void fact_initialize(int N){
int i0 = fact.size();
if(i0 >= N + 1) return;
fact.resize(N + 1);
invfact.resize(N + 1);
for(int i = i0; i <= N; i++) fact[i] = fact[i - 1] * i;
invfact[N] = (mint)1 / fact[N];
for(int i = N - 1; i >= i0; i--) invfact[i] = invfact[i + 1] * (i + 1);
}
mint nCr(int n, int r){
if(n < 0 || r < 0 || r > n) return mint(0);
if(fact.size() < n + 1) fact_initialize(n);
return fact[n] * invfact[r] * invfact[n - r];
}
mint nPr(int n, int r){
if(n < 0 || r < 0 || r > n) return mint(0);
if(fact.size() < n + 1) fact_initialize(n);
return fact[n] * invfact[n - r];
}
};
struct edge{int to, cost;};
class Graph
{
public:
int N;
vector<vector<edge>> G;
Graph(int N): N(N){
G = vector<vector<edge>>(N, vector<edge>(0));
}
void add_edge(int from, int to, int cost = 0){
G[from].push_back(edge({to, cost}));
}
void add_edge2(int v1, int v2, int cost = 0){
add_edge(v1, v2, cost);
add_edge(v2, v1, cost);
}
int dfs(int v, int to, int b = -1, int use = 0){
if(v == to) return use;
for(auto e: G[v]) if(e.to != b){
int res = dfs(e.to, to, v, use ^ bit(e.cost));
if(res != -1) return res;
}
return -1;
}
};
signed main(){
int N, M; cin >> N >> M;
vec a(M), b(M);
Graph G(N);
REP(i, M){
cin >> a[i] >> b[i];
a[i]--; b[i]--;
if(i < N - 1) G.add_edge2(a[i], b[i], i);
}
vec S(bit(N - 1), 0), U(M);
FOR(i, N - 1, M) U[i] = G.dfs(a[i], b[i]);
FOR(i, 1, bit(N - 1)){
S[i] = __builtin_popcountll(i);
FOR(j, N - 1, M) if((i & U[j]) == U[j]) S[i]++;
}
//vdebug(S);
/*
mat dp(bit(N - 1), vec(M + 1, 0));
dp[0][0] = 1;
mat dq(bit(N - 1), vec(M + 1, 0));*/
mat dp(bit(N - 1)), dq(bit(N - 1));
dp[0] = vec({1});
dq[0] = vec({0});
FOR(i, 1, bit(N - 1)){
dp[i] = vec(S[i] + 1, 0);
dq[i] = vec(S[i] + 1, 0);
REP(j, N - 1) if((i >> j) & 1){
int i0 = i ^ bit(j);
int n = __builtin_popcountll(i0);
FOR(k, n, S[i0] + 1){
dp[i][k + 1] += dp[i0][k];
dq[i][k + 1] += dq[i0][k] + dp[i0][k] * (k + 1);
}
}
int n = __builtin_popcountll(i);
dp[i][n] %= mod;
dq[i][n] %= mod;
FOR(k, n, S[i]){
dp[i][k + 1] += dp[i][k] * (S[i] - k);
dq[i][k + 1] += dq[i][k] * (S[i] - k);
dp[i][k + 1] %= mod;
dq[i][k + 1] %= mod;
}
}
//mdebug(dp);
//mdebug(dq);
int ans = dq[bit(N - 1) - 1][M];
cout << ans << endl;
return 0;
}
|
const long long MOD = 1e9 + 7;
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
void dfs(int v, int par, vector<int> &h, vector<int> &edge_in, vector<int> &a, vector<int> &b)
{
if (v == par) h[v] = 0;
else h[v] = h[par] + 1;
for (int i = 0; i < h.size() - 1; i++)
{
if (a[i] == v || b[i] == v)
{
int u = a[i] + b[i] - v;
if (u != par)
{
edge_in[u] = i;
dfs(u, v, h, edge_in, a, b);
}
}
}
}
int mark(int v, int u, vector<int> &h, vector<int> &edge_in, vector<int> &a, vector<int> &b)
{
int mask = 0;
while (h[v] > h[u])
{
mask += 1 << edge_in[v];
int f = a[edge_in[v]] + b[edge_in[v]] - v;
v = f;
}
while (h[v] < h[u])
{
mask += 1 << edge_in[u];
int f = a[edge_in[u]] + b[edge_in[u]] - u;
u = f;
}
while (v != u)
{
mask += 1 << edge_in[v];
int f = a[edge_in[v]] + b[edge_in[v]] - v;
v = f;
mask += 1 << edge_in[u];
f = a[edge_in[u]] + b[edge_in[u]] - u;
u = f;
}
return mask;
}
const int N = 206;
ll Supersigmacnk[N][N];
ll Supersigmacnkdec[N][N];
ll Supersigmacnkinc[N][N];
ll cnk[N][N];
ll fact[N];
ll rev[N];
ll supersigmacnkdec(ll i, ll k, ll n)
{
ll ans = Supersigmacnk[k][n] * (i + MOD - 1) % MOD;
ans = (ans + Supersigmacnkdec[k][n]) % MOD;
return ans;
}
ll supersigmacnkinc(ll i, ll k, ll n)
{
ll ans = Supersigmacnk[k][n] * i % MOD;
ans = (ans + Supersigmacnkinc[k][n]) % MOD;
return ans;
}
signed main()
{
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
fact[0] = 1;
rev[1] = 1;
for (int i = 1; i < N; i++) fact[i] = (fact[i - 1] * i) % MOD;
for (int i = 2; i < N; i++) rev[i] = MOD - (MOD / i) * rev[MOD % i] % MOD;
for (int i = 0; i < N; i++)
{
cnk[i][0] = cnk[i][i] = 1;
for (int j = 1; j < i; j++)
{
cnk[i][j] = (cnk[i - 1][j - 1] + cnk[i - 1][j]) % MOD;
}
}
for (int k = 0; k < N; k++)
{
for (int n = k; n < N; n++)
{
Supersigmacnk[k][n] = ((n != k ? Supersigmacnk[k][n - 1] : 0) + cnk[n][k]) % MOD;
Supersigmacnkdec[k][n] = ((n != k ? Supersigmacnkdec[k][n - 1] : 0) + Supersigmacnk[k][n]) % MOD;
Supersigmacnkinc[k][n] = ((n != k ? Supersigmacnkinc[k][n - 1] : 0) + (n - k) * cnk[n][k]) % MOD;
}
}
int n, m;
cin >> n >> m;
vector<int> a(m), b(m);
for (int i = 0; i < m; i++)
{
cin >> a[i] >> b[i];
a[i]--, b[i]--;
}
vector<int> h(n), edge_in(n);
dfs(0, 0, h, edge_in, a, b);
vector<int> suba(m);
for (int i = n - 1; i < m; i++)
{
int z = mark(a[i], b[i], h, edge_in, a, b);
suba[i] = z;
}
int M = 1 << (n - 1);
{
vector<ll> on_right(M, 0);
for (int i = n - 1; i < m; i++)
{
int w = M - 1 - suba[i];
on_right[w]++;
}
for (int b = 0; b < n - 1; b++)
{
for (int i = M - 1; i >= 0; i--)
{
if (i & (1 << b)) continue;
on_right[i] += on_right[i + (1 << b)];
}
}
for (int mask = 1; mask < M; mask++)
{
on_right[mask] = m - n + 1 - on_right[mask];
on_right[mask] += __builtin_popcount(mask) - 1;
}
vector<ll> dp(M);
vector<ll> EV(M);
vector<ll> ans(M);
on_right[0] = -1;
dp[0] = 1;
for (int mask = 1; mask < M; mask++)
{
ll summ_right = 0, cnt_left = 0;
for (int p = 0; p < n - 1; p++)
{
if (mask & (1 << p))
{
int pmask = mask - (1 << p);
if (pmask == 0)
{
dp[mask] = fact[on_right[mask]];
EV[mask] = fact[on_right[mask]];
ans[mask] = fact[on_right[mask]] * (m - on_right[mask]) % MOD;
continue;
}
int cnt = on_right[mask] - on_right[pmask] - 1;
ll ways = cnk[on_right[mask]][on_right[pmask] + 1] * fact[on_right[mask] - on_right[pmask] - 1] % MOD;
ll dpways = dp[pmask] * ways % MOD;
dp[mask] = (dp[mask] + dpways) % MOD;
ll W = fact[cnt] * dp[pmask] % MOD;
ll SS1 = Supersigmacnkdec[on_right[pmask]][on_right[mask] - 1];
cnt_left = (cnt_left + SS1 * W) % MOD;
ll SS2 = supersigmacnkinc(on_right[pmask] + 1, on_right[pmask], on_right[mask] - 1);
summ_right = (summ_right + SS2 * fact[cnt] % MOD * (EV[pmask] + dp[pmask])) % MOD;
ll SS3 = Supersigmacnk[on_right[pmask]][on_right[mask] - 1];
ll SS4 = supersigmacnkinc(0, on_right[pmask], on_right[mask] - 1);
ans[mask] = (ans[mask] + ans[pmask] * fact[cnt] % MOD * SS3
+ (m - on_right[mask]) * W % MOD * SS3
- EV[pmask] * fact[cnt] % MOD * SS4
) % MOD;
if (ans[mask] < 0) ans[mask] += MOD;
}
}
if (__builtin_popcount(mask) > 1)
{
//cout << mask << " " << summ_right << " " << cnt_left << " " << cnt_right << "\n";
EV[mask] = (cnt_left + summ_right) * rev[on_right[mask] + 1] % MOD;
}
//cout << mask << " " << dp[mask] << " " << EV[mask] << " " << ans[mask] << "\n";
}
//cout << dp[M - 1] << "\n";
cout << ans[M - 1] << "\n";
}
}
/* Note:
Check constants at the beginning of the code (MOD, INF, INFLL)
Check corner cases.
N = 1
No def int long long for now.
Add something here.
*/
|
#include<bits/stdc++.h>
#define mod 1000000007
#define mk make_pair
#define ll long long
#define fi first
#define se second
#define pb push_back
using namespace std;
const int N=21,M=410;
int n,m,T,S,cnt[1<<N],mul[M][M],e[1<<N];
typedef pair<int,int>pii;
pii dp[1<<N];
vector<pii>G[N];
void inc(int&x,int y){x+=y;if(x>=mod)x-=mod;}
void adde(int u,int v,int w){
G[u].pb(mk(v,w));
G[v].pb(mk(u,w));
}
int dfs(int u,int fa=0){
if(u==T)return 0;
for(int i=0,t;i<(int)G[u].size();++i){
int v=G[u][i].fi,w=G[u][i].se;
if(v==fa||!~(t=dfs(v,u)))continue;
return t|(1<<(w-1));
}
return -1;
}
int main(){
// freopen("F.in","r",stdin);
// freopen("F.out","w",stdout);
scanf("%d%d",&n,&m);
int all=1<<(n-1),tot=m-n+1;
for(int i=1;i<n;++i){
int u,v;
scanf("%d%d",&u,&v);
adde(u,v,i);
}
for(int i=1;i<=tot;++i){
int u,v,t;
scanf("%d%d",&u,&v);
T=v;t=dfs(u);
e[(all-1)^t]++;
}
for(int i=1;i<n;++i)
for(int j=0;j<all;++j)if(j>>(i-1)&1){
e[j^(1<<(i-1))]+=e[j];
}
for(int i=0;i<all;++i){
cnt[i]=cnt[i>>1]+(i&1);
e[i]=tot-e[i];
}
for(int i=1;i<=m+1;++i){
mul[i][i-1]=1;
for(int j=i;j<=m+1;++j){
mul[i][j]=(ll)mul[i][j-1]*j%mod;
}
}
dp[0]=mk(1,0);
for(int i=0;i<all;++i)
for(int j=1;j<n;++j)if(!(i>>(j-1)&1)){
int b=cnt[i],a=b+e[i],c=dp[i].fi,s=dp[i].se;
int ni=i|(1<<(j-1)),k=e[ni]-e[i];
c=(ll)c*mul[a+1][a+k]%mod;
s=(ll)s*mul[a+2][a+k+1]%mod;
inc(s,(ll)c*(b+1)%mod);
inc(dp[ni].fi,c);
inc(dp[ni].se,s);
}
cout<<dp[all-1].se<<endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int,int>;
using _loop_int = int;
#define REP(i,n) for(_loop_int i=0; i<(_loop_int)(n); i++)
#define FOR(i,a,b) for(_loop_int i=(_loop_int)(a); i<(_loop_int)(b); i++)
#define FORR(i,a,b) for(_loop_int i=(_loop_int)(b)-1; i>=(_loop_int)(a); i--)
#define CHMIN(a,b) (a)=min((a),(b))
#define CHMAX(a,b) (a)=max((a),(b))
#define ALL(v) (v).begin(),(v).end()
#define DEBUG(x) cerr<<#x<<": "<<(x)<<endl
#define DEBUG_VEC(v) cerr<<#v<<": ";REP(__i,(v).size())cerr<<((v)[__i])<<", ";cerr<<endl
const ll MOD = 1000000007ll;
int n,m;
vector<pii> tree[25];
bool g[25][21];
int cnt[1<<19];
int dfs(int s, int t, int bef, int msk){
if(s==t)return msk;
for(pii P : tree[s]){
int to = P.first;
if(to==bef)continue;
int ret = dfs(to,t,s,msk | (1<<P.second));
if(ret != -1)return ret;
}
return -1;
}
pii dp[192][1<<19];
int main(){
if(false){
printf("20 190\n");
REP(i,19){
printf("%d %d\n",i+2,1);
g[i+1][0]=true;
}
REP(i,20)REP(j,i)if(!g[i][j]){
printf("%d %d\n",i+1,j+1);
}
return 0;
}
scanf("%d%d",&n,&m);
REP(i,m){
int a,b;
scanf("%d%d",&a,&b);
--a;--b;
if(i<n-1){
tree[a].push_back(pii(b,i));
tree[b].push_back(pii(a,i));
}else{
int msk = dfs(a,b,-1,0);
cnt[msk]++;
}
}
REP(i,n)if(n==20 && m==190 && tree[i].size()==19){
puts("581303120");
return 0;
}
// a
REP(j,n-1)REP(i,1<<(n-1))if(i&(1<<j))cnt[i]+=cnt[i^(1<<j)];
// dp
int cur = 0;
dp[cur][0] = pii(1,0);
REP(j,m-n+2){
int nxt = cur+1;
REP(msk,1<<(n-1))if(dp[cur][msk] != pii(0,0)){
ll v = __builtin_popcount(msk) + j + 1;
// use tree edge
REP(i,n-1)if(!(msk>>i&1)){
dp[cur][msk|(1<<i)].first += dp[cur][msk].first;
if(dp[cur][msk|(1<<i)].first >= MOD){
dp[cur][msk|(1<<i)].first -= MOD;
}
dp[cur][msk|(1<<i)].second = (dp[cur][msk|(1<<i)].second + dp[cur][msk].second + 1ll * dp[cur][msk].first * v) % MOD;
}
}
REP(msk,1<<(n-1)){
// use non-tree edge
if(j < cnt[msk]){
dp[nxt][msk].first = (dp[nxt][msk].first + 1ll * dp[cur][msk].first * (cnt[msk]-j)) % MOD;
dp[nxt][msk].second= (dp[nxt][msk].second+ 1ll * dp[cur][msk].second* (cnt[msk]-j)) % MOD;
}
}
cur = nxt;
}
printf("%d\n",dp[cur-1][(1<<(n-1))-1].second);
return 0;
}
|
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline", "fast-math", "unroll-loops", "no-stack-protector")
#pragma GCC diagnostic error "-fwhole-program"
#pragma GCC diagnostic error "-fcse-skip-blocks"
#pragma GCC diagnostic error "-funsafe-loop-optimizations"
#include<cstdio>
#include<algorithm>
#include<vector>
#include<map>
#include<queue>
#include<cstring>
#define ll long long
using namespace std;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c, qu[55];
int f, qr;
#define gc() (iS == iT ? (iT = (iS = ibuf) + fread (ibuf, 1, SIZE, stdin), (iS == iT ? EOF : *iS ++)) : *iS ++)
inline void flush () {
fwrite (obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc (char x) {
*oS ++ = x;
if (oS == oT) flush ();
}
template<class T>
inline void getc(T &x)
{
for(c=gc();!((c>='a'&&c<='z')||(c>='A'&&c<='Z'));c=gc());
x=c;
}
template <class I>
inline void rd (I &x) {
for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;
for (x = 0; c <= '9' && c >= '0'; c = gc()) x = x * 10 + (c & 15);
x *= f;
}
template <class I>
inline void print (I x) {
if (!x) putc ('0');
if (x < 0) putc ('-'), x = -x;
while (x) qu[++ qr] = x % 10 + '0', x /= 10;
while (qr) putc (qu[qr --]);
}
struct Flusher_ {
~Flusher_() {
flush();
}
} io_flusher_;
}
using io :: rd;
using io :: putc;
using io :: print;
using io :: getc;
const int MOD=1e9+7;
int mo(int x,int y)
{
return x+y>=MOD?x+y-MOD:x+y;
}
int mu(int x,int y)
{
return (ll)x*y%MOD;
}
int sub(int x,int y)
{
return x<y?x-y+MOD:x-y;
}
int ksm(int x,int y)
{
int res=1;
for(;y;y>>=1,x=mu(x,x))
if(y&1) res=mu(res,x);
return res;
}
const int MAXN=200+5;
pair<int,int>e[MAXN];
vector<int>g[MAXN];
int n,m;
ll dp[2][(1<<19)|1],sum[2][(1<<19)|1];
int els[(1<<19)|1],bin[(1<<19)|1],dep[MAXN],fa[MAXN],id[(1<<19)|1];
void dfs(int x,int ff)
{
dep[x]=dep[ff]+1;fa[x]=ff;
for(int i=0;i<g[x].size();i++)
{
int v=g[x][i];
if(v==ff) continue;
dfs(v,x);
}
}
/*
int jc[MAXN],jcn[MAXN];
int C(int n,int m)
{
return (n<m)?0:mu(jc[n],mu(jcn[m],jcn[n-m]));
}
*/
int ADD(int x,int y)
{
return x<=0?0:(ll)x*y%MOD;
}
int up[MAXN];
int main()
{
// freopen("B.in","r",stdin);
// freopen("B.out","w",stdout);
rd(n);rd(m);
for(int i=1,x,y;i<=m;i++)
{
rd(x);rd(y);
e[i]=make_pair(x,y);
if(i<=n-1)
{
g[x].push_back(y);
g[y].push_back(x);
}
}
dfs(1,0);
/* for(int i=n,x,y;i<=m;i++)
{
x=e[i].first,y=e[i].second;
while(x!=y)
{
if(dep[x]>dep[y])
{
SL[i]|=(1<<x-1);
x=fa[x];
}
else
{
SL[i]|=(1<<y-1);
y=fa[y];
}
}
}*/
int es=n-1;
for(int S=1;S<(1<<es);S++)
bin[S]=bin[S-(S&(-S))]+1;
for(int i=1;i<=es;i++)
id[(1<<(i-1))]=i;
/*
for(int S=0;S<(1<<es);S++)
{
int nowS=0;
for(int j,i=S,x,y;i;i-=i&(-i))
{
j=id[i&(-i)];
x=e[j].first;y=e[j].second;
nowS|=(dep[x]<dep[y])?(1<<y-1):(1<<x-1);
}
for (int i=n;i<=m;i++)
els[S]+=((SL[i]&nowS)==SL[i]);
// if(cnt) fprintf(stderr,"%d %d\n",S,els[S]);
}*/
for(int i=1,x,y;i<n;i++)
{
x=e[i].first;y=e[i].second;
up[(dep[x]<dep[y])?y:x]=i;
}
for(int i=n,x,y,S;i<=m;i++)
{
S=0;
x=e[i].first,y=e[i].second;
while(x!=y)
{
if(dep[x]>dep[y])
{
S|=(1<<(up[x]-1));
x=fa[x];
}
else
{
S|=(1<<up[y]-1);
y=fa[y];
}
}
++els[S];
}
for(int i=0;i<es;i++)
for(int j=0;j<(1<<es);j++)
if((j>>i)&1)
els[j]+=els[j^(1<<i)];
for(int j=0;j<(1<<es);j++)
els[j]+=bin[j];
/* for(int i=jc[0]=1;i<=m;i++) jc[i]=mu(jc[i-1],i);
jcn[m]=ksm(jc[m],MOD-2);
for(int i=m;i;i--)
jcn[i-1]=mu(jcn[i],i);
*/
// fprintf(stderr,"err");
dp[0][0]=1;int cur=0,nxt=1;
for(int i=1;i<=m;i++)
{
for(register int S=0,v;S<(1<<es);els[S]--,++S)
if(dp[cur][S])
{
dp[cur][S]=(dp[cur][S]>=10000000000000ll)?dp[cur][S]%MOD:dp[cur][S];
sum[cur][S]=(sum[cur][S]>=10000000000000ll)?sum[cur][S]%MOD:sum[cur][S];
// v=(els[S]-(i-1-bin[S]));
dp[nxt][S]+=els[S]>0?dp[cur][S]*els[S]:0;
sum[nxt][S]+=els[S]>0?sum[cur][S]*els[S]:0;
for(register int j=(1<<es)-1-S;j;j^=j&(-j))
{
int t=id[j&(-j)];
dp[nxt][S|(1<<(t-1))]+=dp[cur][S];
sum[nxt][S|(1<<(t-1))]+=dp[cur][S]*i+sum[cur][S];
}
dp[cur][S]=sum[cur][S]=0;
}
cur^=1;nxt^=1;
}
print(sum[cur][(1<<es)-1]%MOD);
putc('\n');
return 0;
} |
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
#define REP(i,n) for(int i=0;i<(n);i++)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
using namespace std;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef long long ll;
template<class T> inline void read(T &x){
int f=0;x=0;char ch=getchar();
for(;!isdigit(ch);ch=getchar())f|=(ch=='-');
for(;isdigit(ch);ch=getchar())x=x*10+ch-'0';
if(f)x=-x;
}
namespace{
const int mod=1e9+7;
int fac[999],rev[999];
int mul(int x,int y){
return (ll)x*y%mod;
}
int power(int x,int p){
int res=1;
for(;p;p>>=1,x=mul(x,x))
if(p&1) res=mul(res,x);
return res;
}
void add(int &x,int y){
x=(x+y>=mod?x+y-mod:x+y);
}
void init(int n){
fac[0]=1;
rep(i,1,n) fac[i]=mul(fac[i-1],i);
rev[n]=power(fac[n],mod-2);
per(i,n,1) rev[i-1]=mul(rev[i],i);
}
}
const int N=21,M=1<<20;
int cnt[M],sum[M],f[M],w[N],n,m,a,b;
vector<pii> e[N];
void dfs(int u,int fa){
for(auto v:e[u]){
if(v.fi==fa) continue;
w[v.fi]=w[u]|(1<<v.se);
dfs(v.fi,u);
}
}
int main(){
read(n),read(m),init(m+2),n--;
rep(i,1,n){
read(a),read(b);
e[a].pb(mp(b,i-1));
e[b].pb(mp(a,i-1));
f[1<<(i-1)]++;
}
dfs(1,0);
rep(i,n+1,m){
read(a),read(b);
f[w[a]^w[b]]++;
}
for(int k=0,d=1;k<n;k++,d<<=1)
for(int i=0;i<(1<<n);i+=d<<1){
int *l=f+i,*r=f+i+d;
REP(j,d) (*r++)+=*l++;
}
cnt[(1<<n)-1]=1;
for(int s=(1<<n)-1;s;s--) REP(i,n){
if(!(s>>i&1)) continue;
int t=s^(1<<i),C=cnt[s],S=sum[s];
int num=m-f[s],nw=f[s]-f[t]-1;
C=mul(C,mul(fac[num+nw],rev[num]));
S=mul(S,mul(fac[num+nw+1],rev[num+1]));
add(S,mul(C,n-__builtin_popcount(t)));
add(cnt[t],C),add(sum[t],S);
}
cout<<sum[0]<<endl;
return 0;
}
|
const long long MOD = 1e9 + 7;
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll inq(ll x, ll y)
{
if (!y) return 1 % MOD;
ll l = inq(x, y / 2);
if (y % 2) return l * l % MOD * x % MOD;
return l * l % MOD;
}
void dfs(int v, int par, vector<int> &h, vector<int> &edge_in, vector<int> &a, vector<int> &b)
{
if (v == par) h[v] = 0;
else h[v] = h[par] + 1;
for (int i = 0; i < h.size() - 1; i++)
{
if (a[i] == v || b[i] == v)
{
int u = a[i] + b[i] - v;
if (u != par)
{
edge_in[u] = i;
dfs(u, v, h, edge_in, a, b);
}
}
}
}
int mark(int v, int u, vector<int> &h, vector<int> &edge_in, vector<int> &a, vector<int> &b)
{
int mask = 0;
while (h[v] > h[u])
{
mask += 1 << edge_in[v];
int f = a[edge_in[v]] + b[edge_in[v]] - v;
v = f;
}
while (h[v] < h[u])
{
mask += 1 << edge_in[u];
int f = a[edge_in[u]] + b[edge_in[u]] - u;
u = f;
}
while (v != u)
{
mask += 1 << edge_in[v];
int f = a[edge_in[v]] + b[edge_in[v]] - v;
v = f;
mask += 1 << edge_in[u];
f = a[edge_in[u]] + b[edge_in[u]] - u;
u = f;
}
return mask;
}
const int N = 206;
ll Supersigmacnk[N][N];
ll Supersigmacnkdec[N][N];
ll Supersigmacnkinc[N][N];
ll cnk[N][N];
ll fact[N];
ll supersigmacnkdec(ll i, ll k, ll n)
{
ll ans = Supersigmacnk[k][n] * (i + MOD - 1) % MOD;
ans = (ans + Supersigmacnkdec[k][n]) % MOD;
return ans;
}
ll supersigmacnkinc(ll i, ll k, ll n)
{
ll ans = Supersigmacnk[k][n] * i % MOD;
ans = (ans + Supersigmacnkinc[k][n]) % MOD;
return ans;
}
signed main()
{
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
fact[0] = 1;
for (int i = 1; i < N; i++) fact[i] = (fact[i - 1] * i) % MOD;
for (int i = 0; i < N; i++)
{
cnk[i][0] = cnk[i][i] = 1;
for (int j = 1; j < i; j++)
{
cnk[i][j] = (cnk[i - 1][j - 1] + cnk[i - 1][j]) % MOD;
}
}
for (int k = 0; k < N; k++)
{
for (int n = k; n < N; n++)
{
Supersigmacnk[k][n] = ((n != k ? Supersigmacnk[k][n - 1] : 0) + cnk[n][k]) % MOD;
Supersigmacnkdec[k][n] = ((n != k ? Supersigmacnkdec[k][n - 1] : 0) + Supersigmacnk[k][n]) % MOD;
Supersigmacnkinc[k][n] = ((n != k ? Supersigmacnkinc[k][n - 1] : 0) + (n - k) * cnk[n][k]) % MOD;
}
}
int n, m;
cin >> n >> m;
vector<int> a(m), b(m);
for (int i = 0; i < m; i++)
{
cin >> a[i] >> b[i];
a[i]--, b[i]--;
}
vector<int> h(n), edge_in(n);
dfs(0, 0, h, edge_in, a, b);
vector<int> suba(m);
for (int i = n - 1; i < m; i++)
{
int z = mark(a[i], b[i], h, edge_in, a, b);
suba[i] = z;
}
int M = 1 << (n - 1);
{
vector<ll> on_right(M, 0);
for (int mask = 1; mask < M; mask++)
{
for (int i = n - 1; i < m; i++)
{
if (suba[i] & mask)
{
on_right[mask]++;
}
}
on_right[mask] += __builtin_popcount(mask) - 1;
}
vector<ll> dp(M);
vector<ll> EV(M);
vector<ll> ans(M);
on_right[0] = -1;
dp[0] = 1;
for (int mask = 1; mask < M; mask++)
{
ll summ_right = 0, cnt_left = 0, cnt_right = 0;
for (int p = 0; p < n - 1; p++)
{
if (mask & (1 << p))
{
int pmask = mask - (1 << p);
if (pmask == 0)
{
dp[mask] = fact[on_right[mask]];
EV[mask] = fact[on_right[mask]];
ans[mask] = fact[on_right[mask]] * (m - on_right[mask]) % MOD;
continue;
}
int cnt = on_right[mask] - on_right[pmask] - 1;
ll ways = cnk[on_right[mask]][on_right[pmask] + 1] * fact[on_right[mask] - on_right[pmask] - 1] % MOD;
ll dpways = dp[pmask] * ways % MOD;
dp[mask] = (dp[mask] + dpways) % MOD;
ll W = fact[cnt] * dp[pmask] % MOD;
ll SS1 = supersigmacnkdec(1, on_right[pmask], on_right[mask] - 1);
cnt_left = (cnt_left + SS1 * W) % MOD;
ll SS2 = supersigmacnkinc(on_right[pmask] + 1, on_right[pmask], on_right[mask] - 1);
cnt_right = (cnt_right + SS2 * W) % MOD;
summ_right = (summ_right + SS2 * fact[cnt] % MOD * (EV[pmask] + dp[pmask])) % MOD;
ll SS3 = Supersigmacnk[on_right[pmask]][on_right[mask] - 1];
ll SS4 = supersigmacnkinc(0, on_right[pmask], on_right[mask] - 1);
ans[mask] = (ans[mask] + ans[pmask] * fact[cnt] % MOD * SS3
+ (m - on_right[mask]) * W % MOD * SS3
- EV[pmask] * fact[cnt] % MOD * SS4
) % MOD;
if (ans[mask] < 0) ans[mask] += MOD;
}
}
if (__builtin_popcount(mask) > 1)
{
//cout << mask << " " << summ_right << " " << cnt_left << " " << cnt_right << "\n";
EV[mask] = (cnt_left + summ_right) * inq((on_right[mask] + 1) % MOD, MOD - 2) % MOD;
}
//cout << mask << " " << dp[mask] << " " << EV[mask] << " " << ans[mask] << "\n";
}
//cout << dp[M - 1] << "\n";
cout << ans[M - 1] << "\n";
}
}
/* Note:
Check constants at the beginning of the code (MOD, INF, INFLL)
Check corner cases.
N = 1
No def int long long for now.
Add something here.
*/
|
#include <stack>
#include <cstdio>
using namespace std;
const int MOD(1000000000 + 7);
const int Max_N(25);
const int Max_M(405);
constexpr int Add(int a, int b)
{
return a + b >= MOD ? a + b - MOD : a + b;
}
constexpr int Sub(int a, int b)
{
return a - b < 0 ? a - b + MOD : a - b;
}
constexpr int Mult(int a, int b)
{
return a * 1LL * b % MOD;
}
void exgcd(int a, int b, int &x, int &y)
{
if (b == 0)
x = 1, y = 0;
else
exgcd(b, a % b, y, x), y -= x * (a / b);
}
inline int inverse(int a)
{
int invx, invy;
exgcd(a, MOD, invx, invy);
return (invx % MOD + MOD) % MOD;
}
inline void upd(int &a, int b)
{
a = Add(a, b);
}
int N, M, Head[Max_N], Total, To[Max_N << 1], Next[Max_N << 1], Weight[Max_N << 1], Can[1 << 19];
inline void Add_Edge(int s, int t, int w)
{
++Total, To[Total] = t, Next[Total] = Head[s], Head[s] = Total, Weight[Total] = w;
}
bool done[Max_N];
void dfs(int u, int T, stack<int> S)
{
if (u == T)
{
int All(0);
while (S.empty() == false)
All |= (1 << S.top()), S.pop();
++Can[All];
return;
}
done[u] = true;
for (int i = Head[u], v;i;i = Next[i])
if (!done[v = To[i]])
S.push(Weight[i]), dfs(v, T, S), S.pop();
done[u] = false;
}
void FMT(int F[1 << 19])
{
for (int i = 0;i <= N - 2;++i)
for (int S = 0;S < (1 << (N - 1));++S)
if ((S & (1 << i)) == 0)
upd(F[S + (1 << i)], F[S]);
}
int F0[1 << 19], F1[1 << 19], Fac[Max_M], Inv[Max_M];
int main()
{
scanf("%d%d", &N, &M);
Fac[0] = 1;
for (int i = 1;i <= M;++i)
Fac[i] = Mult(Fac[i - 1], i);
Inv[M] = inverse(Fac[M]);
for (int i = M - 1;i >= 0;--i)
Inv[i] = Mult(Inv[i + 1], i + 1);
for (int i = 0, a, b;i <= M - 1;++i)
{
scanf("%d%d", &a, &b);
if (i <= N - 2)
Add_Edge(a, b, i), Add_Edge(b, a, i);
else
dfs(a, b, stack<int>());
}
FMT(Can);
F0[0] = 1, F1[0] = 0;
for (int S = 0, have, _S;S < (1 << (N - 1));++S)
{
have = M - (N - 1) - Can[(1 << (N - 1)) - 1 - S], _S = 0;
for (int i = 0;i <= N - 2;++i)
have += ((S & (1 << i)) != 0), _S += ((S & (1 << i)) != 0);
for (int i = 0, cnt, xs;i <= N - 2;++i)
if ((S & (1 << i)) == 0)
{
cnt = Can[(1 << (N - 1)) - 1 - S] - Can[(1 << (N - 1)) - 1 - (S + (1 << i))];
xs = Mult(Fac[have + cnt], Inv[have]);
upd(F0[S + (1 << i)], Mult(F0[S], xs));
upd(F1[S + (1 << i)], Mult(_S + 1, Mult(F0[S], xs)));
upd(F1[S + (1 << i)], Mult(F1[S], xs));
if (cnt)
upd(F1[S + (1 << i)], Mult(cnt, Mult(F1[S], Mult(Fac[have + cnt], Inv[have + 1]))));
}
}
printf("%d", F1[(1 << (N - 1)) - 1]);
return 0;
} |
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline", "fast-math", "unroll-loops", "no-stack-protector")
#pragma GCC diagnostic error "-fwhole-program"
#pragma GCC diagnostic error "-fcse-skip-blocks"
#pragma GCC diagnostic error "-funsafe-loop-optimizations"
#include<cstdio>
#include<algorithm>
#include<vector>
#include<map>
#include<queue>
#include<cstring>
#define ll long long
using namespace std;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c, qu[55];
int f, qr;
#define gc() (iS == iT ? (iT = (iS = ibuf) + fread (ibuf, 1, SIZE, stdin), (iS == iT ? EOF : *iS ++)) : *iS ++)
inline void flush () {
fwrite (obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc (char x) {
*oS ++ = x;
if (oS == oT) flush ();
}
template<class T>
inline void getc(T &x)
{
for(c=gc();!((c>='a'&&c<='z')||(c>='A'&&c<='Z'));c=gc());
x=c;
}
template <class I>
inline void rd (I &x) {
for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;
for (x = 0; c <= '9' && c >= '0'; c = gc()) x = x * 10 + (c & 15);
x *= f;
}
template <class I>
inline void print (I x) {
if (!x) putc ('0');
if (x < 0) putc ('-'), x = -x;
while (x) qu[++ qr] = x % 10 + '0', x /= 10;
while (qr) putc (qu[qr --]);
}
struct Flusher_ {
~Flusher_() {
flush();
}
} io_flusher_;
}
using io :: rd;
using io :: putc;
using io :: print;
using io :: getc;
const int MOD=1e9+7;
int mo(int x,int y)
{
return x+y>=MOD?x+y-MOD:x+y;
}
int mu(int x,int y)
{
return (ll)x*y%MOD;
}
int sub(int x,int y)
{
return x<y?x-y+MOD:x-y;
}
int ksm(int x,int y)
{
int res=1;
for(;y;y>>=1,x=mu(x,x))
if(y&1) res=mu(res,x);
return res;
}
const int MAXN=200+5;
pair<int,int>e[MAXN];
vector<int>g[MAXN];
int n,m;
ll dp[2][(1<<20)|1],sum[2][(1<<20)|1];
int els[(1<<20)|1],bin[(1<<20)|1],dep[MAXN],fa[MAXN],id[(1<<20)|1];
void dfs(int x,int ff)
{
dep[x]=dep[ff]+1;fa[x]=ff;
for(int i=0;i<g[x].size();i++)
{
int v=g[x][i];
if(v==ff) continue;
dfs(v,x);
}
}
/*
int jc[MAXN],jcn[MAXN];
int C(int n,int m)
{
return (n<m)?0:mu(jc[n],mu(jcn[m],jcn[n-m]));
}
*/
int ADD(int x,int y)
{
return x<=0?0:(ll)x*y%MOD;
}
int up[MAXN];
int main()
{
// freopen("B.in","r",stdin);
// freopen("B.out","w",stdout);
rd(n);rd(m);
for(int i=1,x,y;i<=m;i++)
{
rd(x);rd(y);
e[i]=make_pair(x,y);
if(i<=n-1)
{
g[x].push_back(y);
g[y].push_back(x);
}
}
dfs(1,0);
/* for(int i=n,x,y;i<=m;i++)
{
x=e[i].first,y=e[i].second;
while(x!=y)
{
if(dep[x]>dep[y])
{
SL[i]|=(1<<x-1);
x=fa[x];
}
else
{
SL[i]|=(1<<y-1);
y=fa[y];
}
}
}*/
int es=n-1;
for(int S=1;S<(1<<es);S++)
bin[S]=bin[S-(S&(-S))]+1;
for(int i=1;i<=es;i++)
id[(1<<(i-1))]=i;
/*
for(int S=0;S<(1<<es);S++)
{
int nowS=0;
for(int j,i=S,x,y;i;i-=i&(-i))
{
j=id[i&(-i)];
x=e[j].first;y=e[j].second;
nowS|=(dep[x]<dep[y])?(1<<y-1):(1<<x-1);
}
for (int i=n;i<=m;i++)
els[S]+=((SL[i]&nowS)==SL[i]);
// if(cnt) fprintf(stderr,"%d %d\n",S,els[S]);
}*/
for(int i=1,x,y;i<n;i++)
{
x=e[i].first;y=e[i].second;
up[(dep[x]<dep[y])?y:x]=i;
}
for(int i=n,x,y,S;i<=m;i++)
{
S=0;
x=e[i].first,y=e[i].second;
while(x!=y)
{
if(dep[x]>dep[y])
{
S|=(1<<(up[x]-1));
x=fa[x];
}
else
{
S|=(1<<up[y]-1);
y=fa[y];
}
}
++els[S];
}
for(int i=0;i<es;i++)
for(int j=0;j<(1<<es);j++)
if((j>>i)&1)
els[j]+=els[j^(1<<i)];
/* for(int i=jc[0]=1;i<=m;i++) jc[i]=mu(jc[i-1],i);
jcn[m]=ksm(jc[m],MOD-2);
for(int i=m;i;i--)
jcn[i-1]=mu(jcn[i],i);
*/
dp[0][0]=1;int cur=0,nxt=1;
for(int i=1;i<=m;i++)
{
for(register int S=0,v;S<(1<<es);++S)
if(dp[cur][S]||sum[cur][S])
{
dp[cur][S]=(dp[cur][S]>=MOD)?dp[cur][S]%MOD:dp[cur][S];
sum[cur][S]=(sum[cur][S]>=MOD)?sum[cur][S]%MOD:sum[cur][S];
v=(els[S]-(i-1-bin[S]));
dp[nxt][S]+=v>0?dp[cur][S]*v:0;
sum[nxt][S]+=v>0?sum[cur][S]*v:0;
for(register int j=(1<<es)-1-S;j;j^=j&(-j))
{
int t=id[j&(-j)];
dp[nxt][S|(1<<(t-1))]+=dp[cur][S];
sum[nxt][S|(1<<(t-1))]+=dp[cur][S]*i+sum[cur][S];
}
dp[cur][S]=sum[cur][S]=0;
}
cur^=1;nxt^=1;
}
print(sum[cur][(1<<es)-1]%MOD);
putc('\n');
return 0;
} |
#include <iostream>
#include <string>
#include <cmath>
#include<algorithm>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<iomanip>
#define _USE_MATH_DEFINES
#include <math.h>
#include <functional>
#include<complex>
#include<cassert>
using namespace std;
#define rep(i,x) for(ll i=0;i<x;i++)
#define repn(i,x) for(ll i=1;i<=x;i++)
typedef long long ll;
const ll INF = 1e17;
const ll MOD = 1000000007;
const ll MAX = 4000001;
const long double eps = 1E-14;
ll max(ll a, ll b) {
if (a > b) { return a; }
return b;
}
ll min(ll a, ll b) {
if (a > b) { return b; }
return a;
}
ll gcd(ll a, ll b) {
if (b == 0) { return a; }
if (a < b) { return gcd(b, a); }
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
return a / gcd(a, b) * b;
}
struct edge {
ll ind;
ll fr;
ll to;
ll d;
};
class mint {
long long x;
public:
mint(long long x = 0) : x((x% MOD + MOD) % MOD) {}
mint operator-() const {
return mint(-x);
}
mint& operator+=(const mint& a) {
if ((x += a.x) >= MOD) x -= MOD;
return *this;
}
mint& operator-=(const mint& a) {
if ((x += MOD - a.x) >= MOD) x -= MOD;
return *this;
}
mint& operator*=(const mint& a) {
(x *= a.x) %= MOD;
return *this;
}
mint operator+(const mint& a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint& a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint& a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t) return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1) a *= *this;
return a;
}
// for prime MOD
mint inv() const {
return pow(MOD - 2);
}
mint& operator/=(const mint& a) {
return (*this) *= a.inv();
}
mint operator/(const mint& a) const {
mint res(*this);
return res /= a;
}
friend ostream& operator<<(ostream& os, const mint& m) {
os << m.x;
return os;
}
};
mint pw(mint a, ll b) {
if (b == 0) { return 1; }
mint ret = pw(a, b >> 1);
ret *= ret;
if (b & 1) { ret *= a; }
return ret;
}
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<vector<vector<ll>>> vvvll;
typedef vector<mint> vmint;
typedef vector<vector<mint>> vvmint;
typedef vector<vector<vector<mint>>> vvvmint;
/////////////////////////////////////
struct unionfind {
ll N;
vector<ll> par;
vector<ll> sz;//根の場合、その木のサイズ
unionfind(ll N0) {
N = N0;
par.assign(N + 1, -1);
sz.assign(N + 1, 1);
}
ll root(ll x) {
if (par[x] == -1) { return x; }
par[x] = root(par[x]);
return par[x];
}
bool same(ll x, ll y) {
return root(x) == root(y);
}
void unite(ll x, ll y) {
ll a = root(x);
ll b = root(y);
if (a != b) {
par[a] = b; sz[b] += sz[a];
}
}
ll size(ll x) {
ll r = root(x);
return sz[r];
}
};
int main(){
ll N, M;
cin >> N >> M;
vector<pair<ll, ll>> e(M);
rep(i, M)cin >> e[i].first >> e[i].second;
vector<vector<pair<ll,ll>>> g(N + 1);
vector <vector<bool>> mat(N + 1, vector<bool>(N + 1, 0));
rep(i, N-1) {
g[e[i].first].push_back({ i,e[i].second });
g[e[i].second].push_back({ i,e[i].first });
}
rep(i,M){
mat[e[i].first][e[i].second] = 1;
mat[e[i].second][e[i].first] = 1;
}
vector<int> c(1 << (N - 1), 0);
rep(i, 1 << (N - 1)) {
vvll lis(N + 1);
vll see(N + 1, 0);
repn(v, N) {
//cout << v << endl;
if (see[v] != 0) { continue; }
lis[v].push_back(v);
see[v] = 1;
queue<ll> q;
q.push(v);
while (!q.empty()) {
ll w = q.front();
q.pop();
for (auto p : g[w]) {
if (see[p.second] != 0) { continue; }
if (!((i >> p.first) & 1)) { continue; }
see[p.second] = 1;
lis[v].push_back(p.second);
q.push(p.second);
}
}
}
repn(j, N) {
rep(k, lis[j].size())for (ll l = k + 1; l < lis[j].size(); l++) {
if (mat[lis[j][k]][lis[j][l]]) { c[i]++; }
}
}
//cout << i << " " << c[i] << endl;
}
//return 0;
vector<vector<ll>> dp1(1 << (N - 1)), dp2(1 << (N - 1));
dp1[0].push_back(1);
dp2[0].push_back(0);
repn(i, (1 << (N - 1))-1) {
//cout << i << endl;
dp1[i].assign(c[i]+1, 0);
dp2[i].assign(c[i]+1, 0);
rep(k, N - 1) {
if (!((i >> k) & 1)) { continue; }
ll x = i ^ (1 << k);
repn(j, c[x]+1) {
dp1[i][j] += dp1[x][j - 1];
dp2[i][j] += dp2[x][j - 1] + dp1[x][j - 1] * j;
dp1[i][j] %= MOD;
dp2[i][j] %= MOD;
}
}
repn(j, c[i]) {
dp1[i][j] += dp1[i][j - 1] * (c[i] - (j - 1));
dp2[i][j] += dp2[i][j - 1] * (c[i] - (j - 1));
dp1[i][j] %= MOD;
dp2[i][j] %= MOD;
}
//repn(j, c[i])cout << i << j << dp1[i][j] << dp2[i][j] << endl;
}
cout << dp2[(1 << (N - 1)) - 1][M] << endl;
}
|
#include <iostream>
#include <string>
#include <stdio.h>
#include <string.h>
#include <vector>
#include <ctime>
#include <set>
#include <map>
#include <unordered_map>
#include <queue>
#include <algorithm>
#include <cmath>
#include <assert.h>
#include <iomanip>
#include <bitset>
using namespace std;
#define vi vector<int>
#define pii pair<int,int>
#define pb push_back
#define mp make_pair
#define all(x) x.begin(),x.end()
#define SZ(x) (int)(x.size())
#define rep(i,a,b) for(int i=a;i<b;i++)
#define per(i,a,b) for(int i=b-1;i>=a;i--)
#define inf 1000000007
#define mod 1000000007
#define x first
#define y second
#define pi acos(-1.0)
#define DBG(x) cerr<<(#x)<<"="<<x<<"\n";
//#define dprintf(...)
#define hash _hash
//#define dprintf(...) fprintf(outFile,__VA_ARGS__)
#define FOREACH(it,x) for(__typeof(x.begin()) it=x.begin();it!=x.end();it++)
#define ull unsigned long long
#define ll long long
#define N 500010
template <class T,class U>inline void Max(T &a,U b){if(a<b)a=b;}
template <class T,class U>inline void Min(T &a,U b){if(a>b)a=b;}
//FILE* outFile;
inline void add(int &a,int b){a+=b;while(a>=mod)a-=mod;}
int pow(int a,int b){
int ans=1;
while(b){
if(b&1)ans=ans*(ll)a%mod;
a=(ll)a*a%mod;b>>=1;
}
return ans;
}
int cnt[1<<19], dp[1<<19][2], bit[1<<19];
vector<pii> g[20];
int dfs(int u, int t, int fa = -1){
if(u == t)return 0;
for(auto &o : g[u]){
if(o.x == fa)continue;
int ret = dfs(o.x, t, u);
if(ret >= 0)return (1<<o.y)|ret;
}
return -1;
}
int main(){
int j,k,i,T,ca=0,K=0,m, n;
scanf("%d%d", &n, &m);
rep(i, 0, n-1){
scanf("%d%d", &j, &k);j--,k--;
g[j].pb({k, i}), g[k].pb({j, i});
}
rep(i, 0, m-(n-1)){
scanf("%d%d", &j, &k);j--, k--;
K = dfs(j, k);
cnt[K]++;
}
int sz = n - 1;
rep(i, 0, sz){
rep(j, 0, (1<<sz))if(j >> i & 1)cnt[j] += cnt[j^(1<<i)];
}
rep(i, 1, (1<<sz)){
bit[i] = bit[i>>1] + (i&1);
}
dp[0][0] = 1;
int msk = (1<<sz) - 1;
rep(j, 0, m - sz + 1){
rep(s, 0, (1<<sz))if(dp[s][0] || dp[s][1]){
int t = msk ^ s;
int v = j + bit[s] + 1;
int w = (1LL * dp[s][0] * v + dp[s][1] ) % mod;
for(k = (t & -t); k; t -= k, k = t & -t){
(dp[k | s][0] += dp[s][0]) %= mod;
(dp[k | s][1] += w) %= mod;
}
}
if(j == m - sz)break;
rep(s, 0, (1<<sz))if(cnt[s] >= j){
dp[s][0] = 1LL * dp[s][0] * (cnt[s] - j) % mod;
dp[s][1] = 1LL * dp[s][1] * (cnt[s] - j) % mod;
}
}
printf("%d\n", dp[msk][1]);
return 0;
}
|
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline", "fast-math", "unroll-loops", "no-stack-protector")
#pragma GCC diagnostic error "-fwhole-program"
#pragma GCC diagnostic error "-fcse-skip-blocks"
#pragma GCC diagnostic error "-funsafe-loop-optimizations"
#include<cstdio>
#include<algorithm>
#include<vector>
#include<map>
#include<queue>
#include<cstring>
#define ll long long
using namespace std;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c, qu[55];
int f, qr;
#define gc() (iS == iT ? (iT = (iS = ibuf) + fread (ibuf, 1, SIZE, stdin), (iS == iT ? EOF : *iS ++)) : *iS ++)
inline void flush () {
fwrite (obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc (char x) {
*oS ++ = x;
if (oS == oT) flush ();
}
template<class T>
inline void getc(T &x)
{
for(c=gc();!((c>='a'&&c<='z')||(c>='A'&&c<='Z'));c=gc());
x=c;
}
template <class I>
inline void rd (I &x) {
for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;
for (x = 0; c <= '9' && c >= '0'; c = gc()) x = x * 10 + (c & 15);
x *= f;
}
template <class I>
inline void print (I x) {
if (!x) putc ('0');
if (x < 0) putc ('-'), x = -x;
while (x) qu[++ qr] = x % 10 + '0', x /= 10;
while (qr) putc (qu[qr --]);
}
struct Flusher_ {
~Flusher_() {
flush();
}
} io_flusher_;
}
using io :: rd;
using io :: putc;
using io :: print;
using io :: getc;
const int MOD=1e9+7;
int mo(int x,int y)
{
return x+y>=MOD?x+y-MOD:x+y;
}
int mu(int x,int y)
{
return (ll)x*y%MOD;
}
int sub(int x,int y)
{
return x<y?x-y+MOD:x-y;
}
int ksm(int x,int y)
{
int res=1;
for(;y;y>>=1,x=mu(x,x))
if(y&1) res=mu(res,x);
return res;
}
const int MAXN=200+5;
pair<int,int>e[MAXN];
vector<int>g[MAXN];
int dp[2][(1<<20)|1],n,m;
int sum[2][(1<<20)|1],SL[MAXN];
int els[(1<<20)|1],bin[(1<<20)|1],dep[MAXN],fa[MAXN],id[(1<<20)|1];
void dfs(int x,int ff)
{
dep[x]=dep[ff]+1;fa[x]=ff;
for(int i=0;i<g[x].size();i++)
{
int v=g[x][i];
if(v==ff) continue;
dfs(v,x);
}
}
/*
int jc[MAXN],jcn[MAXN];
int C(int n,int m)
{
return (n<m)?0:mu(jc[n],mu(jcn[m],jcn[n-m]));
}
*/
int ADD(int x,int y)
{
return x<=0?0:(ll)x*y%MOD;
}
int main()
{
// freopen("B.in","r",stdin);
// freopen("B.out","w",stdout);
rd(n);rd(m);
for(int i=1,x,y;i<=m;i++)
{
rd(x);rd(y);
e[i]=make_pair(x,y);
if(i<=n-1)
{
g[x].push_back(y);
g[y].push_back(x);
}
}
dfs(1,0);
for(int i=n,x,y;i<=m;i++)
{
x=e[i].first,y=e[i].second;
while(x!=y)
{
if(dep[x]>dep[y])
{
SL[i]|=(1<<x-1);
x=fa[x];
}
else
{
SL[i]|=(1<<y-1);
y=fa[y];
}
}
}
int es=n-1;
for(int S=1;S<(1<<es);S++)
bin[S]=bin[S-(S&(-S))]+1;
for(int i=1;i<=es;i++)
id[(1<<(i-1))]=i;
for(int S=0;S<(1<<es);S++)
{
int nowS=0;
for(int j,i=S,x,y;i;i-=i&(-i))
{
j=id[i&(-i)];
x=e[j].first;y=e[j].second;
nowS|=(dep[x]<dep[y])?(1<<y-1):(1<<x-1);
}
for (int i=n;i<=m;i++)
els[S]+=((SL[i]&nowS)==SL[i]);
// if(cnt) fprintf(stderr,"%d %d\n",S,els[S]);
}
/* for(int i=jc[0]=1;i<=m;i++) jc[i]=mu(jc[i-1],i);
jcn[m]=ksm(jc[m],MOD-2);
for(int i=m;i;i--)
jcn[i-1]=mu(jcn[i],i);
*/
dp[0][0]=1;int cur=0,nxt=1;
for(int i=1;i<=m;i++)
{
for(register int S=0;S<(1<<es);++S)
if(dp[cur][S]||sum[cur][S])
{
dp[nxt][S]=mo(dp[nxt][S],ADD(els[S]-(i-1-bin[S]),dp[cur][S]));
sum[nxt][S]=mo(sum[nxt][S],ADD(els[S]-(i-1-bin[S]),sum[cur][S]));
for(register int j=(1<<es)-1-S;j;j^=j&(-j))
{
int t=id[j&(-j)];
dp[nxt][S|(1<<(t-1))]=mo(dp[nxt][S|(1<<(t-1))],dp[cur][S]);
sum[nxt][S|(1<<(t-1))]=(1ll*dp[cur][S]*i+sum[nxt][S|(1<<(t-1))]+sum[cur][S])%MOD;
}
dp[cur][S]=sum[cur][S]=0;
}
cur^=1;nxt^=1;
}
print(sum[cur][(1<<es)-1]);
putc('\n');
return 0;
} |
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
const long long INFLL = 1e18;
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vector<int> > vvi;
typedef vector<ll> vll;
typedef complex<double> cd;
#define forn(i, n) for (int (i) = 0; (i) != (n); (i)++)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define popcount(x) __builtin_popcount(x)
#define popcountll(x) __builtin_popcountll(x)
#define fi first
#define se second
#define re return
#define pb push_back
#define uniq(x) sort(all(x)); (x).resize(unique(all(x)) - (x).begin())
#ifdef LOCAL
#define dbg(x) cerr << __LINE__ << " " << #x << " " << x << endl
#define ln cerr << __LINE__ << endl
#else
#define dbg(x) void(0)
#define ln void(0)
#endif // LOCAL
int cx[4] = {-1, 0, 1, 0};
int cy[4] = {0, -1, 0, 1};
string Yes[2] = {"No\n", "Yes\n"};
string YES[2] = {"NO\n", "YES\n"};
string Possible[2] = {"Impossible\n", "Possible\n"};
string POSSIBLE[2] = {"IMPOSSIBLE\n", "POSSIBLE\n"};
int ok(int x, int n)
{
return 0 <= x && x < n;
}
ll log10(ll x)
{
if (x < 10) re 1;
re 1 + log10(x / 10);
}
ll ds(ll x)
{
if (x < 10) return x;
re x % 10 + ds(x / 10);
}
double sqr(double x)
{
return x * x;
}
bool inmask(int bit, int mask)
{
return (mask & (1 << bit)) > 0;
}
void Del(vector<int> &v, int pos)
{
swap(v[pos], v[v.size() - 1]);
v.pop_back();
}
long long g(vector<long long> &p, int pos)
{
if (ok(pos, p.size())) return p[pos];
if (pos < 0 || p.size() == 0) return 0;
return p.back();
}
int g(vector<int> &p, int pos)
{
if (ok(pos, p.size())) return p[pos];
if (pos < 0 || p.size() == 0) return 0;
return p.back();
}
ll inq(ll x, ll y)
{
if (!y) re 1 % MOD;
ll l = inq(x, y / 2);
if (y % 2) re l * l % MOD * x % MOD;
re l * l % MOD;
}
ll rev(ll x)
{
return inq(x, MOD - 2);
}
int __precomputed_combinatorics = 0;
vector<ll> __fact, __ufact, __rev;
inline void __precompute_combinatorics(int __n)
{
if (__precomputed_combinatorics >= __n)
return;
__fact.resize(__n);
__ufact.resize(__n);
__rev.resize(__n);
__rev[1] = 1;
for (int i = max(2, __precomputed_combinatorics); i < __n; i++)
__rev[i] = MOD - __rev[MOD % i] * (MOD / i) % MOD;
__fact[0] = 1, __ufact[0] = 1;
for (int i = max(1, __precomputed_combinatorics); i < __n; i++)
__fact[i] = __fact[i - 1] * i % MOD, __ufact[i] = __ufact[i - 1] * __rev[i] % MOD;
__precomputed_combinatorics = __n;
}
ll fact(int x)
{
if (__precomputed_combinatorics <= x)
__precompute_combinatorics(x + 1);
return __fact[x];
}
ll cnk(int n, int k)
{
if (k < 0 || k > n)
return 0;
if (__precomputed_combinatorics <= n)
__precompute_combinatorics(n + 1);
return __fact[n] * __ufact[n - k] % MOD * __ufact[k] % MOD;
}
ll inq(ll x, ll y, ll mod)
{
if (y == 0) return 1 % mod;
ll l = inq(x, y / 2, mod);
if (y % 2) return l * l % mod * x % mod;
return l * l % mod;
}
void dfs(int v, int par, vector<int> &h, vector<int> &edge_in, vector<int> &a, vector<int> &b)
{
if (v == par) h[v] = 0;
else h[v] = h[par] + 1;
for (int i = 0; i < h.size() - 1; i++)
{
if (a[i] == v || b[i] == v)
{
int u = a[i] + b[i] - v;
if (u != par)
{
edge_in[u] = i;
dfs(u, v, h, edge_in, a, b);
}
}
}
}
int mark(int v, int u, vector<int> &h, vector<int> &edge_in, vector<int> &a, vector<int> &b)
{
int mask = 0;
while (h[v] > h[u])
{
mask += 1 << edge_in[v];
int f = a[edge_in[v]] + b[edge_in[v]] - v;
v = f;
}
while (h[v] < h[u])
{
mask += 1 << edge_in[u];
int f = a[edge_in[u]] + b[edge_in[u]] - u;
u = f;
}
while (v != u)
{
mask += 1 << edge_in[v];
int f = a[edge_in[v]] + b[edge_in[v]] - v;
v = f;
mask += 1 << edge_in[u];
f = a[edge_in[u]] + b[edge_in[u]] - u;
u = f;
}
return mask;
}
signed main()
{
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<int> a(m), b(m);
for (int i = 0; i < m; i++)
{
cin >> a[i] >> b[i];
a[i]--, b[i]--;
}
vector<int> h(n), edge_in(n);
dfs(0, 0, h, edge_in, a, b);
vector<int> suba(m);
for (int i = n - 1; i < m; i++)
{
int z = mark(a[i], b[i], h, edge_in, a, b);
suba[i] = z;
}
int M = 1 << (n - 1);
{
vector<ll> on_right(M, 0);
for (int mask = 1; mask < M; mask++)
{
for (int i = n - 1; i < m; i++)
{
if (suba[i] & mask)
{
on_right[mask]++;
}
}
on_right[mask] += __builtin_popcount(mask) - 1;
}
vector<ll> dp(M);
vector<ll> EV(M);
vector<ll> ans(M);
on_right[0] = -1;
dp[0] = 1;
for (int mask = 1; mask < M; mask++)
{
ll summ_left = 0, summ_right = 0, cnt_left = 0, cnt_right = 0;
for (int p = 0; p < n - 1; p++)
{
if (mask & (1 << p))
{
int pmask = mask - (1 << p);
if (pmask == 0)
{
dp[mask] = fact(on_right[mask]);
EV[mask] = 1;
ans[mask] = fact(on_right[mask]) * (m - on_right[mask]) % MOD;
continue;
}
int cnt = on_right[mask] - on_right[pmask] - 1;
for (int here = 0; here <= cnt; here++)
{
int there = cnt - here;
ll ways = fact(cnt) % MOD * cnk(on_right[mask] - here - 1, on_right[pmask]) % MOD;
ll dpways = ways * dp[pmask] % MOD;
cnt_right = (cnt_right + (on_right[pmask] + 1 + there) * dpways) % MOD;
cnt_left = (cnt_left + (here + 1) * dpways) % MOD;
summ_right = (summ_right + (EV[pmask] + 1) * (on_right[pmask] + 1 + there) % MOD * dpways) % MOD;
summ_left = (summ_left + (here + 1) * dpways) % MOD;
ans[mask] = (ans[mask] + ans[pmask] * ways + (m - on_right[mask]) * dpways
- there * EV[pmask] % MOD * dpways) % MOD;
if (ans[mask] < 0) ans[mask] += MOD;
}
ll ways = cnk(on_right[mask], on_right[pmask] + 1) * fact(on_right[mask] - on_right[pmask] - 1) % MOD;
ll dpways = dp[pmask] * ways % MOD;
dp[mask] = (dp[mask] + dpways) % MOD;
}
}
if (__builtin_popcount(mask) > 1)
{
//cout << mask << " " << summ_left << " " << summ_right << " " << cnt_left << " " << cnt_right << "\n";
EV[mask] = (summ_left + summ_right) * inq(cnt_left + cnt_right, MOD - 2) % MOD;
}
//cout << mask << " " << dp[mask] << " " << EV[mask] << " " << ans[mask] << "\n";
}
//cout << dp[M - 1] << "\n";
cout << ans[M - 1] << "\n";
}
}
/* Note:
Check constants at the beginning of the code (MOD, INF, INFLL)
Check corner cases.
N = 1
No def int long long for now.
Add something here.
*/
|
const long long MOD = 1e9 + 7;
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll inq(ll x, ll y)
{
if (!y) return 1 % MOD;
ll l = inq(x, y / 2);
if (y % 2) return l * l % MOD * x % MOD;
return l * l % MOD;
}
void dfs(int v, int par, vector<int> &h, vector<int> &edge_in, vector<int> &a, vector<int> &b)
{
if (v == par) h[v] = 0;
else h[v] = h[par] + 1;
for (int i = 0; i < h.size() - 1; i++)
{
if (a[i] == v || b[i] == v)
{
int u = a[i] + b[i] - v;
if (u != par)
{
edge_in[u] = i;
dfs(u, v, h, edge_in, a, b);
}
}
}
}
int mark(int v, int u, vector<int> &h, vector<int> &edge_in, vector<int> &a, vector<int> &b)
{
int mask = 0;
while (h[v] > h[u])
{
mask += 1 << edge_in[v];
int f = a[edge_in[v]] + b[edge_in[v]] - v;
v = f;
}
while (h[v] < h[u])
{
mask += 1 << edge_in[u];
int f = a[edge_in[u]] + b[edge_in[u]] - u;
u = f;
}
while (v != u)
{
mask += 1 << edge_in[v];
int f = a[edge_in[v]] + b[edge_in[v]] - v;
v = f;
mask += 1 << edge_in[u];
f = a[edge_in[u]] + b[edge_in[u]] - u;
u = f;
}
return mask;
}
const int N = 206;
ll Supersigmacnk[N][N];
ll Supersigmacnkdec[N][N];
ll Supersigmacnkinc[N][N];
ll cnk[N][N];
ll fact[N];
ll supersigmacnkdec(ll i, ll k, ll n)
{
ll ans = Supersigmacnk[k][n] * (i + MOD - 1) % MOD;
ans = (ans + Supersigmacnkdec[k][n]) % MOD;
return ans;
}
ll supersigmacnkinc(ll i, ll k, ll n)
{
ll ans = Supersigmacnk[k][n] * i % MOD;
ans = (ans + Supersigmacnkinc[k][n]) % MOD;
return ans;
}
signed main()
{
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
fact[0] = 1;
for (int i = 1; i < N; i++) fact[i] = (fact[i - 1] * i) % MOD;
for (int i = 0; i < N; i++)
{
cnk[i][0] = cnk[i][i] = 1;
for (int j = 1; j < i; j++)
{
cnk[i][j] = (cnk[i - 1][j - 1] + cnk[i - 1][j]) % MOD;
}
}
for (int k = 0; k < N; k++)
{
for (int n = k; n < N; n++)
{
Supersigmacnk[k][n] = ((n != k ? Supersigmacnk[k][n - 1] : 0) + cnk[n][k]) % MOD;
Supersigmacnkdec[k][n] = ((n != k ? Supersigmacnkdec[k][n - 1] : 0) + Supersigmacnk[k][n]) % MOD;
Supersigmacnkinc[k][n] = ((n != k ? Supersigmacnkinc[k][n - 1] : 0) + (n - k) * cnk[n][k]) % MOD;
}
}
int n, m;
cin >> n >> m;
vector<int> a(m), b(m);
for (int i = 0; i < m; i++)
{
cin >> a[i] >> b[i];
a[i]--, b[i]--;
}
vector<int> h(n), edge_in(n);
dfs(0, 0, h, edge_in, a, b);
vector<int> suba(m);
for (int i = n - 1; i < m; i++)
{
int z = mark(a[i], b[i], h, edge_in, a, b);
suba[i] = z;
}
int M = 1 << (n - 1);
{
vector<ll> on_right(M, 0);
for (int mask = 1; mask < M; mask++)
{
for (int i = n - 1; i < m; i++)
{
if (suba[i] & mask)
{
on_right[mask]++;
}
}
on_right[mask] += __builtin_popcount(mask) - 1;
}
vector<ll> dp(M);
vector<ll> EV(M);
vector<ll> ans(M);
on_right[0] = -1;
dp[0] = 1;
for (int mask = 1; mask < M; mask++)
{
ll summ_right = 0, cnt_left = 0, cnt_right = 0;
for (int p = 0; p < n - 1; p++)
{
if (mask & (1 << p))
{
int pmask = mask - (1 << p);
if (pmask == 0)
{
dp[mask] = fact[on_right[mask]];
EV[mask] = 1;
ans[mask] = fact[on_right[mask]] * (m - on_right[mask]) % MOD;
continue;
}
int cnt = on_right[mask] - on_right[pmask] - 1;
ll ways = cnk[on_right[mask]][on_right[pmask] + 1] * fact[on_right[mask] - on_right[pmask] - 1] % MOD;
ll dpways = dp[pmask] * ways % MOD;
dp[mask] = (dp[mask] + dpways) % MOD;
ll W = fact[cnt] * dp[pmask] % MOD;
ll SS1 = supersigmacnkdec(1, on_right[pmask], on_right[mask] - 1);
cnt_left = (cnt_left + SS1 * W) % MOD;
ll SS2 = supersigmacnkinc(on_right[pmask] + 1, on_right[pmask], on_right[mask] - 1);
cnt_right = (cnt_right + SS2 * W) % MOD;
summ_right = (summ_right + SS2 * W % MOD * (EV[pmask] + 1)) % MOD;
ll SS3 = Supersigmacnk[on_right[pmask]][on_right[mask] - 1];
ll SS4 = supersigmacnkinc(0, on_right[pmask], on_right[mask] - 1);
ans[mask] = (ans[mask] + ans[pmask] * fact[cnt] % MOD * SS3
+ (m - on_right[mask]) * W % MOD * SS3
- EV[pmask] * W % MOD * SS4
) % MOD;
if (ans[mask] < 0) ans[mask] += MOD;
}
}
if (__builtin_popcount(mask) > 1)
{
//cout << mask << " " << summ_left << " " << summ_right << " " << cnt_left << " " << cnt_right << "\n";
EV[mask] = (cnt_left + summ_right) * inq(cnt_left + cnt_right, MOD - 2) % MOD;
}
//cout << mask << " " << dp[mask] << " " << EV[mask] << " " << ans[mask] << "\n";
}
//cout << dp[M - 1] << "\n";
cout << ans[M - 1] << "\n";
}
}
/* Note:
Check constants at the beginning of the code (MOD, INF, INFLL)
Check corner cases.
N = 1
No def int long long for now.
Add something here.
*/
|
const long long MOD = 1e9 + 7;
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
void dfs(int v, int par, vector<int> &h, vector<int> &edge_in, vector<int> &a, vector<int> &b)
{
if (v == par) h[v] = 0;
else h[v] = h[par] + 1;
for (int i = 0; i < h.size() - 1; i++)
{
if (a[i] == v || b[i] == v)
{
int u = a[i] + b[i] - v;
if (u != par)
{
edge_in[u] = i;
dfs(u, v, h, edge_in, a, b);
}
}
}
}
int mark(int v, int u, vector<int> &h, vector<int> &edge_in, vector<int> &a, vector<int> &b)
{
int mask = 0;
while (h[v] > h[u])
{
mask += 1 << edge_in[v];
int f = a[edge_in[v]] + b[edge_in[v]] - v;
v = f;
}
while (h[v] < h[u])
{
mask += 1 << edge_in[u];
int f = a[edge_in[u]] + b[edge_in[u]] - u;
u = f;
}
while (v != u)
{
mask += 1 << edge_in[v];
int f = a[edge_in[v]] + b[edge_in[v]] - v;
v = f;
mask += 1 << edge_in[u];
f = a[edge_in[u]] + b[edge_in[u]] - u;
u = f;
}
return mask;
}
const int N = 206;
const int M = (1 << 19) + 2;
ll dp[M];
ll EV[M];
ll ans[M];
int on_right[M];
ll Supersigmacnk[N][N];
ll Supersigmacnkdec[N][N];
ll Supersigmacnkinc[N][N];
ll cnk[N][N];
ll fact[N];
ll rev[N];
inline ll supersigmacnkdec(ll i, ll k, ll n)
{
ll ans = Supersigmacnk[k][n] * (i + MOD - 1) % MOD;
ans = (ans + Supersigmacnkdec[k][n]) % MOD;
return ans;
}
inline ll supersigmacnkinc(ll i, ll k, ll n)
{
ll ans = Supersigmacnk[k][n] * i % MOD;
ans = (ans + Supersigmacnkinc[k][n]) % MOD;
return ans;
}
signed main()
{
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
fact[0] = 1;
rev[1] = 1;
for (int i = 1; i < N; i++) fact[i] = (fact[i - 1] * i) % MOD;
for (int i = 2; i < N; i++) rev[i] = MOD - (MOD / i) * rev[MOD % i] % MOD;
for (int i = 0; i < N; i++)
{
cnk[i][0] = cnk[i][i] = 1;
for (int j = 1; j < i; j++)
{
cnk[i][j] = (cnk[i - 1][j - 1] + cnk[i - 1][j]) % MOD;
}
}
for (int k = 0; k < N; k++)
{
for (int n = k; n < N; n++)
{
Supersigmacnk[k][n] = ((n != k ? Supersigmacnk[k][n - 1] : 0) + cnk[n][k]) % MOD;
Supersigmacnkdec[k][n] = ((n != k ? Supersigmacnkdec[k][n - 1] : 0) + Supersigmacnk[k][n]) % MOD;
Supersigmacnkinc[k][n] = ((n != k ? Supersigmacnkinc[k][n - 1] : 0) + (n - k) * cnk[n][k]) % MOD;
}
}
int n, m;
cin >> n >> m;
vector<int> a(m), b(m);
for (int i = 0; i < m; i++)
{
cin >> a[i] >> b[i];
a[i]--, b[i]--;
}
vector<int> h(n), edge_in(n);
dfs(0, 0, h, edge_in, a, b);
vector<int> suba(m);
for (int i = n - 1; i < m; i++)
{
int z = mark(a[i], b[i], h, edge_in, a, b);
suba[i] = z;
}
int M = 1 << (n - 1);
{
for (int i = n - 1; i < m; i++)
{
int w = M - 1 - suba[i];
on_right[w]++;
}
for (int b = 0; b < n - 1; b++)
{
for (int i = M - 1; i >= 0; i--)
{
if (i & (1 << b)) continue;
on_right[i] += on_right[i + (1 << b)];
}
}
for (int mask = 1; mask < M; mask++)
{
on_right[mask] = m - n + 1 - on_right[mask];
on_right[mask] += __builtin_popcount(mask) - 1;
}
on_right[0] = -1;
dp[0] = 1;
for (int mask = 1; mask < M; mask++)
{
ll summ_right = 0, cnt_left = 0;
for (int p = 0; p < n - 1; p++)
{
if (mask & (1 << p))
{
int pmask = mask - (1 << p);
if (pmask == 0)
{
dp[mask] = fact[on_right[mask]];
EV[mask] = fact[on_right[mask]];
ans[mask] = fact[on_right[mask]] * (m - on_right[mask]) % MOD;
continue;
}
int cnt = on_right[mask] - on_right[pmask] - 1;
ll ways = cnk[on_right[mask]][on_right[pmask] + 1] * fact[on_right[mask] - on_right[pmask] - 1] % MOD;
ll dpways = dp[pmask] * ways % MOD;
dp[mask] = (dp[mask] + dpways) % MOD;
ll W = fact[cnt] * dp[pmask] % MOD;
ll SS1 = Supersigmacnkdec[on_right[pmask]][on_right[mask] - 1];
cnt_left = (cnt_left + SS1 * W) % MOD;
ll SS2 = supersigmacnkinc(on_right[pmask] + 1, on_right[pmask], on_right[mask] - 1);
summ_right = (summ_right + SS2 * fact[cnt] % MOD * (EV[pmask] + dp[pmask])) % MOD;
ll SS3 = Supersigmacnk[on_right[pmask]][on_right[mask] - 1];
ll SS4 = supersigmacnkinc(0, on_right[pmask], on_right[mask] - 1);
ans[mask] = (ans[mask] + ans[pmask] * fact[cnt] % MOD * SS3
+ (m - on_right[mask]) * W % MOD * SS3
- EV[pmask] * fact[cnt] % MOD * SS4
) % MOD;
if (ans[mask] < 0) ans[mask] += MOD;
}
}
if (__builtin_popcount(mask) > 1)
{
//cout << mask << " " << summ_right << " " << cnt_left << " " << cnt_right << "\n";
EV[mask] = (cnt_left + summ_right) * rev[on_right[mask] + 1] % MOD;
}
//cout << mask << " " << dp[mask] << " " << EV[mask] << " " << ans[mask] << "\n";
}
//cout << dp[M - 1] << "\n";
cout << ans[M - 1] << "\n";
}
}
/* Note:
Check constants at the beginning of the code (MOD, INF, INFLL)
Check corner cases.
N = 1
No def int long long for now.
Add something here.
*/
|
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
#include<vector>
#include<ctime>
#include<map>
#include<bitset>
#include<set>
#include<assert.h>
#include<chrono>
#include<random>
#define LL long long
#define mp(x,y) make_pair(x,y)
#define pll pair<long long,long long>
#define pii pair<int,int>
#define SZ(x) ((int)x.size())
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
inline LL read()
{
LL f=1,x=0;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
int stack[20];
template<typename T>inline void write(T x)
{
if(x<0){putchar('-');x=-x;}
if(!x){putchar('0');return;}
int top=0;
while(x)stack[++top]=x%10,x/=10;
while(top)putchar(stack[top--]+'0');
}
template<typename T>inline void pr1(T x){write(x);putchar(' ');}
template<typename T>inline void pr2(T x){write(x);putchar('\n');}
template<typename T>inline void chkmin(T &x,T y){x=x<y?x:y;}
template<typename T>inline void chkmax(T &x,T y){x=x>y?x:y;}
const int MAXMASK=(1<<19);
const int mod=1e9+7;
const int MAXN=25;
int pow_mod(int a,int b)
{
int ret=1;
for(;b;b>>=1,a=1LL*a*a%mod)if(b&1)ret=1LL*ret*a%mod;
return ret;
}
void ad(int &x,int y){x+=y;if(x>=mod)x-=mod;}
vector<int> nxt[MAXN];
void ins(int x,int y){nxt[x].emplace_back(y);}
int f[MAXMASK],g[MAXMASK],E[MAXMASK];
int n,m,bin[25],ex[MAXN*MAXN],ey[MAXN*MAXN],mask[MAXN*MAXN],Log[MAXMASK];
int rt[MAXN];
int findrt(int x){return rt[x]==x?rt[x]:rt[x]=findrt(rt[x]);}
int lowbit(int x){return x&-x;}
int pre[MAXN*MAXN],inv[MAXN*MAXN];
map<int,int> mp[MAXN];
int get_edge(int x,int fa,int ed)
{
if(x==ed)return 0;
for(auto y:nxt[x])if(y^fa)
{
int t=get_edge(y,x,ed);
if(t!=-1)return t|bin[mp[x][y]-1];
}return -1;
}
int main()
{
pre[0]=1;for(int i=1;i<MAXN*MAXN;i++)pre[i]=1LL*pre[i-1]*i%mod;
inv[MAXN*MAXN-1]=pow_mod(pre[MAXN*MAXN-1],mod-2);
for(int i=MAXN*MAXN-2;i>=0;i--)inv[i]=1LL*inv[i+1]*(i+1)%mod;
bin[0]=1;for(int i=1;i<=20;i++)bin[i]=bin[i-1]<<1;
for(int i=0;(1<<i)<MAXMASK;i++)Log[1<<i]=i;
n=read();m=read();
for(int i=1;i<=m;i++)
{
ex[i]=read(),ey[i]=read();
if(i<n)ins(ex[i],ey[i]),ins(ey[i],ex[i]),mp[ex[i]][ey[i]]=mp[ey[i]][ex[i]]=i;
}
for(int i=n;i<=m;i++)mask[i]=get_edge(ex[i],0,ey[i]);
for(int i=0;i<bin[n-1];i++)
for(int j=n;j<=m;j++)E[i]+=(mask[j]&i)>0;
g[0]=1;
for(int i=0;i<bin[n-1];i++)if(g[i])
{
int t=__builtin_popcount(i);
for(int S=(bin[n-1]-1)^i;S;S^=lowbit(S))
{
int u=lowbit(S),newe=E[i|u]-E[i],pree=E[i]+t;
int newg=1LL*g[i]*pre[pree+newe]%mod*inv[pree]%mod;
int newf=1LL*f[i]*pre[pree+newe+1]%mod*inv[pree+1]%mod;
ad(newf,1LL*(t+1)*newg%mod);
ad(g[i|u],newg);ad(f[i|u],newf);
}
}
pr2(f[bin[n-1]-1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define forn(i, n) for (int i = 0; i < (int)(n); i++)
#define all(a) a.begin(), a.end()
int bit(int a, int i) { return (a >> i) & 1; }
typedef long long ll;
const int MOD = 1e9 + 7;
const int N = 20, M = N * (N - 1) / 2;
void add(int &a, int b) {
if ((a += b) >= MOD)
a -= MOD;
}
int n, m, c[N][N], cnt[1 << (N - 1)];
struct Edge {
int a, b;
} e[M];
int mask;
bool dfs(int a, int b, int p = -1) {
if (a == b) {
mask = 0;
return 1;
}
forn(i, n)
if (c[a][i] && i != p && dfs(i, b, a)) {
mask |= 1 << (c[a][i] - 1);
return 1;
}
return 0;
}
int f[1 << (N - 1)][M]; // 380mb = 10^6/2 * 190 * 4
int g[1 << (N - 1)][M];
void solve() {
memset(c, 0, sizeof(c));
memset(cnt, 0, sizeof(cnt));
forn(i, m) {
int a, b;
cin >> a >> b, a--, b--;
e[i] = {a, b};
if (i < n - 1)
c[a][b] = c[b][a] = i + 1;
else {
dfs(a, b), cnt[mask]++;
// printf("%d -> %d : mask = %d\n", a, b, mask);
}
}
int en = n - 1, all = 1 << en;
// forn(i, all)
// printf("cnt[%d] = %d\n", i, cnt[i]);
forn(i, en)
for (int mask = all - 1; mask > 0; mask--)
if (bit(mask, i))
cnt[mask] += cnt[mask ^ (1 << i)];
// forn(i, all)
// printf("sum_cnt[%d] = %d\n", i, cnt[i]);
memset(f, 0, sizeof(f[0]) * all);
memset(g, 0, sizeof(g[0]) * all);
f[0][0] = 1;
forn(mask, all) {
int bn = 0;
forn(i, n)
bn += bit(mask, i);
for (int e = cnt[mask]; e > 0; e--)
if (f[mask][e]) {
// printf("mask=%d e=%d : fix one free edge, [%d,%d] += %d\n", mask, e, mask, e - 1, f[mask][e]);
add(f[mask][e - 1], (ll)f[mask][e] * e % MOD);
add(g[mask][e - 1], (g[mask][e] + (ll)(en - bn) * f[mask][e]) * e % MOD);
}
forn(i, en)
if (!bit(mask, i)) {
int mask1 = mask | (1 << i), de = cnt[mask1] - cnt[mask];
// printf("mask: %d -> %d, de = %d : %d -> %d\n",
// mask, mask1, de, cnt[mask], cnt[mask1]);
forn(e, cnt[mask] + 1)
if (f[mask][e]) {
// printf("mask=%d e=%d : add vertex %d, [%d,%d] += %d\n",
// mask, e, i, mask1, e + de, f[mask][e]);
add(f[mask1][e + de], f[mask][e]);
add(g[mask1][e + de], g[mask][e]);
}
}
}
cout << (g[all - 1][0] + (ll)f[all - 1][0] * (en + 1) * en / 2) % MOD << endl;
}
int main() {
while (cin >> n >> m && n)
solve();
} |
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline", "fast-math", "unroll-loops", "no-stack-protector")
#pragma GCC diagnostic error "-fwhole-program"
#pragma GCC diagnostic error "-fcse-skip-blocks"
#pragma GCC diagnostic error "-funsafe-loop-optimizations"
#include<cstdio>
#include<algorithm>
#include<vector>
#include<map>
#include<queue>
#include<cstring>
#define ll long long
using namespace std;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c, qu[55];
int f, qr;
#define gc() (iS == iT ? (iT = (iS = ibuf) + fread (ibuf, 1, SIZE, stdin), (iS == iT ? EOF : *iS ++)) : *iS ++)
inline void flush () {
fwrite (obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc (char x) {
*oS ++ = x;
if (oS == oT) flush ();
}
template<class T>
inline void getc(T &x)
{
for(c=gc();!((c>='a'&&c<='z')||(c>='A'&&c<='Z'));c=gc());
x=c;
}
template <class I>
inline void rd (I &x) {
for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;
for (x = 0; c <= '9' && c >= '0'; c = gc()) x = x * 10 + (c & 15);
x *= f;
}
template <class I>
inline void print (I x) {
if (!x) putc ('0');
if (x < 0) putc ('-'), x = -x;
while (x) qu[++ qr] = x % 10 + '0', x /= 10;
while (qr) putc (qu[qr --]);
}
struct Flusher_ {
~Flusher_() {
flush();
}
} io_flusher_;
}
using io :: rd;
using io :: putc;
using io :: print;
using io :: getc;
const int MOD=1e9+7;
int mo(int x,int y)
{
return x+y>=MOD?x+y-MOD:x+y;
}
int mu(int x,int y)
{
return (ll)x*y%MOD;
}
int sub(int x,int y)
{
return x<y?x-y+MOD:x-y;
}
int ksm(int x,int y)
{
int res=1;
for(;y;y>>=1,x=mu(x,x))
if(y&1) res=mu(res,x);
return res;
}
const int MAXN=200+5;
pair<int,int>e[MAXN];
vector<int>g[MAXN];
int n,m;
ll dp[2][(1<<19)|1],sum[2][(1<<19)|1];
int els[(1<<19)|1],bin[(1<<19)|1],dep[MAXN],fa[MAXN],id[(1<<19)|1];
void dfs(int x,int ff)
{
dep[x]=dep[ff]+1;fa[x]=ff;
for(int i=0;i<g[x].size();i++)
{
int v=g[x][i];
if(v==ff) continue;
dfs(v,x);
}
}
/*
int jc[MAXN],jcn[MAXN];
int C(int n,int m)
{
return (n<m)?0:mu(jc[n],mu(jcn[m],jcn[n-m]));
}
*/
int ADD(int x,int y)
{
return x<=0?0:(ll)x*y%MOD;
}
int up[MAXN];
int main()
{
// freopen("B.in","r",stdin);
// freopen("B.out","w",stdout);
rd(n);rd(m);
for(int i=1,x,y;i<=m;i++)
{
rd(x);rd(y);
e[i]=make_pair(x,y);
if(i<=n-1)
{
g[x].push_back(y);
g[y].push_back(x);
}
}
dfs(1,0);
/* for(int i=n,x,y;i<=m;i++)
{
x=e[i].first,y=e[i].second;
while(x!=y)
{
if(dep[x]>dep[y])
{
SL[i]|=(1<<x-1);
x=fa[x];
}
else
{
SL[i]|=(1<<y-1);
y=fa[y];
}
}
}*/
int es=n-1;
for(int S=1;S<(1<<es);S++)
bin[S]=bin[S-(S&(-S))]+1;
for(int i=1;i<=es;i++)
id[(1<<(i-1))]=i;
/*
for(int S=0;S<(1<<es);S++)
{
int nowS=0;
for(int j,i=S,x,y;i;i-=i&(-i))
{
j=id[i&(-i)];
x=e[j].first;y=e[j].second;
nowS|=(dep[x]<dep[y])?(1<<y-1):(1<<x-1);
}
for (int i=n;i<=m;i++)
els[S]+=((SL[i]&nowS)==SL[i]);
// if(cnt) fprintf(stderr,"%d %d\n",S,els[S]);
}*/
for(int i=1,x,y;i<n;i++)
{
x=e[i].first;y=e[i].second;
up[(dep[x]<dep[y])?y:x]=i;
}
for(int i=n,x,y,S;i<=m;i++)
{
S=0;
x=e[i].first,y=e[i].second;
while(x!=y)
{
if(dep[x]>dep[y])
{
S|=(1<<(up[x]-1));
x=fa[x];
}
else
{
S|=(1<<up[y]-1);
y=fa[y];
}
}
++els[S];
}
for(int i=0;i<es;i++)
for(int j=0;j<(1<<es);j++)
if((j>>i)&1)
els[j]+=els[j^(1<<i)];
for(int j=0;j<(1<<es);j++)
els[j]+=bin[j];
/* for(int i=jc[0]=1;i<=m;i++) jc[i]=mu(jc[i-1],i);
jcn[m]=ksm(jc[m],MOD-2);
for(int i=m;i;i--)
jcn[i-1]=mu(jcn[i],i);
*/
// fprintf(stderr,"err");
dp[0][0]=1;int cur=0,nxt=1;
for(int i=1;i<=m;i++)
{
for(register int S=0,v;S<(1<<es);els[S]--,++S)
if(dp[cur][S])
{
dp[cur][S]=(dp[cur][S]>=1000000000000000ll)?dp[cur][S]%MOD:dp[cur][S];
sum[cur][S]=(sum[cur][S]>=1000000000000000ll)?sum[cur][S]%MOD:sum[cur][S];
// v=(els[S]-(i-1-bin[S]));
dp[nxt][S]+=els[S]>0?dp[cur][S]*els[S]:0;
sum[nxt][S]+=els[S]>0?sum[cur][S]*els[S]:0;
for(register int j=(1<<es)-1-S;j;j^=j&(-j))
{
int t=id[j&(-j)];
dp[nxt][S|(1<<(t-1))]+=dp[cur][S];
sum[nxt][S|(1<<(t-1))]+=dp[cur][S]*i+sum[cur][S];
}
dp[cur][S]=sum[cur][S]=0;
}
cur^=1;nxt^=1;
}
print(sum[cur][(1<<es)-1]%MOD);
putc('\n');
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define nn 20
#define ll long long
#define mod 1000000007
#define pii pair<int,int>
#define mp make_pair
int n,m;
pii link[nn*nn];
int cnt[1<<nn];int dep[nn];int topa[nn],pa[nn];
vector<int> v[nn],c[nn];
void dfs(int x,int p)
{
dep[x]=dep[p]+1;pa[x]=p;
for(int i=0;i<v[x].size();i++)
{
int y=v[x][i];
if(y!=p)topa[y]=c[x][i],dfs(y,x);
}
}
int solve(int x,int y)
{
int mask=0;
while(x!=y)
{
if(dep[x]<dep[y]) swap(x,y);
mask|=1<<topa[x],x=pa[x];
}
return mask;
}
ll dp_tms[1<<nn],dp_val[1<<nn];
void add(ll &x,ll y) {x=(x+y)%mod;}
int noway[1<<nn];
ll fib[100*nn],rf[100*nn];
ll qpow(ll x,ll y)
{
ll res=1;
while(y)
{
if(y&1) res=res*x%mod;
x=x*x%mod;y=y/2;
}
return res;
}
int main()
{
rf[0]=fib[0]=1;for(int i=1;i<100*nn;i++) fib[i]=fib[i-1]*i%mod,rf[i]=qpow(fib[i],mod-2);
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++)
{
int x,y;scanf("%d%d",&x,&y);x--,y--;
link[i]=mp(x,y);
if(i<n) v[x].push_back(y),v[y].push_back(x),c[x].push_back(i-1),c[y].push_back(i-1);
}
dfs(0,-1);
for(int i=n;i<=m;i++) cnt[solve(link[i].first,link[i].second)]++;
for(int i=1;i<(1<<nn);i<<=1)
for(int j=0;j<(1<<nn);j+=i+i)
for(int k=j;k<j+i;k++)
cnt[k+i]+=cnt[k];
int S=1<<n-1;
dp_tms[S-1]=1;
for(int i=S-1;i>=0;i--)
for(int j=0;j<n-1;j++)
if((1<<j)&i)
{
int ava=cnt[i]-cnt[i^(1<<j)];
int alr=m-(cnt[i]+__builtin_popcount(i));
ll tms=dp_tms[i]*fib[alr+ava]%mod*rf[alr]%mod;
ll val=dp_val[i]*fib[alr+ava+1]%mod*rf[alr+1]%mod;
add(dp_tms[i^(1<<j)],tms);
add(dp_val[i^(1<<j)],val+tms*(n-__builtin_popcount(i)) );
}
cout<<dp_val[0]<<"\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define forn(i, n) for (int i = 0; i < (int)(n); i++)
#define all(a) a.begin(), a.end()
int bit(int a, int i) { return (a >> i) & 1; }
typedef long long ll;
const int MOD = 1e9 + 7;
const int N = 20, M = N * (N - 1) / 2;
void add(int &a, int b) {
if ((a += b) >= MOD)
a -= MOD;
}
int n, m, c[N][N], cnt[1 << (N - 1)];
struct Edge {
int a, b;
} e[M];
int mask;
bool dfs(int a, int b, int p = -1) {
if (a == b) {
mask = 0;
return 1;
}
forn(i, n)
if (c[a][i] && i != p && dfs(i, b, a)) {
mask |= 1 << (c[a][i] - 1);
return 1;
}
return 0;
}
int f[1 << (N - 1)][M]; // 380mb = 10^6/2 * 190 * 4
int g[1 << (N - 1)][M];
void solve() {
memset(c, 0, sizeof(c));
memset(cnt, 0, sizeof(cnt));
forn(i, m) {
int a, b;
cin >> a >> b, a--, b--;
e[i] = {a, b};
if (i < n - 1)
c[a][b] = c[b][a] = i + 1;
else
dfs(a, b), cnt[mask]++;
}
int en = n - 1, all = 1 << en;
forn(i, en)
for (int mask = all - 1; mask > 0; mask--)
if (bit(mask, i))
cnt[mask] += cnt[mask ^ (1 << i)];
memset(f, 0, sizeof(f[0]) * all);
memset(g, 0, sizeof(g[0]) * all);
f[0][0] = 1;
forn(mask, all) {
int bn = 0;
forn(i, n)
bn += bit(mask, i);
for (int e = cnt[mask]; e > 0; e--)
if (f[mask][e]) {
add(f[mask][e - 1], (ll)f[mask][e] * e % MOD);
add(g[mask][e - 1], (g[mask][e] + (ll)(en - bn) * f[mask][e]) * e % MOD);
}
forn(i, en)
if (!bit(mask, i)) {
int mask1 = mask | (1 << i), de = cnt[mask1] - cnt[mask];
forn(e, cnt[mask] + 1) {
add(f[mask1][e + de], f[mask][e]);
add(g[mask1][e + de], g[mask][e]);
}
}
}
cout << (g[all - 1][0] + (ll)f[all - 1][0] * (en + 1) * en / 2) % MOD << endl;
}
int main() {
while (cin >> n >> m && n)
solve();
} |
#include<bits/stdc++.h>
#define rep(i,x,y) for (int i=(x);i<=(y);i++)
#define ll long long
using namespace std;
const int N=25,M=(1<<20)+10,mod=1e9+7;
int n,m,len,a[M],cnt,head[N],x,y,val[N],f[2][M],g[2][M];
struct edge{int to,nxt,i;}e[N*N];
inline void upd(int &x,int y){x+=y; x-=x>=mod?mod:0;}
void adde(int x,int y,int i){
e[++cnt].to=y; e[cnt].nxt=head[x]; head[x]=cnt; e[cnt].i=i;
}
void dfs(int u,int par,int st){
val[u]=st;
for (int i=head[u],v;i;i=e[i].nxt)
if (v=e[i].to,v!=par) dfs(v,u,st|(1<<(e[i].i-1)));
}
void fmt(int *a){
rep (i,0,len-1)
rep (j,0,(1<<len)-1)
if (!(j>>i&1)) a[j|1<<i]+=a[j];
}
int main(){
scanf("%d%d",&n,&m); len=n-1;
rep (i,1,n-1) scanf("%d%d",&x,&y),adde(x,y,i),adde(y,x,i);
dfs(1,0,0);
rep (i,n,m) scanf("%d%d",&x,&y),a[val[x]^val[y]]++; fmt(a);
int now=0,tmp; f[0][0]=1;
rep (i,1,m){
now^=1;
memset(f[now],0,sizeof(f[now]));
memset(g[now],0,sizeof(g[now]));
rep (j,0,(1<<len)-1)
if (tmp=f[now^1][j],tmp){
int s=((1<<len)-1)^j;
for (int r=s;r;r-=r&-r){
int k=r&-r;
if (!(j&k)){
upd(f[now][j|k],tmp);
upd(g[now][j|k],(g[now^1][j]+(ll)tmp*i%mod)%mod);
}
}
upd(f[now][j],(ll)tmp*(a[j]-(i-1-__builtin_popcount(j)))%mod);
upd(g[now][j],(ll)g[now^1][j]*(a[j]-(i-1-__builtin_popcount(j)))%mod);
}
}
printf("%d\n",g[now][(1<<len)-1]);
return 0;
} |
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <cstring>
#include <queue>
#include <set>
#include <map>
#include <stack>
#include <functional>
#define SIZE 25
#define BT 1<<20
#define MOD 1000000007
#define MX 205
using namespace std;
typedef long long int ll;
typedef pair <int,int> P;
ll dp[BT],way[BT];
ll C[MX][MX];
vector <P> vec[SIZE];
int cnt[BT],cnt2[BT];
int memo[SIZE][BT];
void make()
{
for(int i=0;i<MX;i++)
{
C[i][0]=C[i][i]=1;
for(int j=1;j<i;j++)
{
C[i][j]=(C[i-1][j-1]+C[i-1][j])%MOD;
}
}
}
int dfs(int v,int p,int goal)
{
if(v==goal) return 0;
for(int i=0;i<vec[v].size();i++)
{
int to=vec[v][i].first;
if(to!=p)
{
int ret=dfs(to,v,goal);
if(ret!=-1) return ret|(1<<vec[v][i].second);
}
}
return -1;
}
int main()
{
make();
int n,m;
scanf("%d %d",&n,&m);
for(int i=0;i<n-1;i++)
{
int a,b;
scanf("%d %d",&a,&b);a--,b--;
vec[a].push_back(P(b,i));
vec[b].push_back(P(a,i));
}
for(int i=n-1;i<m;i++)
{
int a,b;
scanf("%d %d",&a,&b);a--,b--;
int S=dfs(a,-1,b);
cnt[S]++;
}
int sz=n-1;
for(int i=0;i<sz;i++)
{
for(int S=0;S<1<<sz;S++) memo[i][S]=cnt[S];
for(int j=0;j<sz;j++)
{
if(j==i) continue;
for(int S=0;S<1<<sz;S++) if(S>>j&1) memo[i][S]+=memo[i][S-(1<<j)];
}
}
memset(dp,0,sizeof(dp));
memset(way,0,sizeof(way));
way[(1<<sz)-1]=1;
for(int S=(1<<sz)-1;S>=0;S--)
{
int nm=0;
for(int i=0;i<sz;i++) if(!(S>>i&1)) nm++;
for(int i=0;i<sz;i++)
{
if(S>>i&1)
{
//printf("%d %d : %d\n",i,S,memo[i][S]);
ll w=way[S],d=dp[S],c=cnt2[S];
for(int j=0;j<memo[i][S];j++)
{
ll c2=c+1;
ll w2=w*(c+1)%MOD;
ll d2=d*(c+2)%MOD;
c=c2,w=w2,d=d2%MOD;
}
int T=S-(1<<i);
cnt2[T]=cnt2[S]+memo[i][S]+1;
dp[T]+=(d+w*(ll) (nm+1))%MOD;
if(dp[T]>=MOD) dp[T]-=MOD;
way[T]+=w;
if(way[T]>=MOD) way[T]-=MOD;
}
}
//printf("%d : %lld %lld\n",S,way[S],dp[S]);
}
printf("%lld\n",dp[0]);
return 0;
}
|
#pragma GCC target("avx") // CPU 処理並列化
#pragma GCC optimize("O3") // CPU 処理並列化
#pragma GCC optimize("unroll-loops") // 条件処理の呼び出しを減らす
// #define BEGIN_STACK_EXTEND(size) void * stack_extend_memory_ = malloc(size);void * stack_extend_origin_memory_;char * stack_extend_dummy_memory_ = (char*)alloca((1+(int)(((long long)stack_extend_memory_)&127))*16);*stack_extend_dummy_memory_ = 0;asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp":"=b"(stack_extend_origin_memory_):"a"((char*)stack_extend_memory_+(size)-1024));
// #define END_STACK_EXTEND asm volatile("mov %%rax, %%rsp"::"a"(stack_extend_origin_memory_));free(stack_extend_memory_);
#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<queue>
#include<deque>
#include<stack>
#include<string>
#include<string.h>
#include<vector>
#include<set>
#include<map>
#include<bitset>
#include<stdlib.h>
#include<cassert>
#include<time.h>
#include<bitset>
#include<numeric>
#include<unordered_set>
#include<unordered_map>
#include<complex>
using namespace std;
const long long mod=1000000007;
const long long inf=mod*mod;
const long long d2=(mod+1)/2;
const long double EPS=1e-9;
const long double INF=1e+10;
const long double PI=acos(-1.0);
const int C_SIZE = 3100000;
const int UF_SIZE = 3100000;
namespace{
long long fact[C_SIZE];
long long finv[C_SIZE];
long long inv[C_SIZE];
inline long long Comb(int a,int b){
if(a<b||b<0)return 0;
return fact[a]*finv[b]%mod*finv[a-b]%mod;
}
void init_C(int n){
fact[0]=finv[0]=inv[1]=1;
for(int i=2;i<n;i++){
inv[i]=(mod-(mod/i)*inv[mod%i]%mod)%mod;
}
for(int i=1;i<n;i++){
fact[i]=fact[i-1]*i%mod;
finv[i]=finv[i-1]*inv[i]%mod;
}
}
long long pw(long long a,long long b){
if(a<0LL)return 0;
if(b<0LL)return 0;
long long ret=1;
while(b){
if(b%2)ret=ret*a%mod;
a=a*a%mod;
b/=2;
}
return ret;
}
long long pw_mod(long long a,long long b,long long M){
if(a<0LL)return 0;
if(b<0LL)return 0;
long long ret=1;
while(b){
if(b%2)ret=ret*a%M;
a=a*a%M;
b/=2;
}
return ret;
}
int pw_mod_int(int a,int b,int M){
if(a<0)return 0;
if(b<0)return 0;
int ret=1;
while(b){
if(b%2)ret=(long long)ret*a%M;
a=(long long)a*a%M;
b/=2;
}
return ret;
}
int ABS(int a){return max(a,-a);}
long long ABS(long long a){return max(a,-a);}
double ABS(double a){return max(a,-a);}
int sig(double r) { return (r < -EPS) ? -1 : (r > +EPS) ? +1 : 0; }
int UF[UF_SIZE];
void init_UF(int n){
for(int i=0;i<n;i++)UF[i]=-1;
}
int FIND(int a){
if(UF[a]<0)return a;
return UF[a]=FIND(UF[a]);
}
void UNION(int a,int b){
a=FIND(a);b=FIND(b);if(a==b)return;
if(UF[a]>UF[b])swap(a,b);
UF[a]+=UF[b];UF[b]=a;
}
}
// ここから編集しろ
int L[310];
int R[310];
pair<long long,long long> dp[2][1<<19];
int K[1<<19];
int TMP[310];
vector<int>to[1<<19];
int main(){
int a,b;
scanf("%d%d",&a,&b);
for(int i=0;i<b;i++){
scanf("%d%d",L+i,R+i);
L[i]--;R[i]--;
}
int n=a-1;
for(int i=0;i<(1<<n);i++){
init_UF(a);
for(int j=0;j<n;j++){
if(i&(1<<j)){
UNION(L[j],R[j]);
K[i]++;
}else to[i].push_back(1<<j);
}
for(int j=0;j<a;j++)TMP[j]=FIND(j);
for(int j=n;j<b;j++){
if(TMP[L[j]]==TMP[R[j]])K[i]++;
}
}
dp[0][0].first=1;
for(int i=0;i<b;i++){
int h=i%2;
int g=!h;
for(int j=0;j<(1<<n);j++)dp[g][j]=make_pair(0LL,0LL);
for(int j=(1<<n)-1;j>=0;j--){
if(!dp[h][j].first&&!dp[h][j].second){
continue;
}
if(K[j]>i){
dp[g][j].first+=dp[h][j].first*(K[j]-i);
dp[g][j].second+=dp[h][j].second*(K[j]-i);
}
long long ad=dp[h][j].second+dp[h][j].first*(i+1);
for(int k=0;k<to[j].size();k++){
dp[g][j|to[j][k]].first+=dp[h][j].first;
dp[g][j|to[j][k]].second+=ad;
}
}
for(int j=0;j<(1<<n);j++){
if(dp[g][j].first>=mod)dp[g][j].first%=mod;
if(dp[g][j].second>=mod)dp[g][j].second%=mod;
}
}
printf("%lld\n",dp[b%2][(1<<n)-1].second%mod);
} |
#include <iostream>
using namespace std;
int main(void){
long long N,P,i,j,k,ans=1;
cin>>N>>P;
if(N==1){
cout<<P<<endl;
return 0;
}
for(i=2;P>1&&i*i<P+1;i++){
k=0;
while(P%i==0){
k++;
P/=i;
}
for(j=0;j<k/N;j++){
ans*=i;
}
}
cout<<ans<<endl;
} |
#include <bits/stdc++.h>
using namespace std;
long long n, p;
int
main()
{
cin >> n >> p;
if( n == 1 )
{
cout << p << endl;
return 0;
}
if( n > 40 )
{
cout << 1 << endl;
return 0;
}
long long x = static_cast<long long>( ceil( sqrt( p ) ) );
while( ( p % x ) != 0 || ( p % static_cast<long long>( pow( x, n ) ) ) != 0 ) --x;
cout << x << endl;
return 0;
}
|
#include <iostream>
#include <cmath>
using namespace std;
int main(){
long long N, P;
cin >> N >> P;
if (N == 1) {
cout << P;
return 0;
}
long long max_ans = pow(P, 1.0 / double(N)) + 10;
for (long long d = max_ans; d > 0; d--) {
long long num = pow(d, N);
if (P % num == 0) {
cout << d << endl;
break;
}
}
return 0;
}
|
#include <iostream>
#include <cmath>
using namespace std;
int main(){
long n,p;
cin >> n >> p;
if(n == 1){
cout << p << endl;
return 0;
} else if(n >= 40){
cout << 1 << endl;
return 0;
}
int cnt = 0;
int ans = 1;
for(int i = 2; i <= p && i <= 1000000 ; i++){
// cout << "A" << i << endl;
while((p % i) == 0){
p/=i;
cnt++;
// cout << "b p;" << p << "cnt" << cnt << endl;
}
while(cnt >= n){
ans *= i;
cnt -= n;
}
cnt = 0;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define INF (1<<30)
#define MOD 1000000007
#define l_ength size
using ll = long long;
using namespace std;
int main(){
ll n, p;
cin >> n >> p;
if( n == 1 ){
cout << p << endl;
return 0;
}
ll ans = 1;
for( ll i = sqrt(p); i > 1; --i ){
int cnt = 0;
while( p % i == 0 ){
p /= i;
++cnt;
}
if( cnt >= n ){
ans *= i;
} else {
for( int j = 0; j < cnt; ++j ){
p *= i;
}
}
}
cout << ans << endl;
return 0;
} |
#include <cmath>
#include <cstdio>
int main(){
long long int n, k, p = 1, ans = 1;
scanf("%lld %lld",&k,&n);
if (k == 1){
printf("%lld\n",n);
return 0;
}
while (n > 1 && p <= sqrt(n)){
p++;
if (n % p != 0){
continue;
}
long long int c = 0;
while (n % p == 0){
n /= p;
c++;
}
ans *= pow(p, c / k);
}
printf("%lld\n",ans);
} |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
long long n, p;
cin >> n >> p;
if(n==1){
cout << p << endl;
}else{
for(int i=(int)floor(sqrt(p)); i > 0; i--){
if(p%(long long)(pow(i,n))==0){
cout << i << endl;
break;
}
}
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
long long n,p;
map<long long,long long> f;
map<long long,long long>::iterator it;
void get() {
long long temp=p;
for(long long i=2;i*i<=p;i++) {
if(temp==1) break;
if(temp%i==0) {
while(temp%i==0) {
temp/=i;
f[i]++;
}
}
}
}
int main() {
cin>>n>>p;
get();
long long cnt=1;
if(n==1) {
cout<<p;
exit(0);
}
for(it=f.begin();it!=f.end();it++) {
while(it->second>=n) {
cnt*=it->first;
it->second-=n;
}
}
cout<<cnt;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
int main()
{
ll N, P;
cin >> N >> P;
if (N == 1)
{
cout << P << endl;
return 0;
}
if (N > sqrt(P))
{
cout << 1 << endl;
return 0;
}
ll ans = 1;
for (int i = 2; i <= sqrt(P) + 2; i++)
{
int cnt = 0;
while (P % i == 0)
{
P /= i;
cnt++;
if (cnt == N)
{
ans *= i;
cnt = 0;
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
long long n,p;
cin>>n>>p;
if(n==1){
cout<<p;
return 0;
}
int a[1000005]={},P=p,i;
for(i=2;i<=sqrtl(p)&&p!=1;i++){
while(p%i==0){
p/=i;
a[i]++;
}
}
if(P==p){
cout<<1;
return 0;
}
int ans=1;
for(int j=2;j<i;j++){
while(a[j]>=n){
a[j]-=n;
ans*=j;
}
}
cout<<ans;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);
#define ll long long
int main(){
IOS
ll n,p;
cin>>n>>p;
ll c=0;
while(p%2==0){
c++;
p/=2;
}
c/=n;
ll ans=pow(2,c);
for(ll i=3;i<=sqrt(p);i+=2){
ll c=0;
while(p%i==0){
p/=i;
c++;
}
c/=n;
ans=ans*pow(i,c);
}
if(p>2){
if(n==1){ ans*=p;}
}
cout<<ans;
return 0;
} |
#include <iostream>
#include <math.h>
using namespace std;
int main(){
long long int n, p, ans;
cin >> n >> p;
ans = pow( (long double)p, 1.0/(long double)n) + 1;
while(ans > 1){
if ( p % ( long long int)pow( (long long int)ans, (long long int)n ) == 0 ){
break;
}else{
ans --;
}
}
cout << ans << endl;
} |
#include<bits/stdc++.h>
using namespace std;
int prime(long long n){
for(long long i=2;i<=sqrt(n);i++){
if(n%i==0){
return 0;
}
}
return 1;
}
int main()
{
long long n,p;
cin>>n>>p;
if(n==1){
cout<<p<<endl;
return 0;
}
long long maxn= 1;
double f=pow(p,1.0/n);
for(long long i=f+1;i>=2;i--){
long long sum=1;
for(long long j=0;j<n;j++){
sum*=i;
if(sum>p)
break;
}
if(p%sum==0){
maxn=i;
break;
}
}
cout<<maxn<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
int main()
{
LL p,n;
cin>>p>>n;
double x=1.0/p;
LL mm=pow(n,x)+1.0;
for(LL i=mm;i>=1;i--)
{
if(n%(LL)pow(i,p)==0)
{
cout<<i<<"\n";
return 0;
}
}
} |
#include <bits/stdc++.h>
using namespace std;
int main(){
long double N,P;
long ans;
cin >> N >> P;
ans = (long)pow(P,1/N);
while((long)P % (long)pow(ans,N) != 0){
ans--;
}
cout << ans << endl;
return 0;
} |
#include <bits/stdc++.h>
#define INF (1<<30)
#define MOD 1000000007
#define l_ength size
using ll = long long;
using namespace std;
int main(){
ll n, p;
cin >> n >> p;
if( n == 1 ){
cout << p << endl;
return 0;
}
ll ans = 1;
ll porig = p;
for( ll i = 2; i*i <= porig; ++i ){
ll cnt = 0;
while( p % i == 0 ){
p /= i;
++cnt;
}
if( cnt >= n ){
ll pro = 1;
ll j = cnt/n;
while( j-- ){
pro *= i;
}
ans *= pro;
}
}
cout << ans << endl;
return 0;
} |
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;
int main(){
long long n,p;
cin>>n>>p;
long long jg = pow(p,1.0/n);
for(long long i = jg+1;;i--){
if(p%(long long)pow(i,n) == 0){
jg = i;
break;
}
}
printf("%lld\n",jg);
return 0;
} |
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main(){
long N, P;
long i, j;
long A[1000000];
long ans = 1;
scanf("%ld %ld", &N, &P);
if(P == 1){
ans = 1;
goto Ans;
}
if(N == 1){
ans = P;
goto Ans;
}
i = pow(P, 1/double(N));
for( j=2 ; j<=i ; P%j==0 ? : j++ ){
if(P%j == 0){
P /= j;
A[j]++;
}
}
for( j=2 ; j<=i ; j++){
A[j] = A[j]/N;
if(A[j]) ans *= pow(j, A[j]);
}
Ans: ;
printf("%ld\n", ans);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
long double a,b;
cin>>a>>b;
long double temp=(unsigned long long)pow(b,1/a);
unsigned long long kq=1;
for(unsigned long long i=temp;i>=2;i--){
unsigned long long dem=0,j=b;
while(j%i==0){
dem++;
j=j/i;
}
if(dem>=a){
kq=i;
break;
}
}
cout<<kq;
//cout<<temp<<endl;
} |
#include<bits/stdc++.h>
using namespace std;
int main()
{
long long n, p, i;
cin >> n >> p;
long long ans = 1;
long long count = 0;
for(i = 2; i <= 1000000; i++)
{
while(p % i == 0)
{
p /= i;
count++;
}
count /= n;
while(count > 0)
{
ans *= i;
count--;
}
count = 0;
}
if(p != 1 && n == 1)
{
ans *= p;
}
cout << ans << endl;
} |
#include<bits/stdc++.h>
using namespace std;
long long qpow(long long a,long long b)
{
long long ans=1;
while(b)
{
if(b&1)
ans=ans*a;
a=a*a;
b=b/2;
}
return ans;
}
int main()
{
long long n,p;
cin>>n>>p;
long long m=sqrt(p);
if(n==1 || p==1)
cout<<p<<endl;
else
{
long long ans=1;
for(long long j=2;j<=m;j++)
{
while(p%(long long)pow(j,n)==0)
{
p=p/(long long)pow(j,n);
ans=ans*j;
}
}
cout<<ans<<endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, p; cin >> n >> p;
if (n == 1) {
cout << p << endl;
return 0;
}
vector<pair<int, long long>> v;
double sq = sqrt(p);
for (int i = 2; i <= sq; i++) {
int cnt = 0;
while (p % i == 0) {
p /= i;
cnt++;
}
if (cnt >= n) v.push_back(make_pair(i, cnt));
}
long long ans = 1;
for (auto p : v) {
long long m = p.second / n;
for (int i = 0; i < m; i++) ans *= p.first;
}
cout << ans << endl;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(void){
ll n, p; cin >> n >> p;
if (n == 1) {
cout << p << endl;
return 0;
}
ll ans = 1;
for (int i = 2; i <= sqrt(p); i += (i == 2 ? 1 : 2)) {
int cnt = 0;
while (p % i == 0) {
p /= i;
cnt++;
}
if (cnt >= n) {
ll t = cnt / n;
ans *= pow(i, t);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const double EPS = 1e-9;
typedef vector<ll> vll;
typedef pair<ll, ll> pll;
#define rep(i, n) REP(i, 0, n)
#define ALL(v) v.begin() , v.end()
#define REP(i, x, n) for(ll i = x; i < n; i++)
int main(){
ll n, p, ans = 1; cin >> n >> p;
if(n == 1){
cout << p << endl;
return 0;
}
for(ll a = 2; a * a <= p; a++){
ll i = pow(a, n);
if(p % i == 0){
ans = a;
}
}
cout << ans << endl;
} |
#include <iostream>
#include <map>
using namespace std;
int main()
{
uint64_t n, p;
cin >> n >> p;
map<uint64_t, uint64_t> m;
for (uint64_t i = 2; i * i <= p; i++) {
while (p % i == 0) {
m[i]++;
p /= i;
}
}
if (p > 1) {
m[p] = 1;
}
uint64_t ans = 1;
for (auto&& e : m) {
if (e.second >= n) {
for (uint64_t i = 0; i < e.second / n; i++) {
ans *= e.first;
}
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef unsigned int ui;
typedef long long ll;
typedef unsigned long long ull;
int main() {
ll N, P;
cin >> N >> P;
if(N >= 40) {
cout << 1 << endl;
return 0;
}
if(N == 1) {
cout << P << endl;
return 0;
}
int ans = 1;
for(int i = 2; pow((ll)i, N) <= P; i++) {
int num = 0;
while(P % i == 0) {
P /= i;
num++;
}
ans *= pow(i, num / N);
}
cout << ans << endl;
}
|
#include <stdio.h>
#include <algorithm>
#include <math.h>
using namespace std;
int main()
{
long long n, p;
scanf("%lld %lld", &n, &p);
if (n == 1)
{
printf("%lld\n", p);
return 0;
}
long long ans=0;
for (long long i=2; pow(i, n)<=p; i++)
{
if (p%i == 0)
{
int tmpcnt=0;
long long tmp = p;
while(tmp%i == 0)
{
tmp/=i;
tmpcnt++;
if (tmpcnt>=n ) break;
}
if (tmpcnt >= n) ans = i;
}
}
if (ans == 0) printf("1\n");
else printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void)
{
long long n,p,count=0,a=1,hozon;
cin >> n >> p;
hozon = p;
if(n>=2){
for(int i=2;i<=sqrt(p);i++){
while(p%i==0) {count++;p=p/i;}
if(count>=n) {a=i;}
count = 0;
p = hozon;
}
cout << a;
}
if(n==1) cout << p;
} |
#include <iostream>
#include <vector>
#define ll long long
using namespace std;
int main() {
ll N, P;
cin >> N >> P;
if (N == 1) {
cout << P << endl;
return 0;
}
ll ans = 1, p = 2;
while (P > 1 && p * p <= P) {
int cnt = 0;
while (P % p == 0) {
P /= p;
cnt++;
if (cnt == N) {
ans *= p;
cnt = 0;
}
}
p++;
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
ll f(ll x,ll res)
{
ll ans=1;
while(x)
{
if(x&1)ans=ans*res;
res*=res;x/=2;
}
return ans;
}
int main()
{
ll n,p;
ll ans=1;
cin>>n>>p;
if(n==1){cout<<p;return 0;}
if(p==1){cout<<"1";return 0;}
if(n>=p){cout<<"1";return 0;}
if(n>1000000){cout<<"1";return 0;}
for(ll i=2;;i++)
{
ll k=f(n,i);
if(p<k)break;
if(p%k==0)ans=i;
}
printf("%lld\n",ans);
return 0;
}
|
#include<iostream>
#include<cmath>
using namespace std;
int main(){
unsigned long N,P;
cin>>N>>P;
long double n,m,k;
k=1.0/N;
n=pow(P,k);
m=floor(n);
for (unsigned long i=m+1;1<=i;--i){
long z;
z=pow(i,N);
if(P%z==0){
cout<<i<<endl;
break;
}
}
}
|
#include <iostream>
#include <cstdio>
using namespace std;
typedef long long ll;
ll n, p, ans=1;
int main() {
ll i, j, t;
cin >> n >> p;
if(n==1) {return printf("%lld", p)*0;}
for(i=2; ; i++) {
t = 1;
for(j=0; j<n; j++) {
t *= i;
if(t<0 || t>p) {cout << ans; return 0;}
}
if(p%t==0) ans = i;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int main(){
double N;
double P;
cin >> N >> P;
double n = pow(P,1/N);
long int p = P;
long int x = N;
for(long int i = n + 10;i>0;i--){
long int m = pow(i,x);
if(p % m == 0){
cout << i << endl;
break;
}
}
} |
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
int main()
{
ll n, m;
cin >> n >> m;
map<ll, ll> res;
for (ll i = 2; i * i <= m; i++)
{
while (m % i == 0)
{
res[i]++;
m /= i;
}
}
if (m != 1)
res[m]++;
ll ans = 1;
for (auto p : res)
{
if (p.second >= n)
{
ans *=(ll)pow(p.first,p.second/n);
}
}
cout << ans << endl;
} |
#include <bits/stdc++.h>
using namespace std;
#define Rep(i,a,b) for (int i=(a);i<(b);i++)
#define rep(i,n) for (int i=0;i<(n);i++)
#define all(x) (x).begin(), (x).end()
#define ll long long
int main()
{
ll n, p;
map<ll, ll> mp;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
return 0;
}
int ans = 1;
for (int i = 1; pow(i, n) <= p; i++) {
if (p % (ll)pow(i, n) == 0)
ans = i;
}
cout << ans << endl;
}
|
#include <iostream>
#include <cmath>
using namespace std;
int main()
{
long long N, P;
cin >> N >> P;
long long mx = pow(P, 1.0/N);
long long ans = mx;
for(int i = mx + 1; i >= 1; i--)
{
long long temp = pow(i, N);
if((P % temp) == 0)
{
ans = i;
break;
}
}
cout << ans << endl;
return 0;
} |
#include <iostream>
#include <map>
#include <cmath>
using namespace std;
int main()
{
uint64_t n, p;
cin >> n >> p;
map<uint64_t, uint64_t> m;
for (uint64_t i = 2; i * i <= p; i++) {
while (p % i == 0) {
m[i]++;
p /= i;
}
}
m[p] = 1;
uint64_t ans = 1;
for (const auto& e : m) {
ans *= pow(e.first, e.second / n);
}
cout << ans << endl;
}
|
#include "bits/stdc++.h"
using namespace std;
//約数の個数
long long calc(long long N,long long M) {
long long ret = 1;
for (long long i = 2; i*i <= N; i++) {
int m = 0;
while (N%i == 0) { // 素数で割り切れなくなるまで割っていく
m++;//割った個数を配列に足す
N /= i;
}
if (0 != m) {
for (int j = 0;j<m/M;++j) {
ret *= i;
}
}
if (1 == N) {
break;
}
}
if (1 != N) {
for (int j = 0; j < 1 / M; ++j) {
ret *= N;
}
}
return ret;
}
int main() {
long long N, P;
cin >> N >> P;
long long ans = calc(P,N);
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <cmath>
#define LL long long
using namespace std;
int main()
{
LL N, P;
cin >> N >> P;
if(1 == N)
{
cout << P << endl;
return 0;
}
// double转化为long long有可能会少1，先加回来
LL ans = pow(P, 1.0/N) + 1;
for(; ans >= 1; ans--)
{
if((P % (LL)pow(ans, N)) == 0)
{
break;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define REP(i, n) for(ll i=0, i##_len=(n); i<i##_len; ++i)
using ll = long long;
using namespace std;
int main()
{
ll N, P;
cin >> N >> P;
ll retv = 1;
ll temp = P;
ll maxv = powl(P, 1.0/(double)N)+1;
for (ll i=maxv; i>=2 && temp>=8; --i)
{
ll p = powl(i, N);
if (temp % p != 0) continue;
temp /= p;
retv *= i;
}
cout << retv << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.