2024-2-26~7-7 记录

2-26 ~ 3-3（5题）

寒假又 tm 荒废了，今年应该是我在 OI 道路上的最后一年了，可能确切地说是六个月，不多说什么了，时间不多了，做什么事都要高效起来。

开学第一个星期，有点不适应，shabby一中搞半月假，周考也炸了。摸了几题前缀和的题目做，算是练练手，感觉差不多找回来了。

现在大致的计划是先把基础算法再过一遍，但要加大难度，跟着蓝书和提高课就差不多了。（今晚回寝再想想）

现在能腾出来的时间午休 12:50 ~ 13:40，晚自习21:30 ~ 22:30，大概 2h，尽量保持一天一题的效率。

明天接着前缀和、差分。

3-4（1题）

找了一篇洛谷日爆日报上的文章，学了个二次差分，挺容易想的，我甚至直接看例题就有这个思路了，不过这题数据毒瘤，用树状数组维护会 T，还是老老实实用数组维护前缀和 O(n) 过。

我发现对这个用树状数组维护的功能还是没学好，现在我以为只能用来维护前缀和？常数又比数组大？

4-28

最近出现了一些事，在我生命中算是很重要吧，所以对程序不怎么上心了，今天开始应该差不多可以回归正轨了吧。

树状数组搞完之后，本来是搞贪心的，但是中途做了个二分图的题（本质的增广路也就是贪心思想），然后就开了二分图的坑，最近两个/半月（指在校周期）都在搞这个。

后面感觉还是先不学贪心了......好迷茫

二分图还有一整个题单的题可以刷，感觉学得差不多了。

今年又转眼快过半了，好像还是止步不前。

Ⅰ 5月份上旬，前一个星期搞完二分图，接着复习一下 lca，tarjan，最短路，差分约束，拓扑排序，学一下分治（网络流有点犹豫要不要开，看上去是个无底洞的样子...）

Ⅱ 下旬搞数据结构，先复习单调队列、二叉堆、树状数组。

Ⅲ 可能到月末才能结束，然后重点搞线段树，搞到六月半，顺便把二分、前缀和什么的基础技巧在结合中巩固。

Ⅳ 然后就是期末了，接着就是暑假，暑假最重点，接近两个月只搞动态规划

先计划这么多吧。关键词就是：图论、数据结构、动态规划

唉，这个五一假怎么天天下雨，不过听着窗外的雨声，挺舒服的。发呆好吗？发呆挺好的......发呆不好，我为什么认为发呆挺好的？不要发呆。

还有，不弹吉他，以后再玩。

5-6（2.5题 qwq）

wc，我居然也是一个中午能写两道蓝题的oier了，心情肥肠不戳。

做了一道基本的有约束条件的最大匹配 [HNOI2006] 超级英雄，一遍过练练手。

然后又开了试题库问题，一开始以为题目所给的条件很明确地作为了最大匹配的约束条件，后来发现是不可做的。

再想想发现可以转化成拆点 + 最大匹配，而且非常好做。

主要是输出答案有点恶心，拆点成 i, i + k, i + 2k ... i + k_cnt * k，我最后输出每一种点时搞了半天，下界没想清楚，我直接就用 ∑ k_cnt，不够，换 (Σ k_cnt)^2，大了，直到猜到 (∑ k_cnt) * 3，居然过了哈哈哈

言归正传，每种点的下界是不同的，应该是 i + k_cnt * k

我去，22:26 极限又做了一道 gcd + 最大匹配 [TJOI2011] 卡片，也是拿下 70pts，T 了三个点， $O (T n^{2} \log 10^{7})$ 确实可能还可以优化，明天再说

5-7（2题）

一道 P7368 [USACO05NOV] Asteroids G 最大独立集，

一道 P6268 [SHOI2002] 舞会最大匹配，不过重点是建图，它给的不是一个直接能跑的图，要用染色法先建一个二分图。

晚上看了一下昨天那题的题解，要用质因数分解建图。

确实， $O (n^{2} \log 10^{7})$ 暴力枚举建图会有很多无效的判断，而 $O (n \sqrt{10^{7}})$ 预处理出左右部每个数的质因数，对应相连，也满足 gcd(a,b) > 1 的条件。

发现基于唯一分解定理的质因数分解是一种很优秀的拆法，可以省去很多无效的判断。

