2023牛客暑期多校训练营3

已于 2023-08-01 21:35:05 修改
阅读量198 收藏
点赞数
分类专栏： 2023牛客暑假多校 文章标签： 算法 数据结构
于 2023-08-01 21:34:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Unlimited_ci/article/details/132043927
版权

目录

A.World Fragments I

D.Ama no Jaku

E.Koraidon, Miraidon and DFS Shortest Path

 H.Until the Blue Moon Rises

J.Fine Logic

A.World Fragments I

思路：签到，因为是将x转换为y，所以当x为0时且y不为0时是无法进行转换的，否则输出abs（x-y）即可。

#include<bits/stdc++.h>

using namespace std;
const int N=2e5+5;
typedef long long ll;
typedef pair<ll,ll> pll;
int mod=998244353;
const int maxv=4e6+5;


void solve()
{	
	string x,y;
	cin>>x>>y;
	ll c1=0,c2=0;
	for(int i=0;i<x.size();i++){

			c1=c1*2+x[i]-'0';

	}
	for(int i=0;i<y.size();i++){

			c2=c2*2+y[i]-'0';

	}
   // cout<<c1<<" "<<c2<<endl;
	if(c1==0&&c2!=0){
		cout<<-1<<endl;
        return ;
	}
    cout<<abs(c1-c2)<<endl;
}

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	int t;
	t=1;
	//cin>>t;
	while(t--){
		//if(n==-1&&k==-1) break;
		solve();
	}
	system("pause");
	return 0;
}

D.Ama no Jaku

思路：只有全部变为0或者全部变为1才合法。那么现在考虑如何使操作步数最小。

考虑每一行，每一行只有与第一行相同或是与第一行反转相同，对于列同理。统计行和列这两类最小的操作次数相加即可。

对于上述的优化：我们对第一行和第一列中0和1的数量进行统计即可。然后记录第一行翻转后的字符串，最后对于每一行去一一匹配。因为如果每一行都可以通过翻转或者保持原状和第一行一致的话，那么所有行终会相等，所有行相等，表示每一列内部都是相同的，所以此时不需要去让每一列和列首进行比较。至于统计第一行和第一列中0和1的数目和此同理。

#include<bits/stdc++.h>

using namespace std;
const int N=2e5+5;
typedef long long ll;
typedef pair<ll,ll> pll;
int mod=998244353;
const int maxv=4e6+5;

ll qmi(int a,int b)
{
    ll res=1;
    while(b){
        if(b%2) res*=b%mod;
        b>>=1;
        a=a*a%mod;
    }
    return res;
}

ll inv(int x)
{
    return qmi(x,mod-2);
}
string a[N];

void solve()
{	
	int n;	
    cin>>n;
	for(int i=0;i<n;i++) cin>>a[i];
	string s;
	int c1=0,c2=0;
	for(int i=0;i<n;i++){
		s+=a[0][i]^1;
		c1+=(a[0][i]=='0');
		c2+=(a[i][0]=='0');
	}
	for(int i=0;i<n;i++){
		if(a[i]!=a[0]&&a[i]!=s){
			cout<<-1<<endl;
			return ;
		}
	}
	cout<<min(n-c1,c1)+min(n-c2,c2)<<endl;

}

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	int t;
	t=1;
	//cin>>t;
	while(t--){
		solve();
	}
	system("pause");
	return 0;
}

E.Koraidon, Miraidon and DFS Shortest Path

思路：考虑以下几种情况：（懵哥给出）

一个点有多种方式到达

这种情况肯定不合法。

出现环：

情况三：

感觉情况三实际上跟情况一差不多，对于(u,v)为深至浅，分析从1号点开始，是否非要进过u到达v，若是必须，则是图二中环的情况，否则即为图三。所以考虑支配树。

先给出支配的定义： 

我们以5为例子，5的最近支配点为2，但其实是有其他路径能从1到达5的，那么此种情况肯定不合法。

所以我们对支配树用lca进行维维护，然后再bfs的过程中去check即可。

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 10;
namespace dtree // 支配树模板
{
    const int MAXN = 500020;
    vector<int> E[MAXN], RE[MAXN], rdom[MAXN];

    int S[MAXN], RS[MAXN], cs;
    int par[MAXN], val[MAXN], sdom[MAXN], rp[MAXN], dom[MAXN];

