牛客练习赛62题解

题目链接

A.牛妹的游戏

题意：
$n个点的完全图，m条边属于一类阵营$
$另外m条边属于另一类阵营$
$给出你n，m和这m条边，问相同阵营是否存在一个三元环$
题解：
$通过画图观察可以发现$
$n<=5的时候$
$将每个点依次相连，首尾相接，就不会存在同阵营三元环$
$但是当n>5的时候$
$如果再次这样，你就会发现，可以在内部成为一个三元环$
$但是如果加上三元环的其中一个边，就会构造成另外一个阵营的三元环$
$看题解这道题是个拉姆塞结论，大概就是n大于5必有三元环这种意思$
$n<5的时候，就可以用邻接矩阵存图$
$直接枚举任意三个点，看这三个点之间的边同属于这m条边或者都不属于即可$

AC代码

#include<bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define endl '\n'
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int mod=1e9+7;
//const int mod=998244353;
const double eps = 1e-10;
const double pi=acos(-1.0);
const int maxn=1e6+10;
const ll inf=0x3f3f3f3f;
const int dir[4][2]={{0,1},{1,0},{0,-1},{-1,0}};

int g[10][10];

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    int t;
    cin>>t;
    while(t--){
        int n,m;
        cin>>n>>m;
        if(n>5){
            cout<<"yes"<<endl;
            for(int i=0;i<m;i++){int u,v;cin>>u>>v;}
            continue;
        }
        memset(g,0,sizeof g);
        for(int i=0;i<m;i++){
            int u,v;
            cin>>u>>v;
            g[u][v]=g[v][u]=1;
        }
        bool f=0;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                for(int k=1;k<=n;k++){
                    if(i==j||j==k||i==k)continue;
                    if(g[i][j]==g[i][k]&&g[i][k]==g[j][k]&&g[j][k]==g[i][j])f=1;
                }
        if(f)cout<<"yes"<<endl;
        else cout<<"no"<<endl;
    }


    return 0;
}

---

B.病毒扩散

题意：
$（0，0）处有一个感染者$
$在每1s每个点都会往右边的一个点和上边的一个点扩散一个感染者$
$q次询问在（x,y）在ts的时候有多少感染者$
题解：
$问题模型转换$
$可以转换成某个人ts的时间到达（x，y）的方案数$
$每秒它可以不动，右移或者上移$
$右移和上移就代表正常的每秒的扩散$
$不动就代表在某个点的下一秒或者以后几秒对（x，y）的扩散数$
$问题模型转换好了，就很好写了$
$使用组合数，C(t,x)\ast C(t-x,y)$
$从ts里选出xs和ys右移和上移即可$

AC代码

#include<bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define endl '\n'
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
//const int mod=1e9+7;
const int mod=998244353;
const double eps = 1e-10;
const double pi=acos(-1.0);
const int maxn=1e6+10;
const ll inf=0x3f3f3f3f;
const int dir[4][2]={{0,1},{1,0},{0,-1},{-1,0}};

ll fact[maxn],inv1[maxn];
ll Pow(ll a, ll b){
	ll ans = 1;
	while(b > 0){
		if(b & 1){
			ans = ans * a % mod;
		}
		a = a * a % mod;
		b >>= 1;
	}
	return ans;
}
//逆元
ll inv(ll b){
    return Pow(b,mod-2)%mod;
}



ll C(ll n,ll m){
    if(m==0||m==n) return 1;
    ll res=(fact[n]*inv1[m]%mod*inv1[n-m])%mod;
    return res;
}

void init() {
	fact[0] = 1;
	for (int i = 1; i < maxn; i++) {
		fact[i] = fact[i - 1] * i %mod;
	}
	inv1[maxn - 1] = Pow(fact[maxn - 1], mod - 2);
	for (int i = maxn - 2; i >= 0; i--) {
		inv1[i] = inv1[i + 1] * (i + 1) %mod;
	}
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    int t;
    cin>>t;
    init();
    while(t--){
        ll x,y,t;
        cin>>x>>y>>t;
        if(x+y>t)cout<<0<<endl;
        else cout<<(C(t,x)*C(t-x,y))%mod<<endl;
    }


    return 0;
}

---

C.牛牛染颜色