md 但是我打了百多行代码，各种 TLE，RE，MLE，自己的实现能力还是很差...

5-8（1题）

做了一道有意思的题 P2526 [SHOI2001] 小狗散步，发现二分图算法的题目越难就越难在二分图建模上，也就是建图。

最关键的就是 dog 每次与主人相遇之间只能走 0 或 1 个景点，那么景点这个点集之间就没边相连。

考虑与主人的固定路径连边，以主人的路径为左部（点代线），景点为右部。

连边条件就是 i -> x -> i+1 <= 2 * (i -> i+1) ，然后要求最大景点数，也就是求最大匹配。

主人的路径肯定是 dog 的路径方案的子集，而景点就可以在连最大匹配时记录即可。

女少口阿！

5-9（3题）
5-10（3题）

遇到两道带点权的最大独立集的问题，还没学不会做eee，mark
P2774 方格取数问题、P4474 王者之剑

学了一下最小路径点覆盖。

但是 P2764 最小路径覆盖问题在做这道板子时，对于输出路径方案是有些复杂的。

一开始我想的很简单，已知右部对应左部的 match[]，可以转化得到反过来的 rev_m[]，

根据拆点二分图左部为出点，右部为入点的性质，很容易发现可以用递推在左右部反复横跳得到路径，

再每次标记访问过的点，遍历一遍左部的点就完了。

但是这样显然没有考虑最小路径数，即总是先考虑较长的路径。

想到无入度肯定比有入度的点期望得到的路径更长，所以我就先让无入度的点优先，即先递推右部无入度的点，感觉也是一种贪心的思想。

虽然 A 了，但是感觉这种局部的想法很假...

5-11（1题）

计划写题解的二分图好题：（也可能不写，感觉还不是很值得写，目前为止很多题都比较套路，没有什么启发性）
P2065 [TJOI2011] 卡片

P2526 [SHOI2001] 小狗散步

P1407 [国家集训队] 稳定婚姻

P2765 魔术球问题

P3231 [HNOI2013] 消毒（关于此题的trick）

P2423 [HEOI2012] 朋友圈

P2774 方格取数问题

P4055 [JSOI2009] 游戏

5-12（3题）

主要是晚上打了个比赛 arc177 ，赛时只做出前两题，都花了差不多半小时，都是简单的模拟，

不过体验很好，at 的题图都画得这么好吗？

5-13（0题）

写了一下总结，今天效率很低，

新的一周开始了，但是二分图还有十几道题没啃掉，而且都还较有思维性，感觉复习要往后拖了。

5-14（1题）

写了一篇魔术球问题的题解。

5-15（0题）

不知道为什么，感觉好困啊，看题目都会睡着去，我想二分图到今天就先告一段落了。（题目以后留着总复习写？神tm总复习）

最短路开搞。

5-16（1题）

做了一道简单的最短路 P5767 [NOI1997] 最优乘车

一开始肯定是往点权化边权的角度建图，将各个路线分开讨论，很容易发现可以建分层图，在不同层次（即路线）的换乘站之间连边权为 1 的双向边，然后跑一遍 dijkstra 就可以了。

但我后来发现我只能 $O (n^{2} m^{2})$ 暴力建图，这种图好像不能用分层图做，我对分层图思想还是没有学明白。

其实刚刚那个思路有点缩路径为点的味道，也就是我们并不关心在同一路线内的移动，

然后我就想把这个权值 1 附到整条线路上，坐过几条线路，那换乘数显然就是所坐线路数 -1

那么就可以 $O (m n^{2})$ 建每条线路内的所有点单向的最多可达边，

如 a -> b -> c -> d，就有很多路径可以只做一次路线即可到达（即边权为 1）：

a -> b，a -> c，a -> d

b -> c，b -> d

c -> d

5-19

周末三天三场比赛，全打成shi了，***

Codeforces Round 945 (Div. 2)

Panasonic Programming Contest 2024（AtCoder Beginner Contest 354）

AtCoder Regular Contest 178

5-20（2题）

做了两道分层图的题目，不过我现在只学会了暴力建图表示决策状态转移，类dp思想的方法还是很难懂。

劳动一体化好累啊，这检查的人也真的是太棒了，早上硬是拖了我们整整三节课不放过。

我去，感觉 5 月份快过去了，我最短路还没复习多少，这搞得赢啊...（恼