    void clear(int n)
    {
        cs = 0;
        for (int i = 0; i <= n; i++)
        {
            par[i] = val[i] = sdom[i] = rp[i] = dom[i] = S[i] = RS[i] = 0;
            E[i].clear();
            RE[i].clear();
            rdom[i].clear();
        }
    }
    void add_edge(int x, int y) { E[x].push_back(y); }
    void Union(int x, int y) { par[x] = y; }
    int Find(int x, int c = 0)
    {
        if (par[x] == x)
            return c ? -1 : x;
        int p = Find(par[x], 1);
        if (p == -1)
            return c ? par[x] : val[x];
        if (sdom[val[x]] > sdom[val[par[x]]])
            val[x] = val[par[x]];
        par[x] = p;
        return c ? p : val[x];
    }
    void dfs(int x)
    {
        RS[S[x] = ++cs] = x;
        par[cs] = sdom[cs] = val[cs] = cs;
        for (int e : E[x])
        {
            if (S[e] == 0)
                dfs(e), rp[S[e]] = S[x];
            RE[S[e]].push_back(S[x]);
        }
    }
    int solve(int s, int *up)
    {
        dfs(s);
        for (int i = cs; i; i--)
        {
            for (int e : RE[i])
                sdom[i] = min(sdom[i], sdom[Find(e)]);
            if (i > 1)
                rdom[sdom[i]].push_back(i);
            for (int e : rdom[i])
            {
                int p = Find(e);
                if (sdom[p] == i)
                    dom[e] = i;
                else
                    dom[e] = p;
            }
            if (i > 1)
                Union(i, rp[i]);
        }
        for (int i = 2; i <= cs; i++)
            if (sdom[i] != dom[i])
                dom[i] = dom[dom[i]];
        for (int i = 2; i <= cs; i++)
            up[RS[i]] = RS[dom[i]];
        return cs;
    }
}
int up[MAXN];//记录每个节点的最近支配节点
vector<int> G[MAXN];
int dep[MAXN], f[21][MAXN];
void dfs(int x, int fa)//dfs跑支配树中每个节点的深度
{
    dep[x] = dep[fa] + 1;
    for (int i = 0; i <= 19; i++)
        f[i + 1][x] = f[i][f[i][x]];
    for (auto it : G[x])
    {
        if (it == fa)
            continue;
        f[0][it] = x;
        dfs(it, x);
    }
}
int lca(int x, int y)//维护最近公共祖先
{
    if (dep[x] < dep[y])
        swap(x, y);
    for (int i = 20; i >= 0; i--)
    {
        if (dep[f[i][x]] >= dep[y])
            x = f[i][x];
        if (x == y)
            return x;
    }
    for (int i = 20; i >= 0; i--)
        if (f[i][x] != f[i][y])
            x = f[i][x], y = f[i][y];
    return f[0][x];
}
string solve()
{
    int n, m;
    cin >> n >> m;
    dtree::clear(n);
    for (int i = 1; i <= n; i++)
        G[i].clear();
    for (int i = 1; i <= m; i++)
    {
        int x, y;
        cin >> x >> y;
        dtree::E[x].push_back(y);
    }
    dtree::solve(1, up);
    for (int i = 2; i <= n; i++)
        G[up[i]].push_back(i);
    /*for(int i=2;i<=n;i++){
        cout<<up[i]<<" ";
        cout<<endl;
    }*/
    dfs(1, 0);
    const int inf = 1e9;
    vector<int> dis(n + 1, inf);
    dis[1] = 0;
    queue<int> q;
    q.push(1);
    bool flag = true;
    while (!q.empty())
    {
        int x = q.front();
        q.pop();
        for (auto it : dtree::E[x])
            if (dis[it] == inf)//合法情况
            {
                q.push(it);
                dis[it] = dis[x] + 1;
                continue;
            }
            else if (dis[it] != dis[x] + 1)
//懵哥题解中给出的情况2，3，当为一个环时，x为环尾，it为环首，
//因为该环的支配节点皆为每个点的前驱节点，所以lca必然合法。
            {
                if (lca(it, x) != it){
                    flag = false;
                    //cout<<lca(it,x)<<" "<<it<<" "<<x<<endl;
/*情况三中给出的图，有一条5-3的边，
但5和3的lca为1，此时为由深指向浅，但是两者的lca不为较深的节点，所以肯定是不合法的*/
                }

            }
    }
    if (flag)
        return "Yes";
    else
        return "No";
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int T;
    cin >> T;
    while (T--)
        cout << solve() << endl;
    system("pause");
    return 0;
}

 H.Until the Blue Moon Rises

