牛客练习赛43 题解

最新推荐文章于 2022-03-20 13:33:50 发布
原创 最新推荐文章于 2022-03-20 13:33:50 发布 · 395 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文介绍了解决分数除法问题的一种快速幂方法，并提出了一种改进的Kruskal算法来解决最小生成树问题。此外，还探讨了容斥原理在游戏策略中的应用。

这场打的有点梦游......

B.Tachibana Kanade Loves Probability

思路：我们模拟一下分数除法 a/b 发现是不停的 ：a*10，a%=b，然后根据这点直接快速幂求出第k1为数是多少就行。

#include<bits/stdc++.h>
#define ll long long
using namespace std;
ll ksm(ll res,ll x,int y,int mod)
{
	while(y)
	{
		if(y&1)res=res*x%mod;
		x=x*x%mod;
		y/=2;
	}
	return res;
}
int main()
{
	int T;
	scanf("%d",&T);
	while(T--)
	{
		ll a,b,k1,k2,num=10;
		scanf("%lld%lld%lld%lld",&a,&b,&k1,&k2);
		a=ksm(a,num,k1-1,b);
		int n=k2-k1+1;
		for(int i=1;i<=n;i++)
		{
			a*=10;
			int x=a/b;
			printf("%c",x+'0');
			a%=b;
		}
		puts("");
	}
}

C. Tachibana Kanade Loves Review

思路：很显然的求最小生成树，但是我用prim疯狂超时了，我们可以把这个题改成kruskal然后基数排序求最小生成树，怎么改呢？我们加入0号点，对于点 u ，如果 u 不在k个点集中，那么连接边 0<-->u，权值为au，如果u在k个点集中，那么设置边权为0，然后就用 kruskal对着n+1个点求最小生成树即可。

#include<bits/stdc++.h>
#define ll long long
//#define reads(x) scanf("%d",&x)
using namespace std;
const int maxn=1e6+10;
int cnt,Laxt[maxn*10],Next[maxn*10],To[maxn*10];
int Len[maxn*10],a[maxn],vis[maxn];
ll t,res;
struct node
{
	int u,w;
	node(int a,int b){u=a,w=b;}
	bool operator<(const node&t)const
	{
		return w>t.w;
	}
};
priority_queue<node>q;
void prim()
{
	while(!q.empty())
	{
		int u=q.top().u;
		int tmp=q.top().w;
		q.pop();
		if(vis[u])continue;
		vis[u]=1;
		res+=tmp;
		for(int i=Laxt[u];i;i=Next[i])
		{
			int v=To[i];
			if(!vis[v]&&Len[i]<a[v])
			q.push(node(v,Len[i])),a[v]=Len[i];
		}
	}
}
void add(int u,int v,int w)
{
	Next[++cnt]=Laxt[u];
	Laxt[u]=cnt;
	To[cnt]=v;
	Len[cnt]=w;
}

inline int read() {
    int x = 0,f = 1;
    char ch = getchar();
    while(!isdigit(ch)) { if(ch == '-') f = -1; ch = getchar();}
    while(isdigit(ch)) { x = (x << 3) + (x << 1) + ch - 48; ch = getchar();}
    return x*f;
}

int main()
{
	int n,m,k,u,v,x,mx=1;
	n=read();m=read();k=read();t=read();
	for(int i=1;i<=n;i++)
	{
		a[i]=read();
	}
	for(int i=1;i<=k;i++)
	{
		x=read();
		vis[x]=1;
	}
	for(int i=1;i<=n;i++)
	if(!vis[i])
	q.push(node(i,a[i]));
	
	for(int i=1;i<=m;i++)
	{
		u=read();v=read();x=read();
		add(u,v,x);
		add(v,u,x);
	}
	for(int i=1;i<=n;i++)
	if(vis[i])
	{
		for(int j=Laxt[i];j;j=Next[j])
		if(Len[j]<a[To[j]]&&!vis[To[j]])
		{
			q.push(node(To[j],Len[j]));
			a[To[j]]=Len[j];
		}	
	}
	prim();	
	if(res>t)puts("No");
	else puts("Yes");
}

D.Tachibana Kanade Loves Sequence