5-21（3题）
5-22（0题）
5-23（1题）

P3008 [USACO11JAN] Roads and Planes G 一道锻炼码力的好题

思路很直观，预处理连通快，然后跑 dij + 拓扑排序，现在才发现 DAG 上求单源最短路可以一遍拓扑排序 $O (n + m)$ 扫描出来

5-27（1题）

P1347 排序一道经典的传递闭包运用

考虑构造 $d_{i, j} = 1$ 表示 i < j，在线做传递闭包

若矛盾，即 i < j 和 j < i 同时成立，可以判断 $d_{i, j} = d_{j, i} = 1$ ，同时注意到，若在这种矛盾条件下，传递闭包可以得到 $d_{i, i} = 1$
若当前无法确定所有关系，即存在 $d_{i, j} = d_{j, i} = 0$

剩下就是唯一确定所有关系了。

在做这道题目的方案输出时，每次输出最小答案，之前我都是打擂台，是一种 对于所有的思想

但这里我学到了用 存在的思想，即考察当前 i, 若存在 $d_{j, i} = 1$ ，即 j < i，则 i 不可能为当前全局最小值，否则就是最小值。

code

 #include <bits/stdc++.h>
#define re register int 
using namespace std;
const int N = 50;
 
int n, m, d[N][N];
bool vis[N];
 
inline void floyd()
{
	for (re k = 0; k < n; k ++)
		for (re i = 0; i < n; i ++)
			for (re j = 0; j < n; j ++)
				d[i][j] = (d[i][j] | d[i][k] & d[k][j]);
}
 
inline int check()
{
	for (re i = 0; i < n; i ++) 
		if (d[i][i]) return 1;
		
	for (re i = 0; i < n; i ++)
		for (re j = 0; j < n; j ++)
		{
			if(i == j) continue;
			if (!d[i][j] && !d[j][i]) return 0;
		}
	
	return 2;
}
 
inline char get_min()
{
	bool flag = true;
	for (re i = 0; i < n; i ++)
		if (!vis[i])
		{
			flag = true;
			for (re j = 0; j < n; j ++)
				if (!vis[j] && d[j][i])
				{
					flag = false;
					break;
				}
			
			if (flag)
			{
				vis[i] = true;
				return i + 'A';
			}
		}
}
 
inline void print(int type, int p)
{
	if (type == 1)
		printf("Inconsistency found after %d relations", p);
	if (type == 0)
		printf("Sorted sequence cannot be determined");
	if (type == 2)
	{
		memset(vis, false, sizeof(vis));
		
		printf("Sorted sequence determined after %d relations: ", p);
		for (re i = 0; i < n; i ++)
			printf("%c", get_min());		
	}
	printf(".\n");	
}
 
int main()
{
	while (1)
	{
		cin >> n >> m; 
		if (!n && !m) break;
		
		memset(d, 0, sizeof(d));
		int type = 0, p;
		for (re i = 1; i <= m; i ++)
		{
			string s; cin >> s;
			int a = s[0] - 'A', b = s[2] - 'A';
			
			if (!type)
			{
				d[a][b] = 1;
				floyd();
				type = check();
				if (type) p = i;
			}
		}
		print(type, p);
	}
	
	return 0;
}

我越来发现，这悠长的代码就像诗一样，像一件艺术品，太美了 qwq

5-28（1题）

344. 观光之旅一道求无向图最小环的问题，又是一个 floyd 的经典运用

主要是时刻要记住 floyd 的本质，

$d_{k, i, j}$ 表示经过 若干个编号不超过 k 的节点，从 i 到 j 的最短路径长度

求无向图的最小环就是运用了这个性质，（同时也利用到了 无向图的对称性）

有 (i, j) 两点的最短距离，且路径上的点编号保证在 1 ~ k - 1，引入 k 号点求最小环，也就是在 floyd 的第一层循环中求最小环。

5-29（1题）

做了一道很板的点权化边权 P3393 逃离僵尸岛

最后死活 28pts 调不出来，一会发现 bfs 没有设置临时bool数组，否则可能会对后边的点有阻断，

一会又发现对于 n 点忘记讨论可能同时也是危险城市，就加了个双重三目运算

我敲代码怎么这么冗长，不简洁，bug百出呢

28pts code

 #include <bits/stdc++.h>
