2022.8.7训练总结

最新推荐文章于 2024-07-08 22:12:26 发布
最新推荐文章于 2024-07-08 22:12:26 发布
阅读量148 收藏
点赞数 1
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cwy_zhuchenze/article/details/126254951
版权

T1.「JOI 2015 Final」JOI 公园

题意分析

题意描述：选择一个自然数xx, 将和第一个广场的距离小于等于xx 的所有广场相互之间连接地下通道

所以，对于给出的每一条边，当max(dis[u], dis[v]) > xmax(dis[u],dis[v])>x时，这条边将额外对答案作出贡献

否则的话，该边所连接的广场均被记入地下通道计划中

所以，对于每个枚举出的xx,它所对应的修缮花费总和为 \sum_1^m∑1m​ didi(max(dis[u], dis[v]) > xmax(dis[u],dis[v])>x) + x * cx∗c

具体实现

1.dijkstradijkstra算法，计算每个广场到一号广场的最短路

2.记录下e[i].sh = max(dis[e[i].u], dis[e[i].v])e[i].sh=max(dis[e[i].u],dis[e[i].v])

3.对ee数组以shsh的大小，由小到大排序

4.暴力枚举每一个分割点，更新最小花费

代码实现

ans = sum;
// sum,最开始记录所有边权的总和
for (int i = 1; i <= m; i ++) {
	e[i].sh = max(dis[e[i].u], dis[e[i].v]);
}
sort(e + 1, e + m + 1, cmp);
for (int i = 1; i <= m; i ++) {
	sum -= e[i].w;
   // 以第i个边的sh为分割(x)，之前的所有边(sh)显然小于等于x
   // 所以这些边的边权全部减去
   // 剩余的sum(边权和)恰好是可以为答案做出贡献的值的总和(即不被纳入地下交通计划)
	ans = min(ans, sum + (long long) e[i].sh *c );
}
printf("%lld\n", ans);

最后提醒：数据范围开long long

T2.「JOI 2017 Final」足球

题意分析

题目难点：如何建图

分析：因为有控球和不控球的状态差别，或者说是有球滚动和人移动的不同代价 所以我们需要拆点(建分层图)

分层

首先，因为人的移动本质上是一样的，所以我们不妨将人带着球的移动当成一层来看

