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 <stdio.h>
#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<b?a:b;
}
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 <stdio.h>
#include <string.h>
#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]<v)max[i]=v;//查询当前数列中末尾L个数中的最大的数
               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]<cnt-x+1)left=mid;//此处写成if(mid<x)left=mid;
//修改，提交AC.2019-8-6 18:50
#include <stdio.h>
#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<right){
               mid=(left+right)/2;
               if(stack[mid]<cnt-x+1)left=mid;//此处写成if(mid<x)left=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 <stdio.h>
#include <string.h>
#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 <stdio.h>
#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<q[u].left||q[u].right<left) return -INF;
   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 <stdio.h>
#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<<j)+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<<k))k++;//tot-2^(k-1)+1 z-2^(k-1)+1=left => 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 <stdio.h>
#include <string.h>
#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<x;i++)vis[sg[x-i][i]]=1;
   for(j=1;j<y;j++)vis[sg[j][y-j]]=1;
   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<i;k++)vis[sg[i-k][k]]=1;
           for(k=1;k<j;k++)vis[sg[k][j-k]]=1;
           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<x;i++)vis[get_sg(x-i,i)]=1;//此处写成for(i=1;i<x;i++)vis[sg[x-i][i]]=1;
//for(j=1;j<y;j++)vis[get_sg(j,y-j)]=1;//此处写成for(j=1;j<y;j++)vis[sg[j][y-j]]=1;
//程序输出结果始终对不上，多次对比代码，发现
//int vis[maxn*maxn];//之前写成全局变量
//虽然，递归打表思路比较简单，但还得小心vis数组只在递归函数内生效，即局部变量．2019-8-9 22:51
#include <stdio.h>
#include <string.h>
#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<x;i++)vis[get_sg(x-i,i)]=1;//此处写成for(i=1;i<x;i++)vis[sg[x-i][i]]=1;
   for(j=1;j<y;j++)vis[get_sg(j,y-j)]=1;//此处写成for(j=1;j<y;j++)vis[sg[j][y-j]]=1;
   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 <stdio.h>
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]<seq[i],那么dp[i][j]=dp[i−1][j](此时A序列长度i-j，之前i-1-j;A序列最后一位为seq[i],之前为seq[i-1].B序列在这一步，前后均无变化)
如果可以接在B序列上的话,即dp[i−1][i−j]<seq[i](可以接在B序列上,但是由于状态是B序列的长度,所以两个序列要交换,所以是i-j),那么A序列和B序列要互换,此时B'序列的最后一个元素就是之前A序列的最后一个元素seq[i−1],即dp[i][k]=min(dp[i][j],seq[i−1])*/
/*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 <stdio.h>
#include <string.h>
#define maxn 2010
int dp[maxn][maxn/2],seq[maxn];
int min(int a,int b){
   return a<b?a:b;
}
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]<seq[i])dp[i][j]=min(dp[i][j],dp[i-1][j]);//A,B序列次序不变，seq[i]还是接在原A序列之后
               if(dp[i-1][i-j-1] <seq[i])dp[i][j]=min(dp[i][j],seq[i-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 <stdio.h>
#include <string.h>
#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 <cstdio>
#include <algorithm>
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<b.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 <stdio.h>
#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<now&&num<cnt)ans=now,num=cnt;//在<=n范畴内，选约数多的
       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 <stdio.h>
#define maxn 35
int n;
double k,c,f[maxn][maxn],sum[maxn],d[maxn];
double min(double a,double b){
   return a<b?a:b;
}
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 <stdio.h>
#include <string.h>
#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]<b)a[i]=-1;
       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 <stdio.h>
#include <string.h>
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<b?a:b;
}
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]<ans){//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 <stdio.h>
#include <string.h>
#include <ctype.h>
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 <stdio.h>
#include <string.h>
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<r;p++)
                       for(q=0;q<c;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)<ans)//此处写成if(sum%(i*j)&&sum/(i*j)<ans)
               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 <stdio.h>
#include <string.h>
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 <stdio.h>
#include <string.h>
#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<n;i++)e[i]=(node){i,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 <stdio.h>
#include <string.h>
#define maxn 100
int X[maxn],Y[maxn];
void add(){//x<y,x+y=z高精度加
   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 <stdio.h>
double max(double a,double b){
   return a>b?a:b;
}
double min(double a,double b){
   return a<b?a:b;
}
double dfs(double x,double y,int n){//对应边长分别为x,y的蛋糕，分为n块
   int i;
   double ans=1e100,ans1,ans2;
   if(n==1){//当前已不可分割
       if(x<y)return y/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 <stdio.h>
#include <string.h>
#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<t){
       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 <stdio.h>
#include <string.h>
#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 <stdio.h>
#include <string.h>
#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<n;i++)//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<m;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<m;i++)scanf("%d%d",&x,&y),map[i][x]=map[i][y]=1;
   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 <stdio.h>
#include <string.h>
#define maxn 55
char str[maxn];
int f[maxn][maxn];
int min(int a,int b){
   return a<b?a:b;
}
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<n;L++)//区间间隔//此处错写成for(i=1;i<n;i++)//此处错写成for(i=1;i<=n;i++)
       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<j;k++)f[i][j]=min(f[i][j],f[i][k]+f[k+1][j]);
       }
   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 <stdio.h>
#include <string.h>
#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 <stdio.h>
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<right){
       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 <stdio.h>
#include <string.h>
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 <stdio.h>
#include <string.h>
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，对于两个祖先，我们可以
选择一个，那么应该选编号小的，但是如果编号小的已经可以选了（就是在环了），我们就应该将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 <stdio.h>
#include <string.h>
#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<f2
           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刷题记录---提高组难度相关推荐

ACM比赛经验、刷题记录及模板库总结（更新中）
前言本文所提及的部分题目代码,可以在我的Github上找到第一部分经验分享及感受第二部分刷题记录一.基础算法&程序语言 //strlen()函数的复杂度是O(n)要小心 //截取字 ...
重走长征路---OI每周刷题记录---9月21日 2013 AC 17题
总目录详见https://blog.csdn.net/mrcrack/article/details/84471041 做题原则,找不到测评地址的题不做.2018-11-28 重走长征路---OI每周 ...
LeetCode刷题记录2——217. Contains Duplicate（easy）
LeetCode刷题记录2--217. Contains Duplicate(easy) 目录 LeetCode刷题记录2--217. Contains Duplicate(easy) 题目语言思 ...
LeetCode刷题记录1——717. 1-bit and 2-bit Characters（easy）
LeetCode刷题记录1--717. 1-bit and 2-bit Characters(easy) LeetCode刷题记录1--717. 1-bit and 2-bit Characters( ...
$2019$ 暑期刷题记录 $2$（基本算法专题）
$ 2019 $ 暑期刷题记录 $ 2 $ (基本算法专题) $ by~~wch $ $ BZOJ~1958~Strange~Towers~of~Hanoi $ (动态规划,递推) 题目大意: 求有 ...
算法笔记CodeUp第一至第六章刷题记录
文章目录 <算法笔记>2.2小节--C/C++快速入门->顺序结构 1.例题1-1-1 按要求输出信息(1) 2.例题1-1-2 按要求输出信息(2) 3.例题1-2-1 求两个整数 ...
力扣刷题记录--哈希表相关题目
当遇到需要快速判断一个元素是否出现在集合里面的时候,可以考虑哈希法,牺牲一定的空间换取查找的时间. java常用的哈希表有HashMap.HashSet以及用数组去模拟哈希,这几种方法各有优劣. 数组 ...
2024届毕业生的刷题记录
2024届毕业生的刷题记录 LeetCode 热题 HOT 100 两数之和两数相加无重复字符的最长子串寻找两个正序数组的中位数最长回文子串 N字形变换整数反转字符串转换整数回文数正则 ...
重走长征路---OI每周刷题记录---11月16日 2013
总目录详见https://blog.csdn.net/mrcrack/article/details/84471041 做题原则,找不到测评地址的题不做.2018-11-28 重走长征路---OI每周 ...

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

BZOJ刷题记录---提高组难度相关推荐

最新文章

热门文章