#define re register int 
using namespace std;
typedef long long LL;
typedef pair<LL, int> PII;
const int N = 1e5 + 10, M = 4e5 + 10;
const LL inf = LLONG_MAX;
 
struct edge
{
	int to, w, next;
}e[M];
int top, h[N];
int n, m, k, gap, p, q, c[N], a[N], b[N];
LL dist[N];
bool vis[N], flag[N], pass[N];
 
inline void add(int x, int y, int w)
{
	e[++ top] = (edge){y, w, h[x]};
	h[x] = top;
}
 
inline void bfs(int s)
{
	int cnt = 0;
	bool tmp[N]; memset(tmp, false, sizeof(tmp));
	queue<int> q;
	
	q.push(s);
	flag[s] = tmp[s] = true;
	
	while (!q.empty())
	{
		int x = q.front(); q.pop();
		
		if (cnt == gap) break;
		
		bool tag = false;
		for (re i = h[x]; i; i = e[i].next)
		{
			int y = e[i].to;
			
			if (!tag) tag = true, cnt ++;
 			if (!tmp[y])
			{
				tmp[y] = true;
				q.push(y);
			} 
		}
	}
	
	for (re i = 1; i <= n; i ++)
		if (tmp[i]) pass[i] = true;
}
 
inline void dijkstra()
{
	priority_queue<PII, vector<PII>, greater<PII> > q;
	
	memset(vis, false, sizeof(vis));
	for (re i = 1; i <= n; i ++) dist[i] = inf;
	
	dist[1] = 0;
	q.push(make_pair(0, 1));
	
	while (!q.empty())
	{
		int x = q.top().second; q.pop();
		if (vis[x]) continue;
		vis[x] = true;
		
		for (re i = h[x]; i; i = e[i].next)
		{
			int y = e[i].to, w = e[i].w;
			
			if (flag[y]) continue;
			if (dist[y] > dist[x] + w)
			{
				dist[y] = dist[x] + w;
				q.push(make_pair(dist[y], y));
			}
		} 
	}
}
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	
	cin >> n >> m >> k >> gap >> p >> q;
	for (re i = 1; i <= k; i ++) 
	{
		cin >> c[i];
		flag[c[i]] = true;
	}
	for (re i = 1; i <= m; i ++)
	{
		cin >> a[i] >> b[i];
		add(a[i], b[i], 0); add(b[i], a[i], 0);
	}
	for (re i = 1; i <= k; i ++)
		bfs(c[i]);
 
	memset(e, 0, sizeof(e));
	memset(h, 0, sizeof(h));
	top = 0;
	
	for (re i = 1; i <= m; i ++)
	{	
		if (pass[b[i]]) add(a[i], b[i], q);
		else add(a[i], b[i], (b[i] == n ? 0 : (pass[b[i]] ? q : p)));
		
		if (pass[a[i]]) add(b[i], a[i], q);
		else add(b[i], a[i], (a[i] == n ? 0 : (pass[a[i]] ? q : p)));
	}
	dijkstra();
	
	cout << dist[n] << '\n';
	
	return 0;
}

AC code

 #include <bits/stdc++.h>
#define re register int 
using namespace std;
typedef long long LL;
typedef pair<LL, int> PII;
const int N = 1e5 + 10, M = 4e5 + 10;
const LL inf = LLONG_MAX;
 
int n, m, k, gap, p, q, c[N];
int dep[N], val[N];
LL dist[N];
bool vis[N], flag[N];
vector<int> g[N];
 
inline void bfs()
{
	int cnt = 0;
	queue<int> q;
	
	for (re i = 1; i <= k; i ++)
		q.push(c[i]);
	
	while (!q.empty())
	{
		int x = q.front(); q.pop();
		
		for (re i = 0; i < g[x].size(); i ++)
		{
			int y = g[x][i];
			
 			if (!dep[y])
			{
				dep[y] = dep[x] + 1;
				q.push(y);
			} 
		}
	}
}
 