接着，球滚动的过程也需考虑(因为踢球的代价不同）将球的滚动分为两层：横着滚动和竖着滚动(方向不同)

如何从滚动过程跳跃到运球过程

因为状态第一层的定义是人运球的过程，所以从移动过程的当前点(x, y)(x,y)转移至运球过程的当前点(x, y)(x,y)一定需要一名球员来接球

接球的球员一定是距离(x, y)(x,y)最近的那名球员

所以，关于接球球员的选择，我们需要在预处理时求得

另外

坐标是从0开始的，一张图实际共有(n + 1)* (m + 1)(n+1)∗(m+1)个点

以下是具体实现

关于代价

p[sp - 2]p[sp−2], 人的移动

p[sp - 3]p[sp−3],踢球时

p[sp - 4]p[sp−4],球的滚动

变成未被控球看作p[sp - 3]p[sp−3]的代价

滚动一米花费p[sp - 4]p[sp−4]的代价

人在移动，运球时花费p[sp - 2]p[sp−2]的代价

关于拆点

每个点我们拆出 33 个点表示控球(00)、未被控球左右滚动(11)、未被控球上下滚动(22)

关于连边

具体有以下几类边可以相连

(i, j, 0)(i,j,0)向四周的 00 连边权为 CC 的边，表示控球跑 11 米

(i, j, 1)(i,j,1)向左右的 11 连边权为 AA 的边，表示球向左右滚动 11 米

(i, j, 2)(i,j,2)向上下的 22 连边权为 AA 的边，表示球向上下滚动 11 米

(i, j, 0)(i,j,0)向(i, j, 1)(i,j,1)和(i, j, 2)(i,j,2)连边权为 BB 的边，表示把球踢出去

(i, j, 1)(i,j,1)向(i, j, 2)(i,j,2)和(i, j, 0)(i,j,0)连边权为 dis_ij * Cdisi​j∗C 的边，表示最近的球员跑过来控球

我的代码备注

可以看到, id(x, y)id(x,y)是在压缩每一个点的标识，将这张二维图压缩成一维，便于之后的dijkstradijkstra操作

另外,在建边与连边时，参考学习并查集时的扩展域思想

有id(x, y) + (n + 1) * (m + 1)id(x,y)+(n+1)∗(m+1) 和 id(x, y) + 2 * (n + 1) * (m + 1)id(x,y)+2∗(n+1)∗(m+1)的操作

代码实现

以下是完整代码

#include <cstdio>
#include <queue>
#include <map>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
#define sc ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
#define pus make_pair
#define pa pair<long long, int>
const int N = 1e5 + 5, M = 505, INF = 0x3f3f3f3f, sp = 5, S = M * M * 30;
const int dx[sp] = { 0, 0, 1, -1 };
const int dy[sp] = { 1, -1, 0, 0 };

int m, n, s, cnt;
long long p[sp];
int head[S / 10], ver[S], nextw[S];
bool v[M][M], vis[S / 10];
long long dis[S / 10], dist[M][M], edgew[S];

struct node {
    int x, y;
};
node st[N];

struct edge {
    long long val;
    int id;
    edge(long long x, int y) {
        val = x;
        id = y;
    }
};

priority_queue<edge> q;

bool operator<(edge x, edge y) { return x.val > y.val; }

inline int id(int x, int y) {
	return x * (m + 1) + y;
}

void add_edge(int x, int y, long long z) {
	ver[++cnt] = y;
	edgew[cnt] = (long long) z;
	nextw[cnt] = head[x];
	head[x] = cnt;
}

void bfs() {
    queue<pa> q;
    for (int i = 1; i <= s; i++) {
        q.push(pus(st[i].x, st[i].y));
        dist[st[i].x][st[i].y] = 0;
    }
    while (q.size()) {
        int x = q.front().first, y = q.front().second;
        q.pop();
        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i], ny = y + dy[i];
            if (nx < 0 || ny < 0 || nx > n || ny > m || v[nx][ny] || dist[nx][ny]) {
                continue;
            }
            dist[nx][ny] = dist[x][y] + 1;
            q.push(pus(nx, ny));
        }
    }
}

void dijkstra(int s) {
	memset(dis, 0x3f, sizeof dis);
    dis[s] = 0;
    q.push(edge(0, s));
    while (!q.empty()) {
        int x = q.top().id;
        q.pop();
        if (vis[x])
            continue;
        vis[x] = 1;
        for (int i = head[x]; i; i = nextw[i]) {
            int y = ver[i];
            long long z = edgew[i];
            if (dis[y] > dis[x] + z) {
                dis[y] = dis[x] + z;
                q.push(edge(dis[y], y));
            }
        }
    }
}

