2021牛客暑期多校3 BCEFJ题解

最新推荐文章于 2022-07-04 18:53:12 发布
最新推荐文章于 2022-07-04 18:53:12 发布
阅读量107 收藏
点赞数
分类专栏： 2021暑期补题报告
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53344326/article/details/119281260
版权
本文探讨了两种经典算法问题的解决方案：一是通过构造图并寻找最小生成树解决矩阵涂色问题，二是利用最大匹配策略解决矩阵元素排列优化问题。涉及算法包括Prim算法、Kruskal算法和匈牙利算法。通过对每个问题的思路分析和代码实现，展示了如何在实际问题中应用图论知识。
摘要由CSDN通过智能技术生成

B.Black and white
思维题, 只要想出来就好做了.
题目大意:
把一个矩阵全涂黑, 问最少需要多少花费,对一个2*2的矩阵的时候,有三个被涂黑了,那么第四个就黑了.每个元素的值就是涂黑的花费.
思路:
我们把行和列都看成一个点, 每个格子看成点之间的连线, 然后就得到了一个图. 在图上求最小生成树, 使得整个图能联通. 那就是所求值.
代码:

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 5050;
int fa[N * 2];
ll n, m, a, b, c, d, p;

int find(int x) {
	if (x == fa[x]) {
		return x;
	} else {
		return fa[x] = find(fa[x]);
	}
}

struct vv {
    int u, v, w;
	bool operator < (const vv h) const {
		return h.w < w;
	}
};
priority_queue<vv> pp;
int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin >> n >> m >> a >> b >> c >> d >> p;
	ll tmp = a;
    
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {
			tmp = (tmp * tmp * b + tmp * c + d) % p;
			pp.push({ i, j + (int)n, (int)tmp});
		}
	}
    
	for (int i = 1; i <= n + m; i++) fa[i] = i;
	ll ans = 0, cot = 0;
	while (!pp.empty()) {
		vv tm1 = pp.top();
		pp.pop();
		//         cout << tm1.u << " " << tm1.v << " " << tm1.w << endl;
		int fu = find(tm1.u), fv = find(tm1.v);
		if (fu == fv) continue;
		ans += tm1.w;
		cot++;
        fa[fu] = fv;
		if (cot == n + m - 1) break;
	}
	cout << ans << endl;
}

C. Minimum grid
最大匹配
题目大意:
给出每一行,每一列的最大值,然后给出能存放点的坐标, 然后求最后最小的和.
思路:
对于某个值, 我们要想最小化值, 就是尽量让相同值放在同一个地方, 所以我们就让相同的值作为点, 然后能用的格子作为边. 找最大匹配, 也就是尽量让相同的点匹配.
代码:

#pragma GCC optimize(3)
#include<bits/stdc++.h>

using namespace std;
using ll = long long;

#define ctx cout << "xxxxxxx" << endl

const int K = 1e6 + 10;
const int N = 1e4 + 10;

vector<int> row[K], col[K];
bool mp[N][N];
int match[N], used[N];
vector<int> tmp[N];

ll n, m, k;


bool dfs(int pos)
{
	for (auto i : tmp[pos])
	{
		if (used[i]) continue;
		used[i] = 1;
		if (!match[i] || dfs(match[i]))
		{
			match[i] = pos;
			return 1;
		}

	}
	return 0;
}