inline void dijkstra()
{
	priority_queue<PII, vector<PII>, greater<PII> > q;
	
	memset(vis, false, sizeof(vis));
	for (re i = 1; i <= n; i ++) dist[i] = inf;
	
	dist[1] = 0;
	q.push(make_pair(0, 1));
	
	while (!q.empty())
	{
		int x = q.top().second; q.pop();
		if (vis[x]) continue;
		vis[x] = true;
		
		for (re i = 0; i < g[x].size(); i ++)
		{
			int y = g[x][i];
			
			if (flag[y]) continue;
			if (dist[y] > dist[x] + val[y])
			{
				dist[y] = dist[x] + val[y];
				q.push(make_pair(dist[y], y));
			}
		} 
	}
}
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	
	cin >> n >> m >> k >> gap >> p >> q;
	for (re i = 1; i <= k; i ++) 
	{
		cin >> c[i];
		flag[c[i]] = true;
	}
	for (re i = 1; i <= m; i ++)
	{
		int a, b; cin >> a >> b;
		g[a].push_back(b);
		g[b].push_back(a);
	}
	bfs();
	
	for (re i = 1; i <= n; i ++)
	{	
		if (dep[i] <= gap) val[i] = q;
		else val[i] = p;
	}
	val[1] = val[n] = 0;
	dijkstra();
	
	cout << dist[n] << '\n';
	
	return 0;
}

真的，我从代码实现中能很清晰地看到我相较大佬的思维差距，哎

5-30（1题）

Friendly Spiders 一道需要构造虚点的题目

构造虚点这个 trick 不错

5-31（2题）

继续找了两道虚点的题做 Shichikuji and Power Grid、Rudolf and Subway

我去，直接给我做爽了，思路想得好顺，好爽，代码也是打得行云流水一遍出，好爽（不过后边那道题好像写超时了...

我发现，这个虚点思想真的有启发性，对生活实际也很有帮助

比如城市之间发电站、电缆的最小花费设计，城市地铁线路求换乘数最少方案，很少有这种能用自己学到的知识靠近生活解决实际问题的感觉了。

6-1（2题）

今天晚上晚二就来打比赛了，打了一场 abc，只做得AB，哎

本来想着调完程序晚三回去补作业，tmd，调了一个多小时这个cf多测超时的问题，md，烦死了

后面调完反正也没多少时间了，又去做了一道题，又 wa，接着调，调不出来了

哎，调程序真的让人烦躁，烦，好烦

这里的电脑也是直接烂了两台，md搬来另一台主机，上面的 dev-c++ 程序调试窗口弹出来还调试不了，直接莫名其妙就完成了，然后显示继续... 真的烦，啊

明天学考摸底，没复习一点（有点慌 ~

6-2（1题）

发现自己不会处理带权无向图中边的联通快，崩了，回去睡觉再想想

6-3（1题）

哎，要放高考假了，又是一年高考了，想想自己也来一中一年了，感觉自己没有很多进步呀，一年啊，整整一年啊，我 15、16岁的一年啊。

这次放假九天，最短路、生成树、lca、tarjan、差分约束、拓扑排序以及涉及的一些 tricks 希望都能搞完。

6-4（0题）

今天是痛快地休息了一天，舒服 ~，摘了杨梅，逛了公园，玩了mc、天际线（我发现我对这种交通、规划的东西好上头）、吃了爸妈煮的饭菜（真香啊~

额，今天不知道为什么逛了一下上海科技大学的官网（好像是看了某位大佬的随笔，感觉这个大学......哎呦，不错哦 qwq

分数线大概是 620~630 的样子，主要是它有个“校园开放日”的活动，居然可以有类似加分的政策，A类就是直接加20分，哇去

感觉这所学校离我很近，但我还得更努力

6-6（1题）

Full Tank? 一道拆点最短路好题（其实也很板

一开始很容易想到对加油这个操作进行拆点，然后手模一下....发现不会做，且边数过大包超时的，离线做就有 $O (q (2 c M + c N) \log c N)$ ，大概飙到 10^9 了，且离线做还不好搞每次的油箱容量（也没想了），在线更不可能

大概就是这样

感觉自己还是没有提升，总是想地很浅显，能直接建图就一定不用dp思想，还一个劲地死做

其实这题拓维就很好做了，

还有，拓维做时间复杂度也有 $O (q M \log N)$ ，10^8，我以为也会 T

但是翻了翻书才发现自己忘记了很重要的本质：dijstra 基于贪心思想，用优先队列 bfs 实现，每个状态更新多次，只扩展一次，第一次出队即为该状态的最小代价

所以当 x = t 的时候，就可以直接 break 掉了，这样 10^8 就很明显跑不满，也就能卡着过了。

6-8（1题）