int main() {
    sc;
    cin >> n >> m;
    for (int i = 1; i < 4; i++) {
        cin >> p[i];
    }
    cin >> s;
    for (int i = 1; i <= s; i++) {
        cin >> st[i].x >> st[i].y;
        v[st[i].x][st[i].y] = true;
    }
    bfs();
    for (int x = 0; x <= n; x++) {
    	for (int y = 0; y <= m; y++) {
    		for (int i = 0; i < 4; i++) {
    			int nx = x + dx[i], ny = y + dy[i];
            	if (nx < 0 || ny < 0 || nx > n || ny > m) {
                	continue;
            	}
            	// 向四周的 0 连边权为 C 的边，表示控球跑 1 米
            	add_edge(id(x, y), id(nx, ny), p[sp - 2]);
			}
			// 向(i,j,1)和(i,j,2)连边权为 B 的边，表示把球踢出去
			add_edge(id(x, y), id(x, y) + (n + 1) * (m + 1), p[sp - 3]);
			add_edge(id(x, y), id(x, y) + 2 * (n + 1) * (m + 1), p[sp - 3]);
		} 
	}
	for (int x = 0; x <= n; x++) {
    	for (int y = 0; y <= m; y++) {
    		for (int i = 0; i < 2; i++) {
    			int nx = x + dx[i], ny = y + dy[i];
            	if (nx < 0 || ny < 0 || nx > n || ny > m) {
                	continue;
            	}
            	// 向左右的 1 连边权为 A 的边，表示球向左右滚动 1 米
            	add_edge(id(x, y) + (n + 1) * (m + 1), id(nx, ny) + (n + 1) * (m + 1), p[sp - 4]);
			}
			// 向(i,j,2)和(i,j,0)连边权为 dis_ij * C的边，表示最近的球员跑过来控球
			add_edge(id(x, y) + (n + 1) * (m + 1), id(x, y), dist[x][y] * p[sp - 2]);
		} 
	}
	for (int x = 0; x <= n; x++) {
    	for (int y = 0; y <= m; y++) {
    		for (int i = 2; i < 4; i++) {
    			int nx = x + dx[i], ny = y + dy[i];
            	if (nx < 0 || ny < 0 || nx > n || ny > m) {
                	continue;
            	}
            	// 向上下的 2 连边权为 A 的边，表示球向上下滚动 1 米
            	add_edge(id(x, y) + 2 * (n + 1) * (m + 1), id(nx, ny) + 2 * (n + 1) * (m + 1), p[sp - 4]);
			}
			// 向(i,j,2)和(i,j,0)连边权为 dis_ij * C的边，表示最近的球员跑过来控球
			add_edge(id(x, y) + 2 * (n + 1) * (m + 1), id(x, y), dist[x][y] * p[sp - 2]);
		} 
	}
	dijkstra(id(st[1].x, st[1].y));
	printf("%lld", dis[id(st[s].x, st[s].y)]);

    return 0;
}

草稿——

T3.「JOI 2013 Final」 现代豪宅

题意分析

具体实现

代码实现

#include <cstdio>
#include <queue>
#include <vector>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
#define sc ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
#define int long long
const int N = 3000005, M = 40000005, INF = 0x7f7f7f7f7f7f, sp = 5;

int m, n, s, cnt, sum, x, y, p;
int head[N], ver[M], nextw[M], edgew[M];
int dis[N];
bool vis[N];

struct node {
	int x, y;
};
vector<node> h[N], w[N];

bool cmp(node x, node y) {
	return x.x < y.x;
}

struct edge {
	int val, id;
	edge(int x, int y) {
		val = x;
		id = y;
	}
};

priority_queue<edge> q;

bool operator <(edge x, edge y) {
	return x.val > y.val;
}

void add(int x, int y, int z) {
	ver[++sum] = y;
	edgew[sum] = z;
	nextw[sum] = head[x];
	head[x] = sum;
}

void dijkstra() {
	for (int i = 0; i <= p; i ++) {
		dis[i] = INF;
	}
	dis[0] = 0;
	q.push(edge(0, 0));
	while (q.size()) {
		edge u = q.top();
		q.pop();
      // 因为在处理dijkstra时,我们是先更改值，再将对应的标识压入队列
      // 所以，当u.val > dis[u.id]时，代表u.id已被访问过，确定最短路
		if (u.val > dis[u.id]) {
			continue;
		}
		for (int i = head[u.id]; i; i = nextw[i]) {
			int y = ver[i];
			long long z = edgew[i];
			if (dis[y] > dis[u.id] + z) {
				dis[y] = dis[u.id] + z;
				q.push(edge(dis[y], y));
			}
		}
	}
}