int main() {
	cin >> n >> m >> k;
	int x;
	for (int i = 1; i <= n; i++) {
		cin >> x;
		row[x].push_back(i);
	}
	for (int i = 1; i <= n; i++) {
		cin >> x;
		col[x].push_back(i + n);
	}
	for (int i = 1; i <= m; i++) {
		int y;
		cin >> x >> y;
		// 		if(x <= n && y <= n) 
		mp[x][y] = 1;
	}
	ll ans = 0;
	for (int i = k; i >= 1; i--) {
		if (row[i].size() == 0 && col[i].size() == 0) continue;
		//		vector<int> tmp[n+5];
		for (int i = 1; i <= n; i++) tmp[i].clear();
		for (auto r : row[i]) {
			for (auto c : col[i]) {
				if (mp[r][c - n]) tmp[r].push_back(c);
			}
		}
		memset(match, 0, sizeof(match));
		ll res = 0;
		for (int i = 1; i <= n; i++) {
			memset(used, 0, sizeof(used));
			if (dfs(i)) res++;
		}
        ll maxx = row[i].size() + col[i].size() - res;
        ans += maxx*i;
	}

	cout << ans << endl;
}

E. xy = k*(xx + yy), 1 <= x <= y <= n, 求满足的(x, y)对.
思路:
先暴力来一发, 打表找规律. 发现(x, x^3)一定满足, 后面出现了一些跳跃, 表现是y = pre_y * x ^ 2 - pre_x, x = pre_y;类似这样.
存住表, 然后排序, 二分找.
代码:

#include<bits/stdc++.h>
using namespace std;
using ll = long long;

vector<ll> num;

void init(){
	for(ll i = 2; i <= (1e6); i++){
		ll tm1 = i*i*i, tm2 = i;
		while(tm1 <= (1e18)){
			num.push_back(tm1);
			if(tm1 > (1e18+i)/(i*i)) break;
			ll tm3 = tm1*i*i - tm2;
            if(tm3 > 1e18) break;
			tm2 = tm1;
            tm1 = tm3;
		}
	}
	sort(num.begin(), num.end());
}

int main(){
	num.push_back(1);
	init();
	ll t;
	cin >> t;
//     for(int i = 0; i <= 100; i++) cout << num[i] << endl;
	while(t--){
		ll n;
		cin >> n;
		ll ans = lower_bound(num.begin(), num.end(), n+1) - num.begin();
		cout << ans << endl;
	}
}

F. 24 dian
暴力
题目:
四个数,加上 + , - , *, /, ‘(’ , ‘)’ 使之能得到m。必须包含分数。
思路：
暴力dfs，每次找两个数四则运算，一直到全部可能用完。
代码不会… 朋友给的

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define INF 0x3f3f3f3f

const int maxn = 1e6 + 5;
const int mod = 1e9 + 7;
const double eps = 1e-8;
int a[maxn], mp[14][14][14][14];
int n, m;
int cnt = 0;
vector<int>nows(4);