P4011 孤岛营救问题一道拆点的题，但是高度提炼出核心，其实就是一道状态压缩 + bfs 的题

这题让我学到了状态压缩的妙处啊，对于每个点，其当前拥有的钥匙种类不定，1~10，不可能再多开十个维度去麻烦地记录，而且这还算少的范围了，

所以，对这种若干只有 0/1 状态的记录，可以压缩到用一个二进制数记录，这样就只用开一维，其中，| 可以理解为 ∪（并），& 可以理解为 ∩（交）

dp 可以看作是拓扑图上的最短路问题。 —— y总

把这题我写的代码也挂这，很简短很美

code

 #include <bits/stdc++.h>
#define re register int 
using namespace std;
const int N = 11;
const int dx[4] = {0, -1, 0, 1};
const int dy[4] = {-1, 0, 1, 0};
 
struct node
{
	int x, y, state, dist;
};
 
int n, m, p, k, s, res = -1;
int type[N][N][N][N], key[N][N];
bool vis[N][N][1 << N];
 
inline void bfs()
{
	queue<node> q;
	
	vis[1][1][key[1][1]] = true;
	q.push({1, 1, key[1][1], 0});
	
	while (!q.empty())
	{
		node u = q.front(); q.pop();
	
		if (u.x == n && u.y == m) 
		{
			res = u.dist;
			break;
		}
		
		for (re i = 0; i < 4; i ++)
		{
			node v = (node){u.x + dx[i], u.y + dy[i], u.state, u.dist};
			int t = type[u.x][u.y][v.x][v.y];
			
			if (v.x < 1 || v.x > n || v.y < 1 || v.y > m || !t) continue;
			
			if (t == -1 || (t && v.state >> t & 1))
			{
				v.state |= key[v.x][v.y];
				v.dist ++;
				
				if (vis[v.x][v.y][v.state]) continue;
				vis[v.x][v.y][v.state] = true;
				q.push(v);
			}
		}
	}
}
 
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	
	memset(type, -1, sizeof(type));
	
	cin >> n >> m >> p >> k;
	while (k --)
	{
		int a, b, c, d, g; cin >> a >> b >> c >> d >> g;
		type[a][b][c][d] = g;
		type[c][d][a][b] = g;
	}
	cin >> s;
	while (s --)
	{
		int x, y, g; cin >> x >> y >> g;
		key[x][y] |= (1 << g);
	}
	bfs();
	cout << res << '\n';
	
	return 0;
}

6-9（3题）

最短路结束！

6-10

我嘞个豆啊，这物理是学了就忘了，还得补网课......

6-12（4题）

我去，现在深夜 1:10，我在这里打颠佬

打了一场 cf Codeforces Round 952 (Div. 4)，把前四道题都切了，虽然都很简单，但是我还是很开心，超开心的

E 结论很好想到，主要是最后半小时没想出来怎么构造方案，还得最优化，如果暴力打擂台就会 T

6-13 ~ 6-14（3题）

补了两天的题，H1、H2 还没补完 ......

这个机房的电脑真是越来越烂了，愣是花了二十多分钟，拆了三台电脑，才拼好一台能凑合着用的

我感觉考前这两周精力不会太放在这上边，效率会低一点，md，我高考假作业好多（文科）没写，我也不想应付了，摆

最好期末前能把图论搞完，暑假练 dp，我去，时间真的不多了，数据结构还好多没学，烦烦烦

6-15 ~ 6-16（2题）

这两天是计划要复习 lca 的，但是不知道怎么了，感觉花了时间都没做出什么实际的东西

题目也没做，感觉好奇怪啊

星期天下午倒是趁难得 4:30 下课还赶上比赛了，Codeforces Round 953 (Div. 2)

三十分钟切了 AB，然后就罚坐了一个半小时 ... 再说吧，没多少时间了

感觉最近有些懒散了 ... 不行

6-17（2题）

做了两道典型的树上点差分和边差分题目

感觉没什么难的，还是要做一些综合其他算法的树上差分题目，加油加油

最近调题老是调得很慢，一些很低级的错误愣是好长时间找不到

还是要沉得下心，相信自己的思路，不要浮躁

6-18（2题）

两道很考思维的树上差分，闇の連鎖和 NOIp2015提高的运输计划

好题，真的好题

6-19 ~ 6-20（1题）

