mrcrack

BZOJ刷题记录---提高组难度

BZOJ刷题记录---提高组难度

总目录详见https://blog.csdn.net/mrcrack/article/details/90228694

序号	题号	算法	思想难度	实现难度	总难度	推荐指数
1	1876	高精求GCD	18	33	51	2
2	2173	找规律	37	14	51	3
3	2208	暴力	23	28	51	2
4	1258	找规律	33	19	52	2
5	2005	数学	30	22	52	6
6	2429	最小生成树	23	29	52	3
7	2464	最短路	21	31	52	2
8	1028	枚举	26	27	53	4
9	2222	打表+手算	39	14	53	1
10	2456	脑补	34	19	53	6
11	4300	DP+单调转移	30	23	53
12	1008	数学分析+快速幂	27	27	54	7
13	1413	博弈	39	15	54	4
14	4368	贪心	31	23	54
15	1012	树状数组/线段树/RMQ	24	31	55	3
16	1228	博弈论SG函数	40	15	55	3
17	1489	DP	32	23	55	5
18	1607	线性筛因数	27	28	55	6
19	1050	并查集	27	29	56	8
20	1053	搜索	27	29	56	4
21	1261	DP	31	25	56	6
22	1303	前缀和	33	23	56	8
23	1569	DP	28	28	56	4
24	1970	暴力+高精	25	31	56	1
25	2241	暴力	28	28	56	2
26	1002	递推+高精度	32	25	57	2
27	1024	搜索	29	28	57	4
28	1054	BFS	27	30	57	5
29	1059	二分图	27	30	57	9
30	1191	二分图	27	30	57	9
31	1260	DP	32	25	57	6
32	1263	贪心+高精度	29	28	57	5
33	1816	二分	31	26	57	6
34	1854	二分图	27	30	57	6
35	1967	Floodfill最短路/贪心Cheat	42	15	57	1
36	3505	数学	29	28	57	4
37	4247	背包DP	31	26	57
38	1206	堆	27	31	58	3
39	1296	DP	33	25	58	6
40	1485	卡特兰数	29	29	58	3
41	1856	卡特兰数	29	29	58	3
42	2457	贪心	33	25	58	5
43	2467	找规律	37	21	58	3
44	2764	DP+高精度	26	32	58	2
45	1045&3293	数学求中位数	33	25	58	5
46	1013	高斯消元	28	31	59	4
47	1025	DP	32	27	59	5
48	1078	模拟斜堆	31	28	59	4
49	1265	高精度	29	30	59	2
50	1433	二分图	29	30	59	4
51	1505	贪心	35	24	59	5
52	2048	数学	39	20	59	3
53	2156	最短路	29	30	59	2
54	3108	乱搞	36	23	59	4
55	3214	字符串处理	24	35	59	2
56	3668	进制乱搞	27	32	59	6
57	4195	离散化+并查集	28	31	59	4
58	1019	DP	35	25	60	3
59	1055	DP	33	27	60	6
60	1452	三维树状数组	27	33	60	3
61	1509	树上最长链	30	30	60	6
62	1867	DP	32	28	60	5
63	1965	快速幂+快速乘	30	30	60	7
64	2435	BFS	30	30	60	5
65	2705	欧拉函数	30	30	60	6
66	2783	树上倍增	30	30	60	6
67	3210	坐标转化	33	27	60	5
68	1015	并查集	32	29	61	8
69	1036	树链剖分/动态树	26	35	61	10
70	1047	二维RMQ	27	34	61	5
71	1084	DP	33	28	61	7
72	1213	二分+高精	25	36	61	1
73	3106	DP	31	30	61	5
74	3142	数学	36	25	61	5
75	3613	二分+贪心	33	28	61	4
76	1026	数位DP	31	31	62	6
77	1079	记忆化搜索	31	31	62	2
78	1081	模拟	32	30	62	4
79	1293	单调队列	31	31	62	7
80	1407	扩展欧几里得	32	30	62	5
81	1588	Splay/Set	27	35	62	4
82	1811	差分解方程	36	26	62	6
83	1879	状压DP	33	29	62	6
84	2190	线性筛欧拉函数	31	31	62	7
85	2426	贪心	33	29	62	4
86	2656	高精度	31	31	62	2
87	2751	快速幂+快速乘	31	31	62	6
88	3191	DP	36	26	62	6
89	3517	解方程	40	22	62	6
90	4233	递推	40	22	62	4
91	1031	后缀数组	27	36	63	6
92	1044	二分+DP	33	30	63	6
93	1076	期望DP	34	29	63	6
94	1089	递推+高精度	32	31	63	2
95	1103	树链剖分	27	36	63	6
96	1198	搜索	31	32	63	2
97	1208	Splay/Set	29	34	63	3
98	1216	堆	27	36	63	5
99	1224	DFS+剪枝	35	28	63	3
100	1257	数学	36	27	63	7
101	2150	二分图	32	31	63	8
102	2172	分类讨论+暴力	35	28	63	2
103	3155	树状数组	31	32	63	6
104	4008	期望DP	33	30	63	6
105	4318	期望	40	23	63
106	4403	卢卡斯	33	30	63
107	1269&1507	Splay/STL	28	35	63	3
108	1416&1498	高精度算概率	31	32	63	4
109	1010	DP单调性/斜率优化	32	32	64	8
110	1046	DP+贪心	34	30	64	5
111	1092	模拟	34	30	64	4
112	1259	打表	44	20	64	1
113	1304	树形DP	33	31	64	6
114	1406	数学	36	28	64	5
115	1820	DP	35	29	64	7
116	1996	DP	36	28	64	6
117	2153	DP斜率优化	32	32	64	5
118	2302	DP+组合数递推	35	29	64	6
119	2328	贪心	35	29	64	5
120	2338	计算几何+排序	32	32	64	6
121	2600	二分/单调性	34	30	64	6
122	2660	DP	32	32	64	5
123	2765	解方程	32	32	64	5
124	2824	搜索	34	30	64	2
125	2875	矩阵乘法	31	33	64	7
126	3175	二分图	33	31	64	9
127	3208	记忆化搜索	32	32	64	4
128	3223	Splay翻转	27	37	64	7
129	3224	Splay	26	38	64	8
130	3227	DP+打表	34	30	64	2
131	3288	线性筛+欧拉函数	32	32	64	6
132	3437	DP斜率优化	32	32	64	7
133	3444	数学	34	30	64	4
134	3612	DP	37	27	64	5
135	4321	DP	40	24	64
136	4401	枚举约数+树上统计	35	29	64
137	1007	单调栈	33	32	65	8
138	1048	记忆化搜索	34	31	65	6
139	1051	tarjan	30	35	65	5
140	1058	Splay/Set	29	36	65	4
141	1068	记忆化搜索	35	30	65	7
142	1087	状压DP	33	32	65	6
143	1202	并查集	33	32	65	8
144	1220	数学+高精度	34	31	65	2
145	1237	DP	39	26	65	6
146	1491	Floyd	33	32	65	7
147	1560	DP小优化	36	29	65	7
148	1801	DP	34	31	65	7
149	1864	树形DP	33	32	65	6
150	1899	DP	35	30	65	6
151	1911	DP斜率优化	32	33	65	8
152	1912	树上最长链	34	31	65	6
153	1925	DP	35	30	65	7
154	1966	DP	35	30	65	4
155	2049	LCT	27	38	65	7
156	2186	数学	32	33	65	7
157	2242	快速幂+逆元+BSGS	29	36	65	7
158	2335	分类讨论	39	26	65	3
159	2423	DP	36	29	65	6
160	2431	DP	35	30	65	6
161	2565	Manacher	33	32	65	7
162	2729	组合计数高精度	35	30	65	5
163	2822	卡特兰数+高精度	33	32	65	2
164	3156	DP斜率优化	32	33	65	6
165	3173	树状数组+倒求顺序	34	31	65	6
166	3190	单调栈	33	32	65	8
167	3212	线段树区间操作	27	38	65	9
168	3506	Splay	28	37	65	6
169	3609	博弈	40	25	65	4
170	3631	树链剖分	28	37	65	6
171	3643	暴力	33	32	65	4
172	4325	暴力	26	39	65
173	4385	单调队列	31	34	65
174	1787&1832	LCA	31	34	65	6
175	1789&1830	暴力	34	31	65	5

测评地址：

1.bzoj 1876 //1876: [SDOI2009]SuperGCD //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1876

2.bzoj 2173 //2173: 整数的lqp拆分 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2173勘误

//一直觉得此文有问题，翻看https://blog.csdn.net/heheda_is_an_OIer/article/details/49862719比较认同，摘抄如下
//这道题样例解释似乎有问题？
//f[1]=1 f[2]=1 f[3]=2
//3=1+1+1 ->1*1*1=1
//3=1+2->1*1=1
//3=2+1->1*1=1
//3=3->2=2
//为此纠结了好久…… 得出方程 dp[i]=sigma(dp[j]*f[i-j])

3.bzoj 2208 //2208: [Jsoi2010]连通数 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2208

建议先AC// P3387 【模板】缩点 // 在线测评地址https://www.luogu.org/problemnew/show/P3387

4.bzoj 1258 //1258: [CQOI2007]三角形tri //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1258
题目有误例如T12靠在T24和T4上应改成例如T12靠在T14和T4上

5.BZOJ 2005 //2005: [Noi2010]能量采集 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2005

6.bzoj 2429 //2429: [HAOI2006]聪明的猴子 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2429

7.bzoj 2464 //2464: 中山市选[2009]小明的游戏 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2464

8.bzoj 1028 //1028: [JSOI2007]麻将 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1028

9.bzoj 2222 //2222: [Cqoi2006]猜数游戏 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2222

//搜索网络，该题没有作出说明的，也无正解．2019-7-27 10:29 搁置该题

10.bzoj 2456 //2456: mode //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2456

11.bzoj 4300 //4300: 绝世好题 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=4300

//搜索网络，发现bi-1中的i-1是个整体，作为b的脚标，我的天，题目表述不清啊
//bi与bi-1是数列中相邻的２个数，2019-7-27 12:41

//题目还需修改，需要表达的意思是(bi&bi-1)!=0 2019-7-27 12:54

12.bzoj 1008 //1008: [HNOI2008]越狱 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1008

13.bzoj 1413 //1413: [ZJOI2009]取石子游戏 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1413

神题一枚

14.bzoj 4368 //4368: [IOI2015]boxes纪念品盒 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=4368

//题目有缺漏，完整题目可见http://uoj.ac/problem/229

15.bzoj 1012 //1012: [JSOI2008]最大数maxnumber //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1012

16.bzoj 1228 //1228: [SDOI2009]E&D //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1228

17.bzoj 1489 //1489: [HNOI2009]双递增序 //在线测评地址https://www.luogu.org/problem/P4728

18.bzoj 1607 //1607: [Usaco2008 Dec]Patting Heads 轻拍牛头 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1607中文翻译太差
//该题需读英文原题https://blog.csdn.net/sdj222555/article/details/9259045

19.bzoj 1050 //1050: [HAOI2006]旅行comf //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1050

20.bzoj 1053 //1053: [HAOI2007]反素数ant //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1053

21.bzoj 1261 //1261: [SCOI2006]zh_tree //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1261

无需处理第2行：n个用空格隔开的正整数，为每个单词出现的次数(次数<200)。

22.bzoj 1303 //1303: [CQOI2009]中位数图 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1303

23.bzoj 1569 //1569: [JSOI2008]Blue Mary的职员分配 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1569

24.bzoj 1970 //1970: [Ahoi2005]Code 矿藏编码 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1970

25.bzoj 2241 //2241: [SDOI2011]打地鼠 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2241

26.bzoj 1002 //1002: [FJOI2007]轮状病毒 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1002

27.bzoj 1024 //1024: [SCOI2009]生日快乐 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1024

28.bzoj 1054 //1054: [HAOI2008]移动玩具 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1054

29.bzoj 1059 //1059: [ZJOI2007]矩阵游戏 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1059

30.bzoj 1191 //1191: [HNOI2006]超级英雄Hero //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1191

31.bzoj 1260 //1260: [CQOI2007]涂色paint //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1260

32.bzoj 1263 //1263: [SCOI2006]整数划分 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1263

33.bzoj 1816 //1816: [Cqoi2010]扑克牌 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1816

34.bzoj 1854 //1854: [Scoi2010]游戏 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1854

35.bzoj 1967 //1967: [Ahoi2005]CROSS 穿越磁场 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1967

36.bzoj 3505 //3505: [Cqoi2014]数三角形 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=3505

37.bzoj 4247 //4247: 挂饰 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=4247

38.bzoj 1206 //1206: [HNOI2005]虚拟内存 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1206

39.bzoj 1296 //1296: [SCOI2009]粉刷匠 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1296

40.bzoj 1485 //1485: [HNOI2009]有趣的数列 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1485

41.bzoj 1856 //1856: [Scoi2010]字符串 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1856

42.bzoj 2457 //2457: [BeiJing2011]双端队列 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2457