signed main()  {
	sc;
	cin >> m >> n >> s;
	p = s << 1 | 1;
	for (int i = 1; i <= s; i ++) {
		cin >> x >> y;
		++ cnt;
		w[x].push_back((node) {y, cnt});
		h[y].push_back((node) {x, cnt + s});
	}
	for (int i = 1; i <= n; i ++) {
		sort(h[i].begin(), h[i].end(), cmp);
		int len = h[i].size();
		for (int j = 1; j < len; j ++) {
			add(h[i][j - 1].y, h[i][j].y, h[i][j].x - h[i][j - 1].x);
			add(h[i][j].y, h[i][j - 1].y, h[i][j].x - h[i][j - 1].x);
		}
	}
	if(h[n].size()) {
		int len = h[n].size() - 1;
		add(p, h[n][len].y, m - h[n][len].x);
		add(h[n][len].y, p, m - h[n][len].x);
	}
	for (int i = 1; i <= m; i ++) {
		sort(w[i].begin(), w[i].end(), cmp);
		int len = w[i].size();
		for (int j = 1; j < len; j ++) {
			add(w[i][j - 1].y, w[i][j].y, w[i][j].x - w[i][j - 1].x);
			add(w[i][j].y, w[i][j - 1].y, w[i][j].x - w[i][j - 1].x);
		}
	}
	if(w[m].size()) {
		int len = w[m].size() - 1;
		add(p, w[m][len].y, n - w[m][len].x);
		add(w[m][len].y, p, n - w[m][len].x);
	}
	if(w[1].size()) {
		add(0, w[1][0].y, w[1][0].x - 1);
		add(w[1][0].y, 0, w[1][0].x - 1);
	}
	for (int i = 1; i <= s; i ++) {
		add(i, i + s, 1);
		add(i + s, i, 1);
	}
	dijkstra();
	if (dis[p] > INF - 1) {
		puts("-1");
		return 0;
	}
	printf("%lld", dis[p]);
	
	
	return 0;
}

T4.「JOISC 2014 Day1」有趣的家庭菜园

题意分析

具体实现

#include <cstdio>
#include <queue>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
#define sc ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
const int N = 3e5 + 5, INF = 0x3f3f3f3f, sp = 5;

int n;
long long ans;
int s[N], d[N], BIT[N][2];

int lowbit(int x) { return x & -x; }

void updata(int x, int k, int fl) {
    for (int i = x; i <= n; i += lowbit(i)) {
        BIT[i][fl] += k;
    }
}

int sum(int x, int fl) {
    int nsum = 0;
    for (int i = x; i > 0; i -= lowbit(i)) {
        nsum += BIT[i][fl];
    }
    return nsum;
}

void sf() {
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &s[i]);
        d[i] = s[i];
    }
}

void discrete() {
    sort(s + 1, s + n + 1);
    int cnt = unique(s + 1, s + n + 1) - s - 1;
    for (int i = 1; i <= n; i++) {
        d[i] = lower_bound(s + 1, s + cnt + 1, d[i]) - s;
        updata(d[i], 1, 1);
    }
}

