Codeforces Round #589 (Div. 2) -- 题解

A. Distinct Digits

#include
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
const int mx = 1e5 + 10;
int top;
int a[mx];
bool check(int i){
	bool b[20];
	memset(b,0,sizeof(b));
	while(i){
		if (b[i%10]) return 0;
		b[i%10] = 1;
		i /= 10;
	}
	return 1;
}
int main()
{   
	int n,m;
	for (int i=1;i

B. Filling the Grid

#include
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
const int mx = 1e3 + 10;
const int mod = 1e9 + 7;
int h,w;
int c[mx],r[mx];
ll qpow(ll x,ll y)
{
	ll ans = 1;
	while(y){
		if(y&1) ans = ans*x%mod;
		y >>= 1;
		x = x*x%mod;
	}
	return ans;
}
int main()
{   
	scanf("%d%d",&h,&w);
	for (int i=1;i<=h;i++)
	scanf("%d",r+i);
	for (int i=1;i<=w;i++)
	scanf("%d",c+i);
	int ans = 0;
	for (int i=1;i<=h;i++){
		for(int j=1;j<=w;j++){
			if (r[i] == j-1 && c[j] >= i)
				return 0*puts("0");
			if (c[j] == i-1 && r[i] >= j)
				return 0*puts("0");
			if (j <= r[i]+1) continue;
			if (i <= c[j]+1) continue;
			ans++;
		}
	}
	printf("%lld\n",qpow(2,ans));
    return 0;
}

C. Primes and Multiplication

#include
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
const int mx = 1e5 + 20;
const int mod = 1e9 + 7;
int top,b[mx],c[mx];
int pri[mx];
bool vis[mx];
void init()
{
	for (int i=2;i>= 1;
		x = x*x%mod;
	}
	return ans;
}
int main()
{   
	init();
	int siz = 0;
	ll m,n;
	scanf("%lld%lld",&n,&m);
	for (int i=0;1ll*pri[i]*pri[i]<=n;i++) {
		if (n % pri[i] == 0)
			b[siz++] = pri[i];
		while (n % pri[i] == 0)
			n /= pri[i];
	}
	
	if (n != 1) b[siz++] = n;
	
	ll ans = 1;
	for (int i=0;i m / b[i]) {
				//cout << v << endl;
				ans = ans*qpow(v%mod,m/v)%mod;
				break;
			}
			
			ll cnt = m / v - m / (v*b[i]);
			ans = ans*qpow(v%mod,cnt)%mod;
			
		}
	}
	
	printf("%lld\n",ans);
    return 0;
}

D. Complete Tripartite

#include
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
const int mx = 1e5 + 10;
const int mod = 1e9 + 7;
int n,m,ans[mx];
vector  g[mx],r[mx];
bool vis[mx];
void dfs(int x)
{
	vis[x] = 1;
	for (int v:g[x]) if (!vis[v])
		dfs(v);
}
int main()
{   
	scanf("%d%d",&n,&m);
	int u,v;
	for (int i=0;i

E. Another Filling the Grid

#include
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
const int mx = 1e3 + 10;
const int mod = 1e9 + 7;
int n,m;
ll fac[mx],inv[mx];
void init()
{
	inv[0] = fac[0] = inv[1] = 1;
	for(int i=1;i>= 1;
		x = x*x%mod;
	}
	return ans;
}
#define f(x,m) (qpow(m,x)-qpow(m-1,x))
int main()
{   
	init();
	scanf("%d%d",&n,&m);
	ll ans = 0;
	for (int i=0;i<=n;i++){
		ans += ((i&1)? -1 : 1)*C(n,i)*qpow(m-1,n*i)%mod*qpow(f(n-i,m),n)%mod;
		ans %= mod;
	}
	ans += mod;
	printf("%lld\n",ans%mod);
    return 0;
}

F. One Node is Gone

#include 
using namespace std;
const int mx = 2e5 + 10;
int n,du[mx];
vector  g[mx];
bool flag;
int siz[mx],ma_son[mx];
 
#define three_son(t1,t2,t3,fa,d) \
		min(dfs(t1,fa,d),min(dfs(t2,fa,d+1),dfs(t3,fa,d+1)))
 
int dfs(int u,int fa,int d)
{
	int ans = 1e9;
	if (du[u]==1)
		return d==n?1e9:-1;
    if (du[u]==2||du[u]==4){
        if (flag) return -1;
        flag = 1;
        if (du[u]==2) {
            int ret = dfs(g[u][0]==fa?g[u][1]:g[u][0],u,d+1);
            return ret == -1?-1:u;
        }
        if (du[u]==4){
            //cout << u << endl;
            int tmp[3],top = 0;
            for (int v:g[u]) if (v!=fa)
                tmp[top++] = v;
            int ret = -1;
            ret = three_son(tmp[0],tmp[1],tmp[2],u,d+1);
            if (ret != -1) return u;
            ret = three_son(tmp[1],tmp[0],tmp[2],u,d+1);
            if (ret != -1) return u;
            ret = three_son(tmp[2],tmp[1],tmp[0],u,d+1);
            if (ret != -1) return u;
            return -1;
        }
    }
 
    if (du[u] != 3) return -1;
 
	for (int v:g[u]) {
		if (v == fa) continue;
		ans = min(ans,dfs(v,u,d+1));
	}
	return ans;
}
void dfs_siz(int u,int fa)
{
    siz[u] = 1;
    for (int v:g[u]) {
        if (v == fa) continue;
        dfs_siz(v,u);
        siz[u] += siz[v];
        ma_son[u] = max(ma_son[u],siz[v]);
    }
    ma_son[u] = max(ma_son[u],(1<