题意：
$给一个有n个结点的树，1是根结点$
$每个结点可以染色成黑色或者白色$
$如果两个结点是黑色，那么他们两个结点的最近公共祖先也必须是黑色$
$问有多少种涂色方案$
题解：
$树形DP$
$用dp[u][0/1]表示树上结点u染黑色(1)或者白色(0)的方案数$
$如果这个结点是黑色，那么他的任何一个子树都可以是黑色或者白色$
$即dp[v][1]+dp[v][0]$
$如果这个结点是白色，那么他的子树$
$只能全部白色，或者只有一个黑色的$
$由于要考虑空集防止重复计算的情况，所以要对每次情况进行减一，最后结束了加上这个空集$
$所以可以得到转移方程$

$dp[u][0]=(dp[u][0]+dp[v][1]+dp[v][0]-1)$
$dp[u][1]=dp[u][1]\ast (dp[v][1]+dp[v][0])$

$最后的答案即dp[1][1]+dp[1][0]$

AC代码

#include<bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define endl '\n'
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int mod=1e9+7;
//const int mod=998244353;
const double eps = 1e-10;
const double pi=acos(-1.0);
const int maxn=1e6+10;
const ll inf=0x3f3f3f3f;
const int dir[4][2]={{0,1},{1,0},{0,-1},{-1,0}};

struct edge{
    int v,nx;
}e[maxn<<1];
int head[maxn];
int cnt;
void add(int u,int v){
    e[++cnt].v=v;
    e[cnt].nx=head[u];
    head[u]=cnt;
}
ll dp[maxn][2];
void dfs(int u,int fa){
    dp[u][0]=dp[u][1]=1;
    for(int i=head[u];i;i=e[i].nx){
        int v=e[i].v;
        if(v==fa)continue;
        dfs(v,u);
        dp[u][0]=(dp[u][0]+dp[v][1]+dp[v][0]-1)%mod;
        dp[u][1]=dp[u][1]*(dp[v][1]+dp[v][0])%mod;
    }
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    int n;
    cin>>n;
    for(int i=1;i<n;i++){
        int u,v;
        cin>>u>>v;
        add(u,v);add(v,u);
    }
    dfs(1,0);
    cout<<(dp[1][0]+dp[1][1])%mod<<endl;
    return 0;
}

---

D. 牛牛的呱数

题意：
$给你n个数，每个数的长度<=1e6$
$每个数有无数个，任意组合，组合成p的倍数$
$问这样组成数最小的长度$
题解：
$由于n<=100,p<=200$
$所以可以考虑BFS$
$枚举每种情况，维护一下再向p取余的结果x和长度y此时的最短长度$
$每次连接这n个数，然后加入队列$
$每次新的dx=(x+10^y\ast a[i])\%p$
$然后BFS每次当x=0的时候取这个结果，最终取最小值即可$

AC代码

#include<bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define endl '\n'
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int mod=1e9+7;
//const int mod=998244353;
const double eps = 1e-10;
const double pi=acos(-1.0);
const int maxn=1e6+10;
const ll inf=0x3f3f3f3f;
const int dir[4][2]={{0,1},{1,0},{0,-1},{-1,0}};

int a[110];
int dis[210][210];
int len[110];
int b[maxn];
struct node{
    int a,b,len;
};

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    int n,p;
    cin>>n>>p;
    b[0]=1;
    for(int i=1;i<maxn;i++)b[i]=b[i-1]*10%p;
    for(int i=1;i<=n;i++){
        string s;
        cin>>s;
        len[i]=s.length();
        for(int j=0;j<len[i];j++)
            a[i]=(a[i]*10+s[j]-'0')%p;
    }
    int ans=inf;
    memset(dis,inf,sizeof dis);
    queue<node> q;
    for(int i=1;i<=n;i++){
        int da=a[i];
        int db=b[len[i]];
        int dlen=len[i];
        if(dis[da][db]>dlen){
            dis[da][db]=dlen;
            q.push((node){da,db,dlen});
        }
    }
    while(!q.empty()){
        node x=q.front();
        q.pop();
        if(x.len>dis[x.a][x.b])continue;
        if(!x.a)ans=min(ans,x.len);
        for(int i=1;i<=n;i++){
            int da=(x.a+a[i]*x.b)%p;
            int db=x.b*b[len[i]]%p;
            int dlen=x.len+len[i];
            if(dlen<dis[da][db]){
                dis[da][db]=dlen;
                q.push((node){da,db,dlen});
            }
        }
    }
    if(ans>=inf)cout<<-1;
    else cout<<ans;
    return 0;
}