43.bzoj 2467 //2467: [中山市选2010]生成树 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2467

44.bzoj 2764 //2764: [JLOI2011]基因补全 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2764

45.

bzoj 1045 //1045:[HAOI2008] 糖果传递 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1045

bzoj 3293 //3293: [Cqoi2011]分金币 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=3293

46.bzoj 1013 //1013: [JSOI2008]球形空间产生器sphere //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1013

47.bzoj 1025 //1025:[SCOI2009]游戏 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1025

48.bzoj 1078 //1078:[SCOI2008]斜堆 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1078

49.bzoj 1265 //1265: [AHOI2006]斐波卡契的兔子（kacci） //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1265

50.bzoj 1433 //1433:[ZJOI2009]假期的宿舍 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1433

51.bzoj 1505 //1505:[NOI2004]小H的小屋 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1505

52.bzoj 2048 //2048: [2009国家集训队]书堆 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2048

53.bzoj 2156 //2156: 星际探险 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2156

//题目有误，这题在bzoj上的样例输入被吞了一个回车，所以请注意p=3。
/*
3 3
0 1 1
1 2 2
0 2 1
3
0 1 2
*/

54.bzoj 3108 //3108: [cqoi2013]图的逆变换 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=3108

55.bzoj 3214 //3214:[ZJOI2013]丽洁体 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=3214

56.bzoj 3668 //3668:[NOI2014]起床困难综合症 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=3668

57.bzoj 4195 //4195:[NOI2015]程序自动分析难点不是离散化+并查集 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=4195

58.bzoj 1019 //1019:[SHOI2008]汉诺塔 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1019

59.bzoj 1055 //1055:[HAOI2008]玩具取名 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1055

60.bzoj 1452 //1452:[JSOI2009] Count //[JSOI2009]计数问题 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1452

61.bzoj 1509 //1509:[NOI2003]逃学的小孩 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1509

62.bzoj 1867 //1867: [Noi1999]钉子和小球 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1867

63.bzoj 1965 //1965:[Ahoi2005] SHUFFLE 洗牌 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1965

64.bzoj 2435 //2435:[NOI2011]道路修建 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2435

65.bzoj 2705 //2705: [SDOI2012]Longge的问题 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2705

66.bzoj 2783 //2783: [JLOI2012]树 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2783

67.bzoj 3210 //3210: 花神的浇花集会 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=3210

68.bzoj 1015 //1015: [JSOI2008]星球大战starwar //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1015

69.bzoj 1036 //1036: [ZJOI2008]树的统计Count //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1036

70.bzoj 1047 //1047: [HAOI2007]理想的正方形 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1047

71.bzoj 1084 //1084: [SCOI2005]最大子矩阵 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1084

72.bzoj 1213 //1213: [HNOI2004]高精度开根 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1213

73.bzoj 3106 //3106: [cqoi2013]棋盘游戏 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=3106

74.bzoj 3142 //3142: [Hnoi2013]数列 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=3142

75.bzoj 3613 //3613: [Heoi2014]南园满地堆轻絮 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=3613

76.bzoj 1026 //1026: [SCOI2009]windy数 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1026

77.bzoj 1079 //1079: [SCOI2008]着色方案 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1079

78.bzoj 1081 //1081: [SCOI2005]超级格雷码 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1081题目排版有问题
//在线测评地址https://www.luogu.org/problem/P2328题目还是看这个吧

说明，编写的程序，测试样例时，输出为

洛谷AC,bzoj WA.

测试样例时，输出为

洛谷AC,bzoj AC.

79.bzoj 1293 //1293: [SCOI2009]生日礼物 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1293

80.bzoj 1407 //1407: [Noi2002]Savage //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1407
//在线测评地址https://www.luogu.org/problem/P2421

81.bzoj 1588 //1588: [HNOI2002]营业额统计 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1588
//在线测评地址https://www.luogu.org/problem/P2234

82.bzoj 1811 //1811: [Ioi2005]mea //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1811

83.bzoj 1879 //1879: [Sdoi2009]Bill的挑战 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1879
//在线测评地址https://www.luogu.com.cn/problem/P2167

84.bzoj 2190 //2190: [SDOI2008]仪仗队 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2190
//在线测评地址https://www.luogu.com.cn/problem/P2158

题解：

1.bzoj 1876 //1876: [SDOI2009]SuperGCD //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1876

题解详见https://blog.csdn.net/mrcrack/article/details/100971786

2.bzoj 2173 //2173: 整数的lqp拆分 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2173勘误//一直觉得此文有问题，翻看https://blog.csdn.net/heheda_is_an_OIer/article/details/49862719比较认同，摘抄如下
//这道题样例解释似乎有问题？
//f[1]=1 f[2]=1 f[3]=2
//3=1+1+1 ->1*1*1=1
//3=1+2->1*1=1
//3=2+1->1*1=1
//3=3->2=2
//为此纠结了好久…… 得出方程 dp[i]=sigma(dp[j]*f[i-j])
题解详见https://blog.csdn.net/mrcrack/article/details/100971922

3.bzoj 2208 //2208: [Jsoi2010]连通数 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2208

题解详见https://blog.csdn.net/mrcrack/article/details/100972410

4.bzoj 1258 //1258: [CQOI2007]三角形tri //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1258

题解详见https://blog.csdn.net/mrcrack/article/details/100972553

5.BZOJ 2005 //2005: [Noi2010]能量采集 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2005

题解详见https://blog.csdn.net/mrcrack/article/details/100972686

6.bzoj 2429 //2429: [HAOI2006]聪明的猴子 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2429

题解详见https://blog.csdn.net/mrcrack/article/details/100972847

7.bzoj 2464 //2464: 中山市选[2009]小明的游戏 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2464

题解详见https://blog.csdn.net/mrcrack/article/details/100973004

8.bzoj 1028 //1028: [JSOI2007]麻将 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1028

题解详见https://blog.csdn.net/mrcrack/article/details/100973127

9.bzoj 2222 //2222: [Cqoi2006]猜数游戏 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2222

题解详见https://blog.csdn.net/mrcrack/article/details/100973246

10.bzoj 2456 //2456: mode //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2456

题解详见https://blog.csdn.net/mrcrack/article/details/101343515

11.bzoj 4300 //4300: 绝世好题 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=4300

题解详见https://blog.csdn.net/mrcrack/article/details/101343616

12.bzoj 1008 //1008: [HNOI2008]越狱 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1008

题解详见https://blog.csdn.net/mrcrack/article/details/101343700

13.bzoj 1413 //1413: [ZJOI2009]取石子游戏 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1413

题解详见https://blog.csdn.net/mrcrack/article/details/101343749

14.bzoj 4368 //4368: [IOI2015]boxes纪念品盒 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=4368

//4368: [IOI2015]boxes纪念品盒
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=4368
//题目有缺漏，完整题目可见http://uoj.ac/problem/229
//样例也可这样，0->1->2 发放礼品,2秒,2->0回来,2秒,0->7->6->5发放礼品,3秒,5->0回来,3秒,总共2+2+3+3=10秒
//样例通过，提交Wrong_Answer.2019-8-5 22:17
//for(i=1;i<=right[0]/2;i++)t=right[i],right[i]=right[right[0]-i+1],right[right[0]-i+1]=t;//此处写成for(i=1;i<=right[0]/2;i++)right[i]=right[right[0]-i+1];//逆序
//样例通过，提交AC.2019-8-5 22:23
//可参阅此文https://blog.csdn.net/waduan2/article/details/79061209

#include
#define LL long long
#define maxn 10000010
int p[maxn],left[maxn],right[maxn];
LL TL[maxn],TR[maxn];//TL[i]左去左回到ｉ消耗的时间
LL max(LL a,LL b){
   return a>b?a:b;
}
LL min(LL a,LL b){
   return a }
int main(){
   int N,K,L,i,j,t;
   LL tmp,ans;
   scanf("%d%d%d",&N,&K,&L);
   left[0]=0,right[0]=0;
   for(i=1;i<=N;i++){
       scanf("%d",&p[i]);
       if(p[i]<=L/2)left[++left[0]]=p[i];
       else right[++right[0]]=L-p[i];
   }
   for(i=1;i<=right[0]/2;i++)t=right[i],right[i]=right[right[0]-i+1],right[right[0]-i+1]=t;//此处写成for(i=1;i<=right[0]/2;i++)right[i]=right[right[0]-i+1];//逆序
   for(i=1;i<=left[0];i++)
       if(i<=K)TL[i]=left[i];
       else TL[i]=TL[i-K]+left[i];
   for(i=1;i<=right[0];i++)
       if(i<=K)TR[i]=right[i];
       else TR[i]=TR[i-K]+right[i];
   ans=(TL[left[0]]+TR[right[0]])*2;
   for(i=left[0]-K;i<=left[0];i++){
       tmp=(TL[i]+TR[max(left[0]-K-i+right[0],0)])*2+L;
       ans=min(ans,tmp);
   }
   printf("%lld\n",ans);
   return 0;
}

15.bzoj 1012 //1012: [JSOI2008]最大数maxnumber //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1012

提供5种方法

//1012: [JSOI2008]最大数maxnumber
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1012
//第一遍读题，竟然没读懂，题目真是言简意赅
//静下心，边读题，边对着样例，弄明白题意了．
//样例解释如下
5 100   当前数列0
A 96     当前数列0 96
Q 1       当前数列0 96
A 97     当前数列0 96 93
Q 1       当前数列0 96 93
Q 2       当前数列0 96 93
//M <= 200,000，故 A n 功能对应的算法时间复杂度是O(M) 2*10^5
//时间主要花在 Q L 功能上，普通枚举对应的算法时间复杂度是O(ML) 极限情况是(2*10^5)^2=4*10^10
//适合处理的算法，有单调队列树状数组线段数
//单调队列该题的难点在于 L是会变化的
//树状数组线段数的难点在于数列在不断变长