void dfs(vector<double>x, bool flag) {
    if (x.size() == 1) {//计算结束得到一个值
        if (abs(x[0] - m) < eps) {//该值是m
            if (flag) {//如果出现过小数
                if (mp[nows[0]][nows[1]][nows[2]][nows[3]] == 0)cnt++;//该数未被找到过则cnt++
                mp[nows[0]][nows[1]][nows[2]][nows[3]]++;//记录该值被发现过一次
            }
            else {//没有出现过小数
                if (mp[nows[0]][nows[1]][nows[2]][nows[3]] > 0)cnt--;//如果发现过该值是小数 cnt--
                mp[nows[0]][nows[1]][nows[2]][nows[3]] = -INF;//标记该值可以没有出现过小数达到 
            }
        }
        return;
    }
    for (int i = 0;i < x.size();i++) {
        vector<double>tmp1 = x;
        double b;    double a = x[i];//a取x的第i位

        for (int j = i;j < tmp1.size() - 1;j++)//把x第i位移除得到tmp1 
            tmp1[j] = tmp1[j + 1];
        tmp1.pop_back();

        for (int j = 0;j < tmp1.size();j++) {
            vector<double>tmp = tmp1;
            b = tmp[j];//b取x的第j位
            for (int k = j;k < tmp.size() - 1;k++)//把tem1第j位移除得到tmp 
                tmp[k] = tmp[k + 1];
            tmp.pop_back();
			//把a和b的计算结果放回数组 继续进行计算 
            tmp.push_back(a + b); 
            dfs(tmp, flag);
            tmp.pop_back();

            tmp.push_back(a - b);
            dfs(tmp, flag);
            tmp.pop_back();

            tmp.push_back(b - a);
            dfs(tmp, flag);
            tmp.pop_back();

            tmp.push_back(a * b);
            dfs(tmp, flag);
            tmp.pop_back();

            if (abs(b - 0) > eps) {
                tmp.push_back(a / b);
                if (abs(round(a / b) - a / b) > eps) {
                    // cout << a << ' ' << b << endl;
                    dfs(tmp, 1);
                }
                else
                    dfs(tmp, flag);
                tmp.pop_back();
            }

            if (abs(a - 0) > eps) {//a不是0就做“除以0 ”这个操作 
                tmp.push_back(b / a);
                if (abs(round(b / a) - b / a) > eps) {//四舍五入的值和不四舍五入的值有差别则是小数 
                    // cout << b << ' ' << a << endl;
                    dfs(tmp, 1);
                }
                else//否则是整数 
                    dfs(tmp, flag);
                tmp.pop_back();
            }
        }
    }
}
signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);cout.tie(0);
    cin >> n >> m;
    if (n <= 3)
    {
        cout << 0;
        return 0;
    }
    for (int i = 1;i <= 13;i++)
        for (int j = i;j <= 13;j++)
            for (int k = j;k <= 13;k++)
                for (int l = k;l <= 13;l++) {
                    nows[0] = i, nows[1] = j, nows[2] = k, nows[3] = l;
                    vector<double> tmp(4);
                    tmp[0] = i, tmp[1] = j, tmp[2] = k, tmp[3] = l;
                    dfs(tmp, 0);
                }
    cout << cnt << endl;
    for (int i = 1;i <= 13;i++)
        for (int j = i;j <= 13;j++)
            for (int k = j;k <= 13;k++)
                for (int l = k;l <= 13;l++)
                    if (mp[i][j][k][l] > 0)
                        cout << i << ' ' << j << ' ' << k << ' ' << l << endl;
}

J. Counting Triangles
思维题。
题目大意：
用给的程序生成边的颜色， 求颜色相同的三角形。
思路：
所有的可能减去不能的，就是答案。我们对每个点统计黑色和白色，那么这些边组成的三角形一定不能成。就是hei * bai。然后由于每个点都会遍历两次，所以最后结果除2.
代码

#include<bits/stdc++.h>


namespace GenHelper
{
    unsigned z1,z2,z3,z4,b,u;
    unsigned get()
    {
        b=((z1<<6)^z1)>>13;
        z1=((z1&4294967294U)<<18)^b;
        b=((z2<<2)^z2)>>27;
        z2=((z2&4294967288U)<<2)^b;
        b=((z3<<13)^z3)>>21;
        z3=((z3&4294967280U)<<7)^b;
        b=((z4<<3)^z4)>>12;
        z4=((z4&4294967168U)<<13)^b;
        return (z1^z2^z3^z4);
    }
    bool read() {
      while (!u) u = get();
      bool res = u & 1;
      u >>= 1; return res;
    }
    void srand(int x)
    {
        z1=x;
        z2=(~x)^0x233333333U;
        z3=x^0x1234598766U;
        z4=(~x)+51;
      	u = 0;
    }
}
using namespace GenHelper;
using namespace std;
using ll = long long;
bool edge[8005][8005];
int n, seed;

void solve();