思路：我们把两个数组从大到小排序，取出两个数组中所有大于1的数，分别算总权值v1 v2，假设v1>v2，那么我们就从a数组中选取的数中从小到大删除直到v1刚好>=v2（即再删除一个数v1<v2），那么这样贪心出来的结果肯定是最优的。

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn=1e5+10;
struct node
{
	int x,id;
	bool operator<(const node&t)const
	{
		return x>t.x;
	}
}a[maxn],b[maxn];
int ans1[maxn],ans2[maxn];
ll ans,t1,t2;
int main()
{
	int n,k1,k2,num1=0,num2=0;
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	scanf("%d",&a[i].x),a[i].id=i;
	for(int i=1;i<=n;i++)
	scanf("%d",&b[i].x),b[i].id=i;
	sort(a+1,a+1+n);
	sort(b+1,b+1+n);
	for(int i=1;i<=n;i++)
	if(a[i].x>=2)
	t1+=a[i].x,num1++,ans1[a[i].id]=1;
	else
	{
		k1=i-1;
		break;
	}
	for(int i=1;i<=n;i++)
	if(b[i].x>=2)
	t2+=b[i].x,num2++,ans2[b[i].id]=1;
	else
	{
		k2=i-1;
		break;
	}
	int k=k1,flag=1;
	if(t1<t2)k=k2,flag=2;
	for(int i=k;i;i--)
	if(flag==1)
	{
		if(t1-a[i].x>=t2)
		{
			t1-=a[i].x;
			num1--;
			ans1[a[i].id]=0;
		}
		else
		break;
	}
	else
	{
		if(t2-b[i].x>=t1)
		{
			t2-=b[i].x;
			num2--;
			ans2[b[i].id]=0;
		}
		else
		break;
	}
	printf("%lld\n",min(t1,t2)-num1-num2);
	for(int i=1;i<n;i++)
	printf("%d ",ans1[i]);printf("%d\n",ans1[n]);
	for(int i=1;i<n;i++)
	printf("%d ",ans2[i]);printf("%d\n",ans2[n]);
}

E. Tachibana Kanade And Dream City

思路：我们先求出任意两点最短路，然后二分距离dist，对于所有点u，连接S-->u，流量为v，u+n-->T，流量为w，u-->u+n，流量为无限大，枚举所有最短路小于等于dist的点 u v，连边 u-->v+n，流量为无穷大，如果跑出来最大流等于源点所有流量那么这个dist就是可行的。

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn=405,inf=1e9+1;
struct Edge
{
    int from,to,cap,flow;
};
struct Dinic
{
    int n,m,s,t;
    vector<Edge>edges;
    vector<int>G[maxn];
    bool vis[maxn];
    int d[maxn];
    int cur[maxn];
    void init(int n)
    {
        this->n=n;
        for(int i=0;i<n;i++)G[i].clear();
        edges.clear();
    }
    void Add(int from,int to,int cap)
    {
        edges.push_back((Edge){from,to,cap,0});
        edges.push_back((Edge){to,from,0,0});
        m=edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }
    bool bfs()
    {
        memset(vis,0,sizeof(vis));
        queue<int>Q;
        Q.push(s);
        d[s]=0;
        vis[s]=1;
        while(!Q.empty())
        {
            int x=Q.front();Q.pop();
            for(int i=0;i<G[x].size();i++)
            {
                Edge& e=edges[G[x][i]];
                if(!vis[e.to]&&e.cap>e.flow)
                {
                    vis[e.to]=1;
                    d[e.to]=d[x]+1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }
    int dfs(int x,int a)
    {
        if(x==t||a==0)return a;
        int flow=0,f;
        for(int& i=cur[x];i<G[x].size();i++)
        {
            Edge& e=edges[G[x][i]];
            if(d[x]+1==d[e.to]&&(f=dfs(e.to,min(a,e.cap-e.flow)))>0)
            {
                e.flow+=f;
                edges[G[x][i]^1].flow-=f;
                flow+=f;
                a-=f;
                if(a==0)break;
            }
        }
        return flow;
    }
    int Maxflow(int s,int t)
    {
        this->s=s;this->t=t;
        int flow=0;
        while(bfs())
        {
            memset(cur,0,sizeof(cur));
            flow+=dfs(s,inf);
        }
        return flow;
    }
}solve;
int u[maxn],w[maxn],n,m;
ll d[maxn][maxn];
int ok(int mid)
{
    solve.init(n*2+2);
    int S=0,T=n*2+1,res=0;
    for(int i=1;i<=n;i++)
    {
        solve.Add(S,i,u[i]);
        solve.Add(i+n,T,w[i]);
        solve.Add(i,i+n,inf);
        res+=u[i];
    }
    for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
    if(d[i][j]<=mid)
    solve.Add(i,j,inf);
     
    return solve.Maxflow(S,T)==res;
}
void update(ll& x,ll y)
{
    x=min(x,y);
}
int main()
{
    int l=0,r=1e9,mid,a,b,c;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    scanf("%d%d",&u[i],&w[i]);
    for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)d[i][j]=inf;
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&a,&b,&c);
        update(d[a][b],c);
        update(d[b][a],c);
    }
    for(int k=1;k<=n;k++)
    for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
    update(d[i][j],d[i][k]+d[k][j]);
    if(!ok(r))
    {
    	puts("-1");
    	return 0;
	}
    while(l<r)
    {
        mid=(l+r)/2;
        if(ok(mid))r=mid;
        else l=mid+1;
    }
    printf("%d\n",l);
}