做了一道很好的 lca 的分类讨论题 A and B and Lecture Rooms 这里边用到了一个很好用的技巧：通过倍增上跳树上两点简单路径的中点（以及可能其他性质的点）

code

 if (dep[u] < dep[v]) swap(u, v);
	
		int step = dist / 2;
		int cnt = size[u];
		
		for(int i = log2(n); i >= 0; i--)
			if(step - (1 << i) > 0)
			{
				u = f[u][i];
				cnt += size[u] - cnt;
				
				step -= (1 << i);
			}
		u = f[u][0];

这个 shareOI-master 里分享的大佬们的（课件？，还是很值得一看的，很多有意思的题目和思路

今天下午老家家里人路过来看了看我，大半年没见了（其实也不算很久

一起的时候看着他们还是很高兴的，一直关心我的学习生活的烦恼，分别之后回来路上就有点感慨自己

哎，和家里人越来越生疏了，独自和父母一起出来念书这么多年，我不能辜负家里人的期待 ... 真的，那种诗句里的思乡之情来了就是压抑不住的

6-21 ~ 6-22（2题）

数学周考 ... 怎么说呢，又炸了，感觉自己都变弱智了，不要写得多，要想得多（最好想到能很符合逻辑地能得到结果的做法，闷头写并不会想很远），要不然很多时候只会是浪费时间！