思路：根据哥德巴赫猜想，任意一个偶数都可以被分解为两个质数之和，对此此题进行分类讨论即可。

1：当n为1时，那么总和必须得是质数

2：当n为2时，当总和为奇数时，那么对于两个质数和为奇数的情况，必然是只能一个数为奇数，一个数为偶数，那么一个数为偶数且为质数的只有2，由此，我们只需要保证和-2为质数就行；当总数为偶数时，我们保证和大于四即可，因为两个质数都2即为最小情况。

3当n大于2时，和大于2*n即可。

#include<bits/stdc++.h>

using namespace std;
const int N=2e5+5;
typedef long long ll;
typedef pair<ll,ll> pll;
int mod=1e9+7;
const int maxv=4e6+5;



void solve()
{	
	int n;
	cin>>n;
	vector<ll> a(n);
	ll sum=0;
	for(auto &ai: a) cin>>ai;
    for(int i=0;i<n;i++) sum+=a[i];
    if(n==1){
        if(sum<2){
            cout<<"No"<<endl;
            return;
        }
        for(int i=2;i<=sum/i;i++){
            if(sum%i==0) {
                cout<<"No"<<endl;
                return ;
            }
        }
        cout<<"Yes"<<endl;
    }
    else if(n==2){
        if(sum%2==0){
            if(sum>=4) cout<<"Yes"<<endl;
            else cout<<"No"<<endl;
        }
        else{
            ll x=sum-2;
            if(x<2){
                cout<<"No"<<endl;
                return;
            }    
            for(int i=2;i<=x/i;i++){
                if(x%i==0) {
                    cout<<"No"<<endl;
                    return ;
                }
            }
            cout<<"Yes"<<endl;
        }
    }
    else{
        if(sum>=2*n) cout<<"Yes"<<endl;
        else cout<<"No"<<endl;
    }
}

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	int t;
	t=1;
	//cin>>t;
	while(t--){
		//if(n==0) break;
		solve();
	}
	system("pause");
	return 0;
}

J.Fine Logic

思路：给出了偏序关系，自然想到建图，然后按题意来跑拓扑排序，我们可以发现，最多只需要两次全排列即可，因为需要第二次全排列的情况是出现了环，环的首尾相连无法在一个全排列中满足，且无论多少个环，都只需要两个全排列进行解决，因为首尾相连的那条边全部放在第二个全排列中即可，既然如此，我们可以知道，两个全排列可以满足所有情况，那么应该如何构造？当出现环时，我们将全排列正着输出一遍，反向输出一边即可，因为这样满足了任意两点之间的关系，若无环则只需要输出一组拓扑序即可。

#include<bits/stdc++.h>

using namespace std;
const int N=1e6+5;
typedef long long ll;
typedef pair<ll,ll> pll;
int mod=1e9+7;
const int maxv=4e6+5;


vector<int> e[N];
int st[N];
int f=0;
int n,m;
vector<int> ans;
int d[N];
void dfs(int x,int pre)
{
    st[x]=1;
    for(auto u: e[x]){
        if(st[u]==1){
            f=1;
        }
        else if(st[u]==0){
            dfs(u,x);
        }
    }
    st[x]=2;
}

void topsort()
{
    queue<int> q;
    for(int i=1;i<=n;i++){
        if(d[i]==0) q.push(i);
    }
    while(!q.empty()){
        int t=q.front();
        q.pop();
        ans.push_back(t);
        for(auto x: e[t]){
            d[x]--;
            if(d[x]==0) q.push(x);
        }
    }
}
void solve()
{	

    cin>>n>>m;
    for(int i=1;i<=m;i++){
        int a,b;
        cin>>a>>b;
        e[a].push_back(b);
        d[b]++;
    }
    for(int i=1;i<=n;i++){
        if(!st[i]){
            dfs(i,-1);
        }
    }    
    topsort();
    if(!f){
        cout<<1<<endl;
        for(auto x: ans) cout<<x<<" ";
        cout<<endl;
    }
    else{
        cout<<2<<endl;
        for(int i=1;i<=n;i++) cout<<i<<" ";
        cout<<endl;
        for(int i=n;i>=1;i--) cout<<i<<" ";
        cout<<endl;
    }

}

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	int t;
	t=1;
	//cin>>t;
	while(t--){
		solve();
	}
	system("pause");
	return 0;
}