F. Tachibana Kanade Loves Game

思路：裸的容斥原理。

#include<bits/stdc++.h>
#define pi pair<int,int>
#define Pair(x,y) make_pair(x,y)
#define ll long long
using namespace std;
int pri[10]={0,2,3,5,7,11,13,17,19};
int vis[21];
vector<pi>G[21];
void init()
{
    for(int i=1;i<=8;i++)
    vis[pri[i]]=1;
    G[2].push_back(Pair(2,1));
    for(int i=3;i<=20;i++)
    {
        G[i]=G[i-1];
        if(!vis[i])continue;
        G[i].push_back(Pair(i,1));
        for(int j=0;j<G[i-1].size();j++)
        {
            pi tmp=G[i-1][j];
            tmp.second*=-1;
            tmp.first*=i;
            G[i].push_back(tmp);
        }
    }
}
int main()
{
    int T;
    init();
    scanf("%d",&T);
    while(T--)
    {
        ll n,m,a,b;
        scanf("%lld%lld%lld%d",&a,&b,&n,&m);
        if(!a)puts("QAQ");
        else if(!b)puts("Yes");
        else
        {
            for(int i=0;i<G[m].size();i++)
            {
                pi tmp=G[m][i];
                a-=n/tmp.first*tmp.second;
            }
            a+=n;
            if(a>b)puts("Yes");
            else puts("QAQ");
        }
    }
}

 