//http://hzwer.com/1130.html介绍了３种方法
//单调队列
//样例通过，提交Wrong_Answer．2019-8-6 10:20
//重新读题，发现其中t是最近一次查询操作的答案（如果还未执行过查询操作，则t=0) 没注意到
//修改，提交AC.2019-8-6 10:31
#include
#include
#define maxn 200010
int q[maxn],max[maxn],t;//max[i]指结尾到i包括i,之间的最大值
int main(){
   int m,d,i,v,b=0;//b 其中t是最近一次查询操作的答案（如果还未执行过查询操作，则t=0)
   char cmd[5];
   memset(max,0,sizeof(max)),t=1,q[t]=0;
   scanf("%d%d",&m,&d);
   while(m--){
       scanf("%s%d",cmd,&v);
       if(cmd[0]=='A'){
           v=(b+v)%d,q[++t]=v;
           for(i=t;i>=1;i--)//最大值，是从右往左扫，遇到小的就覆盖．
               if(max[i]                else break;
       }else if(cmd[0]=='Q') b=max[t-v+1],printf("%d\n",b);
   }
   return 0;
}

//1012: [JSOI2008]最大数maxnumber
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1012
//http://hzwer.com/1130.html介绍了３种方法
//单调栈+二分栈用来存储脚标
//样例通过，提交Wrong_Answer.2019-8-6 18:43
//排查代码
//if(stack[mid] //修改，提交AC.2019-8-6 18:50
#include
#define maxn 200010
int stack[maxn],top=0,a[maxn],cnt=0;
int main(){
   int m,d,x,t=0,left,right,mid;
   char cmd[5];
   scanf("%d%d",&m,&d);
   while(m--){
       scanf("%s%d",cmd,&x);
       if(cmd[0]=='A'){
           x=(x+t)%d;
           while(top&&a[stack[top]]<=x)top--;
           a[++cnt]=x,stack[++top]=cnt;
       }else if(cmd[0]=='Q'){
           left=0,right=top;
           while(left+1                mid=(left+right)/2;
               if(stack[mid]                else right=mid;
           }
           printf("%d\n",t=a[stack[right]]);
       }
   }
   return 0;
}

//1012: [JSOI2008]最大数maxnumber
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1012
//树状数组思路源自https://blog.csdn.net/ssimple_y/article/details/75732961
//直接维护一个倒着的树状数组，更新和查询都和普通的相反，从后往前更新和从前往后查询就行了。
//样例通过，提交AC.2019-8-7 9:52
//树状数组，比线段树简单多了．
#include
#include
#define maxn 200100
int c[maxn],cnt=0;
int max(int a,int b){
   return a>b?a:b;
}
int lowbit(int x){
   return x&-x;
}
void update(int k,int v){
   while(k) c[k]=max(c[k],v),k-=lowbit(k);
}
int query(int k,int n){
   int ans=0;
   while(k<=n) ans=max(ans,c[k]),k+=lowbit(k);
   return ans;
}
int main(){
   int m,d,x,t=0;
   char cmd[5];
   memset(c,0,sizeof(c));
   scanf("%d%d",&m,&d);
   while(m--){
       scanf("%s%d",cmd,&x);
       if(cmd[0]=='A') x=(t+x)%d,cnt++,update(cnt,x);
       else if(cmd[0]=='Q') printf("%d\n",t=query(cnt-x+1,cnt));
   }
   return 0;
}

//1012: [JSOI2008]最大数maxnumber
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1012
//https://www.luogu.org/problemnew/solution/P1198?page=3   作者: rushcheyo 更新时间: 2017-01-26 14:11
//线段树标准写法
//体会，query函数最难写．
//样例通过，提交Runtime_Error.2019-8-7 17:05
//}q[maxn*5];//此处写成}q[maxn*4];
//修改，提交AC. 4倍不可靠，开空间不能太扣．2019-8-7 17:10
#include
#define maxn 200010
#define INF 999999999
int cnt=0;//统计节点数
struct node{
   int left,right,mx;
}q[maxn*5];//此处写成}q[maxn*4];
int max(int a,int b){
   return a>b?a:b;
}
void build(int u,int left,int right){
   int mid=(left+right)/2;
   q[u].left=left,q[u].right=right,q[u].mx=-INF;
   if(left==right)return;
   build(2*u,left,mid);
   build(2*u+1,mid+1,right);
}
void update(int u,int x,int v){
   if(q[u].left<=x&&x<=q[u].right) q[u].mx=max(q[u].mx,v);//更新x所涉及的区域
   else return;
   update(2*u,x,v);
   update(2*u+1,x,v);
}
int query(int u,int left,int right){
   if(right    if(left<=q[u].left&&q[u].right<=right) return q[u].mx;//漏了此句
   return max(query(2*u,left,right),query(2*u+1,left,right));//此处写成return max(query(2*u,left,mid),query(2*u+1,mid+1,right));
}
int main(){
   int m,d,x,t=0;
   char cmd[5];
   scanf("%d%d",&m,&d);
   build(1,1,m);
   while(m--){
       scanf("%s%d",cmd,&x);
       if(cmd[0]=='A') x=(x+t)%d,cnt++,update(1,cnt,x);
       else if(cmd[0]=='Q') printf("%d\n",t=query(1,cnt-x+1,cnt));
   }
   return 0;
}

ST表介绍摘自https://www.cnblogs.com/Blackops/p/6295094.html

//1012: [JSOI2008]最大数maxnumber
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1012
//ST表
//该题比较神奇的是一个逆向ST表
//样例未通过，
//t=max(dp[tot][k-1],dp[left+(1<<(k-1)+1)][k-1]);//此处写成t=dp[tot][k]=max(dp[tot][k-1],dp[left+(1<<(k-1)+1)][k-1]); 注意，查询时，不修改．
//样例通过，提交Wrong_Answer.2019-8-8 8:01
//t=max(dp[tot][k-1],dp[left+(1<<(k-1)-1)][k-1]);//此处写成t=max(dp[tot][k-1],dp[left+(1<<(k-1)+1)][k-1]);
//修改，提交Wrong_Answer.2019-8-8 8:07
//t=max(dp[tot][k-1],dp[left+(1<<(k-1))-1][k-1]);//此处写成t=max(dp[tot][k-1],dp[left+(1<<(k-1)-1)][k-1]);
//修改，提交AC.2019-8-8 8:15
#include
#define maxn 200010
int dp[maxn][20],tot=0;//20的由来 log2(200000)
int max(int a,int b){
   return a>b?a:b;
}
int main(){
   int m,d,x,t=0,j,left,k;
   char cmd[5];
   scanf("%d%d",&m,&d);
   while(m--){
       scanf("%s%d",cmd,&x);
       if(cmd[0]=='A'){
           dp[++tot][0]=(x+t)%d;
           for(j=1;tot-(1<=1;j++)dp[tot][j]=max(dp[tot][j-1],dp[tot-(1<<(j-1))][j-1]);//逆向ST表，自tot向1
       }else if(cmd[0]=='Q'){
           left=tot-x+1,k=0;
           while(tot-left+2>(1< z=left+2^(k-1)-1   tot-2^(k-1)+1>left+2^(k-1)-1 =>tot-left+2>2*2^(k-1)
           t=max(dp[tot][k-1],dp[left+(1<<(k-1))-1][k-1]);//此处写成t=max(dp[tot][k-1],dp[left+(1<<(k-1)-1)][k-1]);//此处写成t=max(dp[tot][k-1],dp[left+(1<<(k-1)+1)][k-1]);//此处写成t=dp[tot][k]=max(dp[tot][k-1],dp[left+(1<<(k-1)+1)][k-1]); 注意，查询时，不修改．
           printf("%d\n",t);
       }
   }
   return 0;
}

16.bzoj 1228 //1228: [SDOI2009]E&D //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1228

//1228: [SDOI2009]E&D
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1228
//题目出得不错，关于如何游戏，还针对性的举例，使读者尽快明白题意．
//与一般的策略游戏不同，似乎看不出是什么策略游戏．

//在题目理解上花了很长时间，一直以为是在一堆Ａ上可以移走一部分，也可以全部移走，另一堆Ｂ，再移一部分过来，只要这堆Ｂ上剩下的数量大于等于１即可
//重新读题，发现不是这么回事，任取一堆石子，将其移走，也即将上述的一堆Ａ，全部移走，读错题，该题迟迟打不开思路
//思路迟迟打不开局面时，不妨重新读题．2019-8-9 17:49
//打表的前提，源自模拟，以下为sg[1][1],sg[2][1],sg[2][2],sg[3][1],sg[3][2],sg[3][3]的模拟过程

sg[i][j] i代表当前左堆数量 j代表当前右堆数量

sg[1][1]=0

sg[2][1]=1 (sg[1][1]=0)移走右堆
sg[1][2]=1 (sg[1][1]=0)移走左堆

sg[2][2]=1 (sg[1][1]=0])移走右堆 (sg[1][1]=0)移走右堆

sg[3][1]=0 (sg[2][1]=1 sg[1][2]=1)移走右堆
sg[1][3]=0 (sg[1][2]=1 sg[2][1]=1)移走左堆

sg[3][2]=2 (sg[2][1]=1 sg[1][2]=1)移走右堆 (sg[1][1]=0)移走左堆
sg[2][3]=2

sg[3][3]=0 (sg[2][1]=1 sg[1][2]=1)移走右堆 (sg[1][2]=1 sg[2][1]=1)移走左堆

//打表效果如下

//以下为打表代码,参考了该文https://blog.csdn.net/wondover/article/details/79999308
//循环写法2019-8-9 22:12
#include
#include
#define maxn 110
int sg[maxn][maxn],vis[maxn*maxn];
void get_sg(int x,int y){
   int i,j;
   memset(vis,0,sizeof(vis));
   for(i=1;i    for(j=1;j    for(i=0;i<=maxn*maxn;i++)
       if(vis[i]==0){
           sg[x][y]=i;
           break;
       }
}
int main(){
   int n,i,j,k;
   sg[1][1]=0,n=20;
   for(i=1;i<=n;i++)
       for(j=1;j<=i;j++){
           memset(vis,0,sizeof(vis));
           for(k=1;k            for(k=1;k            for(k=0;k<=maxn*maxn;k++)
               if(vis[k]==0){
                   sg[j][i]=sg[i][j]=k;
                   break;
               }
       }
   for(i=1;i<=n;i++){
       for(j=1;j<=n;j++)
           printf("%3d",sg[i][j]);
       printf("\n");
   }
   return 0;
}

//以下为打表代码,参考了该文https://blog.csdn.net/qq_18455665/article/details/50837758
//记忆化搜索的递归写法2019-8-9 22:12
//for(i=1;i //for(j=1;j //程序输出结果始终对不上，多次对比代码，发现
//int vis[maxn*maxn];//之前写成全局变量
//虽然，递归打表思路比较简单，但还得小心vis数组只在递归函数内生效，即局部变量．2019-8-9 22:51
#include
#include
#define maxn 110
int n,m,sg[maxn][maxn];
int get_sg(int x,int y){
   int i,j;
   int vis[maxn*maxn];//之前写成全局变量
   if(sg[x][y]!=-1)return sg[x][y];
   memset(vis,0,sizeof(vis));
   for(i=1;i    for(j=1;j    for(i=0;i<=maxn*maxn;i++)
       if(vis[i]==0)return sg[x][y]=sg[y][x]=i;
}
int main(){
   int i,j;
   memset(sg,-1,sizeof(sg)),sg[1][1]=0,n=m=20;//memset(sg,-1,sizeof(sg)),sg[1][1]=0,n=m=20;
   for(i=1;i<=n;i++){
       for(j=1;j<=m;j++)
           printf("%3d",get_sg(i,j));
       printf("\n");
   }
   return 0;
}

//重心是放在找必胜态规律，还是找必败态规律．2019-8-10 9:34
//想明白了，其实就是确认sg[x][y]的具体算法
//阿达马矩阵一个还未研究的问题
//摘自https://blog.csdn.net/wu_tongtong/article/details/78993414
实际上SG值满足规律：
    x为奇数，y为奇数：SG=0
    x为偶数，y为偶数：SG=SG(x/2 , y/2)+1
    x为奇数，y为偶数：SG=SG((x+1)/2 , y/2)+1
    x为偶数，y为奇数：SG=SG(x/2 , (y+1)/2)+1

//摘自https://www.cnblogs.com/Y-E-T-I/p/8398428.html

//样例通过，提交AC.2019-8-10 10:56
#include
int sg(int x,int y){
   if((x&1)&&(y&1))return 0;//x,y均为奇数
   return sg((x+1)/2,(y+1)/2)+1;
}
int main(){
   int t,n,ans,x,y,i;
   scanf("%d",&t);
   while(t--){
       scanf("%d",&n);//漏了此行，没想法啊
       ans=0;//初始化别忘了
       for(i=1;i<=n/2;i++){
           scanf("%d%d",&x,&y);
           ans^=sg(x,y);
       }
       if(!ans) printf("NO\n");
       else printf("YES\n");
   }
   return 0;
}

17.bzoj 1489 //1489: [HNOI2009]双递增序 //在线测评地址https://www.luogu.org/problem/P4728

//1489: [HNOI2009]双递增序
//在线测评地址https://www.luogu.org/problem/P4728
//最长不下降子序列，但该题更复杂．
//https://www.lydsy.com/JudgeOnline/problem.php?id=1489没有题面，竟然还能提交．
//题目不全，根据各种题解，可以判定，元素值非负且不大于 10^6
//摘自https://www.cnblogs.com/terribleterrible/p/9873856.html
/*感觉这个题还蛮难想的.
首先状态特别难想.设dp[i][j]表示前i个数,B序列的长度为j的情况下,B序列的最后一个数的最小值.
其中A序列为上一个数seq[i]所在的序列,B序列为另外一个序列.
这样设状态的巧妙之处在于,它几乎完美地用最精炼的语言描述了序列的信息,使我们可以方便地转移.我们现在知道A序列的最后一个数seq[i],B序列的最后一个数dp[i][j].A序列的长度i−j,B序列的长度j.
于是转移(目标dp[i][j])就是:
如果可以接在A序列上的话,即seq[i−1] 如果可以接在B序列上的话,即dp[i−1][i−j] /*seq[i]接在原B序列之后，这种情况，理解难度较大.原B序列长度i-j-1 最后一个数值为dp[i-1][i-j-1] ;原A长度(i-1)-(i-j-1)=j 最后一个数值为seq[i-1];*/
/*现序列为A'(原B变化而来)长度i-j 最后一个数值为seq[i],B'(原A变化而来)长度j 最后一个数值为d[i][j].*/
//样例通过，提交AC.2019-8-11 11:08
#include
#include
#define maxn 2010
int dp[maxn][maxn/2],seq[maxn];
int min(int a,int b){
   return a }
int main(){
   int m,n,i,j;
   scanf("%d",&m);
   while(m--){
       memset(dp,127,sizeof(dp)),seq[0]=dp[0][0]=-1;//此处写成memset(dp,127,sizeof(127)),seq[0]=dp[0][0]=-1; 昏了
       scanf("%d",&n);
       for(i=1;i<=n;i++)scanf("%d",&seq[i]);
       for(i=1;i<=n;i++)//处理到dp[i][],是从dp[i-1][]转移而来
           for(j=0;j<=min(i-1,n/2);j++){//此处写成for(j=0;j<=min(i,n/2);j++){
               if(seq[i-1]                if(dp[i-1][i-j-1]            }
       if(dp[n][n/2]<=1000000)printf("Yes!\n");//此处写成if(dp[n][n/2]<=1000000)printf("YES!\n");
       else printf("No!\n");//此处写成else printf("NO!\n");
   }
   return 0;
}

18.bzoj 1607 //1607: [Usaco2008 Dec]Patting Heads 轻拍牛头 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1607

//1607: [Usaco2008 Dec]Patting Heads 轻拍牛头
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1607
//该题需读英文原题https://blog.csdn.net/sdj222555/article/details/9259045
//竟然没弄懂样例
//四处翻阅，最后发现这句是关键有五个数,对于任一个数来说,其它的数有多少个是它的约数
/*
5
2 第1头编号 1(第2头编号)|2,2(第3头编号)|2                  总共2
1 第2头编号无                                   总共0
2 第3头编号 1(第2头编号)|2,2(第1头编号)|2               总共2
3 第4头编号 1(第2头编号)|3                           总共1
4 第5头编号 1(第2头编号)|4,2(第1头编号)|4,2(第3头编号)|4   总共3
*/
//总的来说，该题翻译不好，题意不明．2019-8-11 12:49
//摘自https://blog.csdn.net/nixinyis/article/details/68507856
//用类似筛素数的方法，考虑每个a[i]对后面（a[i],a[i]*2,a[i]*3……的影响，如果那个数字存在）
//仔细想了想，这个算法曾经用过．
//样例通过，提交AC.2019-8-11 15:56
//读了一边英文题目https://blog.csdn.net/sdj222555/article/details/9259045
//才发https://www.lydsy.com/JudgeOnline/problem.php?id=1607的翻译，根本就是乱翻．2019-8-11 16:04
#include
#include
#define maxn 100010
int a[maxn],b[maxn*10],ans[maxn*10];
int max(int a,int b){
   return a>b?a:b;
}
int main(){
   int n,i,j,mx=0;
   memset(b,0,sizeof(b)),memset(ans,0,sizeof(ans));
   scanf("%d",&n);
   for(i=1;i<=n;i++)scanf("%d",&a[i]),b[a[i]]++,mx=max(mx,a[i]);
   for(i=1;i<=mx;i++)
       if(b[i])
           for(j=i;j<=mx;j+=i)
               ans[j]+=b[i];//此处写成ans[j]++;
   for(i=1;i<=n;i++)printf("%d\n",ans[a[i]]-1);//此处写成for(i=1;i<=n;i++)printf("%d\n",ans[i]-1);
   return 0;
}

19.bzoj 1050 //1050: [HAOI2006]旅行comf //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1050

//1050: [HAOI2006]旅行comf
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1050
//题目描述还是有问题的，不过，借助题目，数据输入，以及样例，还是能弄懂题目所要表达的意思．
//题目所要表达的意思，景点s到景点t间有多条路径，输出速度比最小的值．
//IMPOSSIBLE可用并查集处理
//路径选择，觉得暂无办法．
//有一个问题，前面的连接，可能对后面景点s到景点t 联通无用，那前面的数据还有用吗
//仔细想了想，多虑了，其实就是最小生成树算法．若景点s到景点t能联通，前面的连接一定是有效的

//一直对上图的例子念念不忘，不过解决了，请看，第一次搜索，将a,b,c,d,S,T 4个点都找到，此时算出值为4/1=4
//但可以在接下来的搜索中，找到d,S,T 3个点，此时算出的值为4/3，显然比上面小，故，最小生成树算法，在该题，没有问题．
//顾虑很多，一一解决．2019-8-12 7:45
//参考了此文的写法https://www.cnblogs.com/hhh1109/p/8438369.html直接一个克鲁斯卡尔+队列就好了，把边从小到大排，然后暴力每一条边为出发点，不断向右边找，直到s==t，这样就能求出比值最小的边了
//参考了此文的优化https://www.cnblogs.com/Mrsrz/p/7281581.html注意代码第23行的优化。为什么可以这么优化呢？因为这条边与上一条边权值相同，在上一条边作最小边时，这条边已经被加进去过了，所以得到的答案不可能更优，或者是直接连通，比值为1，也不可能更优。所以可以这么优化。

//参考了此文的写法https://www.cnblogs.com/hhh1109/p/8438369.html直接一个克鲁斯卡尔+队列就好了，把边从小到大排，然后暴力每一条边为出发点，不断向右边找，直到s==t，这样就能求出比值最小的边了
//参考了此文的优化https://www.cnblogs.com/Mrsrz/p/7281581.html注意代码第23行的优化。为什么可以这么优化呢？因为这条边与上一条边权值相同，在上一条边作最小边时，这条边已经被加进去过了，所以得到的答案不可能更优，或者是直接连通，比值为1，也不可能更优。所以可以这么优化。
//if(ans1*e[i].v>=ans2*e[j].v) ans1=e[j].v,ans2=e[i].v;//此处写成if(getf(s)==getf(t)&&ans1*e[i].v<=ans2*e[j].v) ans1=e[j].v,ans2=e[i].v;//此处写成if(ans1*e[i].v<=ans2*e[j].v) ans1=e[j].v,ans2=e[i].v;//if(ans1/ans2<=e[j].v/e[i].v)
//上述过程查了会．
//样例通过，提交AC.2019-8-12 9:47
#include
#include
using namespace std;
int n,m,f[510];
struct node{
   int x,y,v;
}e[5010];
int gcd(int a,int b){//求最大公约数
   return b?gcd(b,a%b):a;
}
int getf(int u){//找爸爸
   if(f[u]==u)return u;
   return f[u]=getf(f[u]);
}
int cmp(node a,node b){//自小到大排序
   return a.v }
int main(){
   int i,j,s,t,f1,f2,ans1=0,ans2=0,d;
   e[0].x=0,e[0].y=0,e[0].v=0;
   scanf("%d%d",&n,&m);
   for(i=1;i<=m;i++)scanf("%d%d%d",&e[i].x,&e[i].y,&e[i].v);
   scanf("%d%d",&s,&t);//漏了此句读取，程序一直出现段错误，查了10分钟
   sort(e+1,e+1+m,cmp);
   for(i=1;i<=m;i++){
       if(e[i].v==e[i-1].v)continue;//因为这条边与上一条边权值相同，在上一条边作最小边时，这条边已经被加进去过了，所以得到的答案不可能更优，或者是直接连通，比值为1，也不可能更优。
       for(j=1;j<=n;j++)f[j]=j;
       for(j=i;j<=m;j++){
           f1=getf(e[j].x),f2=getf(e[j].y);
           if(f1!=f2)f[f2]=f1;//左靠
           if(getf(s)==getf(t))break;
       }
       if(i==1&&getf(s)!=getf(t)){
           printf("IMPOSSIBLE\n");
           return 0;
       }
       if(getf(s)!=getf(t))break;//优化，当前找不到联通，之后也无需找联通了，因为找不到
       if(ans1*e[i].v>=ans2*e[j].v) ans1=e[j].v,ans2=e[i].v;//此处写成if(getf(s)==getf(t)&&ans1*e[i].v<=ans2*e[j].v) ans1=e[j].v,ans2=e[i].v;//此处写成if(ans1*e[i].v<=ans2*e[j].v) ans1=e[j].v,ans2=e[i].v;//if(ans1/ans2<=e[j].v/e[i].v)
   }
   d=gcd(ans1,ans2);
   if(d==ans2)printf("%d\n",ans1/ans2);
   else printf("%d/%d\n",ans1/d,ans2/d);
   return 0;
}

20.bzoj 1053 //1053: [HAOI2007]反素数ant //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1053

//1053: [HAOI2007]反素数ant
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1053
//g(1)=1,g(2)=2,g(3)=2,g(4)=3,g(5)=2,g(6)=4
//题意看懂了，1<=N<=2,000,000,000，有点吓人，肯定要用特殊的算法
//sqrt(2*10^9)=10^4*sqrt(20)=5*10^4求具体一个数的约数个数，应该没有问题
//恐怖的是，有2*10^9这么多个数据要求约数．
//就算能O(1)求出某个数的约数个数，有2*10^9这么多个数据要处理，也是没辙．
//摘自https://www.cnblogs.com/zbtrs/p/7284348.html
/*
分析：这道题让我们求这样一个数：1.因数最多 2.如果满足1条件的有多个，则取最小的那一个.
       根据唯一分解定理可以得到：x = p1^k1 * p2^k2 *...*pn^kn,其中p1,p2,...,pn为质数，这样有多少个因数呢？根据乘法原理，质数p1可以不选，选1个，2个...k1个，p2到pn也是类似，那么因数个数=(k1 + 1)*(k2 + 1)*...*(kn + 1).
       显然，用小质数比用大质数更好，又因为2*3*5*7*11*13*17*19*23*29=6,469,693,230>2,000,000,000，所以我们只需要用到前9个质数就可以了！这样，我们搜索每个质数的次数，更新答案就可以了。如果在搜索中数的大小超过了n,就剪枝。
*/
//摘自https://blog.csdn.net/thy0311/article/details/50668138
/*
那么首先明确一点，在生成一个数时，想要他的约数个数最大，那个就要让素因数的个数最大化，同时可以发现，小素数越多越占优，及大素数的个数不得大于任何一个小素数，原因在于假如有2个7，一个5，那么也可以有2个5一个7，且一定比之前的大，那么就不符合要求了。
*/
//此文代码写得不错http://hzwer.com/3141.html
//样例通过，提交AC.2019-8-12 22:24
#include
#define LL long long
int prime[]={1,2,3,5,7,11,13,17,19,23};//prime[0]无用，可放任意数据2*3*5*7*11*13*17*19*23*29=6469693230 故只要搜到23即可，即搜到prime[9]即可．
int num=0,n;
LL ans=0;
void dfs(int k,LL now,int cnt,int last){//k当前用到的prime[k]中的脚标 now当前处理到的数值 cnt当前数据约数个数 last当前数据对应质因数幂次
   int i;
   LL x=1;
   if(k==10){
       if(ans        else if(ans>now&&num<=cnt)ans=now,num=cnt;//两数，选值小，约数多的
       return;
   }
   for(i=0;i<=last;i++){
       dfs(k+1,now*x,cnt*(i+1),i);//i的原因是，因数大的幂次数不会大于因数小的幂次数
       x*=prime[k];
       if(now*x>n)break;
   }
}
int main(){
   scanf("%d",&n);
   dfs(1,1,1,31);//2^31=2*1000*1000*1000 31是指某个因数最多幂次数
   printf("%lld\n",ans);
   return 0;
}

21.bzoj 1261 //1261: [SCOI2006]zh_tree //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1261

无需处理第2行：n个用空格隔开的正整数，为每个单词出现的次数(次数<200)。

//1261: [SCOI2006]zh_tree
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1261
//读完题目，发现有问题，第2行：（5分）n个用空格隔开的整数，为该树的前序遍历，在样例中无体现．
//最小平均代价，概率越大，应离根越近．

//摘自https://www.cnblogs.com/yifusuyi/p/10210584.html有小错误，略有修改

//样例通过，提交．2019-8-13 22:21
#include
#define maxn 35
int n;
double k,c,f[maxn][maxn],sum[maxn],d[maxn];
double min(double a,double b){
   return a }
int main(){
   int i,len,left,right,j;
   sum[0]=0;
   scanf("%d%lf%lf",&n,&k,&c);
   for(i=1;i<=n;i++)
       for(j=1;j<=n;j++)
           f[i][j]=1e100;//之前写成memset(f,0,sizeof(f)); memset用在整数上．
   for(i=1;i<=n;i++)scanf("%lf",&d[i]),f[i][i]=d[i],f[i+1][i]=0,sum[i]=sum[i-1]+d[i];//此处写成for(i=1;i<=n;i++)scanf("%lf",&d[i]),f[i][i]=d[i],f[i][i+1]=0,sum[i]=sum[i-1]+d[i];//f[i][i+1]为右子树无元素作准备，
   f[1][0]=0;//漏了此句
   for(len=1;len<=n;len++)//此处写成for(len=2;len<=n;len++)
       for(left=1;left<=n;left++){
           right=left+len;
           if(right>n)break;
           for(i=left;i<=right;i++)
               f[left][right]=min(f[left][right],f[left][i-1]+f[i+1][right]+(sum[right]-sum[left-1]));//此处写成f[left][right]=min(f[left][right],f[left][i]+f[i+1][right]+k*(sum[right]-sum[left-1]));
       }
   printf("%.3lf\n",(k*f[1][n]+sum[n]*c)/sum[n]);
   return 0;
}

22.bzoj 1303 //1303: [CQOI2009]中位数图 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1303

//1303: [CQOI2009]中位数图
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1303
//请注意，给出1~n的一个排列，统计该排列有多少个长度为奇数的连续子序列的中位数是b。
//即，子序列中的序列不可变，即样例的情况，是不存在5 2 4的子序列．

//摘自https://www.luogu.org/problemnew/solution/P1627　作者: Heartlessly 更新时间: 2019-02-13 19:52

//摘自https://www.luogu.org/problemnew/solution/P1627 作者: P_Wang 更新时间: 2018-01-28 22:00

//偏爱此文代码https://www.cnblogs.com/cjyyb/p/9751694.html
//样例通过，提交AC.2019-8-14 17:28
#include
#include
#define LL long long
#define maxn 100010
LL ans=0;
int n,b,a[maxn],s[maxn*2],sum;
int main(){
   int i,pos;
   memset(s,0,sizeof(s));
   scanf("%d%d",&n,&b);
   for(i=1;i<=n;i++){
       scanf("%d",&a[i]);
       if(a[i]>b)a[i]=1;
       else if(a[i]        else if(a[i]==b)a[i]=0,pos=i;
   }
   for(i=pos,sum=0;i;i--) sum+=a[i],s[maxn+sum]++;
   for(i=pos,sum=0;i<=n;i++)sum+=a[i],ans+=s[maxn-sum];//组合数学
   printf("%lld\n",ans);
   return 0;
}

23.bzoj 1569 //1569: [JSOI2008]Blue Mary的职员分配 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1569

//1569: [JSOI2008]Blue Mary的职员分配
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1569
//看起来象背包，但比一般的背包复杂多了．
//摘自https://blog.csdn.net/qq_39387710/article/details/80086241
/*
1.第三天招来的人第四天才能工作
2.当天赚的钱可以用来招人
*/
//摘自https://www.cnblogs.com/ZH-comld/p/9549058.html
/*
看着是个暴力dp，但要注意转移方向。
单纯获利是，从钱少的的地方向钱多的地方转移。
发广告时，从等待天数少的向天数多的地方转移，但钱会减少。
连续发广告是，从人少向人多转移，钱会减少。
我们的枚举顺序确定了，人，等待天数，钱，名誉。
*/
//摘自https://www.cnblogs.com/zwfymqz/p/9226115.html
/*
f[i][a][b][sta]表示此时已经有了i个人，a点金钱，b点声誉，里上一次打广告过去了sta天
*/
//摘自https://www.cnblogs.com/TheRoadToTheGold/p/8202570.html
/*
dp[i][j][a][b] 表示i个职员，发广告状态为j，已有金钱a，声誉b的最少天数
j=0 表示没有发广告，否则j表示距离发广告j天
枚举有t个人增加金钱，那就有i-t个人增加声誉
当j=3时，人数+1
当j=0或j=3时，考虑发不发广告
注意：
1、当天赚的钱可以用来发广告
2、新招募的人当天不能为公司带来收益
*/
//该题涉每次发布广告三天以后不同人理解三天容易出现偏差，最好有详细的例子，并配上文字说明．
//样例通过，提交Wrong_Answer．2019-8-15 18:46
//if(ma>=z) dp[i+1][ma-z][mb][1]=min(dp[i+1][ma-z][mb][1],dp[i][j][k][t]+1);//此处写成if(ma>=z) dp[i+1][ma-z][mb][0]=min(dp[i+1][ma-z][mb][0],dp[i][j][k][t]+1)，想的时候，都考虑到了，不过没想到只写了i+1,而没写１;//招聘新人
//样例通过，提交AC.2019-8-15 18:52
#include
#include
int dp[45][25][25][5];
int max(int a,int b){
   return a>b?a:b;
}
int min(int a,int b){
   return a }
int main(){
   int n,x,y,z,a,b,i,j,k,t,ma,mb,p,ans;
   memset(dp,127,sizeof(dp)),ans=999999999;
   scanf("%d%d%d%d%d%d",&n,&x,&y,&z,&a,&b);
   dp[n][0][0][0]=0;//条件还没开始时的情况，也即计时没有开始的情况．对理解第0天，第1天，有帮助
   for(i=n;i<=40;i++)//人数优先
       for(t=0;t<=3;t++)//因发广告的时间越长，意味着等待时间越长，故放在第２层循环
           for(j=0;j<=max(a,z);j++)//不仅要考虑赚钱，还要考虑能雇得起人的情况
               for(k=0;k<=b;k++)
                   if(dp[i][j][k][t]                        if(j>=a&&k==b)ans=dp[i][j][k][t];//虽然更新了ans，但下面的情况还要执行．???
                       for(p=0;p<=i;p++){//人员状态．有p人赚钱，那么，有i-p人挣声誉
                           ma=min(j+p*x,max(a,z)),mb=min(k+(i-p)*y,b);//赚钱，挣声誉状态
                           if(!t){//雇人状态，还未招聘
                               dp[i][ma][mb][t]=min(dp[i][ma][mb][t],dp[i][j][k][t]+1);//不招聘
                               if(ma>=z) dp[i][ma-z][mb][t+1]=min(dp[i][ma-z][mb][t+1],dp[i][j][k][t]+1);//招聘
                           }else if(t<3){//招聘中
                               dp[i][ma][mb][t+1]=min(dp[i][ma][mb][t+1],dp[i][j][k][t]+1);//因在招聘中，只能干等下一天
                           }else if(t==3){//刚招聘到人员，人数多1，实际人数变成i+1
                               dp[i+1][ma][mb][0]=min(dp[i+1][ma][mb][0],dp[i][j][k][t]+1);//不招聘
                               if(ma>=z) dp[i+1][ma-z][mb][1]=min(dp[i+1][ma-z][mb][1],dp[i][j][k][t]+1);//此处写成if(ma>=z) dp[i+1][ma-z][mb][0]=min(dp[i+1][ma-z][mb][0],dp[i][j][k][t]+1)，想的时候，都考虑到了，不过没想到只写了i+1,而没写１;//招聘新人
                           }
                       }
                   }
   printf("%d\n",ans);
   return 0;
}

24.bzoj 1970 //1970: [Ahoi2005]Code 矿藏编码 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1970

//1970: [Ahoi2005]Code 矿藏编码
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1970
//样例竟然看不懂．
/*样例2021010210001理解如下
因整块存在山峰，平地，故存在(2)021010210001
第1区域是平地，存在2(0)21010210001；第４区域是山峰，存在202101021000(1)
第2区域存在山峰，平地，故存在20(2)(1010)210001   (2)要分为4个区域，(1010)具体细分的四个区域
第3区域存在山峰，平地，故存在2021010(2)(1000)1   (2)要分为4个区域，(1000)具体细分的四个区域
*/
//样例关于区间的划分，类似递归，该题，自己独立完成，估计要费些时间．
//比较容易判定的是输入数据只为０或１的情况
//https://www.cnblogs.com/y-clever/p/7645021.html代码写得比较精彩
//k=49,(2^49)^2=2^98=3.2*10^29,2^63 9.3*10^18long long 溢出，需采用高精度算法
//样例通过，提交Wrong_Answer.2019-8-16 18:13
//在(2^k)*(2^k)的理解上出了问题，一度理解为2^(k+1),其实是2^(2k)
//for(i=0;i<=k*2;i++){//此处写成for(i=0;i<=k;i++)
//for(i=k*2;i>=0;i--){//此处写成for(i=k+1;i>=0;i--)
//修改，提交AC.2019-8-16 18:34
#include
#include
#include
int k,a[105],b[50];//a[]存储二进制 b[]存储十进制
int read_int(){
   char c;
   while(!isdigit(c=getchar()));//非数字，陷在循环中，直到遇到数字，跳出
   return c-'0';
}
void dfs(int dep){
   int t=read_int();
   if(t==0)a[dep*2]++;
   else if(t==2)dfs(dep-1),dfs(dep-1),dfs(dep-1),dfs(dep-1);//读取，甚是巧妙
}
int main(){
   int i,j;
   memset(a,0,sizeof(a)),memset(b,0,sizeof(b)),b[0]=1;
   scanf("%d",&k);
   dfs(k);
   for(i=0;i<=k*2;i++){//此处写成for(i=0;i<=k;i++)
       a[i+1]+=a[i]/2;
       a[i]%=2;
   }
   for(i=k*2;i>=0;i--){//此处写成for(i=k+1;i>=0;i--)//将二进制a[]处理成十进制b[]
       for(j=1;j<=b[0];j++) b[j]*=2;
       if(a[i])b[1]++;//此处写成if(a[i]==0)b[1]++;，眼昏
       for(j=1;j<=b[0];j++){
           b[j+1]+=b[j]/10;
           b[j]%=10;
       }
       if(b[j])b[0]=j;
   }
   for(i=b[0];i>=1;i--)printf("%d",b[i]);//测试了a[]={1,0,0,0,0,0,0,0,0,0,0},a[]={1,1,1,1,1,1,1,1,1,1,1}的输出，发现没有问题
   printf("\n");
   return 0;
}

25.bzoj 2241 //2241: [SDOI2011]打地鼠 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2241

//2241: [SDOI2011]打地鼠
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2241
//样例解释如下，R*C=2*2，变化过程如下
/*
0次
1 2 1
2 4 2
1 2 1
1次
0 1 1
1 3 2
1 2 1
2次
0 0 0
1 2 1
1 2 1
3次
0 0 0
0 1 1
0 1 1
4次
0 0 0
0 0 0
0 0 0
*/
//摘自https://www.cnblogs.com/htwx/articles/4905842.html
//搜索+剪枝。。。。枚举i，j，易得敲击的顺序是固定的，先从边角开始敲，然后判断即可。。。。。
//http://hzwer.com/2288.html代码写得漂亮
//样例通过，提交AC．2019-8-17 9:28
#include
#include
int map[105][105],m,n,ans=1999999999,tmp[105][105],sum=0;
void solve(int r,int c){
   int i,j,p,q,t;
   memcpy(tmp,map,sizeof(tmp));
   for(i=1;i<=m;i++)//从角上开始打地鼠
       for(j=1;j<=n;j++)
           if(t=tmp[i][j]){
               if(i+r-1<=m&&j+c-1<=n)//此处写成if(t=tmp[i][j]&&i+r-1<=n&&j+c-1<=m)
                   for(p=0;p                        for(q=0;q                            tmp[i+p][j+q]-=t;
                           if(tmp[i+p][j+q]<0)return;
                       }
               else return;//漏了此行，此行确实精妙
           }
   ans=sum/(r*c);
}
int main(){
   int i,j;//sum地鼠数量
   scanf("%d%d",&m,&n);
   for(i=1;i<=m;i++)
       for(j=1;j<=n;j++)
           scanf("%d",&map[i][j]),sum+=map[i][j];
   for(i=m;i>=1;i--)//枚举锤子R*C
       for(j=n;j>=1;j--)
           if(sum%(i*j)==0&&sum/(i*j)                solve(i,j);
   printf("%d\n",ans);
   return 0;
}

二维差分详见https://blog.csdn.net/mrcrack/article/details/99701435

//http://blog.leanote.com/post/okami/bzoj2241-[SDOI2011]%E6%89%93%E5%9C%B0%E9%BC%A0二维差分代码，此文写得不错
//样例通过，提交Wrong_Answer.2019-8-18 09:20
//一查，将m,n位置写反了．
//修改提交AC.2019-8-18 9:25
#include
#include
int m,n,a[110][110],d[110][110],ans=1999999999,tot=0;
void solve(int r,int c){
   int delta,i,j;
   memset(d,0,sizeof(d));
   for(i=1;i<=m;i++)//此处写成for(i=1;i<=n;i++)
       for(j=1;j<=n;j++){//此处写成for(j=1;j<=m;j++){
           d[i][j]+=d[i][j-1]+d[i-1][j]-d[i-1][j-1];
           delta=a[i][j]-d[i][j];
           if(delta<0)return;
           if(delta==0)continue;//该过程可以行进到i==n,j==m
           if(i+r-1>m||j+c-1>n)return;//此处写成if(i+r-1>n||j+c-1>m)return;
           d[i][j]+=delta;
           d[i][j+c]-=delta;
           d[i+r][j]-=delta;
           d[i+r][j+c]+=delta;
       }
   ans=tot/(r*c);
}
int main(){
   int i,j;
   scanf("%d%d",&m,&n);
   for(i=1;i<=m;i++)
       for(j=1;j<=n;j++)
           scanf("%d",&a[i][j]),tot+=a[i][j];
   for(i=m;i>=1;i--)
       for(j=n;j>=1;j--)
           if(tot%(i*j)==0&&ans>tot/(i*j))
               solve(i,j);
   printf("%d\n",ans);
   return 0;
}

26.bzoj 1002 //1002: [FJOI2007]轮状病毒 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1002

//1002: [FJOI2007]轮状病毒
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1002
/*
n=1,输出1,画图可得
n=2,输出5,画图可得
n=3,输出16,题中例子,通过分类讨论的排列组合也可得
n=4,输出49,通过分类讨论的排列组合可得,不知正确与否
n=5,输出,暂时没有办法了,要讨论的情况多了许多，精力跟不上啊，也没有这个耐性，若能推导出公式，有兴趣，验证一下
*/
//看看，能不能通过n=1-4，找到规律
//能感觉到，随着ｎ增大，输出结果增大很快．long long估计不够用
//面对上述情况，尝试了好几次，找不到数学规律，感叹，数学储备还是不够，板凳深度不够啊 2019-8-18 17:41
//翻了翻AC代码，发现n=4,输出45,重复算了4组，分类讨论的排列组合思路正确，这一次比较接近结果．

//https://blog.csdn.net/jiangshibiao/article/details/22645557打表代码，此文写得真不赖
//打表思路：在所有边中，随机挑n条边，因有n+1个点．构成生成树．类枚举１－ｎ内的排列数
//以下为打表代码．2019-8-19 12:28
//部分输出为

#include
#include
#define maxn 110
struct node{
   int a,b;
}e[maxn*2];
int f[maxn],m,ans,vis[maxn],n;//m总边数 n点的最大序号
int getf(int u){//找爸爸
   return f[u]==u?u:f[u]=getf(f[u]);
}
void dfs(int step,int start){//step当前找到的有效边数，当前搜索的起始边的位置的前１位
   int i,j,tmp[maxn],f1,f2;
   if(step==n){
       ans++;
       return;
   }
   for(i=start+1;i<=m;i++){//i搜索边的位置
       f1=getf(e[i].a),f2=getf(e[i].b);
       if(f1==f2)continue;
       for(j=0;j<=n;j++)tmp[j]=f[j];
       f[f2]=f1;//左靠
       dfs(step+1,i);//此处错写成dfs(step+1,i+1);
       for(j=0;j<=n;j++)f[j]=tmp[j];
   }
}
int main(){
   int i;
   for(n=1;n<=15;n++){//此处写成for(n=1;n<=100;n++){程序一直停滞
       for(i=1;i        e[n]=(node){n,1};//此处写成e[n]=node{n,1};//圆弧连线
       for(i=n+1;i<=n*2;i++)e[i]=(node){0,i-n};//中心到圈上的连线
       m=2*n;//总边数，n段圆弧，n段直线
       for(i=0;i<=n;i++)f[i]=i;//并查集
       ans=0;
       dfs(0,0);
       printf("%d ",ans);
   }
   return 0;
}

/*
1 5 16 45 121 320 841 2205 5776 15125 39601 103680 271441 710645 1860496
奇数项
1     3        5           7           9          11             13               15
1     16      121       841       5776     39601       271441      1860496
1*1 4*4   11*11   29*29   76*76   199*199   521*521     1364*1364
1      4        11        29          76         199          521              1364

偶数项
2           4           6              8               10               12                14
5           45         320          2205         15125         103680        710645
5*1       5*9       5*64        5*441       5*3025       5*20736      5*142129
5*1*1   5*3*3   5*8*8      5*21*21   5*55*55     5*144*144 5*377*377
1           3           8              21             55               144               377
*/

//想到的也就上面数据的层次，已实属不宜，还要想得更深远，请看https://blog.csdn.net/jiangshibiao/article/details/22645557

//上述猜想，只涉及高精度加即可，编写的过程中，发现，还涉及高精度乘，高精度乘低精度，白高兴一场
//在有限的数据里测试通过，提交AC．2019-8-19 17:37
//感觉代码编得有些生硬，还是要看看他人代码．
//翻看了一下，在区分奇偶数的算法限制下，代码还算写得漂亮，那就呈现出来．
#include
#include
#define maxn 100
int X[maxn],Y[maxn];
void add(){//x    int i,z[maxn];
   memset(z,0,sizeof(z)),z[0]=Y[0];
   for(i=1;i<=Y[0];i++){
       z[i]+=X[i]+Y[i];//此处错写成z[i]=y[i]+x[i];
       z[i+1]+=z[i]/10;
       z[i]%=10;
   }
   if(z[z[0]+1])z[0]+=1;
   memcpy(X,Y,sizeof(X)),memcpy(Y,z,sizeof(Y));
}
void mul(){//平方
   int i,j,z[maxn];
   memset(z,0,sizeof(z));
   for(i=1;i<=Y[0];i++)
       for(j=1;j<=Y[0];j++){
           z[i+j-1]+=Y[i]*Y[j];
           z[i+j]+=z[i+j-1]/10;
           z[i+j-1]%=10;
       }
   z[0]=Y[0]+Y[0];
   while(!z[z[0]])z[0]--;
   memcpy(Y,z,sizeof(Y));
}
void mul2(){//*5
   int i,z[maxn];
   memset(z,0,sizeof(z));
   for(i=1;i<=Y[0];i++){
       z[i]+=Y[i]*5;
       z[i+1]+=z[i]/10;
       z[i]%=10;
   }
   z[0]=Y[0]+1;
   while(!z[z[0]])z[0]--;
   memcpy(Y,z,sizeof(Y));
}
int main(){
   int n,i,m;
   scanf("%d",&n);
   memset(X,0,sizeof(X)),memset(Y,0,sizeof(Y));
   if(n==1){
       printf("1\n");
       return 0;
   }else if(n==2){
       printf("5\n");
       return 0;
   }
   else if(n%2){//奇数
       m=n,X[0]=1,X[1]=1,Y[0]=1,Y[1]=3;
   }else{//偶数
       m=n-1,X[0]=1,X[1]=1,Y[0]=1,Y[1]=2;
   }
   for(i=3;i<=m;i++)add();
   mul();
   if(n%2==0)mul2();
   for(i=Y[0];i>=1;i--)printf("%d",Y[i]);
   printf("\n");
   return 0;
}

//打表算法之后，还要掌握正解，不能就这么放过．
//http://ruanx.pw/post/Matrix-Tree.html Matrix-Tree定理此文介绍得不错2019-8-19 22:04
//https://wenku.baidu.com/view/ba835975f80f76c66137ee06eff9aef8941e488d.html 周冬的ppt 2019-8-20 7:40

27.bzoj 1024 //1024: [SCOI2009]生日快乐 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1024

//1024: [SCOI2009]生日快乐
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1024
//样例解释如下

//有个疑问，长边与短边的比值的最大值最小，长边是指所有边中最长边吗，短边是指所有边中最短边吗
//感觉要考虑的东西挺多，而且思考过程涉递归
//1 <= N <= 10递归用得上
//浮点数，故最后每块蛋糕面积相同
//从各种题解看来，长边与短边的比值的最大值最小，长边与短边归属于同一块蛋糕，看来题意还是要详细说清．
//https://blog.csdn.net/qq_41357771/article/details/79006028此文思路不错，代码也注释得很好，摘抄如下

这题第一眼看上去就是DP，可是我们会发现N很小，所以完全可以DFS求解。因为我们要切出相等的面积，所以就可以枚举当前切一刀，左边将被切成i块，右边将被切成N-i块（相应的左边的x或y变成x/N*i或y/N*i，右边x或y变成N-x/N*i或N-y/N*i），然后，最后可以保证切出的面积相等。
然后。。。
就解完了。

//样例通过，提交AC.2019-8-20 17:08
//递归真是很神奇，平时要多想想，数据流向．
#include
double max(double a,double b){
   return a>b?a:b;
}
double min(double a,double b){
   return a }
double dfs(double x,double y,int n){//对应边长分别为x,y的蛋糕，分为n块
   int i;
   double ans=1e100,ans1,ans2;
   if(n==1){//当前已不可分割
       if(x        else return x/y;
   }
   for(i=1;i<=n/2;i++){
       ans1=max(dfs(x,y*i/n,i),dfs(x,y-y*i/n,n-i));//平行于x切，一部分分为i块，另一部分只能分为n-i块
       ans2=max(dfs(x*i/n,y,i),dfs(x-x*i/n,y,n-i));//平行于y切，一部分分为i块，另一部分只能分为n-i块
       ans=min(ans,ans1);
       ans=min(ans,ans2);
   }
   return ans;
}
int main(){
   int n;
   double x,y;
   scanf("%lf%lf%d",&x,&y,&n);
   printf("%.6lf\n",dfs(x,y,n));
   return 0;
}

28.bzoj 1054 //1054: [HAOI2008]移动玩具 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1054

//1054: [HAOI2008]移动玩具
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1054
//挺神奇的一道题，以往是１个玩具在动，该题是多个玩具可动．
//样例好理解，问题就怕，在移动过程中，遇到阻挡，如何处理
//发现，此处有上述问题的解决https://www.luogu.org/problemnew/solution/P4289?page=5 作者: wyj123456 更新时间: 2019-06-06 19:19
/*
另外，我们还要知道一个事实，就是一个玩具移到一个有玩具的位置，就可以直接穿过去
因为 i 号想移动到 j 号，途中遇到 k 号，i 号就可以留在 k 号位置，然后 k 号帮 i 号接着走，等同于 i 号穿过 k 号，所以，变化前与变化后都有玩具的地方可以忽略，不会阻碍到其他玩具
*/
//https://blog.csdn.net/Hanks_o/article/details/79428720此文代码够短
//2^16=65536种情况，开数组d[]存储每种状态离初始状态的步数
//nr=i+next[k][0],nc=j+next[k][1];//此处错写成nr=i+next[i][0],nc=j+next[i][1];，昏了
//样例通过，提交AC.2019-8-21 17:20
//状压＋BFS
#include
#include
#define maxn 70000
int d[maxn],vis[maxn],next[][2]={{-1,0},{1,0},{0,-1},{0,1}},start,end,q[maxn],h,t,n;//上下左右
char str[6][6];
struct node{
   char str[6][6];
}list[maxn];
int str2int(char s[6][6]){//将4*4的字符转化为16位二进制数    状压
   int i,j,a=0;
   for(i=1;i<=4;i++)
       for(j=1;j<=4;j++)
           a*=2,a+=s[i][j]-'0';
   return a;
}
void swap(char *a,char *b){
   char t;
   t=*a,*a=*b,*b=t;
}
void bfs(int st){
   int i,j,r,c,nr,nc,pos,x,y,k;
   memset(d,127,sizeof(d)),memset(vis,0,sizeof(vis)),d[start]=0;//初始化为最大值.
   h=t=1,q[t]=1,t++,vis[st]=1;
   while(h        pos=q[h],x=str2int(list[pos].str);
       for(i=1;i<=4;i++)
           for(j=1;j<=4;j++){
               if(list[pos].str[i][j]=='0') continue;
               for(k=0;k<4;k++){
                   nr=i+next[k][0],nc=j+next[k][1];//此处错写成nr=i+next[i][0],nc=j+next[i][1];，昏了
                   if(nr<1||nr>4||nc<1||nc>4||list[pos].str[nr][nc]=='1') continue;
                   swap(&list[pos].str[i][j],&list[pos].str[nr][nc]),y=str2int(list[pos].str);
                   if(d[y]>=d[x]+1){
                       d[y]=d[x]+1;
                       if(!vis[y])vis[y]=1,n++,memcpy(list[n].str,list[pos].str,sizeof(list[n].str)),q[t]=n,t++;
                   }
                   swap(&list[pos].str[nr][nc],&list[pos].str[i][j]);//回溯
               }
           }
       h++;
   }
}
int main(){
   int i,j;
   for(i=1;i<=4;i++)scanf("%s",str[i]+1);
   start=str2int(str),memcpy(list[1].str,str,sizeof(list[1].str)),n=1;
   for(i=1;i<=4;i++)scanf("%s",str[i]+1);
   end=str2int(str);
   bfs(start);
   printf("%d\n",d[end]);
}

29.bzoj 1059 //1059: [ZJOI2007]矩阵游戏 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1059

//1059: [ZJOI2007]矩阵游戏
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1059
//题意清晰，样例好懂
//该题难点在于限制多，因其可整行或正列移动．
//http://blog.sina.com.cn/s/blog_9aa2786a01012107.html此文思路不错，摘抄如下
//如果某一行无法找到与之相匹配的列，说明无论怎么移动列，都不可能使这一行有1。而移到行则更不可能了。
//https://blog.csdn.net/dark_scope/article/details/8880547二分图算法，此文介绍得相当棒
//样例通过，提交AC.2019-8-21 21:04
//二分图的算法掌握，终归还是要多想想，主动权在男子．
#include
#include
#define maxn 210
int map[maxn][maxn],used[maxn],link[maxn],n;
int find(int x){//x男
   int i;
   for(i=1;i<=n;i++){//i女
       if(map[x][i]&&!used[i]){//used[i]=1该轮选择中，已陪好对，不可更改．相中与已配好对的优先级最高
           used[i]=1;
           if(!link[i]||find(link[i])){//男占据主动，让配好对的男子重新选择
               link[i]=x;
               return 1;
           }
       }
   }
   return 0;
}
void solve(){
   int i;
   for(i=1;i<=n;i++){
       memset(used,0,sizeof(used));
       if(!find(i)){
           printf("No\n");
           return;//此处return用得舒服
       }
   }
   printf("Yes\n");
}
int main(){
   int t,i,j;
   scanf("%d",&t);
   while(t--){
       memset(link,0,sizeof(link));
       scanf("%d",&n);
       for(i=1;i<=n;i++)
           for(j=1;j<=n;j++)
               scanf("%d",&map[i][j]);
       solve();
   }
   return 0;
}

30.bzoj 1191 //1191: [HNOI2006]超级英雄Hero //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1191

//1191: [HNOI2006]超级英雄Hero
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1191
//比较明显的二分图
//样例通过，提交Wrong_Answer.2019-8-21 21:48
//if(!link[i]||find(link[i])){//此处错写成if(!link[i]||!find(link[i])){昏了
//修改，提交Wrong_Answer.2019-8-21 21:54
//memset(used,0,sizeof(used));//写错位置，将该行写在for循环之外2019-8-21 22:04
//该题有个潜在的难点，就是问题，妙计的序号是０，那么就会与二分模板算法起冲突
//故，要想方设法让问题，妙计的序号从１开始．2019-8-21 22:12
//大篇幅修改后，提交AC.2019-8-21 22:15
#include
#include
#define maxn 1010
int n,m,map[maxn][maxn],link[maxn],used[maxn],cnt=0;
int find(int x){//x男
   int i;
   for(i=1;i<=n;i++)//此处错写成for(i=0;i        if(map[x][i]&&!used[i]){
           used[i]=1;
           if(!link[i]||find(link[i])){//此处错写成if(!link[i]||!find(link[i])){昏了
               link[i]=x;
               return 1;
           }
       }
   return 0;
}
void solve(){
   int i;
   for(i=1;i<=m;i++){//此处错写成for(i=0;i        memset(used,0,sizeof(used));//写错位置，将该行写在for循环之外
       if(!find(i))break;
       else cnt++;
   }
}
int main(){
   int i,x,y;
   memset(map,0,sizeof(map)),memset(link,0,sizeof(link));
   scanf("%d%d",&n,&m);
   for(i=1;i<=m;i++)scanf("%d%d",&x,&y),map[i][++x]=map[i][++y]=1;//此处错写成for(i=0;i    solve();
   printf("%d\n",cnt);
   return 0;
}

31.bzoj 1260 //1260: [CQOI2007]涂色paint //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1260

//1260: [CQOI2007]涂色paint
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1260
//题意清晰，样例好懂．
//此文https://www.luogu.org/problemnew/solution/P4170?page=2 作者: 哈哈哈哈？？更新时间: 2019-07-18 21:28思路清晰，摘抄如下
/*
要求的是最少的染色次数，求什么设什么
dp[l][r]表示涂完区间【l,r】的所需最少次数
从小到大枚举区间【l,r】
一：如果【l,r】两端颜色相同那么在涂【l+1,r】时多涂一个就好
或者在涂【l,r-1】时多涂一个
同时考虑【l+1,r-1】对【l,r】的影响
二:
如果【l,r】两端颜色不相同,走正常的区间合并即可
三：如果l==r 涂色次数为一
*/
//样例通过，提交Wrong_Answer．2018-8-22 12:31
//排查了代码，发现还是在区间dp的理解上出了问题，应该是从区间间隔为0,1,2,3,......,n-1进行动归．
//样例通过，提交AC.2019-8-22 14:48
#include
#include
#define maxn 55
char str[maxn];
int f[maxn][maxn];
int min(int a,int b){
   return a }
int main(){
   int i,j,n,k,L;
   memset(f,127,sizeof(f));
   scanf("%s",str+1);
   n=strlen(str+1);
   for(i=1;i<=n;i++)f[i][i]=1;
   for(L=1;L        for(i=1;i+L<=n;i++){//此处错写成for(j=i+1;j<=n;j++){
           j=i+L;
           if(str[i]==str[j])f[i][j]=min(f[i+1][j],f[i][j-1]);
           else
               for(k=i;k        }
   printf("%d\n",f[1][n]);
   return 0;
}

32.bzoj 1263 //1263: [SCOI2006]整数划分 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1263

//1263: [SCOI2006]整数划分
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1263
// 第2行输出最大乘积的前100位,题意比较明确，需要高精度算法
//乘积最大位数如何确定
//此文https://blog.csdn.net/PoPoQQQ/article/details/43602567思路不错，摘抄如下，有修改
/*
结论：
如果n是3的倍数那么将n划分成n/3个3是最优的
如果n是3的倍数+1 那么将n划分成(n-4)/3个3和两个2是最优的
如果n是3的倍数+2 那么将n划分成(n-2)/3个3和1个2是最优的
证明是有的
考虑不是划分成整数，而是划分成任意实数
设我们将n划分成了x个正实数之和
易知当这x个数相等时答案是最优的
那么每个数都是n/x，答案是(n/x)^x
设y=(n/x)^x
则有lny=x[ln(n)-ln(x)]
两侧求导可得y'=(n/x)^x * ( ln(n) - ln(x) - 1 )

补充求导过程：
(lny)'=(x(ln(n)-ln(x)))'
y'/y=(x)'(ln(n)-ln(x))+x(ln(n)-ln(x))'
y'/y=ln(n)-ln(x)+x(0-1/x)
y'/y=ln(n)-ln(x)-1
带入y=(n/x)^x
y'=(n/x)^x * ( ln(n) - ln(x) - 1 )

当x=n/e时y‘取0 此时乘积最大

补充：
y'=(n/x)^x * ( ln(n) - ln(x) - 1 )=0 导数为0，出现极值
即
ln(n)-ln(x)-1=0
ln(n)-ln(x)-ln(e)=0
ln(n)-ln(e)-ln(x)=0
ln(n/e)-ln(x)=0
ln(n/e)=ln(x)
x=n/e

因此每个数要尽量靠近e才能使答案最大
现在考虑整数离e最近的整数是3 因此要把n尽量分成3 不足的用2补齐这样可以保证是最优的。
*/
//此文https://blog.csdn.net/PoPoQQQ/article/details/43602567代码也写得优秀
//有了上述算法，该题编起来就简单了，高精度＊低精度
//担心超时，测试了31000
//1s能完成
//样例通过，提交Wrong_Answer.
//重新读题，发现＂第2行输出最大乘积的前100位＂，会错意了，第２行输出有问题
//修改，提交AC.2019-8-22 16:48
#include
#include
#define maxn 5100
int ans[maxn];
void mul(int x){
   int i;
   for(i=1;i<=ans[0];i++)ans[i]*=x;
   for(i=1;i<=ans[0];i++)ans[i+1]+=ans[i]/10,ans[i]%=10;
   if(ans[i])ans[0]=i;
}
int main(){
   int n,i;
   memset(ans,0,sizeof(ans));
   scanf("%d",&n);
   ans[1]=1,ans[0]=1;//ans[0]储存数据长度
   switch(n%3){//10≤n≤31000
       case 0:
           for(i=3;i<=n;i+=3)mul(3);//n=3,6,9,12可以尝试得出for的循环规律
           break;
       case 1:
           for(i=7;i<=n;i+=3)mul(3);//n=4,7,10可以尝试得出for的循环规律
           mul(4);
           break;
       case 2:
           for(i=5;i<=n;i+=3)mul(3);//n=2,5,8,11可以尝试得出for的循环规律
           mul(2);
           break;
   }
   printf("%d\n",ans[0]);
   if(ans[0]<=100)
       for(i=ans[0];i>=1;i--)printf("%d",ans[i]);
   else
       for(i=ans[0];i>ans[0]-100;i--)printf("%d",ans[i]);
   printf("\n");
   return 0;
}

33.bzoj 1816 //1816: [Cqoi2010]扑克牌 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1816

//1816: [Cqoi2010]扑克牌
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1816
//题意叙述不清，好在样例有解释，题意也算弄明白了
//ci < = 500,000,000常规算法显然无能为力
//如n=5,套牌是指{1,2,3,4,5},这一点，题意不是很明确．
//大致的思路有了，就是难以形成有效算法
//https://blog.csdn.net/qq_36038511/article/details/79600866此文代码注释写得特别好
//https://www.cnblogs.com/NaVi-Awson/p/7641892.html此文代码写得不错
/*
该题的核心是，二分套牌数目，
计算出所需的 joker的个数，算出的所需的 joker的个数需小于等于提供的 joker的个数
因每副套牌只能用１个joker，故算出的所需的 joker的个数需小于等于二分中的套牌数目
*/
//二分的判定过程，还是比较难想的．2019-8-23 8:29
//计算过程中,int容易溢出，不过，程序编得好，还是可以不涉及long long
//样例通过，提交Wrong_Answer.2019-8-13 8:42
//想了想，存在套牌数目==0的情况，代码确实出了问题
/*
提供如下测试数据
3 0
0 2 3
输出为
0
*/
//left=0,right=m+1;//此处错写成left=1,right=m+1;
//修改，提交Wrong_Answer.2019-8-23 8:47
//仔细想想，还是处理过程中，存在误解，方案数可以大于提供的 joker的个数，之前误以为是小于等于的关系
//0 < = m, ci < = 500,000,000，故最大方案数是500,000,000
//left=0,right=500000000+1;//此处错写成left=0,right=m+1;
//修改，提交Wrong_Answer.2019-8-23 9:04
//left=0,right=520000000;//left=0,right=500000000+1;
//将right=510000000提交Wrong_Answer
//将right=520000000提交AC
//不得不说后台的测试数据有误，因0 < = m, ci < = 500,000,000，故最大方案数之可能是500,000,000
//测试完毕，收工，以下为AC代码，收获是，数据还是要比条件提供的大许多，防止后台数据有误．2019-8-23 9:24
#include
int n,m,c[55];
int judge(int x){//x指当前的套牌数目
   int i,tot=0;//tot指需要补的joker数量
   for(i=1;i<=n;i++)//选择不用那一种
       if(x>c[i]){
           tot+=x-c[i];//x>c[i]指当前i位置的牌数量不足，需要joker来补
           if(tot>m||tot>x)return 0;//在此判断的好处是可以回避long long//最多有m个joker，tot不能超越;因１套牌，最多只能用１个joker，故，用的joker数量必须小于等于套牌数目
       }
   return 1;
}
void bitsection(){
   int left,right,mid;
   left=0,right=520000000;//left=0,right=500000000+1;//此处错写成left=0,right=m+1;//此处错写成left=1,right=m+1;//right=m+1目的是使答案落在left，若无法理解，请拿出纸笔进行模拟
   while(left+1        mid=(left+right)/2;
       if(judge(mid)) left=mid;
       else right=mid;
   }
   printf("%d\n",left);
}
int main(){
   int i;
   scanf("%d%d",&n,&m);
   for(i=1;i<=n;i++)scanf("%d",&c[i]);
   bitsection();
   return 0;
}

34.bzoj 1854 //1854: [Scoi2010]游戏 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1854

//1854: [Scoi2010]游戏
//在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1854

//从未接触过二分图的可看此文入门https://blog.csdn.net/dark_scope/article/details/8880547二分图算法，此文介绍得相当棒
//二分图https://www.luogu.org/problemnew/solution/P1640?page=3此文介绍不错，照抄如下
/*
建模很巧妙，我们可以以属性为左端点（属性值≤n\le n≤n），装备为右端点做二分图匹配。以样例为例，是这样的。
3
1 2
3 2
4 5

显然，4,5不可能被使用，所以略去。
然后从1到n，按属性值匹配，这里匹配的意义已经很明显了。当属性i无法匹配时，输出i−1
*/
//样例通过，提交Wrong_Answer.2019-8-23 16:24
//int head[10100],cnt=0,n,used[1000010],link[1000010];//此处写成int head[10100],cnt=0,n,used[10100],link[1000010];
//used针对的是女而非男．这次印象深刻了．
//修改，提交Time_Limit_Exceed．这下放心了，二分图的算法没有问题，可以开始优化了．2019-8-23 17:11
//以下为二分图的无优化算法，提交Time_Limit_Exceed．但值得读者参考，提供给大家．
#include
#include
int head[10100],cnt=0,n,used[1000010],link[1000010];//此处写成int head[10100],cnt=0,n,used[10100],link[1000010];
struct node{
   int to,next;//to连线的节点,next下一条边
}e[1000010*2];
void add_edge(int u,int v){//邻接表
   cnt++,e[cnt].to=v,e[cnt].next=head[u],head[u]=cnt;
}
int max(int a,int b){
   return a>b?a:b;
}
int find(int x){
   int b,v;
   b=head[x];
   while(b){
       v=e[b].to;
       if(!used[v]){
           used[v]=1;
           if(!link[v]||find(link[v])){
               link[v]=x;//v girl x boy
               return 1;
           }
       }
       b=e[b].next;
   }
   return 0;
}
int main(){
   int i,a,b,m=0;
   memset(head,0,sizeof(head)),memset(link,0,sizeof(link));
   scanf("%d",&n);
   for(i=1;i<=n;i++)scanf("%d%d",&a,&b),m=max(m,max(a,b)),add_edge(a,i),add_edge(b,i);
   for(i=1;i<=m;i++){
       memset(used,0,sizeof(used));
       if(!find(i))break;
   }
   printf("%d\n",i-1);
   return 0;
}

//通过此文https://blog.csdn.net/wzq_QwQ/article/details/48706075代码，直接看懂时间戳优化．
//其实与memset殊途同归，只是时间戳优化，时间复杂度是O(1),memset时间复杂度是O(n),确实神奇．2019-8-23 17:47
//样例通过，提交AC.2019-8-23 17:50
//摘自https://www.cnblogs.com/orzzz/p/7132766.html
/*
时间戳优化？？！
开始以为dfs的时间戳。。。结果发现是第几次执行的时间戳。
因为每次要memset一下vis数组，浪费了大量时间。时间戳巧妙地O(1)解决了这个问题。
初始化零？我只要让你数组里不管是谁都失效就好了。所以vis数组用int来存，第几次执行匈牙利算法内层的循环时间戳就是几。设它为T。vis!=T的，和原来vis=0是等效的，即未遍历过，vis=T的，和原来vis=1是等效的，即已遍历过。每当dfs到下一个点。让这个点的vis=T。所以都不用说O(1)，根本就是一个T++就解决了。
真的，时间戳大法真的666。只要是类似的memset问题，都可以这么解决，并不限于匈牙利算法。
*/
//以下为二分图，时间戳，优化，代码．
#include
#include
int head[10100],cnt=0,n,used[1000010],link[1000010],nowtime=0;//此处写成int head[10100],cnt=0,n,used[10100],link[1000010];
struct node{
   int to,next;//to连线的节点,next下一条边
}e[1000010*2];
void add_edge(int u,int v){//邻接表
   cnt++,e[cnt].to=v,e[cnt].next=head[u],head[u]=cnt;
}
int max(int a,int b){
   return a>b?a:b;
}
int find(int x){
   int b,v;
   b=head[x];
   while(b){
       v=e[b].to;
       if(used[v]!=nowtime){//时间戳优化，确实挺神
           used[v]=nowtime;
           if(!link[v]||find(link[v])){
               link[v]=x;//v girl x boy
               return 1;
           }
       }
       b=e[b].next;
   }
   return 0;
}
int main(){
   int i,a,b,m=0;
   memset(head,0,sizeof(head)),memset(link,0,sizeof(link)),memset(used,0,sizeof(used));;
   scanf("%d",&n);
   for(i=1;i<=n;i++)scanf("%d%d",&a,&b),m=max(m,max(a,b)),add_edge(a,i),add_edge(b,i);
   for(i=1;i<=m;i++){
       nowtime++;
       if(!find(i))break;
   }
   printf("%d\n",i-1);
   return 0;
}

//并查集，摘自https://www.cnblogs.com/BLADEVIL/p/3474189.html
/*
我们可以把一件装备看成一条边，两个属性看成两个点，那么这就相当于读入了一张图
当读入每一个x,y时，我们找到两个点的祖先节点，fx,fy，我们保证祖先节点在该连通块
中编号（装备属性）最大，用flag数组记录能否过第I关，那么两种情况

fx=fy(即fx==fy)
这种情况就是加入这条边之后，图中成了一个环（可能这个环之前就存在），那么对于
一个环，假设是1-x节点的环，我们肯定可以全选择（题目中的选择），之前假设是一颗树
的话，X个节点，我们可以选择x-1个，也就是只有一个点选不了，我们肯定让最大的
点没法选，所以除了祖先以外应该全都是true，那么加上这条边之后，祖先也可以选了，所以
将祖先也就是flag[fx]设成true

fx<>fy(即fx!=fy)
这种情况就是一条边连接两个连通分量，先假设两个连通分量都是树，那么我们这个新的连通分量也是
一颗树，对于这种情况，我们可以多选择一个没选过的点，也就是在fx,fy中选编号小的设成true，那么如果
两个环的话，这条边就没用了，之前已经可以全选了，那一个环一个树的情况，使fx 选择一个，那么应该选编号小的，但是如果编号小的已经可以选了（就是在环了），我们就应该将fy设成true，这点
应该注意，网上有的标程没判断这个，也A了，只能说数据弱。。。
*/
/*
提供一组数据，测试并查集编写得是否正确
输入
2
1 45
2 100
输出
1
*/
//此文代码写得不错https://blog.csdn.net/qq_38678604/article/details/78570183
//样例通过，提交AC.2019-8-24 18:06
//以下代码为并查集代码，不得不说，该题的并查集在处理具体细节时，难度还是挺大的，就难度而言，并查集较难
#include
#include
#define maxm 10010
int f[maxm],vis[maxm];
int getf(int u){
   return f[u]==u?u:f[u]=getf(f[u]);
}
int max(int a,int b){
   return a>b?a:b;
}
int main(){
   int u,v,f1,f2,i,n,t,m=0;
   memset(vis,0,sizeof(vis));
   scanf("%d",&n);
   for(i=1;i<=10001;i++)f[i]=i;//漏了此行
   for(i=1;i<=n;i++){
       scanf("%d%d",&u,&v),m=max(m,max(u,v));
       f1=getf(u),f2=getf(v);
       if(f1!=f2){
           if(f1>f2)t=f1,f1=f2,f2=t;//目标f1            if(vis[f1])vis[f2]=1;
           vis[f1]=1,f[f1]=f2;
       }else vis[f1]=1;//f1==f2
   }
   for(i=1;i<=m+1;i++)
       if(!vis[i]){
           printf("%d\n",i-1);
           break;
       }
   return 0;
}

35.bzoj 1967 //1967: [Ahoi2005]CROSS 穿越磁场 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1967

题解详见https://blog.csdn.net/mrcrack/article/details/100106496

36.bzoj 3505 //3505: [Cqoi2014]数三角形 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=3505

题解详见https://blog.csdn.net/mrcrack/article/details/100159123

37.bzoj 4247 //4247: 挂饰 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=4247

题解详见https://blog.csdn.net/mrcrack/article/details/100175533

38.bzoj 1206 //1206: [HNOI2005]虚拟内存 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1206

题解详见https://blog.csdn.net/mrcrack/article/details/100520972

39.bzoj 1296 //1296: [SCOI2009]粉刷匠 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1296

题解详见https://blog.csdn.net/mrcrack/article/details/100771310

40.bzoj 1485 //1485: [HNOI2009]有趣的数列 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1485

题解详见https://blog.csdn.net/mrcrack/article/details/100846675

41.bzoj 1856 //1856: [Scoi2010]字符串 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1856

题解详见https://blog.csdn.net/mrcrack/article/details/100929075

42.bzoj 2457 //2457: [BeiJing2011]双端队列 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2457

题解详见https://blog.csdn.net/mrcrack/article/details/101052107

43.bzoj 2467 //2467: [中山市选2010]生成树 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2467

题解详见https://blog.csdn.net/mrcrack/article/details/101144174

44.bzoj 2764 //2764: [JLOI2011]基因补全 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2764

题解详见https://blog.csdn.net/mrcrack/article/details/101276099

45.

bzoj 1045 //1045:[HAOI2008] 糖果传递 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1045

bzoj 3293 //3293: [Cqoi2011]分金币 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=3293

题解详见https://blog.csdn.net/mrcrack/article/details/101387446

46.bzoj 1013 //1013: [JSOI2008]球形空间产生器sphere //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1013

题解详见https://blog.csdn.net/mrcrack/article/details/101427379

47.bzoj 1025 //1025:[SCOI2009]游戏 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1025

题解详见https://blog.csdn.net/mrcrack/article/details/101543589

48.bzoj 1078 //1078:[SCOI2008]斜堆 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1078

题解详见https://blog.csdn.net/mrcrack/article/details/101828789

49.bzoj 1265 //1265: [AHOI2006]斐波卡契的兔子（kacci） //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1265

题解详见https://blog.csdn.net/mrcrack/article/details/102720717

50.bzoj 1433 //1433:[ZJOI2009]假期的宿舍 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1433

题解详见https://blog.csdn.net/mrcrack/article/details/101940840

51.bzoj 1505 //1505:[NOI2004]小H的小屋 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1505

题解详见https://blog.csdn.net/mrcrack/article/details/101990491

52.bzoj 2048 //2048: [2009国家集训队]书堆 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2048

题解详见https://blog.csdn.net/mrcrack/article/details/102131189

53.bzoj 2156 //2156: 星际探险 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2156

//题目有误，这题在bzoj上的样例输入被吞了一个回车，所以请注意p=3。
/*
3 3
0 1 1
1 2 2
0 2 1
3
0 1 2
*/

题解详见https://blog.csdn.net/mrcrack/article/details/102763610

54.bzoj 3108 //3108: [cqoi2013]图的逆变换 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=3108

题解详见https://blog.csdn.net/mrcrack/article/details/102157743

55.bzoj 3214 //3214:[ZJOI2013]丽洁体 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=3214

题解详见https://blog.csdn.net/mrcrack/article/details/102330197

56.bzoj 3668 //3668:[NOI2014]起床困难综合症 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=3668

题解详见https://blog.csdn.net/mrcrack/article/details/102391638

57.bzoj 4195 //4195:[NOI2015]程序自动分析难点不是离散化+并查集 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=4195

题解详见https://blog.csdn.net/mrcrack/article/details/102492317

58.bzoj 1019 //1019:[SHOI2008]汉诺塔 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1019

题解详见https://blog.csdn.net/mrcrack/article/details/102516994

59.bzoj 1055 //1055:[HAOI2008]玩具取名 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1055

题解详见https://blog.csdn.net/mrcrack/article/details/102569892

60.bzoj 1452 //1452:[JSOI2009] Count //[JSOI2009]计数问题 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1452

题解详见https://blog.csdn.net/mrcrack/article/details/102589671

61.bzoj 1509 //1509:[NOI2003]逃学的小孩 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1509

题解详见https://blog.csdn.net/mrcrack/article/details/102611118

62.bzoj 1867 //1867: [Noi1999]钉子和小球 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1867

题解详见https://blog.csdn.net/mrcrack/article/details/102768596

63.bzoj 1965 //1965:[Ahoi2005] SHUFFLE 洗牌 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1965

题解详见https://blog.csdn.net/mrcrack/article/details/102686031

64.bzoj 2435 //2435:[NOI2011]道路修建 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2435

题解详见https://blog.csdn.net/mrcrack/article/details/102702978

65.bzoj 2705 //2705: [SDOI2012]Longge的问题 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2705

题解详见https://blog.csdn.net/mrcrack/article/details/102770004

66.bzoj 2783 //2783: [JLOI2012]树 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2783

题解详见https://blog.csdn.net/mrcrack/article/details/102771315

67.bzoj 3210 //3210: 花神的浇花集会 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=3210

题解详见https://blog.csdn.net/mrcrack/article/details/102826952

68.bzoj 1015 //1015: [JSOI2008]星球大战starwar //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1015

题解详见https://blog.csdn.net/mrcrack/article/details/102842100

69.bzoj 1036 //1036: [ZJOI2008]树的统计Count //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1036

题解详见https://blog.csdn.net/mrcrack/article/details/102886819

70.bzoj 1047 //1047: [HAOI2007]理想的正方形 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1047

题解详见https://blog.csdn.net/mrcrack/article/details/102887883

71.bzoj 1084 //1084: [SCOI2005]最大子矩阵 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1084

题解详见https://blog.csdn.net/mrcrack/article/details/102909049

72.bzoj 1213 //1213: [HNOI2004]高精度开根 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1213

题解详见https://blog.csdn.net/mrcrack/article/details/102920108

73.bzoj 3106 //3106: [cqoi2013]棋盘游戏 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=3106

题解详见https://blog.csdn.net/mrcrack/article/details/102950775

74.bzoj 3142 //3142: [Hnoi2013]数列 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=3142

题解详见https://blog.csdn.net/mrcrack/article/details/102963173

75.bzoj 3613 //3613: [Heoi2014]南园满地堆轻絮 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=3613

题解详见https://blog.csdn.net/mrcrack/article/details/102990302

76.bzoj 1026 //1026: [SCOI2009]windy数 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1026

题解详见https://blog.csdn.net/mrcrack/article/details/103001816

77.bzoj 1079 //1079: [SCOI2008]着色方案 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1079

题解详见https://blog.csdn.net/mrcrack/article/details/103038788

说明，编写的程序，测试样例时，输出为

洛谷AC,bzoj WA.

测试样例时，输出为

洛谷AC,bzoj AC.

题解详见https://blog.csdn.net/mrcrack/article/details/103071194

79.bzoj 1293 //1293: [SCOI2009]生日礼物 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1293

题解详见https://blog.csdn.net/mrcrack/article/details/103104322

80.bzoj 1407 //1407: [Noi2002]Savage //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1407
//在线测评地址https://www.luogu.org/problem/P2421

题解详见https://blog.csdn.net/mrcrack/article/details/103110930

81.bzoj 1588 //1588: [HNOI2002]营业额统计 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1588
//在线测评地址https://www.luogu.org/problem/P2234

题解详见https://blog.csdn.net/mrcrack/article/details/103112853

82.bzoj 1811 //1811: [Ioi2005]mea //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1811

题解详见https://blog.csdn.net/mrcrack/article/details/103349734

83.bzoj 1879 //1879: [Sdoi2009]Bill的挑战 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=1879
//在线测评地址https://www.luogu.com.cn/problem/P2167

题解详见https://blog.csdn.net/mrcrack/article/details/103372312

84.bzoj 2190 //2190: [SDOI2008]仪仗队 //在线测评地址https://www.lydsy.com/JudgeOnline/problem.php?id=2190
//在线测评地址https://www.luogu.com.cn/problem/P2158

题解详见https://blog.csdn.net/mrcrack/article/details/103446528

BZOJ刷题记录---提高组难度

你可能感兴趣的:(跟着大佬学算法)