int main() {
    sf();
    discrete();
    for (int i = 1; i <= n; i++) {
        int u, v;
        updata(d[i], -1, 1);
        u = n - i - sum(d[i], 1);
        updata(d[i], 1, 0);
        v = i - sum(d[i], 0);
        ans += min(u, v);
    }
    printf("%lld", ans);

    return 0;
}
cwy_zhuchenze
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
「JOI 2015 Final」JOI 公园
青烟绕指柔的博客
06-02 417
题目链接：「JOI 2015 Final」JOI 公园 显然我们枚举的X只可能是最短路上面的值。 然后我们知道小于X的点的个数，然后我们再找到有多少边是要翻修的，所以我们可以发现要翻修的边其实就是 max(d[u],d[v])>x的边。 然后我们枚举每个d即可。 之后可以二分找到对应的翻修的边，或者直接利用单调性做。 AC代码： #pragma GCC optimize("-Ofast","-funroll-all-loops") #include<bits/stdc++.h> #de
吴恩达ChatGPT课程总结.zip
05-11
ChatGPT是OpenAI推出的一款基于大型语言模型的对话式应用，它在2022年底引起了广泛热议。在这个"吴恩达ChatGPT课程总结"中，我们可以期待深入探讨ChatGPT的工作原理、应用以及它在人工智能领域的影响力。 ChatGPT是...
【Yolov5】1.认真总结6000字Yolov5保姆级教程（2022.06.28全新版本v6.1）
热门推荐
若丶尘的博客
08-03 36万+
爆肝6000字Yolov5保姆级教程，80岁老奶奶都看得懂。文章特点：一个完整的流程，从头教到尾，不讲冗长的理论，实操
2022.10.8 YOLOv7训练自定义数据集
weixin_52706724的博客
10-09 538
YOLOv7训练自定义数据集
2022.3 C++植物大战僵尸项目总结
amzirl的博客
03-15 1万+
对于植物大战僵尸这个项目的全面复盘与详尽思考
2022.10.16 学习周报
peaunt1的博客
10-16 4512
CNN
2022年机械学习总结8篇.docx
01-12
"机械学习总结" 本文档是关于机械学习的总结，分为八个部分，每个部分都从不同的角度讲述了机械学习的经验和收获。以下是每个部分的知识点总结： 机械学习总结（一）： * 机械设计需要个人不断积累不断思考，不能...
2022年大学计算机实习总结例文.docx
07-13
7. 计算机基础知识：在大学计算机课程中，通常会涵盖如操作系统使用（例如Windows XP）、文字处理（Word20xx）、电子表格（Excel20xx）、演示文稿制作（PowerPoint20xx）、网络应用、网页制作（FrontPage20xx）以及...
2022会计毕业生实习总结20225篇.doc
11-24
这篇文档是一份关于2022年会计毕业生实习的总结，涵盖了实习生在某信息技术公司的财务部进行会计岗位实习的经历和感悟。以下是基于文档内容提炼出的相关知识点： 1. 实习的意义：实习有助于大学生形成正确的就业...
opencv4.7.0 .cache及编译文件
05-17
OpenCV 4.7.0版本带来了许多新特性和性能优化，包括更快的图像处理算法、更多的预训练模型以及对新硬件的支持。 2. **Windows Server 2019**： 这是微软推出的一款服务器操作系统，用于企业级应用部署和托管。它...
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
最新发布
qq_43671872的博客
07-08 587
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
算法力扣刷题 三十一【150. 逆波兰表达式求值】
danaaaa的博客
07-04 659
后缀表示法。
[Leetcode 136][Easy]-只出现一次的数字
2201_75413354的博客
07-03 221
②后面研究，发现对于对于查找数组中唯一一个出现一次的元素，我们更适合使用线性扫描和位操作的方法。异或运算满足交换律，且一个数异或自己结果是0，一个数异或0结果是自己。因此把数组中所有元素进行异或运算，得到结果是唯一数。①首先看到数组中重复的数字，想到快慢指针，但是数组的元素是乱序的不好求。使用了STL库的sort函数，时间复杂度O(nlogn)不符合题目要求，空间复杂度O(1)。
算法012：将x减到0的最小操作数
m0_62319039的博客
07-07 414
算法012：将x减到0的最小操作数
【力扣】数组中的第K个最大元素
m0_61876562的博客
07-05 247
l, left]（该部分小于基准元素key）、[left + 1, right - 1]（等于基准元素key）、[right, r]（大于基准元素key）。3、计算每部分所包含的元素个数，分别为a 、b = right - left - 1、 c = r - right + 1;请注意，你需要找的是数组排序后的第。你必须设计并实现时间复杂度为。个最大的元素，而不是第。1、随机选择基准元素。
秋招力扣刷题——从前序与中序遍历序列构造二叉树
qq_50604294的博客
07-04 203
给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。：两种代码的结束条件以及分割的右区间处理方式不同，后者更容易理解一点。
算法力扣刷题 二十九【20. 有效的括号】
danaaaa的博客
07-04 465
栈解决对称匹配问题
整数反转-int
谜底的博客
07-05 220
主要这道题给定的int而不是string，不是双指针解法，就是数学计算法。给定一个整数，求出反转后的数。
Python基于卷积神经网络分类模型(CNN分类算法)实现时装类别识别项目实战
胖哥真不错的博客
07-03 1033
Python基于卷积神经网络分类模型(CNN分类算法)实现时装类别识别项目实战
kali2022.2和kali2022.1差别
10-10
kali2022.2和kali2022.1是Kali Linux操作系统的两个不同版本。它们之间的主要差别包括以下几点： 1. 更新软件包：kali2022.2相对于kali2022.1来说，会有更多的软件包更新。这些更新可能包括新版本的软件、安全修补和功能改进。 2. 内核版本：kali2022.2可能会采用更新的Linux内核版本，以提供更好的硬件兼容性和性能优化。 3. 默认工具：新版本的Kali Linux通常会随着时间的推移添加新的默认工具或更新现有工具的版本。这些工具可能涉及网络安全、渗透测试、数字取证等方面。 4. 用户界面：尽管Kali Linux的用户界面（如GNOME桌面环境）可能没有太大变化，但新版本通常会修复一些已知问题，并提供更好的用户体验。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值