bool operator==(const T& t) const，关系运算符重载
weixin_42322256的博客
04-10 6184
基本定义： bool operator ==( )可以分为——bool operator ==( const bool& other)、bool operator ==( const T& other), 其中T代表类型； 运算符函数定义的一般格式如下： <返回类型说明符> operator <运算符符号> (<参数表>) { <函数体> } 关系运算符重载： bool operator == (const T& )..
结构体内嵌比较函数bool operator ＜ (const node &x) const {}
Li5566123的博客
03-20 6732
关于结构体内嵌比较函数： 一般情况下: struct node { int l,r; bool operator <(const node &a)const{ return r < a.r; } }a[maxn]; 直接写比较函数是裸的r表示当前的值，如果r<a.r，那么就是从小到大排序，但是优先队列的是相反的。 sort默认为从小到大排序，优先队列默认为从大到小。 struct node { int l,r;
爆刷PAT（甲级）——之链表专题【1032】【1052】【1097】【1133】——一个排序法应对大部分链表题
Hide_in_Code
04-24 430
之前几次PAT，好几次遇见了链表题——将数据以“节点”的形式给出，以“本地址addr”、“值value”、“下一个地址next”的数据形式，让编码者自行逻辑链接操作。由于平时没有刻意关注过，结果实战时按照模拟的方法去做题，要么思维混乱、耗费很多的时间写代码，要么晦涩地模拟出一坨屎。 我个人之前，首先是将“地址”信息作为“字符串”读入；其次，节点间的联系使用map把它映射成数字id；最后，再按照数...
uva11729
dreams_fly_oyzx的博客
05-17 287
uva 11729 任务执行时间长的先交代 #include #include #include #include #include #include using namespace std; #define MAXN (1000+5) struct node{ int b, j; bool operator <(const node &a)const{
牛客练习赛43（A B C F解题报告）
甦萌的博客
04-07 291
比赛链接：https://ac.nowcoder.com/acm/contest/548#question A： 暴力就行的，注意输出 #include<bits/stdc++.h> using namespace std; struct node { int a,b; }mp[105]; int main() { int n,i,a,b,flag,j; ...
牛客练习赛43A A-QAQ
weixin_43104528的博客
05-05 277
思路:找一个A前面一个字符之前的Q与后一个字符之后的Q，两个个数的乘积是用到了这个位置A的子序列的个数。 #include <iostream> #include <bits/stdc++.h> using namespace std; int cnt1[5009] = {0}; //存放第i-1个字符之前有多少Q int cnt2[5009] = {0}; //存放i+1...
牛客练习赛43
weixin_30917213的博客
04-06 74
牛客练习赛43 A题：Tachibana Kanade Loves School 水题，看清"YE5"和"N0"而不是"YES"、"NO"; #include<bits/stdc++.h> using namespace std; int main(){ int n,a[110],b[110]; cin>>n; for(int...
牛客月赛43题解
谈论现实
01-15 1286
牛客小白月赛43题目A 满意的数字题面示例思路代码B 牛牛变魔术题面示例思路代码C 木棍游戏题面示例思路代码D 有趣的区间题面示例思路代码E 满意的集合题面示例思路代码F 全体集合题面示例思路代码 题目 A 满意的数字 题面 示例 思路 每个数都是满意的数字，注意是第m个因子不是每个因子，看题一定要仔细。 代码 #include<bits/stdc++.h> using namespace std; int main(){ int t,N; cin>>t;
牛客练习赛79题解
qaqaqa666的博客
03-27 342
牛客练习赛79题解 A 炼金术师 考试的时候想的是从后面到前面遍历，有不同的颜色，就加一，但是没有通过，一直段错误 利用栈来维护 1、新加入的颜色的长度和栈顶元素比较，如果当前的这个栈顶元素的长度小于新加入的颜色的长度，就表示新加入的颜色可以覆盖栈顶元素的颜色，所以就把栈顶弹出。 2、遇到覆盖不了的元素就可以把这个颜色加入栈了。 #include<bits/stdc++.h> using namespace std; stack<int> s; int mai
【题解】牛客练习赛85
cqbzlydd的博客
06-26 174
昨日如烟，忽觉自闭甚痛。 B题数组开小，导致自闭一整场 D题死磕分块，谁知却是 线段树 + bitset （论算法错误的严重性） E题没有时间读，dpdpdp 神题 B. 简单贪心+尺取。 时间复杂度 O(3n)O(3n)O(3n) 。 D. 我们可以把它抽象为区间数颜色的问题。 分块的时间复杂度 O(15∗n53)O(15*n^{\frac{5}{3}})O(15∗n35​) ，考虑用 ans[i][j]ans[i][j]ans[i][j] 记录块的答案，取 B=n23B=n^{\frac
【牛客网】牛客练习赛43
x_mn的博客
04-08 380
链接：https://ac.nowcoder.com/acm/contest/548/B 来源：牛客网 题目描述 立华奏在学习初中数学的时候遇到了这样一道大水题： “设箱子内有 n 个球，其中给 m 个球打上标记，设一次摸球摸到每一个球的概率均等，求一次摸球摸到打标记的球的概率” “emmm...语言入门题” 但是她改了一下询问方式：设最终的答案为 p ,请输出 p 小数点后 K1K1 到...
牛客练习赛43（B）
xyqqwer的博客
04-06 441
题目链接：https://ac.nowcoder.com/acm/contest/548/B 题目描述 立华奏在学习初中数学的时候遇到了这样一道大水题： “设箱子内有 n 个球，其中给 m 个球打上标记，设一次摸球摸到每一个球的概率均等，求一次摸球摸到打标记的球的概率” “emmm...语言入门题” 但是她改了一下询问方式：设最终的答案为 p ,请输出 p 小数点后 K1K1 到 K2K2...
牛客练习赛43 f Tachibana Kanade Loves Game
xfx's blog
04-07 7445
题目链接 题目描述 立华奏是一个天天打比赛的萌新。 省选将至，萌新立华奏深知自己没有希望进入省队，因此开始颓废。她正在颓废一款名为《IODS 9102》的游戏。 在游戏中，立华奏拥有 k 点血量，而她的对手拥有 q 点血量。当她的血量变为 0 时，游戏便结束了；同理，如果对方的血量变为 0，立华奏就获胜了。在立华奏手中，有 n 种武器，编号分别为1,2,⋯,n，每一种武器在使用后，都能让对方受到 ...
牛客练习赛43C Tachibana Kanade Loves Review
weixin_30849403的博客
04-06 139
题目地址 Link 题解 虚点这种东西还是没有掌握好啊。 考虑建一个虚点，向已经学会的东西连一条边权为0的边，关系正常连边，单独学的从虚点连一条边过去。 然后做一遍最小生成树就得到答案了。 这题略卡常，上个快读稳一点。 #include <algorithm> #include <iostream> #include <cstring> #include &lt...
牛客练习赛43 回顾
weixin_30511039的博客
04-05 178
链接：https://ac.nowcoder.com/acm/contest/548/A来源：牛客网 题目描述 这次 Tachibana Kanade 来到了一个神奇的学校参观，她发现了一些有趣的事情。 这个学校的所有人脾气都十分的古怪：每个人都有两个属性 aiai 和 bibi，每个人都想和除他以外所有 j 满足 ai+bi=ajai+bi=aj 的人搞好关系。我们定义一对人...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

长沙橘子猫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值