Unlimitedz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2020牛客暑期多校集训营第二场题解.pdf
01-20
### 2020牛客暑期多校集训营第二场题解 #### Gromah 题目解析 在本次解析中，我们将逐一探讨各题目的关键算法思想和技术细节。 ### A. All with Pairs (全部配对) 本题讨论了如何利用哈希表来解决一对对字符串的...
2024牛客暑期训练营第一场
07-22
### 2024牛客暑期训练营第一场补题报告关键知识点解析 #### 题目C: Accept **核心思想**: 维护序列总和及其权值变化。 **详细解析**: - **背景**: 给定一个序列 `a[1], a[2], ..., a[n]` 和一系列操作，每轮操作...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 866
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
2.6基本算法之动态规划6045:开餐馆
Andy_SCP001的博客
07-24 168
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
cf场+线性dp
xxx_jsu的博客
07-23 325
令a[1]=x[1]+1后我们可以让a[i+1]=a[i]+x[i]，但是这样的话数可能会比较小，所以我们可以累加a[i]，因为是mod所以只要不大于x[i+1]可以一直加下去。2.n>b-a>0这种情况我们还需要考虑到使用到的a，在此之前我们按照等差数列出售了(b-a)个，那么剩下n-(b-a)个我们则需要按照a来出售。采用双指针，一个指向a的头部，一个指向b的头部，两者开始进行匹配，若相同则b往下走一位，否则就终止。题目的第一问其实就是让我们求最长不上升子序列，第二问就是求有多少段最长不上升序列。
2766. 重新放置石块 Medium
珞米的博客
07-24 502
第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，有石块的位置为 [2,2,3,3]。第 i = 1 步操作中，我们将位置 3 处的石块移到位置 2 处，有石块的位置为 [2,2,2,2]。第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，位置 2,6,7,8 有石块。第 i = 1 步操作中，我们将位置 7 处的石块移到位置 9 处，位置 2,6,8,9 有石块。第 i = 2 步操作中，我们将位置 2 处的石块移到位置 5 处，位置 5,6,8,9 有石块。
代码随想录算法训练营第二十二天|回溯算法part01
最新发布
qq_43456971的博客
07-25 590
这一题与上题一样，除了终止条件中需要判断和是否为target。多了一个剪枝操作，就是当值已经大于target，直接返回。本题还有一个建立数字和字母之间映射的问题，使用string数组来进行映射。因此回溯算法的宽度是每个集合里面的个数，回溯算法的深度是集合的个数。参数是digits与index，index是用来记录遍历第几个集合。在单个集合1-9中，寻找所有个数为k且和为target的组合。在单个集合1-n中，寻找所有个数为k的组合。这一题是在多个集合中找所有可能的组合。和所有递归一样，都有三部曲。
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 249
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
算法-KMP字符串匹配
xx_xb的博客
07-23 250
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
算法题目整合5
qq_62571233的博客
07-23 901
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 302
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
贪心加暴力枚举
wniuniu_的博客
07-24 204
所以我们可以直接暴力枚举，然后我们知道假操作一定是在最开始进行，至于加多少次我们可以直接枚举。
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
danaaaa的博客
07-24 1022
二叉搜索树向左或向右指明方向，不用遍历整个树。
2.6基本算法之动态规划2989:糖果
Andy_SCP001的博客
07-24 373
糖果公司的N件产品每件都包含数量不同的糖果。Dzx希望他选择的产品包含的糖果总数是K的整数倍，这样他才能平均地将糖果分给帮助他维护世界和平的伙伴们。/*边界条件:dp[i][j]初始化为负无穷,int dp[1005][1005];//dp[i][j]:从i种糖果中选,组成糖果总数量k的倍数。dp[0][0]=0;//dp[0][0]边界条件:0种糖果组成糖果总数量0的倍数是0。另外,必须保证所有的状态是由dp[0][0]转移过来的*/除了dp[0][0]为0,因为我们这里求的是最大值,
Python鲁汶意外莱顿复杂图拓扑分解算法
跨学科知识视角展现
07-24 1049
:dart:算法池化和最佳分区搜索：:pen:网格搜索 | :pen:发现算法池 | :pen:返回指定图的最佳划分 | :pen:返回指定图的最佳分区 | :dart:适应度和聚类比较功能：:pen:图的划分 | :pen:节点度 | :pen:给定算法检测到社群总数 | :pen:图密度 | :pen:社群顶点的度数之和 | :pen:解之间的预期一致 | :pen:联合熵 | :pen:平均内部度、所有可能的节点对的平均路径长度 | :pen:节点指向社群外的边平均比例 | :pen:现有边距离社群比
【算法】分割回文串
时清云的博客
07-24 311
难度：中等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值