今天做了一道转化差分的题 P6869 [COCI2019-2020#5] Putovanje

很简单，反正我边听着歌一遍就过了，挺开心的吼吼

6-24（1题）

Knights 出得很好的一到 lca 的题目，要有图论建模的思维，

码了一百多行，前前后后花了我四十分钟的样子（还是码代码的速度太慢了），不过后边调试时间还是一会儿就过了

还要想吐槽一下，这 cf 的题测试点也忒多了吧，70 个测试点，我还胆战心惊地慢慢等它跑，一会我就刷新一下页面，一会又刷新一下

不过感觉挺开心的，看着它从 Running on 1 一直往后跑，有种过五关斩六将的自豪感

6-25

好累啊，每天试卷一叠一叠压下来，喘不过气了

感觉期末这几天来这又像是一种暂时跳脱 whk 的喘息，又像是会让大脑更加疲惫的不必要的坚持

就是效率太低了，平均一个中午才能想出思路，代码码到一半就打铃

晚自习还要百忙之中抽一节课把代码码完，然后是无尽的调试，都是到 22：50 分左右才走，越搞越晚

真的有一种脑容量不够用的感觉

做卷子已经让我头大了，还要思考一道竞赛的题目，已经到我的极限了快，最终的结果只能是两边都顾不好，虽然 OI 的题目让我很愉悦，就像今天英语刚学的词组 intellectual enjoyment ，但抗不住累啊

明天把今天这两道题（也是好题）搞完之后，就先放一放了。

哇，发现休息了十几天，昨天下午三点半终于期末考完了。。。解放啦，耶耶耶，芜湖

今天下午就出成绩了，nb

原始分考了个 520，一眼看过去，语文 94 英语 105...史，数学 122 还ok，物理 51？！！！哇，tmd炸了...... 化学 71 地理 77 乱考的

以为是真的要成废物了，往下翻(焦急地)。。。班级第 3？年级 rank 72？？？

突然觉得自己还是考得不错，刷新记录了。

说到记录，我突然想在这里简略回忆一下高一的考试情况：

记得创新班考试是 365 进来的（特意去翻了一下qq空间，那时候的自己好shabi啊）。

因为后来新高一进来就是一连串的竞赛月，没搞什么whk，期中考试前几乎是听一遍新课就直接裸考，不过还是考到了 230 左右，感觉自己好nb（哈哈，心里暗自窃喜原来我的底线这么高......不过看着出省光荣榜上的同学，自己的成绩还是很不够意思

csp-s挂了，noip3= 草草结束了我的高一赛季，很不是滋味，期末考还是认真应付了一下，好像是 160 左右

下学期选了物化地，应该压力小一些吧，好家伙，压力是真的小，跟先前的所谓创新 b 班（其实 c 班），更加nb，上课下课睡神一大堆，不过与我无关

这次开学，就没像新高一那次那么高强度训练了，（真的，再回过头看，那时候真的很拼了，完全不顾whk）期中考好像也是跌到有 190 多（这是什么前后逻辑关系 qwq），我也不知道啊，

然后就是这次期末考了，直接冲到年级 73 了，呃呃呃，我也不知道啊

不过，总而言之，“雄关漫道真如铁，而今迈步从头越”。

今天去长沙溜达了一会，一个贼大的湖，在梅溪湖旁边的一个公园，湖风超大。很明显感觉到长沙的公园氛围很年轻，都是帅哥美女在逛公园 qwq，比株洲的公园没那么压抑，大部分是老人

骑单车逛了一圈，太阳直晒真热，树荫下就显得像空调房一样凉快

过人行道（不是路口），一开始路上车开好快，我都不敢向前，纳闷怎么是没看到这么大个人嘛？抬头发现，原来长沙普通的人行道都装红绿灯啊？高级

好累，晚上有一场 cf，A 翻译没怎么看懂，也没什么心思写题了，便挂 eee

posted @ 2024-03-03 22:23 Zhang_Wenjie 阅读(54) 评论(1) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 2024-7-9 ~ 10-12 记录

· 10-13 ~ 10-26 停课纪实

· 2023暑假做题小记

· 2024.7 训练日记

· 信友队 2024 暑假集训 · 贰

公告

昵称： Zhang_Wenjie
园龄： 3年4个月
粉丝： 4
关注： 24

+加关注

2025年3月

日

一

二

三

四

五

六

$Z h a n g W e n j i e$

昔日龌龊不足夸，来日放荡思无涯。春风得意马蹄疾，一日看尽长安花。

2024-2-26~7-7 记录

公告

积分与排名

随笔分类

常用

校队

	#include <bits/stdc++.h>
	#define re register int
	using namespace std;
	const int N = 50;

	int n, m, d[N][N];
	bool vis[N];

	inline void floyd()
	{
	for (re k = 0; k < n; k ++)
	for (re i = 0; i < n; i ++)
	for (re j = 0; j < n; j ++)
	d[i][j] = (d[i][j] \| d[i][k] & d[k][j]);
	}

	inline int check()
	{
	for (re i = 0; i < n; i ++)
	if (d[i][i]) return 1;

	for (re i = 0; i < n; i ++)
	for (re j = 0; j < n; j ++)
	{
	if(i == j) continue;
	if (!d[i][j] && !d[j][i]) return 0;
	}

	return 2;
	}

	inline char get_min()
	{
	bool flag = true;
	for (re i = 0; i < n; i ++)
	if (!vis[i])
	{
	flag = true;
	for (re j = 0; j < n; j ++)
	if (!vis[j] && d[j][i])
	{
	flag = false;
	break;
	}

	if (flag)
	{
	vis[i] = true;
	return i + 'A';
	}
	}
	}

	inline void print(int type, int p)
	{
	if (type == 1)
	printf("Inconsistency found after %d relations", p);
	if (type == 0)
	printf("Sorted sequence cannot be determined");
	if (type == 2)
	{
	memset(vis, false, sizeof(vis));

	printf("Sorted sequence determined after %d relations: ", p);
	for (re i = 0; i < n; i ++)
	printf("%c", get_min());
	}
	printf(".\n");
	}

	int main()
	{
	while (1)
	{
	cin >> n >> m;
	if (!n && !m) break;

	memset(d, 0, sizeof(d));
	int type = 0, p;
	for (re i = 1; i <= m; i ++)
	{
	string s; cin >> s;
	int a = s[0] - 'A', b = s[2] - 'A';

	if (!type)
	{
	d[a][b] = 1;
	floyd();
	type = check();
	if (type) p = i;
	}
	}
	print(type, p);
	}

	return 0;
	}

	if (dep[u] < dep[v]) swap(u, v);

	int step = dist / 2;
	int cnt = size[u];

	for(int i = log2(n); i >= 0; i--)
	if(step - (1 << i) > 0)
	{
	u = f[u][i];
	cnt += size[u] - cnt;

	step -= (1 << i);
	}
	u = f[u][0];

ZhangWenjie

昔日龌龊不足夸，来日放荡思无涯。 春风得意马蹄疾，一日看尽长安花。

2024-2-26~7-7 记录

公告

积分与排名

随笔分类

常用

校队

$Z h a n g W e n j i e$

昔日龌龊不足夸，来日放荡思无涯。春风得意马蹄疾，一日看尽长安花。