int main() {
 
  cin >> n >> seed;
  srand(seed);
  for (int i = 0; i < n; i++)
    	for (int j = i + 1; j < n; j++)
        	edge[j][i] = edge[i][j] = read();
    ll ans = 0, tmp = 0;
    for(int i = 0; i < n; i++){
        ll hei = 0, bai = 0;
        for(int j = 0; j < n; j++){
            if(j == i) continue;
            if(edge[i][j]) hei++;
            else bai++;
        }
        tmp += hei * bai;
    }
    ans = (ll)n*(n-1)*(n-2) / (3*2) - tmp/2;
    cout << ans << endl;
 	return 0;
}
李发？
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2018牛客暑期多校第二场题解
09-28
### 2018牛客暑期多校第二场题解 #### 题目一：健身计划（laofudasuan） **题目大意** 白云正在制定一个健身计划，每秒可以选择步行1米或者跑步k米（k为常数），但不能连续两秒都跑步。当白云累计行走的距离在[L,R...
2020牛客暑期多校集训营第二场题解.pdf
01-20
### 2020牛客暑期多校集训营第二场题解 #### Gromah 题目解析 在本次解析中，我们将逐一探讨各题目的关键算法思想和技术细节。 ### A. All with Pairs (全部配对) 本题讨论了如何利用哈希表来解决一对对字符串的...
2021牛客多校3
bok_choy_的博客
08-08 124
文章目录F-24dian（搜索）J-Counting Triangles（计数） F-24dian（搜索） 题意： 规则就是 242424 点的规则，但是本题牌数是 1−41-41−4 ，并且要保证在一组牌得到 242424 点的所有可能解中，都包含不能整除的分数。 最后求合法解数。 思路： 牌数 ≤3\leq3≤3 时，是无解的（肯定存在 不包含的分数 的解）虽然不明白，但是我再次大受震撼 直接搜索，dfs(集合a,数字b)dfs(\text{集合}a,\text{数字}b)dfs(集合a,数字b) 表示
【多校训练】2021牛客多校3
MEET YOU FIRST TIME
07-28 441
【前言】 比赛的时候I想了一个俩log的方法，结果最后过不了，遂放弃。后来发现其实维护的东西没有那么多… 这场题目有点阴间，感觉剩下的题除了I都不太可做，题解都两三页。 rk47，校3/9，日常被踩 A. Guess and lies 【题意】 Alice想一个nnn以内的数Bob来猜，每次Bob可以询问是否大于等于某个数，Alice会回答yes或no，但是Alice在一轮里面可以说一次谎。Alice希望猜的次数尽可能多，Bob希望猜的次数尽可能少。同时，Alice第一次一定会回答yes。 现在对于x∈[1
2021牛客多校3（BCFJ）
weixin_51987650的博客
07-04 287
题意：地图规模为5000*5000级别，点权wi​(0≤wi​
2021牛客多校训练营3
weixin_46554592的博客
07-29 91
B Black and white 这题直接将行列转换成点，而把点看成两个行列点的边，这样就转换成了当行列点在一个连通块的时候，再来个已经是连通块的点的时候，就不需要加上他的权值了，所以一共有n + m 个点，最后又要使得所有点是连通的，也就是如果再加一条边一定可以形成环，而这条环是我们不需要加的，所以直接就转换成了最小生成树，n + m - 1条边，prim直接求。 #include<bits/stdc++.h> using namespace std; typedef long lon
2020牛客暑期多校第一场讲课笔记版本题解1
08-03
3. 有向图的生成树计数(Domino Flip Graphs): 提到了Domino翻转图中的距离计算，可以通过"Lagrange Duality"证明，答案是b的转置乘以矩阵A的逆再乘以b。这在图论和网络流问题中常见。 4. 二次型(Quadratic Form): ...
2021牛客暑期多校（三）
qq_44873216的博客
07-27 321
2021牛客暑期多校（三）
2021暑期牛客多校训练3
code___farmer的博客
08-16 128
J-Counting Triangles 思维题，正难则反 思路： 看到此题的第一反应通常是搜索，但会超时，优化的话也会超时。 题目要求三边颜色相同的三角形，那么可以将所有的三角形的个数减去三边颜色不完全相同的三角形的个数即可得到答案。 所有的三角形的个数：Cn3=n∗(n−1)∗(n−1)/6C_n^3=n*(n-1)*(n-1)/6Cn3​=n∗(n−1)∗(n−1)/6 三边颜色不完全相同的三角形的个数：将每个点相连的黑边的个数和白边的个数相乘再相加，最后除以2（每个三角形会被重复数一次）。 #in
#2021牛客暑假多校3_J.Counting Triangles_正难则反
欧阳小百合
07-25 171
J.Counting Triangles 题目传送门： J 题面： 一句话： 给一个 n(n<=8000) 个顶点的图，每两个顶点边颜色为黑或白，求三个顶点组成的三角形边颜色相同的个数。 正难则反！！！！！！！！ 不要直接求个数，用总数减去不符合条件的个数。 代码： #include <bits/stdc++.h> using namespace std; typedef long long ll; namespace GenHelper { unsigned z1, z2,
#2021牛客暑假多校3_E.Math_数论打表
欧阳小百合
07-25 375
E.Math 题面： 题目大意： 给定nnn的情况下，问你在1≤x≤y≤n1≤x≤y≤n1≤x≤y≤n的范围内，能找到多少组数对(x,y)(x,y)(x,y)，使得x2+y2x^2+y^2x2+y2除以x∗y+1x*y+1x∗y+1是一个整数。 输出数量。 题目思路： 先打个表找规律。 #include <bits/stdc++.h> using namespace std; typedef long long ll; int main() { int i=10000; l
2021牛客多校第三场题解
玉的博客
08-17 196
B题 题目大意：n * m的方格，每个方格的值表示把这个方格涂黑的代价，2 * 2的方格内如果有三个已经涂黑，那么第四个自动涂黑，即代价为0.问将所有方格涂黑的最小代价。n,m<5000 思路：可以发现，只需要涂n+m+1个方格就可以将整个图涂黑。将w[i,j]看作i和j两个点之间的边权，转化为最小生成树问题，在n*m条边中选出n+m条边构成最小生成树。因为是稠密图所以选择prim算法。注意如果行编号从1 ~ n,则列编号从n+1 ~ n + m，避免边的表示重复。 ac代码： #include
2021牛客多校赛第三场
weixin_44588874的博客
08-09 208
传送门 A B水题 C二分图根据坐标x,y建图 D E水题 F恶心人的模拟 G H I J摆烂同色三角形模型 C（计算几何） 题意：给定一个n×n的矩形，有m个指定的空位需要放置非负整数，给定所有数字的最大值k，再给出每一行的最大值bi（是指你需要将这一行最大的那个数保证为bi），每一列的最大值ci，求矩阵中所放置数字和的最小值 前要：先讲一个比这简单的问题，给你n*m的棋盘，给定某些行某些列，你需要保证这些行列上存在至少一个棋子，同时你只能在指定的k个位置安放棋子。保证有解的情况下问你最少需要多少个棋子
2021牛客暑期多校训练营 3 题解
满天星的博客
07-24 453
2021牛客暑期多校训练营 3 E Math J Counting Triangles
2021牛客多校第三场E
Gone_Summer的博客
09-27 150
参考文章：关于lower_bound( )和upper_bound( )的常见用法_brandong-CSDN博客_lower_bound
2021牛客暑期多校训练营3补题
TIT_0的博客
08-11 145
2021牛客暑期多校训练营3：B题（Black and white） 题目原文 Goodeat has a white chessboard with n rows and m columns. Each grid (i, j) has a weight c(i, j). At any time, the grid (i, j) can be dyed black at the cost of c(i, j). Goodeat has a special talent. For the four inte
牛客暑期多校第二场题解：动态规划与环形DP应用
本资源是2018年牛客暑期多校第二场的ACM题解文档，主要涉及三个编程问题的解题思路和方法。 第一个问题是关于动态规划（Dynamic Programming，简称DP）的应用。题目名为"laofudasuan"，背景是白云健身的模拟。问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值