Copy disabled (too large)
Download .txt
Showing preview only (12,076K chars total). Download the full file to get everything.
Repository: f-zyj/ACM
Branch: master
Commit: 3414f319207f
Files: 1386
Total size: 11.0 MB
Directory structure:
gitextract_h_u2zojh/
├── .gitignore
├── ACM 模板代码/
│ ├── f-0-1分数规划/
│ │ └── f-0-1分数规划/
│ │ └── main.cpp
│ ├── f-2-SAT/
│ │ └── f-2-SAT/
│ │ └── main.cpp
│ ├── f-AC自动机/
│ │ └── f-AC自动机/
│ │ └── main.cpp
│ ├── f-Baby-Step Giant-Step/
│ │ └── f-Baby-Step Giant-Step/
│ │ └── main.cpp
│ ├── f-DAG的深度优先搜索标记/
│ │ └── f-DAG的深度优先搜索标记/
│ │ └── main.cpp
│ ├── f-FFT/
│ │ └── f-FFT/
│ │ └── main.cpp
│ ├── f-FWT/
│ │ └── f-FWT/
│ │ └── main.cpp
│ ├── f-Floyd求最小环/
│ │ └── f-Floyd求最小环/
│ │ └── main.cpp
│ ├── f-GCD/
│ │ └── f-GCD/
│ │ └── main.cpp
│ ├── f-Graham求凸包/
│ │ └── f-Graham求凸包/
│ │ └── main.cpp
│ ├── f-KMP算法/
│ │ └── f-KMP算法/
│ │ └── main.cpp
│ ├── f-Karp-Rabin算法/
│ │ └── f-Karp-Rabin算法/
│ │ └── main.cpp
│ ├── f-LCA/
│ │ └── f-LCA/
│ │ └── main.cpp
│ ├── f-Liuctic的计算几何库/
│ │ └── f-Liuctic的计算几何库/
│ │ └── main.cpp
│ ├── f-MST/
│ │ └── f-MST/
│ │ └── main.cpp
│ ├── f-Manacher算法/
│ │ └── f-Manacher算法/
│ │ └── main.cpp
│ ├── f-Polya计数/
│ │ └── f-Polya计数/
│ │ └── main.cpp
│ ├── f-RMQ/
│ │ └── f-RMQ/
│ │ └── main.cpp
│ ├── f-SPFA/
│ │ └── f-SPFA/
│ │ └── main.cpp
│ ├── f-Sunday Algorithm/
│ │ └── f-Sunday Algorithm/
│ │ └── main.cpp
│ ├── f-Tarian强连通分量/
│ │ └── f-Tarian强连通分量/
│ │ └── main.cpp
│ ├── f-Treap/
│ │ └── f-Treap/
│ │ └── main.cpp
│ ├── f-Trie树/
│ │ └── f-Trie树/
│ │ └── main.cpp
│ ├── f-Ugly Numbers/
│ │ └── f-Ugly Numbers/
│ │ └── main.cpp
│ ├── f-simpson积分/
│ │ └── f-simpson积分/
│ │ └── main.cpp
│ ├── f-strstr函数/
│ │ └── f-strstr函数/
│ │ └── main.cpp
│ ├── f-一般图匹配带花树/
│ │ └── f-一般图匹配带花树/
│ │ └── main.cpp
│ ├── f-主席树/
│ │ └── f-主席树/
│ │ └── main.cpp
│ ├── f-二分图匹配/
│ │ └── f-二分图匹配/
│ │ └── main.cpp
│ ├── f-二分图多重匹配/
│ │ └── f-二分图多重匹配/
│ │ └── main.cpp
│ ├── f-二分查找/
│ │ └── f-二分查找/
│ │ └── main.cpp
│ ├── f-二叉排序树/
│ │ └── f-二叉排序树/
│ │ └── main.cpp
│ ├── f-二叉查找树/
│ │ └── f-二叉查找树/
│ │ └── main.cpp
│ ├── f-伸展数/
│ │ └── f-伸展数/
│ │ └── main.cpp
│ ├── f-使序列有序的最少交换次数/
│ │ └── f-使序列有序的最少交换次数/
│ │ └── main.cpp
│ ├── f-划分树/
│ │ └── f-划分树/
│ │ └── main.cpp
│ ├── f-判断线段相交/
│ │ └── f-判断线段相交/
│ │ └── main.cpp
│ ├── f-动态树/
│ │ └── f-动态树/
│ │ └── main.cpp
│ ├── f-区间最大频率/
│ │ └── f-区间最大频率/
│ │ └── main.cpp
│ ├── f-半平面交/
│ │ └── f-半平面交/
│ │ └── main.cpp
│ ├── f-双连通分支/
│ │ └── f-双连通分支/
│ │ └── main.cpp
│ ├── f-取第k个元素/
│ │ └── f-取第k个元素/
│ │ └── main.cpp
│ ├── f-合数相关/
│ │ └── f-合数相关/
│ │ └── main.cpp
│ ├── f-后缀数组/
│ │ └── f-后缀数组/
│ │ └── main.cpp
│ ├── f-后缀自动机/
│ │ └── f-后缀自动机/
│ │ └── main.cpp
│ ├── f-周期性方程/
│ │ └── f-周期性方程/
│ │ └── main.cpp
│ ├── f-培训作业/
│ │ └── f-培训作业/
│ │ └── main.cpp
│ ├── f-堆/
│ │ └── f-堆/
│ │ └── main.cpp
│ ├── f-堆栈/
│ │ └── f-堆栈/
│ │ └── main.cpp
│ ├── f-多项式求根（牛顿法）/
│ │ └── f-多项式求根（牛顿法）/
│ │ └── main.cpp
│ ├── f-大数取模的二进制方法/
│ │ └── f-大数取模的二进制方法/
│ │ └── main.cpp
│ ├── f-大数平方根（字符串数组表示）/
│ │ └── f-大数平方根（字符串数组表示）/
│ │ └── main.cpp
│ ├── f-大数运算/
│ │ └── f-大数运算/
│ │ └── main.cpp
│ ├── f-字符串 HASH/
│ │ └── f-字符串 HASH/
│ │ └── main.cpp
│ ├── f-容斥/
│ │ └── f-容斥/
│ │ └── main.cpp
│ ├── f-左偏树/
│ │ └── f-左偏树/
│ │ └── main.cpp
│ ├── f-带权值的并查集/
│ │ └── f-带权值的并查集/
│ │ └── main.cpp
│ ├── f-平衡二叉树/
│ │ └── f-平衡二叉树/
│ │ └── main.cpp
│ ├── f-平面最近点对/
│ │ └── f-平面最近点对/
│ │ └── main.cpp
│ ├── f-弦图判断/
│ │ └── f-弦图判断/
│ │ └── main.cpp
│ ├── f-弦图的PERFECT ELIMINATION点排列/
│ │ └── f-弦图的PERFECT ELIMINATION点排列/
│ │ └── main.cpp
│ ├── f-快排/
│ │ └── f-快排/
│ │ └── main.cpp
│ ├── f-所有数位相加/
│ │ └── f-所有数位相加/
│ │ └── main.cpp
│ ├── f-扩展KMP/
│ │ └── f-扩展KMP/
│ │ └── main.cpp
│ ├── f-拓扑排序/
│ │ └── f-拓扑排序/
│ │ └── main.cpp
│ ├── f-排列组合/
│ │ └── f-排列组合/
│ │ └── main.cpp
│ ├── f-散列表查找/
│ │ └── f-散列表查找/
│ │ └── main.cpp
│ ├── f-旋转卡壳/
│ │ └── f-旋转卡壳/
│ │ └── main.cpp
│ ├── f-无向图找桥/
│ │ └── f-无向图找桥/
│ │ └── main.cpp
│ ├── f-无向图最小割/
│ │ └── f-无向图最小割/
│ │ └── main.cpp
│ ├── f-无向图连通分支/
│ │ └── f-无向图连通分支/
│ │ └── main.cpp
│ ├── f-无向图连通度（割）/
│ │ └── f-无向图连通度（割）/
│ │ └── main.cpp
│ ├── f-星期问题/
│ │ └── f-星期问题/
│ │ └── main.cpp
│ ├── f-曼哈顿最小生成树/
│ │ └── f-曼哈顿最小生成树/
│ │ └── main.cpp
│ ├── f-最佳点割集/
│ │ └── f-最佳点割集/
│ │ └── main.cpp
│ ├── f-最佳边割集/
│ │ └── f-最佳边割集/
│ │ └── main.cpp
│ ├── f-最大1矩阵/
│ │ └── f-最大1矩阵/
│ │ └── main.cpp
│ ├── f-最大团问题/
│ │ └── f-最大团问题/
│ │ └── main.cpp
│ ├── f-最大流/
│ │ └── f-最大流/
│ │ └── main.cpp
│ ├── f-最小树形图/
│ │ └── f-最小树形图/
│ │ └── main.cpp
│ ├── f-最小点割集/
│ │ └── f-最小点割集/
│ │ └── main.cpp
│ ├── f-最小生成树/
│ │ └── f-最小生成树/
│ │ └── main.cpp
│ ├── f-最小费用流/
│ │ └── f-最小费用流/
│ │ └── main.cpp
│ ├── f-最小路径覆盖/
│ │ └── f-最小路径覆盖/
│ │ └── main.cpp
│ ├── f-最小边割集/
│ │ └── f-最小边割集/
│ │ └── main.cpp
│ ├── f-最少找钱币问题/
│ │ └── f-最少找钱币问题/
│ │ └── main.cpp
│ ├── f-最短公共祖先/
│ │ └── f-最短公共祖先/
│ │ └── main.cpp
│ ├── f-最短路/
│ │ └── f-最短路/
│ │ └── main.cpp
│ ├── f-最长公共子序列/
│ │ └── f-最长公共子序列/
│ │ └── main.cpp
│ ├── f-最长公共递增子序列/
│ │ └── f-最长公共递增子序列/
│ │ └── main.cpp
│ ├── f-最长有序子序列/
│ │ └── f-最长有序子序列/
│ │ └── main.cpp
│ ├── f-有上下界的流/
│ │ └── f-有上下界的流/
│ │ └── main.cpp
│ ├── f-有向图强连通分支/
│ │ └── f-有向图强连通分支/
│ │ └── main.cpp
│ ├── f-有向图最小树形图/
│ │ └── f-有向图最小树形图/
│ │ └── main.cpp
│ ├── f-有向图最小点基/
│ │ └── f-有向图最小点基/
│ │ └── main.cpp
│ ├── f-有向图的强连通分量/
│ │ └── f-有向图的强连通分量/
│ │ └── main.cpp
│ ├── f-树状数组/
│ │ └── f-树状数组/
│ │ └── main.cpp
│ ├── f-树链剖分/
│ │ └── f-树链剖分/
│ │ └── main.cpp
│ ├── f-棋盘分割/
│ │ └── f-棋盘分割/
│ │ └── main.cpp
│ ├── f-模线性方程（组）/
│ │ └── f-模线性方程（组）/
│ │ └── main.cpp
│ ├── f-次小生成树/
│ │ └── f-次小生成树/
│ │ └── main.cpp
│ ├── f-欧拉函数PHI/
│ │ └── f-欧拉函数PHI/
│ │ └── main.cpp
│ ├── f-欧拉路/
│ │ └── f-欧拉路/
│ │ └── main.cpp
│ ├── f-母函数/
│ │ └── f-母函数/
│ │ └── main.cpp
│ ├── f-求A^B的约数之和/
│ │ └── f-求A^B的约数之和/
│ │ └── main.cpp
│ ├── f-求多边形重心/
│ │ └── f-求多边形重心/
│ │ └── main.cpp
│ ├── f-求逆元/
│ │ └── f-求逆元/
│ │ └── main.cpp
│ ├── f-汉诺塔/
│ │ └── f-汉诺塔/
│ │ └── main.cpp
│ ├── f-生成树计数/
│ │ └── f-生成树计数/
│ │ └── main.cpp
│ ├── f-稳定婚姻问题/
│ │ └── f-稳定婚姻问题/
│ │ └── main.cpp
│ ├── f-第K短路/
│ │ └── f-第K短路/
│ │ └── main.cpp
│ ├── f-素数相关/
│ │ └── f-素数相关/
│ │ └── main.cpp
│ ├── f-约瑟夫环问题/
│ │ └── f-约瑟夫环问题/
│ │ └── main.cpp
│ ├── f-线性方程组/
│ │ └── f-线性方程组/
│ │ └── main.cpp
│ ├── f-线段树/
│ │ └── f-线段树/
│ │ └── main.cpp
│ ├── f-线索二叉树/
│ │ └── f-线索二叉树/
│ │ └── main.cpp
│ ├── f-组合数C(n, r)/
│ │ └── f-组合数C(n, r)/
│ │ └── main.cpp
│ ├── f-莫比乌斯反演/
│ │ └── f-莫比乌斯反演/
│ │ └── main.cpp
│ ├── f-莫队算法/
│ │ └── f-莫队算法/
│ │ └── main.cpp
│ ├── f-赫夫曼编码/
│ │ └── f-赫夫曼编码/
│ │ ├── huffman.cpp
│ │ ├── huffman.hpp
│ │ ├── main.cpp
│ │ ├── queue.cpp
│ │ └── queue.hpp
│ ├── f-逆序数/
│ │ └── f-逆序数/
│ │ └── main.cpp
│ ├── f-邻接表/
│ │ └── f-邻接表/
│ │ └── main.cpp
│ ├── f-阶乘最后非零位/
│ │ └── f-阶乘最后非零位/
│ │ └── main.cpp
│ ├── f-集合划分问题/
│ │ └── f-集合划分问题/
│ │ └── main.cpp
│ ├── f-集合相关问题/
│ │ └── f-集合相关问题/
│ │ └── main.cpp
│ └── f-高斯消元/
│ └── f-高斯消元/
│ └── main.cpp
├── ACM 模版-f_zyj 更新至 v 2.1/
│ ├── v 1.1/
│ │ └── ACM模板-f_zyj v 1.1.pages/
│ │ └── Metadata/
│ │ ├── BuildVersionHistory.plist
│ │ ├── DocumentIdentifier
│ │ └── Properties.plist
│ └── v 2.1/
│ └── ACM模板-f_zyj v 2.1.pages
├── README.md
├── 按 OJ 分类/
│ ├── 51Nod/
│ │ ├── f-51Nod-1000-A+B/
│ │ │ └── f-51Nod-1000-A+B/
│ │ │ └── main.c
│ │ ├── f-51Nod-1001-数组中和等于K的数对/
│ │ │ └── f-51Nod-1001-数组中和等于K的数对/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1002-数塔取数问题/
│ │ │ └── f-51Nod-1002-数塔取数问题/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1003-阶乘后面的0的数量/
│ │ │ └── f-51Nod-1003-阶乘后面的0的数量/
│ │ │ └── main.c
│ │ ├── f-51Nod-1004-n^n的末位数字/
│ │ │ └── f-51Nod-1004-n^n的末位数字/
│ │ │ └── main.c
│ │ ├── f-51Nod-1005-大数加法/
│ │ │ └── f-51Nod-1005-大数加法/
│ │ │ └── main.c
│ │ ├── f-51Nod-1006-Tick and Tick/
│ │ │ └── f-51Nod-1006-Tick and Tick/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1006-最长公共子序列Lcs/
│ │ │ └── f-51Nod-1006-最长公共子序列Lcs/
│ │ │ └── main.c
│ │ ├── f-51Nod-1007-正整数分组/
│ │ │ └── f-51Nod-1007-正整数分组/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1008-N的阶乘 mod P/
│ │ │ └── f-51Nod-1008-N的阶乘 mod P/
│ │ │ └── main.c
│ │ ├── f-51Nod-1009-数字1的数量/
│ │ │ └── f-51Nod-1009-数字1的数量/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1010-只包含2 3 5的数/
│ │ │ └── f-51Nod-1010-只包含2 3 5的数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1011-最大公约数GCD/
│ │ │ └── f-51Nod-1011-最大公约数GCD/
│ │ │ └── main.c
│ │ ├── f-51Nod-1012-最小公倍数LCM/
│ │ │ └── f-51Nod-1012-最小公倍数LCM/
│ │ │ └── main.c
│ │ ├── f-51Nod-1013-3的幂的和/
│ │ │ └── f-51Nod-1013-3的幂的和/
│ │ │ └── main.c
│ │ ├── f-51Nod-1014-X^2 Mod P/
│ │ │ └── f-51Nod-1014-X^2 Mod P/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1015-水仙花数/
│ │ │ └── f-51Nod-1015-水仙花数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1016-水仙花数 V2/
│ │ │ └── f-51Nod-1016-水仙花数 V2/
│ │ │ └── main.c
│ │ ├── f-51Nod-1018-排序/
│ │ │ └── f-51Nod-1018-排序/
│ │ │ └── main.c
│ │ ├── f-51Nod-1019-逆序数/
│ │ │ └── f-51Nod-1019-逆序数/
│ │ │ └── main.c
│ │ ├── f-51Nod-1020-逆序排序/
│ │ │ └── f-51Nod-1020-逆序排序/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1021-石子归并/
│ │ │ └── f-51Nod-1021-石子归并/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1022-石子归并 V2/
│ │ │ └── f-51Nod-1022-石子归并 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1023-石子归并 V3/
│ │ │ └── f-51Nod-1023-石子归并 V3/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1024-矩阵中不重复的元素/
│ │ │ └── f-51Nod-1024-矩阵中不重复的元素/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1027-大数乘法/
│ │ │ └── f-51Nod-1027-大数乘法/
│ │ │ └── main.c
│ │ ├── f-51Nod-1028-大数乘法 V2/
│ │ │ └── f-51Nod-1028-大数乘法 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1029-大数除法/
│ │ │ └── f-51Nod-1029-大数除法/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1030-大数进制转换/
│ │ │ └── f-51Nod-1030-大数进制转换/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1031-骨牌覆盖/
│ │ │ └── f-51Nod-1031-骨牌覆盖/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1032-骨牌覆盖 V2/
│ │ │ └── f-51Nod-1032-骨牌覆盖 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1033-骨牌覆盖 V2/
│ │ │ └── f-51Nod-1033-骨牌覆盖 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1035-最长的循环节/
│ │ │ └── f-51Nod-1035-最长的循环节/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1038-X^A Mod P/
│ │ │ └── f-51Nod-1038-X^A Mod P/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1040-最大公约数之和/
│ │ │ └── f-51Nod-1040-最大公约数之和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1042-数字0~9的数量/
│ │ │ └── f-51Nod-1042-数字0~9的数量/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1043-幸运号码/
│ │ │ └── f-51Nod-1043-幸运号码/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1046-A^B Mod C/
│ │ │ └── f-51Nod-1046-A^B Mod C/
│ │ │ └── main.c
│ │ ├── f-51Nod-1047-整数分解为2的幂/
│ │ │ └── f-51Nod-1047-整数分解为2的幂/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1049-最大子段和/
│ │ │ └── f-51Nod-1049-最大子段和/
│ │ │ └── main.c
│ │ ├── f-51Nod-1050-循环数组最大子段和/
│ │ │ └── f-51Nod-1050-循环数组最大子段和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1051-最大子矩阵和/
│ │ │ └── f-51Nod-1051-最大子矩阵和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1052-最大M子段和/
│ │ │ └── f-51Nod-1052-最大M子段和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1053-最大M子段和 V2/
│ │ │ └── f-51Nod-1053-最大M子段和 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1054-最长等差数列/
│ │ │ └── f-51Nod-1054-最长等差数列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1055-最长等差数列/
│ │ │ └── f-51Nod-1055-最长等差数列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1056-最长等差数列 V2/
│ │ │ └── f-51Nod-1056-最长等差数列 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1057-N的阶乘/
│ │ │ └── f-51Nod-1057-N的阶乘/
│ │ │ └── main.c
│ │ ├── f-51Nod-1058-N的阶乘的长度/
│ │ │ └── f-51Nod-1058-N的阶乘的长度/
│ │ │ └── main.c
│ │ ├── f-51Nod-1059-N的阶乘 V2/
│ │ │ └── f-51Nod-1059-N的阶乘 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1060-最复杂的数/
│ │ │ └── f-51Nod-1060-最复杂的数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1062-序列中的最大数/
│ │ │ └── f-51Nod-1062-序列中的最大数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1063-序列中最大的数 V2/
│ │ │ └── f-51Nod-1063-序列中最大的数 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1065-最小正子段和/
│ │ │ └── f-51Nod-1065-最小正子段和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1066-Bash游戏/
│ │ │ └── f-51Nod-1066-Bash游戏/
│ │ │ └── main.c
│ │ ├── f-51Nod-1067-Bash游戏 V2/
│ │ │ └── f-51Nod-1067-Bash游戏 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1068-Bash游戏 V3/
│ │ │ └── f-51Nod-1068-Bash游戏 V3/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1069-Nim游戏/
│ │ │ └── f-51Nod-1069-Nim游戏/
│ │ │ └── main.c
│ │ ├── f-51Nod-1070-Bash游戏 V4/
│ │ │ └── f-51Nod-1070-Bash游戏 V4/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1072-威佐夫游戏/
│ │ │ └── f-51Nod-1072-威佐夫游戏/
│ │ │ └── main.c
│ │ ├── f-51Nod-1073-约瑟夫环/
│ │ │ └── f-51Nod-1073-约瑟夫环/
│ │ │ └── main.c
│ │ ├── f-51Nod-1074-约瑟夫环 V2/
│ │ │ └── f-51Nod-1074-约瑟夫环 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1076-2条不相交的路径/
│ │ │ └── f-51Nod-1076-2条不相交的路径/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1079-中国剩余定理/
│ │ │ └── f-51Nod-1079-中国剩余定理/
│ │ │ └── main.c
│ │ ├── f-51Nod-1080-两个数的平方和/
│ │ │ └── f-51Nod-1080-两个数的平方和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1081-子段求和/
│ │ │ └── f-51Nod-1081-子段求和/
│ │ │ └── main.c
│ │ ├── f-51Nod-1082-与7无关的数/
│ │ │ └── f-51Nod-1082-与7无关的数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1083-矩阵取数问题/
│ │ │ └── f-51Nod-1083-矩阵取数问题/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1084-矩阵取数问题 V2/
│ │ │ └── f-51Nod-1084-矩阵取数问题 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1085-背包问题/
│ │ │ └── f-51Nod-1085-背包问题/
│ │ │ └── main.c
│ │ ├── f-51Nod-1086-背包问题 V2/
│ │ │ └── f-51Nod-1086-背包问题 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1087-1 10 100 1000/
│ │ │ └── f-51Nod-1087-1 10 100 1000/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1088-最长回文子串/
│ │ │ └── f-51Nod-1088-最长回文子串/
│ │ │ └── main.c
│ │ ├── f-51Nod-1089-最长回文子串 V2（Manacher算法）/
│ │ │ └── f-51Nod-1089-最长回文子串 V2（Manacher算法）/
│ │ │ └── main.c
│ │ ├── f-51Nod-1090-3个数和为0/
│ │ │ └── f-51Nod-1090-3个数和为0/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1091-线段的重叠/
│ │ │ └── f-51Nod-1091-线段的重叠/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1092-回文字符串/
│ │ │ └── f-51Nod-1092-回文字符串/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1093-骆驼和香蕉/
│ │ │ └── f-51Nod-1093-骆驼和香蕉/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1094-和为k的连续区间/
│ │ │ └── f-51Nod-1094-和为k的连续区间/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1095-Anigram单词/
│ │ │ └── f-51Nod-1095-Anigram单词/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1096-距离之和最小/
│ │ │ └── f-51Nod-1096-距离之和最小/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1097-拼成最小的数/
│ │ │ └── f-51Nod-1097-拼成最小的数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1098-最小方差/
│ │ │ └── f-51Nod-1098-最小方差/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1099-任务执行顺序/
│ │ │ └── f-51Nod-1099-任务执行顺序/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1100-斜率最大/
│ │ │ └── f-51Nod-1100-斜率最大/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1101-换零钱/
│ │ │ └── f-51Nod-1101-换零钱/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1102-面积最大的矩形/
│ │ │ └── f-51Nod-1102-面积最大的矩形/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1103-N的倍数/
│ │ │ └── f-51Nod-1103-N的倍数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1105-第K大的数/
│ │ │ └── f-51Nod-1105-第K大的数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1106-质数检测/
│ │ │ └── f-51Nod-1106-质数检测/
│ │ │ └── main.c
│ │ ├── f-51Nod-1107-斜率小于0的连线数量/
│ │ │ └── f-51Nod-1107-斜率小于0的连线数量/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1108-距离之和最小 V2/
│ │ │ └── f-51Nod-1108-距离之和最小 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1109-01组成的N的倍数/
│ │ │ └── f-51Nod-1109-01组成的N的倍数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1110-距离之和最小 V3/
│ │ │ └── f-51Nod-1110-距离之和最小 V3/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1112-KGold/
│ │ │ └── f-51Nod-1112-KGold/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1113-矩阵快速幂/
│ │ │ └── f-51Nod-1113-矩阵快速幂/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1116-K进制下的大数/
│ │ │ └── f-51Nod-1116-K进制下的大数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1117-聪明的木匠/
│ │ │ └── f-51Nod-1117-聪明的木匠/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1118-机器人走方格/
│ │ │ └── f-51Nod-1118-机器人走方格/
│ │ │ └── main.c
│ │ ├── f-51Nod-1119-机器人走方格 V2/
│ │ │ └── f-51Nod-1119-机器人走方格 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1120-机器人走方格 V3/
│ │ │ └── f-51Nod-1120-机器人走方格 V3/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1122-机器人走方格 V4/
│ │ │ └── f-51Nod-1122-机器人走方格 V4/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1124-N!的非0最低位/
│ │ │ └── f-51Nod-1124-N!的非0最低位/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1125-交换机器的最小代价/
│ │ │ └── f-51Nod-1125-交换机器的最小代价/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1126-求递推序列的第N项/
│ │ │ └── f-51Nod-1126-求递推序列的第N项/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1127-最短的包含字符串/
│ │ │ └── f-51Nod-1127-最短的包含字符串/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1128-正整数分组 V2/
│ │ │ └── f-51Nod-1128-正整数分组 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1130-N的阶乘的长度 V2（斯特林近似）/
│ │ │ └── f-51Nod-1130-N的阶乘的长度 V2（斯特林近似）/
│ │ │ └── main.c
│ │ ├── f-51Nod-1131-覆盖数字的数量/
│ │ │ └── f-51Nod-1131-覆盖数字的数量/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1133-不重叠的线段/
│ │ │ └── f-51Nod-1133-不重叠的线段/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1134-最长递增子序列/
│ │ │ └── f-51Nod-1134-最长递增子序列/
│ │ │ └── main.c
│ │ ├── f-51Nod-1135-原根/
│ │ │ └── f-51Nod-1135-原根/
│ │ │ └── main.c
│ │ ├── f-51Nod-1136-欧拉函数/
│ │ │ └── f-51Nod-1136-欧拉函数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1137-矩阵乘法/
│ │ │ └── f-51Nod-1137-矩阵乘法/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1138-连续整数的和/
│ │ │ └── f-51Nod-1138-连续整数的和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1140-矩阵相乘结果的判断/
│ │ │ └── f-51Nod-1140-矩阵相乘结果的判断/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1149-Pi的递推式/
│ │ │ └── f-51Nod-1149-Pi的递推式/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1153-选择子序列/
│ │ │ └── f-51Nod-1153-选择子序列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1154-回文串划分/
│ │ │ └── f-51Nod-1154-回文串划分/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1157-全是1的最大子矩阵/
│ │ │ └── f-51Nod-1157-全是1的最大子矩阵/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1158-全是1的最大子矩阵/
│ │ │ └── f-51Nod-1158-全是1的最大子矩阵/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1161-Partial Sums/
│ │ │ └── f-51Nod-1161-Partial Sums/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1163-最高的奖励/
│ │ │ └── f-51Nod-1163-最高的奖励/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1166-大数开平方/
│ │ │ └── f-51Nod-1166-大数开平方/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1174-区间中最大数/
│ │ │ └── f-51Nod-1174-区间中最大数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1175-区间中第K大的数/
│ │ │ └── f-51Nod-1175-区间中第K大的数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1179-最大的最大公约数/
│ │ │ └── f-51Nod-1179-最大的最大公约数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1181-质数中的质数（质数筛法）/
│ │ │ └── f-51Nod-1181-质数中的质数（质数筛法）/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1182-完美字符串/
│ │ │ └── f-51Nod-1182-完美字符串/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1183-编辑距离/
│ │ │ └── f-51Nod-1183-编辑距离/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1184-第N个质数/
│ │ │ └── f-51Nod-1184-第N个质数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1185-威佐夫游戏 V2/
│ │ │ └── f-51Nod-1185-威佐夫游戏 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1186-质数检测 V2/
│ │ │ └── f-51Nod-1186-质数检测 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1188-最大公约数之和 V2/
│ │ │ └── f-51Nod-1188-最大公约数之和 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1189-阶乘分数/
│ │ │ └── f-51Nod-1189-阶乘分数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1191-消灭兔子/
│ │ │ └── f-51Nod-1191-消灭兔子/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1192-Gcd表中的质数/
│ │ │ └── f-51Nod-1192-Gcd表中的质数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1195-斐波那契数列的循环节/
│ │ │ └── f-51Nod-1195-斐波那契数列的循环节/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1196-字符串的数量/
│ │ │ └── f-51Nod-1196-字符串的数量/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1197-字符串的数量 V2/
│ │ │ └── f-51Nod-1197-字符串的数量 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1198-字符串的数量 V3/
│ │ │ └── f-51Nod-1198-字符串的数量 V3/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1199-Money out of Thin Air/
│ │ │ └── f-51Nod-1199-Money out of Thin Air/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1201-整数划分/
│ │ │ └── f-51Nod-1201-整数划分/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1202-子序列个数/
│ │ │ └── f-51Nod-1202-子序列个数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1203-JZPLCM/
│ │ │ └── f-51Nod-1203-JZPLCM/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1204-Parity/
│ │ │ └── f-51Nod-1204-Parity/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1205-流水线调度/
│ │ │ └── f-51Nod-1205-流水线调度/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1208-Stars in Your Window/
│ │ │ └── f-51Nod-1208-Stars in Your Window/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1212-无向图最小生成树/
│ │ │ └── f-51Nod-1212-无向图最小生成树/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1215-数组的宽度/
│ │ │ └── f-51Nod-1215-数组的宽度/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1217-Minimum Modular/
│ │ │ └── f-51Nod-1217-Minimum Modular/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1220-约数之和/
│ │ │ └── f-51Nod-1220-约数之和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1222-最小公倍数计数/
│ │ │ └── f-51Nod-1222-最小公倍数计数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1225-余数之和/
│ │ │ └── f-51Nod-1225-余数之和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1227-平均最小公倍数/
│ │ │ └── f-51Nod-1227-平均最小公倍数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1228-序列求和/
│ │ │ └── f-51Nod-1228-序列求和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1230-幸运数/
│ │ │ └── f-51Nod-1230-幸运数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1232-完美数/
│ │ │ └── f-51Nod-1232-完美数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1237-最大公约数之和 V3/
│ │ │ └── f-51Nod-1237-最大公约数之和 V3/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1238-最小公倍数之和 V3/
│ │ │ └── f-51Nod-1238-最小公倍数之和 V3/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1239-欧拉函数之和/
│ │ │ └── f-51Nod-1239-欧拉函数之和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1240-莫比乌斯函数/
│ │ │ └── f-51Nod-1240-莫比乌斯函数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1241-特殊的排序/
│ │ │ └── f-51Nod-1241-特殊的排序/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1242-斐波那契数列的第N项/
│ │ │ └── f-51Nod-1242-斐波那契数列的第N项/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1243-排船的问题/
│ │ │ └── f-51Nod-1243-排船的问题/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1244-莫比乌斯函数之和/
│ │ │ └── f-51Nod-1244-莫比乌斯函数之和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1246-罐子和硬币/
│ │ │ └── f-51Nod-1246-罐子和硬币/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1247-可能的路径/
│ │ │ └── f-51Nod-1247-可能的路径/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1249-近似有序区间/
│ │ │ └── f-51Nod-1249-近似有序区间/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1254-最大子段和 V2/
│ │ │ └── f-51Nod-1254-最大子段和 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1255-字典序最小的子序列/
│ │ │ └── f-51Nod-1255-字典序最小的子序列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1256-乘法逆元/
│ │ │ └── f-51Nod-1256-乘法逆元/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1257-背包问题 V3/
│ │ │ └── f-51Nod-1257-背包问题 V3/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1258-序列求和 V4/
│ │ │ └── f-51Nod-1258-序列求和 V4/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1259-整数划分 V2/
│ │ │ └── f-51Nod-1259-整数划分 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1262-扔球/
│ │ │ └── f-51Nod-1262-扔球/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1264-线段相交/
│ │ │ └── f-51Nod-1264-线段相交/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1265-四点共面/
│ │ │ └── f-51Nod-1265-四点共面/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1266-蚂蚁/
│ │ │ └── f-51Nod-1266-蚂蚁/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1267-4个数和为0/
│ │ │ └── f-51Nod-1267-4个数和为0/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1268-和为K的组合/
│ │ │ └── f-51Nod-1268-和为K的组合/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1270-数组的最大代价/
│ │ │ └── f-51Nod-1270-数组的最大代价/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1272-最大距离/
│ │ │ └── f-51Nod-1272-最大距离/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1273-旅行计划/
│ │ │ └── f-51Nod-1273-旅行计划/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1274-最长递增路径/
│ │ │ └── f-51Nod-1274-最长递增路径/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1275-连续子段的差异/
│ │ │ └── f-51Nod-1275-连续子段的差异/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1276-岛屿的数量/
│ │ │ └── f-51Nod-1276-岛屿的数量/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1277-字符串中的最大值/
│ │ │ └── f-51Nod-1277-字符串中的最大值/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1278-相离的圆/
│ │ │ └── f-51Nod-1278-相离的圆/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1279-扔盘子/
│ │ │ └── f-51Nod-1279-扔盘子/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1280-前缀后缀集合/
│ │ │ └── f-51Nod-1280-前缀后缀集合/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1281-山峰和旗子/
│ │ │ └── f-51Nod-1281-山峰和旗子/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1282-时钟/
│ │ │ └── f-51Nod-1282-时钟/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1283-最小周长/
│ │ │ └── f-51Nod-1283-最小周长/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1284-2 3 5 7的倍数/
│ │ │ └── f-51Nod-1284-2 3 5 7的倍数/
│ │ │ └── main.c
│ │ ├── f-51Nod-1285-山峰和分段/
│ │ │ └── f-51Nod-1285-山峰和分段/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1287-加农炮/
│ │ │ └── f-51Nod-1287-加农炮/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1288-汽油补给/
│ │ │ └── f-51Nod-1288-汽油补给/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1289-大鱼吃小鱼/
│ │ │ └── f-51Nod-1289-大鱼吃小鱼/
│ │ │ └── main.c
│ │ ├── f-51Nod-1293-球与切换器/
│ │ │ └── f-51Nod-1293-球与切换器/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1294-修改数组/
│ │ │ └── f-51Nod-1294-修改数组/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1295-XOR key/
│ │ │ └── f-51Nod-1295-XOR key/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1296-有限制的排列/
│ │ │ └── f-51Nod-1296-有限制的排列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1298-圆与三角形/
│ │ │ └── f-51Nod-1298-圆与三角形/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1299-监狱逃离/
│ │ │ └── f-51Nod-1299-监狱逃离/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1305-Pairwise Sum and Divide/
│ │ │ └── f-51Nod-1305-Pairwise Sum and Divide/
│ │ │ └── main.c
│ │ ├── f-51Nod-1307-绳子与重物/
│ │ │ └── f-51Nod-1307-绳子与重物/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1310-Chandrima and XOR/
│ │ │ └── f-51Nod-1310-Chandrima and XOR/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1315-合法整数集/
│ │ │ └── f-51Nod-1315-合法整数集/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1316-回文矩阵/
│ │ │ └── f-51Nod-1316-回文矩阵/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1319-跳跃游戏/
│ │ │ └── f-51Nod-1319-跳跃游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1320-合法尾数序列/
│ │ │ └── f-51Nod-1320-合法尾数序列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1322-关于树的函数/
│ │ │ └── f-51Nod-1322-关于树的函数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1328-比赛往事/
│ │ │ └── f-51Nod-1328-比赛往事/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1330-雕像投影/
│ │ │ └── f-51Nod-1330-雕像投影/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1333-无聊的数学家们/
│ │ │ └── f-51Nod-1333-无聊的数学家们/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1335-子序列翻转/
│ │ │ └── f-51Nod-1335-子序列翻转/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1337-翻转游戏/
│ │ │ └── f-51Nod-1337-翻转游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1341-混合序列/
│ │ │ └── f-51Nod-1341-混合序列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1344-走格子/
│ │ │ └── f-51Nod-1344-走格子/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1345-画点集/
│ │ │ └── f-51Nod-1345-画点集/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1346-递归/
│ │ │ └── f-51Nod-1346-递归/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1347-旋转字符串/
│ │ │ └── f-51Nod-1347-旋转字符串/
│ │ │ └── main.c
│ │ ├── f-51Nod-1349-最大值/
│ │ │ └── f-51Nod-1349-最大值/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1350-斐波那契表示/
│ │ │ └── f-51Nod-1350-斐波那契表示/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1351-吃点心/
│ │ │ └── f-51Nod-1351-吃点心/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1352-集合计数/
│ │ │ └── f-51Nod-1352-集合计数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1353-树/
│ │ │ └── f-51Nod-1353-树/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1354-选数字/
│ │ │ └── f-51Nod-1354-选数字/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1355-斐波那契的最小公倍数/
│ │ │ └── f-51Nod-1355-斐波那契的最小公倍数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1358-浮波那契/
│ │ │ └── f-51Nod-1358-浮波那契/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1359-循环探求/
│ │ │ └── f-51Nod-1359-循环探求/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1363-最小公倍数之和/
│ │ │ └── f-51Nod-1363-最小公倍数之和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1364-最大字典序排列/
│ │ │ └── f-51Nod-1364-最大字典序排列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1366-贫富差距/
│ │ │ └── f-51Nod-1366-贫富差距/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1371-填数字/
│ │ │ └── f-51Nod-1371-填数字/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1376-最长递增子序列的数量/
│ │ │ └── f-51Nod-1376-最长递增子序列的数量/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1377-最慢的快排/
│ │ │ └── f-51Nod-1377-最慢的快排/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1378-夹克老爷的愤怒/
│ │ │ └── f-51Nod-1378-夹克老爷的愤怒/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1379-索函数/
│ │ │ └── f-51Nod-1379-索函数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1380-夹克老爷的逢三抽一/
│ │ │ └── f-51Nod-1380-夹克老爷的逢三抽一/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1381-硬币游戏/
│ │ │ └── f-51Nod-1381-硬币游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1383-整数分解为2的幂/
│ │ │ └── f-51Nod-1383-整数分解为2的幂/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1384-全排列/
│ │ │ └── f-51Nod-1384-全排列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1385-凑数字/
│ │ │ └── f-51Nod-1385-凑数字/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1388-六边形平面/
│ │ │ └── f-51Nod-1388-六边形平面/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1390-游戏得分/
│ │ │ └── f-51Nod-1390-游戏得分/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1391-01串/
│ │ │ └── f-51Nod-1391-01串/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1393-0和1相等串/
│ │ │ └── f-51Nod-1393-0和1相等串/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1394-差和问题/
│ │ │ └── f-51Nod-1394-差和问题/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1396-还是01串/
│ │ │ └── f-51Nod-1396-还是01串/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1398-等公交/
│ │ │ └── f-51Nod-1398-等公交/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1400-序列分解/
│ │ │ └── f-51Nod-1400-序列分解/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1402-最大值/
│ │ │ └── f-51Nod-1402-最大值/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1403-有趣的堆栈/
│ │ │ └── f-51Nod-1403-有趣的堆栈/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1405-树的距离之和/
│ │ │ └── f-51Nod-1405-树的距离之和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1406-与查询/
│ │ │ └── f-51Nod-1406-与查询/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1409-加强版贪吃蛇/
│ │ │ └── f-51Nod-1409-加强版贪吃蛇/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1412-AVL树的种类/
│ │ │ └── f-51Nod-1412-AVL树的种类/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1413-权势二进制/
│ │ │ └── f-51Nod-1413-权势二进制/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1414-冰雕/
│ │ │ └── f-51Nod-1414-冰雕/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1416-两点/
│ │ │ └── f-51Nod-1416-两点/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1417-天堂里的游戏/
│ │ │ └── f-51Nod-1417-天堂里的游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1418-放球游戏/
│ │ │ └── f-51Nod-1418-放球游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1419-最小公倍数挑战/
│ │ │ └── f-51Nod-1419-最小公倍数挑战/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1420-数袋鼠好有趣/
│ │ │ └── f-51Nod-1420-数袋鼠好有趣/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1421-最大MOD值/
│ │ │ └── f-51Nod-1421-最大MOD值/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1422-沙拉酱前缀/
│ │ │ └── f-51Nod-1422-沙拉酱前缀/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1423-最大二"货"/
│ │ │ └── f-51Nod-1423-最大二"货"/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1424-零树/
│ │ │ └── f-51Nod-1424-零树/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1425-减减数/
│ │ │ └── f-51Nod-1425-减减数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1428-活动安排问题/
│ │ │ └── f-51Nod-1428-活动安排问题/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1429-巧克力/
│ │ │ └── f-51Nod-1429-巧克力/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1430-奇偶游戏/
│ │ │ └── f-51Nod-1430-奇偶游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1431-快乐排队/
│ │ │ └── f-51Nod-1431-快乐排队/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1432-独木舟/
│ │ │ └── f-51Nod-1432-独木舟/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1433-0和5/
│ │ │ └── f-51Nod-1433-0和5/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1434-区间LCM/
│ │ │ └── f-51Nod-1434-区间LCM/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1435-位数阶乘/
│ │ │ └── f-51Nod-1435-位数阶乘/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1436-方程的解数/
│ │ │ └── f-51Nod-1436-方程的解数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1437-迈克步/
│ │ │ └── f-51Nod-1437-迈克步/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1438-方阵与完全平方数/
│ │ │ └── f-51Nod-1438-方阵与完全平方数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1439-互质对/
│ │ │ └── f-51Nod-1439-互质对/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1441-士兵的数字游戏/
│ │ │ └── f-51Nod-1441-士兵的数字游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1442-士兵的旅行/
│ │ │ └── f-51Nod-1442-士兵的旅行/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1443-路径和树/
│ │ │ └── f-51Nod-1443-路径和树/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1444-破坏道路/
│ │ │ └── f-51Nod-1444-破坏道路/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1445-变色DNA/
│ │ │ └── f-51Nod-1445-变色DNA/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1448-二染色问题/
│ │ │ └── f-51Nod-1448-二染色问题/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1449-砝码称重/
│ │ │ └── f-51Nod-1449-砝码称重/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1451-合法三角形/
│ │ │ └── f-51Nod-1451-合法三角形/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1452-加括号/
│ │ │ └── f-51Nod-1452-加括号/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1453-抽彩球/
│ │ │ └── f-51Nod-1453-抽彩球/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1454-升排列/
│ │ │ └── f-51Nod-1454-升排列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1455-宝石猎人/
│ │ │ └── f-51Nod-1455-宝石猎人/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1456-小K的技术/
│ │ │ └── f-51Nod-1456-小K的技术/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1459-迷宫游戏/
│ │ │ └── f-51Nod-1459-迷宫游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1460-连接小岛/
│ │ │ └── f-51Nod-1460-连接小岛/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1461-稳定桌/
│ │ │ └── f-51Nod-1461-稳定桌/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1463-找朋友/
│ │ │ └── f-51Nod-1463-找朋友/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1464-半回文/
│ │ │ └── f-51Nod-1464-半回文/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1467-旋转绳/
│ │ │ └── f-51Nod-1467-旋转绳/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1468-小Y的IP地址/
│ │ │ └── f-51Nod-1468-小Y的IP地址/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1469-淋漓尽致子串/
│ │ │ └── f-51Nod-1469-淋漓尽致子串/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1473-等幂映射/
│ │ │ └── f-51Nod-1473-等幂映射/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1475-建设国家/
│ │ │ └── f-51Nod-1475-建设国家/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1476-括号序列的最小代价/
│ │ │ └── f-51Nod-1476-括号序列的最小代价/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1478-括号序列的最长合法子段/
│ │ │ └── f-51Nod-1478-括号序列的最长合法子段/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1480-打广告/
│ │ │ └── f-51Nod-1480-打广告/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1483-化学变换/
│ │ │ └── f-51Nod-1483-化学变换/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1484-猜数游戏/
│ │ │ └── f-51Nod-1484-猜数游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1485-字母排序/
│ │ │ └── f-51Nod-1485-字母排序/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1486-大大走格子/
│ │ │ └── f-51Nod-1486-大大走格子/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1487-占领资源/
│ │ │ └── f-51Nod-1487-占领资源/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1489-蜥蜴和地下室/
│ │ │ └── f-51Nod-1489-蜥蜴和地下室/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1490-多重游戏/
│ │ │ └── f-51Nod-1490-多重游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1491-黄金系统/
│ │ │ └── f-51Nod-1491-黄金系统/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1493-数据关联/
│ │ │ └── f-51Nod-1493-数据关联/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1494-选举拉票/
│ │ │ └── f-51Nod-1494-选举拉票/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1495-中国好区间/
│ │ │ └── f-51Nod-1495-中国好区间/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1496-最小异或和/
│ │ │ └── f-51Nod-1496-最小异或和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1499-图/
│ │ │ └── f-51Nod-1499-图/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1500-苹果曼和树/
│ │ │ └── f-51Nod-1500-苹果曼和树/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1503-猪和回文/
│ │ │ └── f-51Nod-1503-猪和回文/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1509-加长棒/
│ │ │ └── f-51Nod-1509-加长棒/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1510-最小化序列/
│ │ │ └── f-51Nod-1510-最小化序列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1513-树上的回文/
│ │ │ └── f-51Nod-1513-树上的回文/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1515-明辨是非/
│ │ │ └── f-51Nod-1515-明辨是非/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1519-拆方块/
│ │ │ └── f-51Nod-1519-拆方块/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1521-一维战舰/
│ │ │ └── f-51Nod-1521-一维战舰/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1522-上下序列/
│ │ │ └── f-51Nod-1522-上下序列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1523-非回文/
│ │ │ └── f-51Nod-1523-非回文/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1524-可除图的最大团/
│ │ │ └── f-51Nod-1524-可除图的最大团/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1525-重组公司/
│ │ │ └── f-51Nod-1525-重组公司/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1526-分配笔名/
│ │ │ └── f-51Nod-1526-分配笔名/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1530-稳定方块/
│ │ │ └── f-51Nod-1530-稳定方块/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1533-一堆的堆/
│ │ │ └── f-51Nod-1533-一堆的堆/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1534-棋子游戏/
│ │ │ └── f-51Nod-1534-棋子游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1535-深海探险/
│ │ │ └── f-51Nod-1535-深海探险/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1536-不一样的猜数游戏/
│ │ │ └── f-51Nod-1536-不一样的猜数游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1540-俄罗斯赌轮盘/
│ │ │ └── f-51Nod-1540-俄罗斯赌轮盘/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1548-欧姆诺姆和糖果/
│ │ │ └── f-51Nod-1548-欧姆诺姆和糖果/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1552-白兰地定位系统/
│ │ │ └── f-51Nod-1552-白兰地定位系统/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1554-欧姆诺姆和项链/
│ │ │ └── f-51Nod-1554-欧姆诺姆和项链/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1556-计算/
│ │ │ └── f-51Nod-1556-计算/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1557-两个集合/
│ │ │ └── f-51Nod-1557-两个集合/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1560-扔人游戏/
│ │ │ └── f-51Nod-1560-扔人游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1562-玻璃切割/
│ │ │ └── f-51Nod-1562-玻璃切割/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1563-坐标轴上的最大团/
│ │ │ └── f-51Nod-1563-坐标轴上的最大团/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1564-区间的价值/
│ │ │ └── f-51Nod-1564-区间的价值/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1571-最近等对/
│ │ │ └── f-51Nod-1571-最近等对/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1572-宝岛地图/
│ │ │ └── f-51Nod-1572-宝岛地图/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1573-美丽的集合/
│ │ │ └── f-51Nod-1573-美丽的集合/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1574-排列转换/
│ │ │ └── f-51Nod-1574-排列转换/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1580-铺管道/
│ │ │ └── f-51Nod-1580-铺管道/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1581-摆放骨牌/
│ │ │ └── f-51Nod-1581-摆放骨牌/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1582-n叉树/
│ │ │ └── f-51Nod-1582-n叉树/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1586-约数和/
│ │ │ └── f-51Nod-1586-约数和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1589-移数博弈/
│ │ │ └── f-51Nod-1589-移数博弈/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1593-公园晨跑/
│ │ │ └── f-51Nod-1593-公园晨跑/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1594-Gcd and Phi/
│ │ │ └── f-51Nod-1594-Gcd and Phi/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1595-回文度/
│ │ │ └── f-51Nod-1595-回文度/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1596-搬货物/
│ │ │ └── f-51Nod-1596-搬货物/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1597-有限背包计数问题/
│ │ │ └── f-51Nod-1597-有限背包计数问题/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1603-限高二叉排列树/
│ │ │ └── f-51Nod-1603-限高二叉排列树/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1605-棋盘问题/
│ │ │ └── f-51Nod-1605-棋盘问题/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1607-卷积和/
│ │ │ └── f-51Nod-1607-卷积和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1610-路径计数/
│ │ │ └── f-51Nod-1610-路径计数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1612-合法表达式/
│ │ │ └── f-51Nod-1612-合法表达式/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1613-翻硬币/
│ │ │ └── f-51Nod-1613-翻硬币/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1615-跳跃的杰克/
│ │ │ └── f-51Nod-1615-跳跃的杰克/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1616-最小集合/
│ │ │ └── f-51Nod-1616-最小集合/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1617-奇偶数组/
│ │ │ └── f-51Nod-1617-奇偶数组/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1618-树或非树/
│ │ │ └── f-51Nod-1618-树或非树/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1619-完全二叉树的方差/
│ │ │ └── f-51Nod-1619-完全二叉树的方差/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1621-花钱买车牌/
│ │ │ └── f-51Nod-1621-花钱买车牌/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1622-集合对/
│ │ │ └── f-51Nod-1622-集合对/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1623-完美消除/
│ │ │ └── f-51Nod-1623-完美消除/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1625-夹克爷发红包/
│ │ │ └── f-51Nod-1625-夹克爷发红包/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1629-B君的圆锥/
│ │ │ └── f-51Nod-1629-B君的圆锥/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1630-B君的竞技场/
│ │ │ └── f-51Nod-1630-B君的竞技场/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1631-小鲨鱼在51Nod小学/
│ │ │ └── f-51Nod-1631-小鲨鱼在51Nod小学/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1635-第K个幸运排列/
│ │ │ └── f-51Nod-1635-第K个幸运排列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1636-教育改革/
│ │ │ └── f-51Nod-1636-教育改革/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1637-幸运数字转换/
│ │ │ └── f-51Nod-1637-幸运数字转换/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1638-字符串重组/
│ │ │ └── f-51Nod-1638-字符串重组/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1639-绑鞋带/
│ │ │ └── f-51Nod-1639-绑鞋带/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1640-天气晴朗的魔法/
│ │ │ └── f-51Nod-1640-天气晴朗的魔法/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1645-中位数变换/
│ │ │ └── f-51Nod-1645-中位数变换/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1649-齐头并进/
│ │ │ └── f-51Nod-1649-齐头并进/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1650-穿越无人区/
│ │ │ └── f-51Nod-1650-穿越无人区/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1661-黑板上的游戏/
│ │ │ └── f-51Nod-1661-黑板上的游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1670-打怪兽/
│ │ │ └── f-51Nod-1670-打怪兽/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1671-货物运输/
│ │ │ └── f-51Nod-1671-货物运输/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1673-树有几多愁/
│ │ │ └── f-51Nod-1673-树有几多愁/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1674-区间的价值 V2/
│ │ │ └── f-51Nod-1674-区间的价值 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1675-序列变换/
│ │ │ └── f-51Nod-1675-序列变换/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1677-treecnt/
│ │ │ └── f-51Nod-1677-treecnt/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1678-lyk与gcd/
│ │ │ └── f-51Nod-1678-lyk与gcd/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1679-连通率/
│ │ │ └── f-51Nod-1679-连通率/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1681-公共祖先/
│ │ │ └── f-51Nod-1681-公共祖先/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1684-子集价值/
│ │ │ └── f-51Nod-1684-子集价值/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1685-第K大区间2/
│ │ │ └── f-51Nod-1685-第K大区间2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1686-第K大区间/
│ │ │ └── f-51Nod-1686-第K大区间/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1689-逛街/
│ │ │ └── f-51Nod-1689-逛街/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1693-水群/
│ │ │ └── f-51Nod-1693-水群/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1705-七星剑/
│ │ │ └── f-51Nod-1705-七星剑/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1711-平均数/
│ │ │ └── f-51Nod-1711-平均数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1712-区间求和/
│ │ │ └── f-51Nod-1712-区间求和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1714-B君的游戏/
│ │ │ └── f-51Nod-1714-B君的游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1716-多项式?/
│ │ │ └── f-51Nod-1716-多项式?/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1718-"多项式"/
│ │ │ └── f-51Nod-1718-"多项式"/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1719-数值计算/
│ │ │ └── f-51Nod-1719-数值计算/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1732-51Nod婚姻介绍所/
│ │ │ └── f-51Nod-1732-51Nod婚姻介绍所/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1737-配对/
│ │ │ └── f-51Nod-1737-配对/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1742-开心的小Q/
│ │ │ └── f-51Nod-1742-开心的小Q/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1747-近似多项式/
│ │ │ └── f-51Nod-1747-近似多项式/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1753-相似子串/
│ │ │ └── f-51Nod-1753-相似子串/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1765-谷歌的恐龙/
│ │ │ └── f-51Nod-1765-谷歌的恐龙/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1766-树上的最远点对/
│ │ │ └── f-51Nod-1766-树上的最远点对/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1773-A国的贸易/
│ │ │ └── f-51Nod-1773-A国的贸易/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1779-逆序对统计/
│ │ │ └── f-51Nod-1779-逆序对统计/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1780-完美序列/
│ │ │ └── f-51Nod-1780-完美序列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1781-Pinball/
│ │ │ └── f-51Nod-1781-Pinball/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1785-数据流中的算法/
│ │ │ └── f-51Nod-1785-数据流中的算法/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1791-合法括号子段/
│ │ │ └── f-51Nod-1791-合法括号子段/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1799-二分答案/
│ │ │ └── f-51Nod-1799-二分答案/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1800-汉诺塔/
│ │ │ └── f-51Nod-1800-汉诺塔/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1803-森林直径/
│ │ │ └── f-51Nod-1803-森林直径/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1804-小C的多边形/
│ │ │ └── f-51Nod-1804-小C的多边形/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1805-小树/
│ │ │ └── f-51Nod-1805-小树/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1806-wangyurzee的树/
│ │ │ └── f-51Nod-1806-wangyurzee的树/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1810-连续区间/
│ │ │ └── f-51Nod-1810-连续区间/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1811-联通分量计数/
│ │ │ └── f-51Nod-1811-联通分量计数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1815-调查任务/
│ │ │ └── f-51Nod-1815-调查任务/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1821-最优集合/
│ │ │ └── f-51Nod-1821-最优集合/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1829-函数/
│ │ │ └── f-51Nod-1829-函数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1831-小C的游戏/
│ │ │ └── f-51Nod-1831-小C的游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1832-先序遍历与后序遍历/
│ │ │ └── f-51Nod-1832-先序遍历与后序遍历/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1833-环/
│ │ │ └── f-51Nod-1833-环/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1835-完全图/
│ │ │ └── f-51Nod-1835-完全图/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1836-战忽局的手段/
│ │ │ └── f-51Nod-1836-战忽局的手段/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1837-砝码称重/
│ │ │ └── f-51Nod-1837-砝码称重/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1849-Clarke and package/
│ │ │ └── f-51Nod-1849-Clarke and package/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1859-Clarke and number/
│ │ │ └── f-51Nod-1859-Clarke and number/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1868-彩色树/
│ │ │ └── f-51Nod-1868-彩色树/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1874-字符串排序/
│ │ │ └── f-51Nod-1874-字符串排序/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1946-特殊表示法/
│ │ │ └── f-51Nod-1946-特殊表示法/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1952-栈/
│ │ │ └── f-51Nod-1952-栈/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1962-区间计数/
│ │ │ └── f-51Nod-1962-区间计数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1967-路径定向/
│ │ │ └── f-51Nod-1967-路径定向/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1969-Fire!/
│ │ │ └── f-51Nod-1969-Fire!/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1981-如何愉快地与STL玩耍/
│ │ │ └── f-51Nod-1981-如何愉快地与STL玩耍/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1995-三子棋/
│ │ │ └── f-51Nod-1995-三子棋/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-2000-四边形分割平面/
│ │ │ └── f-51Nod-2000-四边形分割平面/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-2006-飞行员配对（二分图最大匹配）/
│ │ │ └── f-51Nod-2006-飞行员配对（二分图最大匹配）/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-2020-排序相减/
│ │ │ └── f-51Nod-2020-排序相减/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-TalkingData数据科学精英夏令营挑战赛-A-初中的算术/
│ │ │ └── f-51Nod-TalkingData数据科学精英夏令营挑战赛-A-初中的算术/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-TalkingData数据科学精英夏令营挑战赛-B-丢手绢/
│ │ │ └── f-51Nod-TalkingData数据科学精英夏令营挑战赛-B-丢手绢/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-TalkingData数据科学精英夏令营挑战赛-C-好数/
│ │ │ └── f-51Nod-TalkingData数据科学精英夏令营挑战赛-C-好数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-TalkingData数据科学精英夏令营挑战赛-D-数据流中的算法-众数/
│ │ │ └── f-51Nod-TalkingData数据科学精英夏令营挑战赛-D-数据流中的算法-众数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-TalkingData数据科学精英夏令营挑战赛-E-路径定向/
│ │ │ └── f-51Nod-TalkingData数据科学精英夏令营挑战赛-E-路径定向/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-算法马拉松13-A-取余最长路/
│ │ │ └── f-51Nod-算法马拉松13-A-取余最长路/
│ │ │ └── main.c
│ │ ├── f-51Nod-算法马拉松13-B-数有几多愁/
│ │ │ └── f-51Nod-算法马拉松13-B-数有几多愁/
│ │ │ └── main.c
│ │ ├── f-51Nod-算法马拉松13-C-比大小/
│ │ │ └── f-51Nod-算法马拉松13-C-比大小/
│ │ │ └── main.c
│ │ ├── f-51Nod-算法马拉松15（脱欧专场）-A-B君的游戏/
│ │ │ └── f-51Nod-算法马拉松15（脱欧专场）-A-B君的游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-算法马拉松16-A-B君的连通/
│ │ │ └── f-51Nod-算法马拉松16-A-B君的连通/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-算法马拉松16-B-卷积和/
│ │ │ └── 51Nod-算法马拉松16-B-卷积和/
│ │ │ └── main.cpp
│ │ ├── f-BSG白山极客挑战赛-A-数数字/
│ │ │ └── f-BSG白山极客挑战赛-A-数数字/
│ │ │ └── main.c
│ │ ├── f-BSG白山极客挑战赛-B-AVL树的种类/
│ │ │ └── f-BSG白山极客挑战赛-B-AVL树的种类/
│ │ │ └── main.c
│ │ ├── f-算法马拉松17（告别奥运）-B-分解/
│ │ │ └── f-算法马拉松17（告别奥运）-B-分解/
│ │ │ └── main.cpp
│ │ ├── f-算法马拉松18-A-染色问题/
│ │ │ └── f-算法马拉松18-A-染色问题/
│ │ │ └── main.cpp
│ │ └── f-算法马拉松18-B-非010串/
│ │ └── f-算法马拉松18-B-非010串/
│ │ └── main.cpp
│ ├── BNUOJ/
│ │ └── f-BNUOJ-4052-BT马/
│ │ └── f-BNUOJ-4052-BT马/
│ │ └── main.c
│ ├── BZOJ/
│ │ └── f-BZOJ-2301-[HAOI2011]Problem b/
│ │ └── f-BZOJ-2301-[HAOI2011]Problem b/
│ │ └── main.cpp
│ ├── CCF/
│ │ ├── f-CCF模拟-1-出现次数最多的数/
│ │ │ └── f-CCF模拟-1-出现次数最多的数/
│ │ │ └── main.cpp
│ │ ├── f-CCF模拟-2-ISBN号码/
│ │ │ └── f-CCF模拟-2-ISBN号码/
│ │ │ └── main.cpp
│ │ ├── f-CCF模拟-3-最大的矩阵/
│ │ │ └── f-CCF模拟-3-最大的矩阵/
│ │ │ └── main.cpp
│ │ ├── f-CCF模拟-4-有趣的数/
│ │ │ └── f-CCF模拟-4-有趣的数/
│ │ │ └── main.cpp
│ │ └── f-CCF模拟-5-I’m stuck!/
│ │ └── f-CCF模拟-5-I’m stuck!/
│ │ └── main.cpp
│ ├── CDOJ/
│ │ ├── f-CDOJ-2016-A-柱爷与咸鱼神功/
│ │ │ └── f-CDOJ-2016-A-柱爷与咸鱼神功/
│ │ │ └── main.c
│ │ ├── f-CDOJ-2016-B-柱爷与最大区间和/
│ │ │ └── f-CDOJ-2016-B-柱爷与最大区间和/
│ │ │ └── main.c
│ │ ├── f-CDOJ-2016-C-柱爷的下凡/
│ │ │ └── f-CDOJ-2016-C-柱爷的下凡/
│ │ │ └── main.c
│ │ ├── f-CDOJ-2016-F-柱爷与三叉戟不得不说的故事/
│ │ │ └── f-CDOJ-2016-F-柱爷与三叉戟不得不说的故事/
│ │ │ └── main.c
│ │ └── f-CDOJ-2016-H-柱爷大战滑稽王/
│ │ └── f-CDOJ-2016-H-柱爷大战滑稽王/
│ │ └── main.c
│ ├── CF/
│ │ ├── f-BNU Training 2016.07.29 Div. 2-B-Levko and Table/
│ │ │ └── f-BNU Training 2016.07.29 Div. 2-B-Levko and Table/
│ │ │ └── main.cpp
│ │ ├── f-CF-Avito Code Challenge 2018-A-Antipalindrome/
│ │ │ └── f-CF-Avito Code Challenge 2018-A-Antipalindrome/
│ │ │ └── main.cpp
│ │ ├── f-CF-Avito Code Challenge 2018-B-Businessmen Problems/
│ │ │ └── f-CF-Avito Code Challenge 2018-B-Businessmen Problems/
│ │ │ └── main.cpp
│ │ ├── f-CF-Avito Code Challenge 2018-C-Useful Decomposition/
│ │ │ └── f-CF-Avito Code Challenge 2018-C-Useful Decomposition/
│ │ │ └── main.cpp
│ │ ├── f-CF-Avito Code Challenge 2018-D-Bookshelves/
│ │ │ └── f-CF-Avito Code Challenge 2018-D-Bookshelves/
│ │ │ └── main.cpp
│ │ ├── f-CF-Avito Code Challenge 2018-E-Addition on Segments/
│ │ │ └── f-CF-Avito Code Challenge 2018-E-Addition on Segments/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #210 (Div. 1)-A-Levko and Array Recovery/
│ │ │ └── f-CF-Codeforces Round #210 (Div. 1)-A-Levko and Array Recovery/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #365 (Div. 2)-A-Mishka and Game/
│ │ │ └── f-CF-Codeforces Round #365 (Div. 2)-A-Mishka and Game/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #365 (Div. 2)-B-Mishka and trip/
│ │ │ └── f-CF-Codeforces Round #365 (Div. 2)-B-Mishka and trip/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #366 (Div. 2)-A-Hulk/
│ │ │ └── f-CF-Codeforces Round #366 (Div. 2)-A-Hulk/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #377 (Div. 2)-A-Buy a Shovel/
│ │ │ └── f-CF-Codeforces Round #377 (Div. 2)-A-Buy a Shovel/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #377 (Div. 2)-B-Cormen — The Best Friend Of a Man/
│ │ │ └── f-CF-Codeforces Round #377 (Div. 2)-B-Cormen — The Best Friend Of a Man/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #392 (Div. 2)-A-Holiday Of Equality/
│ │ │ └── f-CF-Codeforces Round #392 (Div. 2)-A-Holiday Of Equality/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #392 (Div. 2)-B-Blown Garland/
│ │ │ └── f-CF-Codeforces Round #392 (Div. 2)-B-Blown Garland/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-A-Vicious Keyboard/
│ │ │ └── f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-A-Vicious Keyboard/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-B-Valued Keys/
│ │ │ └── f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-B-Valued Keys/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-C-Voltage Keepsake/
│ │ │ └── f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-C-Voltage Keepsake/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-D-Volatile Kite/
│ │ │ └── f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-D-Volatile Kite/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #410 (Div. 2)-A-Mike and palindrome/
│ │ │ └── f-CF-Codeforces Round #410 (Div. 2)-A-Mike and palindrome/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #410 (Div. 2)-B-Mike and strings/
│ │ │ └── f-CF-Codeforces Round #410 (Div. 2)-B-Mike and strings/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #410 (Div. 2)-C-Mike and gcd problem/
│ │ │ └── f-CF-Codeforces Round #410 (Div. 2)-C-Mike and gcd problem/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #410 (Div. 2)-D-Mike and distribution/
│ │ │ └── f-CF-Codeforces Round #410 (Div. 2)-D-Mike and distribution/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #418 (Div. 2)-C-An impassioned circulation of affection/
│ │ │ └── f-CF-Codeforces Round #418 (Div. 2)-C-An impassioned circulation of affection/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #420 (Div. 2)-A-Okabe and Future Gadget Laboratory/
│ │ │ └── f-CF-Codeforces Round #420 (Div. 2)-A-Okabe and Future Gadget Laboratory/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #420 (Div. 2)-B-Okabe and Banana Trees/
│ │ │ └── f-CF-Codeforces Round #420 (Div. 2)-B-Okabe and Banana Trees/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #420 (Div. 2)-C-Okabe and Boxes/
│ │ │ └── f-CF-Codeforces Round #420 (Div. 2)-C-Okabe and Boxes/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #420 (Div. 2)-D-Okabe and City/
│ │ │ └── f-CF-Codeforces Round #420 (Div. 2)-D-Okabe and City/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #420 (Div. 2)-E-Okabe and El Psy Kongroo/
│ │ │ └── f-CF-Codeforces Round #420 (Div. 2)-E-Okabe and El Psy Kongroo/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #483 (Div. 2)-A-Game/
│ │ │ └── f-CF-Codeforces Round #483 (Div. 2)-A-Game/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #483 (Div. 2)-B-Minesweeper/
│ │ │ └── f-CF-Codeforces Round #483 (Div. 2)-B-Minesweeper/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #483 (Div. 2)-C-Finite or not?/
│ │ │ └── f-CF-Codeforces Round #483 (Div. 2)-C-Finite or not?/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #483 (Div. 2)-D-XOR-pyramid/
│ │ │ └── f-CF-Codeforces Round #483 (Div. 2)-D-XOR-pyramid/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #485 (Div. 2)/
│ │ │ ├── A-Infinity Gauntlet/
│ │ │ │ └── main.cpp
│ │ │ ├── B-High School: Become Human/
│ │ │ │ └── main.cpp
│ │ │ ├── C-Three displays/
│ │ │ │ └── main.cpp
│ │ │ ├── D-Fair/
│ │ │ │ └── main.cpp
│ │ │ └── E-Petr and Permutations/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #487 (Div. 2)/
│ │ │ ├── A-A Blend of Springtime/
│ │ │ │ └── main.cpp
│ │ │ ├── B-A Tide of Riverscape/
│ │ │ │ └── main.cpp
│ │ │ ├── C-A Mist of Florescence/
│ │ │ │ └── main.cpp
│ │ │ └── D-A Shade of Moonlight/
│ │ │ └── main.cpp
│ │ ├── f-CF-Educational Codeforces Round 15-A-Maximum Increase/
│ │ │ └── f-CF-Educational Codeforces Round 15-A-Maximum Increase/
│ │ │ └── main.cpp
│ │ ├── f-CF-Educational Codeforces Round 15-B-Powers of Two/
│ │ │ └── CF-Educational Codeforces Round 15-B-Powers of Two/
│ │ │ └── main.cpp
│ │ ├── f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-A-Chess Placing/
│ │ │ └── f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-A-Chess Placing/
│ │ │ └── main.cpp
│ │ ├── f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-B-Switches and Lamps/
│ │ │ └── f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-B-Switches and Lamps/
│ │ │ └── main.cpp
│ │ ├── f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-C-Liebig's Barrels/
│ │ │ └── f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-C-Liebig's Barrels/
│ │ │ └── main.cpp
│ │ ├── f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-D-Sand Fortress/
│ │ │ └── f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-D-Sand Fortress/
│ │ │ └── main.cpp
│ │ ├── f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-E-Pencils and Boxes/
│ │ │ └── f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-E-Pencils and Boxes/
│ │ │ └── main.cpp
│ │ ├── f-CF-Tinkoff Challenge-Elimination Round-A-Oleg and shares/
│ │ │ └── f-CF-Tinkoff Challenge-Elimination Round-A-Oleg and shares/
│ │ │ └── main.cpp
│ │ ├── f-CF-Tinkoff Challenge-Elimination Round-B-Igor and his way to work/
│ │ │ └── f-CF-Tinkoff Challenge-Elimination Round-B-Igor and his way to work/
│ │ │ └── main.cpp
│ │ ├── f-CF-Tinkoff Challenge-Elimination Round-C-Mice problem/
│ │ │ └── f-CF-Tinkoff Challenge-Elimination Round-C-Mice problem/
│ │ │ └── main.cpp
│ │ └── f-CF-Tinkoff Challenge-Elimination Round-D-Presents in Bankopolis/
│ │ └── f-CF-Tinkoff Challenge-Elimination Round-D-Presents in Bankopolis/
│ │ └── main.cpp
│ ├── EOJ/
│ │ ├── f-EOJ-大学生程序设计邀请赛（华东师范大学）-A-拼音魔法/
│ │ │ └── f-EOJ-大学生程序设计邀请赛（华东师范大学）-A-拼音魔法/
│ │ │ └── main.cpp
│ │ ├── f-EOJ-大学生程序设计邀请赛（华东师范大学）-B-分词/
│ │ │ └── f-EOJ-大学生程序设计邀请赛（华东师范大学）-B-分词/
│ │ │ └── main.cpp
│ │ ├── f-EOJ-大学生程序设计邀请赛（华东师范大学）-C-袋鼠妈妈找孩子/
│ │ │ └── f-EOJ-大学生程序设计邀请赛（华东师范大学）-C-袋鼠妈妈找孩子/
│ │ │ └── main.cpp
│ │ ├── f-EOJ-大学生程序设计邀请赛（华东师范大学）-D-实验室传染病/
│ │ │ └── f-EOJ-大学生程序设计邀请赛（华东师范大学）-D-实验室传染病/
│ │ │ └── main.cpp
│ │ ├── f-EOJ-大学生程序设计邀请赛（华东师范大学）-E-黑心啤酒厂/
│ │ │ └── f-EOJ-大学生程序设计邀请赛（华东师范大学）-E-黑心啤酒厂/
│ │ │ └── main.cpp
│ │ ├── f-EOJ-大学生程序设计邀请赛（华东师范大学）-F-丽娃河的狼人传说/
│ │ │ └── f-EOJ-大学生程序设计邀请赛（华东师范大学）-F-丽娃河的狼人传说/
│ │ │ └── main.cpp
│ │ ├── f-EOJ-大学生程序设计邀请赛（华东师范大学）-G-铁路修复计划/
│ │ │ └── f-EOJ-大学生程序设计邀请赛（华东师范大学）-G-铁路修复计划/
│ │ │ └── main.cpp
│ │ ├── f-EOJ-大学生程序设计邀请赛（华东师范大学）-H-法国传统舞蹈/
│ │ │ └── f-EOJ-大学生程序设计邀请赛（华东师范大学）-H-法国传统舞蹈/
│ │ │ └── main.cpp
│ │ └── f-EOJ-大学生程序设计邀请赛（华东师范大学）-I-七巧板/
│ │ └── f-EOJ-大学生程序设计邀请赛（华东师范大学）-I-七巧板/
│ │ └── main.cpp
│ ├── GDUT/
│ │ └── f-GDUT-1164-找出出现次数超过一半的数/
│ │ └── f-GDUT-1164-找出出现次数超过一半的数/
│ │ └── main.cpp
│ ├── HDU/
│ │ ├── ICPC Asia Regional Qingdao Online-1001-Apple/
│ │ │ └── ICPC Asia Regional Qingdao Online-1001-Apple/
│ │ │ └── main.cpp
│ │ ├── ICPC Asia Regional Qingdao Online-1003-The Dominator of Strings/
│ │ │ └── ICPC Asia Regional Qingdao Online-1003-The Dominator of Strings/
│ │ │ └── main.cpp
│ │ ├── ICPC Asia Regional Qingdao Online-1008-Chinese Zodiac/
│ │ │ └── ICPC Asia Regional Qingdao Online-1008-Chinese Zodiac/
│ │ │ └── main.cpp
│ │ ├── ICPC Asia Regional Qingdao Online-1009-Smallest Minimum Cut/
│ │ │ └── ICPC Asia Regional Qingdao Online-1009-Smallest Minimum Cut/
│ │ │ └── main.cpp
│ │ ├── ICPC Asia Regional Qingdao Online-1010-Brute Force Sorting/
│ │ │ └── ICPC Asia Regional Qingdao Online-1010-Brute Force Sorting/
│ │ │ └── main.cpp
│ │ ├── ICPC Asia Regional Qingdao Online-1011-A Cubic number and A Cubic Number/
│ │ │ └── ICPC Asia Regional Qingdao Online-1011-A Cubic number and A Cubic Number/
│ │ │ └── main.cpp
│ │ ├── ICPC Asia Regional Shenyang Online-1001-string string string/
│ │ │ └── ICPC Asia Regional Shenyang Online-1001-string string string/
│ │ │ └── main.cpp
│ │ ├── ICPC Asia Regional Shenyang Online-1002-cable cable cable/
│ │ │ └── ICPC Asia Regional Shenyang Online-1002-cable cable cable/
│ │ │ └── main.cpp
│ │ ├── ICPC Asia Regional Shenyang Online-1004-array array array/
│ │ │ └── ICPC Asia Regional Shenyang Online-1004-array array array/
│ │ │ └── main.cpp
│ │ ├── ICPC Asia Regional Shenyang Online-1005-number number number/
│ │ │ └── ICPC Asia Regional Shenyang Online-1005-number number number/
│ │ │ └── main.cpp
│ │ ├── ICPC Asia Regional Shenyang Online-1008-transaction transaction transaction/
│ │ │ └── ICPC Asia Regional Shenyang Online-1008-transaction transaction transaction/
│ │ │ └── main.cpp
│ │ ├── ICPC Asia Regional Shenyang Online-1012-card card card/
│ │ │ └── ICPC Asia Regional Shenyang Online-1012-card card card/
│ │ │ └── main.cpp
│ │ ├── f-2016"百度之星"-资格赛-1001-A/
│ │ │ └── f-2016"百度之星"-资格赛-1001-A/
│ │ │ └── main.c
│ │ ├── f-2017"百度之星"程序设计大赛-资格赛-1002-度度熊的王国战略/
│ │ │ └── f-2017"百度之星"程序设计大赛-资格赛-1002-度度熊的王国战略/
│ │ │ └── main.cpp
│ │ ├── f-2017"百度之星"程序设计大赛-资格赛-1003-度度熊与邪恶大魔王/
│ │ │ └── f-2017"百度之星"程序设计大赛-资格赛-1003-度度熊与邪恶大魔王/
│ │ │ └── main.cpp
│ │ ├── f-2017"百度之星"程序设计大赛-资格赛-1004-度度熊的午饭时光/
│ │ │ └── f-2017"百度之星"程序设计大赛-资格赛-1004-度度熊的午饭时光/
│ │ │ └── main.cpp
│ │ ├── f-HDOJ-2066-一个人的旅行/
│ │ │ └── f-HDOJ-2066-一个人的旅行/
│ │ │ └── main.c
│ │ ├── f-HDU-1003-Max Sum/
│ │ │ └── f-HDU-1003-Max Sum/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1004-Let the Balloon Rise/
│ │ │ └── f-HDU-1004-Let the Balloon Rise/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1005-Number Sequence/
│ │ │ └── f-HDU-1005-Number Sequence/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1007-Quoit Design/
│ │ │ └── f-HDU-1007-Quoit Design/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1008-Elevator/
│ │ │ └── f-HDU-1008-Elevator/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1009-FatMouse' Trade/
│ │ │ └── f-HDU-1009-FatMouse' Trade/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1010-Tempter of the Bone/
│ │ │ └── f-HDU-1010-Tempter of the Bone/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1011-Starship Troopers/
│ │ │ └── f-HDU-1011-Starship Troopers/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1021-Fibonacci Again/
│ │ │ └── f-HDU-1021-Fibonacci Again/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1050-Moving Tables/
│ │ │ └── f-HDU-1050-Moving Tables/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1102-Constructing Roads/
│ │ │ └── f-HDU-1102-Constructing Roads/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1142-A Walk Through the Forest/
│ │ │ └── f-HDU-1142-A Walk Through the Forest/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1162-Eddy's picture/
│ │ │ └── f-HDU-1162-Eddy's picture/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1166-敌兵布阵/
│ │ │ └── f-HDU-1166-敌兵布阵/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1176-免费馅饼/
│ │ │ └── f-HDU-1176-免费馅饼/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1198-Farm Irrigation/
│ │ │ └── f-HDU-1198-Farm Irrigation/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1213-How Many Tables/
│ │ │ └── f-HDU-1213-How Many Tables/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1217-Arbitrage/
│ │ │ └── f-HDU-1217-Arbitrage/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1224-Free DIY Tour/
│ │ │ └── f-HDU-1224-Free DIY Tour/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1232-畅通工程/
│ │ │ └── f-HDU-1232-畅通工程/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1233-还是畅通工程/
│ │ │ └── f-HDU-1233-还是畅通工程/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1245-Saving James Bond/
│ │ │ └── f-HDU-1245-Saving James Bond/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1272-小希的迷宫/
│ │ │ └── f-HDU-1272-小希的迷宫/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1286-找新朋友/
│ │ │ └── f-HDU-1286-找新朋友/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1301-Jungle Roads/
│ │ │ └── f-HDU-1301-Jungle Roads/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1317-XYZZY/
│ │ │ └── f-HDU-1317-XYZZY/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1325-Is It A Tree?/
│ │ │ └── f-HDU-1325-Is It A Tree?/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1385-Minimum Transport Cost/
│ │ │ └── f-HDU-1385-Minimum Transport Cost/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1394-Minimum Inversion Number/
│ │ │ └── f-HDU-1394-Minimum Inversion Number/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1402-A*B Problem Plus/
│ │ │ └── f-HDU-1402-A*B Problem Plus/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1512-Monkey King/
│ │ │ └── f-HDU-1512-Monkey King/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1532-Drainage Ditches/
│ │ │ └── f-HDU-1532-Drainage Ditches/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1535-Invitation Cards/
│ │ │ └── f-HDU-1535-Invitation Cards/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1546-Idiomatic Phrases Game/
│ │ │ └── f-HDU-1546-Idiomatic Phrases Game/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1548-A strange lift/
│ │ │ └── f-HDU-1548-A strange lift/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1558-Segment set/
│ │ │ └── f-HDU-1558-Segment set/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1573-X问题/
│ │ │ └── f-51Nod-1573-X问题/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1576-A÷B/
│ │ │ └── f-HDU-1576-A÷B/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1595-find the longest of the shortest/
│ │ │ └── f-HDU-1595-find the longest of the shortest/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1596-find the safest road/
│ │ │ └── f-HDU-1596-find the safest road/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1598-find the most comfortable road/
│ │ │ └── f-HDU-1598-find the most comfortable road/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1599-find the mincost route/
│ │ │ └── f-HDU-1599-find the mincost route/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1688-Sightseeing/
│ │ │ └── f-HDU-1688-Sightseeing/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1690-Bus System/
│ │ │ └── f-HDU-1690-Bus System/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1695-GCD/
│ │ │ └── f-HDU-1695-GCD/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1698-Just a Hook/
│ │ │ └── f-HDU-1698-Just a Hook/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1754-I Hate It/
│ │ │ └── f-HDU-1754-I Hate It/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1811-Rank of Tetris/
│ │ │ └── f-HDU-1811-Rank of Tetris/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1829-A Bug's Life/
│ │ │ └── f-HDU-1829-A Bug's Life/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1839-Delay Constrained Maximum Capacity Path/
│ │ │ └── f-HDU-1839-Delay Constrained Maximum Capacity Path/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1846-Brave Game/
│ │ │ └── f-HDU-1846-Brave Game/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1847-Good Luck in CET-4 Everybody!/
│ │ │ └── f-HDU-1847-Good Luck in CET-4 Everybody!/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1850-Being a Good Boy in Spring Festival/
│ │ │ └── f-HDU-1850-Being a Good Boy in Spring Festival/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1856-More is better/
│ │ │ └── f-HDU-1856-More is better/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1863-畅通工程/
│ │ │ └── f-HDU-1863-畅通工程/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1869-六度分离/
│ │ │ └── f-HDU-1869-六度分离/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1874-畅通工程续/
│ │ │ └── f-HDU-1874-畅通工程续/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1875-畅通工程再续/
│ │ │ └── f-HDU-1875-畅通工程再续/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1879-继续畅通工程/
│ │ │ └── f-HDU-1879-继续畅通工程/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2000-ASCII码排序/
│ │ │ └── f-HDU-2000-ASCII码排序/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2007-平方和与立方和/
│ │ │ └── f-HDU-2007-平方和与立方和/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2010-水仙花数/
│ │ │ └── f-HDU-2010-水仙花数/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛1-1001-Add More Zero/
│ │ │ └── f-HDU-2017 多校训练赛1-1001-Add More Zero/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛1-1002-Balala Power!/
│ │ │ └── f-HDU-2017 多校训练赛1-1002-Balala Power!/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛1-1003-Colorful Tree/
│ │ │ └── f-HDU-2017 多校训练赛1-1003-Colorful Tree/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛1-1006-Function/
│ │ │ └── f-HDU-2017 多校训练赛1-1006-Function/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛1-1008-Hints of sd0061/
│ │ │ └── f-HDU-2017 多校训练赛1-1008-Hints of sd0061/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛1-1011-KazaQ's Socks/
│ │ │ └── f-HDU-2017 多校训练赛1-1011-KazaQ's Socks/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛10-1001-Admiral/
│ │ │ └── f-HDU-2017 多校训练赛10-1001-Admiral/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛10-1002-Array Challenge/
│ │ │ └── f-HDU-2017 多校训练赛10-1002-Array Challenge/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛10-1008-Monkeys/
│ │ │ └── f-HDU-2017 多校训练赛10-1008-Monkeys/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛10-1010-Schedule/
│ │ │ └── f-HDU-2017 多校训练赛10-1010-Schedule/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛10-1011-Two Paths/
│ │ │ └── f-HDU-2017 多校训练赛10-1011-Two Paths/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛2-1001-Is Derek lying?/
│ │ │ └── f-HDU-2017 多校训练赛2-1001-Is Derek lying?/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛2-1003-Maximum Sequence/
│ │ │ └── f-HDU-2017 多校训练赛2-1003-Maximum Sequence/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛2-1006-Funny Function/
│ │ │ └── f-HDU-2017 多校训练赛2-1006-Funny Function/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛2-1008-To my boyfriend/
│ │ │ └── f-HDU-2017 多校训练赛2-1008-To my boyfriend/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛2-1009-TrickGCD/
│ │ │ └── f-HDU-2017 多校训练赛2-1009-TrickGCD/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛2-1011-Regular polygon/
│ │ │ └── f-HDU-2017 多校训练赛2-1011-Regular polygon/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛3-1001-simple counting problem/
│ │ │ └── f-HDU-2017 多校训练赛3-1001-simple counting problem/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛3-1003-Kanade’s sum/
│ │ │ └── f-HDU-2017 多校训练赛3-1003-Kanade’s sum/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛3-1004-Kanade's trio/
│ │ │ └── f-HDU-2017 多校训练赛3-1004-Kanade's trio/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛3-1005-RXD and dividing/
│ │ │ └── f-HDU-2017 多校训练赛3-1005-RXD and dividing/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛3-1008-RXD and math/
│ │ │ └── f-HDU-2017 多校训练赛3-1008-RXD and math/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛3-1011-RXD's date/
│ │ │ └── f-HDU-2017 多校训练赛3-1011-RXD's date/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛4-1003-Counting Divisors/
│ │ │ └── f-HDU-2017 多校训练赛4-1003-Counting Divisors/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛4-1004-Dirt Ratio/
│ │ │ └── f-HDU-2017 多校训练赛4-1004-Dirt Ratio/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛4-1007-Matching In Multiplication/
│ │ │ └── f-HDU-2017 多校训练赛4-1007-Matching In Multiplication/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛4-1009-Questionnaire/
│ │ │ └── f-HDU-2017 多校训练赛4-1009-Questionnaire/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛4-1011-Time To Get Up/
│ │ │ └── f-HDU-2017 多校训练赛4-1011-Time To Get Up/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛4-1012-Wavel Sequence/
│ │ │ └── f-HDU-2017 多校训练赛4-1012-Wavel Sequence/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛5-1001-Rikka with Candies/
│ │ │ └── f-HDU-2017 多校训练赛5-1001-Rikka with Candies/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛5-1006-Rikka with Graph/
│ │ │ └── f-HDU-2017 多校训练赛5-1006-Rikka with Graph/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛5-1008-Rikka with Subset/
│ │ │ └── f-HDU-2017 多校训练赛5-1008-Rikka with Subset/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛5-1011-Rikka with Competition/
│ │ │ └── f-HDU-2017 多校训练赛5-1011-Rikka with Competition/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛6-1002-Mindis/
│ │ │ └── f-HDU-2017 多校训练赛6-1002-Mindis/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛6-1003-Inversion/
│ │ │ └── f-HDU-2017 多校训练赛6-1003-Inversion/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛6-1007-GCDispower/
│ │ │ └── f-HDU-2017 多校训练赛6-1007-GCDispower/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛6-1008-Kirinriki/
│ │ │ └── f-HDU-2017 多校训练赛6-1008-Kirinriki/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛6-1010-Gameia/
│ │ │ └── f-HDU-2017 多校训练赛6-1010-Gameia/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛6-1011-Classes/
│ │ │ └── f-HDU-2017 多校训练赛6-1011-Classes/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛7-1002-Build a tree/
│ │ │ └── f-HDU-2017 多校训练赛7-1002-Build a tree/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛7-1005-Euler theorem/
│ │ │ └── f-HDU-2017 多校训练赛7-1005-Euler theorem/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛7-1008-Hard challenge/
│ │ │ └── f-HDU-2017 多校训练赛7-1008-Hard challenge/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛7-1010-Just do it/
│ │ │ └── f-HDU-2017 多校训练赛7-1010-Just do it/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛7-1011-Kolakoski/
│ │ │ └── f-HDU-2017 多校训练赛7-1011-Kolakoski/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛8-1002-Battlestation Operational/
│ │ │ └── f-HDU-2017 多校训练赛8-1002-Battlestation Operational/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛8-1006-Fleet of the Eternal Throne/
│ │ │ └── f-HDU-2017 多校训练赛8-1006-Fleet of the Eternal Throne/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛8-1008-Hybrid Crystals/
│ │ │ └── f-HDU-2017 多校训练赛8-1008-Hybrid Crystals/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛8-1011-Killer Names/
│ │ │ └── f-HDU-2017 多校训练赛8-1011-Killer Names/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛9-1002-Ch’s gift/
│ │ │ └── f-HDU-2017 多校训练赛9-1002-Ch’s gift/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛9-1005-FFF at Valentine/
│ │ │ └── f-HDU-2017 多校训练赛9-1005-FFF at Valentine/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛9-1006-Senior Pan/
│ │ │ └── f-HDU-2017 多校训练赛9-1006-Senior Pan/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛9-1008-Numbers/
│ │ │ └── f-HDU-2017 多校训练赛9-1008-Numbers/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛9-1010-Two strings/
│ │ │ └── f-HDU-2017 多校训练赛9-1010-Two strings/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017"百度之星"程序设计大赛-初赛(B)-1001-Chess/
│ │ │ └── f-HDU-2017"百度之星"程序设计大赛-初赛(B)-1001-Chess/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017"百度之星"程序设计大赛-初赛(B)-1002-Factory/
│ │ │ └── f-HDU-2017"百度之星"程序设计大赛-初赛(B)-1002-Factory/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017"百度之星"程序设计大赛-初赛(B)-1005-度度熊的交易计划/
│ │ │ └── f-HDU-2017"百度之星"程序设计大赛-初赛(B)-1005-度度熊的交易计划/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017"百度之星"程序设计大赛-初赛(B)-1006-小小粉丝度度熊/
│ │ │ └── f-HDU-2017"百度之星"程序设计大赛-初赛(B)-1006-小小粉丝度度熊/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017"百度之星"程序设计大赛-复赛-1001-Arithmetic of Bomb/
│ │ │ └── f-HDU-2017"百度之星"程序设计大赛-复赛-1001-Arithmetic of Bomb/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017"百度之星"程序设计大赛-复赛-1003-Pokémon GO/
│ │ │ └── f-HDU-2017"百度之星"程序设计大赛-复赛-1003-Pokémon GO/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017"百度之星"程序设计大赛-复赛-1005-Valley Numer/
│ │ │ └── f-HDU-2017"百度之星"程序设计大赛-复赛-1005-Valley Numer/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017"百度之星"程序设计大赛-复赛-1006-Valley Numer II/
│ │ │ └── f-HDU-2017"百度之星"程序设计大赛-复赛-1006-Valley Numer II/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1001-Vertex Cover/
│ │ │ └── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1001-Vertex Cover/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1003-Friend-Graph/
│ │ │ └── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1003-Friend-Graph/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1004-A Secret/
│ │ │ └── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1004-A Secret/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1005-CaoHaha's staff/
│ │ │ └── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1005-CaoHaha's staff/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1006-Subsequence Count/
│ │ │ └── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1006-Subsequence Count/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1007-Palindrome Function/
│ │ │ └── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1007-Palindrome Function/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2050-折线分割平面/
│ │ │ └── f-HDU-2050-折线分割平面/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2058-The sum problem/
│ │ │ └── f-HDU-2058-The sum problem/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2066-一个人的旅行/
│ │ │ └── f-HDU-2066-一个人的旅行/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2112-HDU Today/
│ │ │ └── f-HDU-2112-HDU Today/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2121-Ice_cream’s world II/
│ │ │ └── f-HDU-2121-Ice_cream’s world II/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2211-杀人游戏/
│ │ │ └── f-HDU-2211-杀人游戏/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2224-The shortest path/
│ │ │ └── f-HDU-2224-The shortest path/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2363-Cycling/
│ │ │ └── f-HDU-2363-Cycling/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2377-Bus Pass/
│ │ │ └── f-HDU-2377-Bus Pass/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2473-Junk-Mail Filter/
│ │ │ └── f-HDU-2473-Junk-Mail Filter/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2489-Minimal Ratio Tree/
│ │ │ └── f-HDU-2489-Minimal Ratio Tree/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2490-Parade/
│ │ │ └── f-HDU-2490-Parade/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2516-取石子游戏/
│ │ │ └── f-HDU-2516-取石子游戏/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2544-最短路/
│ │ │ └── f-HDU-2544-最短路/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2586-How far away ？/
│ │ │ └── f-HDU-2586-How far away ？/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2588-GCD/
│ │ │ └── f-HDU-2588-GCD/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2680-Choose the best route/
│ │ │ └── f-HDU-2680-Choose the best route/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2722-Here We Go(relians) Again/
│ │ │ └── f-HDU-2722-Here We Go(relians) Again/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2795-Billboard/
│ │ │ └── f-HDU-2795-Billboard/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2807-The Shortest Path/
│ │ │ └── f-HDU-2807-The Shortest Path/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2818-Building Block/
│ │ │ └── f-HDU-2818-Building Block/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2833-WuKong/
│ │ │ └── f-HDU-2833-WuKong/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2874-Connections between cities/
│ │ │ └── f-HDU-2874-Connections between cities/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2888-Check Corners/
│ │ │ └── f-HDU-2888-Check Corners/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2923-Einbahnstrasse/
│ │ │ └── f-HDU-2923-Einbahnstrasse/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2962-Trucking/
│ │ │ └── f-HDU-2962-Trucking/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3035-War/
│ │ │ └── f-HDU-3035-War/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3038-How Many Answers Are Wrong/
│ │ │ └── f-HDU-3038-How Many Answers Are Wrong/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3047-Zjnu Stadium/
│ │ │ └── f-HDU-3047-Zjnu Stadium/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3138-Coconuts/
│ │ │ └── f-HDU-3138-Coconuts/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3172-Virtual Friends/
│ │ │ └── f-HDU-3172-Virtual Friends/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3183-A Magic Lamp/
│ │ │ └── f-HDU-3183-A Magic Lamp/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3191-How Many Paths Are There/
│ │ │ └── f-HDU-3191-How Many Paths Are There/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3237-Help Bubu/
│ │ │ └── f-HDU-3237-Help Bubu/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3308-LCIS/
│ │ │ └── f-HDU-3308-LCIS/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3311-Dig The Wells/
│ │ │ └── f-HDU-3311-Dig The Wells/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3339-In Action/
│ │ │ └── f-HDU-3339-In Action/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3364-Lanterns/
│ │ │ └── f-HDU-3364-Lanterns/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3367-Pseudoforest/
│ │ │ └── f-HDU-3367-Pseudoforest/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3371-Connect the Cities/
│ │ │ └── f-HDU-3371-Connect the Cities/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3397-Sequence operation/
│ │ │ └── f-HDU-3397-Sequence operation/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3461-Code Lock/
│ │ │ └── f-HDU-3461-Code Lock/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3486-Interviewe/
│ │ │ └── f-HDU-3486-Interviewe/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3549-Flow Problem/
│ │ │ └── f-HDU-3549-Flow Problem/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3572-Task Schedule/
│ │ │ └── f-HDU-3572-Task Schedule/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3631-Shortest Path/
│ │ │ └── f-HDU-3631-Shortest Path/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3635-Dragon Balls/
│ │ │ └── f-HDU-3635-Dragon Balls/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3672-Caves/
│ │ │ └── f-HDU-3672-Caves/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3757-Evacuation Plan/
│ │ │ └── f-HDU-3757-Evacuation Plan/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3768-Shopping/
│ │ │ └── f-HDU-3768-Shopping/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3790-最短路径问题/
│ │ │ └── f-HDU-3790-最短路径问题/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3832-Earth Hour/
│ │ │ └── f-HDU-3832-Earth Hour/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3860-Circuit Board/
│ │ │ └── f-HDU-3860-Circuit Board/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3870-Catch the Theves/
│ │ │ └── f-HDU-3870-Catch the Theves/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3923-Invoker/
│ │ │ └── f-HDU-3923-Invoker/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3926-Hand in Hand/
│ │ │ └── f-HDU-3926-Hand in Hand/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3938-Portal/
│ │ │ └── f-HDU-3938-Portal/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3986-Harry Potter and the Final Battle/
│ │ │ └── f-HDU-3986-Harry Potter and the Final Battle/
│ │ │ └── main.cpp
│ │ ├── f-HDU-4009-Transfer water/
│ │ │ └── f-HDU-4009-Transfer water/
│ │ │ └── main.cpp
│ │ ├── f-HDU-4081-Qin Shi Huang's National Road System/
│ │ │ └── f-HDU-4081-Qin Shi Huang's National Road System/
│ │ │ └── main.cpp
│ │ ├── f-HDU-4114-Disney's FastPass/
│ │ │ └── f-HDU-4114-Disney's FastPass/
│ │ │ └── main.cpp
│ │ ├── f-HDU-4179-Difficult Routes/
│ │ │ └── f-HDU-4179-Difficult Routes/
│ │ │ └── main.cpp
│ │ ├── f-HDU-4405-Aeroplane chess/
│ │ │ └── f-HDU-4405-Aeroplane chess/
│ │ │ └── main.cpp
│ │ ├── f-HDU-4609-3-idiots/
│ │ │ └── f-HDU-4609-3-idiots/
│ │ │ └── main.cpp
│ │ ├── f-HDU-4651-Partition/
│ │ │ └── f-HDU-4651-Partition/
│ │ │ └── main.cpp
│ │ ├── f-HDU-4658-Integer Partition/
│ │ │ └── f-HDU-4658-Integer Partition/
│ │ │ └── main.cpp
│ │ ├── f-HDU-4841-圆桌问题/
│ │ │ └── f-HDU-4841-圆桌问题/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5512-Pagodas/
│ │ │ └── f-HDU-5512-Pagodas/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5514-Frogs/
│ │ │ └── f-HDU-5514-Frogs/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5517-Triple/
│ │ │ └── f-HDU-5517-Triple/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5534-Partial Tree/
│ │ │ └── f-HDU-5534-Partial Tree/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5556-Land of Farms/
│ │ │ └── f-HDU-5556-Land of Farms/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5558-Alice's Classified Message/
│ │ │ └── f-HDU-5558-Alice's Classified Message/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5559-Frog and String/
│ │ │ └── f-HDU-5559-Frog and String/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5572-An Easy Physics Problem/
│ │ │ └── f-HDU-5572-An Easy Physics Problem/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5575-Discover Water Tank/
│ │ │ └── f-HDU-5575-Discover Water Tank/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5584-LCM Walk/
│ │ │ └── f-HDU-5584-LCM Walk/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5698-瞬间移动/
│ │ │ └── f-HDU-5698-瞬间移动/
│ │ │ └── main.c
│ │ ├── f-HDU-5700-区间交/
│ │ │ └── f-HDU-5700-区间交/
│ │ │ └── main.c
│ │ ├── f-HDU-5701-中位数计数/
│ │ │ └── f-HDU-5701-中位数计数/
│ │ │ └── main.c
│ │ ├── f-HDU-5791-Two/
│ │ │ └── f-HDU-5791-Two/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5833-Zhu and 772002/
│ │ │ └── f-HDU-5833-Zhu and 772002/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5874-Friends and Enemies/
│ │ │ └── f-HDU-5874-Friends and Enemies/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5877-Weak Pair/
│ │ │ └── f-HDU-5877-Weak Pair/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5878-I Count Two Three/
│ │ │ └── f-HDU-5878-I Count Two Three/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5879-Cure/
│ │ │ └── f-HDU-5879-Cure/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5881-Tea/
│ │ │ └── f-HDU-5881-Tea/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5883-The Best Path/
│ │ │ └── f-HDU-5883-The Best Path/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5884-Sort/
│ │ │ └── f-HDU-5884-Sort/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5886-Tower Defence/
│ │ │ └── f-HDU-5886-Tower Defence/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5889-Barricade/
│ │ │ └── f-HDU-5889-Barricade/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5912-Fraction/
│ │ │ └── f-HDU-5912-Fraction/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5933-ArcSoft's Office Rearrangement/
│ │ │ └── f-HDU-5933-ArcSoft's Office Rearrangement/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5935-Car/
│ │ │ └── f-HDU-5935-Car/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5943-Kingdom of Obsession/
│ │ │ └── f-HDU-5943-Kingdom of Obsession/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5955-Guessing the Dice Roll/
│ │ │ └── f-HDU-5955-Guessing the Dice Roll/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5982-Relic Discovery/
│ │ │ └── f-HDU-5982-Relic Discovery/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5984-Pocky/
│ │ │ └── f-HDU-5984-Pocky/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5985-Lucky Coins/
│ │ │ └── f-HDU-5985-Lucky Coins/
│ │ │ └── main.cpp
│ │ ├── f-HDU-6000-Wash/
│ │ │ └── f-HDU-6000-Wash/
│ │ │ └── main.cpp
│ │ ├── f-HDU-6004-Periodical Cicadas/
│ │ │ └── f-HDU-6004-Periodical Cicadas/
│ │ │ └── main.cpp
│ │ ├── f-HDU-6006-Engineer Assignment/
│ │ │ └── f-HDU-6006-Engineer Assignment/
│ │ │ └── main.cpp
│ │ ├── f-HDU-6008-Worried School/
│ │ │ └── f-HDU-6008-Worried School/
│ │ │ └── main.cpp
│ │ ├── f-HDU-6010-Daylight Saving Time/
│ │ │ └── f-HDU-6010-Daylight Saving Time/
│ │ │ └── main.cpp
│ │ └── f-HDU-6249-Alice’s Stamps/
│ │ └── f-HDU-6249-Alice’s Stamps/
│ │ └── main.cpp
│ ├── HENUOJ/
│ │ └── f-HENUOJ-1036-B-小女♂孩采蘑菇/
│ │ └── f-HENUOJ-1036-B-小女♂孩采蘑菇/
│ │ └── main.cpp
│ ├── HOJ/
│ │ └── f-HOJ-1983-Beautiful numbers/
│ │ └── f-HOJ-1983-Beautiful numbers/
│ │ └── main.cpp
│ ├── HPU/
│ │ └── f-HPU-1008-Mod/
│ │ └── f-HPU-1008-Mod/
│ │ └── main.cpp
│ ├── HRBUST/
│ │ └── f-HRBUST-1025-JiaoZhu and WAR3/
│ │ └── f-HRBUST-1025-JiaoZhu and WAR3/
│ │ └── main.cpp
│ ├── NEUQ/
│ │ ├── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-A-谷神的赌博游戏/
│ │ │ └── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-A-谷神的赌博游戏/
│ │ │ └── main.cpp
│ │ ├── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-B-一个简单的问题/
│ │ │ └── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-B-一个简单的问题/
│ │ │ └── main.cpp
│ │ ├── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-C-来简单地数个数/
│ │ │ └── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-C-来简单地数个数/
│ │ │ └── main.cpp
│ │ ├── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-D-简单图形输出/
│ │ │ └── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-D-简单图形输出/
│ │ │ └── main.cpp
│ │ ├── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-E-简单的RMQ/
│ │ │ └── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-E-简单的RMQ/
│ │ │ └── main.cpp
│ │ ├── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-F-一道简单的递推题/
│ │ │ └── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-F-一道简单的递推题/
│ │ │ └── main.cpp
│ │ ├── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-G-那么大奶牛之神/
│ │ │ └── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-G-那么大奶牛之神/
│ │ │ └── main.cpp
│ │ ├── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-H-简单的机械臂设计/
│ │ │ └── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-H-简单的机械臂设计/
│ │ │ └── main.cpp
│ │ ├── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-I-一道不简单的题目/
│ │ │ └── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-I-一道不简单的题目/
│ │ │ └── main.cpp
│ │ └── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-J-简单的变位词/
│ │ └── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-J-简单的变位词/
│ │ └── main.cpp
│ ├── NYOJ/
│ │ ├── f-2016河南ACM省赛-A-表达式求值/
│ │ │ └── f-2016河南ACM省赛-A-表达式求值/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1070-诡异的电梯[Ⅰ]/
│ │ │ └── f-NYOJ-1070-诡异的电梯[Ⅰ]/
│ │ │ └── main.c
│ │ ├── f-NYOJ-108-士兵杀敌（一）/
│ │ │ └── f-NYOJ-108-士兵杀敌（一）/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-110-剑客决斗/
│ │ │ └── f-NYOJ-110-剑客决斗/
│ │ │ └── main.c
│ │ ├── f-NYOJ-116-士兵杀敌（二）/
│ │ │ └── f-NYOJ-116-士兵杀敌（二）/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-12-喷水装置（二）/
│ │ │ └── f-NYOJ-12-喷水装置（二）/
│ │ │ └── main.c
│ │ ├── f-NYOJ-1235-A÷B Problem/
│ │ │ └── f-NYOJ-1235-A÷B Problem/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1236-挑战密室/
│ │ │ └── f-NYOJ-1236-挑战密室/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1237-最大岛屿/
│ │ │ └── f-NYOJ-1237-最大岛屿/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1238-最少换乘/
│ │ │ └── f-NYOJ-1238-最少换乘/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1239-引水工程/
│ │ │ └── f-NYOJ-1239-引水工程/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1249-物资调度/
│ │ │ └── f-NYOJ-1249-物资调度/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1250-机器人/
│ │ │ └── f-NYOJ-1250-机器人/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1251-山区修路/
│ │ │ └── f-NYOJ-1251-山区修路/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1252-世界之威/
│ │ │ └── f-NYOJ-1252-世界之威/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1255-Rectangles/
│ │ │ └── f-NYOJ-1255-Rectangles/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1273-宣传墙/
│ │ │ └── f-NYOJ-1273-宣传墙/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1276-机器设备/
│ │ │ └── f-NYOJ-1276-机器设备/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-14-会场安排问题/
│ │ │ └── f-NYOJ-14-会场安排问题/
│ │ │ └── main.c
│ │ ├── f-NYOJ-15-括号匹配（二）/
│ │ │ └── f-NYOJ-15-括号匹配（二）/
│ │ │ └── main.c
│ │ ├── f-NYOJ-16-矩形嵌套/
│ │ │ └── f-NYOJ-16-矩形嵌套/
│ │ │ └── main.c
│ │ ├── f-NYOJ-17-单调递增最长子序列/
│ │ │ └── f-NYOJ-17-单调递增最长子序列/
│ │ │ └── main.c
│ │ ├── f-NYOJ-18-The Triangle/
│ │ │ └── f-NYOJ-18-The Triangle/
│ │ │ └── main.c
│ │ ├── f-NYOJ-19-擅长排列的小明/
│ │ │ └── f-NYOJ-19-擅长排列的小明/
│ │ │ └── main.c
│ │ ├── f-NYOJ-2-括号配对问题/
│ │ │ └── f-NYOJ-2-括号配对问题/
│ │ │ └── main.c
│ │ ├── f-NYOJ-20-吝啬的国度/
│ │ │ └── f-NYOJ-20-吝啬的国度/
│ │ │ └── main.c
│ │ ├── f-NYOJ-201-作业题/
│ │ │ └── f-NYOJ-201-作业题/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-21-三个水杯/
│ │ │ └── f-NYOJ-21-三个水杯/
│ │ │ └── main.c
│ │ ├── f-NYOJ-24-素数距离问题/
│ │ │ └── f-NYOJ-24-素数距离问题/
│ │ │ └── main.c
│ │ ├── f-NYOJ-26-孪生素数问题/
│ │ │ └── f-NYOJ-26-孪生素数问题/
│ │ │ └── main.c
│ │ ├── f-NYOJ-27-水池数目/
│ │ │ └── f-NYOJ-27-水池数目/
│ │ │ └── main.c
│ │ ├── f-NYOJ-28-大数阶乘/
│ │ │ └── f-NYOJ-28-大数阶乘/
│ │ │ └── main.c
│ │ ├── f-NYOJ-32-组合数/
│ │ │ └── f-NYOJ-32-组合数/
│ │ │ └── main.c
│ │ ├── f-NYOJ-33-蛇形填数/
│ │ │ └── f-NYOJ-33-蛇形填数/
│ │ │ └── main.c
│ │ ├── f-NYOJ-35-表达式求值/
│ │ │ └── f-NYOJ-35-表达式求值/
│ │ │ └── main.c
│ │ ├── f-NYOJ-37-回文字符串/
│ │ │ └── f-NYOJ-37-回文字符串/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-417-死神来了/
│ │ │ └── f-NYOJ-417-死神来了/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-46-最少乘法次数/
│ │ │ └── f-NYOJ-46-最少乘法次数/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-5-Binary String Matching/
│ │ │ └── f-NYOJ-5-Binary String Matching/
│ │ │ └── main.c
│ │ ├── f-NYOJ-6-喷水装置（一）/
│ │ │ └── f-NYOJ-6-喷水装置（一）/
│ │ │ └── main.c
│ │ ├── f-NYOJ-7-街区最短路径问题/
│ │ │ └── f-NYOJ-7-街区最短路径问题/
│ │ │ └── main.c
│ │ ├── f-NYOJ-739-笨蛋难题四/
│ │ │ └── f-NYOJ-739-笨蛋难题四/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-8-一种排序/
│ │ │ └── f-NYOJ-8-一种排序/
│ │ │ └── main.c
│ │ ├── f-NYOJ-999-师傅又被妖怪抓走了/
│ │ │ └── f-NYOJ-999-师傅又被妖怪抓走了/
│ │ │ └── main.cpp
│ │ ├── f-河南第十届ACM省赛-C-最小密钥/
│ │ │ └── f-河南第十届ACM省赛-C-最小密钥/
│ │ │ └── main.cpp
│ │ ├── f-河南第十届ACM省赛-D-年终奖金/
│ │ │ └── f-河南第十届ACM省赛-D-年终奖金/
│ │ │ └── main.cpp
│ │ ├── f-河南第十届ACM省赛-E-八纵八横/
│ │ │ └── f-河南第十届ACM省赛-E-八纵八横/
│ │ │ └── main.cpp
│ │ └── f-河南第十届ACM省赛-I-Transmit information/
│ │ └── f-河南第十届ACM省赛-I-Transmit information/
│ │ └── main.cpp
│ ├── NZAU/
│ │ ├── f-NZAU-C-Mine Sweeping Game/
│ │ │ └── f-NZAU-C-Mine Sweeping Game/
│ │ │ └── main.c
│ │ └── f-NZAU-F-The Nearest Same Chocolate/
│ │ └── f-NZAU-F-The Nearest Same Chocolate/
│ │ └── main.c
│ ├── PAT/
│ │ ├── f-PAT-2017年团体程序设计天梯赛-大区赛-L2-4-功夫传人/
│ │ │ └── f-PAT-2017年团体程序设计天梯赛-大区赛-L2-4-功夫传人/
│ │ │ └── main.cpp
│ │ ├── f-PAT-L1-006-连续因子/
│ │ │ └── f-PAT-L1-006-连续因子/
│ │ │ └── main.cpp
│ │ ├── f-PAT-天梯赛习题集-L2-018-多项式A除以B/
│ │ │ └── f-PAT-天梯赛习题集-L2-018-多项式A除以B/
│ │ │ └── main.cpp
│ │ ├── f-PAT-天梯赛习题集-L3-013-非常弹的球/
│ │ │ └── f-PAT-天梯赛习题集-L3-013-非常弹的球/
│ │ │ └── main.cpp
│ │ ├── f-PAT-天梯赛习题集-L3-014-周游世界/
│ │ │ └── f-PAT-天梯赛习题集-L3-014-周游世界/
│ │ │ └── main.cpp
│ │ └── f-PAT-天梯赛习题集-L3-015-球队“食物链”/
│ │ └── f-PAT-天梯赛习题集-L3-015-球队“食物链”/
│ │ └── main.cpp
│ ├── POJ/
│ │ ├── f-POJ-1061-青蛙的约会/
│ │ │ └── f-POJ-1061-青蛙的约会/
│ │ │ └── main.c
│ │ ├── f-POJ-1681-Painter's Problem/
│ │ │ └── f-POJ-1681-Painter's Problem/
│ │ │ └── main.cpp
│ │ ├── f-POJ-1729-Jack and Jill/
│ │ │ └── f-POJ-1729-Jack and Jill/
│ │ │ └── main.cpp
│ │ ├── f-POJ-1811-Prime Test/
│ │ │ └── f-POJ-1811-Prime Test/
│ │ │ └── main.cpp
│ │ ├── f-POJ-1845-Sumdiv/
│ │ │ └── f-POJ-1845-Sumdiv/
│ │ │ └── main.cpp
│ │ ├── f-POJ-1961-Period/
│ │ │ └── f-POJ-1961-Period/
│ │ │ └── main.cpp
│ │ ├── f-POJ-1985-Cow Marathon/
│ │ │ └── f-POJ-1985-Cow Marathon/
│ │ │ └── main.cpp
│ │ ├── f-POJ-2096-Collecting Bugs/
│ │ │ └── f-POJ-2096-Collecting Bugs/
│ │ │ └── main.cpp
│ │ ├── f-POJ-2185-Milking Grid/
│ │ │ └── f-POJ-2185-Milking Grid/
│ │ │ └── main.cpp
│ │ ├── f-POJ-2406-Power Strings/
│ │ │ └── f-POJ-2406-Power Strings/
│ │ │ └── main.cpp
│ │ ├── f-POJ-2752-Seek the Name, Seek the Fame/
│ │ │ └── f-POJ-2752-Seek the Name, Seek the Fame/
│ │ │ └── main.cpp
│ │ ├── f-POJ-3461-Oulipo/
│ │ │ └── f-POJ-3461-Oulipo/
│ │ │ └── main.cpp
│ │ ├── f-POJ-3744-Scout YYF I/
│ │ │ └── f-POJ-3744-Scout YYF I/
│ │ │ └── main.cpp
│ │ ├── f-POJ-3866-Exclusive Access 2/
│ │ │ └── f-POJ-3866-Exclusive Access 2/
│ │ │ └── main.cpp
│ │ └── f-POJ-机加工表面/
│ │ └── f-POJ-机加工表面/
│ │ └── main.c
│ ├── Project Eular/
│ │ └── f-Project Eular-71-Ordered fractions/
│ │ └── f-Project Eular-71-Ordered fractions/
│ │ └── main.cpp
│ ├── SHU/
│ │ ├── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-A-黑白图像直方图/
│ │ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-A-黑白图像直方图/
│ │ │ └── main.cpp
│ │ ├── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-B-神无月排位赛/
│ │ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-B-神无月排位赛/
│ │ │ └── main.cpp
│ │ ├── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-C-I Love ces/
│ │ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-C-I Love ces/
│ │ │ └── main.cpp
│ │ ├── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-D-添加好友/
│ │ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-D-添加好友/
│ │ │ └── main.cpp
│ │ ├── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-E-字符串进制转换/
│ │ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-E-字符串进制转换/
│ │ │ └── main.cpp
│ │ ├── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-F-A序列/
│ │ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-F-A序列/
│ │ │ └── main.cpp
│ │ ├── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-G-战斗/
│ │ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-G-战斗/
│ │ │ └── main.cpp
│ │ ├── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-H-调和序列/
│ │ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-H-调和序列/
│ │ │ └── main.cpp
│ │ ├── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-I-丢史蒂芬妮/
│ │ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-I-丢史蒂芬妮/
│ │ │ └── main.cpp
│ │ ├── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-J-膜一下将带给你好运/
│ │ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-J-膜一下将带给你好运/
│ │ │ └── main.cpp
│ │ ├── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-K-购买装备/
│ │ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-K-购买装备/
│ │ │ └── main.cpp
│ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-M-风力观测/
│ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-M-风力观测/
│ │ └── main.cpp
│ ├── THU/
│ │ ├── f-THU-2016-3-1-TSP/
│ │ │ └── f-THU-2016-3-1-TSP/
│ │ │ └── main.cpp
│ │ └── f-THU-2016-3-2-Pokeface/
│ │ └── f-THU-2016-3-2-Pokeface/
│ │ └── main.cpp
│ ├── UVA/
│ │ ├── f-UVA-11600-Masud Rana/
│ │ │ └── f-UVA-11600-Masud Rana/
│ │ │ └── main.cpp
│ │ └── f-UVA-12260-Free Goodies/
│ │ └── f-UVA-12260-Free Goodies/
│ │ └── main.cpp
│ ├── UVALive/
│ │ ├── f-UVALive-4394-String painter/
│ │ │ └── f-UVALive-4394-String painter/
│ │ │ └── main.cpp
│ │ ├── f-UVALive-7500-Boxes and Balls/
│ │ │ └── f-UVALive-7500-Boxes and Balls/
│ │ │ └── main.cpp
│ │ ├── f-UVALive-7509-Dome and Steles/
│ │ │ └── f-UVALive-7509-Dome and Steles/
│ │ │ └── main.cpp
│ │ └── f-UVALive-7512-November 11th/
│ │ └── f-UVALive-7512-November 11th/
│ │ └── main.cpp
│ ├── VJ/
│ │ ├── f-[kuangbin带你飞]专题二-搜索进阶-A-Eight/
│ │ │ └── f-[kuangbin带你飞]专题二-搜索进阶-A-Eight/
│ │ │ └── main.cpp
│ │ ├── f-[kuangbin带你飞]专题二-搜索进阶-B-Eight II/
│ │ │ └── f-[kuangbin带你飞]专题二-搜索进阶-B-Eight II/
│ │ │ └── main.cpp
│ │ ├── f-[kuangbin带你飞]专题二-搜索进阶-C-哈密顿绕行世界问题/
│ │ │ └── f-[kuangbin带你飞]专题二-搜索进阶-C-哈密顿绕行世界问题/
│ │ │ └── main.cpp
│ │ └── f-[kuangbin带你飞]专题二-搜索进阶-D-Escape/
│ │ └── f-[kuangbin带你飞]专题二-搜索进阶-D-Escape/
│ │ └── main.cpp
│ ├── ZOJ/
│ │ ├── f-ZOJ-3329-One Person Game/
│ │ │ └── f-ZOJ-3329-One Person Game/
│ │ │ └── main.cpp
│ │ ├── f-ZOJ-People Counting/
│ │ │ └── f-ZOJ-People Counting/
│ │ │ └── main.c
│ │ ├── f-ZOJ-The 14th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple-A-Cooking Competition/
│ │ │ └── f-ZOJ-The 14th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple-A-Cooking Competition/
│ │ │ └── main.cpp
│ │ ├── f-ZOJ-The 14th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple-B-Problem Preparation/
│ │ │ └── f-ZOJ-The 14th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple-B-Problem Preparation/
│ │ │ └── main.cpp
│ │ ├── f-ZOJ-The 14th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple-C-What Kind of Friends Are You?/
│ │ │ └── f-ZOJ-The 14th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple-C-What Kind of Friends Are You?/
│ │ │ └── main.cpp
│ │ ├── f-ZOJ-The 14th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple-D-Let's Chat/
│ │ │ └── f-ZOJ-The 14th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple-D-Let's Chat/
│ │ │ └── main.cpp
│ │ └── f-ZOJ-The 14th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple-E-Seven Segment Display/
│ │ └── f-ZOJ-The 14th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple-E-Seven Segment Display/
│ │ └── main.cpp
│ ├── ZZUACM/
│ │ ├── f-ZZUACM-Tutti!/
│ │ │ └── f-ZZUACM-Tutti!/
│ │ │ └── main.c
│ │ ├── f-ZZUACM-最长匹配子串/
│ │ │ └── f-ZZUACM-最长匹配子串/
│ │ │ └── main.c
│ │ ├── f-ZZUACM-词法分析器/
│ │ │ └── f-ZZUACM-词法分析器/
│ │ │ └── main.c
│ │ └── f-ZZUACM-追踪术/
│ │ └── f-ZZUACM-追踪术/
│ │ └── main.c
│ ├── ZZULIOJ/
│ │ ├── f-ZZULIOJ-多校训练（985专场）-A-985的字符串难题/
│ │ │ └── f-ZZULIOJ-多校训练（985专场）-A-985的字符串难题/
│ │ │ └── main.cpp
│ │ ├── f-ZZULIOJ-多校训练（985专场）-C-985的方格难题/
│ │ │ └── f-ZZULIOJ-多校训练（985专场）-C-985的方格难题/
│ │ │ └── main.cpp
│ │ ├── f-ZZULIOJ-多校训练（985专场）-D-985的0-1串难题/
│ │ │ └── f-ZZULIOJ-多校训练（985专场）-D-985的0-1串难题/
│ │ │ └── main.cpp
│ │ └── f-轻院选拔赛-最后一题/
│ │ └── f-轻院选拔赛-最后一题/
│ │ └── main.c
│ ├── hiho/
│ │ ├── f-hiho-hihoCoder挑战赛29-A-序列的值/
│ │ │ └── f-hiho-hihoCoder挑战赛29-A-序列的值/
│ │ │ └── main.cpp
│ │ ├── f-hiho-hihoCoder挑战赛29-B-快速乘法/
│ │ │ └── f-hiho-hihoCoder挑战赛29-B-快速乘法/
│ │ │ └── main.cpp
│ │ └── f-hiho-hihoCoder挑战赛29-D-不上升序列/
│ │ └── f-hiho-hihoCoder挑战赛29-D-不上升序列/
│ │ └── main.cpp
│ ├── 出处遗忘/
│ │ ├── f-2016CCPC-A-A water problem/
│ │ │ └── f-2016CCPC-A-A water problem/
│ │ │ └── main.cpp
│ │ ├── f-2016CCPC-B-Zhu and 772002/
│ │ │ └── f-2016CCPC-B-Zhu and 772002/
│ │ │ └── main.cpp
│ │ ├── f-2016CCPC-D-Danganronpa/
│ │ │ └── f-2016CCPC-D-Danganronpa/
│ │ │ └── main.cpp
│ │ ├── f-2016年多大学培训大赛4-1012-Bubble Sort/
│ │ │ └── f-2016年多大学培训大赛4-1012-Bubble Sort/
│ │ │ └── main.cpp
│ │ ├── f-C/
│ │ │ ├── mainOne.cpp
│ │ │ └── mainTwo.c
│ │ ├── f-DES/
│ │ │ └── f-DES/
│ │ │ ├── DES.cpp
│ │ │ ├── DES.hpp
│ │ │ └── main.cpp
│ │ ├── f-DES(C)/
│ │ │ └── f-DES(C)/
│ │ │ └── main.cpp
│ │ ├── f-GSJS/
│ │ │ └── f-GSJS/
│ │ │ ├── main.cpp
│ │ │ ├── radianToAngle.cpp
│ │ │ └── radianToAngle.hpp
│ │ ├── f-NOI-30-字符环/
│ │ │ └── f-NOI-30-字符环/
│ │ │ └── main.c
│ │ ├── f-NOIP-2009-分数线划定/
│ │ │ └── f-NOIP-2009-分数线划定/
│ │ │ └── main.c
│ │ ├── f-Permutations/
│ │ │ └── f-Permutations/
│ │ │ └── main.c
│ │ ├── f-cdecl/
│ │ │ └── f-cdecl/
│ │ │ └── main.cpp
│ │ ├── f-kwic/
│ │ │ └── f-kwic/
│ │ │ └── main.cpp
│ │ ├── f-work2/
│ │ │ └── f-work2/
│ │ │ ├── file.cpp
│ │ │ ├── file.hpp
│ │ │ └── main.cpp
│ │ ├── f-乐视2017实习-偶数大翻转/
│ │ │ └── f-乐视2017实习-偶数大翻转/
│ │ │ └── main.cpp
│ │ ├── f-乐视2017实习-兵临城下/
│ │ │ └── f-乐视2017实习-兵临城下/
│ │ │ └── main.cpp
│ │ ├── f-乐视2017实习-幻兽交易/
│ │ │ └── f-乐视2017实习-幻兽交易/
│ │ │ └── main.cpp
│ │ ├── f-交谊舞/
│ │ │ └── f-交谊舞/
│ │ │ └── main.c
│ │ ├── f-今日头条2018校招-字母交换/
│ │ │ └── f-今日头条2018校招-字母交换/
│ │ │ └── main.cpp
│ │ ├── f-树的遍历/
│ │ │ └── f-树的遍历/
│ │ │ └── main.c
│ │ ├── f-湖南人文科技-1659-不一样的解密/
│ │ │ └── f-湖南人文科技-1659-不一样的解密/
│ │ │ └── main.c
│ │ ├── f-爱奇艺2018秋招-最后一位/
│ │ │ └── f-爱奇艺2018秋招-最后一位/
│ │ │ └── main.cpp
│ │ ├── f-爱奇艺2018秋招-缺失的括号/
│ │ │ └── f-爱奇艺2018秋招-缺失的括号/
│ │ │ └── main.cpp
│ │ ├── f-生日相同2.0/
│ │ │ └── f-生日相同2.0/
│ │ │ └── main.c
│ │ ├── f-百度2016实习-XML文档/
│ │ │ └── f-爱奇艺2018秋招-XML文档/
│ │ │ └── main.cpp
│ │ ├── f-百度2016实习-乘法表/
│ │ │ └── f-百度2016实习-乘法表/
│ │ │ └── main.cpp
│ │ ├── f-百度2016实习-编号转换/
│ │ │ └── f-百度2016实习-编号转换/
│ │ │ └── main.cpp
│ │ ├── f-腾讯2017暑期实习生编程题-A-构造回文/
│ │ │ └── f-腾讯2017暑期实习生编程题-A-构造回文/
│ │ │ └── main.cpp
│ │ ├── f-腾讯2017暑期实习生编程题-B-算法基础-字符移位/
│ │ │ └── f-腾讯2017暑期实习生编程题-B-算法基础-字符移位/
│ │ │ └── main.cpp
│ │ ├── f-腾讯2017暑期实习生编程题-C-有趣的数字/
│ │ │ └── f-腾讯2017暑期实习生编程题-C-有趣的数字/
│ │ │ └── main.cpp
│ │ ├── f-计算对角线元素之和/
│ │ │ └── f-计算对角线元素之和/
│ │ │ └── main.c
│ │ ├── f-阿里编程测试-问答题1/
│ │ │ └── f-阿里编程测试-问答题1/
│ │ │ └── main.cpp
│ │ ├── 二路插入.cpp
│ │ ├── 今日头条2018测试/
│ │ │ ├── 4.cpp
│ │ │ └── 5.cpp
│ │ ├── 今日头条2018算法/
│ │ │ ├── 3.cpp
│ │ │ ├── 4.cpp
│ │ │ └── 5.cpp
│ │ ├── 归并.cpp
│ │ ├── 拼多多2018内推/
│ │ │ ├── 1.cpp
│ │ │ ├── 2.cpp
│ │ │ ├── 3.cpp
│ │ │ └── 4.cpp
│ │ ├── 红黑树.cpp
│ │ ├── 网易2018校园招聘编程题真题集合/
│ │ │ ├── 1.cpp
│ │ │ ├── 2.cpp
│ │ │ ├── 3.cpp
│ │ │ ├── 4.cpp
│ │ │ ├── 5.cpp
│ │ │ ├── 6.cpp
│ │ │ ├── 7.cpp
│ │ │ └── 8.cpp
│ │ ├── 网易2018校招内推编程题集合/
│ │ │ ├── 1.cpp
│ │ │ ├── 2.cpp
│ │ │ ├── 3.cpp
│ │ │ ├── 4.cpp
│ │ │ ├── 5.cpp
│ │ │ ├── 6.cpp
│ │ │ ├── 7.cpp
│ │ │ └── 8.cpp
│ │ └── 辗转相除法.c
│ ├── 牛客网/
│ │ ├── f-牛客网-2018 美团 CodeM 编程大赛-初赛 A 轮/
│ │ │ ├── 1-遥控按键/
│ │ │ │ └── main.cpp
│ │ │ ├── 2-下棋/
│ │ │ │ └── main.cpp
│ │ │ └── 3-城市漫游/
│ │ │ └── main.cpp
│ │ ├── f-牛客网-2018 美团 CodeM 编程大赛-初赛 B 轮/
│ │ │ ├── 1-开关灯/
│ │ │ │ └── main.cpp
│ │ │ ├── 3-低位值/
│ │ │ │ └── main.cpp
│ │ │ └── 4-神奇盘子/
│ │ │ └── main.cpp
│ │ ├── f-牛客网-2018 美团 CodeM 编程大赛-资格赛/
│ │ │ ├── 1-下单/
│ │ │ │ └── main.cpp
│ │ │ ├── 2-可乐/
│ │ │ │ └── main.cpp
│ │ │ ├── 3-世界杯/
│ │ │ │ └── main.cpp
│ │ │ ├── 4-分数/
│ │ │ │ └── main.cpp
│ │ │ └── 5-你的城市/
│ │ │ └── main.cpp
│ │ └── f-牛客网-剑指Offer/
│ │ ├── 二维数组中的查找/
│ │ │ └── main.cpp
│ │ ├── 从尾到头打印链表/
│ │ │ └── main.cpp
│ │ └── 替换空格/
│ │ └── main.cpp
│ ├── 玲珑杯/
│ │ ├── f-"玲珑杯“ ACM热身赛 # 0.5-A-Alarm/
│ │ │ └── f-"玲珑杯“ ACM热身赛 # 0.5-A-Alarm/
│ │ │ └── main.cpp
│ │ ├── f-"玲珑杯“ ACM热身赛 # 0.5-B-Battle/
│ │ │ └── f-"玲珑杯“ ACM热身赛 # 0.5-B-Battle/
│ │ │ └── main.cpp
│ │ ├── f-“玲珑杯”ACM比赛 Round #1-A-Absolute Defeat/
│ │ │ └── f-“玲珑杯”ACM比赛 Round #1-A-Absolute Defeat/
│ │ │ └── main.cpp
│ │ └── f-“玲珑杯”ACM比赛 Round #10-A-Black and White/
│ │ └── f-“玲珑杯”ACM比赛 Round #10-A-Black and White/
│ │ └── main.cpp
│ ├── 百炼/
│ │ └── f-百练-2456-Aggressive cows/
│ │ └── f-百练-2456-Aggressive cows/
│ │ └── main.cpp
│ ├── 码农谷/
│ │ ├── f-2016码农谷全国大学生程序设计邀请赛（测试赛）-试题一-将字符串中的字符按规则重新排列/
│ │ │ └── f-2016码农谷全国大学生程序设计邀请赛（测试赛）-试题一-将字符串中的字符按规则重新排列/
│ │ │ └── main.cpp
│ │ ├── f-2016码农谷全国大学生程序设计邀请赛（测试赛）-试题三-将数分成两组，使得两组中各元素的和相等/
│ │ │ └── f-2016码农谷全国大学生程序设计邀请赛（测试赛）-试题三-将数分成两组，使得两组中各元素的和相等/
│ │ │ └── main.cpp
│ │ ├── f-2016码农谷全国大学生程序设计邀请赛（测试赛）-试题二-统计出以某个字符串为前缀的单词数量/
│ │ │ └── f-2016码农谷全国大学生程序设计邀请赛（测试赛）-试题二-统计出以某个字符串为前缀的单词数量/
│ │ │ └── main.cpp
│ │ ├── f-2016码农谷全国大学生程序设计邀请赛（测试赛）-试题四-求二进制数字符串的和/
│ │ │ └── f-2016码农谷全国大学生程序设计邀请赛（测试赛）-试题四-求二进制数字符串的和/
│ │ │ └── main.cpp
│ │ ├── f-2016码农谷全国大学生程序设计邀请赛（第一轮资格赛）-试题一 对码农的编程水平进行排名/
│ │ │ └── f-2016码农谷全国大学生程序设计邀请赛（第一轮资格赛）-试题一 对码农的编程水平进行排名/
│ │ │ └── main.cpp
│ │ ├── f-2016码农谷全国大学生程序设计邀请赛（第一轮资格赛）-试题三 将一个英文语句以单词为单位逆序排序/
│ │ │ └── f-2016码农谷全国大学生程序设计邀请赛（第一轮资格赛）-试题三 将一个英文语句以单词为单位逆序排序/
│ │ │ └── main.cpp
│ │ ├── f-2016码农谷全国大学生程序设计邀请赛（第一轮资格赛）-试题二 奇怪的数字：6174/
│ │ │ └── f-2016码农谷全国大学生程序设计邀请赛（第一轮资格赛）-试题二 奇怪的数字：6174/
│ │ │ └── main.cpp
│ │ └── f-2016码农谷全国大学生程序设计邀请赛（第一轮资格赛）-试题四 小码农挑选资源的方案数/
│ │ └── f-2016码农谷全国大学生程序设计邀请赛（第一轮资格赛）-试题四 小码农挑选资源的方案数/
│ │ └── main.cpp
│ ├── 蓝桥杯/
│ │ ├── f-ADV-1-两条直线/
│ │ │ └── f-ADV-1-两条直线/
│ │ │ └── main.c
│ │ ├── f-ADV-144-01背包/
│ │ │ └── f-ADV-144-01背包/
│ │ │ └── main.c
│ │ ├── f-ADV-158-新建Microsoft Word文档/
│ │ │ └── f-ADV-158-新建Microsoft Word文档/
│ │ │ └── main.c
│ │ ├── f-ADV-200-求最大值/
│ │ │ └── f-ADV-200-求最大值/
│ │ │ └── main.c
│ │ ├── f-ADV-215-Problem S4: Interesting Numbers 加强版/
│ │ │ └── f-ADV-215-Problem S4: Interesting Numbers 加强版/
│ │ │ └── main.c
│ │ ├── f-ADV-3-金属采集/
│ │ │ └── f-ADV-3-金属采集/
│ │ │ └── main.c
│ │ ├── f-ALGO-116-最大的算式/
│ │ │ └── f-ALGO-116-最大的算式/
│ │ │ └── main.c
│ │ ├── f-ALGO-133-Tricky and Clever Password/
│ │ │ └── f-ALGO-133-Tricky and Clever Password/
│ │ │ └── main.c
│ │ ├── f-ALGO-137-Lift and Throw/
│ │ │ └── f-ALGO-137-Lift and Throw/
│ │ │ └── main.c
│ │ ├── f-ALGO-142-P1103/
│ │ │ └── f-ALGO-142-P1103/
│ │ │ └── main.c
│ │ ├── f-ALGO-144-2-3逆序打印数字/
│ │ │ └── f-ALGO-144-2-3逆序打印数字/
│ │ │ └── main.c
│ │ ├── f-ALGO-4-结点选择/
│ │ │ └── f-ALGO-4-结点选择/
│ │ │ └── main.c
│ │ ├── f-ALGO-48-关联矩阵/
│ │ │ └── f-ALGO-48-关联矩阵/
│ │ │ └── main.c
│ │ ├── f-ALGO-5-最短路/
│ │ │ └── f-ALGO-5-最短路/
│ │ │ └── main.c
│ │ ├── f-ALGO-6-安慰奶牛/
│ │ │ └── f-ALGO-6-安慰奶牛/
│ │ │ └── main.c
│ │ ├── f-ALGO-8-操作格子/
│ │ │ └── f-ALGO-8-操作格子/
│ │ │ └── main.c
│ │ ├── f-ALGO-87-字串统计/
│ │ │ └── f-ALGO-87-字串统计/
│ │ │ └── main.c
│ │ ├── f-ALGO-90-出现次数最多的整数/
│ │ │ └── f-ALGO-90-出现次数最多的整数/
│ │ │ └── main.c
│ │ ├── f-BASIC-12-十六进制转八进制/
│ │ │ └── f-BASIC-12-十六进制转八进制/
│ │ │ └── main.c
│ │ ├── f-PREV-2-打印十字图/
│ │ │ └── f-PREV-2-打印十字图/
│ │ │ └── main.c
│ │ ├── f-PREV-3-带分数/
│ │ │ └── f-PREV-3-带分数/
│ │ │ └── main.c
│ │ ├── f-PREV-5-错误票据/
│ │ │ └── f-PREV-5-错误票据/
│ │ │ └── main.c
│ │ ├── f-蓝桥-ALGO-10-集合运算/
│ │ │ └── f-蓝桥-ALGO-10-集合运算/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-11-瓷砖铺放/
│ │ │ └── f-蓝桥-ALGO-11-瓷砖铺放/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-12-幂方分解/
│ │ │ └── f-蓝桥-ALGO-12-幂方分解/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-13-拦截导弹/
│ │ │ └── f-蓝桥-ALGO-13-拦截导弹/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-14-回文数/
│ │ │ └── f-蓝桥-ALGO-14-回文数/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-15-旅行家的预算/
│ │ │ └── f-蓝桥-ALGO-15-旅行家的预算/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-16-进制转换/
│ │ │ └── f-蓝桥-ALGO-16-进制转换/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-17-乘积最大/
│ │ │ └── f-蓝桥-ALGO-17-乘积最大/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-18-单词接龙/
│ │ │ └── f-蓝桥-ALGO-18-单词接龙/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-19-方格取数/
│ │ │ └── f-蓝桥-ALGO-19-方格取数/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-20-求先序排列/
│ │ │ └── f-蓝桥-ALGO-20-求先序排列/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-22-整数划分/
│ │ │ └── f-蓝桥-ALGO-22-整数划分/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-23-一元三次方程求解/
│ │ │ └── f-蓝桥-ALGO-23-一元三次方程求解/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-24-统计单词个数/
│ │ │ └── f-蓝桥-ALGO-24-统计单词个数/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-25-Car的旅行路线/
│ │ │ └── f-蓝桥-ALGO-25-Car的旅行路线/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-26-麦森数/
│ │ │ └── f-蓝桥-ALGO-26-麦森数/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-27-FBI树/
│ │ │ └── f-蓝桥-ALGO-27-FBI树/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-28-星际交流/
│ │ │ └── f-蓝桥-ALGO-28-星际交流/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-29-校门外的树/
│ │ │ └── f-蓝桥-ALGO-29-校门外的树/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-32-JAM计数法/
│ │ │ └── f-蓝桥-ALGO-32-JAM计数法/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-33-数列/
│ │ │ └── f-蓝桥-ALGO-33-数列/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-34-纪念品分组/
│ │ │ └── f-蓝桥-ALGO-34-纪念品分组/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-35-传球游戏/
│ │ │ └── f-蓝桥-ALGO-35-传球游戏/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-36-传纸条/
│ │ │ └── f-蓝桥-ALGO-36-传纸条/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-37-Hankson的趣味题/
│ │ │ └── f-蓝桥-ALGO-37-Hankson的趣味题/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-38-接水问题/
│ │ │ └── f-蓝桥-ALGO-38-接水问题/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-40-会议中心/
│ │ │ └── f-蓝桥-ALGO-40-会议中心/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-44-采油区域/
│ │ │ └── f-蓝桥-ALGO-44-采油区域/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-9-摆动序列/
│ │ │ └── f-蓝桥-ALGO-9-摆动序列/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥杯-历届试题-PREV-13-网络寻路/
│ │ │ └── f-蓝桥杯-历届试题-PREV-13-网络寻路/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥杯省A-剪邮票/
│ │ │ └── f-蓝桥杯省A-剪邮票/
│ │ │ └── main.c
│ │ ├── f-蓝桥杯省A-四平方和/
│ │ │ └── f-蓝桥杯省A-四平方和/
│ │ │ └── main.c
│ │ ├── f-蓝桥杯省A-密码脱落/
│ │ │ └── f-蓝桥杯省A-密码脱落/
│ │ │ └── main.c
│ │ ├── f-蓝桥杯省A-寒假作业/
│ │ │ └── f-蓝桥杯省A-寒假作业/
│ │ │ └── main.c
│ │ ├── f-蓝桥杯省A-方格填数/
│ │ │ └── f-蓝桥杯省A-方格填数/
│ │ │ └── main.c
│ │ └── f-蓝桥杯省A-最大比例/
│ │ └── f-蓝桥杯省A-最大比例/
│ │ └── main.c
│ └── 计蒜客/
│ ├── f-2016-计蒜之道-初赛-第二场-A-联想公司的logo设计/
│ │ └── f-2016-计蒜之道-初赛-第二场-A-联想公司的logo设计/
│ │ └── main.c
│ ├── f-2016-计蒜之道-初赛-第二场-B-联想的显示屏校准/
│ │ └── f-2016-计蒜之道-初赛-第二场-B-联想的显示屏校准/
│ │ └── main.c
│ ├── f-2016-计蒜之道-初赛-第五场-A-腾讯的一笔画游戏/
│ │ └── f-2016-计蒜之道-初赛-第五场-A-腾讯的一笔画游戏/
│ │ └── main.cpp
│ ├── f-2016-计蒜之道-初赛-第四场-A-淘宝流量分配/
│ │ └── f-2016-计蒜之道-初赛-第四场-A-淘宝流量分配/
│ │ └── main.cpp
│ ├── f-2016-计蒜之道-初赛-第四场-B、C、D-遗失的支付宝密码/
│ │ └── f-2016-计蒜之道-初赛-第四场-B、C、D-遗失的支付宝密码/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-A-Banana/
│ │ └── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-A-Banana/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-B-Out-out-control cars/
│ │ └── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-B-Out-out-control cars/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-C-Coconut/
│ │ └── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-C-Coconut/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-E-Half-consecutive Numbers/
│ │ └── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-E-Half-consecutive Numbers/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-F-Islands/
│ │ └── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-F-Islands/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-G-Query on a string/
│ │ └── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-G-Query on a string/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-H-Skiing/
│ │ └── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-H-Skiing/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-J-Our Journey of Dalian Ends/
│ │ └── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-J-Our Journey of Dalian Ends/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 计蒜之道 初赛 第六场-A-微软手机的信号显示/
│ │ └── f-计蒜客-2017 计蒜之道 初赛 第六场-A-微软手机的信号显示/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 计蒜之道 初赛 第六场-B-微软大楼设计方案（简单）/
│ │ └── f-计蒜客-2017 计蒜之道 初赛 第六场-B-微软大楼设计方案（简单）/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 计蒜之道 复赛-A-阿里云秘钥池/
│ │ └── f-计蒜客-2017 计蒜之道 复赛-A-阿里云秘钥池/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 计蒜之道 复赛-B-Windows 画图/
│ │ └── f-计蒜客-2017 计蒜之道 复赛-B-Windows 画图/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 计蒜之道 复赛-D-百度地图导航/
│ │ └── f-计蒜客-2017 计蒜之道 复赛-D-百度地图导航/
│ │ └── main.cpp
│ └── f-计蒜客-2017 计蒜之道 复赛-F-腾讯消消乐/
│ └── f-计蒜客-2017 计蒜之道 复赛-F-腾讯消消乐/
│ └── main.cpp
└── 相关资源/
├── DOC/
│ ├── C语言归并、选择、直接插入、希尔、冒泡、快速、堆排序与顺序、二分查找排序.docx
│ ├── C语言程序190例.doc
│ ├── C语言算法100例.doc
│ ├── C语言趣味程序设计编程百例精解.doc
│ └── 经典算法50例（绝对经典）.doc
├── OI国家集训队论文集1999~2016/
│ ├── 国家集训队2000论文集/
│ │ ├── 谢婧--规模化问题的解题策略/
│ │ │ ├── land.5
│ │ │ ├── land.6
│ │ │ ├── land.7
│ │ │ ├── land.8
│ │ │ ├── land.9
│ │ │ └── 谢婧论文.doc
│ │ ├── 郭一--数学模型及其在信息学竞赛中的应用/
│ │ │ └── 郭一论文.doc
│ │ ├── 陈彧--信息学竞赛中的思维方法/
│ │ │ └── 陈彧论文.doc
│ │ ├── 骆骥--数学模型的建立和选择/
│ │ │ └── 骆骥论文.DOC
│ │ ├── 高寒蕊--递推关系的建立及在信息学竞赛中的应用/
│ │ │ └── 高寒蕊论文.doc
│ │ └── 龙翀--解决空间规模问题的几种常用的存储结构/
│ │ └── 龙翀论文.doc
│ ├── 国家集训队2001论文集/
│ │ ├── 俞玮--基本动态规划问题的扩展/
│ │ │ └── 俞玮.doc
│ │ ├── 刘汝佳--搬运工问题的启示/
│ │ │ ├── Chapter3.doc
│ │ │ ├── chapter1.doc
│ │ │ ├── chapter2.doc
│ │ │ ├── content.doc
│ │ │ └── preface.doc
│ │ ├── 张一飞--求n！的高精度算法/
│ │ │ └── 张一飞i.ppt
│ │ ├── 李源--树的枚举/
│ │ │ └── 李源.ppt
│ │ ├── 李益明--发言稿/
│ │ │ └── 李益明.doc
│ │ ├── 毛子青--动态规划算法的优化技巧/
│ │ │ ├── 毛子青.doc
│ │ │ └── 毛子青.ppt
│ │ ├── 江鹏--从一道题目的解法试谈网络流的构造与算法/
│ │ │ └── 江鹏.doc
│ │ ├── 符文杰--Pólya原理及其应用/
│ │ │ └── 符文杰.doc
│ │ ├── 骆骥--由“汽车问题”浅谈深度搜索的一个方面/
│ │ │ └── 骆骥.doc
│ │ ├── 高寒蕊--从圆桌问题谈数据结构的综合运用/
│ │ │ ├── Paper_Show.doc
│ │ │ ├── ghr_mine1.doc
│ │ │ └── ghr_pub1.doc
│ │ └── 高岳--中等硬度解题报告/
│ │ └── 高岳.doc
│ ├── 国家集训队2002论文集/
│ │ ├── 何林--猜想及其应用/
│ │ │ ├── 何林.doc
│ │ │ └── 何林.ppt
│ │ ├── 何江舟--用高斯消元解线性方程组/
│ │ │ └── 何江舟.ppt
│ │ ├── 俞玮--ulam的游戏及编码/
│ │ │ └── 俞玮.pps
│ │ ├── 周文超--树结构在程序设计中的应用/
│ │ │ └── 周文超.PPT
│ │ ├── 孙方成--偶图的算法及应用/
│ │ │ ├── 孙方成.doc
│ │ │ └── 孙方成.ppt
│ │ ├── 孙林春--从《parity》的解法/
│ │ │ └── 孙林春.ppt
│ │ ├── 张一飞--透析一类搏弈游戏的解答过程/
│ │ │ ├── 张一飞.doc
│ │ │ └── 张一飞.ppt
│ │ ├── 张宁--遗传算法的特点及其应用/
│ │ │ ├── 张宁.doc
│ │ │ └── 张宁.ppt
│ │ ├── 张家琳--多项式乘法/
│ │ │ └── 张家琳.ppt
│ │ ├── 戴德承--目标转化思想”的若干应用/
│ │ │ └── 戴德承.doc
│ │ ├── 方奇--浅谈必要条件的应用/
│ │ │ └── 方奇.doc
│ │ ├── 李澎煦--半平面交的算法及其应用/
│ │ │ ├── 李澎煦.doc
│ │ │ └── 李澎煦.ppt
│ │ ├── 李睿--二分法与统计问题/
│ │ │ ├── 李睿.doc
│ │ │ └── 李睿.ppt
│ │ ├── 杨旻旻--构造法/
│ │ │ └── 杨旻旻.ppt
│ │ ├── 王知昆--搜索顺序的选择/
│ │ │ └── 王知昆.ppt
│ │ ├── 符文杰--排序网络/
│ │ │ └── 符文杰.doc
│ │ ├── 许智磊--二分，再二分/
│ │ │ └── 许智磊.doc
│ │ ├── 金恺--浅谈网络流算法的应用/
│ │ │ └── 金恺.PPT
│ │ ├── 骆骥--浅析解对策问题的两种思路/
│ │ │ └── 骆骥.ppt
│ │ └── 黄芸/
│ │ └── 黄芸.ppt
│ ├── 国家集训队2003论文集/
│ │ ├── 伍昱--由对称性解2-SAT问题/
│ │ │ └── 伍昱.ppt
│ │ ├── 何林--一类称球问题的解法/
│ │ │ ├── Program/
│ │ │ │ └── GAME.PAS
│ │ │ ├── 何林.doc
│ │ │ └── 何林.ppt
│ │ ├── 侯启明--信息论在信息学竞赛中的简单应用/
│ │ │ ├── 侯启明.doc
│ │ │ └── 侯启明.ppt
│ │ ├── 刘一鸣--一类搜索问题的优化思想——数据的有序化/
│ │ │ ├── 刘一鸣.doc
│ │ │ └── 刘一鸣.ppt
│ │ ├── 刘才良--平面图在信息学中的应用/
│ │ │ └── 刘才良.ppt
│ │ ├── 周源--浅析“最小表示法”思想在字符串循环同构问题中的应用/
│ │ │ ├── 周源.doc
│ │ │ └── 周源.ppt
│ │ ├── 姜尚仆--模线性方程的应用，用数论方法解决整数问题/
│ │ │ └── 姜尚仆.ppt
│ │ ├── 张云亮--论对题目中算法的选择/
│ │ │ ├── Program/
│ │ │ │ ├── MYTURN.PAS
│ │ │ │ └── TURNOVER.PAS
│ │ │ ├── 张云亮.doc
│ │ │ └── 张云亮.ppt
│ │ ├── 张宁--猜数问题的研究/
│ │ │ ├── Program/
│ │ │ │ ├── TL1.PAS
│ │ │ │ ├── TL2.PAS
│ │ │ │ └── Tl3.pas
│ │ │ ├── 张宁.doc
│ │ │ └── 张宁.ppt
│ │ ├── 方奇--染色法和构造法在棋盘上的应用/
│ │ │ ├── 方奇.doc
│ │ │ └── 方奇.ppt
│ │ ├── 林希德--寻找最大重复子串/
│ │ │ ├── 林希德.doc
│ │ │ └── 林希德.ppt
│ │ ├── 王知昆--浅谈用极大化思想解决最大子矩形问题/
│ │ │ ├── 王知昆.doc
│ │ │ ├── 王知昆.ppt
│ │ │ └── 附件.doc
│ │ ├── 许智磊--浅谈补集转化思想在统计问题中的应用/
│ │ │ ├── 许智磊.doc
│ │ │ └── 许智磊.ppt
│ │ ├── 邵烜程--数学思想助你一臂之力/
│ │ │ ├── 邵烜程.doc
│ │ │ └── 邵烜程.ppt
│ │ ├── 金恺--探寻深度优先搜索中的优化问题/
│ │ │ └── 金恺.ppt
│ │ ├── 陆可昱--长方体的体积并/
│ │ │ └── 陆可昱.ppt
│ │ ├── 雷环中--结果提交类问题/
│ │ │ ├── 雷环中.doc
│ │ │ └── 雷环中.ppt
│ │ ├── 项荣璟--例析动态规划的个性化优化/
│ │ │ └── 项荣璟.ppt
│ │ ├── 饶向荣--剖析一道字符串匹配问题的解题过程/
│ │ │ └── 饶向荣.ppt
│ │ └── 高正宇--浅谈问答式交互问题/
│ │ └── 高正宇.ppt
│ ├── 国家集训队2004论文集/
│ │ ├── 何林.ppt
│ │ ├── 周源.ppt
│ │ ├── 朱晨光.ppt
│ │ ├── 朱泽园.ppt
│ │ ├── 李锐喆.ppt
│ │ ├── 杨思雨.ppt
│ │ ├── 林涛.ppt
│ │ ├── 栗师.ppt
│ │ ├── 楼天城.ppt
│ │ ├── 汪汀.ppt
│ │ ├── 肖天.ppt
│ │ ├── 胡伟栋.ppt
│ │ └── 薛矛.ppt
│ ├── 国家集训队2007论文集/
│ │ └── day2/
│ │ ├── 9.周冬《生成树的计数及其应用》.doc
│ │ └── 9.周冬《生成树的计数及其应用》.ppt
│ └── 国家集训队2008论文集/
│ └── Day1/
│ ├── 1.曹钦翔《数据结构的提炼与压缩》/
│ │ ├── 封面.doc
│ │ ├── 数据结构的提炼与压缩.ppt
│ │ ├── 目录.doc
│ │ └── 论文.doc
│ ├── 2.郑暾《平衡规划——浅析一类平衡思想的应用》/
│ │ ├── catch.dpr
│ │ ├── pku2103.dpr
│ │ ├── pku3237.dpr
│ │ ├── ural1099/
│ │ │ ├── gen.dpr
│ │ │ ├── ural1099_10.dpr
│ │ │ ├── ural1099_10.txt
│ │ │ ├── ural1099_10_10.dpr
│ │ │ ├── ural1099_10_10.txt
│ │ │ ├── ural1099_20.dpr
│ │ │ ├── ural1099_20.txt
│ │ │ ├── ural1099_20_10.dpr
│ │ │ ├── ural1099_20_10.txt
│ │ │ ├── ural1099_50.dpr
│ │ │ ├── ural1099_50.txt
│ │ │ ├── ural1099_5_10.dpr
│ │ │ ├── ural1099_5_10.txt
│ │ │ ├── ural1099_5_5.dpr
│ │ │ └── ural1099_5_5.txt
│ │ ├── ural1099.dpr
│ │ ├── 平衡规划.doc
│ │ └── 平衡规划.ppt
│ ├── 3.刘弈《浅谈信息学中状态的合理设计与应用》/
│ │ ├── 例题程序/
│ │ │ ├── Banal_Tickets.dpr
│ │ │ ├── Shoot_Your_Gun.dpr
│ │ │ └── Square_Roots.dpr
│ │ ├── 浅谈信息学中状态的合理设计与应用.doc
│ │ └── 浅谈信息学中状态的合理设计与应用.ppt
│ └── 4.顾研《浅谈随机化思想在几何问题中的应用》/
│ ├── 浅谈随机化思想在几何问题中的应用.doc
│ └── 浅谈随机化思想在几何问题中的应用.ppt
├── PPT/
│ ├── Hash在ACM竞赛中的应用.ppt
│ ├── 动态规划.ppt
│ ├── 威佐夫博弈.ppt
│ ├── 尼姆博弈.ppt
│ └── 巴什博弈.ppt
└── XLS/
└── NOI知识点.xls
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
# C++
# Prerequisites
*.d
# Compiled Object files
*.slo
*.lo
*.o
*.obj
# Precompiled Headers
*.gch
*.pch
# Compiled Dynamic libraries
*.so
*.dylib
*.dll
# Fortran module files
*.mod
*.smod
# Compiled Static libraries
*.lai
*.la
*.a
*.lib
# Executables
*.exe
*.out
*.app
# C
# Prerequisites
*.d
# Object files
*.o
*.ko
*.obj
*.elf
# Linker output
*.ilk
*.map
*.exp
# Precompiled Headers
*.gch
*.pch
# Libraries
*.lib
*.a
*.la
*.lo
# Shared objects (inc. Windows DLLs)
*.dll
*.so
*.so.*
*.dylib
# Executables
*.exe
*.out
*.app
*.i*86
*.x86_64
*.hex
# Debug files
*.dSYM/
*.su
*.idb
*.pdb
# Kernel Module Compile Results
*.mod*
*.cmd
.tmp_versions/
modules.order
Module.symvers
Mkfile.old
dkms.conf
# Xcode
.DS_Store
build/
*.xcodeproj/
# Pods - for those of you who use CocoaPods
# Pods
================================================
FILE: ACM 模板代码/f-0-1分数规划/f-0-1分数规划/main.cpp
================================================
//
// main.cpp
// f-0-1分数规划
//
// Created by ZYJ on 16/7/22.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
/*
* 0-1 分数规划
* t1 * x1 + t2 * x2 + ... + tn * xn
* r = ---------------------------------
* c1 * x1 + c2 * x2 + ... + cn * xn
* 给定t[1..n], c[1..n], 求x[1..n]使得sigma(xi)=k且r最大(小).
* 为了让r最大, 先设计子问题z(r) = (t1 * x1 + .. + tn * xn) - r * (c1 * xn + .. + cn * xn);
* 假设r的最优值为R. 则有:
* z(r) < 0 当且仅当 r > R;
* z(r) = 0 当且仅当 r = R;
* z(r) > 0 当且仅当 r < R;
* 于是可二分求R.
*/
int main(int argc, const char * argv[])
{
// insert code here...
std::cout << "Hello, World!\n";
return 0;
}
================================================
FILE: ACM 模板代码/f-2-SAT/f-2-SAT/main.cpp
================================================
//
// main.cpp
// f-2-SAT
//
// Created by ZYJ on 16/7/18.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
/*
* 2-sat 问题
* N个集团,每个集团2个人,现在要想选出尽量多的人,
* 且每个集团只能选出一个人。如果两人有矛盾,他们不能同时被选中
* 问最多能选出多少人
*/
const int MAXN = 3010;
int n, m;
int g[3010][3010], ct[3010], f[3010];
int x[3010], y[3010];
int prev[MAXN], low[MAXN], stk[MAXN], sc[MAXN];
int cnt[MAXN];
int cnt0, ptr, cnt1;
void dfs(int w)
{
int min(0);
prev[w] = cnt0++;
low[w] = prev[w];
min = low[w];
stk[ptr++] = w;
for (int i = 0; i < ct[w]; ++i)
{
int t = g[w][i];
if (prev[t] == -1)
{
dfs(t);
}
if (low[t] < min)
{
min = low[t];
}
}
if (min < low[w])
{
low[w] = min;
return ;
}
do
{
int v = stk[--ptr];
sc[v] = cnt1;
low[v] = MAXN;
} while(stk[ptr] != w);
++cnt1;
return ;
}
void Tarjan(int N)
{ // 传入N为点数,结果保存在sc数组中,同一标号的点在同一个强连通分量内,
// 强连通分量数为cnt1
cnt0 = cnt1 = ptr = 0;
int i;
for (i = 0; i < N; ++i)
{
prev[i] = low[i] = -1;
}
for (i = 0; i < N; ++i)
{
if (prev[i] == -1)
{
dfs(i);
}
}
return ;
}
int solve()
{
Tarjan(n);
for (int i = 0; i < n; i++)
{
if (sc[i] == sc[f[i]])
{
return 0;
}
}
return 1;
}
int check(int Mid)
{
for (int i = 0; i < n; i++)
{
ct[i] = 0;
}
for (int i = 0; i < Mid; i++)
{
g[f[x[i]]][ct[f[x[i]]]++] = y[i];
g[f[y[i]]][ct[f[y[i]]]++] = x[i];
}
return solve();
}
int main()
{
while (scanf("%d%d", &n, &m) != EOF && n + m)
{
for (int i = 0; i < n; i++)
{
int p, q;
scanf("%d%d", &p, &q);
f[p] = q, f[q] = p;
}
for (int i = 0; i < m; i++)
{
scanf("%d%d", &x[i], &y[i]);
}
n *= 2;
int Min = 0, Max = m + 1;
while (Min + 1 < Max)
{
int Mid = (Min + Max) / 2;
if (check(Mid))
{
Min = Mid;
}
else
{
Max = Mid;
}
}
printf("%d\n", Min);
}
return 0;
}
================================================
FILE: ACM 模板代码/f-AC自动机/f-AC自动机/main.cpp
================================================
//
// main.cpp
// f-AC自动机
//
// Created by ZYJ on 16/7/12.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
#include <queue>
using namespace std;
/*
* 求目标串中出现了几个模式串
*/
struct Trie
{
int next[500010][26], fail[500010], end[500010];
int root, L;
int newnode()
{
for (int i = 0; i < 26; i++)
{
next[L][i] = -1;
}
end[L++] = 0;
return L - 1;
}
void init()
{
L = 0;
root = newnode();
}
void insert(char buf[])
{
int len = (int)strlen(buf);
int now = root;
for (int i = 0; i < len; i++)
{
if (next[now][buf[i] - 'a'] == -1)
{
next[now][buf[i] - 'a'] = newnode();
}
now = next[now][buf[i] - 'a'];
}
end[now]++;
}
void build()
{
queue<int>Q;
fail[root] = root;
for (int i = 0; i < 26; i++)
{
if (next[root][i] == -1)
{
next[root][i] = root;
}
else
{
fail[next[root][i]] = root;
Q.push(next[root][i]);
}
}
while (!Q.empty())
{
int now = Q.front();
Q.pop();
for (int i = 0;i < 26;i++)
{
if (next[now][i] == -1)
{
next[now][i] = next[fail[now]][i];
}
else
{
fail[next[now][i]]=next[fail[now]][i];
Q.push(next[now][i]);
}
}
}
}
int query(char buf[])
{
int len = (int)strlen(buf);
int now = root;
int res = 0;
for (int i = 0; i < len; i++)
{
now = next[now][buf[i] - 'a'];
int temp = now;
while (temp != root)
{
res += end[temp];
end[temp] = 0;
temp = fail[temp];
}
}
return res;
}
void debug()
{
for (int i = 0; i < L; i++)
{
printf("id = %3d,fail = %3d,end = %3d,chi = [", i, fail[i], end[i]);
for (int j = 0; j < 26; j++)
{
printf("%2d", next[i][j]);
}
printf("]\n");
}
}
};
char buf[1000010];
Trie ac;
int main()
{
int T;
int n;
scanf("%d", &T);
while(T--)
{
scanf("%d", &n);
ac.init();
for (int i = 0; i < n; i++)
{
scanf("%s", buf);
ac.insert(buf);
}
ac.build();
scanf("%s", buf);
printf("%d\n", ac.query(buf));
}
return 0;
}
================================================
FILE: ACM 模板代码/f-Baby-Step Giant-Step/f-Baby-Step Giant-Step/main.cpp
================================================
//
// main.cpp
// f-Baby-Step Giant-Step
//
// Created by ZYJ on 16/7/9.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
#include <cmath>
using namespace std;
/*
* baby_step giant _step
* a^x = b(mod n) n不要求是素数
* 求解上式0 ≤ x < n的解
*/
#define MOD 76543
int hs[MOD];
int head[MOD];
int _next[MOD];
int id[MOD];
int top;
void insert(int x, int y)
{
int k = x % MOD;
hs[top] = x;
id[top] = y;
_next[top] = head[k];
head[k] = top++;
return ;
}
int find(int x)
{
int k = x % MOD;
for (int i = head[k]; i != -1; i = _next[i])
{
if (hs[i] == x)
{
return id[i];
}
}
return -1;
}
long long BSGS(int a, int b, int n)
{
memset(head, -1, sizeof(head));
top = 1;
if (b == 1)
{
return 0;
}
int m = (int)sqrt(n * 1.0), j;
long long x = 1, p = 1;
for (int i = 0; i < m; i++, p = p * a % n)
{
insert(p * b % n, i);
}
for (long long i = m; ; i++)
{
if ((j = find(x = x * p % n)) != -1)
{
return i - j;
}
if (i > n)
{
break;
}
}
return -1;
}
int main(int argc, const char * argv[])
{
// insert code here...
std::cout << "Hello, World!\n";
return 0;
}
================================================
FILE: ACM 模板代码/f-DAG的深度优先搜索标记/f-DAG的深度优先搜索标记/main.cpp
================================================
//
// main.cpp
// f-DAG的深度优先搜索标记
//
// Created by ZYJ on 16/6/13.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
//有向无环图
/*
* DAG的深度优先搜索标记
* INIT:edge[][]邻接矩阵；pre[], post[], tag全置0
* CALL:dfsTag(i, n); pre/post:开始/结束时间
*/
const int V = 1010;
int edge[V][V];
int pre[V];
int post[V];
int tag;
void dfsTag(int cur, int n)
{
//vertex:0 ~ n - 1
pre[cur] = ++tag;
for (int i = 0; i < n; i++)
{
if (edge[cur][i])
{
if (0 == pre[i])
{
std::cout << "Three Edge!" << '\n';
dfsTag(i, n);
}
else
{
if (0 == post[i])
{
std::cout << "Back Edge!" << '\n';
}
else if (pre[i] > pre[cur])
{
std::cout << "Down Edge!" << '\n';
}
else
{
std::cout << "Cross Edge!" << '\n';
}
}
}
}
post[cur] = ++tag;
return ;
}
int main(int argc, const char * argv[])
{
// insert code here...
std::cout << "Hello, World!\n";
return 0;
}
================================================
FILE: ACM 模板代码/f-FFT/f-FFT/main.cpp
================================================
//
// main.cpp
// f-FFT
//
// Created by ZYJ on 16/7/4.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
// FFT
/*
* HDU 1402 求高精度乘法
* A * B Problem Plus
*/
const double PI = acos(-1.0);
// 复数结构体
struct Complex
{
double x, y; // 实部和虚部 x + yi
Complex(double _x = 0.0, double _y = 0.0)
{
x = _x;
y = _y;
}
Complex operator - (const Complex &b) const
{
return Complex(x - b.x, y - b.y);
}
Complex operator + (const Complex &b) const
{
return Complex(x + b.x, y + b.y);
}
Complex operator * (const Complex &b) const
{
return Complex(x * b.x - y * b.y, x * b.y + y * b.x);
}
};
// 进行FFT和IFFT前的反转变换
// 位置i和（i二进制反转后的位置）互换
// len必须去2的幂
void change(Complex y[], int len)
{
int i, j, k;
for (i = 1, j = len / 2; i < len - 1; i++)
{
if (i < j)
{
swap(y[i], y[j]);
}
// 交换护卫小标反转的元素，i < j保证交换一次
// i做正常的+1，j左反转类型的+1，始终保持i和j是反转的
k = len / 2;
while (j >= k)
{
j -= k;
k /= 2;
}
if (j < k)
{
j += k;
}
}
return ;
}
// FFT
// len必须为2 ^ k形式
// on == 1时是DFT，on == -1时是IDFT
void fft(Complex y[], int len, int on)
{
change(y, len);
for (int h = 2; h <= len; h <<= 1)
{
Complex wn(cos(-on * 2 * PI / h), sin(-on * 2 * PI / h));
for (int j = 0; j < len; j += h)
{
Complex w(1, 0);
for (int k = j; k < j + h / 2; k++)
{
Complex u = y[k];
Complex t = w * y[k + h / 2];
y[k] = u + t;
y[k + h / 2] = u - t;
w = w * wn;
}
}
}
if (on == -1)
{
for (int i = 0; i < len; i++)
{
y[i].x /= len;
}
}
}
const int MAXN = 200010;
Complex x1[MAXN], x2[MAXN];
char str1[MAXN / 2], str2[MAXN];
int sum[MAXN];
int main(int argc, const char * argv[])
{
while (cin >> str1 >> str2)
{
int len1 = (int)strlen(str1);
int len2 = (int)strlen(str2);
int len = 1;
while (len < len1 * 2 || len < len2 * 2)
{
len <<= 1;
}
for (int i = 0; i < len1; i++)
{
x1[i] = Complex(str1[len1 - 1 - i] - '0', 0);
}
for (int i = len1; i < len; i++)
{
x1[i] = Complex(0, 0);
}
for (int i = 0; i < len2; i++)
{
x2[i] = Complex(str2[len2 - 1 - i] - '0', 0);
}
for (int i = len2; i < len; i++)
{
x2[i] = Complex(0, 0);
}
// 求DFT
fft(x1, len, 1);
fft(x2, len, 1);
for (int i = 0; i < len; i++)
{
x1[i] = x1[i] * x2[i];
}
fft(x1, len, -1);
for (int i = 0; i < len; i++)
{
sum[i] = (int)(x1[i].x + 0.5);
}
for (int i = 0; i < len; i++)
{
sum[i + 1] += sum[i] / 10;
sum[i] %= 10;
}
len = len1 + len2 - 1;
while (sum[len] <= 0 && len > 0)
{
len--;
}
for (int i = len; i >= 0; i--)
{
printf("%c", sum[i] + '0');
}
putchar('\n');
}
return 0;
}
================================================
FILE: ACM 模板代码/f-FWT/f-FWT/main.cpp
================================================
//
// main.cpp
// f-FWT
//
// Created by ZYJ on 2017/7/6.
// Copyright © 2017年 ZYJ. All rights reserved.
//
/*
* FWT(快速沃尔什变化)-Xor
* MOD:1e9 + 7, INV_2:2关于MOD的逆元
* N:2的整次幂(不够就向上取整)
*/
typedef long long ll;
const int MOD = 1e9 + 7;
const int INV_2 = 5e8 + 4;
inline void FWT(int c[], int N, int tf_utf) // tf_utf 1:tf; 0:utf
{
for (int i = 1; i < N; i <<= 1)
{
int tmp = i << 1;
for (int j = 0; j < N; j += tmp)
{
for (int k = 0; k < i; k++)
{
int x = c[j + k], y = c[j + k + i];
if (tf_utf)
{
c[j + k] = x + y;
if (c[j + k] >= MOD)
{
c[j + k] -= MOD;
}
c[j + k + i] = x - y;
if (c[j + k + i] < 0)
{
c[j + k + i] += MOD;
}
}
else
{
c[j + k] = (ll)(x + y) * INV_2 % MOD;
c[j + k + i] = (ll)(x - y + MOD) * INV_2 % MOD;
}
}
}
}
}
================================================
FILE: ACM 模板代码/f-Floyd求最小环/f-Floyd求最小环/main.cpp
================================================
//
// main.cpp
// f-Floyd求最小环
//
// Created by ZYJ on 16/7/18.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
const int INF = 1000000000;
const int N = 110;
int n, m; // n:节点个数, m:边的个数
int g[N][N]; // 无向图
int dist[N][N]; // 最短路径
int r[N][N]; // r[i][j]: i到j的最短路径的第一步
int out[N], ct; // 记录最小环
int solve(int i, int j, int k)
{ // 记录最小环
ct = 0;
while (j != i)
{
out[ct++] = j;
j = r[i][j];
}
out[ct++] = i;
out[ct++] = k;
return 0;
}
int main()
{
while (scanf("%d%d", &n, &m) != EOF)
{
int i, j, k;
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
{
g[i][j] = INF;
r[i][j] = i;
}
}
for (i = 0; i < m; i++)
{
int x, y, l;
scanf("%d%d%d", &x, &y, &l);
--x;
--y;
if (l < g[x][y])
{
g[x][y] = g[y][x] = l;
}
}
memmove(dist, g, sizeof(dist));
int Min = INF; // 最小环
for (k=0; k < n; k++)
{ // Floyd
for (i = 0; i < k; i++) // 一个环中的最大结点为k(编号最大)
{
if (g[k][i] < INF)
{
for (j = i + 1; j < k; j++)
{
if (dist[i][j] < INF && g[k][j] < INF && Min > dist[i][j] + g[k][i] + g[k][j])
{
Min = dist[i][j] + g[k][i] + g[k][j];
solve(i, j, k); // 记录最小环
}
}
}
}
for (i = 0; i < n; i++)
{
if (dist[i][k] < INF)
{
for (j = 0; j < n; j++)
{
if (dist[k][j] < INF && dist[i][j] > dist[i][k]+dist[k][j])
{
dist[i][j] = dist[i][k] + dist[k][j];
r[i][j] = r[k][j];
}
}
}
}
}
if (Min < INF)
{
for (ct--; ct >= 0; ct--)
{
printf("%d", out[ct] + 1);
if (ct)
{
printf(" ");
}
}
}
else
{
printf("No solution.");
}
printf("\n");
}
return 0;
}
================================================
FILE: ACM 模板代码/f-GCD/f-GCD/main.cpp
================================================
//
// main.cpp
// f-GCD
//
// Created by ZYJ on 16/6/28.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
using namespace std;
// GCD最大公约数
int gcd(int x, int y)
{
if (!x || !y)
{
return x > y ? x : y;
}
for (int t; t = x % y, t; x = y, y = t);
return y;
}
// 快速GCD
int kgcd(int a, int b)
{
if (a == 0)
{
return b;
}
if (b == 0)
{
return a;
}
if (!(a & 1) && !(b & 1))
{
return kgcd(a >> 1, b >> 1) << 1;
}
else if (!(b & 1))
{
return kgcd(a, b >> 1);
}
else if (!(a & 1))
{
return kgcd(a >> 1, b);
}
else
{
return kgcd(abs(a - b), min(a, b));
}
}
// 扩展GCD
/*
* 求x，y使得gcd(a, b) = a * x + b * y;
*/
int extgcd(int a, int b, int &x, int &y)
{
if (b == 0)
{
x = 1;
y = 0;
return a;
}
int d = extgcd(b, a % b, x, y);
int t = x;
x = y;
y = t - a / b * y;
return d;
}
int main(int argc, const char * argv[])
{
int a, b;
while (cin >> a >> b)
{
cout << gcd(a, b) << '\n';
}
// insert code here...
std::cout << "Hello, World!\n";
return 0;
}
================================================
FILE: ACM 模板代码/f-Graham求凸包/f-Graham求凸包/main.cpp
================================================
//
// main.cpp
// f-Graham求凸包
//
// Created by ZYJ on 16/7/23.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
using namespace std;
/*
* Graham 求凸包 O(N * logN)
* CALL: nr = graham(pnt, int n, res); res[]为凸包点集;
*/
struct point
{
double x, y;
};
bool mult(point sp, point ep, point op)
{
return (sp.x - op.x) * (ep.y - op.y) >= (ep.x - op.x) * (sp.y - op.y);
}
//inline bool operator < (const point &l, const point &r)
//{
// return l.y < r.y || (l.y == r.y && l.x < r.x);
//}
int graham(point pnt[], int n, point res[])
{
int i, len, top = 1;
sort(pnt, pnt + n);
if (n == 0)
{
return 0;
}
res[0] = pnt[0];
if (n == 1)
{
return 1;
}
res[1] = pnt[1];
if (n == 2)
{
return 2;
}
res[2] = pnt[2];
for (i = 2; i < n; i++)
{
while (top && mult(pnt[i], res[top], res[top - 1]))
{
top--;
}
res[++top] = pnt[i];
}
len = top;
res[++top] = pnt[n - 2];
for (i = n - 3; i >= 0; i--)
{
while (top != len && mult(pnt[i], res[top], res[top - 1]))
{
top--;
}
res[++top] = pnt[i];
}
return top; // 返回凸包中点的个数
}
================================================
FILE: ACM 模板代码/f-KMP算法/f-KMP算法/main.cpp
================================================
//
// main.cpp
// f-KMP算法
//
// Created by ZYJ on 16/6/16.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
//// KMP算法
//
///*
// * next[]的含义，x[i - next[i]...i - 1] = x[0...next[i] - 1]
// * next[i]为满足x[i - z...i - 1] = x[0...z - 1]的最大z值（就是x的自身匹配）
// * 字符串从下标0开始存，最后得到的next数组比常规情况对应每位少1
// * ex: ababaaaba:常规：011234223；非常规：-100123112
// */
//
//void KMP_Pre(char x[], int m, int next[])
//{
// int i, j;
// j = next[0] = -1;
// i = 0;
// while (i < m)
// {
// while (-1 != j && x[i] != x[j])
// {
// j = next[j];
// }
// next[++i] = ++j;
// }
// return ;
//}
//
///*
// * kmpNext[]的意思：next'[i] = next[next[...[next[i]]]]
// * （直到next'[i] < 0或者x[next'[i]] != x[i]）
// * 这样的预处理可以快一些
// * 字符串从下标0开始存，最后得到的next数组比常规情况对应每位少1
// * ex: ababaaaba:常规：011234223；非常规：-100123112
// */
//
//void preKMP(char x[], int m, int kmpNext[])
//{
// int i, j;
// j = kmpNext[0] = -1;
// i = 0;
// while (i < m)
// {
// while (-1 != j && x[i] != x[j])
// {
// j = kmpNext[j];
// }
// if (x[++i] == x[++j])
// {
// kmpNext[i] = kmpNext[j];
// }
// else
// {
// kmpNext[i] = j;
// }
// }
// return ;
//}
//
///*
// * 返回x在y中出现的次数，可以重叠
// */
//
//int next[10010];
//
//int KMP_Count(char x[], int m, char y[], int n)
//{
// //x是模式串，y是主串
// int i, j;
// int ans = 0;
// //preKMP(x, m, next);
// KMP_Pre(x, m, next);
// i = j = 0;
// while (i < n)
// {
// while (-1 != j && y[i] != x[j])
// {
// j = next[j];
// }
// i++, j++;
// if (j >= m)
// {
// ans++;
// j = next[j];
// }
// }
// return ans;
//}
//
//
//
//int main(int argc, const char * argv[])
//{
// // insert code here...
// std::cout << "Hello, World!\n";
// return 0;
//}
/*
* 通过计算返回子串T的next数组
*/
void getNext(char *T, int *next, int len)
{
int i = 0, j = -1;
next[0] = -1;
while (i < len)
{
if (j == -1 || T[i] == T[j])
{
next[++i] = ++j;
}
else
{
j = next[j]; // 若字符不相同，则j值回溯
}
}
return ;
}
/*
* 返回子串T在主串S中第pos个字符之后的位置。若不存在，则函数返回值为0
* T非空，0 ≤ pos ≤ len - 1
*/
int indexKMP(char *S, char *T, int *next, int pos, int lenS, int lenT)
{
int i = pos;
int j = 0;
getNext(T, next, lenT); // 对串T作分析，得到next数组
while (i < lenS && j < lenT) // 若i小于S的长度且j小于T的长度时循环继续
{
if (j == -1 || S[i] == T[j])// 两字母相等则继续，与朴素算法相比增加了 j = -1 判断
{
i++;
j++;
}
else // 指针后退重新开始匹配
{
j = next[j]; // j退回合适的位置，i值不变
}
}
if (j >= lenT)
{
return i - lenT;
}
else
{
return 0;
}
}
================================================
FILE: ACM 模板代码/f-Karp-Rabin算法/f-Karp-Rabin算法/main.cpp
================================================
//
// main.cpp
// f-Karp-Rabin算法
//
// Created by ZYJ on 16/6/21.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
// Karp-Rabin字符串匹配
/*
* hash(w[0 ... m - 1]) =
* (w[0] * 2 ^ (m - 1) + ... + w[m - 1] * 2 ^ 0) % q;
* hash(w[j + 1 ... j + m]) =
* rehash(y[j], y[j + m], hash(w[j ... j + m - 1]);
* rehash(a, b, h) = ((h - a * 2 ^ (m - 1)) * 2 + b) % q;
* 可以用q = 2 ^ 32简化%运算
*/
//#define REHASH(a, b, h) (((h - (a) * b) << 1) + b)
//
//int krmatch(char *x, int m, char *y, int n)
//{
// //search x in y
// int d, hx, hy, i, j;
// for (d = i = 1; i < m; i++)
// {
// d = (d << 1);
// }
// for (hy = hx = i = 0; i < m; i++)
// {
// hx = ((hx << 1) + x[i]);
// hy = ((hy << 1) + y[i]);
// }
// for (j = 0; j <= n - m; j++)
// {
// if (hx == hy && memcmp(x, y + j, m) == 0)
// {
// return j;
// }
// hy = REHASH(y[j], y[j + m], hy);
// }
// return 0; //理论上不会背执行，全部都应该从上一个return返回
//}
// Karp-Rabin字符块匹配
/*
* Text: n * m matrix;
* Pattern: x * y matrix;
*/
//#define uint unsigned int // C++中自带
const int A = 1024, B = 128;
const uint E = 27;
char text[A][A];
char patt[B][B];
uint ht, hp;
uint pw[B * B];
uint hor[A];
uint ver[A][A];
int n, m, x, y;
void init()
{
int i, j = B * B;
for (i = 1, pw[0] = 1; i < j; i++)
{
pw[i] = pw[i - 1] * E;
}
return ;
}
void hash()
{
int i, j;
for (i = 0; i < n; i++)
{
for (j = 0, hor[i] = 0; j < y; j++)
{
hor[i] *= pw[x];
hor[i] += text[i][j] - 'a';
}
}
for (j = 0; j < m; j++)
{
for (i = 0, ver[0][j] = 0; i < x; i++)
{
ver[0][j] *= E;
ver[0][j] += text[i][j] - 'a';
}
for (i = 1; i <= n - x; i++)
{
ver[i][j] = (ver[i - 1][j] - (text[i - 1][j] - 'a') * pw[x - 1]) * E + text[i + x - 1][j] - 'a';
}
}
for (j = 0, ht = hp = 0; j < y; j++)
{
for (i = 0; i < x; i++)
{
ht *= E;
ht += text[i][j] - 'a';
hp *= E;
hp += patt[i][j] - 'a';
}
}
return ;
}
void read()
{
int i;
std::cin >> n >> m;
for (i = 0; i < n; i++)
{
std::cin >> text[i];
}
for (i = 0; i < x; i++)
{
std::cin >> patt[i];
}
return ;
}
int solve()
{
if (n == 0 || m == 0 || x == 0 || y == 0)
{
return 0;
}
int i, j, cnt = 0;
uint t;
for (i = 0; i <= n - x; i++)
{
for (j = 0, t = ht; j <= m - y; j++)
{
if (t == hp)
{
cnt++;
}
t = (t - ver[i][j] * pw[y * x - x]) * pw[x] + ver[i][j + y];
}
ht = (ht - hor[i] * pw[x - 1]) * E + hor[i + x];
}
return cnt;
}
int main(int argc, const char * argv[])
{
int T;
init();
for (std::cin >> T; T; T--)
{
read();
hash();
std::cout << solve() << '\n';
}
return 0;
}
================================================
FILE: ACM 模板代码/f-LCA/f-LCA/main.cpp
================================================
//
// main.cpp
// f-LCA
//
// Created by ZYJ on 16/7/14.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
#include <queue>
using namespace std;
// DFS + ST算法
///*
// * DFS + ST在线算法
// */
//const int MAXN = 10010;
//int rmq[2 * MAXN]; // rmq数组,就是欧拉序列对应的深度序列
//
//struct ST
//{
// int mm[2*MAXN];
// int dp[2*MAXN][20]; // 最小值对应的下标
// void init(int n)
// {
// mm[0] = -1;
// for (int i = 1; i <= n; i++)
// {
// mm[i] = ((i & (i - 1)) == 0) ? mm[i - 1] + 1 : mm[i - 1];
// dp[i][0] = i;
// }
// for (int j = 1; j <= mm[n]; j++)
// {
// for (int i = 1; i + (1 << j) - 1 <= n; i++)
// {
// dp[i][j] = rmq[dp[i][j - 1]] < rmq[dp[i + (1 << (j - 1))][j - 1]] ? dp[i][j - 1] : dp[i + (1 << (j - 1))][j - 1];
// }
// }
// }
// int query(int a,int b) // 查询[a,b]之间最小值的下标
// {
// if (a > b)
// {
// swap(a, b);
// }
// int k = mm[b - a + 1];
// return rmq[dp[a][k]] <= rmq[dp[b - (1 << k) + 1][k]] ? dp[a][k] : dp[b - (1 << k) + 1][k];
// }
//};
//
//// 边的结构体定义
//struct Edge
//{
// int to, next;
//};
//
//Edge edge[MAXN * 2];
//
//int tot, head[MAXN];
//int F[MAXN * 2]; // 欧拉序列,就是dfs遍历的顺序,长度为2*n-1,下标从1开始
//int P[MAXN]; // P[i]表示点i在F中第一次出现的位置
//int cnt;
//ST st;
//
//void init()
//{
// tot = 0;
// memset(head, -1, sizeof(head));
//}
//
//void addedge(int u, int v) // 加边,无向边需要加两次
//{
// edge[tot].to = v;
// edge[tot].next = head[u];
// head[u] = tot++;
//}
//
//void dfs(int u, int pre, int dep)
//{
// F[++cnt] = u;
// rmq[cnt] = dep;
// P[u] = cnt;
// for (int i = head[u]; i != -1; i = edge[i].next)
// {
// int v = edge[i].to;
// if (v == pre)
// {
// continue;
// }
// dfs(v, u, dep + 1);
// F[++cnt] = u;
// rmq[cnt] = dep;
// }
//}
//
//void LCA_init(int root, int node_num) // 查询LCA前的初始化
//{
// cnt = 0;
// dfs(root, root, 0);
// st.init(2 * node_num - 1);
//}
//
//int query_lca(int u, int v) // 查询u,v的lca编号
//{
// return F[st.query(P[u], P[v])];
//}
//
//bool flag[MAXN];
//
//int main()
//{
// int T;
// int N;
// int u, v;
// scanf("%d", &T);
// while(T--)
// {
// scanf("%d", &N);
// init();
// memset(flag, false, sizeof(flag));
// for (int i = 1; i < N; i++)
// {
// scanf("%d%d", &u, &v);
// addedge(u, v);
// addedge(v, u);
// flag[v] = true;
// }
// int root;
// for (int i = 1; i <= N; i++)
// {
// if (!flag[i])
// {
// root = i;
// break;
// }
// }
// LCA_init(root, N);
// scanf("%d%d", &u, &v);
// printf("%d\n", query_lca(u, v));
// }
// return 0;
//}
// 离线Tarjan算法
///*
// * 给出一颗有向树，Q个查询
// * 输出查询结果中每个点出现次数
// * 复杂度O(n + Q);
// */
//const int MAXN = 1010;
//const int MAXQ = 500010; // 查询数的最大值
//
//// 并查集部分
//int F[MAXN]; // 需要初始化为-1
//
//int find(int x)
//{
// if (F[x] == -1)
// {
// return x;
// }
// return F[x] = find(F[x]);
//}
//
//void bing(int u, int v)
//{
// int t1 = find(u);
// int t2 = find(v);
// if (t1 != t2)
// {
// F[t1] = t2;
// }
//}
//
//bool vis[MAXN]; // 访问标记
//int ancestor[MAXN]; // 祖先
//struct Edge
//{
// int to, next;
//} edge[MAXN * 2];
//int head[MAXN],tot;
//
//void addedge(int u, int v)
//{
// edge[tot].to = v;
// edge[tot].next = head[u];
// head[u] = tot++;
//}
//
//struct Query
//{
// int q, next;
// int index; // 查询编号
//} query[MAXQ * 2];
//
//int answer[MAXQ]; // 存储最后的查询结果,下标0~Q-1
//int h[MAXQ];
//int tt;
//int Q;
//
//void add_query(int u, int v, int index)
//{
// query[tt].q = v;
// query[tt].next = h[u];
// query[tt].index = index;
// h[u] = tt++;
// query[tt].q = u;
// query[tt].next = h[v];
// query[tt].index = index;
// h[v] = tt++;
//}
//
//void init()
//{
// tot = 0;
// memset(head, -1, sizeof(head));
// tt = 0;
// memset(h, -1, sizeof(h));
// memset(vis, false, sizeof(vis));
// memset(F, -1, sizeof(F));
// memset(ancestor, 0, sizeof(ancestor));
//}
//
//void LCA(int u)
//{
// ancestor[u] = u;
// vis[u] = true;
// for (int i = head[u]; i != -1; i = edge[i].next)
// {
// int v = edge[i].to;
// if (vis[v])
// {
// continue;
// }
// LCA(v);
// bing(u, v);
// ancestor[find(u)] = u;
// }
// for (int i = h[u]; i != -1; i = query[i].next)
// {
// int v = query[i].q;
// if (vis[v])
// {
// answer[query[i].index] = ancestor[find(v)];
// }
// }
//}
//
//bool flag[MAXN];
//int Count_num[MAXN];
//
//int main()
//{
// int n;
// int u, v, k;
// while (scanf("%d", &n) == 1)
// {
// init();
// memset(flag, false, sizeof(flag));
// for (int i = 1; i <= n; i++)
// {
// scanf("%d:(%d)", &u, &k);
// while (k--)
// {
// scanf("%d", &v);
// flag[v] = true;
// addedge(u,v);
// addedge(v,u);
// }
// }
// scanf("%d", &Q);
// for (int i = 0; i < Q; i++)
// {
// char ch;
// cin >> ch;
// scanf("%d %d)", &u, &v);
// add_query(u, v, i);
// }
// int root;
// for (int i = 1; i <= n; i++)
// {
// if (!flag[i])
// {
// root = i;
// break;
// }
// }
// LCA(root);
// memset(Count_num, 0, sizeof(Count_num));
// for (int i = 0; i < Q; i++)
// {
// Count_num[answer[i]]++;
// }
// for (int i = 1; i <= n; i++)
// {
// if (Count_num[i] > 0)
// {
// printf("%d:%d\n", i, Count_num[i]);
// }
// }
// }
// return 0;
//}
// LCA倍增法
/*
* POJ 1330
* LCA 在线算法 */
const int MAXN = 10010;
const int DEG = 20;
struct Edge
{
int to, next;
} edge[MAXN * 2];
int head[MAXN], tot;
void addedge(int u, int v)
{
edge[tot].to = v;
edge[tot].next = head[u];
head[u] = tot++;
}
void init()
{
tot = 0;
memset(head, -1, sizeof(head));
}
int fa[MAXN][DEG]; // fa[i][j]表示结点i的第2^j个祖先
int deg[MAXN]; // 深度数组
void BFS(int root)
{
queue<int>que;
deg[root] = 0;
fa[root][0] = root;
que.push(root);
while (!que.empty())
{
int tmp = que.front();
que.pop();
for (int i = 1; i < DEG; i++)
{
fa[tmp][i] = fa[fa[tmp][i - 1]][i - 1];
}
for (int i = head[tmp]; i != -1; i = edge[i].next)
{
int v = edge[i].to;
if (v == fa[tmp][0])
{
continue;
}
deg[v] = deg[tmp] + 1;
fa[v][0] = tmp;
que.push(v);
}
}
}
int LCA(int u, int v)
{
if (deg[u] > deg[v])
{
swap(u, v);
}
int hu = deg[u], hv = deg[v];
int tu = u, tv = v;
for (int det = hv-hu, i = 0; det ; det >>= 1, i++)
{
if (det & 1)
{
tv = fa[tv][i];
}
}
if (tu == tv)
{
return tu;
}
for (int i = DEG - 1; i >= 0; i--)
{
if (fa[tu][i] == fa[tv][i])
{
continue;
}
tu = fa[tu][i];
tv = fa[tv][i];
}
return fa[tu][0];
}
bool flag[MAXN];
int main()
{
int T;
int n;
int u, v;
scanf("%d", &T);
while(T--)
{
scanf("%d", &n);
init();
memset(flag, false, sizeof(flag));
for (int i = 1; i < n; i++)
{
scanf("%d%d", &u, &v);
addedge(u, v);
addedge(v, u);
flag[v] = true;
}
int root;
for (int i = 1; i <= n; i++)
{
if (!flag[i])
{
root = i;
break;
}
}
BFS(root);
scanf("%d%d", &u, &v);
printf("%d\n", LCA(u, v));
}
return 0;
}
================================================
FILE: ACM 模板代码/f-Liuctic的计算几何库/f-Liuctic的计算几何库/main.cpp
================================================
//
// main.cpp
// f-Liuctic的计算几何库
//
// Created by ZYJ on 16/7/23.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
#include <cmath>
/*
* Liuctic 的计算几何库
* p-Lpoint ln,l - Lline ls - Llineseglr - Lrad
* 求平面上两点之间的距离 p2pdis
* 返回(P1-P0)*(P2-P0)的叉积 xmulti
* 确定两条线段是否相交 lsinterls
* 判断点p是否在线段l上 ponls
* 判断两个点是否相等 Euqal_Point
* 线段非端点相交 lsinterls_A
* 判断点q是否在多边形Polygon内 pinplg
* 多边形的面积 area_of_polygon
* 解二次方程 Ax^2+Bx+C=0 equa
* 点到直线距离 p2lndis
* 直线与圆的交点,已知直线与圆相交 lncrossc
* 点是否在射线的正向 samedir
* 射线与圆的第一个交点 lrcrossc
* 求点p1关于直线ln的对称点p2 mirror
* 两直线夹角(弧度) angle_LL
*/
#define infinity 1e20
#define EP 1e-10
const int MAXV = 300;
const double PI = 2.0 * asin(1.0); // 高精度PI
struct Lpoint
{
double x, y;
}; // 点
struct Llineseg
{
Lpoint a, b;
}; // 线段
struct Ldir
{
double dx, dy;
}; // 方向向量
struct Lline
{
Lpoint p;
Ldir dir;
}; // 直线
struct Lrad
{
Lpoint Sp;
Ldir dir;
}; // 射线
struct Lround
{
Lpoint co;
double r;
}; // 圆
// 求平面上两点之间的距离
double p2pdis(Lpoint p1, Lpoint p2)
{
return (sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y)));
}
// (P1-P0)*(P2-P0)的叉积
/*
* 若结果为正,则<P0,P1>在<P0,P2>的顺时针方向;
* 若为0则<P0,P1><P0,P2>共线;
* 若为负则<P0,P1>在<P0,P2>的在逆时针方向;
* 可以根据这个函数确定两条线段在交点处的转向,比如确定p0p1和p1p2在p1处是左转还是右转,只要求(p2-p0)*(p1-p0),
* 若<0则左转,>0则右转,=0则共线
*/
double xmulti(Lpoint p1, Lpoint p2, Lpoint p0)
{
return ((p1.x - p0.x) * (p2.y - p0.y) - (p2.x - p0.x) * (p1.y - p0.y));
}
// 确定两条线段是否相交
double mx(double t1, double t2)
{
if (t1 > t2)
{
return t1;
}
return t2;
}
double mn(double t1, double t2)
{
if (t1 < t2)
{
return t1;
}
return t2;
}
int lsinterls(Llineseg u, Llineseg v)
{
return ((mx(u.a.x, u.b.x) >= mn(v.a.x, v.b.x)) && (mx(v.a.x, v.b.x) >= mn(u.a.x, u.b.x)) && (mx(u.a.y, u.b.y) >= mn(v.a.y, v.b.y)) && (mx(v.a.y, v.b.y) >= mn(u.a.y, u.b.y)) && (xmulti(v.a, u.b, u.a) * xmulti(u.b, v.b, u.a) >= 0) && (xmulti(u.a, v.b, v.a) * xmulti(v.b, u.b, v.a) >= 0));
}
// 判断点p是否在线段l上
int ponls(Llineseg l, Lpoint p)
{
return ((xmulti(l.b, p, l.a) == 0) && (((p.x - l.a.x) * (p.x - l.b.x) < 0) || ((p.y - l.a.y) * (p.y - l.b.y) < 0)));
}
// 判断两个点是否相等
int Euqal_Point(Lpoint p1, Lpoint p2)
{
return ((fabs(p1.x - p2.x) < EP) && (fabs(p1.y - p2.y) < EP));
}
// 线段相交判断函数
/*
* 当且仅当u,v相交并且交点不是u,v的端点时函数为true;
*/
int lsinterls_A(Llineseg u, Llineseg v)
{
return ((lsinterls(u, v)) && (!Euqal_Point(u.a, v.a)) && (!Euqal_Point(u.a, v.b)) && (!Euqal_Point(u.b, v.a)) && (!Euqal_Point(u.b, v.b)));
}
// 判断点q是否在多边形内
/*
* 其中多边形是任意的凸或凹多边形,
* Polygon中存放多边形的逆时针顶点序列
*/
int pinplg(int vcount, Lpoint Polygon[], Lpoint q)
{
int c = 0, i, n;
Llineseg l1, l2;
l1.a = q;
l1.b = q;
l1.b.x = infinity;
n = vcount;
for (i = 0; i < vcount; i++)
{
l2.a = Polygon[i];
l2.b = Polygon[(i + 1) % n];
if ((lsinterls_A(l1, l2)) || ((ponls(l1, Polygon[(i + 1) % n])) && (((!ponls(l1, Polygon[(i + 2) % n])) && (xmulti(Polygon[i], Polygon[(i + 1) % n], l1.a) * xmulti(Polygon[(i + 1) % n], Polygon[(i + 2) % n], l1.a) > 0)) || ((ponls(l1, Polygon[(i + 2) % n])) && (xmulti(Polygon[i], Polygon[(i + 2) % n], l1.a) * xmulti(Polygon[(i + 2) % n], Polygon[(i + 3) % n], l1.a) > 0)))))
{
c++;
}
}
return (c % 2 != 0);
}
// 多边形的面积
/*
* 要求按照逆时针方向输入多边形顶点
* 可以是凸多边形或凹多边形
*/
double area_of_polygon(int vcount, double x[], double y[], Lpoint plg[])
{
int i;
double s;
if (vcount < 3)
{
return 0;
}
s = plg[0].y * (plg[vcount - 1].x - plg[1].x);
for (i = 1; i < vcount; i++)
{
s += plg[i].y * (plg[(i - 1)].x - plg[(i + 1) % vcount].x);
}
return s / 2;
}
// 解二次方程 Ax^2+Bx+C=0
/*
* 返回-1表示无解 返回1 表示有解
*/
int equa(double A, double B, double C, double &x1, double &x2)
{
double f = B * B - 4 * A * C;
if (f < 0)
{
return -1;
}
x1 = (-B + sqrt(f)) / (2 * A);
x2 = (-B - sqrt(f)) / (2 * A);
return 1;
}
// 计算直线的一般式 Ax+By+C=0
void format(Lline ln, double &A, double &B, double &C)
{
A = ln.dir.dy;
B = -ln.dir.dx;
C = ln.p.y * ln.dir.dx - ln.p.x * ln.dir.dy;
return ;
}
// 点到直线距离
double p2ldis(Lpoint a, Lline ln)
{
double A, B, C;
format(ln, A, B, C);
return (fabs(A * a.x + B * a.y + C) / sqrt(A * A + B * B));
}
// 直线与圆的交点,已知直线与圆相交
int lncrossc(Lline ln, Lround Y, Lpoint &p1, Lpoint &p2)
{
double A, B, C, t1, t2;
int zz = -1;
format(ln, A, B, C);
if (fabs(B) < 1e-8)
{
p1.x = p2.x = -1.0 * C / A;
zz = equa(1.0, -2.0 * Y.co.y, Y.co.y * Y.co.y + (p1.x - Y.co.x) * (p1.x - Y.co.x) - Y.r * Y.r, t1, t2);
p1.y = t1;
p2.y = t2;
}
else if (fabs(A) < 1e-8)
{
p1.y = p2.y = -1.0 * C / B;
zz = equa(1.0, -2.0 * Y.co.x, Y.co.x * Y.co.x + (p1.y - Y.co.y) * (p1.y - Y.co.y) - Y.r * Y.r, t1, t2);
p1.x = t1;
p2.x = t2;
}
else
{
zz = equa(A * A + B * B, 2.0 * A * C + 2.0 * A * B * Y.co.y - 2.0 * B * B * Y.co.x, B * B * Y.co.x * Y.co.x + C * C + 2* B * C * Y.co.y + B * B * Y.co.y * Y.co.y - B * B * Y.r * Y.r, t1, t2);
p1.x = t1, p1.y = -1 * (A / B * t1 + C / B);
p2.x = t2, p2.y = -1 * (A / B * t2 + C / B);
}
return 0;
}
// 点是否在射线的正向
bool samedir(Lrad ln, Lpoint P)
{
double ddx, ddy;
ddx = P.x - ln.Sp.x;
ddy = P.y - ln.Sp.y;
if ((ddx * ln.dir.dx > 0 || fabs(ddx * ln.dir.dx) < 1e-7) && (ddy * ln.dir.dy > 0 || (fabs(ddy * ln.dir.dy) < 1e-7)))
{
return true;
}
else
{
return false;
}
}
// 射线与圆的第一个交点
/*
* 已经确定射线所在直线与圆相交返回-1表示不存正向交点,否则返回1
*/
int lrcrossc(Lrad ln, Lround Y, Lpoint &P)
{
Lline ln2;
Lpoint p1, p2;
int res = -1;
double dis = 1e20;
ln2.p = ln.Sp, ln2.dir = ln.dir;
lncrossc(ln2, Y, p1, p2);
if (samedir(ln, p1))
{
res = 1;
if (p2pdis(p1, ln.Sp) < dis)
{
dis = p2pdis(p1, ln.Sp);
}
P = p1;
}
if (samedir(ln, p2))
{
res = 1;
if (p2pdis(p2, ln.Sp) < dis)
{
dis = p2pdis(p2, ln.Sp);
P = p2;
}
}
return res;
}
// 求点p1关于直线ln的对称点p2
Lpoint mirror(Lpoint P, Lline ln)
{
Lpoint Q;
double A, B, C;
format(ln, A, B, C);
Q.x = ((B * B - A * A) * P.x - 2 * A * B * P.y - 2 * A * C) / (A * A + B * B);
Q.y = ((A * A - B * B) * P.y - 2 * A * B * P.x - 2 * B * C) / (A * A + B * B);
return Q;
}
// 两直线夹角(弧度)
double angle_LL(Lline line1, Lline line2)
{
double A1, B1, C1;
format(line1, A1, B1, C1);
double A2, B2, C2;
format(line2, A2, B2, C2);
if (A1 * A2 + B1 * B2 == 0)
{
return PI / 2.0; // 垂直
}
else
{
double t = fabs((A1 * B2 - A2 * B1) / (A1 * A2 + B1 * B2));
return atan(t);
}
}
================================================
FILE: ACM 模板代码/f-MST/f-MST/main.cpp
================================================
//
// main.cpp
// f-MST
//
// Created by ZYJ on 16/7/17.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
using namespace std;
/*
* Minimal Steiner Tree
* G(V, E), A是V的一个子集, 求至少包含A中所有点的最小子树.
* 时间复杂度:O(N^3+N*2^A*(2^A+N))
* INIT: d[][]距离矩阵; id[]置为集合A中点的标号;
* CALL: steiner(int n, int a);
* 给4个点对(a1,b1)...(a4,b4),
* 求min(sigma(dist[ai][bi])),其中重复的路段只能算一次.
* 这题要找出一个steiner森林, 最后要对森林中树的个数进行枚举
*/
#define typec int // type of cost
const typec inf = 0x3f3f3f3f; // max of cost
const typec V = 10010;
const typec A = 10;
int vis[V], id[A]; // id[]: A中点的标号
typec d[V][V], dp[1 << A][V]; // dp[i][v]: 点v到点集i的最短距离
void steiner(int n, int a)
{
int i, j, k, mx, mk = 0, top = (1 << a);
for (k = 0; k < n; k++)
{
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
{
if (d[i][j] > d[i][k] + d[k][j])
{
d[i][j] = d[i][k] + d[k][j];
}
}
}
}
for (i = 0; i < a; i++)
{
// vertex: 0 ~ n-1
for (j = 0; j < n; j++)
{
dp[1 << i][j] = d[j][id[i]];
}
}
for (i = 1; i < top; i++)
{
if (0 == (i & (i - 1)))
{
continue;
}
memset(vis, 0, sizeof(vis));
for (k = 0; k < n; k++) // init
{
for (dp[i][k] = inf, j = 1; j < i; j++)
{
if ((i | j) == i && dp[i][k] > dp[j][k] + dp[i - j][k])
{
dp[i][k] = dp[j][k] + dp[i - j][k];
}
}
}
for (j = 0; mx = inf, j < n; j++)
{
// update
for (k = 0; k < n; k++)
{
if (dp[i][k] <= mx && 0 == vis[k])
{
mx = dp[i][mk = k];
}
}
for (k = 0, vis[mk] = 1; k < n; k++)
{
if (dp[i][mk] > dp[i][k] + d[k][mk])
{
dp[i][mk] = dp[i][k] + d[k][mk];
}
}
}
}
return ;
}
int main(int argc, const char * argv[])
{
int n, a = 8;
int b, z, i, j, k, x = 0, y;
// TODO: read data;
steiner(n, a);
// enum to find the result
for (i = 0, b = inf; z = 0, i < 256; b > z ? b = z : b, i++)
{
for (j = 0; y = 0, j < 4; z += !!y * dp[y][x], j++)
{
for (k = 0; k < 8; k += 2)
{
if ((i >> k & 3) == j)
{
y += 3 << k, x = id[k];
}
}
}
}
// TODO: cout << b << endl;
return 0;
}
================================================
FILE: ACM 模板代码/f-Manacher算法/f-Manacher算法/main.cpp
================================================
//
// main.cpp
// f-Manacher算法
//
// Created by ZYJ on 16/6/20.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
//Manacher最长回文子串
/*
* 求最长回文子串
*/
const int MAXN = 110010;
char A[MAXN * 2];
int B[MAXN * 2];
void Manacher(char s[], int len)
{
int l = 0;
A[l++] = '$'; //0下标存储为其他字符
A[l++] = '#';
for (int i = 0; i < len; i++)
{
A[l++] = s[i];
A[l++] = '#';
}
A[l] = 0; //空字符
int mx = 0;
int id = 0;
for (int i = 0; i < l; i++)
{
B[i] = mx > i ? std::min(B[2 * id - i], mx - i) : 1;
while (A[i + B[i]] == A[i - B[i]])
{
B[i]++;
}
if (i + B[i] > mx)
{
mx = i + B[i];
id = i;
}
}
return ;
}
/*
* abaaba
* i: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
* A: $ # a # b # a # a # b # a # '\0'
* B: 1 1 2 1 4 1 2 7 2 1 4 1 2 1 //以第i个为中心的回文半径（包括第i个）
*/
char s[MAXN];
int main(int argc, const char * argv[])
{
while (std::cin >> s)
{
int len = (int)strlen(s);
Manacher(s, len);
int ans = 0;
for (int i = 0; i < 2 * len + 2; i++) //两倍长度并且首位插有字符，所以i < 2 * len + 2
{
ans = std::max(ans, B[i] - 1);
}
std::cout << ans << std::endl;
}
return 0;
}
================================================
FILE: ACM 模板代码/f-Polya计数/f-Polya计数/main.cpp
================================================
//
// main.cpp
// f-Polya计数
//
// Created by ZYJ on 16/7/10.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
using namespace std;
/*
* c种颜色的珠子，组成长为s的项链，项链没有方向和起始位置
*/
int gcd(int a, int b)
{
return b ? gcd(b, a % b) : a;
}
int main(int argc, const char * argv[])
{
int c, s;
while (cin >> c >> s)
{
int k;
long long p[64];
p[0] = 1; // power of c
for (k = 0; k < s; k++)
{
p[k + 1] = p[k] * c;
}
// reflection part
long long count = s & 1 ? s * p[s / 2 + 1] : (s / 2) * (p[s / 2] + p[s / 2 + 1]);
// rotation part
for (k = 1 ; k <= s ; k++)
{
count += p[gcd(k, s)];
count /= 2 * s;
}
cout << count << '\n';
}
return 0;
}
================================================
FILE: ACM 模板代码/f-RMQ/f-RMQ/main.cpp
================================================
//
// main.cpp
// f-RMQ
//
// Created by ZYJ on 16/7/20.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
using namespace std;
// 一维
///*
// * 求最大值,数组下标从1开始。
// * 求最小值,或者最大最小值下标,或者数组从0开始对应修改即可。
// */
//const int MAXN = 50010;
//int dp[MAXN][20];
//int mm[MAXN];
//
//// 初始化RMQ,b数组下标从1开始,从0开始简单修改
//void initRMQ(int n, int b[])
//{
// mm[0] = -1;
// for (int i = 1; i <= n; i++)
// {
// mm[i] = ((i & (i - 1)) == 0) ? mm[i - 1] + 1 : mm[i - 1];
// dp[i][0] = b[i];
// }
// for (int j = 1; j <= mm[n]; j++)
// {
// for (int i = 1; i + (1 << j) - 1 <= n; i++)
// {
// dp[i][j] = max(dp[i][j - 1], dp[i + (1 << (j - 1))][j - 1]);
// }
// }
//}
//
//// 查询最大值
//int rmq(int x, int y)
//{
// int k = mm[y - x + 1];
// return max(dp[x][k], dp[y - (1 << k) + 1][k]);
//}
// 二维
/*
* 二维RMQ,预处理复杂度 n*m*log*(n)*log(m)
* 数组下标从1开始
*/
int val[310][310];
int dp[310][310][9][9]; // 最大值
int mm[310]; // 二进制位数减一,使用前初始化
void initRMQ(int n, int m)
{
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= m; j++)
{
dp[i][j][0][0] = val[i][j];
}
}
for (int ii = 0; ii <= mm[n]; ii++)
{
for (int jj = 0; jj <= mm[m]; jj++)
{
if (ii + jj)
{
for (int i = 1; i + (1 << ii) - 1 <= n; i++)
{
for(int j = 1; j + (1 << jj) - 1 <= m; j++)
{
if (ii)
{
dp[i][j][ii][jj] = max(dp[i][j][ii - 1][jj], dp[i + (1 << (ii - 1))][j][ii - 1][jj]);
}
else
{
dp[i][j][ii][jj] = max(dp[i][j][ii][jj - 1], dp[i][j + (1 << (jj - 1))][ii][jj - 1]);
}
}
}
}
}
}
}
// 查询矩形内的最大值(x1<=x2,y1<=y2)
int rmq(int x1, int y1, int x2, int y2)
{
int k1 = mm[x2 - x1 + 1];
int k2 = mm[y2 - y1 + 1];
x2 = x2 - (1 << k1) + 1;
y2 = y2 - (1 << k2) + 1;
return max(max(dp[x1][y1][k1][k2], dp[x1][y2][k1][k2]), max(dp[x2][y1][k1][k2], dp[x2][y2][k1][k2]));
}
int main()
{
// 在外面对mm数组进行初始化
mm[0] = -1;
for (int i = 1; i <= 305; i++)
{
mm[i] = ((i & (i - 1)) == 0) ? mm[i - 1] + 1 : mm[i - 1];
}
int n, m;
int Q;
int r1, c1, r2, c2;
while (scanf("%d%d", &n, &m) == 2)
{
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= m; j++)
{
scanf("%d", &val[i][j]);
}
}
initRMQ(n, m);
scanf("%d", &Q);
while(Q--)
{
scanf("%d%d%d%d", &r1, &c1, &r2, &c2);
if (r1 > r2)
{
swap(r1, r2);
}
if (c1 > c2)
{
swap(c1, c2);
}
int tmp = rmq(r1, c1, r2, c2);
printf("%d ", tmp);
if (tmp == val[r1][c1] || tmp == val[r1][c2] || tmp == val[r2][c1] || tmp == val[r2][c2])
{
printf("yes\n");
}
else
{
printf("no\n");
}
}
}
return 0;
}
================================================
FILE: ACM 模板代码/f-SPFA/f-SPFA/main.cpp
================================================
//
// main.cpp
// f-SPFA
//
// Created by ZYJ on 16/7/12.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
#include <queue>
using namespace std;
// SPFA(Shortest Path Faster Algorithm)
//const int INF = 0x3F3F3F3F;
//const int V = 30001;
//const int E = 150001;
//
//int pnt[E], cost[E], nxt[E];
//int e, head[V]; int dist[V]; bool vis[V];
//
//int relax(int u, int v, int c)
//{
// if (dist[v] > dist[u] + c)
// {
// dist[v] = dist[u] + c;
// return 1;
// }
// return 0;
//}
//
//inline void addedge(int u, int v, int c)
//{
// pnt[e] = v;
// cost[e] = c;
// nxt[e] = head[u];
// head[u] = e++;
//}
//
////此处用堆栈实现,有些时候比队列要快
//int SPFA(int src, int n)
//{
// int i;
// for (i = 1; i <= n; ++i)
// { // 顶点1...n
// vis[i] = 0;
// dist[i] = INF;
// }
// dist[src] = 0;
// int Q[E], top = 1;
// Q[0] = src;
// vis[src] = true;
// while(top)
// {
// int u, v;
// u = Q[--top];
// vis[u] = false;
// for(i = head[u]; i != -1; i = nxt[i])
// {
// v = pnt[i];
// if(1 == relax(u, v, cost[i]) && !vis[v])
// {
// Q[top++] = v;
// vis[v] = true;
// }
// }
// }
// return dist[n];
//}
//
//int main()
//{
// int n, m;
// while (scanf("%d%d", &n, &m) != EOF)
// {
// int i, a, b, c;
// e = 0;
// memset(head, -1, sizeof(head));
// for (i = 0; i < m; ++i)
// { // b-a <= c, 有向边(a, b):c ,边的方向!!!
// scanf("%d%d%d", &a, &b, &c);
// addedge(a, b, c);
// }
// printf("%d\n", SPFA(1, n));
// }
// return 0;
//}
/*
* Bellman-Ford算法的一种队列实现,减少了不必要的冗余计算。
* 它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径,可以处理负边。
* 原理:只有那些在前一遍松弛中改变了距离估计值的点,才可能引起他们的邻接点的距离估计值的改变。
* 判断负权回路:记录每个结点进队次数,超过|V|次表示有负权。
*/
#define swap(t, a, b) (t=a, a=b, b=t)
const int INF = 0x3F3F3F3F;
const int V = 1001;
const int E = 20001;
int pnt[E], cost[E], nxt[E];
int e, head[V], dist[V]; bool vis[V];
int cnt[V]; // 入队列次数
int relax(int u, int v, int c)
{
if (dist[v] > dist[u] + c)
{
dist[v] = dist[u] + c;
return 1;
}
return 0;
}
inline void addedge(int u, int v, int c)
{
pnt[e] = v;
cost[e] = c;
nxt[e] = head[u];
head[u] = e++;
}
// 此处用队列实现
int SPFA(int src, int n)
{
int i;
memset(cnt, 0, sizeof(cnt)); // 入队次数
memset(vis, false, sizeof(vis));
for (i = 1; i <= n; ++i)
{
dist[i] = INF;
}
dist[src] = 0;
queue<int> Q;
Q.push(src);
vis[src] = true;
++cnt[src];
while(!Q.empty())
{
int u, v;
u = Q.front();
Q.pop();
vis[u] = false;
for (i = head[u]; i != -1; i = nxt[i])
{
v = pnt[i];
if (1 == relax(u, v, cost[i]) && !vis[v])
{
Q.push(v);
vis[v] = true;
if ((++cnt[v]) > n )
{
return -1; // cnt[i]为入队列次数,用来判断是否存在负权回路
}
}
}
}
if (dist[n] == INF)
{
return -2; // src与n不可达,有些题目可省!!!
}
return dist[n]; // 返回src到n的最短距离,根据题意不同而改变
}
int main()
{
int n, ml, md;
while (scanf("%d%d%d", &n, &ml, &md) != EOF)
{
int i, a, b, c, t;
e = 0;
memset(head, -1, sizeof(head));
for (i = 0; i < ml; ++i) // 边方向!!!
{ // 大-小<=c,有向边(小, 大):c
scanf("%d%d%d", &a, &b, &c);
if (a > b)
{
swap(t, a, b);
}
addedge(a, b, c);
}
for (i = 0; i < md; ++i)
{ // 大-小>=c ==> 小-大<=-c,有向边(大, 小):-c
scanf("%d%d%d", &a, &b, &c);
if (a < b)
{
swap(t, a, b);
}
addedge(a, b, -c);
}
printf("%d\n", SPFA(1, n));
}
return 0;
}
================================================
FILE: ACM 模板代码/f-Sunday Algorithm/f-Sunday Algorithm/main.cpp
================================================
//
// main.cpp
// f-Sunday Algorithm
//
// Created by ZYJ on 16/7/12.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
using namespace std;
// BM算法改进的算法：Sunday Algorithm
/*
* BM算法优于KMP
* SUNDAY
算法描述:字符串查找算法中,最著名的两个是KMP算法(Knuth-Morris-Pratt)和BM算法(Boyer-Moore)。两个算法在最坏情 况下均具有线性的查找时间。但是在实用上,KMP算法并不比最简单的c库函数strstr()快多少,而BM算法则往往比KMP算法快上3-5倍。但是BM算法还不是最快的算法,这里介绍一种比BM算法更快一些的查找算法。例如我们要在"substring searching algorithm"查找"search",刚开始时,把子串与文本左边对齐:
substring searching algorithm search
* 结果在第二个字符处发现不匹配,于是要把子串往后移动。但是该移动多少呢? 这就是各种算法各显神通的地方了,最简单的做法是移动一个字符位置;KMP是利用已经匹配部分的信息来移动;BM算法是做反向比较,并根据已经匹配的部分来确定移动量。这里要介绍的方法是看紧跟在当前子串之后的那个字符(第一个字符串中的'i')。显然,不管移动多少,这个字符是肯定要参加下一步的比较的,也就是说,如果下一步匹配到了,这个字符必须在子串内。所以,可以移动子串,使子串中的最右边的这个字符与它对齐。现在子串'search'中并不存在'i',则说明可以直接跳过一大片,从'i'之后的那个字符开始作下一步的比较,如下:
substring searching algorithm search
* 比较的结果,第一个字符就不匹配,再看子串后面的那个字符,是'r',它在子串中出现在倒数第三位,于是把子串向后移动三位,使两个'r'对齐,如下:
substring searching algorithm search
* 这次匹配成功了!回顾整个过程,我们只移动了两次子串就找到了匹配位置, 是不是很神啊?!可以证明,用这个算法,每一步的移动量都比BM算法要大,所以肯定比BM算法更快。
*/
void SUNDAY(char *text, char *patt)
{
size_t temp[256];
size_t *shift = temp;
size_t i, patt_size = strlen(patt), text_size = strlen(text);
cout << "size : " << patt_size << endl;
for(i = 0; i < 256; i++)
{
*(shift+i) = patt_size + 1;
}
for(i = 0; i < patt_size; i++)
{
*(shift + (unsigned char)(*(patt+i))) = patt_size-i; // shift['s']=6步,shitf['e']=5以此类推
}
size_t limit = text_size - patt_size + 1;
for(i = 0; i < limit; i += shift[text[i + patt_size]])
{
if(text[i] == *patt)
{
char *match_text = text + i + 1;
size_t match_size = 1;
do // 输出所有匹配的位置
{
if(match_size == patt_size)
{
cout << "the NO. is " << i << endl;
}
}
while((*match_text++) == patt[match_size++]);
}
}
cout << endl;
}
int main(void)
{
char text[100] = "substring searching algorithm search";
char patt[10] = "search";
SUNDAY(text, patt);
return 0;
}
================================================
FILE: ACM 模板代码/f-Tarian强连通分量/f-Tarian强连通分量/main.cpp
================================================
//
// main.cpp
// f-Tarian强连通分量
//
// Created by ZYJ on 16/7/17.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
#include <vector>
using namespace std;
/*
* Tarjan 强连通分量
* INIT: vec[]为邻接表; stop, cnt, scnt置0; pre[]置-1;
* CALL: for(i=0;i<n;++i)if(-1==pre[i])tarjan(i,n);
*/
const int V = 10010;
vector<int> vec[V];
int id[V], pre[V], low[V], s[V], stop, cnt, scnt;
void tarjan(int v, int n) // vertex: 0 ~ n-1
{
int t, minc = low[v] = pre[v] = cnt++;
vector<int>::iterator pv;
s[stop++] = v;
for (pv = vec[v].begin(); pv != vec[v].end(); ++pv)
{
if (-1 == pre[*pv])
{
tarjan(*pv, n);
}
if (low[*pv] < minc)
{
minc = low[*pv];
}
}
if (minc < low[v])
{
low[v] = minc;
return ;
}
do
{
id[t = s[--stop]] = scnt;
low[t] = n;
}
while (t != v);
++scnt; // 强连通分量的个数
return ;
}
int main(int argc, const char * argv[])
{
// insert code here...
std::cout << "Hello, World!\n";
return 0;
}
================================================
FILE: ACM 模板代码/f-Treap/f-Treap/main.cpp
================================================
//
// main.cpp
// f-Treap
//
// Created by ZYJ on 16/7/21.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
long long gcd(long long a, long long b)
{
if (b == 0)
{
return a;
}
else
{
return gcd(b, a % b);
}
}
const int MAXN = 300010;
int num[MAXN], st[MAXN];
struct Treap
{
int tot1;
int s[MAXN], tot2; // 内存池和容量
int ch[MAXN][2];
int key[MAXN], size[MAXN];
int sum0[MAXN], sum1[MAXN];
int status[MAXN];
void Init()
{
tot1 = tot2 = 0;
size[0] = 0;
ch[0][0] = ch[0][1] = 0;
sum0[0] = sum1[0] = 0;
return ;
}
bool random(double p)
{
return (double)rand() / RAND_MAX < p;
}
int newnode(int val, int _status)
{
int r;
if (tot2)
{
r = s[tot2--];
}
else
{
r = ++tot1;
}
size[r] = 1;
key[r] = val;
status[r] = _status;
ch[r][0] = ch[r][1] = 0;
sum0[r] = sum1[r] = 0; // 需要push_up
return r;
}
void del(int r)
{
if (!r)
{
return ;
}
s[++tot2] = r;
del(ch[r][0]);
del(ch[r][1]);
return ;
}
void push_up(int r)
{
int lson = ch[r][0], rson = ch[r][1];
size[r] = size[lson] + size[rson] + 1;
sum0[r] = (int)gcd(sum0[lson], sum0[rson]);
sum1[r] = (int)gcd(sum1[lson], sum1[rson]);
if (status[r] == 0)
{
sum0[r] = (int)gcd(sum0[r], key[r]);
}
else
{
sum1[r] = (int)gcd(sum1[r],key[r]);
}
return ;
}
void merge(int &p, int x, int y)
{
if (!x || !y)
{
p = x | y;
}
else if (random((double)size[x] / (size[x] + size[y])))
{
merge(ch[x][1], ch[x][1], y);
push_up(p = x);
}
else
{
merge(ch[y][0], x, ch[y][0]);
push_up(p = y);
}
return ;
}
void split(int p, int &x, int &y, int k)
{
if (!k)
{
x = 0;
y = p;
return ;
}
if (size[ch[p][0]] >= k)
{
y = p;
split(ch[p][0], x, ch[y][0], k);
push_up(y);
}
else
{
x = p;
split(ch[p][1], ch[x][1], y, k - size[ch[p][0]] - 1);
push_up(x);
}
return ;
}
void build(int &p, int l, int r)
{
if (l > r)
{
return ;
}
int mid = (l + r) / 2;
p = newnode(num[mid], st[mid]);
build(ch[p][0], l, mid - 1);
build(ch[p][1], mid + 1, r);
push_up(p);
return ;
}
void debug(int root)
{
if (root == 0)
{
return ;
}
printf("%d 左儿子:%d 右儿子: %d size = %d key = %d\n", root, ch[root][0], ch[root][1], size[root], key[root]);
debug(ch[root][0]);
debug(ch[root][1]);
}
};
Treap T;
char op[10];
int main()
{
// freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
int n, q;
while (scanf("%d%d", &n, &q) == 2)
{
int root = 0;
T.Init();
for (int i = 1; i <= n; i++)
{
scanf("%d%d", &num[i], &st[i]);
}
T.build(root, 1, n);
while (q--)
{
scanf("%s", op);
if (op[0] == 'Q')
{
int l, r, s;
scanf("%d%d%d", &l, &r, &s);
int x, y, z;
T.split(root, x, z, r);
T.split(x, x, y, l - 1);
if (s == 0)
{
printf("%d\n", T.sum0[y] == 0 ? -1 : T.sum0[y]);
}
else
{
printf("%d\n", T.sum1[y] == 0 ? -1 : T.sum1[y]);
}
T.merge(x, x, y);
T.merge(root, x, z);
}
else if (op[0] == 'I')
{
int v, s, loc;
scanf("%d%d%d", &loc, &v, &s);
int x, y;
T.split(root, x, y, loc);
T.merge(x, x, T.newnode(v,s));
T.merge(root, x, y);
}
else if (op[0] == 'D')
{
int loc;
scanf("%d", &loc);
int x, y, z;
T.split(root, x, z, loc);
T.split(x, x, y, loc - 1);
T.del(y);
T.merge(root, x, z);
}
else if(op[0] == 'R')
{
int loc;
scanf("%d", &loc);
int x, y, z;
T.split(root, x, z, loc);
T.split(x, x, y, loc - 1);
T.status[y] = 1 - T.status[y];
T.push_up(y);
T.merge(x, x, y);
T.merge(root, x, z);
}
else
{
int loc, v;
scanf("%d%d", &loc, &v);
int x, y, z;
T.split(root, x, z, loc);
T.split(x, x, y, loc - 1);
T.key[y] = v;
T.push_up(y);
T.merge(x, x, y);
T.merge(root, x, z);
}
}
}
return 0;
}
================================================
FILE: ACM 模板代码/f-Trie树/f-Trie树/main.cpp
================================================
//
// main.cpp
// f-Trie树
//
// Created by ZYJ on 16/7/21.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
// k叉
///*
// * INIT: init();
// * 注: tree[i][tk]>0时表示单词存在, 当然也可赋予它更多含义;
// */
//const int tk = 26, tb = 'a'; // tk叉; 起始字母为tb;
//const int N = 1010; // N: 最大结点个数
//int top, tree[N][tk + 1];
//
//void init()
//{
// top = 1;
// memset(tree[0], 0, sizeof(tree[0]));
// return ;
//}
//
//int sear(char *s) // 失败返回0
//{
// for (int rt = 0; rt == tree[rt][*s - tb];)
// {
// if (*(++s) == 0)
// {
// return tree[rt][tk];
// }
// }
// return 0;
//}
//
//void insert(char *s, int rank = 1)
//{
// int rt, nxt;
// for (rt = 0; *s; rt = nxt, ++s)
// {
// nxt = tree[rt][*s - tb];
// if (0 == nxt)
// {
// tree[rt][*s - tb] = nxt = top;
// memset(tree[top], 0, sizeof(tree[top]));
// top++;
// }
// }
// tree[rt][tk] = rank; // 1表示存在0表示不存在,也可以赋予其其他含义
//}
//
//void delt(char *s) // 只做标记, 假定s一定存在
//{
// int rt = 0;
// for (; *s; ++s)
// {
// rt = tree[rt][*s - tb];
// }
// tree[rt][tk] = 0;
// return ;
//}
//
//int prefix(char *s) // 最长前缀
//{
// int rt = 0, lv;
// for (lv = 0; *s; ++s, ++lv)
// {
// rt = tree[rt][*s - tb];
// if (rt == 0)
// {
// break;
// }
// }
// return lv;
//}
// 左孩子右兄弟
/*
* 左孩子右兄弟
* INIT: init();
*/
const int N = 1010;
int top;
struct trie
{
char c;
int l, r, rk;
} tree[N];
void init()
{
top = 1;
memset(tree, 0, sizeof(tree[0]));
}
int sear(char *s) // 失败返回0
{
int rt;
for (rt = 0; *s; ++s)
{
for (rt = tree[rt].l; rt; rt = tree[rt].r)
{
if (tree[rt].c == *s)
{
break;
}
}
if (rt == 0)
{
return 0;
}
}
return tree[rt].rk;
}
void insert(char *s, int rk = 1) // rk: 权或者标记
{
int i, rt;
for (rt = 0; *s; ++s, rt = i)
{
for (i = tree[rt].l; i; i = tree[i].r)
{
if (tree[i].c == *s)
{
break;
}
}
if (i == 0)
{
tree[top].r = tree[rt].l;
tree[top].l = 0;
tree[top].c = *s;
tree[top].rk = 0;
tree[rt].l = top;
i = top++;
}
}
tree[rt].rk = rk;
return ;
}
void delt(char *s) // 假定s已经存在,只做标记
{
int rt;
for (rt = 0; *s; ++s)
{
for (rt = tree[rt].l; rt; rt = tree[rt].r)
{
if (tree[rt].c == *s)
{
break;
}
}
tree[rt].rk = 0;
}
return ;
}
int profix(char *s) // 最长前缀
{
int rt = 0, lv;
for (lv = 0; *s; ++s, ++lv)
{
for (rt = tree[rt].l; rt; rt = tree[rt].r)
{
if (tree[rt].c == *s)
{
break;
}
}
if (rt == 0)
{
break;
}
}
return lv;
}
================================================
FILE: ACM 模板代码/f-Ugly Numbers/f-Ugly Numbers/main.cpp
================================================
//
// main.cpp
// f-Ugly Numbers
//
// Created by ZYJ on 16/6/23.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
#include <queue>
/*
* Ugly Numbers
* Ugly numbers are numbers whose only prime factors are 2, 3 or 5.
* 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, ...
*/
typedef std::pair<unsigned long, int> node_type;
int main(int argc, const char * argv[])
{
unsigned long result[1502];
std::priority_queue<node_type, std::vector<node_type>, std::greater<node_type>> Q;
Q.push(std::make_pair(1, 2));
for (int i = 0; i < 1500; i++)
{
node_type node = Q.top();
Q.pop();
switch (node.second)
{
case 2:
Q.push(std::make_pair(node.first * 2, 2));
case 3:
Q.push(std::make_pair(node.first * 3, 3));
case 5:
Q.push(std::make_pair(node.first * 5, 5));
}
result[i] = node.first;
}
int n;
std::cin >> n;
while (n > 0)
{
std::cout << result[n - 1] << '\n';
std::cin >> n;
}
return 0;
}
================================================
FILE: ACM 模板代码/f-simpson积分/f-simpson积分/main.cpp
================================================
//
// main.cpp
// f-simpson积分
//
// Created by ZYJ on 16/7/10.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
#include <cmath>
using namespace std;
// 自适应simpson积分
const double eps = 1e-6; // 积分精度
// 被积函数
double F(double x)
{
double ans;
// 被积函数
// ...
// ans = x * exp(x); // 椭圆为例
return ans;
}
// 三点simpson法，这里要求F是一个全局函数
double simpson(double a, double b)
{
double c = a + (b - a) / 2;
return (F(a) + 4 * F(c) + F(b)) * (b - a) / 6;
}
// 自适应simpson公式（递归过程），已知整个区间[a, b]上的三点simpson指A
double asr(double a, double b, double eps, double A)
{
double c = a + (b - a) / 2;
double L = simpson(a, c), R = simpson(c, b);
if (fabs(L + R - A) <= 15 * eps)
{
return L + R + (L + R - A) / 15.0;
}
return asr(a, c, eps / 2, L) + asr(c, b, eps / 2, R);
}
// 自适应simpson公式（主过程）
double asr(double a, double b, double eps)
{
return asr(a, b, eps, simpson(a, b));
}
int main(int argc, const char * argv[])
{
// std::cout << asr(1, 2, eps) << '\n';
return 0;
}
================================================
FILE: ACM 模板代码/f-strstr函数/f-strstr函数/main.cpp
================================================
//
// main.cpp
// f-strstr函数
//
// Created by ZYJ on 16/6/22.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
//函数名：strstr
/*
* strstr函数
* 功能：在串中查找指定字符串的第一次出现
* 用法：char *strstr(char *strOne, char *strTwo);
* 据说strstr函数和KMP的算法效率差不多
*/
int main(int argc, const char * argv[])
{
char strOne[] = "Borland International";
char strTwo[] = "nation";
char *ptr;
ptr = strstr(strOne, strTwo);
std::cout << ptr << '\n';
return 0;
}
================================================
FILE: ACM 模板代码/f-一般图匹配带花树/f-一般图匹配带花树/main.cpp
================================================
//
// main.cpp
// f-一般图匹配带花树
//
// Created by ZYJ on 16/7/13.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
using namespace std;
const int maxn = 300;
int N;
bool G[maxn][maxn];
int match[maxn];
bool InQueue[maxn], InPath[maxn], InBlossom[maxn];
int head, tail;
int Queue[maxn];
int start, finish;
int NewBase;
int father[maxn], Base[maxn];
int Count;
void CreateGraph()
{
int u, v;
memset(G, 0, sizeof(G));
scanf("%d", &N);
while (scanf("%d%d",&u,&v) != EOF)
{
G[u][v] = G[v][u] = 1;
}
}
void Push(int u)
{
Queue[tail++] = u;
InQueue[u] = 1;
}
int Pop()
{
int res = Queue[head++];
return res;
}
int FindCommonAncestor (int u, int v)
{
memset(InPath, 0, sizeof(InPath));
while (true)
{
u = Base[u];
InPath[u] = 1;
if (u == start)
{
break;
}
u = father[match[u]];
}
while (true)
{
v = Base[v];
if (InPath[v])
{
break;
}
v = father[match[v]];
}
return v;
}
void ResetTrace(int u)
{
int v;
while (Base[u] != NewBase)
{
v = match[u];
InBlossom[Base[u]] = InBlossom[Base[v]] = 1;
u = father[v];
if (Base[u] != NewBase)
{
father[u] = v;
}
}
}
void BlossomContract(int u, int v)
{
NewBase = FindCommonAncestor(u, v);
memset(InBlossom, 0, sizeof(InBlossom));
ResetTrace(u);
ResetTrace(v);
if (Base[u] != NewBase)
{
father[u]=v;
}
if (Base[v] != NewBase)
{
father[v]=u;
}
for (int tu=1; tu <= N; tu++)
{
if (InBlossom[Base[tu]])
{
Base[tu] = NewBase;
if (!InQueue[tu])
{
Push(tu);
}
}
}
}
void FindAugmentingPath()
{
memset(InQueue, 0, sizeof(InQueue));
memset(father, 0, sizeof(father));
for (int i = 1; i <= N; i++)
{
Base[i] = i;
}
head = tail = 1;
Push(start);
finish = 0;
while (head < tail)
{
int u = Pop();
for (int v = 1; v <= N; v++)
{
if (G[u][v] && (Base[u] != Base[v]) && match[u] != v)
{
if ((v == start) || ((match[v] > 0) && father[match[v]] > 0))
{
BlossomContract(u, v);
}
else if (father[v] == 0)
{
father[v] = u;
if (match[v] > 0)
{
Push(match[v]);
}
else
{
finish = v;
return ;
}
}
}
}
}
}
void AugmentPath()
{
int u, v, w;
u = finish;
while (u > 0)
{
v = father[u];
w = match[v];
match[v] = u;
match[u] = v;
u = w;
}
}
void Edmonds()
{
memset(match, 0, sizeof(match));
for (int u = 1; u <= N; u++)
{
if (match[u] == 0)
{
start = u;
FindAugmentingPath();
if (finish > 0)
{
AugmentPath();
}
}
}
}
void PrintMatch()
{
Count = 0;
for (int u = 1; u <= N; u++)
{
if (match[u] > 0)
{
Count++;
}
}
printf("%d\n", Count);
for (int u = 1; u <= N; u++)
{
if (u < match[u])
{
printf("%d %d\n", u, match[u]);
}
}
}
int main()
{
CreateGraph();
Edmonds(); // 进行匹配
PrintMatch(); // 输出匹配
return 0;
}
================================================
FILE: ACM 模板代码/f-主席树/f-主席树/main.cpp
================================================
//
// main.cpp
// f-主席树
//
// Created by ZYJ on 16/7/21.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
#include <map>
using namespace std;
///*
// * 给出一个序列,查询区间内有多少个不相同的数
// */
//const int MAXN = 30010;
//const int M = MAXN * 100;
//int n, q, tot;
//int a[MAXN];
//int T[MAXN], lson[M], rson[M], c[M];
//
//int build(int l, int r)
//{
// int root = tot++;
// c[root] = 0;
// if (l != r)
// {
// int mid = (l + r) >> 1;
// lson[root] = build(l, mid);
// rson[root] = build(mid + 1, r);
// }
// return root;
//}
//
//int update(int root, int pos, int val)
//{
// int newroot = tot++, tmp = newroot;
// c[newroot] = c[root] + val;
// int l = 1, r = n;
// while (l < r)
// {
// int mid = (l + r) >> 1;
// if (pos <= mid)
// {
// lson[newroot] = tot++;
// rson[newroot] = rson[root];
// newroot = lson[newroot];
// root = lson[root];
// r = mid;
// }
// else
// {
// rson[newroot] = tot++;
// lson[newroot] = lson[root];
// newroot = rson[newroot];
// root = rson[root];
// l = mid + 1;
// }
// c[newroot] = c[root] + val;
// }
// return tmp;
//}
//
//int query(int root, int pos)
//{
// int ret = 0;
// int l = 1, r = n;
// while (pos < r)
// {
// int mid = (l + r) >> 1;
// if (pos <= mid)
// {
// r = mid;
// root = lson[root];
// }
// else
// {
// ret += c[lson[root]];
// root = rson[root];
// l = mid + 1;
// }
// }
// return ret + c[root];
//}
//
//int main()
//{
// // freopen("in.txt", "r", stdin);
// // freopen("out.txt", "w", stdout);
// while (scanf("%d", &n) == 1)
// {
// tot = 0;
// for (int i = 1; i <= n; i++)
// {
// scanf("%d", &a[i]);
// }
// T[n + 1] = build(1, n);
// map<int,int> mp;
// for (int i = n; i >= 1; i--)
// {
// if (mp.find(a[i]) == mp.end())
// {
// T[i] = update(T[i + 1], i, 1);
// }
// else
// {
// int tmp = update(T[i + 1], mp[a[i]], -1);
// T[i] = update(tmp, i, 1);
// }
// mp[a[i]] = i;
// }
// scanf("%d", &q);
// while (q--)
// {
// int l, r;
// scanf("%d%d", &l, &r);
// printf("%d\n", query(T[l], r));
// }
// }
// return 0;
//}
/*
* 静态区间第k大
*/
//const int MAXN = 100010;
//const int M = MAXN * 30;
//int n, q, m, tot;
//int a[MAXN], t[MAXN];
//int T[MAXN], lson[M], rson[M], c[M];
//
//void Init_hash()
//{
// for (int i = 1; i <= n; i++)
// {
// t[i] = a[i];
// }
// sort(t + 1, t + 1 + n);
// m = (int)(unique(t + 1, t + 1 + n) - t - 1);
//}
//
//int build(int l, int r)
//{
// int root = tot++; c[root] = 0;
// if (l != r)
// {
// int mid = (l + r) >> 1;
// lson[root] = build(l, mid);
// rson[root] = build(mid + 1, r);
// }
// return root;
//}
//
//int hash_(int x)
//{
// return (int)(lower_bound(t + 1, t + 1 + m, x) - t);
//}
//
//int update(int root, int pos, int val)
//{
// int newroot = tot++, tmp = newroot;
// c[newroot] = c[root] + val;
// int l = 1, r = m;
// while (l < r)
// {
// int mid = (l + r) >> 1;
// if (pos <= mid)
// {
// lson[newroot] = tot++;
// rson[newroot] = rson[root];
// newroot = lson[newroot];
// root = lson[root];
// r = mid;
// }
// else
// {
// rson[newroot] = tot++;
// lson[newroot] = lson[root];
// newroot = rson[newroot];
// root = rson[root];
// l = mid + 1;
// }
// c[newroot] = c[root] + val;
// }
// return tmp;
//}
//
//int query(int left_root, int right_root, int k)
//{
// int l = 1, r = m;
// while ( l < r)
// {
// int mid = (l + r) >> 1;
// if (c[lson[left_root]] - c[lson[right_root]] >= k )
// {
// r = mid;
// left_root = lson[left_root];
// right_root = lson[right_root];
// }
// else
// {
// l = mid + 1;
// k -= c[lson[left_root]] - c[lson[right_root]];
// left_root = rson[left_root];
// right_root = rson[right_root];
// }
// }
// return l;
//}
//
//int main()
//{
// // freopen("in.txt","r",stdin);
// // freopen("out.txt","w",stdout);
// while (scanf("%d%d", &n, &q) == 2)
// {
// tot = 0;
// for (int i = 1; i <= n; i++)
// {
// scanf("%d", &a[i]);
// }
// Init_hash();
// T[n + 1] = build(1, m);
// for (int i = n; i; i--)
// {
// int pos = hash_(a[i]);
// T[i] = update(T[i + 1], pos, 1);
// }
// while (q--)
// {
// int l, r, k;
// scanf("%d%d%d", &l, &r, &k);
// printf("%d\n", t[query(T[l], T[r + 1], k)]);
// }
// }
// return 0;
//}
// 树上路径点权第k大
/*
* LCA + 主席树
*/
// 主席树部分
//const int MAXN = 200010;
//const int M = MAXN * 40;
//int n, q, m, TOT;
//int a[MAXN], t[MAXN];
//int T[MAXN], lson[M], rson[M], c[M];
//void Init_hash()
//{
// for (int i = 1; i <= n; i++)
// {
// t[i] = a[i];
// }
// sort(t + 1, t + 1 + n);
// m = (int)(unique(t + 1, t + n + 1) - t - 1);
// return ;
//}
//
//int build(int l, int r)
//{
// int root = TOT++;
// c[root] = 0;
// if (l != r)
// {
// int mid = (l + r) >> 1;
// lson[root] = build(l, mid);
// rson[root] = build(mid + 1, r);
// }
// return root;
//}
//
//int hash_(int x)
//{
// return (int)(lower_bound(t + 1, t + 1 + m, x) - t);
//}
//
//int update(int root, int pos, int val)
//{
// int newroot = TOT++, tmp = newroot;
// c[newroot] = c[root] + val;
// int l = 1, r = m;
// while (l < r)
// {
// int mid = (l + r) >> 1;
// if (pos <= mid)
// {
// lson[newroot] = TOT++;
// rson[newroot] = rson[root];
// newroot = lson[newroot];
// root = lson[root];
// r = mid;
// }
// else
// {
// rson[newroot] = TOT++;
// lson[newroot] = lson[root];
// newroot = rson[newroot];
// root = rson[root];
// l = mid + 1;
// }
// c[newroot] = c[root] + val;
// }
// return tmp;
//}
//
//int query(int left_root, int right_root, int LCA, int k)
//{
// int lca_root = T[LCA];
// int pos = hash_(a[LCA]);
// int l = 1, r = m;
// while (l < r)
// {
// int mid = (l + r) >> 1;
// int tmp = c[lson[left_root]] + c[lson[right_root]] - 2 * c[lson[lca_root]] + (pos >= l && pos <= mid);
// if (tmp >= k)
// {
// left_root = lson[left_root];
// right_root = lson[right_root];
// lca_root = lson[lca_root];
// r = mid;
// }
// else
// {
// k -= tmp;
// left_root = rson[left_root];
// right_root = rson[right_root];
// lca_root = rson[lca_root];
// l = mid + 1;
// }
// }
// return l;
//}
//
//// LCA部分
//int rmq[2 * MAXN]; // rmq数组,就是欧拉序列对应的深度序列
//
//struct ST
//{
// int mm[2 * MAXN];
// int dp[2 * MAXN][20]; // 最小值对应的下标
// void init(int n)
// {
// mm[0] = -1;
// for (int i = 1; i <= n; i++)
// {
// mm[i] = ((i & (i - 1)) == 0) ? mm[i - 1] + 1 : mm[i - 1];
// dp[i][0] = i;
// }
// for (int j = 1; j <= mm[n]; j++)
// {
// for (int i = 1; i + (1 << j) - 1 <= n; i++)
// {
// dp[i][j] = rmq[dp[i][j - 1]] < rmq[dp[i + (1 << (j - 1))][j - 1]] ? dp[i][j - 1] : dp[i + (1 << (j - 1))][j - 1];
// }
// }
// return ;
// }
// int query(int a, int b) // 查询[a,b]之间最小值的下标
// {
// if (a > b)
// {
// swap(a, b);
// }
// int k = mm[b - a + 1];
// return rmq[dp[a][k]] <= rmq[dp[b - (1 << k) + 1][k]] ? dp[a][k] : dp[b - (1 << k) + 1][k];
// }
//};
//
//// 边的结构体定义
//struct Edge
//{
// int to, next;
//};
//
//Edge edge[MAXN * 2];
//int tot, head[MAXN];
//int F[MAXN * 2]; // 欧拉序列,就是dfs遍历的顺序,长度为2*n-1,下标从1开始
//int P[MAXN]; // P[i]表示点i在F中第一次出现的位置
//int cnt;
//ST st;
//
//void init()
//{
// tot = 0;
// memset(head, -1, sizeof(head));
// return ;
//}
//
//void addedge(int u, int v) // 加边,无向边需要加两次
//{
// edge[tot].to = v;
// edge[tot].next = head[u];
// head[u] = tot++;
// return ;
//}
//
//void dfs(int u, int pre, int dep)
//{
// F[++cnt] = u;
// rmq[cnt] = dep;
// P[u] = cnt;
// for (int i = head[u]; i != -1; i = edge[i].next)
// {
// int v = edge[i].to;
// if (v == pre)
// {
// continue;
// }
// dfs(v, u, dep + 1);
// F[++cnt] = u;
// rmq[cnt] = dep;
// }
// return ;
//}
//
//void LCA_init(int root, int node_num) // 查询LCA前的初始化
//{
// cnt = 0;
// dfs(root, root, 0);
// st.init(2 * node_num - 1);
// return ;
//}
//
//int query_lca(int u, int v) // 查询u,v的lca编号
//{
// return F[st.query(P[u], P[v])];
//}
//
//void dfs_build(int u, int pre)
//{
// int pos = hash_(a[u]);
// T[u] = update(T[pre], pos, 1);
// for (int i = head[u]; i != -1; i = edge[i].next)
// {
// int v = edge[i].to;
// if (v == pre)
// {
// continue;
// }
// dfs_build(v, u);
// }
// return ;
//}
//
//
//int main()
//{
// // freopen("in.txt", "r", stdin);
// // freopen("out.txt", "w", stdout);
// while (scanf("%d%d", &n, &q) == 2)
// {
// for (int i = 1; i <= n; i++)
// {
// scanf("%d", &a[i]);
// }
// Init_hash();
// init();
// TOT = 0;
// int u, v;
// for (int i = 1; i < n; i++)
// {
// scanf("%d%d", &u, &v);
// addedge(u, v);
// addedge(v, u);
// }
// LCA_init(1, n);
// T[n + 1] = build(1, m);
// dfs_build(1, n + 1);
// int k;
// while (q--)
// {
// scanf("%d%d%d", &u, &v, &k);
// printf("%d\n", t[query(T[u], T[v], query_lca(u, v), k)]);
// }
// }
// return 0;
//}
// 动态区间第k大
/*
* 树状数组套主席树
*/
const int MAXN = 60010;
const int M = 2500010;
int n, q, m, tot;
int a[MAXN], t[MAXN];
int T[MAXN], lson[M], rson[M],c[M];
int S[MAXN];
struct Query
{
int kind;
int l, r, k;
} query[10010];
void Init_hash(int k)
{
sort(t, t + k);
m = (int)(unique(t, t + k) - t);
return ;
}
int hash_(int x)
{
return (int)(lower_bound(t, t + m, x) - t);
}
int build(int l, int r)
{
int root = tot++;
c[root] = 0;
if (l != r)
{
int mid = (l + r) / 2;
lson[root] = build(l, mid);
rson[root] = build(mid + 1, r);
}
return root;
}
int Insert(int root, int pos, int val)
{
int newroot = tot++, tmp = newroot;
int l = 0, r = m - 1;
c[newroot] = c[root] + val;
while (l < r)
{
int mid = (l + r) >> 1;
if (pos <= mid)
{
lson[newroot] = tot++;
rson[newroot] = rson[root];
newroot = lson[newroot];
root = lson[root];
r = mid;
}
else
{
rson[newroot] = tot++;
lson[newroot] = lson[root];
newroot = rson[newroot];
root = rson[root];
l = mid + 1;
}
c[newroot] = c[root] + val;
}
return tmp;
}
int lowbit(int x)
{
return x & (-x);
}
int use[MAXN];
void add(int x, int pos, int val)
{
while (x <= n)
{
S[x] = Insert(S[x], pos, val);
x += lowbit(x);
}
return ;
}
int sum(int x)
{
int ret = 0;
while (x > 0)
{
ret += c[lson[use[x]]];
x -= lowbit(x);
}
return ret;
}
int Query(int left, int right, int k)
{
int left_root = T[left - 1];
int right_root = T[right];
int l = 0, r = m - 1;
for (int i = left - 1; i; i -= lowbit(i))
{
use[i] = S[i];
}
for (int i = right; i; i -= lowbit(i))
{
use[i] = S[i];
}
while (l < r)
{
int mid = (l + r) / 2;
int tmp = sum(right) - sum(left - 1) + c[lson[right_root]] - c[lson[left_root]];
if (tmp >= k)
{
r = mid;
for (int i = left - 1; i; i -= lowbit(i))
{
use[i] = lson[use[i]];
}
for (int i = right; i; i -= lowbit(i))
{
use[i] = lson[use[i]];
}
left_root = lson[left_root];
right_root = lson[right_root];
}
else
{
l = mid + 1;
k -= tmp;
for (int i = left - 1; i; i -= lowbit(i))
{
use[i] = rson[use[i]];
}
for (int i = right; i; i -= lowbit(i))
{
use[i] = rson[use[i]];
}
left_root = rson[left_root];
right_root = rson[right_root];
}
}
return l;
}
void Modify(int x, int p, int d)
{
while (x <= n)
{
S[x] = Insert(S[x], p, d);
x += lowbit(x);
}
return ;
}
int main()
{
// freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
int Tcase;
scanf("%d", &Tcase);
while (Tcase--)
{
scanf("%d%d", &n, &q);
tot = 0;
m = 0;
for (int i = 1; i <= n; i++)
{
scanf("%d", &a[i]);
t[m++] = a[i];
}
char op[10];
for (int i = 0; i < q; i++)
{
scanf("%s", op);
if (op[0] == 'Q')
{
query[i].kind = 0;
scanf("%d%d%d", &query[i].l, &query[i].r, &query[i].k);
}
else
{
query[i].kind = 1;
scanf("%d%d", &query[i].l, &query[i].r);
t[m++] = query[i].r;
}
}
Init_hash(m);
T[0] = build(0, m - 1);
for (int i = 1; i <= n; i++)
{
T[i] = Insert(T[i - 1], hash_(a[i]), 1);
}
for (int i = 1; i <= n; i++)
{
S[i] = T[0];
}
for (int i = 0; i < q; i++)
{
if (query[i].kind == 0)
{
printf("%d\n", t[Query(query[i].l, query[i].r, query[i].k)]);
}
else
{
Modify(query[i].l, hash_(a[query[i].l]), -1);
Modify(query[i].l, hash_(query[i].r), 1);
a[query[i].l] = query[i].r;
}
}
}
return 0;
}
================================================
FILE: ACM 模板代码/f-二分图匹配/f-二分图匹配/main.cpp
================================================
//
// main.cpp
// f-二分图匹配
//
// Created by ZYJ on 16/7/18.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
// // 匈牙利算法
// 邻接矩阵+DFS
///*
// * 初始化:g[][]两边顶点的划分情况
// * 建立g[i][j]表示i->j的有向边就可以了,是左边向右边的匹配
// * g没有边相连则初始化为0
// * uN是匹配左边的顶点数,vN是匹配右边的顶点数
// * 调用:res=hungary();输出最大匹配数
// * 优点:适用于稠密图,DFS找增广路,实现简洁易于理解
// * 时间复杂度:O(VE)
// */
////顶点编号从0开始的
//const int MAXN = 510;
//int uN, vN; // u,v的数目,使用前面必须赋值
//int g[MAXN][MAXN]; // 邻接矩阵
//int linker[MAXN];
//bool used[MAXN];
//bool dfs(int u)
//{
// for (int v = 0; v < vN; v++)
// {
// if (g[u][v] && !used[v])
// {
// used[v] = true;
// if (linker[v] == -1 || dfs(linker[v]))
// {
// linker[v] = u;
// return true;
// }
// }
// }
// return false;
//}
//
//int hungary()
//{
// int res = 0;
// memset(linker,-1,sizeof(linker));
// for (int u = 0; u < uN; u++)
// {
// memset(used, false, sizeof(used));
// if (dfs(u))
// {
// res++;
// }
// }
// return res;
//}
// 邻接表+DFS
/*
* 使用前用init()进行初始化,给uN赋值
* 加边使用函数addedge(u,v)
*/
//const int MAXN = 5010; // 点数的最大值
//const int MAXM = 50010; // 边数的最大值
//
//struct Edge
//{
// int to, next;
//} edge[MAXM];
//
//int head[MAXN], tot;
//
//void init()
//{
// tot = 0;
// memset(head, -1, sizeof(head));
// return ;
//}
//
//void addedge(int u, int v)
//{
// edge[tot].to = v;
// edge[tot].next = head[u];
// head[u] = tot++;
// return ;
//}
//
//int linker[MAXN];
//bool used[MAXN];
//int uN;
//
//bool dfs(int u)
//{
// for (int i = head[u]; i != -1; i = edge[i].next)
// {
// int v = edge[i].to;
// if (!used[v])
// {
// used[v] = true;
// if (linker[v] == -1 || dfs(linker[v]))
// {
// linker[v] = u;
// return true;
// }
// }
// }
// return false;
//}
//
//int hungary()
//{
// int res = 0;
// memset(linker, -1, sizeof(linker));
// for (int u = 0; u < uN; u++) // 点的编号0~uN-1
// {
// memset(used, false, sizeof(used));
// if (dfs(u))
// {
// res++;
// }
// }
// return res;
//}
// 邻接矩阵+BFS
///*
// * INIT: g[][]邻接矩阵;
// * CALL: res = MaxMatch();Nx, Ny初始化!!!
// * 优点:适用于稀疏二分图,边较少,增广路较短。
// * 匈牙利算法的理论复杂度是O(VE)
// */
//const int MAXN = 1000;
//int g[MAXN][MAXN], Mx[MAXN], My[MAXN], Nx, Ny;
//int chk[MAXN], Q[MAXN], prev[MAXN];
//
//int MaxMatch()
//{
// int res = 0;
// int qs, qe;
// memset(Mx, -1, sizeof(Mx));
// memset(My, -1, sizeof(My));
// memset(chk, -1, sizeof(chk));
// for (int i = 0; i < Nx; i++)
// {
// if (Mx[i] == -1)
// {
// qs = qe = 0;
// Q[qe++] = i;
// prev[i] = -1;
// bool flag = 0;
// while (qs < qe && !flag)
// {
// int u = Q[qs];
// for (int v = 0; v < Ny && !flag; v++)
// {
// if (g[u][v] && chk[v] != i)
// {
// chk[v] = i; Q[qe++] = My[v];
// if (My[v] >= 0)
// {
// prev[My[v]] = u;
// }
// else
// {
// flag = 1;
// int d = u, e = v;
// while (d != -1)
// {
// int t = Mx[d];
// Mx[d] = e;
// My[e] = d;
// d = prev[d];
// e = t;
// }
// }
// }
// }
// qs++;
// }
// if (Mx[i] != -1)
// {
// res++;
// }
// }
// }
// return res;
//}
// // Kuhn Munkras算法
/*
* 邻接距阵形式,复杂度O(m*m*n) 返回最佳匹配值,传入二分图大小m,n
* 邻接距阵mat,表示权,match1,match2返回一个最佳匹配,未匹配顶点
* match值为-1,一定注意m<=n,否则循环无法终止,最小权匹配可将权值
* 取相反数
* 初始化:for (i = 0; i < MAXN; ++i)
* for (j = 0; j < MAXN ; ++j)
* mat[i][j] = -inf;
* 对于存在的边:mat[i][j] = val ; // 注意,不能有负值
*/
//#define MAXN 310
//#define inf 1000000000
//#define _clr(x) memset(x, -1, sizeof(int) * MAXN)
//
//int kuhn_munkras(int m, int n, int mat[][MAXN], int *match_1, int *match_2)
//{
// int s[MAXN], t[MAXN], l_1[MAXN], l_2[MAXN];
// int p, q, ret = 0;
// int i, j, k;
// for (i = 0; i < m; i++)
// {
// for (l_1[i] = -inf, j = 0; j < n; j++)
// {
// l_1[i] = mat[i][j] > l_1[i] ? mat[i][j] : l_1[i];
// }
// if (l_1[i] == -inf)
// {
// return -1; // 无结果
// }
// }
// for (i = 0; i < n; l_2[i++] = 0);
// for (_clr(match_1), _clr(match_2), i = 0; i < m; i++)
// {
// for (_clr(t), s[p = q = 0] = i; p <= q && match_1[i] < 0; p++)
// {
// for (k = s[p], j = 0; j < n && match_1[i] < 0; p++)
// {
// if (l_1[k] + l_2[j] == mat[k][j] && t[j] < 0)
// {
// s[++q] = match_2[j], t[j] = k;
// if (s[q] < 0)
// {
// for (p = j; p >= 0; j = p)
// {
// match_2[j] = k = t[j];
// p = match_1[k];
// match_1[k] = j;
// }
// }
// }
// }
// }
// if (match_1[i] < 0)
// {
// for (i--, p = inf, k = 0; k <= q; k++)
// {
// for (j = 0; j < n; j++)
// {
// if (t[j] < 0 && l_1[s[k]] + l_2[j] - mat[s[k]][j] < p)
// {
// p = l_1[s[k]] + l_2[j] - mat[s[k]][j];
// }
// }
// }
// for (j = 0; j < n; l_2[j] += t[j] < 0 ? 0 : p, j++);
// for (k = 0; k <= q; l_1[s[k++]] -= p);
// }
// }
// for (i = 0; i < m; i++)
// { // if处理无匹配的情况!!
// if (match_1[i] < 0) // ???
// {
// return -1;
// }
// if (mat[i][match_1[i]] <= -inf) // ???
// {
// return -1;
// }
// ret += mat[i][match_1[i]];
// }
// return ret;
//}
//
//int main(int argc, const char * argv[])
//{
//
// std::cout << "Hello, World!\n";
// return 0;
//}
// // Hopcroft-Carp 算法
// 邻接表+DFS
/*
* 复杂度O(sqrt(n)*E)
* 邻接表存图,vector实现
* vector先初始化,然后假如边
* uN为左端的顶点数,使用前赋值(点编号0开始)
*/
//const int MAXN = 3000;
//const int INF = 0x3f3f3f3f;
//vector<int>G[MAXN];
//int uN;
//int Mx[MAXN], My[MAXN];
//int dx[MAXN], dy[MAXN];
//int dis;
//bool used[MAXN];
//
//bool SearchP()
//{
// queue<int>Q;
// dis = INF;
// memset(dx, -1, sizeof(dx));
// memset(dy, -1, sizeof(dy));
// for (int i = 0 ; i < uN; i++)
// {
// if(Mx[i] == -1)
// {
// Q.push(i);
// dx[i] = 0;
// }
// }
// while (!Q.empty())
// {
// int u = Q.front();
// Q.pop();
// if (dx[u] > dis)
// {
// break;
// }
// int sz = (int)G[u].size();
// for (int i = 0; i < sz; i++)
// {
// int v = G[u][i];
// if (dy[v] == -1)
// {
// dy[v] = dx[u] + 1;
// if (My[v] == -1)
// {
// dis = dy[v];
// }
// else
// {
// dx[My[v]] = dy[v] + 1;
// Q.push(My[v]);
// }
// }
// }
// }
// return dis != INF;
//}
//
//bool DFS(int u)
//{
// int sz = (int)G[u].size();
// for (int i = 0; i < sz; i++)
// {
// int v = G[u][i];
// if (!used[v] && dy[v] == dx[u] + 1)
// {
// used[v] = true;
// if (My[v] != -1 && dy[v] == dis)
// {
// continue;
// }
// if (My[v] == -1 || DFS(My[v]))
// {
// My[v] = u;
// Mx[u] = v;
// return true;
// }
// }
// }
// return false;
//}
//
//int MaxMatch()
//{
// int res = 0;
// memset(Mx, -1, sizeof(Mx));
// memset(My, -1, sizeof(My));
// while (SearchP())
// {
// memset(used, false, sizeof(used));
// for (int i = 0; i < uN; i++)
// {
// if(Mx[i] == -1 && DFS(i))
// {
// res++;
// }
// }
// }
// return res;
//}
// 邻接矩阵+DFS
/*
* INIT: g[][]邻接矩阵；
* CALL: res = MaxMatch(); Nx, Ny要初始化！！！
* 时间复杂度: O(V^0.5 * E)
*/
const int MAXN = 3001;
const int INF = 1 << 28;
int g[MAXN][MAXN], Mx[MAXN], My[MAXN], Nx, Ny;
int dx[MAXN], dy[MAXN], dis;
bool vst[MAXN];
bool searchP()
{
queue<int> Q;
dis = INF;
memset(dx, -1, sizeof(dx));
memset(dy, -1, sizeof(dy));
for (int i = 0; i < Nx; i++)
{
if (Mx[i] == -1)
{
Q.push(i); dx[i] = 0;
}
}
while (!Q.empty())
{
int u = Q.front();
Q.pop();
if (dx[u] > dis)
{
break;
}
for (int v = 0; v < Ny; v++)
{
if (g[u][v] && dy[v] == -1)
{
dy[v] = dx[u]+1;
if (My[v] == -1)
{
dis = dy[v];
}
else
{
dx[My[v]] = dy[v] + 1;
Q.push(My[v]);
}
}
}
}
return dis != INF;
}
bool DFS(int u)
{
for (int v = 0; v < Ny; v++)
{
if (!vst[v] && g[u][v] && dy[v] == dx[u] + 1)
{
vst[v] = 1;
if (My[v] != -1 && dy[v] == dis)
{
continue;
}
if (My[v] == -1 || DFS(My[v]))
{
My[v] = u; Mx[u] = v;
return 1;
}
}
}
return 0;
}
int MaxMatch()
{
int res = 0;
memset(Mx, -1, sizeof(Mx));
memset(My, -1, sizeof(My));
while (searchP())
{
memset(vst, 0, sizeof(vst));
for (int i = 0; i < Nx; i++)
{
if (Mx[i] == -1 && DFS(i))
{
res++;
}
}
}
return res;
}
================================================
FILE: ACM 模板代码/f-二分图多重匹配/f-二分图多重匹配/main.cpp
================================================
//
// main.cpp
// f-二分图多重匹配
//
// Created by ZYJ on 16/7/18.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
const int MAXN = 1010;
const int MAXM = 510;
int uN, vN;
int g[MAXN][MAXM];
int linker[MAXM][MAXN];
bool used[MAXM];
int num[MAXM]; // 右边最大的匹配数
bool dfs(int u)
{
for (int v = 0; v < vN; v++)
{
if (g[u][v] && !used[v])
{
used[v] = true;
if (linker[v][0] < num[v])
{
linker[v][++linker[v][0]] = u;
return true;
}
for (int i = 1; i <= num[0]; i++)
{
if (dfs(linker[v][i]))
{
linker[v][i] = u;
return true;
}
}
}
}
return false;
}
int hungary()
{
int res = 0;
for (int i = 0; i < vN; i++)
{
linker[i][0] = 0;
}
for (int u = 0; u < uN; u++)
{
memset(used, false, sizeof(used));
if (dfs(u))
{
res++;
}
}
return res;
}
int main(int argc, const char * argv[])
{
std::cout << "Hello, World!\n";
return 0;
}
================================================
FILE: ACM 模板代码/f-二分查找/f-二分查找/main.cpp
================================================
//
// main.cpp
// f-二分查找
//
// Created by ZYJ on 16/7/22.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
// 查找v
/*
* 在[l, h)范围内查找值v,返回下标
* 假设a数组已经按从小到大排序
* 失败返回-1
*/
//int bs(int a[], int l, int h, int v)
//{
// int m;
// while (l < h)
// {
// m = (l + h) >> 1;
// if (a[m] == v)
// {
// return m;
// }
// if (a[m] < v)
// {
// l = m + 1;
// }
// else
// {
// h = m;
// }
// }
// return -1;
//}
// 查找大于等于v的第一个值
/*
* 传入参数必须l <= h
* 假设a数组已经按从小到大排序
* 返回值l总是合理的
*/
int bs(int a[], int l, int h, int v)
{
int m;
while (l < h)
{
m = (l + h) >> 1;
if (a[m] < v)
{
l = m + 1;
}
else
{
h = m;
}
}
return l;
}
================================================
FILE: ACM 模板代码/f-二叉排序树/f-二叉排序树/main.cpp
================================================
//
// main.cpp
// f-二叉排序树
//
// Created by ZYJ on 16/7/27.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
typedef bool Status;
// 二叉树的二叉链表结点结构定义
typedef struct BiTNode
{
int data;
struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;
// 递归查找二叉排序树T中是否存在Key
// 指针f指向T的双亲，其初始值调用值为NULL
// 若查找成功，则指针p指向该数据元素结点，并返回TRUE
// 否则指针p指向查找路径上访问的最后一个结点，并返回FALSE
Status SearchBST(BiTree T, int Key, BiTree f, BiTree *p)
{
if (!T) // 查找不成功
{
*p = f;
return false;
}
else if (Key == T->data)
{
*p = T;
return true;
}
else if (Key < T->data)
{
return SearchBST(T->lchild, Key, T, p);
}
else
{
return SearchBST(T->rchild, Key, T, p);
}
}
// 当二叉排序树T中不存在关键字等于Key的数据元素时，
// 插入Key并返回TRUE，否则返回FALSE
Status InserBST(BiTree *T, int Key)
{
BiTree p, s;
if (!SearchBST(*T, Key, NULL, &p))
{
s = (BiTree)malloc(sizeof(BiTNode));
s->data = Key;
s->lchild = s->rchild = NULL;
if (!p)
{
*T = s; // 插入s为新的根结点
}
else if (Key < p->data)
{
p->lchild = s; // 插入s为左孩子
}
else
{
p->rchild = s; // 插入s为右孩子
}
return true;
}
else
{
return false; // 树中已有关键字相同的结点，不再插入
}
}
// 删除操作
Status Delete(BiTree *p)
{
BiTree q, s;
if ((*p)->rchild == NULL) // 右子树为空 || 叶子结点
{
q = *p;
(*p) = (*p)->lchild;
free(q);
}
else if ((*p)->lchild == NULL) // 左子树为空
{
q = *p;
(*p) = (*p)->rchild;
free(q);
}
else // p直接前驱（左子树的最右后代）
{
q = *p;
s = (*p)->lchild;
while (s->rchild)
{
q = s;
s = s->rchild;
}
(*p)->data = s->data; // 直接进行数据的替换
if (q != *p)
{
q->rchild = s->lchild;
}
else
{
q->lchild = s->lchild;
}
free(s);
}
return true;
}
// 当二叉排序树T中存在关键字Key的数据元素时，
// 删除Key并返回TRUE，否则返回FALSE
Status DeleteBST(BiTree *T, int Key)
{
if (!*T)
{
return false;
}
else
{
if (Key == (*T)->data)
{
return Delete(T);
}
else if (Key < (*T)->data)
{
return DeleteBST(&(*T)->lchild, Key);
}
else
{
return DeleteBST(&(*T)->rchild, Key);
}
}
}
int main(int argc, const char * argv[]) {
// insert code here...
std::cout << "Hello, World!\n";
return 0;
}
================================================
FILE: ACM 模板代码/f-二叉查找树/f-二叉查找树/main.cpp
================================================
//
// main.cpp
// f-二叉查找树
//
// Created by ZYJ on 16/6/22.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
template<typename T> //树结点结构
class BSTNode
{
public:
T _key; //结点值
BSTNode *_lchild;
BSTNode *_rchild;
BSTNode *_parent;
//构造函数
BSTNode(T key , BSTNode *lchild, BSTNode *rchild, BSTNode *parent) :
_key(key), _lchild(lchild), _rchild(rchild), _parent(parent) {};
};
template<typename T>
class BSTree
{
private:
BSTNode<T>* _Root; //根结点
public:
BSTree() : _Root(NULL) {};
~BSTree() {};
void insert (T key); //二叉树的插入
BSTNode<T>* search(T key); //二叉树的查找
void preOrder(); //先序输出
void inOrder(); //中序输出
void postOrder(); //后序输出
BSTNode<T>* minimumNode(); //查找最小的节点
BSTNode<T>* maximumNode (); //查找最大的节点
T minimumKey(); //查找最小的键值
T maximumKey(); //查找最小的键值
void print(); //打印二叉树
void remove(T key);
BSTNode<T>* predecessor(BSTNode<T>* x); //查找某个结点的前驱
BSTNode<T>* sucessor(BSTNode<T>* x); //查找某个结点的后继
void destory ();
//内部使用函数，供外部接口调用
private:
void insert(BSTNode<T>* &tree, BSTNode<T>* z);
BSTNode<T>* search(BSTNode<T>* &tree, T key) const;
void preOrder(BSTNode<T>*& tree) const;
void inOrder(BSTNode<T>*& tree) const;
void postOrder(BSTNode<T>*& tree) const;
BSTNode<T>* minimumNode(BSTNode<T>*& tree);
BSTNode<T>* maximumNode (BSTNode<T>*& tree);
void print(BSTNode<T>*& tree);
BSTNode<T>* remove(BSTNode<T>*& tree, BSTNode<T>* z);
void destory(BSTNode<T>*& tree);
};
/*
* 前序遍历算法
* BSTree类内部调用函数
*/
template<typename T>
void BSTree<T>::preOrder(BSTNode<T>*& tree) const
{
if(tree)
{
std::cout << tree->_key << " ";
preOrder(tree->_lchild);
preOrder(tree->_rchild);
}
}
// 接口
template<typename T>
void BSTree<T>::preOrder()
{
preOrder(_Root);
}
/*
* 中序遍历算法
* 类内部调用函数
*/
template <typename T>
void BSTree<T>::inOrder(BSTNode<T>*&tree) const
{
if(tree)
{
inOrder(tree->_lchild);
std::cout<<tree->_key<<" ";
inOrder(tree->_rchild);
}
}
// 接口
template<typename T>
void BSTree<T>::inOrder()
{
inOrder(_Root);
}
/*
* 后序遍历算法
* 类内部调用函数
*/
template <typename T>
void BSTree<T>::postOrder(BSTNode<T>*&tree) const
{
if(tree)
{
postOrder(tree->_lchild);
postOrder(tree->_rchild);
std::cout<<tree->_key<<" ";
}
}
// 接口
template<typename T>
void BSTree<T>::postOrder()
{
postOrder(_Root);
}
/*
* 插入操作
* 非递归实现
* 内部使用函数
*/
template<typename T>
void BSTree<T> ::insert(BSTNode<T>* &tree, BSTNode<T>* z)
{
BSTNode<T>* parent = NULL;
BSTNode<T>* temp = tree;
//寻找插入点
while(temp!=NULL)
{
parent= temp;
if(z->_key>temp->_key)
temp= temp->_rchild;
else
temp=temp->_lchild;
}
z->_parent = parent;
if(parent==NULL) //如果树本来就是空树，则直接把z节点插入根节点
tree = z;
else if(z->_key>parent->_key) //如果z的值大于其双亲，则z为其双亲的右孩
parent->_rchild = z;
else
parent->_lchild = z;
}
// 接口
template <typename T>
void BSTree<T>::insert(T key)
{
//创建一个新的节点，使用构造函数初始化
BSTNode<T>* z= new BSTNode<T>(key,NULL,NULL,NULL);
if(!z) //如果创建失败则返回
return ;
//调用内部函数进行插入
insert(_Root,z);
}
/*
* 查找操作
* 非递归实现
* 内部使用函数
*/
template <typename T>
BSTNode<T>* BSTree<T>::search(BSTNode<T>*& tree,T key) const
{
BSTNode<T>* temp = tree;
while(temp != NULL)
{
if(temp->_key == key)
return temp;
else if(temp->_key>key)
temp = temp->_lchild;
else
temp = temp->_rchild;
}
return NULL;
}
/*//查找算法的递归实现
template<typename T>
BSTNode<T>* BSTree<T>::search( BSTNode<T>*& tree,T key) const
{
if(!tree)
{
if(tree->_key==key)
return tree;
if(tree->_key>key)
return search(tree->_lchild,key);
if(tree->_key<z->_key)
return search(tree->_rchild,key);
}
return NULL;
}*/
// 接口
template <typename T>
BSTNode<T> * BSTree<T>::search(T key)
{
return search(_Root,key);
}
/*
* 查找最小的结点
* 内部调用函数
*/
template <typename T>
BSTNode<T>* BSTree<T>::minimumNode(BSTNode<T>*&tree)
{
BSTNode<T>* temp = tree;
while(temp->_lchild)
{
temp= temp->_lchild;
}
return temp;
}
// 接口
template<typename T>
BSTNode<T>* BSTree<T>::minimumNode()
{
return minimumNode(_Root);
}
/*
* 查找键值最大的节点
* 内部调用函数
* 非递归实现
*/
template<typename T>
BSTNode<T>* BSTree<T>::maximumNode(BSTNode<T>* &tree)
{
BSTNode<T>* temp=tree;
while(temp->_rchild)
{
temp= temp->_rchild;
}
return temp;
}
// 接口
template<typename T>
BSTNode<T>* BSTree<T>::maximumNode()
{
return maximumNode(_Root);
}
/*
* 查找最小的键值
* 外部接口函数
* 调用内部函数minimumNode实现
*/
template<typename T>
T BSTree<T>::minimumKey()
{
BSTNode<T> *temp = minimumNode(_Root);
return temp->_key;
}
/*
* 查找最大的键值
* 外部接口函数
* 调用内部函数maximumKey
*/
template<typename T>
T BSTree<T>::maximumKey()
{
BSTNode<T> *temp = maximumNode(_Root);
return temp->_key;
}
/*
* 打印函数(详细描述结点的亲子关系)
* 打印出平衡二叉树
* BStree内部函数
*/
template<typename T>
void BSTree<T>::print(BSTNode<T>*& tree)
{
if(tree) //如果tree不为空
{
if(tree->_lchild) //结点有左孩子
{
std::cout << "节点" << tree->_key << "有左孩子为" << tree->_lchild->_key << std::endl;
}
else
{
std::cout << "节点" << tree->_key << "无左孩子" << std::endl;
}
if(tree->_rchild)
{
std::cout << "节点" << tree->_key << "有右孩子为" << tree->_rchild->_key << std::endl;
}
else
{
std::cout << "节点" << tree->_key << "无右孩子" << std::endl;
}
print(tree->_lchild);
print(tree->_rchild);
}
}
// 接口
template<typename T>
void BSTree<T>::print()
{
print(_Root);
}
/*
* 查找某个节点x的前驱
* 接口
*/
template <typename T>
BSTNode<T>* BSTree<T>::predecessor(BSTNode<T>* x)
{
//如果x是最小的结点，则它没有前驱
if(x->_key == minimumNode(_Root)->_key)
{
return NULL;
}
//先获取二叉树中键值与x的键值相同的结点y
BSTNode <T> * y = NULL;
y = search(_Root,x->_key);
if(y==NULL) return NULL;
//如果y有左孩子，则x的前驱为“以x的左孩为根的子树的最大结点”
if(y->_lchild!=NULL)
return maximumNode(y->_lchild);
//如果y没有左孩子，则x有两种可能：
//1.y是一个右孩子，此时x的前驱为其双亲节点
BSTNode<T>* parent = y->_parent;
if(parent->_rchild == y)
return parent;
//2.y是一个左孩子，则其前驱为其双亲结点中“第一个拥有右孩子结点”的结点
while(parent!=NULL&&parent->_rchild==NULL)
{
parent=parent->_parent;
}
return parent;
}
/*
* 查找某个节点x的后继
* 外部调用接口
*/
template <typename T>
BSTNode<T>* BSTree<T>::sucessor(BSTNode<T>* x)
{
//如果x是键值最大的，则x没有后继结点
if(x->_key==maximumNode(_Root)->_key)
return NULL;
//获取x在二叉树中的结点y
BSTNode<T>* y = NULL;
y = search(_Root,x->_key);
if(!y) //若二叉树没有此结点
return NULL;
//如果y有右孩子，则y的后继为其右孩子的最小结点
if(y->_rchild!=NULL)
return minimumNode(y->_rchild);
//如果y没有右孩子，则可分为两种情况：
//1.y 是左孩子。此时y的后继为y的父结点
BSTNode <T>* parent = y->_parent;
if(y->_parent->_lchild == y)
return parent;
//2.y是右孩子。此时y的后继结点为“第一个拥有左孩且不是y的直接双亲”的结点
while(parent!=NULL)
{
if(parent->_lchild!=NULL&&parent!=y->_parent)
return parent;
parent=parent->_parent;
}
return NULL;
}
/*
* 删除结点
* BSTree类内部调用函数
*/
template <class T>
BSTNode<T>* BSTree<T>::remove(BSTNode<T>* &tree, BSTNode<T> *z)
{
BSTNode<T> *x=NULL;
BSTNode<T> *y=NULL;
if ((z->_lchild == NULL) || (z->_rchild == NULL) )
y = z;
else
y = sucessor(z);
if (y->_lchild != NULL)
x = y->_lchild;
else
x = y->_rchild;
if (x != NULL)
x->_parent = y->_parent;
if (y->_parent == NULL)
tree = x;
else if (y == y->_parent->_lchild)
y->_parent->_lchild = x;
else
y->_parent->_rchild= x;
if (y != z)
z->_key = y->_key;
return y;
}
// 接口
template<typename T>
void BSTree<T>::remove(T key)
{
BSTNode<T> *z, *node;
if ((z = search(_Root, key)) != NULL)
if ( (node = remove(_Root, z)) != NULL)
delete node;
}
/*
* 销毁查找二叉树
* 内部调用函数
*/
template<typename T>
void BSTree<T>::destory(BSTNode<T>*& tree)
{
if(tree->_lchild!=NULL)
destory(tree->_lchild);
if(tree->_rchild!=NULL)
destory(tree->_rchild);
if(tree->_lchild==NULL&&tree->_rchild==NULL)
{
delete(tree);
tree = NULL;
}
}
// 接口
template<typename T>
void BSTree<T>::destory()
{
destory(_Root);
}
int main()
{
BSTree<int> s ;
int a ;
std::cout << "请输入二叉树结点以构造二叉查找树：" << std::endl;
while(std::cin >> a )
s.insert(a);
std::cin.clear();
std::cout << "前序遍历二叉查找树:" << std::endl;
s.postOrder();
std::cout << std::endl;
std::cout << "中序遍历二叉查找树:" << std::endl;
s.inOrder();
std::cout << std::endl;
std::cout << "后序遍历二叉查找树:" << std::endl;
s.postOrder();
std::cout << std::endl;
std::cout << "打印二叉查找树" << std::endl;
s.print();
std::cout << "请输入要查找的数：" << std::endl;
while(std::cin >> a)
{
BSTNode<int>* findnode = s.search(a);
if(!findnode)
{
std::cout << "查找失败" << std::endl;
s.insert(a);
std::cout << "已经将" << a << "插入二叉查找树,现在二叉查找树为：" << std::endl;
s.inOrder();
std::cout << std::endl;
}
else
{
std::cout << findnode->_key << "查找成功" << std::endl;
}
}
std::cin.clear();
std::cout << "请输入结点以查找其前驱节点" << std::endl;
BSTNode<int>* findPreNode= new BSTNode<int>(1,NULL,NULL,NULL);
while(std::cin >> findPreNode->_key)
{
BSTNode<int>* preNode ;
if((preNode= s.predecessor(findPreNode))!=NULL)
{
std::cout << "其前驱结点为：";
std::cout << preNode->_key << std::endl;
}
else
{
std::cout << "没有前驱结点" << std::endl;
}
if((preNode= s.sucessor(findPreNode))!=NULL)
{
std::cout << "其后继结点为：";
std::cout << preNode->_key << std::endl;
}
else
{
std::cout << "没有后继结点" << std::endl;
}
}
std::cin.clear();
std::cout << "请输入要删除的结点：" << std::endl;
while(std::cin >> a)
{
s.remove(a);
std::cout << "删除后的二叉排序树：" << std::endl;
s.inOrder();
}
BSTNode<int>* maxNode = s.minimumNode();
if(!maxNode)
{
std::cout << "最小的节点为：" << maxNode->_key << std::endl;
}
BSTNode<int>* minNode = s.maximumNode();
if(!minNode)
{
std::cout << "最大的节点为：" << minNode->_key << std::endl;
}
std::cout << "销毁二叉树" << std::endl;
s.destory();
s.inOrder();
return 0;
}
================================================
FILE: ACM 模板代码/f-伸展数/f-伸展数/main.cpp
================================================
//
// main.cpp
// f-伸展数
//
// Created by ZYJ on 16/7/20.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
using namespace std;
/*
* 伸展树(Splay Tree)
* 题目:维修数列。
* 经典题,插入、删除、修改、翻转、求和、求和最大的子序列
*/
#define Key_value ch[ch[root][1]][0]
const int MAXN = 500010;
const int INF = 0x3f3f3f3f;
int pre[MAXN], ch[MAXN][2], key[MAXN], size[MAXN];
int root, tot1;
int sum[MAXN], rev[MAXN], same[MAXN];
int lx[MAXN], rx[MAXN], mx[MAXN];
int s[MAXN], tot2; // 内存池和容量
int a[MAXN];
int n, q;
// debug Start**********************************
void Treavel(int x)
{
if (x)
{
Treavel(ch[x][0]);
printf("结点:%2d: 左儿子 %2d 右儿子 %2d 父结点 %2d size = %2d\n", x, ch[x][0], ch[x][1], pre[x], size[x]);
Treavel(ch[x][1]);
}
return ;
}
void debug()
{
printf("root:%d\n", root);
Treavel(root);
return ;
}
// debug End***********************************
void NewNode(int &r, int father, int k)
{
if (tot2)
{
r = s[tot2--]; // 取的时候是tot2--,存的时候就是++tot2
}
else
{
r = ++tot1;
}
pre[r] = father;
ch[r][0] = ch[r][1] = 0;
key[r] = k;
sum[r] = k;
rev[r] = same[r] = 0;
lx[r] = rx[r] = mx[r] = k;
size[r] = 1;
return ;
}
void Update_Rev(int r)
{
if (!r)
{
return ;
}
swap(ch[r][0], ch[r][1]);
swap(lx[r], rx[r]);
rev[r] ^= 1;
return ;
}
void Update_Same(int r, int v)
{
if (!r)
{
return ;
}
key[r] = v;
sum[r] = v * size[r];
lx[r] = rx[r] = mx[r] = max(v, v * size[r]);
same[r] = 1;
return ;
}
void push_up(int r)
{
int lson = ch[r][0], rson = ch[r][1];
size[r] = size[lson] + size[rson] + 1;
sum[r] = sum[lson] + sum[rson] + key[r];
lx[r] = max(lx[lson], sum[lson] + key[r] + max(0, lx[rson]));
rx[r] = max(rx[rson], sum[rson] + key[r] + max(0, rx[lson]));
mx[r] = max(0, rx[lson]) + key[r] + max(0, lx[rson]);
mx[r] = max(mx[r], max(mx[lson], mx[rson]));
return ;
}
void push_down(int r)
{
if (same[r])
{
Update_Same(ch[r][0], key[r]);
Update_Same(ch[r][1], key[r]);
same[r] = 0;
}
if(rev[r])
{
Update_Rev(ch[r][0]);
Update_Rev(ch[r][1]);
rev[r] = 0;
}
return ;
}
void Build(int &x, int l, int r, int father)
{
if (l > r)
{
return ;
}
int mid = (l + r) / 2;
NewNode(x, father, a[mid]);
Build(ch[x][0], l, mid - 1, x);
Build(ch[x][1], mid + 1, r, x);
push_up(x);
return ;
}
void Init()
{
root = tot1 = tot2 = 0;
ch[root][0] = ch[root][1] = size[root] = pre[root] = 0;
same[root] = rev[root] = sum[root] = key[root] = 0;
lx[root] = rx[root] = mx[root] = -INF;
NewNode(root, 0, -1);
NewNode(ch[root][1], root, -1);
for (int i = 0; i < n; i++)
{
scanf("%d", &a[i]);
}
Build(Key_value, 0, n - 1, ch[root][1]);
push_up(ch[root][1]);
push_up(root);
}
// 旋转,0为左旋,1为右旋
void Rotate(int x,int kind)
{
int y = pre[x];
push_down(y);
push_down(x);
ch[y][!kind] = ch[x][kind];
pre[ch[x][kind]] = y;
if (pre[y])
ch[pre[y]][ch[pre[y]][1]==y] = x;
pre[x] = pre[y];
ch[x][kind] = y;
pre[y] = x;
push_up(y);
}
// Splay调整,将r结点调整到goal下面
void Splay(int r, int goal)
{
push_down(r);
while (pre[r] != goal)
{
if (pre[pre[r]] == goal)
{
push_down(pre[r]);
push_down(r);
Rotate(r, ch[pre[r]][0] == r);
}
else
{
push_down(pre[pre[r]]);
push_down(pre[r]);
push_down(r);
int y = pre[r];
int kind = ch[pre[y]][0] == y;
if (ch[y][kind] == r)
{
Rotate(r, !kind);
Rotate(r, kind);
}
else
{
Rotate(y, kind);
Rotate(r, kind);
}
}
}
push_up(r);
if (goal == 0)
{
root = r;
}
return ;
}
int Get_kth(int r, int k)
{
push_down(r);
int t = size[ch[r][0]] + 1;
if (t == k)
{
return r;
}
if (t > k)
{
return Get_kth(ch[r][0], k);
}
else
{
return Get_kth(ch[r][1], k - t);
}
}
// 在第pos个数后面插入tot个数
void Insert(int pos, int tot)
{
for (int i = 0; i < tot; i++)
{
scanf("%d",&a[i]);
}
Splay(Get_kth(root, pos + 1), 0);
Splay(Get_kth(root, pos + 2), root);
Build(Key_value, 0, tot - 1, ch[root][1]);
push_up(ch[root][1]);
push_up(root);
return ;
}
// 删除子树
void erase(int r)
{
if (!r)
{
return ;
}
s[++tot2] = r;
erase(ch[r][0]);
erase(ch[r][1]);
return ;
}
// 从第pos个数开始连续删除tot个数
void Delete(int pos, int tot)
{
Splay(Get_kth(root, pos), 0);
Splay(Get_kth(root, pos + tot + 1), root);
erase(Key_value);
pre[Key_value] = 0;
Key_value = 0;
push_up(ch[root][1]);
push_up(root);
return ;
}
// 将从第pos个数开始的连续的tot个数修改为c
void Make_Same(int pos, int tot, int c)
{
Splay(Get_kth(root, pos), 0);
Splay(Get_kth(root, pos + tot + 1), root);
Update_Same(Key_value, c);
push_up(ch[root][1]);
push_up(root);
return ;
}
// 将第pos个数开始的连续tot个数进行反转
void Reverse(int pos, int tot)
{
Splay(Get_kth(root, pos), 0);
Splay(Get_kth(root,pos+tot + 1), root);
Update_Rev(Key_value);
push_up(ch[root][1]);
push_up(root);
return ;
}
// 得到第pos个数开始的tot个数的和
int Get_Sum(int pos, int tot)
{
Splay(Get_kth(root, pos), 0);
Splay(Get_kth(root, pos + tot + 1), root);
return sum[Key_value];
}
// 得到第pos个数开始的tot个数中最大的子段和
int Get_MaxSum(int pos, int tot)
{
Splay(Get_kth(root, pos), 0);
Splay(Get_kth(root, pos + tot + 1), root);
return mx[Key_value];
}
void InOrder(int r)
{
if (!r)
{
return ;
}
push_down(r);
InOrder(ch[r][0]);
printf("%d ",key[r]);
InOrder(ch[r][1]);
return ;
}
int main()
{
// freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
while (scanf("%d%d", &n, &q) == 2)
{
Init();
char op[20];
int x, y, z;
while (q--)
{
scanf("%s", op);
if (strcmp(op, "INSERT") == 0)
{
scanf("%d%d", &x, &y);
Insert(x, y);
}
else if (strcmp(op, "DELETE") == 0)
{
scanf("%d%d", &x, &y);
Delete(x,y);
}
else if (strcmp(op, "MAKE-SAME") == 0)
{
scanf("%d%d%d", &x, &y, &z);
Make_Same(x, y, z);
}
else if (strcmp(op, "REVERSE") == 0)
{
scanf("%d%d", &x, &y);
Reverse(x, y);
}
else if (strcmp(op, "GET-SUM") == 0)
{
scanf("%d%d", &x, &y);
printf("%d\n", Get_Sum(x, y));
}
else if (strcmp(op, "MAX-SUM") == 0)
{
printf("%d\n", Get_MaxSum(1, size[root] - 2));
}
}
}
return 0;
}
================================================
FILE: ACM 模板代码/f-使序列有序的最少交换次数/f-使序列有序的最少交换次数/main.cpp
================================================
//
// main.cpp
// f-使序列有序的最少交换次数
//
// Created by ZYJ on 2017/5/16.
// Copyright © 2017年 ZYJ. All rights reserved.
//
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
using namespace std;
//int getMinSwaps(vector<int> &A)
//{
// // 排序
// vector<int> B(A);
// sort(B.begin(), B.end());
// map<int, int> m;
// int len = (int)A.size();
// for (int i = 0; i < len; i++)
// {
// m[B[i]] = i; // 建立每个元素与其应放位置的映射关系
// }
//
// int loops = 0; // 循环节个数
// vector<bool> flag(len, false);
// // 找出循环节的个数
// for (int i = 0; i < len; i++)
// {
// if (!flag[i])
// {
// int j = i;
// while (!flag[j])
// {
// flag[j] = true;
// j = m[A[j]]; // 原序列中j位置的元素在有序序列中的位置
// }
// loops++;
// }
// }
// return len - loops;
//}
//
//vector<int> nums;
//
//int main()
//{
// nums.push_back(1);
// nums.push_back(2);
// nums.push_back(4);
// nums.push_back(3);
// nums.push_back(5);
//
// int res = getMinSwaps(nums);
//
// cout << res << '\n';
//
// return 0;
//}
/*
* 默认目标映射关系是 key 1 => val 1 …… key n => val n
* 如果序列不是 1~n 可以通过 map 建立新的目标映射关系
*/
const int MAXN = 30;
int n;
int vis[MAXN];
int A[MAXN], B[MAXN];
int getMinSwaps()
{
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++)
{
B[A[i]] = A[i % n + 1];
}
for (int i = 1; i <= n; i++)
{
B[i] = (B[i] - 2 + n) % n + 1;
}
int cnt = n;
for (int i = 1; i <= n; i++)
{
if (vis[i])
{
continue;
}
vis[i] = 1;
cnt--;
for (int j = B[i]; j != i; j = B[j])
{
vis[j] = 1;
}
}
return cnt;
}
int main()
{
cin >> n;
for (int i = 1; i <= n; i++)
{
cin >> A[i];
}
int res = getMinSwaps();
cout << res << '\n';
return 0;
}
================================================
FILE: ACM 模板代码/f-划分树/f-划分树/main.cpp
================================================
//
// main.cpp
// f-划分树
//
// Created by ZYJ on 16/7/20.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
using namespace std;
/*
* 划分树(查询区间第k大)
*/
const int MAXN = 100010;
int tree[20][MAXN]; // 表示每层每个位置的值
int sorted[MAXN]; // 已经排序好的数
int toleft[20][MAXN]; // toleft[p][i]表示第i层从1到i有数分入左边
void build(int l, int r, int dep)
{
if (l == r)
{
return;
}
int mid = (l + r) >> 1;
int same = mid - l + 1; // 表示等于中间值而且被分入左边的个数
for (int i = l; i <= r; i++) // 注意是l,不是one
{
if (tree[dep][i] < sorted[mid])
{
same--;
}
}
int lpos = l;
int rpos = mid + 1;
for (int i = l; i <= r; i++)
{
if (tree[dep][i] < sorted[mid])
{
tree[dep + 1][lpos++] = tree[dep][i];
}
else if (tree[dep][i] == sorted[mid] && same > 0)
{
tree[dep + 1][lpos++] = tree[dep][i];
same--;
}
else
{
tree[dep + 1][rpos++] = tree[dep][i];
}
toleft[dep][i] = toleft[dep][l - 1] + lpos - l;
}
build(l, mid, dep + 1);
build(mid + 1, r, dep + 1);
return ;
}
// 查询区间第k大的数,[L,R]是大区间,[l,r]是要查询的小区间
int query(int L, int R, int l, int r, int dep, int k)
{
if(l == r)
{
return tree[dep][l];
}
int mid = (L + R) >> 1;
int cnt = toleft[dep][r] - toleft[dep][l - 1];
if (cnt >= k)
{
int newl = L + toleft[dep][l - 1] - toleft[dep][L - 1];
int newr = newl + cnt - 1;
return query(L, mid, newl, newr, dep + 1, k);
}
else
{
int newr = r + toleft[dep][R] - toleft[dep][r];
int newl = newr - (r - l - cnt);
return query(mid + 1, R, newl, newr, dep + 1, k - cnt);
}
}
int main()
{
int n, m;
while (scanf("%d%d", &n, &m) == 2)
{
memset(tree, 0, sizeof(tree));
for (int i = 1; i <= n; i++)
{
scanf("%d", &tree[0][i]);
sorted[i] = tree[0][i];
}
sort(sorted + 1, sorted + n + 1);
build(1, n, 0);
int s, t, k;
while(m--)
{
scanf("%d%d%d", &s, &t, &k);
printf("%d\n", query(1, n, s, t, 0, k));
}
}
return 0;
}
================================================
FILE: ACM 模板代码/f-判断线段相交/f-判断线段相交/main.cpp
================================================
//
// main.cpp
// f-判断线段相交
//
// Created by ZYJ on 16/7/23.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
const double eps=1e-10;
struct point
{
double x, y;
};
double min(double a, double b)
{
return a < b ? a : b;
}
double max(double a, double b)
{
return a > b ? a : b;
}
bool inter(point a, point b, point c, point d)
{
if (min(a.x, b.x) > max(c.x, d.x) || min(a.y, b.y) > max(c.y, d.y) || min(c.x, d.x) > max(a.x, b.x) || min(c.y, d.y) > max(a.y, b.y))
{
return 0;
}
double h, i, j, k;
h = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
i = (b.x - a.x) * (d.y - a.y) - (b.y - a.y) * (d.x - a.x);
j = (d.x - c.x) * (a.y - c.y) - (d.y - c.y) * (a.x - c.x);
k = (d.x - c.x) * (b.y - c.y) - (d.y - c.y) * (b.x - c.x);
return h * i <= eps && j * k <= eps;
}
================================================
FILE: ACM 模板代码/f-动态树/f-动态树/main.cpp
================================================
//
// main.cpp
// f-动态树
//
// Created by ZYJ on 16/7/20.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
using namespace std;
/*
* 切割、合并子树,路径上所有点的点权增加一个值,查询路径上点权的最大值
* 动态维护一组森林,要求支持一下操作:
* link(a,b): 如果a,b不在同一颗子树中,则通过在a,b之间连边的方式,连接这两颗子树
* cut(a,b): 如果a,b在同一颗子树中,且a!=b,则将a视为这颗子树的根以后,切断b与其父亲结点的连接
* ADD(a,b,w): 如果a,b在同一颗子树中,则将a,b之间路径上所有点的点权增加w
* query(a,b): 如果a,b在同一颗子树中,返回a,b之间路径上点权的最大值
*/
const int MAXN = 300010;
int ch[MAXN][2], pre[MAXN], key[MAXN];
int add[MAXN], rev[MAXN], Max[MAXN];
bool rt[MAXN];
void Update_Add(int r, int d)
{
if (!r)
{
return;
}
key[r] += d;
add[r] += d;
Max[r] += d;
return ;
}
void Update_Rev(int r)
{
if (!r)
{
return ;
}
swap(ch[r][0], ch[r][1]);
rev[r] ^= 1;
return ;
}
void push_down(int r)
{
if (add[r])
{
Update_Add(ch[r][0], add[r]);
Update_Add(ch[r][1], add[r]);
add[r] = 0;
}
if (rev[r])
{
Update_Rev(ch[r][0]);
Update_Rev(ch[r][1]);
rev[r] = 0;
}
return ;
}
void push_up(int r)
{
Max[r] = max(max(Max[ch[r][0]], Max[ch[r][1]]), key[r]);
return ;
}
void Rotate(int x)
{
int y = pre[x], kind = ch[y][1] == x;
ch[y][kind] = ch[x][!kind];
pre[ch[y][kind]] = y;
pre[x] = pre[y];
pre[y] = x;
ch[x][!kind] = y;
if (rt[y])
{
rt[y] = false, rt[x] = true;
}
else
{
ch[pre[x]][ch[pre[x]][1] == y] = x;
}
push_up(y);
}
// P函数先将根结点到r的路径上所有的结点的标记逐级下放
void P(int r)
{
if (!rt[r])P(pre[r]);
{
push_down(r);
}
return ;
}
void Splay(int r)
{
P(r);
while (!rt[r])
{
int f = pre[r], ff = pre[f];
if (rt[f])
{
Rotate(r);
}
else if ((ch[ff][1] == f) == (ch[f][1] == r))
{
Rotate(f), Rotate(r);
}
else
{
Rotate(r), Rotate(r);
}
}
push_up(r);
return ;
}
int Access(int x)
{
int y = 0;
for ( ; x; x = pre[y = x])
{
Splay(x);
rt[ch[x][1]] = true, rt[ch[x][1] = y] = false;
push_up(x);
}
return y;
}
// 判断是否是同根(真实的树,非splay)
bool judge(int u, int v)
{
while (pre[u])
{
u = pre[u];
}
while(pre[v])
{
v = pre[v];
}
return u == v;
}
// 使r成为它所在的树的根
void mroot(int r)
{
Access(r);
Splay(r);
Update_Rev(r);
return ;
}
// 调用后u是原来u和v的lca,v和ch[u][1]分别存着lca的2个儿子
// (原来u和v所在的2颗子树)
void lca(int &u, int &v)
{
Access(v), v = 0;
while(u)
{
Splay(u);
if (!pre[u])
{
return ;
}
rt[ch[u][1]] = true;
rt[ch[u][1] = v] = false;
push_up(u);
u = pre[v = u];
}
return ;
}
void link(int u, int v)
{
if (judge(u, v))
{
puts("-1");
return ;
}
mroot(u);
pre[u] = v;
return ;
}
// 使u成为u所在树的根,并且v和它父亲的边断开
void cut(int u, int v)
{
if (u == v || !judge(u, v))
{
puts("-1");
return ;
}
mroot(u);
Splay(v);
pre[ch[v][0]] = pre[v];
pre[v] = 0;
rt[ch[v][0]] = true;
ch[v][0] = 0;
push_up(v);
return ;
}
void ADD(int u, int v, int w)
{
if (!judge(u, v))
{
puts("-1");
return ;
}
lca(u, v);
Update_Add(ch[u][1], w);
Update_Add(v, w);
key[u] += w;
push_up(u);
return ;
}
void query(int u, int v)
{
if (!judge(u, v))
{
puts("-1");
return ;
}
lca(u, v);
printf("%d\n", max(max(Max[v], Max[ch[u][1]]), key[u]));
return ;
}
struct Edge
{
int to, next;
} edge[MAXN * 2];
int head[MAXN], tot;
void addedge(int u, int v)
{
edge[tot].to = v;
edge[tot].next = head[u];
head[u] = tot++;
return ;
}
void dfs(int u)
{
for (int i = head[u]; i != -1; i = edge[i].next)
{
int v = edge[i].to;
if (pre[v] != 0)
{
continue;
}
pre[v] = u;
dfs(v);
}
return ;
}
int main()
{
// freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
int n, q, u, v;
while (scanf("%d", &n) == 1)
{
tot = 0;
for (int i = 0; i <= n; i++)
{
head[i] = -1;
pre[i] = 0;
ch[i][0] = ch[i][1] = 0;
rev[i] = 0;
add[i] = 0;
rt[i] = true;
}
Max[0] = -2000000000;
for (int i = 1; i < n; i++)
{
scanf("%d%d", &u, &v);
addedge(u, v);
addedge(v, u);
}
for (int i = 1; i <= n; i++)
{
scanf("%d", &key[i]);
Max[i] = key[i];
}
scanf("%d", &q);
pre[1] = -1;
dfs(1);
pre[1] = 0;
int op;
while (q--)
{
scanf("%d", &op);
if (op == 1)
{
int x, y;
scanf("%d%d", &x, &y);
link(x, y);
}
else if (op == 2)
{
int x, y;
scanf("%d%d",&x, &y);
cut(x, y);
}
else if (op == 3)
{
int w, x, y;
scanf("%d%d%d", &w, &x, &y);
ADD(x, y, w);
}
else
{
int x, y;
scanf("%d%d", &x, &y);
query(x, y);
}
}
printf("\n");
}
return 0;
}
================================================
FILE: ACM 模板代码/f-区间最大频率/f-区间最大频率/main.cpp
================================================
//
// main.cpp
// f-区间最大频率
//
// Created by ZYJ on 16/7/23.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
/*
* 求区间中数出现的最大频率
* 方法一:线段树.
* 先离散化。因为序列是升序,所以先将所有值相同的点缩成一点。这样n规模就缩小了。建立一个数据结构
* 记录缩点的属性:在原序列中的值id,和该值有多少个num比如序列
* 10
* -1 -1 1 1 1 1 3 10 10 10
* 缩点后为:下标 1 2 3 4
* id -1 1 3 10
* num 2 4 1 3
* 然后建树,树的属性有区间最大值(也就是频率)和区间总和。
* 接受询问的时候。接受的是原来序列的区间[be,ed]我们先搜索一下两个区间分别在离散化区间后的下标。
* 比如接受[2,3]时候相应下标区间就是[1,2];[3,10]的相应下标区间是[2,4];
* 处理频率的时候,我们发现两个极端,也就是左右两个端点的频率不好处理。因为它们是不完全的频率
* 也就是说有部分不在区间内。但是如果对于完全区间,也就是说左右端点下标值完全在所求区间内。
* 比如上例的[2,3]不好处理。但是如果是[1,6],或是[1,10]就很好处理了,只要像RMQ一样询问区间最大值就可以了。
* 方法二:RMQ.
* 我们可以转化一下问题。将左右端点分开来考虑。
* 现在对于离散后的询问区间我们可以分成3个部分.左端点,中间完全区间,右端点。
* 对于中间完全区间线段树或RMQ都能轻松搞定。只要特判一左右的比较一下就得最后解了。
*/
int build(int a, int b);
int query(int index, int a, int b);
const int N = 100010;
struct NODE
{
int b, e; // 区间[b, e]
int l, r; // 左右子节点下标
int number; // 区间内的最大频率值
int last; // 以 data[e]结尾且与 data[e]相同的个数:data[e-last+1]...data[e]
} node[N * 2 + 1];
int len, data[N];
int main()
{
int n;
while (scanf("%d", &n), n)
{
int i, q, a, b;
scanf("%d", &q);
for (i = 0; i < n; i++)
{
scanf("%d", &data[i]);
}
len = 0; // 下标
build(0, n - 1);
while (q--)
{
scanf("%d%d", &a, &b);
printf("%d\n", query(0, a - 1, b - 1)); // 输出区间的最大频率值,而非data[]
}
}
return 0;
}
int build(int a, int b) // 建立线段树
{
int temp = len, mid = (a + b) / 2;
node[temp].b = a, node[temp].e = b;
len++;
if (a == b)
{
node[temp].number = 1;
node[temp].last = 1;
return temp;
}
node[temp].l = build(a, mid);
node[temp].r = build(mid + 1, b);
int left_c = node[temp].l, right_c = node[temp].r, p, lcount = 0, rcount = 0, rec, max = 0;
rec = data[mid];
p = mid;
while (p >= a && data[p] == rec)
{
p--, lcount++;
}
node[left_c].last = lcount;
rec = data[mid + 1];
p = mid + 1;
while (p <= b && data[p] == rec)
{
p++, rcount++;
}
node[right_c].last = rcount;
if (data[mid] == data[mid + 1])
{
max = lcount + rcount;
}
if (node[left_c].number > max)
{
max = node[left_c].number;
}
if (node[right_c].number > max)
{
max = node[right_c].number;
}
node[temp].number = max;
return temp;
}
int query(int index, int a, int b)
{
int begin = node[index].b;
int end = node[index].e;
int mid = (begin + end) / 2;
if (a == begin && b == end)
{
return node[index].number;
}
if (a > mid)
{
return query(node[index].r, a, b);
}
if (b < mid + 1)
{
return query(node[index].l, a, b);
}
int temp1, temp2, max;
if (node[index].l > 0)
{
temp1 = query(node[index].l, a, mid);
}
if (node[index].r > 0)
{
temp2 = query(node[index].r, mid + 1, b);
}
max = temp1 > temp2 ? temp1 : temp2;
if (data[mid] != data[mid + 1])
{
return max;
}
temp1 = node[node[index].l].last > (mid - a + 1) ? (mid - a + 1) : node[node[index].l].last;
temp2 = node[node[index].r].last > (b - mid) ? (b - mid) : node[node[index].r].last;
if (max < temp1 + temp2)
{
max = temp1 + temp2;
}
return max;
}
================================================
FILE: ACM 模板代码/f-半平面交/f-半平面交/main.cpp
================================================
//
// main.cpp
// f-半平面交
//
// Created by ZYJ on 16/7/25.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
#include <cmath>
using namespace std;
// 半平面交模板
//const double eps = 1e-8;
//const double PI = acos(-1.0);
//
//int sgn(double x)
//{
// if (fabs(x) < eps)
// {
// return 0;
// }
// if (x < 0)
// {
// return -1;
// }
// else
// {
// return 1;
// }
//}
//
//struct Point
//{
// double x, y;
// Point(){}
// Point(double _x, double _y)
// {
// x = _x;
// y = _y;
// }
// Point operator - (const Point &b)const
// {
// return Point(x - b.x, y - b.y);
// }
// double operator ^ (const Point &b)const
// {
// return x * b.y - y * b.x;
// }
// double operator * (const Point &b)const
// {
// return x * b.x + y * b.y;
// }
//};
//
//struct Line
//{
// Point s, e;
// double k;
// Line() {}
// Line(Point _s, Point _e)
// {
// s = _s;
// e = _e;
// k = atan2(e.y - s.y, e.x - s.x);
// }
// Point operator & (const Line &b)const
// {
// Point res = s;
// double t = ((s - b.s) ^ (b.s - b.e)) / ((s - e) ^ (b.s - b.e));
// res.x += (e.x - s.x) * t;
// res.y += (e.y - s.y) * t;
// return res;
// }
//};
//
//// 半平面交,直线的左边代表有效区域
//bool HPIcmp(Line a, Line b)
//{
// if (fabs(a.k - b.k) > eps)
// {
// return a.k < b.k;
// }
// return ((a.s - b.s) ^ (b.e - b.s)) < 0;
//}
//
//Line Q[110];
//
//void HPI(Line line[], int n, Point res[], int &resn)
//{
// int tot = n;
// sort(line, line + n, HPIcmp);
// tot = 1;
// for (int i = 1; i < n; i++)
// {
// if (fabs(line[i].k - line[i-1].k) > eps)
// {
// line[tot++] = line[i];
// }
// }
// int head = 0, tail = 1;
// Q[0] = line[0];
// Q[1] = line[1];
// resn = 0;
// for (int i = 2; i < tot; i++)
// {
// if (fabs((Q[tail].e - Q[tail].s) ^ (Q[tail - 1].e - Q[tail - 1].s)) < eps || fabs((Q[head].e - Q[head].s) ^ (Q[head + 1].e - Q[head + 1].s)) < eps)
// {
// return;
// }
// while (head < tail && (((Q[tail] & Q[tail - 1]) - line[i].s) ^ (line[i].e - line[i].s)) > eps)
// {
// tail--;
// }
// while (head < tail && (((Q[head] & Q[head + 1]) - line[i].s) ^ (line[i].e - line[i].s)) > eps)
// {
// head++;
// }
// Q[++tail] = line[i];
// }
// while (head < tail && (((Q[tail] & Q[tail - 1]) - Q[head].s) ^ (Q[head].e - Q[head].s)) > eps)
// {
// tail--;
// }
// while (head < tail && (((Q[head]&Q[head-1]) - Q[tail].s) ^ (Q[tail].e - Q[tail].e)) > eps)
// {
// head++;
// }
// if (tail <= head + 1)
// {
// return ;
// }
// for (int i = head; i < tail; i++)
// {
// res[resn++] = Q[i] & Q[i + 1];
// }
// if (head < tail - 1)
// {
// res[resn++] = Q[head]&Q[tail];
// }
// return ;
//}
// 普通半平面交写法
const double eps = 1e-18;
int sgn(double x)
{
if (fabs(x) < eps)
{
return 0;
}
if (x < 0)
{
return -1;
}
else
{
return 1;
}
}
struct Point
{
double x, y;
Point() {}
Point(double _x, double _y)
{
x = _x;
y = _y;
}
Point operator - (const Point &b)const
{
return Point(x - b.x, y - b.y);
}
double operator ^ (const Point &b)const
{
return x * b.y - y * b.x;
}
double operator * (const Point &b)const
{
return x * b.x + y * b.y;
}
};
// 计算多边形面积
double CalcArea(Point p[], int n)
{
double res = 0;
for (int i = 0; i < n; i++)
{
res += (p[i] ^ p[(i + 1) % n]);
}
return fabs(res / 2);
}
// 通过两点,确定直线方程
void Get_equation(Point p1, Point p2, double &a, double &b, double &c)
{
a = p2.y - p1.y;
b = p1.x - p2.x;
c = p2.x * p1.y - p1.x * p2.y;
return ;
}
// 求交点
Point Intersection(Point p1, Point p2, double a, double b, double c)
{
double u = fabs(a * p1.x + b * p1.y + c);
double v = fabs(a * p2.x + b * p2.y + c);
Point t;
t.x = (p1.x * v + p2.x * u) / (u + v);
t.y = (p1.y * v + p2.y * u) / (u + v);
return t;
}
Point tp[110];
void Cut(double a, double b, double c, Point p[], int &cnt)
{
int tmp = 0;
for (int i = 1; i <= cnt; i++)
{
// 当前点在左侧,逆时针的点
if (a * p[i].x + b * p[i].y + c < eps)
{
tp[++tmp] = p[i];
}
else
{
if (a * p[i - 1].x + b * p[i - 1].y + c < -eps)
{tp[++tmp] = Intersection(p[i - 1], p[i], a, b, c);
}
if (a * p[i + 1].x + b * p[i + 1].y + c < -eps)
{
tp[++tmp] = Intersection(p[i], p[i + 1], a, b, c);
}
}
}
for (int i = 1; i <= tmp; i++)
{
p[i] = tp[i];
}
p[0] = p[tmp];
p[tmp + 1] = p[1];
cnt = tmp;
return ;
}
double V[110], U[110], W[110];
int n;
const double INF = 100000000000.0;
Point p[110];
bool solve(int id)
{
p[1] = Point(0, 0);
p[2] = Point(INF, 0);
p[3] = Point(INF, INF);
p[4] = Point(0, INF);
p[0] = p[4];
p[5] = p[1];
int cnt = 4;
for (int i = 0; i < n; i++)
{
if (i != id)
{
double a = (V[i] - V[id]) / (V[i] * V[id]);
double b = (U[i] - U[id]) / (U[i] * U[id]);
double c = (W[i] - W[id]) / (W[i] * W[id]);
if (sgn(a) == 0 && sgn(b) == 0)
{
if (sgn(c) >= 0)
{
return false;
}
else
{
continue;
}
}
Cut(a, b, c, p, cnt);
}
}
if (sgn(CalcArea(p, cnt)) == 0)
{
return false;
}
else
{
return true;
}
}
int main()
{
while (scanf("%d", &n) == 1)
{
for (int i = 0; i < n; i++)
{
scanf("%lf%lf%lf", &V[i], &U[i], &W[i]);
}
for (int i = 0; i < n; i++)
{
if (solve(i))
{
printf("Yes\n");
}
else
{
printf("No\n");
}
}
}
return 0;
}
================================================
FILE: ACM 模板代码/f-双连通分支/f-双连通分支/main.cpp
================================================
//
// main.cpp
// f-双连通分支
//
// Created by ZYJ on 16/7/17.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
// 边双连通分支
//const int MAXN = 5010; // 点数
//const int MAXM = 20010; // 边数,因为是无向图,所以这个值要*2
//
//struct Edge
//{
// int to, next;
// bool cut; // 是否是桥标记
//}edge[MAXM];
//
//int head[MAXN], tot;
//int Low[MAXN], DFN[MAXN], Stack[MAXN], Belong[MAXN]; //Belong数组的值是1~block
//int Index,top;
//int block; // 边双连通块数
//bool Instack[MAXN];
//int bridge; // 桥的数目
//
//void addedge(int u, int v)
//{
// edge[tot].to = v;
// edge[tot].next = head[u];
// edge[tot].cut=false;
// head[u] = tot++;
// return ;
//}
//
//void Tarjan(int u, int pre)
//{
// int v;
// Low[u] = DFN[u] = ++Index;
// Stack[top++] = u;
// Instack[u] = true;
// for (int i = head[u]; i != -1; i = edge[i].next)
// {
// v = edge[i].to;
// if (v == pre)
// {
// continue;
// }
// if (!DFN[v])
// {
// Tarjan(v, u);
// if (Low[u] > Low[v])
// {
// Low[u] = Low[v];
// }
// if (Low[v] > DFN[u])
// {
// bridge++;
// edge[i].cut = true;
// edge[i^1].cut = true;
// }
// }
// else if (Instack[v] && Low[u] > DFN[v])
// {
// Low[u] = DFN[v];
// }
// }
// if (Low[u] == DFN[u])
// {
// block++;
// do
// {
// v = Stack[--top]; Instack[v] = false;
// Belong[v] = block;
// }
// while (v != u);
// }
// return ;
//}
//
//void init()
//{
// tot = 0;
// memset(head, -1, sizeof(head));
// return ;
//}
//
//int du[MAXN]; // 缩点后形成树,每个点的度数
//
//void solve(int n)
//{
// memset(DFN, 0, sizeof(DFN));
// memset(Instack, false, sizeof(Instack));
// Index = top = block = 0;
// Tarjan(1,0);
// int ans = 0;
// memset(du, 0, sizeof(du));
// for (int i = 1; i <= n; i++)
// {
// for (int j = head[i]; j != -1; j = edge[j].next)
// {
// if (edge[j].cut)
// {
// du[Belong[i]]++;
// }
// }
// }
// for (int i = 1; i <= block; i++)
// {
// if(du[i]==1)
// {
// ans++;
// }
// }
// // 找叶子结点的个数ans,构造边双连通图需要加边(ans+1)/2
// printf("%d\n", (ans + 1) / 2);
//}
//
//int main()
//{
// int n, m;
// int u, v;
// while (scanf("%d%d", &n, &m) == 2)
// {
// init();
// while (m--)
// {
// scanf("%d%d",&u,&v);
// addedge(u,v);
// addedge(v,u);
// }
// solve(n);
// }
// return 0;
//}
// 点双连通分支
/*
* POJ 2942 Knights of the Round Table
* 亚瑟王要在圆桌上召开骑士会议,为了不引发骑士之间的冲突,
* 并且能够让会议的议题有令人满意的结果,每次开会前都必须对出席会议的骑士有如下要求:
* 1、 相互憎恨的两个骑士不能坐在直接相邻的2个位置;
* 2、 出席会议的骑士数必须是奇数,这是为了让投票表决议题时都能有结果。
* 注意:1、所给出的憎恨关系一定是双向的,不存在单向憎恨关系。
* 2、由于是圆桌会议,则每个出席的骑士身边必定刚好有2个骑士。
* 即每个骑士的座位两边都必定各有一个骑士。
* 3、一个骑士无法开会,就是说至少有3个骑士才可能开会。
* 首先根据给出的互相憎恨的图中得到补图。
* 然后就相当于找出不能形成奇圈的点。
* 利用下面两个定理:
* (1)如果一个双连通分量内的某些顶点在一个奇圈中(即双连通分量含有奇圈), 那么这个双连通分量的其他顶点也在某个奇圈中;
* (2)如果一个双连通分量含有奇圈,则他必定不是一个二分图。反过来也成立,这是一个充要条件。
* 所以本题的做法,就是对补图求点双连通分量。然后对于求得的点双连通分量,使用染色法判断是不是二分图,不是二分图,这个双连通分量的点是可以存在的
*/
const int MAXN = 1010;
const int MAXM = 2000010;
struct Edge
{
int to, next;
} edge[MAXM];
int head[MAXN], tot;
int Low[MAXN], DFN[MAXN], Stack[MAXN], Belong[MAXN];
int Index,top;
int block; // 点双连通分量的个数
bool Instack[MAXN];
bool can[MAXN];
bool ok[MAXN]; // 标记
int tmp[MAXN]; // 暂时存储双连通分量中的点
int cc; // tmp的计数
int color[MAXN];// 染色
void addedge(int u, int v)
{
edge[tot].to = v;
edge[tot].next = head[u];
head[u] = tot++;
return ;
}
bool dfs(int u, int col) // 染色判断二分图
{
color[u] = col;
for (int i = head[u]; i != -1; i = edge[i].next)
{
int v = edge[i].to;
if (!ok[v])
{
continue;
}
if (color[v] != -1)
{
if (color[v]==col)
{
return false;
}
continue;
}
if (!dfs(v,!col))
{
return false;
}
}
return true;
}
void Tarjan(int u, int pre)
{
int v;
Low[u] = DFN[u] = ++Index;
Stack[top++] = u;
Instack[u] = true;
for (int i = head[u]; i != -1; i = edge[i].next)
{
v = edge[i].to;
if (v == pre)
{
continue;
}
if (!DFN[v])
{
Tarjan(v, u);
if (Low[u] > Low[v])
{
Low[u] = Low[v];
}
if (Low[v] >= DFN[u])
{
block++;
int vn;
cc = 0;
memset(ok, false, sizeof(ok));
do
{
vn = Stack[--top];
Belong[vn] = block;
Instack[vn] = false;
ok[vn] = true;
tmp[cc++] = vn;
}
while (vn!=v);
ok[u] = 1;
memset(color, -1, sizeof(color));
if (!dfs(u,0))
{
can[u] = true;
while (cc--)
{
can[tmp[cc]] = true;
}
}
}
}
else if (Instack[v] && Low[u] > DFN[v])
{
Low[u] = DFN[v];
}
}
}
void solve(int n)
{
memset(DFN, 0, sizeof(DFN));
memset(Instack, false, sizeof(Instack));
Index = block = top = 0;
memset(can, false, sizeof(can));
for (int i = 1; i <= n; i++)
{
if (!DFN[i])
{
Tarjan(i, -1);
}
}
int ans = n;
for (int i = 1; i <= n; i++)
{
if(can[i])
{
ans--;
}
}
printf("%d\n", ans);
}
void init()
{
tot = 0;
memset(head, -1, sizeof(head));
}
int g[MAXN][MAXN];
int main()
{
int n, m;
int u, v;
while (scanf("%d%d", &n, &m) == 2)
{
if (n == 0 && m == 0)
{
break;
}
init();
memset(g, 0, sizeof(g));
while (m--)
{
scanf("%d%d", &u, &v);
g[u][v] = g[v][u] = 1;
}
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= n; j++)
{
if(i != j && g[i][j] == 0)
{
addedge(i, j);
}
}
}
solve(n);
}
return 0;
}
================================================
FILE: ACM 模板代码/f-取第k个元素/f-取第k个元素/main.cpp
================================================
//
// main.cpp
// f-取第k个元素
//
// Created by ZYJ on 16/7/22.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
/*
* 取第k个元素
* k = 0 ... n - 1,平均复杂度O(n) 注意a[]中的顺序被改变
*/
#define _cp(a,b) ((a) < (b))
typedef int elem_t;
elem_t kth_element(int n, elem_t *a, int k)
{ // a[0 ... n-1]
elem_t t, key;
int l = 0, r = n - 1, i, j;
while (l < r)
{
for (key = a[((i = l - 1) + (j = r + 1)) >> 1]; i < j;)
{
for (j--; _cp(key, a[j]); j--);
for (i++; _cp(a[i], key); i++);
if (i < j)
{
t = a[i], a[i] = a[j], a[j] = t;
}
}
if (k>j)
{
l = j + 1;
}
else
{
r = j;
}
}
return a[k];
}
================================================
FILE: ACM 模板代码/f-合数相关/f-合数相关/main.cpp
================================================
//
// main.cpp
// f-合数相关
//
// Created by ZYJ on 16/7/1.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
using namespace std;
// 合数分解
/*
* 合数的分解需要先进行素数的筛选
*/
const int MAXN = 10000;
int prime[MAXN + 1];
// 获取素数
void gerPrime()
{
memset(prime, 0, sizeof(prime));
for (int i = 2; i <= MAXN; i++)
{
if (!prime[i])
{
prime[++prime[0]] = i;
}
for (int j = 1; j <= prime[0] && prime[j] <= MAXN / i; j++)
{
prime[prime[j] * i] = 1;
if (i % prime[j] == 0)
{
break;
}
}
}
return ;
}
long long factor[100][2];
int fatCnt;
// 合数分解
int gerFactors(long long x)
{
fatCnt = 0;
long long tmp = x;
for (int i = 1; prime[i] <= tmp / prime[i]; i++)
{
factor[fatCnt][1] = 0;
if (tmp % prime[i] == 0)
{
factor[fatCnt][0] = prime[i];
while (tmp % prime[i] == 0)
{
factor[fatCnt][1]++;
tmp /= prime[i];
}
fatCnt++;
}
}
if (tmp != 1)
{
factor[fatCnt][0] = tmp;
factor[fatCnt++][1] = 1;
}
return fatCnt;
}
int main(int argc, const char * argv[])
{
std::cout << "Hello, World!\n";
return 0;
}
================================================
FILE: ACM 模板代码/f-后缀数组/f-后缀数组/main.cpp
================================================
//
// main.cpp
// f-后缀数组
//
// Created by ZYJ on 16/7/12.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
using namespace std;
// DA算法
///*
// * suffix array
// * 倍增算法 O(n*logn)
// * 待排序数组长度为n,放在0~n-1中,在最后面补一个0
// * da(str, n + 1, sa, rank, height, n, m); 注意是n+1;
// * 例如:
// * n = 8;
// * num[] = { 1, 1, 2, 1, 1, 1, 1, 2, $ }; 注意num最后一位为0,其他大于0
// * rank[] = { 4, 6, 8, 1, 2, 3, 5, 7, 0 }; rank[0~n-1]为有效值,rank[n]必定为0无效值
// * sa[] = { 8, 3, 4, 5, 0, 6, 1, 7, 2 }; sa[1~n]为有效值,sa[0]必定为n是无效值
// * height[]= { 0, 0, 3, 2, 3, 1, 2, 0, 1 }; height[2~n]为有效值
// */
//const int MAXN = 20010;
//
//int t1[MAXN];
//int t2[MAXN];
//int c[MAXN]; // 求SA数组需要的中间变量,不需要赋值
//
//// 待排序的字符串放在s数组中,从s[0]到s[n-1],长度为n,且最大值小于m,
//// 除s[n-1]外的所有s[i]都大于0,r[n-1]=0
//// 函数结束以后结果放在sa数组中
//bool cmp(int *r, int a, int b, int l)
//{
// return r[a] == r[b] && r[a + l] == r[b + l];
//}
//
//void da(int str[], int sa[], int rank[], int height[], int n, int m)
//{
// n++;
// int i, j, p, *x = t1, *y = t2; // 第一轮基数排序,如果s的最大值很大,可改为快速排序
// for (i = 0; i < m; i++)
// {
// c[i] = 0;
// }
// for (i = 0; i < n; i++)
// {
// c[x[i] = str[i]]++;
// }
// for (i = 1; i < m; i++)
// {
// c[i] += c[i-1];
// }
// for (i = n - 1; i >= 0; i--)
// {
// sa[--c[x[i]]] = i;
// }
// for (j = 1; j <= n; j <<= 1)
// {
// p = 0;
// // 直接利用sa数组排序第二关键字
// for (i = n - j; i < n; i++)
// {
// y[p++] = i; // 后面的j个数第二关键字为空的最小
// }
// for (i = 0; i < n; i++)
// {
// if (sa[i] >= j)
// {
// y[p++] = sa[i] - j; // 这样数组y保存的就是按照第二关键字排序的结果
// }
// }
// // 基数排序第一关键字
// for (i = 0; i < m; i++)
// {
// c[i] = 0;
// }
// for (i = 0; i < n; i++)
// {
// c[x[y[i]]]++;
// }
// for (i = 1; i < m; i++)
// {
// c[i] += c[i - 1];
// }
// for (i = n - 1; i >= 0; i--)
// {
// sa[--c[x[y[i]]]] = y[i]; // 根据sa和x数组计算新的x数组
// }
// swap(x, y);
// p = 1;
// x[sa[0]] = 0;
// for (i = 1; i < n; i++)
// {
// x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;
// }
// if (p >= n)
// {
// break;
// }
// m = p; // 下次基数排序的最大值
// }
// int k = 0;
// n--;
// for (i = 0; i <= n; i++)
// {
// rank[sa[i]] = i;
// }
// for (i = 0; i < n; i++)
// {
// if (k)
// {
// k--;
// }
// j = sa[rank[i] - 1];
// while (str[i + k] == str[j + k])
// {
// k++;
// }
// height[rank[i]] = k;
// }
//}
//
//int _rank[MAXN], height[MAXN];
//int RMQ[MAXN];
//int mm[MAXN];
//
//int best[20][MAXN];
//
//void initRMQ(int n)
//{
// mm[0] = -1;
// for (int i = 1; i <= n; i++)
// {
// mm[i] = ((i & (i - 1)) == 0) ? mm[i - 1] + 1 : mm[i - 1];
// }
// for (int i = 1; i <= n; i++)
// {
// best[0][i] = i;
// }
// for (int i = 1; i <= mm[n]; i++)
// {
// for (int j = 1; j + (1 << i) - 1 <= n; j++)
// {
// int a = best[i - 1][j];
// int b = best[i - 1][j + (1 << (i - 1))];
// if (RMQ[a] < RMQ[b])
// {
// best[i][j] = a;
// }
// else
// {
// best[i][j]=b;
// }
// }
// }
//}
//
//int askRMQ(int a, int b)
//{
// int t;
// t = mm[b - a + 1];
// b -= (1 << t) - 1;
// a = best[t][a];
// b = best[t][b];
// return RMQ[a] < RMQ[b] ? a : b;
//}
//
//int lcp(int a, int b)
//{
// a = _rank[a];
// b = _rank[b];
// if (a > b)
// {
// swap(a,b);
// }
// return height[askRMQ(a + 1, b)];
//}
//
//char str[MAXN];
//int r[MAXN];
//int sa[MAXN];
//
//int main()
//{
// while (scanf("%s", str) == 1)
// {
// int len = (int)strlen(str);
// int n = 2 * len + 1;
// for (int i = 0; i < len; i++)
// {
// r[i] = str[i];
// }
// for (int i = 0; i < len; i++)
// {
// r[len + 1 + i] = str[len - 1 - i];
// }
// r[len] = 1;
// r[n] = 0;
// da(r, sa, _rank, height, n, 128);
// for (int i = 1; i <= n; i++)
// {
// RMQ[i]=height[i];
// }
// initRMQ(n);
// int ans = 0, st = 0;
// int tmp;
// for (int i = 0; i < len; i++)
// {
// tmp = lcp(i, n - i); // 偶对称
// if (2 * tmp > ans)
// {
// ans = 2 * tmp;
// st = i - tmp;
// }
// tmp=lcp(i, n - i - 1); // 奇数对称
// if (2 * tmp - 1 > ans)
// {
// ans = 2 * tmp - 1;
// st = i - tmp + 1;
// }
// }
// str[st + ans] = 0;
// printf("%s\n", str + st);
// }
// return 0;
//}
// DC3算法
/*
* 后缀数组
* DC3算法,复杂度O(n)
* 所有的相关数组都要开三倍
*/
const int MAXN = 2010;
#define F(x) ((x) / 3 + ((x) % 3 == 1 ? 0 : tb))
#define G(x) ((x) < tb ? (x) * 3 + 1 : ((x)-tb) * 3 + 2)
int wa[MAXN * 3], wb[MAXN * 3], wv[MAXN * 3], wss[MAXN * 3];
int c0(int *r, int a, int b)
{
return r[a] == r[b] && r[a + 1] == r[b + 1] && r[a + 2] == r[b + 2];
}
int c12(int k, int *r, int a, int b)
{
if(k == 2)
{
return r[a] < r[b] || (r[a] == r[b] && c12(1, r, a + 1, b + 1));
}
else
{
return r[a] < r[b] || (r[a] == r[b] && wv[a + 1] < wv[b + 1]);
}
}
void sort(int *r, int *a, int *b, int n, int m)
{
int i;
for (i = 0; i < n; i++)
{
wv[i] = r[a[i]];
}
for (i = 0; i < m; i++)
{
wss[i] = 0;
}
for (i = 0; i < n; i++)
{
wss[wv[i]]++;
}
for (i = 1; i < m; i++)
{
wss[i] += wss[i - 1];
}
for (i = n - 1; i >= 0; i--)
{
b[--wss[wv[i]]] = a[i];
}
}
void dc3(int *r, int *sa, int n, int m)
{
int i, j, *rn = r + n;
int *san = sa + n, ta = 0, tb = (n+1)/3, tbc = 0, p;
r[n] = r[n+1] = 0;
for (i = 0; i < n; i++)
{
if (i % 3 != 0)
{
wa[tbc++] = i;
}
}
sort(r + 2, wa, wb, tbc, m);
sort(r + 1, wb, wa, tbc, m);
sort(r, wa, wb, tbc, m);
for (p = 1, rn[F(wb[0])] = 0, i = 1; i < tbc; i++)
{
rn[F(wb[i])] = c0(r, wb[i - 1], wb[i]) ? p - 1 : p++;
}
if (p < tbc)
{
dc3(rn, san, tbc, p);
}
else
{
for (i = 0; i < tbc; i++)
{
san[rn[i]] = i;
}
}
for (i = 0; i < tbc; i++)
{
if (san[i] < tb)
{
wb[ta++] = san[i] * 3;
}
}
if (n % 3 == 1)
{
wb[ta++] = n - 1;
}
sort(r, wb, wa, ta, m);
for (i = 0; i < tbc; i++)
{
wv[wb[i] = G(san[i])] = i;
}
for (i = 0, j = 0, p = 0; i < ta && j < tbc; p++)
{
sa[p] = c12(wb[j] % 3, r, wa[i], wb[j]) ? wa[i++] : wb[j++];
}
for (; i < ta; p++)
{
sa[p] = wa[i++];
}
for (; j < tbc; p++)
{
sa[p] = wb[j++];
}
}
// str和sa也要三倍
void da(int str[], int sa[], int rank[], int height[], int n,int m)
{
for (int i = n; i < n * 3; i++)
{
str[i] = 0;
}
dc3(str, sa, n+1, m);
int i, j, k = 0;
for (i = 0; i <= n; i++)
{
rank[sa[i]] = i;
}
for (i = 0; i < n; i++)
{
if(k)
{
k--;
}
j = sa[rank[i] - 1];
while (str[i + k] == str[j + k])
{
k++;
}
height[rank[i]] = k;
}
}
================================================
FILE: ACM 模板代码/f-后缀自动机/f-后缀自动机/main.cpp
================================================
//
// main.cpp
// f-后缀自动机
//
// Created by ZYJ on 16/7/12.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
const int CHAR = 26;
const int MAXN = 250010;
struct SAM_Node
{
SAM_Node *fa, *next[CHAR];
int len;
int id, pos;
SAM_Node(){}
SAM_Node(int _len)
{
fa = 0;
len = _len;
memset(next, 0, sizeof(next));
}
};
SAM_Node SAM_node[MAXN * 2], *SAM_root, *SAM_last;
int SAM_size;
SAM_Node *newSAM_Node(int len)
{
SAM_node[SAM_size] = SAM_Node(len);
SAM_node[SAM_size].id = SAM_size;
return &SAM_node[SAM_size++];
}
SAM_Node *newSAM_Node(SAM_Node *p)
{
SAM_node[SAM_size] = *p; SAM_node[SAM_size].id = SAM_size;
return &SAM_node[SAM_size++];
}
void SAM_init()
{
SAM_size = 0;
SAM_root = SAM_last = newSAM_Node(0);
SAM_node[0].pos = 0;
}
void SAM_add(int x, int len)
{
SAM_Node *p = SAM_last, *np = newSAM_Node(p->len+1);
np->pos = len;
SAM_last = np;
for (; p && !p->next[x]; p = p->fa)
{
p->next[x] = np;
}
if (!p)
{
np->fa = SAM_root;
return;
}
SAM_Node *q = p->next[x];
if (q->len == p->len + 1)
{
np->fa = q;
return ;
}
SAM_Node *nq = newSAM_Node(q);
nq->len = p->len + 1;
q->fa = nq;
np->fa = nq;
for(;p && p->next[x] == q; p = p->fa)
p->next[x] = nq;
}
void SAM_build(char *s)
{
SAM_init();
int len = (int)strlen(s);
for (int i = 0; i < len; i++)
{
SAM_add(s[i] - 'a', i + 1);
}
}
/*
// 加入串后进行拓扑排序
char str[MAXN];
int topocnt[MAXN];
SAM_Node *topsam[MAXN * 2];
int n = (int)strlen(str);
SAM_build(str);
memset(topocnt, 0, sizeof(topocnt));
for (int i = 0; i < SAM_size; i++)
{
topocnt[SAM_node[i].len]++;
}
for (int i = 1; i <= n; i++)
{
topocnt[i] += topocnt[i-1];
}
for (int i = 0; i < SAM_size; i++)
{
topsam[--topocnt[SAM_node[i].len]] = &SAM_node[i];
}
*/
// 多串的建立:
// 多串的建立,注意SAM_init()的调用
//void SAM_build(char *s)
//{
// int len = (int)strlen(s);
// SAM_last = SAM_root;
// for (int i = 0; i < len; i++)
// {
// if (!SAM_last->next[s[i] - '0'] || !(SAM_last->next[s[i] - '0']->len == i+1))
// {
// SAM_add(s[i] - '0',i+1);
// }
// else
// {
// SAM_last = SAM_last->next[s[i] - '0'];
// }
// }
//}
================================================
FILE: ACM 模板代码/f-周期性方程/f-周期性方程/main.cpp
================================================
//
// main.cpp
// f-周期性方程
//
// Created by ZYJ on 16/7/10.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
// 追赶法解周期性方程
/*
* 周期性方程定义(n = 5)
* |a_1 b_1 c_1 d_1 e_1| = x_1 --- 1
* |e_2 a_2 b_2 c_2 d_2| = x_2 --- 2
* |d_2 e_2 a_2 b_2 c_2| = x_3 --- 3
* |c_4 d_2 e_2 a_4 b_4| = x_4 --- 4
* |b_5 c_5 d_5 e_5 a_5| = x_5 --- 5
* 输入： a[], b[], c[], x[]
* 输出： 求解结果x在x[]中
*/
const int MAXN = 1000;
int a[MAXN];
int b[MAXN];
int c[MAXN];
int x[MAXN];
void run()
{
c[0] /= b[0];
a[0] /= b[0];
x[0] /= b[0];
for (int i = 1; i < MAXN - 1; i ++)
{
double temp = b[i] - a[i] * c[i - 1];
c[i] /= temp;
x[i] = (x[i] - a[i] * x[i - 1]) / temp;
a[i] = -a[i] * a[i - 1] / temp;
}
a[MAXN - 2] = -a[MAXN - 2] - c[MAXN - 2];
for (int i = MAXN - 3; i >= 0; i--)
{
a[i] = -a[i] - c[i] * a[i + 1];
x[i] -= c[i] * x[i + 1];
}
x[MAXN - 1] -= (c[MAXN - 1] * x[0] + a[MAXN - 1] * x[MAXN - 2]);
x[MAXN - 1] /= (c[MAXN - 1] * a[0] + a[MAXN - 1] * a[MAXN - 2] + b[MAXN - 1]);
for (int i = MAXN - 2; i >= 0; i --)
{
x[i] += a[i] * x[MAXN - 1];
}
return ;
}
int main(int argc, const char * argv[])
{
return 0;
}
================================================
FILE: ACM 模板代码/f-培训作业/f-培训作业/main.cpp
================================================
//#include<stdio.h>
//#include<string.h>
//#define BG 1000000007
//#define MAXN 2501
//
//typedef long long __int64;
//
//int n,N;
//int X[MAXN*2+1];
//struct D{ __int64 A[MAXN][MAXN]; };
//D a,T,a1,T1,b;
//D operator +(const D &c,const D &a)
//{
// for(int i=0;i<n;i++)
// for(int j=0;j<n;j++)
// b.A[i][j]=(a.A[i][j]+c.A[i][j])%BG;
// return b;
//}
//D operator *(const D &c,const D &a)
//{
// __int64 q1,q2;
// for(int i=0;i<n;i++)
// for(int j=0;j<n;j++)
// {
// b.A[i][j]=0;
// for(int k=0;k<n;k++)
// {
// q1=(__int64)c.A[i][k];
// q2=(__int64)a.A[k][j];
// b.A[i][j]+=(q1*q2%BG);
// b.A[i][j]%=BG;
// }
// }
// return b;
//}
//void slov(int k)
//{
// for(int i=0;i<31;i++)
// {
// if((1<<i)&k)
// {
// a=a*a1;
// T=(T*a1)+(a*T);
// }
// a1=a1*a1;
// T1=(T1*a1)+(a1*T1);
// }
// int u;
// __int64 q1,q2;
// for(int i=0;i<n;i++)
// {
// u=0;
// for(int j=0;j<n;j++)
// {
// q1=(__int64)a.A[i][j];
// q2=(__int64)X[j];
// u+=(int)(q1*q2%BG);
// u%=BG;
// }
// printf("%d\n",u);
// }
// for(int i=n;i<N;i++)
// {
// u=0;
// for(int j=0;j<n;j++)
// {
// q1=(__int64)T.A[i][j];
// q2=(__int64)X[j];
// u+=(int)(q1*q2%BG);
// u%=BG;
// }
// for(int j=n;j<N;j++)
// {
// q1=(__int64)a.A[i][j];
// q2=(__int64)X[j];
// u+=(int)(q1*q2%BG);
// u%=BG;
// }
// printf("%d\n",u);
// }
//}
//int main ()
//{
// int k;
// scanf("%d%d",&N,&k);
// if(N%2==0)n=N/2;
// else n=(N+1)/2;
// for(int i=0;i<N;i++)scanf("%d",X+i);
// for(int i=0;i<n;i++)
// for(int j=0;j<=i;j++)a1.A[i][j]=1;
// for(int i=0;i<n;i++)
// for(int j=0;j<n;j++)T1.A[i][j]=1;
// for(int i=0;i<n;i++)a.A[i][i]=1;
// slov(k);
// return 0;
//}
//
////#include <stdio.h>
////#include <math.h>
////
////int main()
////{
//// int n;
//// while (scanf("%d", &n) == 1)
//// {
//// if (n == 0)
//// {
//// return 0;
//// }
////
//// int digA = n % 10;
//// int digB = n / 10 % 10;
//// int digC = n / 100 % 10;
////// printf("%d %d %d\n", digA, digB, digC);
////
//// if (pow(digA, 3) + pow(digB, 3) + pow(digC, 3) == n)
//// {
//// printf("Yes\n");
//// }
//// else
//// {
//// printf("No\n");
//// }
//// }
////
//// return 0;
////}
//#include<stdio.h>
//
//int main()
//{
// int a, b, c, n;
// a = 1;
// b = 1;
// printf("%d\n%d\n", a, b);
//
// for (n = 2; n < 30; n++)
// {
// c = a + b;
// a = b;
// b = c;
// printf("%d\n", c);
// }
// return 0;
//}
#include<stdio.h>
#include<algorithm>
#include<cstring>
#include<vector>
#include<cmath>
#define pb push_back
#define P 63
#define Mo 1000000007
using namespace std;
typedef long long ll;
const int mod=Mo;
void jia(long long &x,long long y) { x+=y; if (x>=Mo) x-=Mo; }
long long i,j,p,k,A[P+5][P+5],E[P+5],Maxp;
long long pr[20005],MA[20005];
vector<long long>v[P],va[P],vb[P],vr[P];
ll modAdd(ll a, ll b) {
a += b;
return a>=mod? (a - mod) : a;
}
ll modMul(ll a , ll b) {
a *= b;
return a>=mod ? (a%mod) : a;
}
void multiply(const vector<ll> &Q, vector<ll> &Qr) {
int size = Qr.size();
for(int i = 0 ; i< size; i++) {
Qr[i] = 0;
for(int j = max(0 , 2*i - size +1 ); j<min( size, (2*i + 1)) ; j++) {
int x = (j&1) ? ( (mod-Q[j]) ) : (Q[j]) ;
int y = modMul(x, Q[2*i - j]);
Qr[i] = modAdd(Qr[i], y );
}
}
}
void cal(long long *A,long long n,long long k,long long *C)
{
vector<ll> Q(k+3);
vector<ll> Qr(k+3);
n--;
while( n >= k) {
Q[0] = 1;
for(int i=0; i<k; i++) {
Q[i+1] = -C[i];
if(Q[i+1] < 0) {
Q[i+1] += mod;
}
}
for(int i=k; i< (2*k); i++) {
A[i] = 0;
for(int j = 0; j < k; j++) {
int add = modMul( A[i-1-j] , C[j] );
A[i] = modAdd(A[i], add);
}
}
multiply(Q, Qr);
for(int i=0; i<k; i++) {
C[i] = (-Qr[i+1]);
if(C[i] < 0) {
C[i] += mod;
}
}
int offset = n & 1;
for(int i=0; i<k; i++) {
A[i] = A[2*i + offset];
}
n /= 2;
}
printf("%lld\n",A[n]);
}
int power(int x,int y)
{
int sum=1;
for (;y;y>>=1)
{
if (y&1) sum=1ll*sum*x%Mo;
x=1ll*x*x%Mo;
}
return sum;
}
void guass(int n)
{
int i,j,k;
for (i=1;i<=n;++i)
{
for (j=i;j<=n;++j) if (A[j][i]) break;
for (k=1;k<=n+1;++k) swap(A[i][k],A[j][k]);
int p=power(A[i][i],Mo-2);
for (j=i+1;j<=n;++j)
if (A[j][i])
{
int now=1ll*A[j][i]*p%Mo;
for (k=i;k<=n+1;++k)
jia(A[j][k],Mo-1ll*A[i][k]*now%Mo);
}
}
for (i=n;i;--i)
{
for (j=i+1;j<=n;++j) jia(A[i][n+1],Mo-1ll*A[i][j]*E[j]%Mo);
E[i]=1ll*A[i][n+1]*power(A[i][i],Mo-2)%Mo;
}
}
long long n,m,sA[P],sB[P];
int Count(vector<long long> A,long long R)
{
long long i,j,sum=0; R%=Mo;
for (i=0;i<(int)A.size();++i)
{
long long S=0,now=1;
for (j=0;j<(int)vr[i].size();++j)
jia(S,1ll*vr[i][j]*now%Mo),now=1ll*now*R%Mo;
jia(sum,1ll*S*A[i]%Mo);
}
return sum;
}
int main()
{
for (i=0;i<P;++i)
{
memset(A,0,sizeof(A));
for (j=1;j<=i+2;++j)
{
for (k=1;k<=i+2;++k) A[j][k]=power(j,k-1);
A[j][i+3]=power(2*j-1,i);
jia(A[j][i+3],A[j-1][i+3]);
if (j>1)
jia(A[j][i+3],power(2*j-2,i));
}
guass(i+2);
for (j=1;j<=i+2;++j) v[i].pb(E[j]);
}
for (i=0;i<P;++i)
{
memset(A,0,sizeof(A));
for (j=1;j<=i+2;++j)
{
for (k=1;k<=i+2;++k) A[j][k]=power(j,k-1);
A[j][i+3]=power(j,i);
(A[j][i+3]+=A[j-1][i+3])%=Mo;
}
guass(i+2);
for (j=1;j<=i+2;++j) vr[i].pb(E[j]);
}
int T;
scanf("%d",&T);
for (;T--;)
{
scanf("%lld%lld",&n,&m);
Maxp=(int)(log2(n)+1);
memset(sA,0,sizeof(sA)); memset(sB,0,sizeof(sB));
for (i=1;i<=Maxp;++i) va[i].clear(),vb[i].clear();
sA[1]=n/2; sB[1]=n; vb[1].pb(1);
for (i=2;i<=Maxp;++i)
{
sA[i]=sA[i-1]/2; sB[i]=sB[i-1]/2;
int str=Count(vb[i-1],sB[i-1]);
for (j=0;j<i;++j) vb[i].pb(0),va[i].pb(0);
vb[i][0]=str;
for (j=0;j<(int)vb[i-1].size();++j)
{
int wei=(Mo-vb[i-1][j]);
for (k=0;k<(int)v[j].size();++k)
jia(vb[i][k],1ll*wei*v[j][k]%Mo);
}
int End=Count(vb[i-1],sA[i-1]);
va[i][0]=(str-End+Mo)%Mo;
jia(va[i][0],Count(va[i-1],sA[i-1]));
for (j=0;j<(int)va[i-1].size();++j)
{
int wei=(Mo-va[i-1][j]);
for (k=0;k<(int)v[j].size();++k)
jia(va[i][k],1ll*wei*v[j][k]%Mo);
}
}
for (i=1;i<=Maxp;++i)
{
pr[i]=Count(va[i],sA[i]);
jia(pr[i],Count(vb[i],sB[i]));
jia(pr[i],Mo-Count(vb[i],sA[i]));
}
memset(MA,0,sizeof(MA));
MA[0]=1;
for (i=1;i<Maxp;++i)
for (j=1;j<=i;++j)
jia(MA[i],1ll*MA[i-j]*pr[j]%Mo);
for (i=0;i<Maxp;++i) swap(pr[i],pr[i+1]);
if (m<Maxp) printf("%d\n",MA[m]);
else cal(MA,m+1,Maxp,pr);
}
}
================================================
FILE: ACM 模板代码/f-堆/f-堆/main.cpp
================================================
//
// main.cpp
// f-堆
//
// Created by ZYJ on 2017/7/25.
// Copyright © 2017年 ZYJ. All rights reserved.
//
#include <iostream>
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <queue>
using namespace std;
const int MAXN = 200000;
int A[MAXN]; // 20w空数组符合要求
template <class T>
inline void scan_d(T &ret)
{
char c;
ret = 0;
while ((c = getchar()) < '0' || c > '9');
while (c >= '0' && c <= '9')
{
ret = ret * 10 + (c - '0'), c = getchar();
}
}
priority_queue<int> qi;
int main(int argc, const char * argv[])
{
clock_t start, finish;
start = clock();
freopen("/Users/zyj/Desktop/output.txt", "r", stdin);
for (int i = 1; i <= MAXN; i++)
{
scan_d(A[i]);
qi.push(A[i]); // 堆排,符合要求
}
finish = clock();
cout << finish - start << '\n';
return 0;
}
================================================
FILE: ACM 模板代码/f-堆栈/f-堆栈/main.cpp
================================================
//
// main.cpp
// f-堆栈
//
// Created by ZYJ on 16/7/23.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
const int MAXSIZE = 10000;
int a[MAXSIZE], heapsize;
inline void swap(int i, int j)
{
int temp = a[i];
a[i] = a[j];
a[j] = temp;
return ;
}
inline int Parent(int i)
{
return i >> 1;
}
inline int Left(int i)
{
return 1 << i;
}
inline int Right(int i)
{
return (1 << i) + 1; // 保持堆的性质
}
void MaxHeapify(int i)
{
int l = Left(i), r = Right(i), largest;
if (l <= heapsize && a[l] > a[i])
{
largest = l;
}
else
{
largest = i;
}
if (r <= heapsize && a[r] > a[largest])
{
largest = r;
}
if (largest != i)
{
swap(i, largest);
MaxHeapify(largest);
}
return ;
}
void BuildMaxHeap(int *arr, int n)
{
heapsize = n;
for (int i = heapsize / 2; i > 0; --i)
{
MaxHeapify(i);
}
return ;
}
void HeapSort(int *arr, int n)
{
BuildMaxHeap(arr, n);
for (int i = n; i > 1; --i)
{
swap(1, i);
heapsize--;
MaxHeapify(1);
}
return ;
}
================================================
FILE: ACM 模板代码/f-多项式求根（牛顿法）/f-多项式求根（牛顿法）/main.cpp
================================================
//
// main.cpp
// f-多项式求根（牛顿法）
//
// Created by ZYJ on 16/7/10.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
using namespace std;
/*
* 牛顿法解多项式的根
* 输入:多项式系数 c[],多项式度数 n,求在[a,b]间的根
* 输出:根 要求保证[a,b]间有根
*/
double fabs(double x)
{
return (x < 0) ? -x : x;
}
double f(int m, double c[], double x)
{
int i;
double p = c[m];
for (i = m; i > 0; i--)
{
p = p * x + c[i - 1];
}
return p;
}
int newton(double x0, double *r, double c[], double cp[], int n, double a, double b, double eps)
{
int MAX_ITERATION = 1000;
int i = 1;
double x1, x2, fp, eps2 = eps / 10.0;
x1 = x0;
while (i < MAX_ITERATION)
{
x2 = f(n, c, x1);
fp = f(n - 1, cp, x1);
if ((fabs(fp) < 0.000000001) && (fabs(x2) > 1.0))
{
return 0;
}
x2 = x1 - x2 / fp;
if (fabs(x1 - x2) < eps2)
{
if (x2 < a || x2 > b)
{
return 0;
}
*r = x2;
return 1;
}
x1 = x2;
i++;
}
return 0;
}
double Polynomial_Root(double c[], int n, double a, double b, double eps)
{
double *cp;
int i;
double root;
cp = (double *)calloc(n, sizeof(double));
for (i = n - 1; i >= 0; i--)
{
cp[i] = (i + 1) * c[i + 1];
}
if (a > b)
{
root = a;
a = b;
b = root;
}
if ((!newton(a, &root, c, cp, n, a, b, eps)) && (!newton(b, &root, c, cp, n, a, b, eps)))
{
newton((a + b) * 0.5, &root, c, cp, n, a, b, eps);
}
free(cp);
if (fabs(root) < eps)
{
return fabs(root);
}
else
return root;
}
================================================
FILE: ACM 模板代码/f-大数取模的二进制方法/f-大数取模的二进制方法/main.cpp
================================================
//
// main.cpp
// f-大数取模的二进制方法
//
// Created by ZYJ on 16/7/10.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
/*
* 求a^b mod c
* 把b化成二进制串的形式: b = (a[t] a[t-1] a[t-2] ... a[1] a[0])
* 那么有: b = a[t]*2^t + a[t-1]*2^(t-1) + ... ... + a[1]*2^1 + a[0]*2^0, 其中 a[i]=0,1
* 则:a^b mod c = a^(a[t]*2^t + a[t-1]*2^(t-1) + ... ... + a[1]*2^1 + a[0]*2^0) mod c
* = ((a^(a[0]*2^0) mod c) * a^(a[]1*2^1) mod c) ... ... 注意到: a^(2^(i+1))mod c = (a^
* (2^i) mod c)^2 mod c,这样就可以在常数项时间内由2^i项推出2^(i+1)项。时间复杂度为O((logb)^3).
*/
int mod_exp(int a, int b_0, int n) //return a^b0 % n
{
if (a > n)
{
a %= n;
}
int i, d = 1, b[35];
for (i = 0; i < 35; i++)
{
b[i] = b_0 % 2;
b_0 /= 2;
if(b_0 == 0)
{
break;
}
}
//b[i]b[i-1]...b[0]为b_0的二进制表示
for (; i >= 0; i++)
{
d = (d * d) % n;
if (b[i] == 1)
{
d = (d * a) % n;
}
}
return d;
}
int main(int argc, const char * argv[]) {
// insert code here...
std::cout << "Hello, World!\n";
return 0;
}
================================================
FILE: ACM 模板代码/f-大数平方根（字符串数组表示）/f-大数平方根（字符串数组表示）/main.cpp
================================================
//
// main.cpp
// f-大数平方根（字符串数组表示）
//
// Created by ZYJ on 16/7/10.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
using namespace std;
void Sqrt(char *str)
{
double i, r, n;
int j, l, size, num, x[1000];
size = (int)strlen(str);
if (size == 1 && str[0] == '0')
{
cout << "0\n";
return;
}
if (size % 2 == 1)
{
n = str[0] - 48;
l = -1;
}
else
{
n = (str[0] - 48) * 10 + str[1] - 48;
l = 0;
}
r = 0;
num = 0;
while (true)
{
i = 0;
while (i * (i + 20 * r) <= n)
{
i++;
}
i--;
n -= i * (i + 20 * r);
r = r * 10 + i;
x[num] = (int)i;
num++;
l += 2;
if (l >= size)
{
break;
}
n = n * 100 + (double)(str[l] - 48) * 10 + (double)(str[l + 1] - 48);
}
for(j = 0; j < num; j++)
{
cout << x[j];
}
putchar('\n');
}
int main(int argc, const char * argv[])
{
// insert code here...
std::cout << "Hello, World!\n";
return 0;
}
================================================
FILE: ACM 模板代码/f-大数运算/f-大数运算/main.cpp
================================================
//
// main.cpp
// f-大数运算
//
// Created by ZYJ on 16/7/22.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
// 高效大数运算
/*
* < , <= , + , - , * , / , %(修改/的最后一行可得)
*/
//const int base = 10000; // (base^2) fit into int
//const int width = 4; // width = log base
//const int N = 1000; // n * width: 可表示的最大位数
//
//struct bint
//{
// int ln, v[N];
// bint (int r = 0)
// {
// // r应该是字符串!
// for (ln = 0; r > 0; r /= base)
// {
// v[ln++] = r % base;
// }
// }
// bint &operator = (const bint &r)
// {
// memcpy(this, &r, (r.ln + 1) * sizeof(int));
// return *this;
// }
//};
//
//bool operator < (const bint &a, const bint &b)
//{
// int i;
// if (a.ln != b.ln)
// {
// return a.ln < b.ln;
// }
// for (i = a.ln - 1; i >= 0 && a.v[i] == b.v[i]; i--);
// return i < 0 ? 0 : a.v[i] < b.v[i];
//}
//
//bool operator <= (const bint &a, const bint &b)
//{
// return !(b < a);
//}
//
//bint operator + (const bint &a, const bint &b)
//{
// bint res;
// int i, cy = 0;
// for (i = 0; i < a.ln || i < b.ln || cy > 0; i++)
// {
// if (i < a.ln)
// {
// cy += a.v[i];
// }
// if (i < b.ln)
// {
// cy += b.v[i];
// }
// res.v[i] = cy % base;
// cy /= base;
// }
// res.ln = i;
// return res;
//}
//
//bint operator - (const bint &a, const bint &b)
//{
// bint res;
// int i, cy = 0;
// for (res.ln = a.ln, i = 0; i < res.ln; i++)
// {
// res.v[i] = a.v[i] - cy;
// if (i < b.ln)
// {
// res.v[i] -= b.v[i];
// }
// if (res.v[i] < 0)
// {
// cy = 1, res.v[i] += base;
// }
// else
// {
// cy = 0;
// }
// }
// while (res.ln > 0 && res.v[res.ln - 1] == 0)
// {
// res.ln--;
// }
// return res;
//}
//
//bint operator * (const bint &a, const bint &b)
//{
// bint res;
// res.ln = 0;
// if (0 == b.ln)
// {
// res.v[0] = 0;
// return res;
// }
// int i, j, cy;
// for (i = 0; i < a.ln; i++)
// {
// for (j = cy = 0; j < b.ln || cy > 0; j++, cy /= base)
// {
// if (j < b.ln)
// {
// cy += a.v[i] * b.v[j];
// }
// if (i + j < res.ln)
// {
// cy += res.v[i + j];
// }
// if (i + j >= res.ln)
// {
// res.v[res.ln++] = cy % base;
// }
// else
// {
// res.v[i + j] = cy % base;
// }
// }
// }
// return res;
//}
//
//bint operator / (const bint &a, const bint &b)
//{ // !b != 0
// bint tmp, mod, res;
// int i, lf, rg, mid;
// mod.v[0] = mod.ln = 0;
// for (i = a.ln - 1; i >= 0; i--)
// {
// mod = mod * base + a.v[i];
// for (lf = 0, rg = base -1; lf < rg;)
// {
// mid = (lf + rg + 1) / 2;
// if (b * mid <= mod)
// {
// lf = mid;
// }
// else
// {
// rg = mid - 1;
// }
// }
// res.v[i] = lf;
// mod = mod - b * lf;
// }
// res.ln = a.ln;
// while (res.ln > 0 && res.v[res.ln - 1] == 0)
// {
// res.ln--;
// }
// return res; // return mod 就是%运算
//}
//
//int digits(bint& a) // 返回位数
//{
// if (a.ln == 0)
// {
// return 0;
// }
// int l = (a.ln - 1) * 4;
// for (int t = a.v[a.ln - 1]; t; ++l, t /= 10);
// return l;
//}
//
//bool read(bint &b, char buf[]) // 读取失败返回0
//{
// if (1 != scanf("%s", buf))
// {
// return 0;
// }
// int w, u, ln = (int)strlen(buf);
// memset(&b, 0, sizeof(bint));
// if ('0' == buf[0] && 0 == buf[1])
// {
// return 1;
// }
// for (w = 1, u = 0; ln;)
// {
// u += (buf[--ln] - '0') * w;
// if (w * 10 == base)
// {
// // ...
// }
// else
// {
// w *= 10;
// }
// }
// if (w != 1)
// {
// b.v[b.ln++] = u;
// }
// return 1;
//}
//
//void write(const bint &v)
//{
// int i;
// printf("%d", v.ln == 0 ? 0 : v.v[v.ln - 1]);
// for (i = v.ln - 2; i >= 0; i--)
// {
// printf("%04d", v.v[i]); // !4 == width
// }
// printf("\n");
// return ;
//}
// 普通大数运算
const int MAXSIZE = 200;
void Add(char *str1, char *str2, char *str3);
void Minus(char *str1, char *str2, char *str3);
void Mul(char *str1, char *str2, char *str3);
void Div(char *str1, char *str2, char *str3);
int main()
{
char str1[MAXSIZE], str2[MAXSIZE], str3[MAXSIZE];
while (scanf("%s %s", str1, str2) == 2)
{
if (strcmp(str1, "0"))
{
memset(str3, '0', sizeof(str3));
Add(str1, str2, str3);
printf("%s\n", str3);
memset(str3, '0', sizeof(str3));
Minus(str1, str2, str3);
printf("%s\n", str3);
memset(str3, '0', sizeof(str3));
Mul(str1, str2, str3);
printf("%s\n", str3);
memset(str3, '0', sizeof(str3));
Div(str1, str2, str3);
printf("%s\n", str3);
}
else
{
if (strcmp(str2, "0"))
{
printf("%s\n-%s\n0\n0\n", str2, str2);
}
else
{
printf("0\n0\n0\n0\n");
}
}
}
return 0;
}
void Add(char *str1, char *str2, char *str3)
{ // str3 = str1 + str2;
int i, j, i1, i2, tmp, carry;
int len1 = (int)strlen(str1), len2 = (int)strlen(str2);
char ch;
i1 = len1 - 1;
i2 = len2 - 1;
j = carry = 0;
for (; i1 >= 0 && i2 >= 0; ++j, --i1, --i2)
{
tmp = str1[i1] - '0' + str2[i2] - '0' + carry;
carry = tmp / 10;
str3[j] = tmp % 10 + '0';
}
while (i1 >= 0)
{
tmp = str1[i1--] - '0' + carry;
carry = tmp / 10;
str3[j++] = tmp % 10 + '0';
}
while (i2 >= 0)
{
tmp = str2[i2--] - '0' + carry;
carry = tmp / 10;
str3[j++] = tmp % 10 + '0';
}
if (carry)
{
str3[j++] = carry + '0';
}
str3[j] = '\0';
for (i = 0, --j; i < j; ++i, --j)
{
ch = str3[i];
str3[i] = str3[j];
str3[j] = ch;
}
return ;
}
void Minus(char *str1, char *str2, char *str3)
{ // str3 = str1-str2 (str1 > str2)
int i, j, i1, i2, tmp, carry;
int len1 = (int)strlen(str1), len2 = (int)strlen(str2);
char ch;
i1 = len1 - 1;
i2 = len2 - 1;
j = carry = 0;
while (i2 >= 0)
{
tmp = str1[i1] - str2[i2] - carry;
if (tmp < 0)
{
str3[j] = tmp + 10 + '0';
carry = 1;
}
else
{
str3[j] = tmp + '0';
carry = 0;
}
i1--;
i2--;
j++;
}
while (i1 >= 0)
{
tmp = str1[i1] - '0' - carry;
if (tmp < 0)
{
str3[j] = tmp + 10 + '0';
carry = 1;
}
else
{
str3[j] = tmp + '0';
carry = 0;
}
--i1;
++j;
}
--j;
while (str3[j] == '0' && j > 0)
{
--j;
}
str3[++j] = '\0';
for (i = 0, --j; i < j; ++i, --j)
{
ch = str3[i];
str3[i] = str3[j];
str3[j] = ch;
}
return ;
}
void Mul(char *str1, char *str2, char *str3)
{
int i, j = 0, i1, i2, tmp, carry, jj;
int len1 = (int)strlen(str1), len2 = (int)strlen(str2);
char ch;
jj = carry = 0;
for (i1 = len1 - 1; i1 >= 0; --i1)
{
j = jj;
for (i2 = len2 - 1; i2 >= 0; --i2, ++j)
{
tmp = (str3[j] - '0') + (str1[i1] - '0') * (str2[i2] - '0') + carry;
if (tmp > 9)
{
carry = tmp / 10;
str3[j] = tmp % 10 + '0';
}
else
{
str3[j] = tmp + '0';
carry = 0;
}
}
if (carry)
{
str3[j] = carry + '0';
carry = 0;
j++;
}
jj++;
}
j--;
while (str3[j] == '0' && j > 0)
{
j--;
}
str3[++j] = '\0';
for (i = 0, --j; i < j; ++i, --j)
{
ch = str3[i];
str3[i] = str3[j];
str3[j] = ch;
}
return ;
}
void Div(char *str1, char *str2, char *str3)
{
int i1, i2, i, j, jj = 0, tag, carry, cf, c[MAXSIZE];
int len1 = (int)strlen(str1), len2 = (int)strlen(str2), lend;
char d[MAXSIZE];
memset(c, 0, sizeof(c));
memcpy(d, str1, len2);
lend = len2;
j = 0;
for (i1 = len2 - 1; i1 < len1; ++i1)
{
if (lend < len2)
{
d[lend] = str1[i1+1];
c[j] = 0;
++j;
++lend;
}
else if (lend == len2)
{
jj = 1;
for (i = 0; i < lend; ++i)
{
if (d[i] > str2[i])
{
break;
}
else if (d[i] < str2[i])
{
jj = 0;
break;
}
}
if (jj == 0)
{
d[lend] = str1[i1+1];
c[j] = 0;
++j;
++lend;
continue;
}
}
if (jj == 1 || lend > len2)
{
cf = jj = 0;
while (d[jj] <= '0' && jj < lend)
{
++jj;
}
if (lend - jj > len2)
{
cf = 1;
}
else if (lend - jj < len2)
{
cf = 0;
}
else
{
i2 = 0;
cf = 1;
for (i = jj; i < lend; ++i)
{
if (d[i] < str2[i2])
{
cf = 0;
break;
}
else if (d[i] > str2[i2])
{
break;
}
++i2;
}
}
while (cf)
{
i2 = len2 - 1;
cf = 0;
for (i = lend - 1; i >= lend - len2; --i)
{
d[i] = d[i] - str2[i2] + '0';
if (d[i] < '0')
{
d[i] = d[i] + 10;
carry = 1;
--d[i - 1];
}
else
{
carry = 0;
}
--i2;
}
++c[j];
jj = 0;
while (d[jj] <= '0' && jj < lend)
{
++jj;
}
if (lend - jj > len2)
{
cf = 1;
}
else if (lend - jj < len2)
{
cf = 0;
}
else
{
i2 = 0;
cf = 1;
for (i = jj; i < lend; ++i)
{
if (d[i] < str2[i2])
{
cf = 0;
break;
}
else if (d[i] > str2[i2])
{
break;
}
++i2;
}
}
}
jj = 0;
while (d[jj] <= '0' && jj < lend)
{
++jj;
}
for (i = 0; i < lend - jj; ++i)
{
d[i] = d[i + jj];
}
d[i] = str1[i1 + 1];
lend = i + 1;
j++;
}
}
i = tag = 0;
while (c[i] == 0)
{
++i;
}
for (; i < j; ++i, ++tag)
{
str3[tag] = c[i]+'0';
}
str3[tag] = '\0';
return ;
}
================================================
FILE: ACM 模板代码/f-字符串 HASH/f-字符串 HASH/main.cpp
================================================
//
// main.cpp
// f-字符串 HASH
//
// Created by ZYJ on 16/6/15.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
//字符串 Hash
/*
* 字符串 Hash
* 注意：mod选择足够大的质数（至少大于字符串个数）
*/
unsigned int hashA(char *url, int mod)
{
unsigned int n = 0;
char *b = (char *)&n;
for (int i = 0; url[i]; i++)
{
b[i % 4] ^= url[i];
}
return n % mod;
}
unsigned int hashB(char *url, int mod)
{
unsigned int h = 0;
unsigned int g;
while (*url)
{
h = (h << 4) + *url++;
g = h & 0xF0000000;
if (g)
{
h ^= (g >> 24);
}
h &= ~g;
}
return h % mod;
}
unsigned int hashC(char *p, int prime = 25013)
{
unsigned int h = 0;
unsigned int g;
for (; *p; p++)
{
h = (h << 4) + *p;
g = h & 0xF0000000;
if (g)
{
h ^= (g >> 24);
h ^= g;
}
}
return h % prime;
}
int main(int argc, const char * argv[])
{
// insert code here...
std::cout << "Hello, World!\n";
return 0;
}
================================================
FILE: ACM 模板代码/f-容斥/f-容斥/main.cpp
================================================
//
// main.cpp
// f-容斥
//
// Created by ZYJ on 2017/9/12.
// Copyright © 2017年 ZYJ. All rights reserved.
//
#include <iostream>
using namespace std;
const int MAXN = 1111;
int n;
double ans;
double p[MAXN];
void dfs(int x, int tot, double sum) // dfs(1, 0, ?)
{
if (x == n + 1)
{
if (sum == 0.0)
{
return ;
}
if (tot & 1)
{
ans += 1 / sum; // 公式随意变
}
else
{
ans -= 1 / sum;
}
return ;
}
dfs(x + 1, tot, sum);
dfs(x + 1, tot + 1, sum + p[x]);
}
int main(int argc, const char * argv[])
{
// insert code here...
std::cout << "Hello, World!\n";
return 0;
}
================================================
FILE: ACM 模板代码/f-左偏树/f-左偏树/main.cpp
================================================
//
// main.cpp
// f-左偏树
//
// Created by ZYJ on 16/7/21.
// Copyright © 2016年 ZYJ. All rights reserved.
//
#include <iostream>
using namespace std;
// 左偏树
/*
* 合并复杂度 O(log N)
* INIT: init()读入数据并进行初始化;
* CALL: merge() 合并两棵左偏树;
* ins() 插入一个新节点;
* top() 取得最小结点;
* pop() 取得并删除最小结点;
* del() 删除某结点;
* add() 增/减一个结点的键值;
* iroot() 获取结点i的根;
*/
#define typec int // type of key val
const int na = -1;
const int N = 1010;
struct node
{
typec key;
int l, r, f, dist;
} tr[N];
int iroot(int i)
{ // find i's root
if (i == na)
{
return i;
}
while (tr[i].f != na)
{
i = tr[i].f;
}
return i;
}
int merge(int rx, int ry)
{
// two root: rx, ry
if (rx == na)
{
return ry;
}
if (ry == na)
{
return rx;
}
if (tr[rx].key > tr[ry].key)
{
swap(rx, ry);
}
int r = merge(tr[rx].r, ry);
tr[rx].r = r;
tr[r].f = rx;
if (tr[r].dist > tr[tr[rx].l].dist)
{
swap(tr[rx].l, tr[rx].r);
}
if (tr[rx].r == na)
{
tr[rx].dist = 0;
}
else
{
tr[rx].dist = tr[tr[rx].r].dist + 1;
}
return rx; // return new root
}
int ins(int i, typec key, int root)
{ // add a new node(i, key)
tr[i].key = key;
tr[i].l = tr[i].r = tr[i].f = na;
tr[i].dist = 0;
return root = merge(root, i); // return new root
}
int del(int i)
{ // delete node i
if (i == na)
{
return i;
}
int x, y, l, r;
l = tr[i].l;
r = tr[i].r;
y = tr[i].f;
tr[i].l = tr[i].r = tr[i].f = na;
tr[x = merge(l, r)].f = y;
if (y != na && tr[y].l == i)
{
tr[y].l = x;
}
if (y != na && tr[y].r == i)
{
tr[y].r = x;
}
for (; y != na; x = y, y = tr[y].f)
{
if (tr[tr[y].l].dist < tr[tr[y].r].dist)
{
swap(tr[y].l, tr[y].r);
}
if (tr[tr[y].r].dist + 1 == tr[y].dist)
{
break;
}
tr[y].dist = tr[tr[y].r].dist + 1;
}
if (x != na) // return new root
{
return iroot(x);
}
else return iroot(y);
}
node top(int root)
{
return tr[root];
}
node pop(int &root)
{
node out = tr[root];
int l = tr[root].l, r = tr[root].r;
tr[root].l = tr[root].r = tr[root].f = na;
tr[l].f = tr[r].f = na;
root = merge(l, r);
return out;
}
int add(int i, typec val) // tr[i].key += val
{
if (i == na)
{
return i;
}
if (tr[i].l == na && tr[i].r == na && tr[i].f == na)
{
tr[i].key += val;
return i;
}
typec key = tr[i].key + val;
int rt = del(i);
return ins(i, key, rt);
}
void init(int n)
{
for (int i = 1; i <= n; i++)
{
scanf("%d", &tr[i].key); // %d: type of key
tr[i].l = tr[i].r = tr[i].f = na;
tr[i].dist = 0;
}
return ;
Showing preview only (204K chars total). Download the full file or copy to clipboard to get everything.
gitextract_h_u2zojh/
├── .gitignore
├── ACM 模板代码/
│ ├── f-0-1分数规划/
│ │ └── f-0-1分数规划/
│ │ └── main.cpp
│ ├── f-2-SAT/
│ │ └── f-2-SAT/
│ │ └── main.cpp
│ ├── f-AC自动机/
│ │ └── f-AC自动机/
│ │ └── main.cpp
│ ├── f-Baby-Step Giant-Step/
│ │ └── f-Baby-Step Giant-Step/
│ │ └── main.cpp
│ ├── f-DAG的深度优先搜索标记/
│ │ └── f-DAG的深度优先搜索标记/
│ │ └── main.cpp
│ ├── f-FFT/
│ │ └── f-FFT/
│ │ └── main.cpp
│ ├── f-FWT/
│ │ └── f-FWT/
│ │ └── main.cpp
│ ├── f-Floyd求最小环/
│ │ └── f-Floyd求最小环/
│ │ └── main.cpp
│ ├── f-GCD/
│ │ └── f-GCD/
│ │ └── main.cpp
│ ├── f-Graham求凸包/
│ │ └── f-Graham求凸包/
│ │ └── main.cpp
│ ├── f-KMP算法/
│ │ └── f-KMP算法/
│ │ └── main.cpp
│ ├── f-Karp-Rabin算法/
│ │ └── f-Karp-Rabin算法/
│ │ └── main.cpp
│ ├── f-LCA/
│ │ └── f-LCA/
│ │ └── main.cpp
│ ├── f-Liuctic的计算几何库/
│ │ └── f-Liuctic的计算几何库/
│ │ └── main.cpp
│ ├── f-MST/
│ │ └── f-MST/
│ │ └── main.cpp
│ ├── f-Manacher算法/
│ │ └── f-Manacher算法/
│ │ └── main.cpp
│ ├── f-Polya计数/
│ │ └── f-Polya计数/
│ │ └── main.cpp
│ ├── f-RMQ/
│ │ └── f-RMQ/
│ │ └── main.cpp
│ ├── f-SPFA/
│ │ └── f-SPFA/
│ │ └── main.cpp
│ ├── f-Sunday Algorithm/
│ │ └── f-Sunday Algorithm/
│ │ └── main.cpp
│ ├── f-Tarian强连通分量/
│ │ └── f-Tarian强连通分量/
│ │ └── main.cpp
│ ├── f-Treap/
│ │ └── f-Treap/
│ │ └── main.cpp
│ ├── f-Trie树/
│ │ └── f-Trie树/
│ │ └── main.cpp
│ ├── f-Ugly Numbers/
│ │ └── f-Ugly Numbers/
│ │ └── main.cpp
│ ├── f-simpson积分/
│ │ └── f-simpson积分/
│ │ └── main.cpp
│ ├── f-strstr函数/
│ │ └── f-strstr函数/
│ │ └── main.cpp
│ ├── f-一般图匹配带花树/
│ │ └── f-一般图匹配带花树/
│ │ └── main.cpp
│ ├── f-主席树/
│ │ └── f-主席树/
│ │ └── main.cpp
│ ├── f-二分图匹配/
│ │ └── f-二分图匹配/
│ │ └── main.cpp
│ ├── f-二分图多重匹配/
│ │ └── f-二分图多重匹配/
│ │ └── main.cpp
│ ├── f-二分查找/
│ │ └── f-二分查找/
│ │ └── main.cpp
│ ├── f-二叉排序树/
│ │ └── f-二叉排序树/
│ │ └── main.cpp
│ ├── f-二叉查找树/
│ │ └── f-二叉查找树/
│ │ └── main.cpp
│ ├── f-伸展数/
│ │ └── f-伸展数/
│ │ └── main.cpp
│ ├── f-使序列有序的最少交换次数/
│ │ └── f-使序列有序的最少交换次数/
│ │ └── main.cpp
│ ├── f-划分树/
│ │ └── f-划分树/
│ │ └── main.cpp
│ ├── f-判断线段相交/
│ │ └── f-判断线段相交/
│ │ └── main.cpp
│ ├── f-动态树/
│ │ └── f-动态树/
│ │ └── main.cpp
│ ├── f-区间最大频率/
│ │ └── f-区间最大频率/
│ │ └── main.cpp
│ ├── f-半平面交/
│ │ └── f-半平面交/
│ │ └── main.cpp
│ ├── f-双连通分支/
│ │ └── f-双连通分支/
│ │ └── main.cpp
│ ├── f-取第k个元素/
│ │ └── f-取第k个元素/
│ │ └── main.cpp
│ ├── f-合数相关/
│ │ └── f-合数相关/
│ │ └── main.cpp
│ ├── f-后缀数组/
│ │ └── f-后缀数组/
│ │ └── main.cpp
│ ├── f-后缀自动机/
│ │ └── f-后缀自动机/
│ │ └── main.cpp
│ ├── f-周期性方程/
│ │ └── f-周期性方程/
│ │ └── main.cpp
│ ├── f-培训作业/
│ │ └── f-培训作业/
│ │ └── main.cpp
│ ├── f-堆/
│ │ └── f-堆/
│ │ └── main.cpp
│ ├── f-堆栈/
│ │ └── f-堆栈/
│ │ └── main.cpp
│ ├── f-多项式求根（牛顿法）/
│ │ └── f-多项式求根（牛顿法）/
│ │ └── main.cpp
│ ├── f-大数取模的二进制方法/
│ │ └── f-大数取模的二进制方法/
│ │ └── main.cpp
│ ├── f-大数平方根（字符串数组表示）/
│ │ └── f-大数平方根（字符串数组表示）/
│ │ └── main.cpp
│ ├── f-大数运算/
│ │ └── f-大数运算/
│ │ └── main.cpp
│ ├── f-字符串 HASH/
│ │ └── f-字符串 HASH/
│ │ └── main.cpp
│ ├── f-容斥/
│ │ └── f-容斥/
│ │ └── main.cpp
│ ├── f-左偏树/
│ │ └── f-左偏树/
│ │ └── main.cpp
│ ├── f-带权值的并查集/
│ │ └── f-带权值的并查集/
│ │ └── main.cpp
│ ├── f-平衡二叉树/
│ │ └── f-平衡二叉树/
│ │ └── main.cpp
│ ├── f-平面最近点对/
│ │ └── f-平面最近点对/
│ │ └── main.cpp
│ ├── f-弦图判断/
│ │ └── f-弦图判断/
│ │ └── main.cpp
│ ├── f-弦图的PERFECT ELIMINATION点排列/
│ │ └── f-弦图的PERFECT ELIMINATION点排列/
│ │ └── main.cpp
│ ├── f-快排/
│ │ └── f-快排/
│ │ └── main.cpp
│ ├── f-所有数位相加/
│ │ └── f-所有数位相加/
│ │ └── main.cpp
│ ├── f-扩展KMP/
│ │ └── f-扩展KMP/
│ │ └── main.cpp
│ ├── f-拓扑排序/
│ │ └── f-拓扑排序/
│ │ └── main.cpp
│ ├── f-排列组合/
│ │ └── f-排列组合/
│ │ └── main.cpp
│ ├── f-散列表查找/
│ │ └── f-散列表查找/
│ │ └── main.cpp
│ ├── f-旋转卡壳/
│ │ └── f-旋转卡壳/
│ │ └── main.cpp
│ ├── f-无向图找桥/
│ │ └── f-无向图找桥/
│ │ └── main.cpp
│ ├── f-无向图最小割/
│ │ └── f-无向图最小割/
│ │ └── main.cpp
│ ├── f-无向图连通分支/
│ │ └── f-无向图连通分支/
│ │ └── main.cpp
│ ├── f-无向图连通度（割）/
│ │ └── f-无向图连通度（割）/
│ │ └── main.cpp
│ ├── f-星期问题/
│ │ └── f-星期问题/
│ │ └── main.cpp
│ ├── f-曼哈顿最小生成树/
│ │ └── f-曼哈顿最小生成树/
│ │ └── main.cpp
│ ├── f-最佳点割集/
│ │ └── f-最佳点割集/
│ │ └── main.cpp
│ ├── f-最佳边割集/
│ │ └── f-最佳边割集/
│ │ └── main.cpp
│ ├── f-最大1矩阵/
│ │ └── f-最大1矩阵/
│ │ └── main.cpp
│ ├── f-最大团问题/
│ │ └── f-最大团问题/
│ │ └── main.cpp
│ ├── f-最大流/
│ │ └── f-最大流/
│ │ └── main.cpp
│ ├── f-最小树形图/
│ │ └── f-最小树形图/
│ │ └── main.cpp
│ ├── f-最小点割集/
│ │ └── f-最小点割集/
│ │ └── main.cpp
│ ├── f-最小生成树/
│ │ └── f-最小生成树/
│ │ └── main.cpp
│ ├── f-最小费用流/
│ │ └── f-最小费用流/
│ │ └── main.cpp
│ ├── f-最小路径覆盖/
│ │ └── f-最小路径覆盖/
│ │ └── main.cpp
│ ├── f-最小边割集/
│ │ └── f-最小边割集/
│ │ └── main.cpp
│ ├── f-最少找钱币问题/
│ │ └── f-最少找钱币问题/
│ │ └── main.cpp
│ ├── f-最短公共祖先/
│ │ └── f-最短公共祖先/
│ │ └── main.cpp
│ ├── f-最短路/
│ │ └── f-最短路/
│ │ └── main.cpp
│ ├── f-最长公共子序列/
│ │ └── f-最长公共子序列/
│ │ └── main.cpp
│ ├── f-最长公共递增子序列/
│ │ └── f-最长公共递增子序列/
│ │ └── main.cpp
│ ├── f-最长有序子序列/
│ │ └── f-最长有序子序列/
│ │ └── main.cpp
│ ├── f-有上下界的流/
│ │ └── f-有上下界的流/
│ │ └── main.cpp
│ ├── f-有向图强连通分支/
│ │ └── f-有向图强连通分支/
│ │ └── main.cpp
│ ├── f-有向图最小树形图/
│ │ └── f-有向图最小树形图/
│ │ └── main.cpp
│ ├── f-有向图最小点基/
│ │ └── f-有向图最小点基/
│ │ └── main.cpp
│ ├── f-有向图的强连通分量/
│ │ └── f-有向图的强连通分量/
│ │ └── main.cpp
│ ├── f-树状数组/
│ │ └── f-树状数组/
│ │ └── main.cpp
│ ├── f-树链剖分/
│ │ └── f-树链剖分/
│ │ └── main.cpp
│ ├── f-棋盘分割/
│ │ └── f-棋盘分割/
│ │ └── main.cpp
│ ├── f-模线性方程（组）/
│ │ └── f-模线性方程（组）/
│ │ └── main.cpp
│ ├── f-次小生成树/
│ │ └── f-次小生成树/
│ │ └── main.cpp
│ ├── f-欧拉函数PHI/
│ │ └── f-欧拉函数PHI/
│ │ └── main.cpp
│ ├── f-欧拉路/
│ │ └── f-欧拉路/
│ │ └── main.cpp
│ ├── f-母函数/
│ │ └── f-母函数/
│ │ └── main.cpp
│ ├── f-求A^B的约数之和/
│ │ └── f-求A^B的约数之和/
│ │ └── main.cpp
│ ├── f-求多边形重心/
│ │ └── f-求多边形重心/
│ │ └── main.cpp
│ ├── f-求逆元/
│ │ └── f-求逆元/
│ │ └── main.cpp
│ ├── f-汉诺塔/
│ │ └── f-汉诺塔/
│ │ └── main.cpp
│ ├── f-生成树计数/
│ │ └── f-生成树计数/
│ │ └── main.cpp
│ ├── f-稳定婚姻问题/
│ │ └── f-稳定婚姻问题/
│ │ └── main.cpp
│ ├── f-第K短路/
│ │ └── f-第K短路/
│ │ └── main.cpp
│ ├── f-素数相关/
│ │ └── f-素数相关/
│ │ └── main.cpp
│ ├── f-约瑟夫环问题/
│ │ └── f-约瑟夫环问题/
│ │ └── main.cpp
│ ├── f-线性方程组/
│ │ └── f-线性方程组/
│ │ └── main.cpp
│ ├── f-线段树/
│ │ └── f-线段树/
│ │ └── main.cpp
│ ├── f-线索二叉树/
│ │ └── f-线索二叉树/
│ │ └── main.cpp
│ ├── f-组合数C(n, r)/
│ │ └── f-组合数C(n, r)/
│ │ └── main.cpp
│ ├── f-莫比乌斯反演/
│ │ └── f-莫比乌斯反演/
│ │ └── main.cpp
│ ├── f-莫队算法/
│ │ └── f-莫队算法/
│ │ └── main.cpp
│ ├── f-赫夫曼编码/
│ │ └── f-赫夫曼编码/
│ │ ├── huffman.cpp
│ │ ├── huffman.hpp
│ │ ├── main.cpp
│ │ ├── queue.cpp
│ │ └── queue.hpp
│ ├── f-逆序数/
│ │ └── f-逆序数/
│ │ └── main.cpp
│ ├── f-邻接表/
│ │ └── f-邻接表/
│ │ └── main.cpp
│ ├── f-阶乘最后非零位/
│ │ └── f-阶乘最后非零位/
│ │ └── main.cpp
│ ├── f-集合划分问题/
│ │ └── f-集合划分问题/
│ │ └── main.cpp
│ ├── f-集合相关问题/
│ │ └── f-集合相关问题/
│ │ └── main.cpp
│ └── f-高斯消元/
│ └── f-高斯消元/
│ └── main.cpp
├── ACM 模版-f_zyj 更新至 v 2.1/
│ ├── v 1.1/
│ │ └── ACM模板-f_zyj v 1.1.pages/
│ │ └── Metadata/
│ │ ├── BuildVersionHistory.plist
│ │ ├── DocumentIdentifier
│ │ └── Properties.plist
│ └── v 2.1/
│ └── ACM模板-f_zyj v 2.1.pages
├── README.md
├── 按 OJ 分类/
│ ├── 51Nod/
│ │ ├── f-51Nod-1000-A+B/
│ │ │ └── f-51Nod-1000-A+B/
│ │ │ └── main.c
│ │ ├── f-51Nod-1001-数组中和等于K的数对/
│ │ │ └── f-51Nod-1001-数组中和等于K的数对/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1002-数塔取数问题/
│ │ │ └── f-51Nod-1002-数塔取数问题/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1003-阶乘后面的0的数量/
│ │ │ └── f-51Nod-1003-阶乘后面的0的数量/
│ │ │ └── main.c
│ │ ├── f-51Nod-1004-n^n的末位数字/
│ │ │ └── f-51Nod-1004-n^n的末位数字/
│ │ │ └── main.c
│ │ ├── f-51Nod-1005-大数加法/
│ │ │ └── f-51Nod-1005-大数加法/
│ │ │ └── main.c
│ │ ├── f-51Nod-1006-Tick and Tick/
│ │ │ └── f-51Nod-1006-Tick and Tick/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1006-最长公共子序列Lcs/
│ │ │ └── f-51Nod-1006-最长公共子序列Lcs/
│ │ │ └── main.c
│ │ ├── f-51Nod-1007-正整数分组/
│ │ │ └── f-51Nod-1007-正整数分组/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1008-N的阶乘 mod P/
│ │ │ └── f-51Nod-1008-N的阶乘 mod P/
│ │ │ └── main.c
│ │ ├── f-51Nod-1009-数字1的数量/
│ │ │ └── f-51Nod-1009-数字1的数量/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1010-只包含2 3 5的数/
│ │ │ └── f-51Nod-1010-只包含2 3 5的数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1011-最大公约数GCD/
│ │ │ └── f-51Nod-1011-最大公约数GCD/
│ │ │ └── main.c
│ │ ├── f-51Nod-1012-最小公倍数LCM/
│ │ │ └── f-51Nod-1012-最小公倍数LCM/
│ │ │ └── main.c
│ │ ├── f-51Nod-1013-3的幂的和/
│ │ │ └── f-51Nod-1013-3的幂的和/
│ │ │ └── main.c
│ │ ├── f-51Nod-1014-X^2 Mod P/
│ │ │ └── f-51Nod-1014-X^2 Mod P/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1015-水仙花数/
│ │ │ └── f-51Nod-1015-水仙花数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1016-水仙花数 V2/
│ │ │ └── f-51Nod-1016-水仙花数 V2/
│ │ │ └── main.c
│ │ ├── f-51Nod-1018-排序/
│ │ │ └── f-51Nod-1018-排序/
│ │ │ └── main.c
│ │ ├── f-51Nod-1019-逆序数/
│ │ │ └── f-51Nod-1019-逆序数/
│ │ │ └── main.c
│ │ ├── f-51Nod-1020-逆序排序/
│ │ │ └── f-51Nod-1020-逆序排序/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1021-石子归并/
│ │ │ └── f-51Nod-1021-石子归并/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1022-石子归并 V2/
│ │ │ └── f-51Nod-1022-石子归并 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1023-石子归并 V3/
│ │ │ └── f-51Nod-1023-石子归并 V3/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1024-矩阵中不重复的元素/
│ │ │ └── f-51Nod-1024-矩阵中不重复的元素/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1027-大数乘法/
│ │ │ └── f-51Nod-1027-大数乘法/
│ │ │ └── main.c
│ │ ├── f-51Nod-1028-大数乘法 V2/
│ │ │ └── f-51Nod-1028-大数乘法 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1029-大数除法/
│ │ │ └── f-51Nod-1029-大数除法/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1030-大数进制转换/
│ │ │ └── f-51Nod-1030-大数进制转换/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1031-骨牌覆盖/
│ │ │ └── f-51Nod-1031-骨牌覆盖/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1032-骨牌覆盖 V2/
│ │ │ └── f-51Nod-1032-骨牌覆盖 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1033-骨牌覆盖 V2/
│ │ │ └── f-51Nod-1033-骨牌覆盖 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1035-最长的循环节/
│ │ │ └── f-51Nod-1035-最长的循环节/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1038-X^A Mod P/
│ │ │ └── f-51Nod-1038-X^A Mod P/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1040-最大公约数之和/
│ │ │ └── f-51Nod-1040-最大公约数之和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1042-数字0~9的数量/
│ │ │ └── f-51Nod-1042-数字0~9的数量/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1043-幸运号码/
│ │ │ └── f-51Nod-1043-幸运号码/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1046-A^B Mod C/
│ │ │ └── f-51Nod-1046-A^B Mod C/
│ │ │ └── main.c
│ │ ├── f-51Nod-1047-整数分解为2的幂/
│ │ │ └── f-51Nod-1047-整数分解为2的幂/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1049-最大子段和/
│ │ │ └── f-51Nod-1049-最大子段和/
│ │ │ └── main.c
│ │ ├── f-51Nod-1050-循环数组最大子段和/
│ │ │ └── f-51Nod-1050-循环数组最大子段和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1051-最大子矩阵和/
│ │ │ └── f-51Nod-1051-最大子矩阵和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1052-最大M子段和/
│ │ │ └── f-51Nod-1052-最大M子段和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1053-最大M子段和 V2/
│ │ │ └── f-51Nod-1053-最大M子段和 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1054-最长等差数列/
│ │ │ └── f-51Nod-1054-最长等差数列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1055-最长等差数列/
│ │ │ └── f-51Nod-1055-最长等差数列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1056-最长等差数列 V2/
│ │ │ └── f-51Nod-1056-最长等差数列 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1057-N的阶乘/
│ │ │ └── f-51Nod-1057-N的阶乘/
│ │ │ └── main.c
│ │ ├── f-51Nod-1058-N的阶乘的长度/
│ │ │ └── f-51Nod-1058-N的阶乘的长度/
│ │ │ └── main.c
│ │ ├── f-51Nod-1059-N的阶乘 V2/
│ │ │ └── f-51Nod-1059-N的阶乘 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1060-最复杂的数/
│ │ │ └── f-51Nod-1060-最复杂的数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1062-序列中的最大数/
│ │ │ └── f-51Nod-1062-序列中的最大数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1063-序列中最大的数 V2/
│ │ │ └── f-51Nod-1063-序列中最大的数 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1065-最小正子段和/
│ │ │ └── f-51Nod-1065-最小正子段和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1066-Bash游戏/
│ │ │ └── f-51Nod-1066-Bash游戏/
│ │ │ └── main.c
│ │ ├── f-51Nod-1067-Bash游戏 V2/
│ │ │ └── f-51Nod-1067-Bash游戏 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1068-Bash游戏 V3/
│ │ │ └── f-51Nod-1068-Bash游戏 V3/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1069-Nim游戏/
│ │ │ └── f-51Nod-1069-Nim游戏/
│ │ │ └── main.c
│ │ ├── f-51Nod-1070-Bash游戏 V4/
│ │ │ └── f-51Nod-1070-Bash游戏 V4/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1072-威佐夫游戏/
│ │ │ └── f-51Nod-1072-威佐夫游戏/
│ │ │ └── main.c
│ │ ├── f-51Nod-1073-约瑟夫环/
│ │ │ └── f-51Nod-1073-约瑟夫环/
│ │ │ └── main.c
│ │ ├── f-51Nod-1074-约瑟夫环 V2/
│ │ │ └── f-51Nod-1074-约瑟夫环 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1076-2条不相交的路径/
│ │ │ └── f-51Nod-1076-2条不相交的路径/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1079-中国剩余定理/
│ │ │ └── f-51Nod-1079-中国剩余定理/
│ │ │ └── main.c
│ │ ├── f-51Nod-1080-两个数的平方和/
│ │ │ └── f-51Nod-1080-两个数的平方和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1081-子段求和/
│ │ │ └── f-51Nod-1081-子段求和/
│ │ │ └── main.c
│ │ ├── f-51Nod-1082-与7无关的数/
│ │ │ └── f-51Nod-1082-与7无关的数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1083-矩阵取数问题/
│ │ │ └── f-51Nod-1083-矩阵取数问题/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1084-矩阵取数问题 V2/
│ │ │ └── f-51Nod-1084-矩阵取数问题 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1085-背包问题/
│ │ │ └── f-51Nod-1085-背包问题/
│ │ │ └── main.c
│ │ ├── f-51Nod-1086-背包问题 V2/
│ │ │ └── f-51Nod-1086-背包问题 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1087-1 10 100 1000/
│ │ │ └── f-51Nod-1087-1 10 100 1000/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1088-最长回文子串/
│ │ │ └── f-51Nod-1088-最长回文子串/
│ │ │ └── main.c
│ │ ├── f-51Nod-1089-最长回文子串 V2（Manacher算法）/
│ │ │ └── f-51Nod-1089-最长回文子串 V2（Manacher算法）/
│ │ │ └── main.c
│ │ ├── f-51Nod-1090-3个数和为0/
│ │ │ └── f-51Nod-1090-3个数和为0/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1091-线段的重叠/
│ │ │ └── f-51Nod-1091-线段的重叠/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1092-回文字符串/
│ │ │ └── f-51Nod-1092-回文字符串/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1093-骆驼和香蕉/
│ │ │ └── f-51Nod-1093-骆驼和香蕉/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1094-和为k的连续区间/
│ │ │ └── f-51Nod-1094-和为k的连续区间/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1095-Anigram单词/
│ │ │ └── f-51Nod-1095-Anigram单词/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1096-距离之和最小/
│ │ │ └── f-51Nod-1096-距离之和最小/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1097-拼成最小的数/
│ │ │ └── f-51Nod-1097-拼成最小的数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1098-最小方差/
│ │ │ └── f-51Nod-1098-最小方差/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1099-任务执行顺序/
│ │ │ └── f-51Nod-1099-任务执行顺序/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1100-斜率最大/
│ │ │ └── f-51Nod-1100-斜率最大/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1101-换零钱/
│ │ │ └── f-51Nod-1101-换零钱/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1102-面积最大的矩形/
│ │ │ └── f-51Nod-1102-面积最大的矩形/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1103-N的倍数/
│ │ │ └── f-51Nod-1103-N的倍数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1105-第K大的数/
│ │ │ └── f-51Nod-1105-第K大的数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1106-质数检测/
│ │ │ └── f-51Nod-1106-质数检测/
│ │ │ └── main.c
│ │ ├── f-51Nod-1107-斜率小于0的连线数量/
│ │ │ └── f-51Nod-1107-斜率小于0的连线数量/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1108-距离之和最小 V2/
│ │ │ └── f-51Nod-1108-距离之和最小 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1109-01组成的N的倍数/
│ │ │ └── f-51Nod-1109-01组成的N的倍数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1110-距离之和最小 V3/
│ │ │ └── f-51Nod-1110-距离之和最小 V3/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1112-KGold/
│ │ │ └── f-51Nod-1112-KGold/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1113-矩阵快速幂/
│ │ │ └── f-51Nod-1113-矩阵快速幂/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1116-K进制下的大数/
│ │ │ └── f-51Nod-1116-K进制下的大数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1117-聪明的木匠/
│ │ │ └── f-51Nod-1117-聪明的木匠/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1118-机器人走方格/
│ │ │ └── f-51Nod-1118-机器人走方格/
│ │ │ └── main.c
│ │ ├── f-51Nod-1119-机器人走方格 V2/
│ │ │ └── f-51Nod-1119-机器人走方格 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1120-机器人走方格 V3/
│ │ │ └── f-51Nod-1120-机器人走方格 V3/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1122-机器人走方格 V4/
│ │ │ └── f-51Nod-1122-机器人走方格 V4/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1124-N!的非0最低位/
│ │ │ └── f-51Nod-1124-N!的非0最低位/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1125-交换机器的最小代价/
│ │ │ └── f-51Nod-1125-交换机器的最小代价/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1126-求递推序列的第N项/
│ │ │ └── f-51Nod-1126-求递推序列的第N项/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1127-最短的包含字符串/
│ │ │ └── f-51Nod-1127-最短的包含字符串/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1128-正整数分组 V2/
│ │ │ └── f-51Nod-1128-正整数分组 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1130-N的阶乘的长度 V2（斯特林近似）/
│ │ │ └── f-51Nod-1130-N的阶乘的长度 V2（斯特林近似）/
│ │ │ └── main.c
│ │ ├── f-51Nod-1131-覆盖数字的数量/
│ │ │ └── f-51Nod-1131-覆盖数字的数量/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1133-不重叠的线段/
│ │ │ └── f-51Nod-1133-不重叠的线段/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1134-最长递增子序列/
│ │ │ └── f-51Nod-1134-最长递增子序列/
│ │ │ └── main.c
│ │ ├── f-51Nod-1135-原根/
│ │ │ └── f-51Nod-1135-原根/
│ │ │ └── main.c
│ │ ├── f-51Nod-1136-欧拉函数/
│ │ │ └── f-51Nod-1136-欧拉函数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1137-矩阵乘法/
│ │ │ └── f-51Nod-1137-矩阵乘法/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1138-连续整数的和/
│ │ │ └── f-51Nod-1138-连续整数的和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1140-矩阵相乘结果的判断/
│ │ │ └── f-51Nod-1140-矩阵相乘结果的判断/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1149-Pi的递推式/
│ │ │ └── f-51Nod-1149-Pi的递推式/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1153-选择子序列/
│ │ │ └── f-51Nod-1153-选择子序列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1154-回文串划分/
│ │ │ └── f-51Nod-1154-回文串划分/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1157-全是1的最大子矩阵/
│ │ │ └── f-51Nod-1157-全是1的最大子矩阵/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1158-全是1的最大子矩阵/
│ │ │ └── f-51Nod-1158-全是1的最大子矩阵/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1161-Partial Sums/
│ │ │ └── f-51Nod-1161-Partial Sums/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1163-最高的奖励/
│ │ │ └── f-51Nod-1163-最高的奖励/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1166-大数开平方/
│ │ │ └── f-51Nod-1166-大数开平方/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1174-区间中最大数/
│ │ │ └── f-51Nod-1174-区间中最大数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1175-区间中第K大的数/
│ │ │ └── f-51Nod-1175-区间中第K大的数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1179-最大的最大公约数/
│ │ │ └── f-51Nod-1179-最大的最大公约数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1181-质数中的质数（质数筛法）/
│ │ │ └── f-51Nod-1181-质数中的质数（质数筛法）/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1182-完美字符串/
│ │ │ └── f-51Nod-1182-完美字符串/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1183-编辑距离/
│ │ │ └── f-51Nod-1183-编辑距离/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1184-第N个质数/
│ │ │ └── f-51Nod-1184-第N个质数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1185-威佐夫游戏 V2/
│ │ │ └── f-51Nod-1185-威佐夫游戏 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1186-质数检测 V2/
│ │ │ └── f-51Nod-1186-质数检测 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1188-最大公约数之和 V2/
│ │ │ └── f-51Nod-1188-最大公约数之和 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1189-阶乘分数/
│ │ │ └── f-51Nod-1189-阶乘分数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1191-消灭兔子/
│ │ │ └── f-51Nod-1191-消灭兔子/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1192-Gcd表中的质数/
│ │ │ └── f-51Nod-1192-Gcd表中的质数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1195-斐波那契数列的循环节/
│ │ │ └── f-51Nod-1195-斐波那契数列的循环节/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1196-字符串的数量/
│ │ │ └── f-51Nod-1196-字符串的数量/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1197-字符串的数量 V2/
│ │ │ └── f-51Nod-1197-字符串的数量 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1198-字符串的数量 V3/
│ │ │ └── f-51Nod-1198-字符串的数量 V3/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1199-Money out of Thin Air/
│ │ │ └── f-51Nod-1199-Money out of Thin Air/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1201-整数划分/
│ │ │ └── f-51Nod-1201-整数划分/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1202-子序列个数/
│ │ │ └── f-51Nod-1202-子序列个数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1203-JZPLCM/
│ │ │ └── f-51Nod-1203-JZPLCM/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1204-Parity/
│ │ │ └── f-51Nod-1204-Parity/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1205-流水线调度/
│ │ │ └── f-51Nod-1205-流水线调度/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1208-Stars in Your Window/
│ │ │ └── f-51Nod-1208-Stars in Your Window/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1212-无向图最小生成树/
│ │ │ └── f-51Nod-1212-无向图最小生成树/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1215-数组的宽度/
│ │ │ └── f-51Nod-1215-数组的宽度/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1217-Minimum Modular/
│ │ │ └── f-51Nod-1217-Minimum Modular/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1220-约数之和/
│ │ │ └── f-51Nod-1220-约数之和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1222-最小公倍数计数/
│ │ │ └── f-51Nod-1222-最小公倍数计数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1225-余数之和/
│ │ │ └── f-51Nod-1225-余数之和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1227-平均最小公倍数/
│ │ │ └── f-51Nod-1227-平均最小公倍数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1228-序列求和/
│ │ │ └── f-51Nod-1228-序列求和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1230-幸运数/
│ │ │ └── f-51Nod-1230-幸运数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1232-完美数/
│ │ │ └── f-51Nod-1232-完美数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1237-最大公约数之和 V3/
│ │ │ └── f-51Nod-1237-最大公约数之和 V3/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1238-最小公倍数之和 V3/
│ │ │ └── f-51Nod-1238-最小公倍数之和 V3/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1239-欧拉函数之和/
│ │ │ └── f-51Nod-1239-欧拉函数之和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1240-莫比乌斯函数/
│ │ │ └── f-51Nod-1240-莫比乌斯函数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1241-特殊的排序/
│ │ │ └── f-51Nod-1241-特殊的排序/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1242-斐波那契数列的第N项/
│ │ │ └── f-51Nod-1242-斐波那契数列的第N项/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1243-排船的问题/
│ │ │ └── f-51Nod-1243-排船的问题/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1244-莫比乌斯函数之和/
│ │ │ └── f-51Nod-1244-莫比乌斯函数之和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1246-罐子和硬币/
│ │ │ └── f-51Nod-1246-罐子和硬币/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1247-可能的路径/
│ │ │ └── f-51Nod-1247-可能的路径/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1249-近似有序区间/
│ │ │ └── f-51Nod-1249-近似有序区间/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1254-最大子段和 V2/
│ │ │ └── f-51Nod-1254-最大子段和 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1255-字典序最小的子序列/
│ │ │ └── f-51Nod-1255-字典序最小的子序列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1256-乘法逆元/
│ │ │ └── f-51Nod-1256-乘法逆元/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1257-背包问题 V3/
│ │ │ └── f-51Nod-1257-背包问题 V3/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1258-序列求和 V4/
│ │ │ └── f-51Nod-1258-序列求和 V4/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1259-整数划分 V2/
│ │ │ └── f-51Nod-1259-整数划分 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1262-扔球/
│ │ │ └── f-51Nod-1262-扔球/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1264-线段相交/
│ │ │ └── f-51Nod-1264-线段相交/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1265-四点共面/
│ │ │ └── f-51Nod-1265-四点共面/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1266-蚂蚁/
│ │ │ └── f-51Nod-1266-蚂蚁/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1267-4个数和为0/
│ │ │ └── f-51Nod-1267-4个数和为0/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1268-和为K的组合/
│ │ │ └── f-51Nod-1268-和为K的组合/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1270-数组的最大代价/
│ │ │ └── f-51Nod-1270-数组的最大代价/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1272-最大距离/
│ │ │ └── f-51Nod-1272-最大距离/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1273-旅行计划/
│ │ │ └── f-51Nod-1273-旅行计划/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1274-最长递增路径/
│ │ │ └── f-51Nod-1274-最长递增路径/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1275-连续子段的差异/
│ │ │ └── f-51Nod-1275-连续子段的差异/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1276-岛屿的数量/
│ │ │ └── f-51Nod-1276-岛屿的数量/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1277-字符串中的最大值/
│ │ │ └── f-51Nod-1277-字符串中的最大值/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1278-相离的圆/
│ │ │ └── f-51Nod-1278-相离的圆/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1279-扔盘子/
│ │ │ └── f-51Nod-1279-扔盘子/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1280-前缀后缀集合/
│ │ │ └── f-51Nod-1280-前缀后缀集合/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1281-山峰和旗子/
│ │ │ └── f-51Nod-1281-山峰和旗子/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1282-时钟/
│ │ │ └── f-51Nod-1282-时钟/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1283-最小周长/
│ │ │ └── f-51Nod-1283-最小周长/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1284-2 3 5 7的倍数/
│ │ │ └── f-51Nod-1284-2 3 5 7的倍数/
│ │ │ └── main.c
│ │ ├── f-51Nod-1285-山峰和分段/
│ │ │ └── f-51Nod-1285-山峰和分段/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1287-加农炮/
│ │ │ └── f-51Nod-1287-加农炮/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1288-汽油补给/
│ │ │ └── f-51Nod-1288-汽油补给/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1289-大鱼吃小鱼/
│ │ │ └── f-51Nod-1289-大鱼吃小鱼/
│ │ │ └── main.c
│ │ ├── f-51Nod-1293-球与切换器/
│ │ │ └── f-51Nod-1293-球与切换器/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1294-修改数组/
│ │ │ └── f-51Nod-1294-修改数组/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1295-XOR key/
│ │ │ └── f-51Nod-1295-XOR key/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1296-有限制的排列/
│ │ │ └── f-51Nod-1296-有限制的排列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1298-圆与三角形/
│ │ │ └── f-51Nod-1298-圆与三角形/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1299-监狱逃离/
│ │ │ └── f-51Nod-1299-监狱逃离/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1305-Pairwise Sum and Divide/
│ │ │ └── f-51Nod-1305-Pairwise Sum and Divide/
│ │ │ └── main.c
│ │ ├── f-51Nod-1307-绳子与重物/
│ │ │ └── f-51Nod-1307-绳子与重物/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1310-Chandrima and XOR/
│ │ │ └── f-51Nod-1310-Chandrima and XOR/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1315-合法整数集/
│ │ │ └── f-51Nod-1315-合法整数集/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1316-回文矩阵/
│ │ │ └── f-51Nod-1316-回文矩阵/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1319-跳跃游戏/
│ │ │ └── f-51Nod-1319-跳跃游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1320-合法尾数序列/
│ │ │ └── f-51Nod-1320-合法尾数序列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1322-关于树的函数/
│ │ │ └── f-51Nod-1322-关于树的函数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1328-比赛往事/
│ │ │ └── f-51Nod-1328-比赛往事/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1330-雕像投影/
│ │ │ └── f-51Nod-1330-雕像投影/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1333-无聊的数学家们/
│ │ │ └── f-51Nod-1333-无聊的数学家们/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1335-子序列翻转/
│ │ │ └── f-51Nod-1335-子序列翻转/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1337-翻转游戏/
│ │ │ └── f-51Nod-1337-翻转游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1341-混合序列/
│ │ │ └── f-51Nod-1341-混合序列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1344-走格子/
│ │ │ └── f-51Nod-1344-走格子/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1345-画点集/
│ │ │ └── f-51Nod-1345-画点集/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1346-递归/
│ │ │ └── f-51Nod-1346-递归/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1347-旋转字符串/
│ │ │ └── f-51Nod-1347-旋转字符串/
│ │ │ └── main.c
│ │ ├── f-51Nod-1349-最大值/
│ │ │ └── f-51Nod-1349-最大值/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1350-斐波那契表示/
│ │ │ └── f-51Nod-1350-斐波那契表示/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1351-吃点心/
│ │ │ └── f-51Nod-1351-吃点心/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1352-集合计数/
│ │ │ └── f-51Nod-1352-集合计数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1353-树/
│ │ │ └── f-51Nod-1353-树/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1354-选数字/
│ │ │ └── f-51Nod-1354-选数字/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1355-斐波那契的最小公倍数/
│ │ │ └── f-51Nod-1355-斐波那契的最小公倍数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1358-浮波那契/
│ │ │ └── f-51Nod-1358-浮波那契/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1359-循环探求/
│ │ │ └── f-51Nod-1359-循环探求/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1363-最小公倍数之和/
│ │ │ └── f-51Nod-1363-最小公倍数之和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1364-最大字典序排列/
│ │ │ └── f-51Nod-1364-最大字典序排列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1366-贫富差距/
│ │ │ └── f-51Nod-1366-贫富差距/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1371-填数字/
│ │ │ └── f-51Nod-1371-填数字/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1376-最长递增子序列的数量/
│ │ │ └── f-51Nod-1376-最长递增子序列的数量/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1377-最慢的快排/
│ │ │ └── f-51Nod-1377-最慢的快排/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1378-夹克老爷的愤怒/
│ │ │ └── f-51Nod-1378-夹克老爷的愤怒/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1379-索函数/
│ │ │ └── f-51Nod-1379-索函数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1380-夹克老爷的逢三抽一/
│ │ │ └── f-51Nod-1380-夹克老爷的逢三抽一/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1381-硬币游戏/
│ │ │ └── f-51Nod-1381-硬币游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1383-整数分解为2的幂/
│ │ │ └── f-51Nod-1383-整数分解为2的幂/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1384-全排列/
│ │ │ └── f-51Nod-1384-全排列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1385-凑数字/
│ │ │ └── f-51Nod-1385-凑数字/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1388-六边形平面/
│ │ │ └── f-51Nod-1388-六边形平面/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1390-游戏得分/
│ │ │ └── f-51Nod-1390-游戏得分/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1391-01串/
│ │ │ └── f-51Nod-1391-01串/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1393-0和1相等串/
│ │ │ └── f-51Nod-1393-0和1相等串/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1394-差和问题/
│ │ │ └── f-51Nod-1394-差和问题/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1396-还是01串/
│ │ │ └── f-51Nod-1396-还是01串/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1398-等公交/
│ │ │ └── f-51Nod-1398-等公交/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1400-序列分解/
│ │ │ └── f-51Nod-1400-序列分解/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1402-最大值/
│ │ │ └── f-51Nod-1402-最大值/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1403-有趣的堆栈/
│ │ │ └── f-51Nod-1403-有趣的堆栈/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1405-树的距离之和/
│ │ │ └── f-51Nod-1405-树的距离之和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1406-与查询/
│ │ │ └── f-51Nod-1406-与查询/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1409-加强版贪吃蛇/
│ │ │ └── f-51Nod-1409-加强版贪吃蛇/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1412-AVL树的种类/
│ │ │ └── f-51Nod-1412-AVL树的种类/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1413-权势二进制/
│ │ │ └── f-51Nod-1413-权势二进制/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1414-冰雕/
│ │ │ └── f-51Nod-1414-冰雕/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1416-两点/
│ │ │ └── f-51Nod-1416-两点/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1417-天堂里的游戏/
│ │ │ └── f-51Nod-1417-天堂里的游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1418-放球游戏/
│ │ │ └── f-51Nod-1418-放球游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1419-最小公倍数挑战/
│ │ │ └── f-51Nod-1419-最小公倍数挑战/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1420-数袋鼠好有趣/
│ │ │ └── f-51Nod-1420-数袋鼠好有趣/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1421-最大MOD值/
│ │ │ └── f-51Nod-1421-最大MOD值/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1422-沙拉酱前缀/
│ │ │ └── f-51Nod-1422-沙拉酱前缀/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1423-最大二"货"/
│ │ │ └── f-51Nod-1423-最大二"货"/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1424-零树/
│ │ │ └── f-51Nod-1424-零树/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1425-减减数/
│ │ │ └── f-51Nod-1425-减减数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1428-活动安排问题/
│ │ │ └── f-51Nod-1428-活动安排问题/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1429-巧克力/
│ │ │ └── f-51Nod-1429-巧克力/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1430-奇偶游戏/
│ │ │ └── f-51Nod-1430-奇偶游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1431-快乐排队/
│ │ │ └── f-51Nod-1431-快乐排队/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1432-独木舟/
│ │ │ └── f-51Nod-1432-独木舟/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1433-0和5/
│ │ │ └── f-51Nod-1433-0和5/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1434-区间LCM/
│ │ │ └── f-51Nod-1434-区间LCM/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1435-位数阶乘/
│ │ │ └── f-51Nod-1435-位数阶乘/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1436-方程的解数/
│ │ │ └── f-51Nod-1436-方程的解数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1437-迈克步/
│ │ │ └── f-51Nod-1437-迈克步/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1438-方阵与完全平方数/
│ │ │ └── f-51Nod-1438-方阵与完全平方数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1439-互质对/
│ │ │ └── f-51Nod-1439-互质对/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1441-士兵的数字游戏/
│ │ │ └── f-51Nod-1441-士兵的数字游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1442-士兵的旅行/
│ │ │ └── f-51Nod-1442-士兵的旅行/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1443-路径和树/
│ │ │ └── f-51Nod-1443-路径和树/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1444-破坏道路/
│ │ │ └── f-51Nod-1444-破坏道路/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1445-变色DNA/
│ │ │ └── f-51Nod-1445-变色DNA/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1448-二染色问题/
│ │ │ └── f-51Nod-1448-二染色问题/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1449-砝码称重/
│ │ │ └── f-51Nod-1449-砝码称重/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1451-合法三角形/
│ │ │ └── f-51Nod-1451-合法三角形/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1452-加括号/
│ │ │ └── f-51Nod-1452-加括号/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1453-抽彩球/
│ │ │ └── f-51Nod-1453-抽彩球/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1454-升排列/
│ │ │ └── f-51Nod-1454-升排列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1455-宝石猎人/
│ │ │ └── f-51Nod-1455-宝石猎人/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1456-小K的技术/
│ │ │ └── f-51Nod-1456-小K的技术/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1459-迷宫游戏/
│ │ │ └── f-51Nod-1459-迷宫游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1460-连接小岛/
│ │ │ └── f-51Nod-1460-连接小岛/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1461-稳定桌/
│ │ │ └── f-51Nod-1461-稳定桌/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1463-找朋友/
│ │ │ └── f-51Nod-1463-找朋友/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1464-半回文/
│ │ │ └── f-51Nod-1464-半回文/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1467-旋转绳/
│ │ │ └── f-51Nod-1467-旋转绳/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1468-小Y的IP地址/
│ │ │ └── f-51Nod-1468-小Y的IP地址/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1469-淋漓尽致子串/
│ │ │ └── f-51Nod-1469-淋漓尽致子串/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1473-等幂映射/
│ │ │ └── f-51Nod-1473-等幂映射/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1475-建设国家/
│ │ │ └── f-51Nod-1475-建设国家/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1476-括号序列的最小代价/
│ │ │ └── f-51Nod-1476-括号序列的最小代价/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1478-括号序列的最长合法子段/
│ │ │ └── f-51Nod-1478-括号序列的最长合法子段/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1480-打广告/
│ │ │ └── f-51Nod-1480-打广告/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1483-化学变换/
│ │ │ └── f-51Nod-1483-化学变换/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1484-猜数游戏/
│ │ │ └── f-51Nod-1484-猜数游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1485-字母排序/
│ │ │ └── f-51Nod-1485-字母排序/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1486-大大走格子/
│ │ │ └── f-51Nod-1486-大大走格子/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1487-占领资源/
│ │ │ └── f-51Nod-1487-占领资源/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1489-蜥蜴和地下室/
│ │ │ └── f-51Nod-1489-蜥蜴和地下室/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1490-多重游戏/
│ │ │ └── f-51Nod-1490-多重游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1491-黄金系统/
│ │ │ └── f-51Nod-1491-黄金系统/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1493-数据关联/
│ │ │ └── f-51Nod-1493-数据关联/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1494-选举拉票/
│ │ │ └── f-51Nod-1494-选举拉票/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1495-中国好区间/
│ │ │ └── f-51Nod-1495-中国好区间/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1496-最小异或和/
│ │ │ └── f-51Nod-1496-最小异或和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1499-图/
│ │ │ └── f-51Nod-1499-图/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1500-苹果曼和树/
│ │ │ └── f-51Nod-1500-苹果曼和树/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1503-猪和回文/
│ │ │ └── f-51Nod-1503-猪和回文/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1509-加长棒/
│ │ │ └── f-51Nod-1509-加长棒/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1510-最小化序列/
│ │ │ └── f-51Nod-1510-最小化序列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1513-树上的回文/
│ │ │ └── f-51Nod-1513-树上的回文/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1515-明辨是非/
│ │ │ └── f-51Nod-1515-明辨是非/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1519-拆方块/
│ │ │ └── f-51Nod-1519-拆方块/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1521-一维战舰/
│ │ │ └── f-51Nod-1521-一维战舰/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1522-上下序列/
│ │ │ └── f-51Nod-1522-上下序列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1523-非回文/
│ │ │ └── f-51Nod-1523-非回文/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1524-可除图的最大团/
│ │ │ └── f-51Nod-1524-可除图的最大团/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1525-重组公司/
│ │ │ └── f-51Nod-1525-重组公司/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1526-分配笔名/
│ │ │ └── f-51Nod-1526-分配笔名/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1530-稳定方块/
│ │ │ └── f-51Nod-1530-稳定方块/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1533-一堆的堆/
│ │ │ └── f-51Nod-1533-一堆的堆/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1534-棋子游戏/
│ │ │ └── f-51Nod-1534-棋子游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1535-深海探险/
│ │ │ └── f-51Nod-1535-深海探险/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1536-不一样的猜数游戏/
│ │ │ └── f-51Nod-1536-不一样的猜数游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1540-俄罗斯赌轮盘/
│ │ │ └── f-51Nod-1540-俄罗斯赌轮盘/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1548-欧姆诺姆和糖果/
│ │ │ └── f-51Nod-1548-欧姆诺姆和糖果/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1552-白兰地定位系统/
│ │ │ └── f-51Nod-1552-白兰地定位系统/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1554-欧姆诺姆和项链/
│ │ │ └── f-51Nod-1554-欧姆诺姆和项链/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1556-计算/
│ │ │ └── f-51Nod-1556-计算/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1557-两个集合/
│ │ │ └── f-51Nod-1557-两个集合/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1560-扔人游戏/
│ │ │ └── f-51Nod-1560-扔人游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1562-玻璃切割/
│ │ │ └── f-51Nod-1562-玻璃切割/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1563-坐标轴上的最大团/
│ │ │ └── f-51Nod-1563-坐标轴上的最大团/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1564-区间的价值/
│ │ │ └── f-51Nod-1564-区间的价值/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1571-最近等对/
│ │ │ └── f-51Nod-1571-最近等对/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1572-宝岛地图/
│ │ │ └── f-51Nod-1572-宝岛地图/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1573-美丽的集合/
│ │ │ └── f-51Nod-1573-美丽的集合/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1574-排列转换/
│ │ │ └── f-51Nod-1574-排列转换/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1580-铺管道/
│ │ │ └── f-51Nod-1580-铺管道/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1581-摆放骨牌/
│ │ │ └── f-51Nod-1581-摆放骨牌/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1582-n叉树/
│ │ │ └── f-51Nod-1582-n叉树/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1586-约数和/
│ │ │ └── f-51Nod-1586-约数和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1589-移数博弈/
│ │ │ └── f-51Nod-1589-移数博弈/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1593-公园晨跑/
│ │ │ └── f-51Nod-1593-公园晨跑/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1594-Gcd and Phi/
│ │ │ └── f-51Nod-1594-Gcd and Phi/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1595-回文度/
│ │ │ └── f-51Nod-1595-回文度/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1596-搬货物/
│ │ │ └── f-51Nod-1596-搬货物/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1597-有限背包计数问题/
│ │ │ └── f-51Nod-1597-有限背包计数问题/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1603-限高二叉排列树/
│ │ │ └── f-51Nod-1603-限高二叉排列树/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1605-棋盘问题/
│ │ │ └── f-51Nod-1605-棋盘问题/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1607-卷积和/
│ │ │ └── f-51Nod-1607-卷积和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1610-路径计数/
│ │ │ └── f-51Nod-1610-路径计数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1612-合法表达式/
│ │ │ └── f-51Nod-1612-合法表达式/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1613-翻硬币/
│ │ │ └── f-51Nod-1613-翻硬币/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1615-跳跃的杰克/
│ │ │ └── f-51Nod-1615-跳跃的杰克/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1616-最小集合/
│ │ │ └── f-51Nod-1616-最小集合/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1617-奇偶数组/
│ │ │ └── f-51Nod-1617-奇偶数组/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1618-树或非树/
│ │ │ └── f-51Nod-1618-树或非树/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1619-完全二叉树的方差/
│ │ │ └── f-51Nod-1619-完全二叉树的方差/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1621-花钱买车牌/
│ │ │ └── f-51Nod-1621-花钱买车牌/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1622-集合对/
│ │ │ └── f-51Nod-1622-集合对/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1623-完美消除/
│ │ │ └── f-51Nod-1623-完美消除/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1625-夹克爷发红包/
│ │ │ └── f-51Nod-1625-夹克爷发红包/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1629-B君的圆锥/
│ │ │ └── f-51Nod-1629-B君的圆锥/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1630-B君的竞技场/
│ │ │ └── f-51Nod-1630-B君的竞技场/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1631-小鲨鱼在51Nod小学/
│ │ │ └── f-51Nod-1631-小鲨鱼在51Nod小学/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1635-第K个幸运排列/
│ │ │ └── f-51Nod-1635-第K个幸运排列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1636-教育改革/
│ │ │ └── f-51Nod-1636-教育改革/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1637-幸运数字转换/
│ │ │ └── f-51Nod-1637-幸运数字转换/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1638-字符串重组/
│ │ │ └── f-51Nod-1638-字符串重组/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1639-绑鞋带/
│ │ │ └── f-51Nod-1639-绑鞋带/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1640-天气晴朗的魔法/
│ │ │ └── f-51Nod-1640-天气晴朗的魔法/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1645-中位数变换/
│ │ │ └── f-51Nod-1645-中位数变换/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1649-齐头并进/
│ │ │ └── f-51Nod-1649-齐头并进/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1650-穿越无人区/
│ │ │ └── f-51Nod-1650-穿越无人区/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1661-黑板上的游戏/
│ │ │ └── f-51Nod-1661-黑板上的游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1670-打怪兽/
│ │ │ └── f-51Nod-1670-打怪兽/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1671-货物运输/
│ │ │ └── f-51Nod-1671-货物运输/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1673-树有几多愁/
│ │ │ └── f-51Nod-1673-树有几多愁/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1674-区间的价值 V2/
│ │ │ └── f-51Nod-1674-区间的价值 V2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1675-序列变换/
│ │ │ └── f-51Nod-1675-序列变换/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1677-treecnt/
│ │ │ └── f-51Nod-1677-treecnt/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1678-lyk与gcd/
│ │ │ └── f-51Nod-1678-lyk与gcd/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1679-连通率/
│ │ │ └── f-51Nod-1679-连通率/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1681-公共祖先/
│ │ │ └── f-51Nod-1681-公共祖先/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1684-子集价值/
│ │ │ └── f-51Nod-1684-子集价值/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1685-第K大区间2/
│ │ │ └── f-51Nod-1685-第K大区间2/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1686-第K大区间/
│ │ │ └── f-51Nod-1686-第K大区间/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1689-逛街/
│ │ │ └── f-51Nod-1689-逛街/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1693-水群/
│ │ │ └── f-51Nod-1693-水群/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1705-七星剑/
│ │ │ └── f-51Nod-1705-七星剑/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1711-平均数/
│ │ │ └── f-51Nod-1711-平均数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1712-区间求和/
│ │ │ └── f-51Nod-1712-区间求和/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1714-B君的游戏/
│ │ │ └── f-51Nod-1714-B君的游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1716-多项式?/
│ │ │ └── f-51Nod-1716-多项式?/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1718-"多项式"/
│ │ │ └── f-51Nod-1718-"多项式"/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1719-数值计算/
│ │ │ └── f-51Nod-1719-数值计算/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1732-51Nod婚姻介绍所/
│ │ │ └── f-51Nod-1732-51Nod婚姻介绍所/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1737-配对/
│ │ │ └── f-51Nod-1737-配对/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1742-开心的小Q/
│ │ │ └── f-51Nod-1742-开心的小Q/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1747-近似多项式/
│ │ │ └── f-51Nod-1747-近似多项式/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1753-相似子串/
│ │ │ └── f-51Nod-1753-相似子串/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1765-谷歌的恐龙/
│ │ │ └── f-51Nod-1765-谷歌的恐龙/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1766-树上的最远点对/
│ │ │ └── f-51Nod-1766-树上的最远点对/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1773-A国的贸易/
│ │ │ └── f-51Nod-1773-A国的贸易/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1779-逆序对统计/
│ │ │ └── f-51Nod-1779-逆序对统计/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1780-完美序列/
│ │ │ └── f-51Nod-1780-完美序列/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1781-Pinball/
│ │ │ └── f-51Nod-1781-Pinball/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1785-数据流中的算法/
│ │ │ └── f-51Nod-1785-数据流中的算法/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1791-合法括号子段/
│ │ │ └── f-51Nod-1791-合法括号子段/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1799-二分答案/
│ │ │ └── f-51Nod-1799-二分答案/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1800-汉诺塔/
│ │ │ └── f-51Nod-1800-汉诺塔/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1803-森林直径/
│ │ │ └── f-51Nod-1803-森林直径/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1804-小C的多边形/
│ │ │ └── f-51Nod-1804-小C的多边形/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1805-小树/
│ │ │ └── f-51Nod-1805-小树/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1806-wangyurzee的树/
│ │ │ └── f-51Nod-1806-wangyurzee的树/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1810-连续区间/
│ │ │ └── f-51Nod-1810-连续区间/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1811-联通分量计数/
│ │ │ └── f-51Nod-1811-联通分量计数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1815-调查任务/
│ │ │ └── f-51Nod-1815-调查任务/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1821-最优集合/
│ │ │ └── f-51Nod-1821-最优集合/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1829-函数/
│ │ │ └── f-51Nod-1829-函数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1831-小C的游戏/
│ │ │ └── f-51Nod-1831-小C的游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1832-先序遍历与后序遍历/
│ │ │ └── f-51Nod-1832-先序遍历与后序遍历/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1833-环/
│ │ │ └── f-51Nod-1833-环/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1835-完全图/
│ │ │ └── f-51Nod-1835-完全图/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1836-战忽局的手段/
│ │ │ └── f-51Nod-1836-战忽局的手段/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1837-砝码称重/
│ │ │ └── f-51Nod-1837-砝码称重/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1849-Clarke and package/
│ │ │ └── f-51Nod-1849-Clarke and package/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1859-Clarke and number/
│ │ │ └── f-51Nod-1859-Clarke and number/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1868-彩色树/
│ │ │ └── f-51Nod-1868-彩色树/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1874-字符串排序/
│ │ │ └── f-51Nod-1874-字符串排序/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1946-特殊表示法/
│ │ │ └── f-51Nod-1946-特殊表示法/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1952-栈/
│ │ │ └── f-51Nod-1952-栈/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1962-区间计数/
│ │ │ └── f-51Nod-1962-区间计数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1967-路径定向/
│ │ │ └── f-51Nod-1967-路径定向/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1969-Fire!/
│ │ │ └── f-51Nod-1969-Fire!/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1981-如何愉快地与STL玩耍/
│ │ │ └── f-51Nod-1981-如何愉快地与STL玩耍/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-1995-三子棋/
│ │ │ └── f-51Nod-1995-三子棋/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-2000-四边形分割平面/
│ │ │ └── f-51Nod-2000-四边形分割平面/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-2006-飞行员配对（二分图最大匹配）/
│ │ │ └── f-51Nod-2006-飞行员配对（二分图最大匹配）/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-2020-排序相减/
│ │ │ └── f-51Nod-2020-排序相减/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-TalkingData数据科学精英夏令营挑战赛-A-初中的算术/
│ │ │ └── f-51Nod-TalkingData数据科学精英夏令营挑战赛-A-初中的算术/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-TalkingData数据科学精英夏令营挑战赛-B-丢手绢/
│ │ │ └── f-51Nod-TalkingData数据科学精英夏令营挑战赛-B-丢手绢/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-TalkingData数据科学精英夏令营挑战赛-C-好数/
│ │ │ └── f-51Nod-TalkingData数据科学精英夏令营挑战赛-C-好数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-TalkingData数据科学精英夏令营挑战赛-D-数据流中的算法-众数/
│ │ │ └── f-51Nod-TalkingData数据科学精英夏令营挑战赛-D-数据流中的算法-众数/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-TalkingData数据科学精英夏令营挑战赛-E-路径定向/
│ │ │ └── f-51Nod-TalkingData数据科学精英夏令营挑战赛-E-路径定向/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-算法马拉松13-A-取余最长路/
│ │ │ └── f-51Nod-算法马拉松13-A-取余最长路/
│ │ │ └── main.c
│ │ ├── f-51Nod-算法马拉松13-B-数有几多愁/
│ │ │ └── f-51Nod-算法马拉松13-B-数有几多愁/
│ │ │ └── main.c
│ │ ├── f-51Nod-算法马拉松13-C-比大小/
│ │ │ └── f-51Nod-算法马拉松13-C-比大小/
│ │ │ └── main.c
│ │ ├── f-51Nod-算法马拉松15（脱欧专场）-A-B君的游戏/
│ │ │ └── f-51Nod-算法马拉松15（脱欧专场）-A-B君的游戏/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-算法马拉松16-A-B君的连通/
│ │ │ └── f-51Nod-算法马拉松16-A-B君的连通/
│ │ │ └── main.cpp
│ │ ├── f-51Nod-算法马拉松16-B-卷积和/
│ │ │ └── 51Nod-算法马拉松16-B-卷积和/
│ │ │ └── main.cpp
│ │ ├── f-BSG白山极客挑战赛-A-数数字/
│ │ │ └── f-BSG白山极客挑战赛-A-数数字/
│ │ │ └── main.c
│ │ ├── f-BSG白山极客挑战赛-B-AVL树的种类/
│ │ │ └── f-BSG白山极客挑战赛-B-AVL树的种类/
│ │ │ └── main.c
│ │ ├── f-算法马拉松17（告别奥运）-B-分解/
│ │ │ └── f-算法马拉松17（告别奥运）-B-分解/
│ │ │ └── main.cpp
│ │ ├── f-算法马拉松18-A-染色问题/
│ │ │ └── f-算法马拉松18-A-染色问题/
│ │ │ └── main.cpp
│ │ └── f-算法马拉松18-B-非010串/
│ │ └── f-算法马拉松18-B-非010串/
│ │ └── main.cpp
│ ├── BNUOJ/
│ │ └── f-BNUOJ-4052-BT马/
│ │ └── f-BNUOJ-4052-BT马/
│ │ └── main.c
│ ├── BZOJ/
│ │ └── f-BZOJ-2301-[HAOI2011]Problem b/
│ │ └── f-BZOJ-2301-[HAOI2011]Problem b/
│ │ └── main.cpp
│ ├── CCF/
│ │ ├── f-CCF模拟-1-出现次数最多的数/
│ │ │ └── f-CCF模拟-1-出现次数最多的数/
│ │ │ └── main.cpp
│ │ ├── f-CCF模拟-2-ISBN号码/
│ │ │ └── f-CCF模拟-2-ISBN号码/
│ │ │ └── main.cpp
│ │ ├── f-CCF模拟-3-最大的矩阵/
│ │ │ └── f-CCF模拟-3-最大的矩阵/
│ │ │ └── main.cpp
│ │ ├── f-CCF模拟-4-有趣的数/
│ │ │ └── f-CCF模拟-4-有趣的数/
│ │ │ └── main.cpp
│ │ └── f-CCF模拟-5-I’m stuck!/
│ │ └── f-CCF模拟-5-I’m stuck!/
│ │ └── main.cpp
│ ├── CDOJ/
│ │ ├── f-CDOJ-2016-A-柱爷与咸鱼神功/
│ │ │ └── f-CDOJ-2016-A-柱爷与咸鱼神功/
│ │ │ └── main.c
│ │ ├── f-CDOJ-2016-B-柱爷与最大区间和/
│ │ │ └── f-CDOJ-2016-B-柱爷与最大区间和/
│ │ │ └── main.c
│ │ ├── f-CDOJ-2016-C-柱爷的下凡/
│ │ │ └── f-CDOJ-2016-C-柱爷的下凡/
│ │ │ └── main.c
│ │ ├── f-CDOJ-2016-F-柱爷与三叉戟不得不说的故事/
│ │ │ └── f-CDOJ-2016-F-柱爷与三叉戟不得不说的故事/
│ │ │ └── main.c
│ │ └── f-CDOJ-2016-H-柱爷大战滑稽王/
│ │ └── f-CDOJ-2016-H-柱爷大战滑稽王/
│ │ └── main.c
│ ├── CF/
│ │ ├── f-BNU Training 2016.07.29 Div. 2-B-Levko and Table/
│ │ │ └── f-BNU Training 2016.07.29 Div. 2-B-Levko and Table/
│ │ │ └── main.cpp
│ │ ├── f-CF-Avito Code Challenge 2018-A-Antipalindrome/
│ │ │ └── f-CF-Avito Code Challenge 2018-A-Antipalindrome/
│ │ │ └── main.cpp
│ │ ├── f-CF-Avito Code Challenge 2018-B-Businessmen Problems/
│ │ │ └── f-CF-Avito Code Challenge 2018-B-Businessmen Problems/
│ │ │ └── main.cpp
│ │ ├── f-CF-Avito Code Challenge 2018-C-Useful Decomposition/
│ │ │ └── f-CF-Avito Code Challenge 2018-C-Useful Decomposition/
│ │ │ └── main.cpp
│ │ ├── f-CF-Avito Code Challenge 2018-D-Bookshelves/
│ │ │ └── f-CF-Avito Code Challenge 2018-D-Bookshelves/
│ │ │ └── main.cpp
│ │ ├── f-CF-Avito Code Challenge 2018-E-Addition on Segments/
│ │ │ └── f-CF-Avito Code Challenge 2018-E-Addition on Segments/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #210 (Div. 1)-A-Levko and Array Recovery/
│ │ │ └── f-CF-Codeforces Round #210 (Div. 1)-A-Levko and Array Recovery/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #365 (Div. 2)-A-Mishka and Game/
│ │ │ └── f-CF-Codeforces Round #365 (Div. 2)-A-Mishka and Game/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #365 (Div. 2)-B-Mishka and trip/
│ │ │ └── f-CF-Codeforces Round #365 (Div. 2)-B-Mishka and trip/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #366 (Div. 2)-A-Hulk/
│ │ │ └── f-CF-Codeforces Round #366 (Div. 2)-A-Hulk/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #377 (Div. 2)-A-Buy a Shovel/
│ │ │ └── f-CF-Codeforces Round #377 (Div. 2)-A-Buy a Shovel/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #377 (Div. 2)-B-Cormen — The Best Friend Of a Man/
│ │ │ └── f-CF-Codeforces Round #377 (Div. 2)-B-Cormen — The Best Friend Of a Man/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #392 (Div. 2)-A-Holiday Of Equality/
│ │ │ └── f-CF-Codeforces Round #392 (Div. 2)-A-Holiday Of Equality/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #392 (Div. 2)-B-Blown Garland/
│ │ │ └── f-CF-Codeforces Round #392 (Div. 2)-B-Blown Garland/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-A-Vicious Keyboard/
│ │ │ └── f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-A-Vicious Keyboard/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-B-Valued Keys/
│ │ │ └── f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-B-Valued Keys/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-C-Voltage Keepsake/
│ │ │ └── f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-C-Voltage Keepsake/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-D-Volatile Kite/
│ │ │ └── f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-D-Volatile Kite/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #410 (Div. 2)-A-Mike and palindrome/
│ │ │ └── f-CF-Codeforces Round #410 (Div. 2)-A-Mike and palindrome/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #410 (Div. 2)-B-Mike and strings/
│ │ │ └── f-CF-Codeforces Round #410 (Div. 2)-B-Mike and strings/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #410 (Div. 2)-C-Mike and gcd problem/
│ │ │ └── f-CF-Codeforces Round #410 (Div. 2)-C-Mike and gcd problem/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #410 (Div. 2)-D-Mike and distribution/
│ │ │ └── f-CF-Codeforces Round #410 (Div. 2)-D-Mike and distribution/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #418 (Div. 2)-C-An impassioned circulation of affection/
│ │ │ └── f-CF-Codeforces Round #418 (Div. 2)-C-An impassioned circulation of affection/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #420 (Div. 2)-A-Okabe and Future Gadget Laboratory/
│ │ │ └── f-CF-Codeforces Round #420 (Div. 2)-A-Okabe and Future Gadget Laboratory/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #420 (Div. 2)-B-Okabe and Banana Trees/
│ │ │ └── f-CF-Codeforces Round #420 (Div. 2)-B-Okabe and Banana Trees/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #420 (Div. 2)-C-Okabe and Boxes/
│ │ │ └── f-CF-Codeforces Round #420 (Div. 2)-C-Okabe and Boxes/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #420 (Div. 2)-D-Okabe and City/
│ │ │ └── f-CF-Codeforces Round #420 (Div. 2)-D-Okabe and City/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #420 (Div. 2)-E-Okabe and El Psy Kongroo/
│ │ │ └── f-CF-Codeforces Round #420 (Div. 2)-E-Okabe and El Psy Kongroo/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #483 (Div. 2)-A-Game/
│ │ │ └── f-CF-Codeforces Round #483 (Div. 2)-A-Game/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #483 (Div. 2)-B-Minesweeper/
│ │ │ └── f-CF-Codeforces Round #483 (Div. 2)-B-Minesweeper/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #483 (Div. 2)-C-Finite or not?/
│ │ │ └── f-CF-Codeforces Round #483 (Div. 2)-C-Finite or not?/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #483 (Div. 2)-D-XOR-pyramid/
│ │ │ └── f-CF-Codeforces Round #483 (Div. 2)-D-XOR-pyramid/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #485 (Div. 2)/
│ │ │ ├── A-Infinity Gauntlet/
│ │ │ │ └── main.cpp
│ │ │ ├── B-High School: Become Human/
│ │ │ │ └── main.cpp
│ │ │ ├── C-Three displays/
│ │ │ │ └── main.cpp
│ │ │ ├── D-Fair/
│ │ │ │ └── main.cpp
│ │ │ └── E-Petr and Permutations/
│ │ │ └── main.cpp
│ │ ├── f-CF-Codeforces Round #487 (Div. 2)/
│ │ │ ├── A-A Blend of Springtime/
│ │ │ │ └── main.cpp
│ │ │ ├── B-A Tide of Riverscape/
│ │ │ │ └── main.cpp
│ │ │ ├── C-A Mist of Florescence/
│ │ │ │ └── main.cpp
│ │ │ └── D-A Shade of Moonlight/
│ │ │ └── main.cpp
│ │ ├── f-CF-Educational Codeforces Round 15-A-Maximum Increase/
│ │ │ └── f-CF-Educational Codeforces Round 15-A-Maximum Increase/
│ │ │ └── main.cpp
│ │ ├── f-CF-Educational Codeforces Round 15-B-Powers of Two/
│ │ │ └── CF-Educational Codeforces Round 15-B-Powers of Two/
│ │ │ └── main.cpp
│ │ ├── f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-A-Chess Placing/
│ │ │ └── f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-A-Chess Placing/
│ │ │ └── main.cpp
│ │ ├── f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-B-Switches and Lamps/
│ │ │ └── f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-B-Switches and Lamps/
│ │ │ └── main.cpp
│ │ ├── f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-C-Liebig's Barrels/
│ │ │ └── f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-C-Liebig's Barrels/
│ │ │ └── main.cpp
│ │ ├── f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-D-Sand Fortress/
│ │ │ └── f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-D-Sand Fortress/
│ │ │ └── main.cpp
│ │ ├── f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-E-Pencils and Boxes/
│ │ │ └── f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-E-Pencils and Boxes/
│ │ │ └── main.cpp
│ │ ├── f-CF-Tinkoff Challenge-Elimination Round-A-Oleg and shares/
│ │ │ └── f-CF-Tinkoff Challenge-Elimination Round-A-Oleg and shares/
│ │ │ └── main.cpp
│ │ ├── f-CF-Tinkoff Challenge-Elimination Round-B-Igor and his way to work/
│ │ │ └── f-CF-Tinkoff Challenge-Elimination Round-B-Igor and his way to work/
│ │ │ └── main.cpp
│ │ ├── f-CF-Tinkoff Challenge-Elimination Round-C-Mice problem/
│ │ │ └── f-CF-Tinkoff Challenge-Elimination Round-C-Mice problem/
│ │ │ └── main.cpp
│ │ └── f-CF-Tinkoff Challenge-Elimination Round-D-Presents in Bankopolis/
│ │ └── f-CF-Tinkoff Challenge-Elimination Round-D-Presents in Bankopolis/
│ │ └── main.cpp
│ ├── EOJ/
│ │ ├── f-EOJ-大学生程序设计邀请赛（华东师范大学）-A-拼音魔法/
│ │ │ └── f-EOJ-大学生程序设计邀请赛（华东师范大学）-A-拼音魔法/
│ │ │ └── main.cpp
│ │ ├── f-EOJ-大学生程序设计邀请赛（华东师范大学）-B-分词/
│ │ │ └── f-EOJ-大学生程序设计邀请赛（华东师范大学）-B-分词/
│ │ │ └── main.cpp
│ │ ├── f-EOJ-大学生程序设计邀请赛（华东师范大学）-C-袋鼠妈妈找孩子/
│ │ │ └── f-EOJ-大学生程序设计邀请赛（华东师范大学）-C-袋鼠妈妈找孩子/
│ │ │ └── main.cpp
│ │ ├── f-EOJ-大学生程序设计邀请赛（华东师范大学）-D-实验室传染病/
│ │ │ └── f-EOJ-大学生程序设计邀请赛（华东师范大学）-D-实验室传染病/
│ │ │ └── main.cpp
│ │ ├── f-EOJ-大学生程序设计邀请赛（华东师范大学）-E-黑心啤酒厂/
│ │ │ └── f-EOJ-大学生程序设计邀请赛（华东师范大学）-E-黑心啤酒厂/
│ │ │ └── main.cpp
│ │ ├── f-EOJ-大学生程序设计邀请赛（华东师范大学）-F-丽娃河的狼人传说/
│ │ │ └── f-EOJ-大学生程序设计邀请赛（华东师范大学）-F-丽娃河的狼人传说/
│ │ │ └── main.cpp
│ │ ├── f-EOJ-大学生程序设计邀请赛（华东师范大学）-G-铁路修复计划/
│ │ │ └── f-EOJ-大学生程序设计邀请赛（华东师范大学）-G-铁路修复计划/
│ │ │ └── main.cpp
│ │ ├── f-EOJ-大学生程序设计邀请赛（华东师范大学）-H-法国传统舞蹈/
│ │ │ └── f-EOJ-大学生程序设计邀请赛（华东师范大学）-H-法国传统舞蹈/
│ │ │ └── main.cpp
│ │ └── f-EOJ-大学生程序设计邀请赛（华东师范大学）-I-七巧板/
│ │ └── f-EOJ-大学生程序设计邀请赛（华东师范大学）-I-七巧板/
│ │ └── main.cpp
│ ├── GDUT/
│ │ └── f-GDUT-1164-找出出现次数超过一半的数/
│ │ └── f-GDUT-1164-找出出现次数超过一半的数/
│ │ └── main.cpp
│ ├── HDU/
│ │ ├── ICPC Asia Regional Qingdao Online-1001-Apple/
│ │ │ └── ICPC Asia Regional Qingdao Online-1001-Apple/
│ │ │ └── main.cpp
│ │ ├── ICPC Asia Regional Qingdao Online-1003-The Dominator of Strings/
│ │ │ └── ICPC Asia Regional Qingdao Online-1003-The Dominator of Strings/
│ │ │ └── main.cpp
│ │ ├── ICPC Asia Regional Qingdao Online-1008-Chinese Zodiac/
│ │ │ └── ICPC Asia Regional Qingdao Online-1008-Chinese Zodiac/
│ │ │ └── main.cpp
│ │ ├── ICPC Asia Regional Qingdao Online-1009-Smallest Minimum Cut/
│ │ │ └── ICPC Asia Regional Qingdao Online-1009-Smallest Minimum Cut/
│ │ │ └── main.cpp
│ │ ├── ICPC Asia Regional Qingdao Online-1010-Brute Force Sorting/
│ │ │ └── ICPC Asia Regional Qingdao Online-1010-Brute Force Sorting/
│ │ │ └── main.cpp
│ │ ├── ICPC Asia Regional Qingdao Online-1011-A Cubic number and A Cubic Number/
│ │ │ └── ICPC Asia Regional Qingdao Online-1011-A Cubic number and A Cubic Number/
│ │ │ └── main.cpp
│ │ ├── ICPC Asia Regional Shenyang Online-1001-string string string/
│ │ │ └── ICPC Asia Regional Shenyang Online-1001-string string string/
│ │ │ └── main.cpp
│ │ ├── ICPC Asia Regional Shenyang Online-1002-cable cable cable/
│ │ │ └── ICPC Asia Regional Shenyang Online-1002-cable cable cable/
│ │ │ └── main.cpp
│ │ ├── ICPC Asia Regional Shenyang Online-1004-array array array/
│ │ │ └── ICPC Asia Regional Shenyang Online-1004-array array array/
│ │ │ └── main.cpp
│ │ ├── ICPC Asia Regional Shenyang Online-1005-number number number/
│ │ │ └── ICPC Asia Regional Shenyang Online-1005-number number number/
│ │ │ └── main.cpp
│ │ ├── ICPC Asia Regional Shenyang Online-1008-transaction transaction transaction/
│ │ │ └── ICPC Asia Regional Shenyang Online-1008-transaction transaction transaction/
│ │ │ └── main.cpp
│ │ ├── ICPC Asia Regional Shenyang Online-1012-card card card/
│ │ │ └── ICPC Asia Regional Shenyang Online-1012-card card card/
│ │ │ └── main.cpp
│ │ ├── f-2016"百度之星"-资格赛-1001-A/
│ │ │ └── f-2016"百度之星"-资格赛-1001-A/
│ │ │ └── main.c
│ │ ├── f-2017"百度之星"程序设计大赛-资格赛-1002-度度熊的王国战略/
│ │ │ └── f-2017"百度之星"程序设计大赛-资格赛-1002-度度熊的王国战略/
│ │ │ └── main.cpp
│ │ ├── f-2017"百度之星"程序设计大赛-资格赛-1003-度度熊与邪恶大魔王/
│ │ │ └── f-2017"百度之星"程序设计大赛-资格赛-1003-度度熊与邪恶大魔王/
│ │ │ └── main.cpp
│ │ ├── f-2017"百度之星"程序设计大赛-资格赛-1004-度度熊的午饭时光/
│ │ │ └── f-2017"百度之星"程序设计大赛-资格赛-1004-度度熊的午饭时光/
│ │ │ └── main.cpp
│ │ ├── f-HDOJ-2066-一个人的旅行/
│ │ │ └── f-HDOJ-2066-一个人的旅行/
│ │ │ └── main.c
│ │ ├── f-HDU-1003-Max Sum/
│ │ │ └── f-HDU-1003-Max Sum/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1004-Let the Balloon Rise/
│ │ │ └── f-HDU-1004-Let the Balloon Rise/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1005-Number Sequence/
│ │ │ └── f-HDU-1005-Number Sequence/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1007-Quoit Design/
│ │ │ └── f-HDU-1007-Quoit Design/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1008-Elevator/
│ │ │ └── f-HDU-1008-Elevator/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1009-FatMouse' Trade/
│ │ │ └── f-HDU-1009-FatMouse' Trade/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1010-Tempter of the Bone/
│ │ │ └── f-HDU-1010-Tempter of the Bone/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1011-Starship Troopers/
│ │ │ └── f-HDU-1011-Starship Troopers/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1021-Fibonacci Again/
│ │ │ └── f-HDU-1021-Fibonacci Again/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1050-Moving Tables/
│ │ │ └── f-HDU-1050-Moving Tables/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1102-Constructing Roads/
│ │ │ └── f-HDU-1102-Constructing Roads/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1142-A Walk Through the Forest/
│ │ │ └── f-HDU-1142-A Walk Through the Forest/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1162-Eddy's picture/
│ │ │ └── f-HDU-1162-Eddy's picture/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1166-敌兵布阵/
│ │ │ └── f-HDU-1166-敌兵布阵/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1176-免费馅饼/
│ │ │ └── f-HDU-1176-免费馅饼/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1198-Farm Irrigation/
│ │ │ └── f-HDU-1198-Farm Irrigation/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1213-How Many Tables/
│ │ │ └── f-HDU-1213-How Many Tables/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1217-Arbitrage/
│ │ │ └── f-HDU-1217-Arbitrage/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1224-Free DIY Tour/
│ │ │ └── f-HDU-1224-Free DIY Tour/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1232-畅通工程/
│ │ │ └── f-HDU-1232-畅通工程/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1233-还是畅通工程/
│ │ │ └── f-HDU-1233-还是畅通工程/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1245-Saving James Bond/
│ │ │ └── f-HDU-1245-Saving James Bond/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1272-小希的迷宫/
│ │ │ └── f-HDU-1272-小希的迷宫/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1286-找新朋友/
│ │ │ └── f-HDU-1286-找新朋友/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1301-Jungle Roads/
│ │ │ └── f-HDU-1301-Jungle Roads/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1317-XYZZY/
│ │ │ └── f-HDU-1317-XYZZY/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1325-Is It A Tree?/
│ │ │ └── f-HDU-1325-Is It A Tree?/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1385-Minimum Transport Cost/
│ │ │ └── f-HDU-1385-Minimum Transport Cost/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1394-Minimum Inversion Number/
│ │ │ └── f-HDU-1394-Minimum Inversion Number/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1402-A*B Problem Plus/
│ │ │ └── f-HDU-1402-A*B Problem Plus/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1512-Monkey King/
│ │ │ └── f-HDU-1512-Monkey King/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1532-Drainage Ditches/
│ │ │ └── f-HDU-1532-Drainage Ditches/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1535-Invitation Cards/
│ │ │ └── f-HDU-1535-Invitation Cards/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1546-Idiomatic Phrases Game/
│ │ │ └── f-HDU-1546-Idiomatic Phrases Game/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1548-A strange lift/
│ │ │ └── f-HDU-1548-A strange lift/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1558-Segment set/
│ │ │ └── f-HDU-1558-Segment set/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1573-X问题/
│ │ │ └── f-51Nod-1573-X问题/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1576-A÷B/
│ │ │ └── f-HDU-1576-A÷B/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1595-find the longest of the shortest/
│ │ │ └── f-HDU-1595-find the longest of the shortest/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1596-find the safest road/
│ │ │ └── f-HDU-1596-find the safest road/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1598-find the most comfortable road/
│ │ │ └── f-HDU-1598-find the most comfortable road/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1599-find the mincost route/
│ │ │ └── f-HDU-1599-find the mincost route/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1688-Sightseeing/
│ │ │ └── f-HDU-1688-Sightseeing/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1690-Bus System/
│ │ │ └── f-HDU-1690-Bus System/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1695-GCD/
│ │ │ └── f-HDU-1695-GCD/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1698-Just a Hook/
│ │ │ └── f-HDU-1698-Just a Hook/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1754-I Hate It/
│ │ │ └── f-HDU-1754-I Hate It/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1811-Rank of Tetris/
│ │ │ └── f-HDU-1811-Rank of Tetris/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1829-A Bug's Life/
│ │ │ └── f-HDU-1829-A Bug's Life/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1839-Delay Constrained Maximum Capacity Path/
│ │ │ └── f-HDU-1839-Delay Constrained Maximum Capacity Path/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1846-Brave Game/
│ │ │ └── f-HDU-1846-Brave Game/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1847-Good Luck in CET-4 Everybody!/
│ │ │ └── f-HDU-1847-Good Luck in CET-4 Everybody!/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1850-Being a Good Boy in Spring Festival/
│ │ │ └── f-HDU-1850-Being a Good Boy in Spring Festival/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1856-More is better/
│ │ │ └── f-HDU-1856-More is better/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1863-畅通工程/
│ │ │ └── f-HDU-1863-畅通工程/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1869-六度分离/
│ │ │ └── f-HDU-1869-六度分离/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1874-畅通工程续/
│ │ │ └── f-HDU-1874-畅通工程续/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1875-畅通工程再续/
│ │ │ └── f-HDU-1875-畅通工程再续/
│ │ │ └── main.cpp
│ │ ├── f-HDU-1879-继续畅通工程/
│ │ │ └── f-HDU-1879-继续畅通工程/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2000-ASCII码排序/
│ │ │ └── f-HDU-2000-ASCII码排序/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2007-平方和与立方和/
│ │ │ └── f-HDU-2007-平方和与立方和/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2010-水仙花数/
│ │ │ └── f-HDU-2010-水仙花数/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛1-1001-Add More Zero/
│ │ │ └── f-HDU-2017 多校训练赛1-1001-Add More Zero/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛1-1002-Balala Power!/
│ │ │ └── f-HDU-2017 多校训练赛1-1002-Balala Power!/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛1-1003-Colorful Tree/
│ │ │ └── f-HDU-2017 多校训练赛1-1003-Colorful Tree/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛1-1006-Function/
│ │ │ └── f-HDU-2017 多校训练赛1-1006-Function/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛1-1008-Hints of sd0061/
│ │ │ └── f-HDU-2017 多校训练赛1-1008-Hints of sd0061/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛1-1011-KazaQ's Socks/
│ │ │ └── f-HDU-2017 多校训练赛1-1011-KazaQ's Socks/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛10-1001-Admiral/
│ │ │ └── f-HDU-2017 多校训练赛10-1001-Admiral/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛10-1002-Array Challenge/
│ │ │ └── f-HDU-2017 多校训练赛10-1002-Array Challenge/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛10-1008-Monkeys/
│ │ │ └── f-HDU-2017 多校训练赛10-1008-Monkeys/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛10-1010-Schedule/
│ │ │ └── f-HDU-2017 多校训练赛10-1010-Schedule/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛10-1011-Two Paths/
│ │ │ └── f-HDU-2017 多校训练赛10-1011-Two Paths/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛2-1001-Is Derek lying?/
│ │ │ └── f-HDU-2017 多校训练赛2-1001-Is Derek lying?/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛2-1003-Maximum Sequence/
│ │ │ └── f-HDU-2017 多校训练赛2-1003-Maximum Sequence/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛2-1006-Funny Function/
│ │ │ └── f-HDU-2017 多校训练赛2-1006-Funny Function/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛2-1008-To my boyfriend/
│ │ │ └── f-HDU-2017 多校训练赛2-1008-To my boyfriend/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛2-1009-TrickGCD/
│ │ │ └── f-HDU-2017 多校训练赛2-1009-TrickGCD/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛2-1011-Regular polygon/
│ │ │ └── f-HDU-2017 多校训练赛2-1011-Regular polygon/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛3-1001-simple counting problem/
│ │ │ └── f-HDU-2017 多校训练赛3-1001-simple counting problem/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛3-1003-Kanade’s sum/
│ │ │ └── f-HDU-2017 多校训练赛3-1003-Kanade’s sum/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛3-1004-Kanade's trio/
│ │ │ └── f-HDU-2017 多校训练赛3-1004-Kanade's trio/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛3-1005-RXD and dividing/
│ │ │ └── f-HDU-2017 多校训练赛3-1005-RXD and dividing/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛3-1008-RXD and math/
│ │ │ └── f-HDU-2017 多校训练赛3-1008-RXD and math/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛3-1011-RXD's date/
│ │ │ └── f-HDU-2017 多校训练赛3-1011-RXD's date/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛4-1003-Counting Divisors/
│ │ │ └── f-HDU-2017 多校训练赛4-1003-Counting Divisors/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛4-1004-Dirt Ratio/
│ │ │ └── f-HDU-2017 多校训练赛4-1004-Dirt Ratio/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛4-1007-Matching In Multiplication/
│ │ │ └── f-HDU-2017 多校训练赛4-1007-Matching In Multiplication/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛4-1009-Questionnaire/
│ │ │ └── f-HDU-2017 多校训练赛4-1009-Questionnaire/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛4-1011-Time To Get Up/
│ │ │ └── f-HDU-2017 多校训练赛4-1011-Time To Get Up/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛4-1012-Wavel Sequence/
│ │ │ └── f-HDU-2017 多校训练赛4-1012-Wavel Sequence/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛5-1001-Rikka with Candies/
│ │ │ └── f-HDU-2017 多校训练赛5-1001-Rikka with Candies/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛5-1006-Rikka with Graph/
│ │ │ └── f-HDU-2017 多校训练赛5-1006-Rikka with Graph/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛5-1008-Rikka with Subset/
│ │ │ └── f-HDU-2017 多校训练赛5-1008-Rikka with Subset/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛5-1011-Rikka with Competition/
│ │ │ └── f-HDU-2017 多校训练赛5-1011-Rikka with Competition/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛6-1002-Mindis/
│ │ │ └── f-HDU-2017 多校训练赛6-1002-Mindis/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛6-1003-Inversion/
│ │ │ └── f-HDU-2017 多校训练赛6-1003-Inversion/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛6-1007-GCDispower/
│ │ │ └── f-HDU-2017 多校训练赛6-1007-GCDispower/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛6-1008-Kirinriki/
│ │ │ └── f-HDU-2017 多校训练赛6-1008-Kirinriki/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛6-1010-Gameia/
│ │ │ └── f-HDU-2017 多校训练赛6-1010-Gameia/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛6-1011-Classes/
│ │ │ └── f-HDU-2017 多校训练赛6-1011-Classes/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛7-1002-Build a tree/
│ │ │ └── f-HDU-2017 多校训练赛7-1002-Build a tree/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛7-1005-Euler theorem/
│ │ │ └── f-HDU-2017 多校训练赛7-1005-Euler theorem/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛7-1008-Hard challenge/
│ │ │ └── f-HDU-2017 多校训练赛7-1008-Hard challenge/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛7-1010-Just do it/
│ │ │ └── f-HDU-2017 多校训练赛7-1010-Just do it/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛7-1011-Kolakoski/
│ │ │ └── f-HDU-2017 多校训练赛7-1011-Kolakoski/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛8-1002-Battlestation Operational/
│ │ │ └── f-HDU-2017 多校训练赛8-1002-Battlestation Operational/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛8-1006-Fleet of the Eternal Throne/
│ │ │ └── f-HDU-2017 多校训练赛8-1006-Fleet of the Eternal Throne/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛8-1008-Hybrid Crystals/
│ │ │ └── f-HDU-2017 多校训练赛8-1008-Hybrid Crystals/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛8-1011-Killer Names/
│ │ │ └── f-HDU-2017 多校训练赛8-1011-Killer Names/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛9-1002-Ch’s gift/
│ │ │ └── f-HDU-2017 多校训练赛9-1002-Ch’s gift/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛9-1005-FFF at Valentine/
│ │ │ └── f-HDU-2017 多校训练赛9-1005-FFF at Valentine/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛9-1006-Senior Pan/
│ │ │ └── f-HDU-2017 多校训练赛9-1006-Senior Pan/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛9-1008-Numbers/
│ │ │ └── f-HDU-2017 多校训练赛9-1008-Numbers/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017 多校训练赛9-1010-Two strings/
│ │ │ └── f-HDU-2017 多校训练赛9-1010-Two strings/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017"百度之星"程序设计大赛-初赛(B)-1001-Chess/
│ │ │ └── f-HDU-2017"百度之星"程序设计大赛-初赛(B)-1001-Chess/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017"百度之星"程序设计大赛-初赛(B)-1002-Factory/
│ │ │ └── f-HDU-2017"百度之星"程序设计大赛-初赛(B)-1002-Factory/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017"百度之星"程序设计大赛-初赛(B)-1005-度度熊的交易计划/
│ │ │ └── f-HDU-2017"百度之星"程序设计大赛-初赛(B)-1005-度度熊的交易计划/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017"百度之星"程序设计大赛-初赛(B)-1006-小小粉丝度度熊/
│ │ │ └── f-HDU-2017"百度之星"程序设计大赛-初赛(B)-1006-小小粉丝度度熊/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017"百度之星"程序设计大赛-复赛-1001-Arithmetic of Bomb/
│ │ │ └── f-HDU-2017"百度之星"程序设计大赛-复赛-1001-Arithmetic of Bomb/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017"百度之星"程序设计大赛-复赛-1003-Pokémon GO/
│ │ │ └── f-HDU-2017"百度之星"程序设计大赛-复赛-1003-Pokémon GO/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017"百度之星"程序设计大赛-复赛-1005-Valley Numer/
│ │ │ └── f-HDU-2017"百度之星"程序设计大赛-复赛-1005-Valley Numer/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017"百度之星"程序设计大赛-复赛-1006-Valley Numer II/
│ │ │ └── f-HDU-2017"百度之星"程序设计大赛-复赛-1006-Valley Numer II/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1001-Vertex Cover/
│ │ │ └── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1001-Vertex Cover/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1003-Friend-Graph/
│ │ │ └── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1003-Friend-Graph/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1004-A Secret/
│ │ │ └── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1004-A Secret/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1005-CaoHaha's staff/
│ │ │ └── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1005-CaoHaha's staff/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1006-Subsequence Count/
│ │ │ └── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1006-Subsequence Count/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1007-Palindrome Function/
│ │ │ └── f-HDU-2017中国大学生程序设计竞赛-网络选拔赛-1007-Palindrome Function/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2050-折线分割平面/
│ │ │ └── f-HDU-2050-折线分割平面/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2058-The sum problem/
│ │ │ └── f-HDU-2058-The sum problem/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2066-一个人的旅行/
│ │ │ └── f-HDU-2066-一个人的旅行/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2112-HDU Today/
│ │ │ └── f-HDU-2112-HDU Today/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2121-Ice_cream’s world II/
│ │ │ └── f-HDU-2121-Ice_cream’s world II/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2211-杀人游戏/
│ │ │ └── f-HDU-2211-杀人游戏/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2224-The shortest path/
│ │ │ └── f-HDU-2224-The shortest path/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2363-Cycling/
│ │ │ └── f-HDU-2363-Cycling/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2377-Bus Pass/
│ │ │ └── f-HDU-2377-Bus Pass/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2473-Junk-Mail Filter/
│ │ │ └── f-HDU-2473-Junk-Mail Filter/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2489-Minimal Ratio Tree/
│ │ │ └── f-HDU-2489-Minimal Ratio Tree/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2490-Parade/
│ │ │ └── f-HDU-2490-Parade/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2516-取石子游戏/
│ │ │ └── f-HDU-2516-取石子游戏/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2544-最短路/
│ │ │ └── f-HDU-2544-最短路/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2586-How far away ？/
│ │ │ └── f-HDU-2586-How far away ？/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2588-GCD/
│ │ │ └── f-HDU-2588-GCD/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2680-Choose the best route/
│ │ │ └── f-HDU-2680-Choose the best route/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2722-Here We Go(relians) Again/
│ │ │ └── f-HDU-2722-Here We Go(relians) Again/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2795-Billboard/
│ │ │ └── f-HDU-2795-Billboard/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2807-The Shortest Path/
│ │ │ └── f-HDU-2807-The Shortest Path/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2818-Building Block/
│ │ │ └── f-HDU-2818-Building Block/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2833-WuKong/
│ │ │ └── f-HDU-2833-WuKong/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2874-Connections between cities/
│ │ │ └── f-HDU-2874-Connections between cities/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2888-Check Corners/
│ │ │ └── f-HDU-2888-Check Corners/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2923-Einbahnstrasse/
│ │ │ └── f-HDU-2923-Einbahnstrasse/
│ │ │ └── main.cpp
│ │ ├── f-HDU-2962-Trucking/
│ │ │ └── f-HDU-2962-Trucking/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3035-War/
│ │ │ └── f-HDU-3035-War/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3038-How Many Answers Are Wrong/
│ │ │ └── f-HDU-3038-How Many Answers Are Wrong/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3047-Zjnu Stadium/
│ │ │ └── f-HDU-3047-Zjnu Stadium/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3138-Coconuts/
│ │ │ └── f-HDU-3138-Coconuts/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3172-Virtual Friends/
│ │ │ └── f-HDU-3172-Virtual Friends/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3183-A Magic Lamp/
│ │ │ └── f-HDU-3183-A Magic Lamp/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3191-How Many Paths Are There/
│ │ │ └── f-HDU-3191-How Many Paths Are There/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3237-Help Bubu/
│ │ │ └── f-HDU-3237-Help Bubu/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3308-LCIS/
│ │ │ └── f-HDU-3308-LCIS/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3311-Dig The Wells/
│ │ │ └── f-HDU-3311-Dig The Wells/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3339-In Action/
│ │ │ └── f-HDU-3339-In Action/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3364-Lanterns/
│ │ │ └── f-HDU-3364-Lanterns/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3367-Pseudoforest/
│ │ │ └── f-HDU-3367-Pseudoforest/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3371-Connect the Cities/
│ │ │ └── f-HDU-3371-Connect the Cities/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3397-Sequence operation/
│ │ │ └── f-HDU-3397-Sequence operation/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3461-Code Lock/
│ │ │ └── f-HDU-3461-Code Lock/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3486-Interviewe/
│ │ │ └── f-HDU-3486-Interviewe/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3549-Flow Problem/
│ │ │ └── f-HDU-3549-Flow Problem/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3572-Task Schedule/
│ │ │ └── f-HDU-3572-Task Schedule/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3631-Shortest Path/
│ │ │ └── f-HDU-3631-Shortest Path/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3635-Dragon Balls/
│ │ │ └── f-HDU-3635-Dragon Balls/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3672-Caves/
│ │ │ └── f-HDU-3672-Caves/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3757-Evacuation Plan/
│ │ │ └── f-HDU-3757-Evacuation Plan/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3768-Shopping/
│ │ │ └── f-HDU-3768-Shopping/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3790-最短路径问题/
│ │ │ └── f-HDU-3790-最短路径问题/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3832-Earth Hour/
│ │ │ └── f-HDU-3832-Earth Hour/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3860-Circuit Board/
│ │ │ └── f-HDU-3860-Circuit Board/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3870-Catch the Theves/
│ │ │ └── f-HDU-3870-Catch the Theves/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3923-Invoker/
│ │ │ └── f-HDU-3923-Invoker/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3926-Hand in Hand/
│ │ │ └── f-HDU-3926-Hand in Hand/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3938-Portal/
│ │ │ └── f-HDU-3938-Portal/
│ │ │ └── main.cpp
│ │ ├── f-HDU-3986-Harry Potter and the Final Battle/
│ │ │ └── f-HDU-3986-Harry Potter and the Final Battle/
│ │ │ └── main.cpp
│ │ ├── f-HDU-4009-Transfer water/
│ │ │ └── f-HDU-4009-Transfer water/
│ │ │ └── main.cpp
│ │ ├── f-HDU-4081-Qin Shi Huang's National Road System/
│ │ │ └── f-HDU-4081-Qin Shi Huang's National Road System/
│ │ │ └── main.cpp
│ │ ├── f-HDU-4114-Disney's FastPass/
│ │ │ └── f-HDU-4114-Disney's FastPass/
│ │ │ └── main.cpp
│ │ ├── f-HDU-4179-Difficult Routes/
│ │ │ └── f-HDU-4179-Difficult Routes/
│ │ │ └── main.cpp
│ │ ├── f-HDU-4405-Aeroplane chess/
│ │ │ └── f-HDU-4405-Aeroplane chess/
│ │ │ └── main.cpp
│ │ ├── f-HDU-4609-3-idiots/
│ │ │ └── f-HDU-4609-3-idiots/
│ │ │ └── main.cpp
│ │ ├── f-HDU-4651-Partition/
│ │ │ └── f-HDU-4651-Partition/
│ │ │ └── main.cpp
│ │ ├── f-HDU-4658-Integer Partition/
│ │ │ └── f-HDU-4658-Integer Partition/
│ │ │ └── main.cpp
│ │ ├── f-HDU-4841-圆桌问题/
│ │ │ └── f-HDU-4841-圆桌问题/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5512-Pagodas/
│ │ │ └── f-HDU-5512-Pagodas/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5514-Frogs/
│ │ │ └── f-HDU-5514-Frogs/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5517-Triple/
│ │ │ └── f-HDU-5517-Triple/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5534-Partial Tree/
│ │ │ └── f-HDU-5534-Partial Tree/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5556-Land of Farms/
│ │ │ └── f-HDU-5556-Land of Farms/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5558-Alice's Classified Message/
│ │ │ └── f-HDU-5558-Alice's Classified Message/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5559-Frog and String/
│ │ │ └── f-HDU-5559-Frog and String/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5572-An Easy Physics Problem/
│ │ │ └── f-HDU-5572-An Easy Physics Problem/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5575-Discover Water Tank/
│ │ │ └── f-HDU-5575-Discover Water Tank/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5584-LCM Walk/
│ │ │ └── f-HDU-5584-LCM Walk/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5698-瞬间移动/
│ │ │ └── f-HDU-5698-瞬间移动/
│ │ │ └── main.c
│ │ ├── f-HDU-5700-区间交/
│ │ │ └── f-HDU-5700-区间交/
│ │ │ └── main.c
│ │ ├── f-HDU-5701-中位数计数/
│ │ │ └── f-HDU-5701-中位数计数/
│ │ │ └── main.c
│ │ ├── f-HDU-5791-Two/
│ │ │ └── f-HDU-5791-Two/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5833-Zhu and 772002/
│ │ │ └── f-HDU-5833-Zhu and 772002/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5874-Friends and Enemies/
│ │ │ └── f-HDU-5874-Friends and Enemies/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5877-Weak Pair/
│ │ │ └── f-HDU-5877-Weak Pair/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5878-I Count Two Three/
│ │ │ └── f-HDU-5878-I Count Two Three/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5879-Cure/
│ │ │ └── f-HDU-5879-Cure/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5881-Tea/
│ │ │ └── f-HDU-5881-Tea/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5883-The Best Path/
│ │ │ └── f-HDU-5883-The Best Path/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5884-Sort/
│ │ │ └── f-HDU-5884-Sort/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5886-Tower Defence/
│ │ │ └── f-HDU-5886-Tower Defence/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5889-Barricade/
│ │ │ └── f-HDU-5889-Barricade/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5912-Fraction/
│ │ │ └── f-HDU-5912-Fraction/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5933-ArcSoft's Office Rearrangement/
│ │ │ └── f-HDU-5933-ArcSoft's Office Rearrangement/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5935-Car/
│ │ │ └── f-HDU-5935-Car/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5943-Kingdom of Obsession/
│ │ │ └── f-HDU-5943-Kingdom of Obsession/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5955-Guessing the Dice Roll/
│ │ │ └── f-HDU-5955-Guessing the Dice Roll/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5982-Relic Discovery/
│ │ │ └── f-HDU-5982-Relic Discovery/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5984-Pocky/
│ │ │ └── f-HDU-5984-Pocky/
│ │ │ └── main.cpp
│ │ ├── f-HDU-5985-Lucky Coins/
│ │ │ └── f-HDU-5985-Lucky Coins/
│ │ │ └── main.cpp
│ │ ├── f-HDU-6000-Wash/
│ │ │ └── f-HDU-6000-Wash/
│ │ │ └── main.cpp
│ │ ├── f-HDU-6004-Periodical Cicadas/
│ │ │ └── f-HDU-6004-Periodical Cicadas/
│ │ │ └── main.cpp
│ │ ├── f-HDU-6006-Engineer Assignment/
│ │ │ └── f-HDU-6006-Engineer Assignment/
│ │ │ └── main.cpp
│ │ ├── f-HDU-6008-Worried School/
│ │ │ └── f-HDU-6008-Worried School/
│ │ │ └── main.cpp
│ │ ├── f-HDU-6010-Daylight Saving Time/
│ │ │ └── f-HDU-6010-Daylight Saving Time/
│ │ │ └── main.cpp
│ │ └── f-HDU-6249-Alice’s Stamps/
│ │ └── f-HDU-6249-Alice’s Stamps/
│ │ └── main.cpp
│ ├── HENUOJ/
│ │ └── f-HENUOJ-1036-B-小女♂孩采蘑菇/
│ │ └── f-HENUOJ-1036-B-小女♂孩采蘑菇/
│ │ └── main.cpp
│ ├── HOJ/
│ │ └── f-HOJ-1983-Beautiful numbers/
│ │ └── f-HOJ-1983-Beautiful numbers/
│ │ └── main.cpp
│ ├── HPU/
│ │ └── f-HPU-1008-Mod/
│ │ └── f-HPU-1008-Mod/
│ │ └── main.cpp
│ ├── HRBUST/
│ │ └── f-HRBUST-1025-JiaoZhu and WAR3/
│ │ └── f-HRBUST-1025-JiaoZhu and WAR3/
│ │ └── main.cpp
│ ├── NEUQ/
│ │ ├── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-A-谷神的赌博游戏/
│ │ │ └── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-A-谷神的赌博游戏/
│ │ │ └── main.cpp
│ │ ├── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-B-一个简单的问题/
│ │ │ └── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-B-一个简单的问题/
│ │ │ └── main.cpp
│ │ ├── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-C-来简单地数个数/
│ │ │ └── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-C-来简单地数个数/
│ │ │ └── main.cpp
│ │ ├── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-D-简单图形输出/
│ │ │ └── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-D-简单图形输出/
│ │ │ └── main.cpp
│ │ ├── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-E-简单的RMQ/
│ │ │ └── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-E-简单的RMQ/
│ │ │ └── main.cpp
│ │ ├── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-F-一道简单的递推题/
│ │ │ └── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-F-一道简单的递推题/
│ │ │ └── main.cpp
│ │ ├── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-G-那么大奶牛之神/
│ │ │ └── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-G-那么大奶牛之神/
│ │ │ └── main.cpp
│ │ ├── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-H-简单的机械臂设计/
│ │ │ └── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-H-简单的机械臂设计/
│ │ │ └── main.cpp
│ │ ├── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-I-一道不简单的题目/
│ │ │ └── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-I-一道不简单的题目/
│ │ │ └── main.cpp
│ │ └── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-J-简单的变位词/
│ │ └── f-图灵杯-第四届“图灵杯”NEUQ-ACM 程序设计竞赛-J-简单的变位词/
│ │ └── main.cpp
│ ├── NYOJ/
│ │ ├── f-2016河南ACM省赛-A-表达式求值/
│ │ │ └── f-2016河南ACM省赛-A-表达式求值/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1070-诡异的电梯[Ⅰ]/
│ │ │ └── f-NYOJ-1070-诡异的电梯[Ⅰ]/
│ │ │ └── main.c
│ │ ├── f-NYOJ-108-士兵杀敌（一）/
│ │ │ └── f-NYOJ-108-士兵杀敌（一）/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-110-剑客决斗/
│ │ │ └── f-NYOJ-110-剑客决斗/
│ │ │ └── main.c
│ │ ├── f-NYOJ-116-士兵杀敌（二）/
│ │ │ └── f-NYOJ-116-士兵杀敌（二）/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-12-喷水装置（二）/
│ │ │ └── f-NYOJ-12-喷水装置（二）/
│ │ │ └── main.c
│ │ ├── f-NYOJ-1235-A÷B Problem/
│ │ │ └── f-NYOJ-1235-A÷B Problem/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1236-挑战密室/
│ │ │ └── f-NYOJ-1236-挑战密室/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1237-最大岛屿/
│ │ │ └── f-NYOJ-1237-最大岛屿/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1238-最少换乘/
│ │ │ └── f-NYOJ-1238-最少换乘/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1239-引水工程/
│ │ │ └── f-NYOJ-1239-引水工程/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1249-物资调度/
│ │ │ └── f-NYOJ-1249-物资调度/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1250-机器人/
│ │ │ └── f-NYOJ-1250-机器人/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1251-山区修路/
│ │ │ └── f-NYOJ-1251-山区修路/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1252-世界之威/
│ │ │ └── f-NYOJ-1252-世界之威/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1255-Rectangles/
│ │ │ └── f-NYOJ-1255-Rectangles/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1273-宣传墙/
│ │ │ └── f-NYOJ-1273-宣传墙/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-1276-机器设备/
│ │ │ └── f-NYOJ-1276-机器设备/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-14-会场安排问题/
│ │ │ └── f-NYOJ-14-会场安排问题/
│ │ │ └── main.c
│ │ ├── f-NYOJ-15-括号匹配（二）/
│ │ │ └── f-NYOJ-15-括号匹配（二）/
│ │ │ └── main.c
│ │ ├── f-NYOJ-16-矩形嵌套/
│ │ │ └── f-NYOJ-16-矩形嵌套/
│ │ │ └── main.c
│ │ ├── f-NYOJ-17-单调递增最长子序列/
│ │ │ └── f-NYOJ-17-单调递增最长子序列/
│ │ │ └── main.c
│ │ ├── f-NYOJ-18-The Triangle/
│ │ │ └── f-NYOJ-18-The Triangle/
│ │ │ └── main.c
│ │ ├── f-NYOJ-19-擅长排列的小明/
│ │ │ └── f-NYOJ-19-擅长排列的小明/
│ │ │ └── main.c
│ │ ├── f-NYOJ-2-括号配对问题/
│ │ │ └── f-NYOJ-2-括号配对问题/
│ │ │ └── main.c
│ │ ├── f-NYOJ-20-吝啬的国度/
│ │ │ └── f-NYOJ-20-吝啬的国度/
│ │ │ └── main.c
│ │ ├── f-NYOJ-201-作业题/
│ │ │ └── f-NYOJ-201-作业题/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-21-三个水杯/
│ │ │ └── f-NYOJ-21-三个水杯/
│ │ │ └── main.c
│ │ ├── f-NYOJ-24-素数距离问题/
│ │ │ └── f-NYOJ-24-素数距离问题/
│ │ │ └── main.c
│ │ ├── f-NYOJ-26-孪生素数问题/
│ │ │ └── f-NYOJ-26-孪生素数问题/
│ │ │ └── main.c
│ │ ├── f-NYOJ-27-水池数目/
│ │ │ └── f-NYOJ-27-水池数目/
│ │ │ └── main.c
│ │ ├── f-NYOJ-28-大数阶乘/
│ │ │ └── f-NYOJ-28-大数阶乘/
│ │ │ └── main.c
│ │ ├── f-NYOJ-32-组合数/
│ │ │ └── f-NYOJ-32-组合数/
│ │ │ └── main.c
│ │ ├── f-NYOJ-33-蛇形填数/
│ │ │ └── f-NYOJ-33-蛇形填数/
│ │ │ └── main.c
│ │ ├── f-NYOJ-35-表达式求值/
│ │ │ └── f-NYOJ-35-表达式求值/
│ │ │ └── main.c
│ │ ├── f-NYOJ-37-回文字符串/
│ │ │ └── f-NYOJ-37-回文字符串/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-417-死神来了/
│ │ │ └── f-NYOJ-417-死神来了/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-46-最少乘法次数/
│ │ │ └── f-NYOJ-46-最少乘法次数/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-5-Binary String Matching/
│ │ │ └── f-NYOJ-5-Binary String Matching/
│ │ │ └── main.c
│ │ ├── f-NYOJ-6-喷水装置（一）/
│ │ │ └── f-NYOJ-6-喷水装置（一）/
│ │ │ └── main.c
│ │ ├── f-NYOJ-7-街区最短路径问题/
│ │ │ └── f-NYOJ-7-街区最短路径问题/
│ │ │ └── main.c
│ │ ├── f-NYOJ-739-笨蛋难题四/
│ │ │ └── f-NYOJ-739-笨蛋难题四/
│ │ │ └── main.cpp
│ │ ├── f-NYOJ-8-一种排序/
│ │ │ └── f-NYOJ-8-一种排序/
│ │ │ └── main.c
│ │ ├── f-NYOJ-999-师傅又被妖怪抓走了/
│ │ │ └── f-NYOJ-999-师傅又被妖怪抓走了/
│ │ │ └── main.cpp
│ │ ├── f-河南第十届ACM省赛-C-最小密钥/
│ │ │ └── f-河南第十届ACM省赛-C-最小密钥/
│ │ │ └── main.cpp
│ │ ├── f-河南第十届ACM省赛-D-年终奖金/
│ │ │ └── f-河南第十届ACM省赛-D-年终奖金/
│ │ │ └── main.cpp
│ │ ├── f-河南第十届ACM省赛-E-八纵八横/
│ │ │ └── f-河南第十届ACM省赛-E-八纵八横/
│ │ │ └── main.cpp
│ │ └── f-河南第十届ACM省赛-I-Transmit information/
│ │ └── f-河南第十届ACM省赛-I-Transmit information/
│ │ └── main.cpp
│ ├── NZAU/
│ │ ├── f-NZAU-C-Mine Sweeping Game/
│ │ │ └── f-NZAU-C-Mine Sweeping Game/
│ │ │ └── main.c
│ │ └── f-NZAU-F-The Nearest Same Chocolate/
│ │ └── f-NZAU-F-The Nearest Same Chocolate/
│ │ └── main.c
│ ├── PAT/
│ │ ├── f-PAT-2017年团体程序设计天梯赛-大区赛-L2-4-功夫传人/
│ │ │ └── f-PAT-2017年团体程序设计天梯赛-大区赛-L2-4-功夫传人/
│ │ │ └── main.cpp
│ │ ├── f-PAT-L1-006-连续因子/
│ │ │ └── f-PAT-L1-006-连续因子/
│ │ │ └── main.cpp
│ │ ├── f-PAT-天梯赛习题集-L2-018-多项式A除以B/
│ │ │ └── f-PAT-天梯赛习题集-L2-018-多项式A除以B/
│ │ │ └── main.cpp
│ │ ├── f-PAT-天梯赛习题集-L3-013-非常弹的球/
│ │ │ └── f-PAT-天梯赛习题集-L3-013-非常弹的球/
│ │ │ └── main.cpp
│ │ ├── f-PAT-天梯赛习题集-L3-014-周游世界/
│ │ │ └── f-PAT-天梯赛习题集-L3-014-周游世界/
│ │ │ └── main.cpp
│ │ └── f-PAT-天梯赛习题集-L3-015-球队“食物链”/
│ │ └── f-PAT-天梯赛习题集-L3-015-球队“食物链”/
│ │ └── main.cpp
│ ├── POJ/
│ │ ├── f-POJ-1061-青蛙的约会/
│ │ │ └── f-POJ-1061-青蛙的约会/
│ │ │ └── main.c
│ │ ├── f-POJ-1681-Painter's Problem/
│ │ │ └── f-POJ-1681-Painter's Problem/
│ │ │ └── main.cpp
│ │ ├── f-POJ-1729-Jack and Jill/
│ │ │ └── f-POJ-1729-Jack and Jill/
│ │ │ └── main.cpp
│ │ ├── f-POJ-1811-Prime Test/
│ │ │ └── f-POJ-1811-Prime Test/
│ │ │ └── main.cpp
│ │ ├── f-POJ-1845-Sumdiv/
│ │ │ └── f-POJ-1845-Sumdiv/
│ │ │ └── main.cpp
│ │ ├── f-POJ-1961-Period/
│ │ │ └── f-POJ-1961-Period/
│ │ │ └── main.cpp
│ │ ├── f-POJ-1985-Cow Marathon/
│ │ │ └── f-POJ-1985-Cow Marathon/
│ │ │ └── main.cpp
│ │ ├── f-POJ-2096-Collecting Bugs/
│ │ │ └── f-POJ-2096-Collecting Bugs/
│ │ │ └── main.cpp
│ │ ├── f-POJ-2185-Milking Grid/
│ │ │ └── f-POJ-2185-Milking Grid/
│ │ │ └── main.cpp
│ │ ├── f-POJ-2406-Power Strings/
│ │ │ └── f-POJ-2406-Power Strings/
│ │ │ └── main.cpp
│ │ ├── f-POJ-2752-Seek the Name, Seek the Fame/
│ │ │ └── f-POJ-2752-Seek the Name, Seek the Fame/
│ │ │ └── main.cpp
│ │ ├── f-POJ-3461-Oulipo/
│ │ │ └── f-POJ-3461-Oulipo/
│ │ │ └── main.cpp
│ │ ├── f-POJ-3744-Scout YYF I/
│ │ │ └── f-POJ-3744-Scout YYF I/
│ │ │ └── main.cpp
│ │ ├── f-POJ-3866-Exclusive Access 2/
│ │ │ └── f-POJ-3866-Exclusive Access 2/
│ │ │ └── main.cpp
│ │ └── f-POJ-机加工表面/
│ │ └── f-POJ-机加工表面/
│ │ └── main.c
│ ├── Project Eular/
│ │ └── f-Project Eular-71-Ordered fractions/
│ │ └── f-Project Eular-71-Ordered fractions/
│ │ └── main.cpp
│ ├── SHU/
│ │ ├── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-A-黑白图像直方图/
│ │ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-A-黑白图像直方图/
│ │ │ └── main.cpp
│ │ ├── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-B-神无月排位赛/
│ │ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-B-神无月排位赛/
│ │ │ └── main.cpp
│ │ ├── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-C-I Love ces/
│ │ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-C-I Love ces/
│ │ │ └── main.cpp
│ │ ├── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-D-添加好友/
│ │ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-D-添加好友/
│ │ │ └── main.cpp
│ │ ├── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-E-字符串进制转换/
│ │ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-E-字符串进制转换/
│ │ │ └── main.cpp
│ │ ├── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-F-A序列/
│ │ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-F-A序列/
│ │ │ └── main.cpp
│ │ ├── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-G-战斗/
│ │ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-G-战斗/
│ │ │ └── main.cpp
│ │ ├── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-H-调和序列/
│ │ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-H-调和序列/
│ │ │ └── main.cpp
│ │ ├── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-I-丢史蒂芬妮/
│ │ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-I-丢史蒂芬妮/
│ │ │ └── main.cpp
│ │ ├── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-J-膜一下将带给你好运/
│ │ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-J-膜一下将带给你好运/
│ │ │ └── main.cpp
│ │ ├── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-K-购买装备/
│ │ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-K-购买装备/
│ │ │ └── main.cpp
│ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-M-风力观测/
│ │ └── f-SHU-“盛大游戏杯”第15届上海大学程序设计联赛夏季赛暨上海高校金马五校赛-M-风力观测/
│ │ └── main.cpp
│ ├── THU/
│ │ ├── f-THU-2016-3-1-TSP/
│ │ │ └── f-THU-2016-3-1-TSP/
│ │ │ └── main.cpp
│ │ └── f-THU-2016-3-2-Pokeface/
│ │ └── f-THU-2016-3-2-Pokeface/
│ │ └── main.cpp
│ ├── UVA/
│ │ ├── f-UVA-11600-Masud Rana/
│ │ │ └── f-UVA-11600-Masud Rana/
│ │ │ └── main.cpp
│ │ └── f-UVA-12260-Free Goodies/
│ │ └── f-UVA-12260-Free Goodies/
│ │ └── main.cpp
│ ├── UVALive/
│ │ ├── f-UVALive-4394-String painter/
│ │ │ └── f-UVALive-4394-String painter/
│ │ │ └── main.cpp
│ │ ├── f-UVALive-7500-Boxes and Balls/
│ │ │ └── f-UVALive-7500-Boxes and Balls/
│ │ │ └── main.cpp
│ │ ├── f-UVALive-7509-Dome and Steles/
│ │ │ └── f-UVALive-7509-Dome and Steles/
│ │ │ └── main.cpp
│ │ └── f-UVALive-7512-November 11th/
│ │ └── f-UVALive-7512-November 11th/
│ │ └── main.cpp
│ ├── VJ/
│ │ ├── f-[kuangbin带你飞]专题二-搜索进阶-A-Eight/
│ │ │ └── f-[kuangbin带你飞]专题二-搜索进阶-A-Eight/
│ │ │ └── main.cpp
│ │ ├── f-[kuangbin带你飞]专题二-搜索进阶-B-Eight II/
│ │ │ └── f-[kuangbin带你飞]专题二-搜索进阶-B-Eight II/
│ │ │ └── main.cpp
│ │ ├── f-[kuangbin带你飞]专题二-搜索进阶-C-哈密顿绕行世界问题/
│ │ │ └── f-[kuangbin带你飞]专题二-搜索进阶-C-哈密顿绕行世界问题/
│ │ │ └── main.cpp
│ │ └── f-[kuangbin带你飞]专题二-搜索进阶-D-Escape/
│ │ └── f-[kuangbin带你飞]专题二-搜索进阶-D-Escape/
│ │ └── main.cpp
│ ├── ZOJ/
│ │ ├── f-ZOJ-3329-One Person Game/
│ │ │ └── f-ZOJ-3329-One Person Game/
│ │ │ └── main.cpp
│ │ ├── f-ZOJ-People Counting/
│ │ │ └── f-ZOJ-People Counting/
│ │ │ └── main.c
│ │ ├── f-ZOJ-The 14th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple-A-Cooking Competition/
│ │ │ └── f-ZOJ-The 14th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple-A-Cooking Competition/
│ │ │ └── main.cpp
│ │ ├── f-ZOJ-The 14th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple-B-Problem Preparation/
│ │ │ └── f-ZOJ-The 14th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple-B-Problem Preparation/
│ │ │ └── main.cpp
│ │ ├── f-ZOJ-The 14th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple-C-What Kind of Friends Are You?/
│ │ │ └── f-ZOJ-The 14th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple-C-What Kind of Friends Are You?/
│ │ │ └── main.cpp
│ │ ├── f-ZOJ-The 14th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple-D-Let's Chat/
│ │ │ └── f-ZOJ-The 14th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple-D-Let's Chat/
│ │ │ └── main.cpp
│ │ └── f-ZOJ-The 14th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple-E-Seven Segment Display/
│ │ └── f-ZOJ-The 14th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple-E-Seven Segment Display/
│ │ └── main.cpp
│ ├── ZZUACM/
│ │ ├── f-ZZUACM-Tutti!/
│ │ │ └── f-ZZUACM-Tutti!/
│ │ │ └── main.c
│ │ ├── f-ZZUACM-最长匹配子串/
│ │ │ └── f-ZZUACM-最长匹配子串/
│ │ │ └── main.c
│ │ ├── f-ZZUACM-词法分析器/
│ │ │ └── f-ZZUACM-词法分析器/
│ │ │ └── main.c
│ │ └── f-ZZUACM-追踪术/
│ │ └── f-ZZUACM-追踪术/
│ │ └── main.c
│ ├── ZZULIOJ/
│ │ ├── f-ZZULIOJ-多校训练（985专场）-A-985的字符串难题/
│ │ │ └── f-ZZULIOJ-多校训练（985专场）-A-985的字符串难题/
│ │ │ └── main.cpp
│ │ ├── f-ZZULIOJ-多校训练（985专场）-C-985的方格难题/
│ │ │ └── f-ZZULIOJ-多校训练（985专场）-C-985的方格难题/
│ │ │ └── main.cpp
│ │ ├── f-ZZULIOJ-多校训练（985专场）-D-985的0-1串难题/
│ │ │ └── f-ZZULIOJ-多校训练（985专场）-D-985的0-1串难题/
│ │ │ └── main.cpp
│ │ └── f-轻院选拔赛-最后一题/
│ │ └── f-轻院选拔赛-最后一题/
│ │ └── main.c
│ ├── hiho/
│ │ ├── f-hiho-hihoCoder挑战赛29-A-序列的值/
│ │ │ └── f-hiho-hihoCoder挑战赛29-A-序列的值/
│ │ │ └── main.cpp
│ │ ├── f-hiho-hihoCoder挑战赛29-B-快速乘法/
│ │ │ └── f-hiho-hihoCoder挑战赛29-B-快速乘法/
│ │ │ └── main.cpp
│ │ └── f-hiho-hihoCoder挑战赛29-D-不上升序列/
│ │ └── f-hiho-hihoCoder挑战赛29-D-不上升序列/
│ │ └── main.cpp
│ ├── 出处遗忘/
│ │ ├── f-2016CCPC-A-A water problem/
│ │ │ └── f-2016CCPC-A-A water problem/
│ │ │ └── main.cpp
│ │ ├── f-2016CCPC-B-Zhu and 772002/
│ │ │ └── f-2016CCPC-B-Zhu and 772002/
│ │ │ └── main.cpp
│ │ ├── f-2016CCPC-D-Danganronpa/
│ │ │ └── f-2016CCPC-D-Danganronpa/
│ │ │ └── main.cpp
│ │ ├── f-2016年多大学培训大赛4-1012-Bubble Sort/
│ │ │ └── f-2016年多大学培训大赛4-1012-Bubble Sort/
│ │ │ └── main.cpp
│ │ ├── f-C/
│ │ │ ├── mainOne.cpp
│ │ │ └── mainTwo.c
│ │ ├── f-DES/
│ │ │ └── f-DES/
│ │ │ ├── DES.cpp
│ │ │ ├── DES.hpp
│ │ │ └── main.cpp
│ │ ├── f-DES(C)/
│ │ │ └── f-DES(C)/
│ │ │ └── main.cpp
│ │ ├── f-GSJS/
│ │ │ └── f-GSJS/
│ │ │ ├── main.cpp
│ │ │ ├── radianToAngle.cpp
│ │ │ └── radianToAngle.hpp
│ │ ├── f-NOI-30-字符环/
│ │ │ └── f-NOI-30-字符环/
│ │ │ └── main.c
│ │ ├── f-NOIP-2009-分数线划定/
│ │ │ └── f-NOIP-2009-分数线划定/
│ │ │ └── main.c
│ │ ├── f-Permutations/
│ │ │ └── f-Permutations/
│ │ │ └── main.c
│ │ ├── f-cdecl/
│ │ │ └── f-cdecl/
│ │ │ └── main.cpp
│ │ ├── f-kwic/
│ │ │ └── f-kwic/
│ │ │ └── main.cpp
│ │ ├── f-work2/
│ │ │ └── f-work2/
│ │ │ ├── file.cpp
│ │ │ ├── file.hpp
│ │ │ └── main.cpp
│ │ ├── f-乐视2017实习-偶数大翻转/
│ │ │ └── f-乐视2017实习-偶数大翻转/
│ │ │ └── main.cpp
│ │ ├── f-乐视2017实习-兵临城下/
│ │ │ └── f-乐视2017实习-兵临城下/
│ │ │ └── main.cpp
│ │ ├── f-乐视2017实习-幻兽交易/
│ │ │ └── f-乐视2017实习-幻兽交易/
│ │ │ └── main.cpp
│ │ ├── f-交谊舞/
│ │ │ └── f-交谊舞/
│ │ │ └── main.c
│ │ ├── f-今日头条2018校招-字母交换/
│ │ │ └── f-今日头条2018校招-字母交换/
│ │ │ └── main.cpp
│ │ ├── f-树的遍历/
│ │ │ └── f-树的遍历/
│ │ │ └── main.c
│ │ ├── f-湖南人文科技-1659-不一样的解密/
│ │ │ └── f-湖南人文科技-1659-不一样的解密/
│ │ │ └── main.c
│ │ ├── f-爱奇艺2018秋招-最后一位/
│ │ │ └── f-爱奇艺2018秋招-最后一位/
│ │ │ └── main.cpp
│ │ ├── f-爱奇艺2018秋招-缺失的括号/
│ │ │ └── f-爱奇艺2018秋招-缺失的括号/
│ │ │ └── main.cpp
│ │ ├── f-生日相同2.0/
│ │ │ └── f-生日相同2.0/
│ │ │ └── main.c
│ │ ├── f-百度2016实习-XML文档/
│ │ │ └── f-爱奇艺2018秋招-XML文档/
│ │ │ └── main.cpp
│ │ ├── f-百度2016实习-乘法表/
│ │ │ └── f-百度2016实习-乘法表/
│ │ │ └── main.cpp
│ │ ├── f-百度2016实习-编号转换/
│ │ │ └── f-百度2016实习-编号转换/
│ │ │ └── main.cpp
│ │ ├── f-腾讯2017暑期实习生编程题-A-构造回文/
│ │ │ └── f-腾讯2017暑期实习生编程题-A-构造回文/
│ │ │ └── main.cpp
│ │ ├── f-腾讯2017暑期实习生编程题-B-算法基础-字符移位/
│ │ │ └── f-腾讯2017暑期实习生编程题-B-算法基础-字符移位/
│ │ │ └── main.cpp
│ │ ├── f-腾讯2017暑期实习生编程题-C-有趣的数字/
│ │ │ └── f-腾讯2017暑期实习生编程题-C-有趣的数字/
│ │ │ └── main.cpp
│ │ ├── f-计算对角线元素之和/
│ │ │ └── f-计算对角线元素之和/
│ │ │ └── main.c
│ │ ├── f-阿里编程测试-问答题1/
│ │ │ └── f-阿里编程测试-问答题1/
│ │ │ └── main.cpp
│ │ ├── 二路插入.cpp
│ │ ├── 今日头条2018测试/
│ │ │ ├── 4.cpp
│ │ │ └── 5.cpp
│ │ ├── 今日头条2018算法/
│ │ │ ├── 3.cpp
│ │ │ ├── 4.cpp
│ │ │ └── 5.cpp
│ │ ├── 归并.cpp
│ │ ├── 拼多多2018内推/
│ │ │ ├── 1.cpp
│ │ │ ├── 2.cpp
│ │ │ ├── 3.cpp
│ │ │ └── 4.cpp
│ │ ├── 红黑树.cpp
│ │ ├── 网易2018校园招聘编程题真题集合/
│ │ │ ├── 1.cpp
│ │ │ ├── 2.cpp
│ │ │ ├── 3.cpp
│ │ │ ├── 4.cpp
│ │ │ ├── 5.cpp
│ │ │ ├── 6.cpp
│ │ │ ├── 7.cpp
│ │ │ └── 8.cpp
│ │ ├── 网易2018校招内推编程题集合/
│ │ │ ├── 1.cpp
│ │ │ ├── 2.cpp
│ │ │ ├── 3.cpp
│ │ │ ├── 4.cpp
│ │ │ ├── 5.cpp
│ │ │ ├── 6.cpp
│ │ │ ├── 7.cpp
│ │ │ └── 8.cpp
│ │ └── 辗转相除法.c
│ ├── 牛客网/
│ │ ├── f-牛客网-2018 美团 CodeM 编程大赛-初赛 A 轮/
│ │ │ ├── 1-遥控按键/
│ │ │ │ └── main.cpp
│ │ │ ├── 2-下棋/
│ │ │ │ └── main.cpp
│ │ │ └── 3-城市漫游/
│ │ │ └── main.cpp
│ │ ├── f-牛客网-2018 美团 CodeM 编程大赛-初赛 B 轮/
│ │ │ ├── 1-开关灯/
│ │ │ │ └── main.cpp
│ │ │ ├── 3-低位值/
│ │ │ │ └── main.cpp
│ │ │ └── 4-神奇盘子/
│ │ │ └── main.cpp
│ │ ├── f-牛客网-2018 美团 CodeM 编程大赛-资格赛/
│ │ │ ├── 1-下单/
│ │ │ │ └── main.cpp
│ │ │ ├── 2-可乐/
│ │ │ │ └── main.cpp
│ │ │ ├── 3-世界杯/
│ │ │ │ └── main.cpp
│ │ │ ├── 4-分数/
│ │ │ │ └── main.cpp
│ │ │ └── 5-你的城市/
│ │ │ └── main.cpp
│ │ └── f-牛客网-剑指Offer/
│ │ ├── 二维数组中的查找/
│ │ │ └── main.cpp
│ │ ├── 从尾到头打印链表/
│ │ │ └── main.cpp
│ │ └── 替换空格/
│ │ └── main.cpp
│ ├── 玲珑杯/
│ │ ├── f-"玲珑杯“ ACM热身赛 # 0.5-A-Alarm/
│ │ │ └── f-"玲珑杯“ ACM热身赛 # 0.5-A-Alarm/
│ │ │ └── main.cpp
│ │ ├── f-"玲珑杯“ ACM热身赛 # 0.5-B-Battle/
│ │ │ └── f-"玲珑杯“ ACM热身赛 # 0.5-B-Battle/
│ │ │ └── main.cpp
│ │ ├── f-“玲珑杯”ACM比赛 Round #1-A-Absolute Defeat/
│ │ │ └── f-“玲珑杯”ACM比赛 Round #1-A-Absolute Defeat/
│ │ │ └── main.cpp
│ │ └── f-“玲珑杯”ACM比赛 Round #10-A-Black and White/
│ │ └── f-“玲珑杯”ACM比赛 Round #10-A-Black and White/
│ │ └── main.cpp
│ ├── 百炼/
│ │ └── f-百练-2456-Aggressive cows/
│ │ └── f-百练-2456-Aggressive cows/
│ │ └── main.cpp
│ ├── 码农谷/
│ │ ├── f-2016码农谷全国大学生程序设计邀请赛（测试赛）-试题一-将字符串中的字符按规则重新排列/
│ │ │ └── f-2016码农谷全国大学生程序设计邀请赛（测试赛）-试题一-将字符串中的字符按规则重新排列/
│ │ │ └── main.cpp
│ │ ├── f-2016码农谷全国大学生程序设计邀请赛（测试赛）-试题三-将数分成两组，使得两组中各元素的和相等/
│ │ │ └── f-2016码农谷全国大学生程序设计邀请赛（测试赛）-试题三-将数分成两组，使得两组中各元素的和相等/
│ │ │ └── main.cpp
│ │ ├── f-2016码农谷全国大学生程序设计邀请赛（测试赛）-试题二-统计出以某个字符串为前缀的单词数量/
│ │ │ └── f-2016码农谷全国大学生程序设计邀请赛（测试赛）-试题二-统计出以某个字符串为前缀的单词数量/
│ │ │ └── main.cpp
│ │ ├── f-2016码农谷全国大学生程序设计邀请赛（测试赛）-试题四-求二进制数字符串的和/
│ │ │ └── f-2016码农谷全国大学生程序设计邀请赛（测试赛）-试题四-求二进制数字符串的和/
│ │ │ └── main.cpp
│ │ ├── f-2016码农谷全国大学生程序设计邀请赛（第一轮资格赛）-试题一 对码农的编程水平进行排名/
│ │ │ └── f-2016码农谷全国大学生程序设计邀请赛（第一轮资格赛）-试题一 对码农的编程水平进行排名/
│ │ │ └── main.cpp
│ │ ├── f-2016码农谷全国大学生程序设计邀请赛（第一轮资格赛）-试题三 将一个英文语句以单词为单位逆序排序/
│ │ │ └── f-2016码农谷全国大学生程序设计邀请赛（第一轮资格赛）-试题三 将一个英文语句以单词为单位逆序排序/
│ │ │ └── main.cpp
│ │ ├── f-2016码农谷全国大学生程序设计邀请赛（第一轮资格赛）-试题二 奇怪的数字：6174/
│ │ │ └── f-2016码农谷全国大学生程序设计邀请赛（第一轮资格赛）-试题二 奇怪的数字：6174/
│ │ │ └── main.cpp
│ │ └── f-2016码农谷全国大学生程序设计邀请赛（第一轮资格赛）-试题四 小码农挑选资源的方案数/
│ │ └── f-2016码农谷全国大学生程序设计邀请赛（第一轮资格赛）-试题四 小码农挑选资源的方案数/
│ │ └── main.cpp
│ ├── 蓝桥杯/
│ │ ├── f-ADV-1-两条直线/
│ │ │ └── f-ADV-1-两条直线/
│ │ │ └── main.c
│ │ ├── f-ADV-144-01背包/
│ │ │ └── f-ADV-144-01背包/
│ │ │ └── main.c
│ │ ├── f-ADV-158-新建Microsoft Word文档/
│ │ │ └── f-ADV-158-新建Microsoft Word文档/
│ │ │ └── main.c
│ │ ├── f-ADV-200-求最大值/
│ │ │ └── f-ADV-200-求最大值/
│ │ │ └── main.c
│ │ ├── f-ADV-215-Problem S4: Interesting Numbers 加强版/
│ │ │ └── f-ADV-215-Problem S4: Interesting Numbers 加强版/
│ │ │ └── main.c
│ │ ├── f-ADV-3-金属采集/
│ │ │ └── f-ADV-3-金属采集/
│ │ │ └── main.c
│ │ ├── f-ALGO-116-最大的算式/
│ │ │ └── f-ALGO-116-最大的算式/
│ │ │ └── main.c
│ │ ├── f-ALGO-133-Tricky and Clever Password/
│ │ │ └── f-ALGO-133-Tricky and Clever Password/
│ │ │ └── main.c
│ │ ├── f-ALGO-137-Lift and Throw/
│ │ │ └── f-ALGO-137-Lift and Throw/
│ │ │ └── main.c
│ │ ├── f-ALGO-142-P1103/
│ │ │ └── f-ALGO-142-P1103/
│ │ │ └── main.c
│ │ ├── f-ALGO-144-2-3逆序打印数字/
│ │ │ └── f-ALGO-144-2-3逆序打印数字/
│ │ │ └── main.c
│ │ ├── f-ALGO-4-结点选择/
│ │ │ └── f-ALGO-4-结点选择/
│ │ │ └── main.c
│ │ ├── f-ALGO-48-关联矩阵/
│ │ │ └── f-ALGO-48-关联矩阵/
│ │ │ └── main.c
│ │ ├── f-ALGO-5-最短路/
│ │ │ └── f-ALGO-5-最短路/
│ │ │ └── main.c
│ │ ├── f-ALGO-6-安慰奶牛/
│ │ │ └── f-ALGO-6-安慰奶牛/
│ │ │ └── main.c
│ │ ├── f-ALGO-8-操作格子/
│ │ │ └── f-ALGO-8-操作格子/
│ │ │ └── main.c
│ │ ├── f-ALGO-87-字串统计/
│ │ │ └── f-ALGO-87-字串统计/
│ │ │ └── main.c
│ │ ├── f-ALGO-90-出现次数最多的整数/
│ │ │ └── f-ALGO-90-出现次数最多的整数/
│ │ │ └── main.c
│ │ ├── f-BASIC-12-十六进制转八进制/
│ │ │ └── f-BASIC-12-十六进制转八进制/
│ │ │ └── main.c
│ │ ├── f-PREV-2-打印十字图/
│ │ │ └── f-PREV-2-打印十字图/
│ │ │ └── main.c
│ │ ├── f-PREV-3-带分数/
│ │ │ └── f-PREV-3-带分数/
│ │ │ └── main.c
│ │ ├── f-PREV-5-错误票据/
│ │ │ └── f-PREV-5-错误票据/
│ │ │ └── main.c
│ │ ├── f-蓝桥-ALGO-10-集合运算/
│ │ │ └── f-蓝桥-ALGO-10-集合运算/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-11-瓷砖铺放/
│ │ │ └── f-蓝桥-ALGO-11-瓷砖铺放/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-12-幂方分解/
│ │ │ └── f-蓝桥-ALGO-12-幂方分解/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-13-拦截导弹/
│ │ │ └── f-蓝桥-ALGO-13-拦截导弹/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-14-回文数/
│ │ │ └── f-蓝桥-ALGO-14-回文数/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-15-旅行家的预算/
│ │ │ └── f-蓝桥-ALGO-15-旅行家的预算/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-16-进制转换/
│ │ │ └── f-蓝桥-ALGO-16-进制转换/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-17-乘积最大/
│ │ │ └── f-蓝桥-ALGO-17-乘积最大/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-18-单词接龙/
│ │ │ └── f-蓝桥-ALGO-18-单词接龙/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-19-方格取数/
│ │ │ └── f-蓝桥-ALGO-19-方格取数/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-20-求先序排列/
│ │ │ └── f-蓝桥-ALGO-20-求先序排列/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-22-整数划分/
│ │ │ └── f-蓝桥-ALGO-22-整数划分/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-23-一元三次方程求解/
│ │ │ └── f-蓝桥-ALGO-23-一元三次方程求解/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-24-统计单词个数/
│ │ │ └── f-蓝桥-ALGO-24-统计单词个数/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-25-Car的旅行路线/
│ │ │ └── f-蓝桥-ALGO-25-Car的旅行路线/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-26-麦森数/
│ │ │ └── f-蓝桥-ALGO-26-麦森数/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-27-FBI树/
│ │ │ └── f-蓝桥-ALGO-27-FBI树/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-28-星际交流/
│ │ │ └── f-蓝桥-ALGO-28-星际交流/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-29-校门外的树/
│ │ │ └── f-蓝桥-ALGO-29-校门外的树/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-32-JAM计数法/
│ │ │ └── f-蓝桥-ALGO-32-JAM计数法/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-33-数列/
│ │ │ └── f-蓝桥-ALGO-33-数列/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-34-纪念品分组/
│ │ │ └── f-蓝桥-ALGO-34-纪念品分组/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-35-传球游戏/
│ │ │ └── f-蓝桥-ALGO-35-传球游戏/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-36-传纸条/
│ │ │ └── f-蓝桥-ALGO-36-传纸条/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-37-Hankson的趣味题/
│ │ │ └── f-蓝桥-ALGO-37-Hankson的趣味题/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-38-接水问题/
│ │ │ └── f-蓝桥-ALGO-38-接水问题/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-40-会议中心/
│ │ │ └── f-蓝桥-ALGO-40-会议中心/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-44-采油区域/
│ │ │ └── f-蓝桥-ALGO-44-采油区域/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥-ALGO-9-摆动序列/
│ │ │ └── f-蓝桥-ALGO-9-摆动序列/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥杯-历届试题-PREV-13-网络寻路/
│ │ │ └── f-蓝桥杯-历届试题-PREV-13-网络寻路/
│ │ │ └── main.cpp
│ │ ├── f-蓝桥杯省A-剪邮票/
│ │ │ └── f-蓝桥杯省A-剪邮票/
│ │ │ └── main.c
│ │ ├── f-蓝桥杯省A-四平方和/
│ │ │ └── f-蓝桥杯省A-四平方和/
│ │ │ └── main.c
│ │ ├── f-蓝桥杯省A-密码脱落/
│ │ │ └── f-蓝桥杯省A-密码脱落/
│ │ │ └── main.c
│ │ ├── f-蓝桥杯省A-寒假作业/
│ │ │ └── f-蓝桥杯省A-寒假作业/
│ │ │ └── main.c
│ │ ├── f-蓝桥杯省A-方格填数/
│ │ │ └── f-蓝桥杯省A-方格填数/
│ │ │ └── main.c
│ │ └── f-蓝桥杯省A-最大比例/
│ │ └── f-蓝桥杯省A-最大比例/
│ │ └── main.c
│ └── 计蒜客/
│ ├── f-2016-计蒜之道-初赛-第二场-A-联想公司的logo设计/
│ │ └── f-2016-计蒜之道-初赛-第二场-A-联想公司的logo设计/
│ │ └── main.c
│ ├── f-2016-计蒜之道-初赛-第二场-B-联想的显示屏校准/
│ │ └── f-2016-计蒜之道-初赛-第二场-B-联想的显示屏校准/
│ │ └── main.c
│ ├── f-2016-计蒜之道-初赛-第五场-A-腾讯的一笔画游戏/
│ │ └── f-2016-计蒜之道-初赛-第五场-A-腾讯的一笔画游戏/
│ │ └── main.cpp
│ ├── f-2016-计蒜之道-初赛-第四场-A-淘宝流量分配/
│ │ └── f-2016-计蒜之道-初赛-第四场-A-淘宝流量分配/
│ │ └── main.cpp
│ ├── f-2016-计蒜之道-初赛-第四场-B、C、D-遗失的支付宝密码/
│ │ └── f-2016-计蒜之道-初赛-第四场-B、C、D-遗失的支付宝密码/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-A-Banana/
│ │ └── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-A-Banana/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-B-Out-out-control cars/
│ │ └── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-B-Out-out-control cars/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-C-Coconut/
│ │ └── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-C-Coconut/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-E-Half-consecutive Numbers/
│ │ └── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-E-Half-consecutive Numbers/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-F-Islands/
│ │ └── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-F-Islands/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-G-Query on a string/
│ │ └── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-G-Query on a string/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-H-Skiing/
│ │ └── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-H-Skiing/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-J-Our Journey of Dalian Ends/
│ │ └── f-计蒜客-2017 ACM-ICPC 亚洲区（乌鲁木齐赛区）网络赛-J-Our Journey of Dalian Ends/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 计蒜之道 初赛 第六场-A-微软手机的信号显示/
│ │ └── f-计蒜客-2017 计蒜之道 初赛 第六场-A-微软手机的信号显示/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 计蒜之道 初赛 第六场-B-微软大楼设计方案（简单）/
│ │ └── f-计蒜客-2017 计蒜之道 初赛 第六场-B-微软大楼设计方案（简单）/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 计蒜之道 复赛-A-阿里云秘钥池/
│ │ └── f-计蒜客-2017 计蒜之道 复赛-A-阿里云秘钥池/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 计蒜之道 复赛-B-Windows 画图/
│ │ └── f-计蒜客-2017 计蒜之道 复赛-B-Windows 画图/
│ │ └── main.cpp
│ ├── f-计蒜客-2017 计蒜之道 复赛-D-百度地图导航/
│ │ └── f-计蒜客-2017 计蒜之道 复赛-D-百度地图导航/
│ │ └── main.cpp
│ └── f-计蒜客-2017 计蒜之道 复赛-F-腾讯消消乐/
│ └── f-计蒜客-2017 计蒜之道 复赛-F-腾讯消消乐/
│ └── main.cpp
└── 相关资源/
├── DOC/
│ ├── C语言归并、选择、直接插入、希尔、冒泡、快速、堆排序与顺序、二分查找排序.docx
│ ├── C语言程序190例.doc
│ ├── C语言算法100例.doc
│ ├── C语言趣味程序设计编程百例精解.doc
│ └── 经典算法50例（绝对经典）.doc
├── OI国家集训队论文集1999~2016/
│ ├── 国家集训队2000论文集/
│ │ ├── 谢婧--规模化问题的解题策略/
│ │ │ ├── land.5
│ │ │ ├── land.6
│ │ │ ├── land.7
│ │ │ ├── land.8
│ │ │ ├── land.9
│ │ │ └── 谢婧论文.doc
│ │ ├── 郭一--数学模型及其在信息学竞赛中的应用/
│ │ │ └── 郭一论文.doc
│ │ ├── 陈彧--信息学竞赛中的思维方法/
│ │ │ └── 陈彧论文.doc
│ │ ├── 骆骥--数学模型的建立和选择/
│ │ │ └── 骆骥论文.DOC
│ │ ├── 高寒蕊--递推关系的建立及在信息学竞赛中的应用/
│ │ │ └── 高寒蕊论文.doc
│ │ └── 龙翀--解决空间规模问题的几种常用的存储结构/
│ │ └── 龙翀论文.doc
│ ├── 国家集训队2001论文集/
│ │ ├── 俞玮--基本动态规划问题的扩展/
│ │ │ └── 俞玮.doc
│ │ ├── 刘汝佳--搬运工问题的启示/
│ │ │ ├── Chapter3.doc
│ │ │ ├── chapter1.doc
│ │ │ ├── chapter2.doc
│ │ │ ├── content.doc
│ │ │ └── preface.doc
│ │ ├── 张一飞--求n！的高精度算法/
│ │ │ └── 张一飞i.ppt
│ │ ├── 李源--树的枚举/
│ │ │ └── 李源.ppt
│ │ ├── 李益明--发言稿/
│ │ │ └── 李益明.doc
│ │ ├── 毛子青--动态规划算法的优化技巧/
│ │ │ ├── 毛子青.doc
│ │ │ └── 毛子青.ppt
│ │ ├── 江鹏--从一道题目的解法试谈网络流的构造与算法/
│ │ │ └── 江鹏.doc
│ │ ├── 符文杰--Pólya原理及其应用/
│ │ │ └── 符文杰.doc
│ │ ├── 骆骥--由“汽车问题”浅谈深度搜索的一个方面/
│ │ │ └── 骆骥.doc
│ │ ├── 高寒蕊--从圆桌问题谈数据结构的综合运用/
│ │ │ ├── Paper_Show.doc
│ │ │ ├── ghr_mine1.doc
│ │ │ └── ghr_pub1.doc
│ │ └── 高岳--中等硬度解题报告/
│ │ └── 高岳.doc
│ ├── 国家集训队2002论文集/
│ │ ├── 何林--猜想及其应用/
│ │ │ ├── 何林.doc
│ │ │ └── 何林.ppt
│ │ ├── 何江舟--用高斯消元解线性方程组/
│ │ │ └── 何江舟.ppt
│ │ ├── 俞玮--ulam的游戏及编码/
│ │ │ └── 俞玮.pps
│ │ ├── 周文超--树结构在程序设计中的应用/
│ │ │ └── 周文超.PPT
│ │ ├── 孙方成--偶图的算法及应用/
│ │ │ ├── 孙方成.doc
│ │ │ └── 孙方成.ppt
│ │ ├── 孙林春--从《parity》的解法/
│ │ │ └── 孙林春.ppt
│ │ ├── 张一飞--透析一类搏弈游戏的解答过程/
│ │ │ ├── 张一飞.doc
│ │ │ └── 张一飞.ppt
│ │ ├── 张宁--遗传算法的特点及其应用/
│ │ │ ├── 张宁.doc
│ │ │ └── 张宁.ppt
│ │ ├── 张家琳--多项式乘法/
│ │ │ └── 张家琳.ppt
│ │ ├── 戴德承--目标转化思想”的若干应用/
│ │ │ └── 戴德承.doc
│ │ ├── 方奇--浅谈必要条件的应用/
│ │ │ └── 方奇.doc
│ │ ├── 李澎煦--半平面交的算法及其应用/
│ │ │ ├── 李澎煦.doc
│ │ │ └── 李澎煦.ppt
│ │ ├── 李睿--二分法与统计问题/
│ │ │ ├── 李睿.doc
│ │ │ └── 李睿.ppt
│ │ ├── 杨旻旻--构造法/
│ │ │ └── 杨旻旻.ppt
│ │ ├── 王知昆--搜索顺序的选择/
│ │ │ └── 王知昆.ppt
│ │ ├── 符文杰--排序网络/
│ │ │ └── 符文杰.doc
│ │ ├── 许智磊--二分，再二分/
│ │ │ └── 许智磊.doc
│ │ ├── 金恺--浅谈网络流算法的应用/
│ │ │ └── 金恺.PPT
│ │ ├── 骆骥--浅析解对策问题的两种思路/
│ │ │ └── 骆骥.ppt
│ │ └── 黄芸/
│ │ └── 黄芸.ppt
│ ├── 国家集训队2003论文集/
│ │ ├── 伍昱--由对称性解2-SAT问题/
│ │ │ └── 伍昱.ppt
│ │ ├── 何林--一类称球问题的解法/
│ │ │ ├── Program/
│ │ │ │ └── GAME.PAS
│ │ │ ├── 何林.doc
│ │ │ └── 何林.ppt
│ │ ├── 侯启明--信息论在信息学竞赛中的简单应用/
│ │ │ ├── 侯启明.doc
│ │ │ └── 侯启明.ppt
│ │ ├── 刘一鸣--一类搜索问题的优化思想——数据的有序化/
│ │ │ ├── 刘一鸣.doc
│ │ │ └── 刘一鸣.ppt
│ │ ├── 刘才良--平面图在信息学中的应用/
│ │ │ └── 刘才良.ppt
│ │ ├── 周源--浅析“最小表示法”思想在字符串循环同构问题中的应用/
│ │ │ ├── 周源.doc
│ │ │ └── 周源.ppt
│ │ ├── 姜尚仆--模线性方程的应用，用数论方法解决整数问题/
│ │ │ └── 姜尚仆.ppt
│ │ ├── 张云亮--论对题目中算法的选择/
│ │ │ ├── Program/
│ │ │ │ ├── MYTURN.PAS
│ │ │ │ └── TURNOVER.PAS
│ │ │ ├── 张云亮.doc
│ │ │ └── 张云亮.ppt
│ │ ├── 张宁--猜数问题的研究/
│ │ │ ├── Program/
│ │ │ │ ├── TL1.PAS
│ │ │ │ ├── TL2.PAS
│ │ │ │ └── Tl3.pas
│ │ │ ├── 张宁.doc
│ │ │ └── 张宁.ppt
│ │ ├── 方奇--染色法和构造法在棋盘上的应用/
│ │ │ ├── 方奇.doc
│ │ │ └── 方奇.ppt
│ │ ├── 林希德--寻找最大重复子串/
│ │ │ ├── 林希德.doc
│ │ │ └── 林希德.ppt
│ │ ├── 王知昆--浅谈用极大化思想解决最大子矩形问题/
│ │ │ ├── 王知昆.doc
│ │ │ ├── 王知昆.ppt
│ │ │ └── 附件.doc
│ │ ├── 许智磊--浅谈补集转化思想在统计问题中的应用/
│ │ │ ├── 许智磊.doc
│ │ │ └── 许智磊.ppt
│ │ ├── 邵烜程--数学思想助你一臂之力/
│ │ │ ├── 邵烜程.doc
│ │ │ └── 邵烜程.ppt
│ │ ├── 金恺--探寻深度优先搜索中的优化问题/
│ │ │ └── 金恺.ppt
│ │ ├── 陆可昱--长方体的体积并/
│ │ │ └── 陆可昱.ppt
│ │ ├── 雷环中--结果提交类问题/
│ │ │ ├── 雷环中.doc
│ │ │ └── 雷环中.ppt
│ │ ├── 项荣璟--例析动态规划的个性化优化/
│ │ │ └── 项荣璟.ppt
│ │ ├── 饶向荣--剖析一道字符串匹配问题的解题过程/
│ │ │ └── 饶向荣.ppt
│ │ └── 高正宇--浅谈问答式交互问题/
│ │ └── 高正宇.ppt
│ ├── 国家集训队2004论文集/
│ │ ├── 何林.ppt
│ │ ├── 周源.ppt
│ │ ├── 朱晨光.ppt
│ │ ├── 朱泽园.ppt
│ │ ├── 李锐喆.ppt
│ │ ├── 杨思雨.ppt
│ │ ├── 林涛.ppt
│ │ ├── 栗师.ppt
│ │ ├── 楼天城.ppt
│ │ ├── 汪汀.ppt
│ │ ├── 肖天.ppt
│ │ ├── 胡伟栋.ppt
│ │ └── 薛矛.ppt
│ ├── 国家集训队2007论文集/
│ │ └── day2/
│ │ ├── 9.周冬《生成树的计数及其应用》.doc
│ │ └── 9.周冬《生成树的计数及其应用》.ppt
│ └── 国家集训队2008论文集/
│ └── Day1/
│ ├── 1.曹钦翔《数据结构的提炼与压缩》/
│ │ ├── 封面.doc
│ │ ├── 数据结构的提炼与压缩.ppt
│ │ ├── 目录.doc
│ │ └── 论文.doc
│ ├── 2.郑暾《平衡规划——浅析一类平衡思想的应用》/
│ │ ├── catch.dpr
│ │ ├── pku2103.dpr
│ │ ├── pku3237.dpr
│ │ ├── ural1099/
│ │ │ ├── gen.dpr
│ │ │ ├── ural1099_10.dpr
│ │ │ ├── ural1099_10.txt
│ │ │ ├── ural1099_10_10.dpr
│ │ │ ├── ural1099_10_10.txt
│ │ │ ├── ural1099_20.dpr
│ │ │ ├── ural1099_20.txt
│ │ │ ├── ural1099_20_10.dpr
│ │ │ ├── ural1099_20_10.txt
│ │ │ ├── ural1099_50.dpr
│ │ │ ├── ural1099_50.txt
│ │ │ ├── ural1099_5_10.dpr
│ │ │ ├── ural1099_5_10.txt
│ │ │ ├── ural1099_5_5.dpr
│ │ │ └── ural1099_5_5.txt
│ │ ├── ural1099.dpr
│ │ ├── 平衡规划.doc
│ │ └── 平衡规划.ppt
│ ├── 3.刘弈《浅谈信息学中状态的合理设计与应用》/
│ │ ├── 例题程序/
│ │ │ ├── Banal_Tickets.dpr
│ │ │ ├── Shoot_Your_Gun.dpr
│ │ │ └── Square_Roots.dpr
│ │ ├── 浅谈信息学中状态的合理设计与应用.doc
│ │ └── 浅谈信息学中状态的合理设计与应用.ppt
│ └── 4.顾研《浅谈随机化思想在几何问题中的应用》/
│ ├── 浅谈随机化思想在几何问题中的应用.doc
│ └── 浅谈随机化思想在几何问题中的应用.ppt
├── PPT/
│ ├── Hash在ACM竞赛中的应用.ppt
│ ├── 动态规划.ppt
│ ├── 威佐夫博弈.ppt
│ ├── 尼姆博弈.ppt
│ └── 巴什博弈.ppt
└── XLS/
└── NOI知识点.xls
Showing preview only (342K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (3923 symbols across 1218 files)
FILE: ACM 模板代码/f-0-1分数规划/f-0-1分数规划/main.cpp
function main (line 25) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-2-SAT/f-2-SAT/main.cpp
function dfs (line 24) | void dfs(int w)
function Tarjan (line 58) | void Tarjan(int N)
function solve (line 77) | int solve()
function check (line 90) | int check(int Mid)
function main (line 104) | int main()
FILE: ACM 模板代码/f-AC自动机/f-AC自动机/main.cpp
type Trie (line 17) | struct Trie
method newnode (line 21) | int newnode()
method init (line 31) | void init()
method insert (line 37) | void insert(char buf[])
method build (line 52) | void build()
method query (line 87) | int query(char buf[])
method debug (line 106) | void debug()
function main (line 123) | int main()
FILE: ACM 模板代码/f-Baby-Step Giant-Step/f-Baby-Step Giant-Step/main.cpp
function insert (line 26) | void insert(int x, int y)
function find (line 36) | int find(int x)
function BSGS (line 49) | long long BSGS(int a, int b, int n)
function main (line 78) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-DAG的深度优先搜索标记/f-DAG的深度优先搜索标记/main.cpp
function dfsTag (line 24) | void dfsTag(int cur, int n)
function main (line 58) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-FFT/f-FFT/main.cpp
type Complex (line 27) | struct Complex
method Complex (line 30) | Complex(double _x = 0.0, double _y = 0.0)
method Complex (line 35) | Complex operator - (const Complex &b) const
method Complex (line 39) | Complex operator + (const Complex &b) const
method Complex (line 43) | Complex operator * (const Complex &b) const
function change (line 52) | void change(Complex y[], int len)
function fft (line 80) | void fft(Complex y[], int len, int on)
function main (line 113) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-FWT/f-FWT/main.cpp
function FWT (line 19) | inline void FWT(int c[], int N, int tf_utf) // tf_utf 1:tf; 0:utf
FILE: ACM 模板代码/f-Floyd求最小环/f-Floyd求最小环/main.cpp
function solve (line 18) | int solve(int i, int j, int k)
function main (line 31) | int main()
FILE: ACM 模板代码/f-GCD/f-GCD/main.cpp
function gcd (line 14) | int gcd(int x, int y)
function kgcd (line 25) | int kgcd(int a, int b)
function extgcd (line 58) | int extgcd(int a, int b, int &x, int &y)
function main (line 73) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-Graham求凸包/f-Graham求凸包/main.cpp
type point (line 17) | struct point
function mult (line 22) | bool mult(point sp, point ep, point op)
function graham (line 32) | int graham(point pnt[], int n, point res[])
FILE: ACM 模板代码/f-KMP算法/f-KMP算法/main.cpp
function getNext (line 111) | void getNext(char *T, int *next, int len)
function indexKMP (line 134) | int indexKMP(char *S, char *T, int *next, int pos, int lenS, int lenT)
FILE: ACM 模板代码/f-Karp-Rabin算法/f-Karp-Rabin算法/main.cpp
function init (line 68) | void init()
function hash (line 78) | void hash()
function read (line 114) | void read()
function solve (line 129) | int solve()
function main (line 152) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-LCA/f-LCA/main.cpp
type Edge (line 316) | struct Edge
function addedge (line 322) | void addedge(int u, int v)
function init (line 329) | void init()
function BFS (line 338) | void BFS(int root)
function LCA (line 366) | int LCA(int u, int v)
function main (line 399) | int main()
FILE: ACM 模板代码/f-Liuctic的计算几何库/f-Liuctic的计算几何库/main.cpp
type Lpoint (line 37) | struct Lpoint
type Llineseg (line 41) | struct Llineseg
type Ldir (line 45) | struct Ldir
type Lline (line 49) | struct Lline
type Lrad (line 54) | struct Lrad
type Lround (line 59) | struct Lround
function p2pdis (line 67) | double p2pdis(Lpoint p1, Lpoint p2)
function xmulti (line 81) | double xmulti(Lpoint p1, Lpoint p2, Lpoint p0)
function mx (line 88) | double mx(double t1, double t2)
function mn (line 96) | double mn(double t1, double t2)
function lsinterls (line 104) | int lsinterls(Llineseg u, Llineseg v)
function ponls (line 111) | int ponls(Llineseg l, Lpoint p)
function Euqal_Point (line 118) | int Euqal_Point(Lpoint p1, Lpoint p2)
function lsinterls_A (line 128) | int lsinterls_A(Llineseg u, Llineseg v)
function pinplg (line 139) | int pinplg(int vcount, Lpoint Polygon[], Lpoint q)
function area_of_polygon (line 165) | double area_of_polygon(int vcount, double x[], double y[], Lpoint plg[])
function equa (line 186) | int equa(double A, double B, double C, double &x1, double &x2)
function format (line 200) | void format(Lline ln, double &A, double &B, double &C)
function p2ldis (line 210) | double p2ldis(Lpoint a, Lline ln)
function lncrossc (line 219) | int lncrossc(Lline ln, Lround Y, Lpoint &p1, Lpoint &p2)
function samedir (line 249) | bool samedir(Lrad ln, Lpoint P)
function lrcrossc (line 269) | int lrcrossc(Lrad ln, Lround Y, Lpoint &P)
function Lpoint (line 300) | Lpoint mirror(Lpoint P, Lline ln)
function angle_LL (line 312) | double angle_LL(Lline line1, Lline line2)
FILE: ACM 模板代码/f-MST/f-MST/main.cpp
function steiner (line 31) | void steiner(int n, int a)
function main (line 94) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-Manacher算法/f-Manacher算法/main.cpp
function Manacher (line 21) | void Manacher(char s[], int len)
function main (line 59) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-Polya计数/f-Polya计数/main.cpp
function gcd (line 16) | int gcd(int a, int b)
function main (line 21) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-RMQ/f-RMQ/main.cpp
function initRMQ (line 59) | void initRMQ(int n, int m)
function rmq (line 94) | int rmq(int x1, int y1, int x2, int y2)
function main (line 103) | int main()
FILE: ACM 模板代码/f-SPFA/f-SPFA/main.cpp
function relax (line 104) | int relax(int u, int v, int c)
function addedge (line 114) | inline void addedge(int u, int v, int c)
function SPFA (line 123) | int SPFA(int src, int n)
function main (line 164) | int main()
FILE: ACM 模板代码/f-Sunday Algorithm/f-Sunday Algorithm/main.cpp
function SUNDAY (line 27) | void SUNDAY(char *text, char *patt)
function main (line 61) | int main(void)
FILE: ACM 模板代码/f-Tarian强连通分量/f-Tarian强连通分量/main.cpp
function tarjan (line 22) | void tarjan(int v, int n) // vertex: 0 ~ n-1
function main (line 53) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-Treap/f-Treap/main.cpp
function gcd (line 11) | long long gcd(long long a, long long b)
type Treap (line 26) | struct Treap
method Init (line 35) | void Init()
method random (line 43) | bool random(double p)
method newnode (line 47) | int newnode(int val, int _status)
method del (line 65) | void del(int r)
method push_up (line 76) | void push_up(int r)
method merge (line 92) | void merge(int &p, int x, int y)
method split (line 110) | void split(int p, int &x, int &y, int k)
method build (line 132) | void build(int &p, int l, int r)
method debug (line 145) | void debug(int root)
function main (line 160) | int main()
FILE: ACM 模板代码/f-Trie树/f-Trie树/main.cpp
type trie (line 89) | struct trie
function init (line 95) | void init()
function sear (line 101) | int sear(char *s) // 失败返回0
function insert (line 121) | void insert(char *s, int rk = 1) // rk: 权或者标记
function delt (line 147) | void delt(char *s) // 假定s已经存在,只做标记
function profix (line 164) | int profix(char *s) // 最长前缀
FILE: ACM 模板代码/f-Ugly Numbers/f-Ugly Numbers/main.cpp
function main (line 20) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-simpson积分/f-simpson积分/main.cpp
function F (line 19) | double F(double x)
function simpson (line 29) | double simpson(double a, double b)
function asr (line 36) | double asr(double a, double b, double eps, double A)
function asr (line 48) | double asr(double a, double b, double eps)
function main (line 53) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-strstr函数/f-strstr函数/main.cpp
function main (line 20) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-一般图匹配带花树/f-一般图匹配带花树/main.cpp
function CreateGraph (line 25) | void CreateGraph()
function Push (line 36) | void Push(int u)
function Pop (line 42) | int Pop()
function FindCommonAncestor (line 48) | int FindCommonAncestor (int u, int v)
function ResetTrace (line 73) | void ResetTrace(int u)
function BlossomContract (line 88) | void BlossomContract(int u, int v)
function FindAugmentingPath (line 115) | void FindAugmentingPath()
function AugmentPath (line 155) | void AugmentPath()
function Edmonds (line 169) | void Edmonds()
function PrintMatch (line 186) | void PrintMatch()
function main (line 206) | int main()
FILE: ACM 模板代码/f-主席树/f-主席树/main.cpp
type Query (line 495) | struct Query
function Init_hash (line 501) | void Init_hash(int k)
function hash_ (line 508) | int hash_(int x)
function build (line 513) | int build(int l, int r)
function Insert (line 526) | int Insert(int root, int pos, int val)
function lowbit (line 555) | int lowbit(int x)
function add (line 562) | void add(int x, int pos, int val)
function sum (line 571) | int sum(int x)
function Query (line 582) | int Query(int left, int right, int k)
function Modify (line 632) | void Modify(int x, int p, int d)
function main (line 642) | int main()
FILE: ACM 模板代码/f-二分图匹配/f-二分图匹配/main.cpp
function searchP (line 411) | bool searchP()
function DFS (line 452) | bool DFS(int u)
function MaxMatch (line 473) | int MaxMatch()
FILE: ACM 模板代码/f-二分图多重匹配/f-二分图多重匹配/main.cpp
function dfs (line 19) | bool dfs(int u)
function hungary (line 44) | int hungary()
function main (line 64) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-二分查找/f-二分查找/main.cpp
function bs (line 47) | int bs(int a[], int l, int h, int v)
FILE: ACM 模板代码/f-二叉排序树/f-二叉排序树/main.cpp
type BiTNode (line 14) | struct BiTNode
type BiTNode (line 17) | struct BiTNode
function Status (line 24) | Status SearchBST(BiTree T, int Key, BiTree f, BiTree *p)
function Status (line 48) | Status InserBST(BiTree *T, int Key)
function Status (line 78) | Status Delete(BiTree *p)
function Status (line 123) | Status DeleteBST(BiTree *T, int Key)
function main (line 146) | int main(int argc, const char * argv[]) {
FILE: ACM 模板代码/f-二叉查找树/f-二叉查找树/main.cpp
class BSTNode (line 12) | class BSTNode
method BSTNode (line 20) | BSTNode(T key , BSTNode *lchild, BSTNode *rchild, BSTNode *parent) :
class BSTree (line 25) | class BSTree
method BSTree (line 30) | BSTree() : _Root(NULL) {}
function T (line 256) | T BSTree<T>::minimumKey()
function T (line 268) | T BSTree<T>::maximumKey()
function main (line 439) | int main()
FILE: ACM 模板代码/f-伸展数/f-伸展数/main.cpp
function Treavel (line 30) | void Treavel(int x)
function debug (line 41) | void debug()
function NewNode (line 49) | void NewNode(int &r, int father, int k)
function Update_Rev (line 69) | void Update_Rev(int r)
function Update_Same (line 81) | void Update_Same(int r, int v)
function push_up (line 94) | void push_up(int r)
function push_down (line 106) | void push_down(int r)
function Build (line 123) | void Build(int &x, int l, int r, int father)
function Init (line 137) | void Init()
function Rotate (line 155) | void Rotate(int x,int kind)
function Splay (line 171) | void Splay(int r, int goal)
function Get_kth (line 209) | int Get_kth(int r, int k)
function Insert (line 228) | void Insert(int pos, int tot)
function erase (line 243) | void erase(int r)
function Delete (line 256) | void Delete(int pos, int tot)
function Make_Same (line 269) | void Make_Same(int pos, int tot, int c)
function Reverse (line 280) | void Reverse(int pos, int tot)
function Get_Sum (line 291) | int Get_Sum(int pos, int tot)
function Get_MaxSum (line 299) | int Get_MaxSum(int pos, int tot)
function InOrder (line 306) | void InOrder(int r)
function main (line 319) | int main()
FILE: ACM 模板代码/f-使序列有序的最少交换次数/f-使序列有序的最少交换次数/main.cpp
function getMinSwaps (line 74) | int getMinSwaps()
function main (line 105) | int main()
FILE: ACM 模板代码/f-划分树/f-划分树/main.cpp
function build (line 22) | void build(int l, int r, int dep)
function query (line 62) | int query(int L, int R, int l, int r, int dep, int k)
function main (line 84) | int main()
FILE: ACM 模板代码/f-判断线段相交/f-判断线段相交/main.cpp
type point (line 13) | struct point
function min (line 18) | double min(double a, double b)
function max (line 23) | double max(double a, double b)
function inter (line 28) | bool inter(point a, point b, point c, point d)
FILE: ACM 模板代码/f-动态树/f-动态树/main.cpp
function Update_Add (line 26) | void Update_Add(int r, int d)
function Update_Rev (line 38) | void Update_Rev(int r)
function push_down (line 49) | void push_down(int r)
function push_up (line 66) | void push_up(int r)
function Rotate (line 72) | void Rotate(int x)
function P (line 92) | void P(int r)
function Splay (line 101) | void Splay(int r)
function Access (line 124) | int Access(int x)
function judge (line 137) | bool judge(int u, int v)
function mroot (line 151) | void mroot(int r)
function lca (line 161) | void lca(int &u, int &v)
function link (line 179) | void link(int u, int v)
function cut (line 192) | void cut(int u, int v)
function ADD (line 209) | void ADD(int u, int v, int w)
function query (line 224) | void query(int u, int v)
type Edge (line 236) | struct Edge
function addedge (line 243) | void addedge(int u, int v)
function dfs (line 251) | void dfs(int u)
function main (line 266) | int main()
FILE: ACM 模板代码/f-区间最大频率/f-区间最大频率/main.cpp
type NODE (line 37) | struct NODE
function main (line 47) | int main()
function build (line 69) | int build(int a, int b) // 建立线段树
function query (line 113) | int query(int index, int a, int b)
FILE: ACM 模板代码/f-半平面交/f-半平面交/main.cpp
function sgn (line 148) | int sgn(double x)
type Point (line 164) | struct Point
method Point (line 167) | Point() {}
method Point (line 168) | Point(double _x, double _y)
method Point (line 173) | Point operator - (const Point &b)const
function CalcArea (line 188) | double CalcArea(Point p[], int n)
function Get_equation (line 199) | void Get_equation(Point p1, Point p2, double &a, double &b, double &c)
function Point (line 208) | Point Intersection(Point p1, Point p2, double a, double b, double c)
method Point (line 167) | Point() {}
method Point (line 168) | Point(double _x, double _y)
method Point (line 173) | Point operator - (const Point &b)const
function Cut (line 219) | void Cut(double a, double b, double c, Point p[], int &cnt)
function solve (line 255) | bool solve(int id)
function main (line 295) | int main()
FILE: ACM 模板代码/f-双连通分支/f-双连通分支/main.cpp
type Edge (line 161) | struct Edge
function addedge (line 176) | void addedge(int u, int v)
function dfs (line 184) | bool dfs(int u, int col) // 染色判断二分图
function Tarjan (line 210) | void Tarjan(int u, int pre)
function solve (line 264) | void solve(int n)
function init (line 288) | void init()
function main (line 296) | int main()
FILE: ACM 模板代码/f-取第k个元素/f-取第k个元素/main.cpp
function elem_t (line 18) | elem_t kth_element(int n, elem_t *a, int k)
FILE: ACM 模板代码/f-合数相关/f-合数相关/main.cpp
function gerPrime (line 23) | void gerPrime()
function gerFactors (line 48) | int gerFactors(long long x)
function main (line 74) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-后缀数组/f-后缀数组/main.cpp
function c0 (line 245) | int c0(int *r, int a, int b)
function c12 (line 250) | int c12(int k, int *r, int a, int b)
function sort (line 262) | void sort(int *r, int *a, int *b, int n, int m)
function dc3 (line 287) | void dc3(int *r, int *sa, int n, int m)
function da (line 348) | void da(int str[], int sa[], int rank[], int height[], int n,int m)
FILE: ACM 模板代码/f-后缀自动机/f-后缀自动机/main.cpp
type SAM_Node (line 14) | struct SAM_Node
method SAM_Node (line 19) | SAM_Node(){}
method SAM_Node (line 20) | SAM_Node(int _len)
function SAM_Node (line 30) | SAM_Node *newSAM_Node(int len)
method SAM_Node (line 19) | SAM_Node(){}
method SAM_Node (line 20) | SAM_Node(int _len)
function SAM_Node (line 36) | SAM_Node *newSAM_Node(SAM_Node *p)
method SAM_Node (line 19) | SAM_Node(){}
method SAM_Node (line 20) | SAM_Node(int _len)
function SAM_init (line 41) | void SAM_init()
function SAM_add (line 47) | void SAM_add(int x, int len)
function SAM_build (line 74) | void SAM_build(char *s)
FILE: ACM 模板代码/f-周期性方程/f-周期性方程/main.cpp
function run (line 30) | void run()
function main (line 60) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-培训作业/f-培训作业/main.cpp
function jia (line 163) | void jia(long long &x,long long y) { x+=y; if (x>=Mo) x-=Mo; }
function ll (line 171) | ll modAdd(ll a, ll b) {
function ll (line 175) | ll modMul(ll a , ll b) {
function multiply (line 180) | void multiply(const vector<ll> &Q, vector<ll> &Qr) {
function cal (line 196) | void cal(long long *A,long long n,long long k,long long *C)
function power (line 240) | int power(int x,int y)
function guass (line 251) | void guass(int n)
function Count (line 276) | int Count(vector<long long> A,long long R)
function main (line 289) | int main()
FILE: ACM 模板代码/f-堆/f-堆/main.cpp
function scan_d (line 22) | inline void scan_d(T &ret)
function main (line 35) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-堆栈/f-堆栈/main.cpp
function swap (line 14) | inline void swap(int i, int j)
function Parent (line 22) | inline int Parent(int i)
function Left (line 27) | inline int Left(int i)
function Right (line 32) | inline int Right(int i)
function MaxHeapify (line 37) | void MaxHeapify(int i)
function BuildMaxHeap (line 60) | void BuildMaxHeap(int *arr, int n)
function HeapSort (line 70) | void HeapSort(int *arr, int n)
FILE: ACM 模板代码/f-多项式求根（牛顿法）/f-多项式求根（牛顿法）/main.cpp
function fabs (line 19) | double fabs(double x)
function f (line 24) | double f(int m, double c[], double x)
function newton (line 35) | int newton(double x0, double *r, double c[], double cp[], int n, double ...
function Polynomial_Root (line 65) | double Polynomial_Root(double c[], int n, double a, double b, double eps)
FILE: ACM 模板代码/f-大数取模的二进制方法/f-大数取模的二进制方法/main.cpp
function mod_exp (line 19) | int mod_exp(int a, int b_0, int n) //return a^b0 % n
function main (line 47) | int main(int argc, const char * argv[]) {
FILE: ACM 模板代码/f-大数平方根（字符串数组表示）/f-大数平方根（字符串数组表示）/main.cpp
function Sqrt (line 13) | void Sqrt(char *str)
function main (line 61) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-大数运算/f-大数运算/main.cpp
function main (line 231) | int main()
function Add (line 266) | void Add(char *str1, char *str2, char *str3)
function Minus (line 306) | void Minus(char *str1, char *str2, char *str3)
function Mul (line 362) | void Mul(char *str1, char *str2, char *str3)
function Div (line 408) | void Div(char *str1, char *str2, char *str3)
FILE: ACM 模板代码/f-字符串 HASH/f-字符串 HASH/main.cpp
function hashA (line 18) | unsigned int hashA(char *url, int mod)
function hashB (line 29) | unsigned int hashB(char *url, int mod)
function hashC (line 46) | unsigned int hashC(char *p, int prime = 25013)
function main (line 63) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-容斥/f-容斥/main.cpp
function dfs (line 19) | void dfs(int x, int tot, double sum) // dfs(1, 0, ?)
function main (line 43) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-左偏树/f-左偏树/main.cpp
type node (line 30) | struct node
function iroot (line 36) | int iroot(int i)
function merge (line 49) | int merge(int rx, int ry)
function ins (line 82) | int ins(int i, typec key, int root)
function del (line 90) | int del(int i)
function node (line 129) | node top(int root)
function node (line 134) | node pop(int &root)
function add (line 144) | int add(int i, typec val) // tr[i].key += val
function init (line 160) | void init(int n)
function main (line 171) | int main(int argc, const char * argv[]) {
FILE: ACM 模板代码/f-带权值的并查集/f-带权值的并查集/main.cpp
type lset (line 17) | struct lset
method link (line 20) | void link(int x, int y)
method makeset (line 40) | void makeset(int n)
method findset (line 50) | int findset(int x)
method unin (line 58) | void unin(int x, int y)
method compress (line 63) | void compress()
FILE: ACM 模板代码/f-平衡二叉树/f-平衡二叉树/main.cpp
type BiTNode (line 18) | struct BiTNode
type BiTNode (line 22) | struct BiTNode
function R_Rotate (line 26) | void R_Rotate(BiTree *p)
function L_Rotate (line 37) | void L_Rotate(BiTree *p)
function LeftBalance (line 48) | void LeftBalance(BiTree *T)
function RightBalance (line 84) | void RightBalance(BiTree *T)
function InsertAVL (line 120) | bool InsertAVL(BiTree *T, int e, bool *taller)
function main (line 184) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-平面最近点对/f-平面最近点对/main.cpp
type Point (line 18) | struct Point
function main (line 33) | int main()
function closest (line 58) | double closest(Point a[],Point b[],Point c[],int p,int q)
function dis (line 121) | double dis(Point p, Point q)
function merge (line 127) | int merge(Point p[], Point q[], int s, int m, int t)
function cmp_x (line 153) | int cmp_x(const void *p, const void *q)
function cmp_y (line 170) | int cmp_y(const void *p, const void *q)
function min (line 187) | inline double min(double p, double q)
FILE: ACM 模板代码/f-弦图判断/f-弦图判断/main.cpp
function mcs (line 33) | void mcs(int n)
function peo (line 60) | int peo(int n)
FILE: ACM 模板代码/f-弦图的PERFECT ELIMINATION点排列/f-弦图的PERFECT ELIMINATION点排列/main.cpp
function cardinality (line 19) | void cardinality(int n)
function main (line 48) | int main(int argc, const char * argv[]) {
FILE: ACM 模板代码/f-快排/f-快排/main.cpp
function ksort (line 13) | void ksort(int l, int h, int a[])
FILE: ACM 模板代码/f-所有数位相加/f-所有数位相加/main.cpp
function dig (line 21) | int dig(int x)
function dig_ (line 38) | int dig_(int x)
function main (line 43) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-扩展KMP/f-扩展KMP/main.cpp
function preEKMP (line 17) | void preEKMP(char x[], int m, int next[])
function EKMP (line 49) | void EKMP(char x[], int m, char y[], int n, int next[], int extend[])
function main (line 81) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-拓扑排序/f-拓扑排序/main.cpp
function TopoOrder (line 19) | void TopoOrder(int n)
function main (line 54) | int main(int argc, const char * argv[]) {
FILE: ACM 模板代码/f-排列组合/f-排列组合/main.cpp
function unrepeat_combination (line 366) | void unrepeat_combination(int l, int p)
function read_data (line 390) | int read_data()
function main (line 418) | int main()
FILE: ACM 模板代码/f-散列表查找/f-散列表查找/main.cpp
function InitHashTable (line 21) | int InitHashTable(HashTable *H)
function Hash (line 37) | int Hash(int key)
function InserHash (line 43) | void InserHash(HashTable *H, int key)
function SearchHash (line 57) | int SearchHash(HashTable H, int key, int *addr)
function main (line 72) | int main(int argc, const char * argv[]) {
FILE: ACM 模板代码/f-旋转卡壳/f-旋转卡壳/main.cpp
function sgn (line 206) | int sgn(double x)
type Point (line 222) | struct Point
method Point (line 225) | Point(double _x = 0, double _y = 0)
method Point (line 230) | Point operator - (const Point &b)const
method input (line 242) | void input()
type Line (line 248) | struct Line
method Line (line 251) | Line(){}
method Line (line 252) | Line(Point _s, Point _e)
function dist (line 260) | double dist(Point a, Point b)
function Point (line 266) | Point NearestPointToLineSeg(Point P, Line L)
method Point (line 225) | Point(double _x = 0, double _y = 0)
method Point (line 230) | Point operator - (const Point &b)const
method input (line 242) | void input()
function _cmp (line 297) | bool _cmp(Point p1, Point p2)
function Graham (line 314) | void Graham(int n)
function pointtoseg (line 357) | double pointtoseg(Point p0, Point p1, Point p2)
function dispallseg (line 363) | double dispallseg(Point p0, Point p1, Point p2, Point p3)
function Get_angle (line 371) | double Get_angle(Point a1, Point a2, Point b1, Point b2)
function rotating_calipers (line 376) | double rotating_calipers(Point p[], int np, Point q[], int nq)
function solve (line 414) | double solve(Point p[], int n, Point q[], int m)
function main (line 421) | int main()
FILE: ACM 模板代码/f-无向图找桥/f-无向图找桥/main.cpp
function main (line 71) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-无向图最小割/f-无向图最小割/main.cpp
function typec (line 26) | typec minCut(int n)
function main (line 78) | int main(int argc, const char * argv[]) {
FILE: ACM 模板代码/f-无向图连通分支/f-无向图连通分支/main.cpp
function search (line 19) | void search(int n, int mat[][MAXN], int* dfn, int* low, int now, int& cn...
function find_components (line 53) | int find_components(int n, int mat[][MAXN], int* id)
function main (line 67) | int main(int argc, const char * argv[]) {
FILE: ACM 模板代码/f-无向图连通度（割）/f-无向图连通度（割）/main.cpp
function dfs (line 27) | void dfs(int cur, int father, int dep, int n)
function main (line 63) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-星期问题/f-星期问题/main.cpp
function main (line 17) | int main()
FILE: ACM 模板代码/f-曼哈顿最小生成树/f-曼哈顿最小生成树/main.cpp
type Point (line 17) | struct Point
function cmp (line 24) | bool cmp(Point a, Point b)
type BIT (line 37) | struct BIT
method init (line 41) | void init()
type Edge (line 49) | struct Edge
function cmpEdge (line 56) | bool cmpEdge(Edge a, Edge b)
function find (line 65) | int find(int x)
function addEdge (line 77) | void addEdge(int u, int v, int d)
function lowbit (line 85) | int lowbit(int x)
function update (line 91) | void update(int i, int val, int pos)
function ask (line 106) | int ask(int i, int m)
function dist (line 122) | int dist(Point a, Point b)
function ManhattanMinimumSpanningTree (line 127) | void ManhattanMinimumSpanningTree(int n, Point p[])
function solve (line 173) | int solve(int k)
function main (line 197) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-最佳点割集/f-最佳点割集/main.cpp
function max_flow (line 14) | int max_flow(int n, int mat[][MAXN], int source, int sink)
function best_vertex_cut (line 55) | int best_vertex_cut(int n, int mat[][MAXN], int *cost, int source, int s...
FILE: ACM 模板代码/f-最佳边割集/f-最佳边割集/main.cpp
function max_flow (line 13) | int max_flow(int n, int mat[][MAXN], int source, int sink)
function best_edge_cut (line 54) | int best_edge_cut(int n, int mat[][MAXN], int source, int sink, int set[...
function main (line 103) | int main(int argc, const char * argv[]) {
FILE: ACM 模板代码/f-最大1矩阵/f-最大1矩阵/main.cpp
function Run (line 19) | int Run(const int &m, const int &n) // a[1...m][1...n]
function main (line 74) | int main(int argc, const char * argv[]) {
FILE: ACM 模板代码/f-最大团问题/f-最大团问题/main.cpp
function dfs (line 24) | int dfs(int n, int ns, int dep)
function clique (line 60) | int clique(int n)
function main (line 78) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-最大流/f-最大流/main.cpp
type Edge (line 583) | struct Edge
function init (line 592) | void init()
function addedge (line 599) | void addedge(int u, int v, int w, int rw = 0)
function BFS (line 615) | void BFS(int start, int end)
function sap (line 642) | int sap(int start, int end, int N)
FILE: ACM 模板代码/f-最小树形图/f-最小树形图/main.cpp
type Edge (line 25) | struct Edge
function zhuliu (line 34) | int zhuliu(int root, int n, int m)
function main (line 113) | int main()
FILE: ACM 模板代码/f-最小点割集/f-最小点割集/main.cpp
function max_flow (line 16) | int max_flow(int n, int mat[][MAXN], int source, int sink)
function min_vertex_cut (line 57) | int min_vertex_cut(int n, int mat[][MAXN], int source, int sink, int *set)
function main (line 116) | int main(int argc, const char * argv[]) {
FILE: ACM 模板代码/f-最小生成树/f-最小生成树/main.cpp
type Edge (line 74) | struct Edge
function addEdge (line 83) | void addEdge(int u, int v, int w)
function cmp (line 91) | bool cmp(Edge a, Edge b)
function find (line 97) | int find(int x)
function Kruskal (line 109) | int Kruskal(int n) //传入点数，返回最小生成树的权值，如果不连通则返回-1
function main (line 144) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-最小费用流/f-最小费用流/main.cpp
type edge (line 152) | struct edge
method edge (line 157) | edge (int x, int y, typef cu, typef cv, typec cc) :u(x), v(y), cuv(cu)...
method other (line 158) | int other(int p)
method typef (line 162) | typef cap(int p)
method typec (line 166) | typec ecost(int p)
method addFlow (line 181) | void addFlow(int p, typef f)
type network (line 187) | struct network
function typec (line 247) | typec network::mincost(int ss, int tt)
function main (line 307) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-最小路径覆盖/f-最小路径覆盖/main.cpp
function main (line 11) | int main(int argc, const char * argv[]) {
FILE: ACM 模板代码/f-最小边割集/f-最小边割集/main.cpp
function max_flow (line 14) | int max_flow(int n, int mat[][MAXN], int source, int sink)
function min_edge_cut (line 55) | int min_edge_cut(int n, int mat[][MAXN], int source, int sink, int set[]...
function main (line 104) | int main(int argc, const char * argv[]) {
FILE: ACM 模板代码/f-最少找钱币问题/f-最少找钱币问题/main.cpp
function main (line 22) | int main()
function DFS (line 48) | void DFS(int total, int p)
FILE: ACM 模板代码/f-最短公共祖先/f-最短公共祖先/main.cpp
function max (line 24) | inline int max(int a, int b)
function kmp (line 29) | int kmp(int &i, int &j, char* str, char* pat)
function main (line 68) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-最短路/f-最短路/main.cpp
type Edge (line 206) | struct Edge
method Edge (line 210) | Edge(int _v = 0, int _cost = 0) : v(_v), cost(_cost){}
function addEdge (line 215) | void addEdge(int u, int v, int w)
function SPFA (line 224) | bool SPFA(int start, int n)
function main (line 269) | int main(int argc, const char * argv[]) {
FILE: ACM 模板代码/f-最长公共子序列/f-最长公共子序列/main.cpp
function LCS (line 15) | int LCS(const char *s1, const char *s2)
function main (line 49) | int main(int argc, const char * argv[]) {
FILE: ACM 模板代码/f-最长公共递增子序列/f-最长公共递增子序列/main.cpp
function gcis (line 19) | int gcis(int a[], int la, int b[], int lb, int ans[])
FILE: ACM 模板代码/f-最长有序子序列/f-最长有序子序列/main.cpp
function bsearch (line 17) | int bsearch(const int *f, int size, const int &a)
function LIS (line 39) | int LIS(const int *a, const int &n)
function main (line 58) | int main()
FILE: ACM 模板代码/f-有上下界的流/f-有上下界的流/main.cpp
function maxflow (line 29) | void maxflow(int n, int src, int sink)
function limitflow (line 68) | int limitflow(int n, int src, int sink)
function main (line 113) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-有向图强连通分支/f-有向图强连通分支/main.cpp
function find_components (line 17) | int find_components(int n, int mat[][MAXN], int* id)
function main (line 68) | int main(int argc, const char * argv[]) {
FILE: ACM 模板代码/f-有向图最小树形图/f-有向图最小树形图/main.cpp
type Edge (line 27) | struct Edge
function iroot (line 33) | int iroot(int i)
function dirTree (line 42) | int dirTree(int root, int nv, int ne) // root:树根
FILE: ACM 模板代码/f-有向图最小点基/f-有向图最小点基/main.cpp
function base_vertex (line 18) | int base_vertex(int n, int mat[][MAXN], int* sets)
function main (line 43) | int main(int argc, const char * argv[]) {
FILE: ACM 模板代码/f-有向图的强连通分量/f-有向图的强连通分量/main.cpp
type Edge (line 109) | struct Edge
function addedge (line 123) | void addedge(int u, int v)
function DFS1 (line 134) | void DFS1(int u)
function DFS2 (line 148) | void DFS2(int u)
function solve (line 163) | void solve(int n) // 点的编号从1开始
function main (line 188) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-树状数组/f-树状数组/main.cpp
function Lowbit (line 47) | inline int Lowbit(const int &x)
function Sum (line 52) | int Sum(int i, int j)
function Update (line 68) | void Update(int i, int j, int num)
FILE: ACM 模板代码/f-树链剖分/f-树链剖分/main.cpp
type Edge (line 204) | struct Edge
function init (line 219) | void init()
function addedge (line 228) | void addedge(int u, int v)
function dfs1 (line 236) | void dfs1(int u, int pre, int d) // 第一遍dfs求出fa,deep,num,son
function getpos (line 256) | void getpos(int u,int sp) // 第二遍dfs求出top和p
type Node (line 278) | struct Node
function build (line 284) | void build(int i, int l, int r)
function push_up (line 299) | void push_up(int i)
function update (line 304) | void update(int i, int k, int val) // 更新线段树的第k个值为val
function query (line 324) | int query(int i, int l, int r) // 查询线段树中[l,r]的最大值
function find (line 345) | int find(int u,int v) // 查询u->v边的最大值
function main (line 373) | int main()
FILE: ACM 模板代码/f-棋盘分割/f-棋盘分割/main.cpp
function main (line 36) | int main()
function input (line 78) | void input()
function reset (line 93) | void reset()
function caluate (line 115) | double caluate(int i1, int j1, int i2, int j2)
function dp (line 129) | void dp(int m, int si, int sj, int ei, int ej)
FILE: ACM 模板代码/f-模线性方程（组）/f-模线性方程（组）/main.cpp
function extgcd (line 19) | int extgcd(int a, int b, int &x, int &y) // 扩展GCD
function modeq (line 34) | void modeq(int a, int b, int n)
function china (line 61) | int china(int b[], int w[], int k)
function main (line 85) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-次小生成树/f-次小生成树/main.cpp
function Prim (line 30) | int Prim(int cost[][MAXN], int n)
function main (line 81) | int main(int argc, const char * argv[]) {
FILE: ACM 模板代码/f-欧拉函数PHI/f-欧拉函数PHI/main.cpp
function phi_and_prime_table (line 104) | void phi_and_prime_table(int N)
FILE: ACM 模板代码/f-母函数/f-母函数/main.cpp
function main (line 24) | int main()
FILE: ACM 模板代码/f-求A^B的约数之和/f-求A^B的约数之和/main.cpp
function getPrime (line 18) | void getPrime()
function getFactors (line 43) | int getFactors(long long x)
function pow_m (line 76) | long long pow_m(long long a, long long n)
function sum (line 93) | long long sum(long long p, long long n)
function solve (line 114) | long long solve(long long A, long long B)
function main (line 126) | int main()
FILE: ACM 模板代码/f-求多边形重心/f-求多边形重心/main.cpp
type point (line 15) | struct point
function point (line 20) | point bcenter(point pnt[], int n)
FILE: ACM 模板代码/f-求逆元/f-求逆元/main.cpp
function powM (line 69) | long long powM(long long a, long long b, long long m)
function inv (line 92) | long long inv(long long a, long long m)
function main (line 97) | int main()
FILE: ACM 模板代码/f-汉诺塔/f-汉诺塔/main.cpp
function main (line 27) | int main()
FILE: ACM 模板代码/f-生成树计数/f-生成树计数/main.cpp
function sgn (line 105) | int sgn(double x)
function det (line 122) | double det(double a[][MAXN], int n)
function main (line 177) | int main()
FILE: ACM 模板代码/f-稳定婚姻问题/f-稳定婚姻问题/main.cpp
type People (line 15) | struct People
method Init (line 21) | void Init()
type R (line 27) | struct R
function main (line 37) | int main()
function Input (line 46) | void Input()
function stableMatching (line 71) | void stableMatching()
function Output (line 115) | void Output()
FILE: ACM 模板代码/f-第K短路/f-第K短路/main.cpp
type node (line 111) | struct node
function init (line 126) | int init()
function solve (line 160) | int solve()
function main (line 201) | int main()
FILE: ACM 模板代码/f-素数相关/f-素数相关/main.cpp
function witness (line 186) | int witness(int a, int n)
function miller (line 206) | int miller(int n, int s = 50)
FILE: ACM 模板代码/f-约瑟夫环问题/f-约瑟夫环问题/main.cpp
function main (line 20) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-线性方程组/f-线性方程组/main.cpp
function gaussCpivot (line 25) | int gaussCpivot(int n, double a[][MAXN], double b[])
function gaussTpivot (line 78) | int gaussTpivot(int n, double a[][MAXN], double b[])
function main (line 158) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-线段树/f-线段树/main.cpp
type node (line 199) | struct node
function build (line 205) | void build(int st, int ed, int v) // 建树,区间为[st, ed]
function UpData (line 220) | void UpData(int v) // 更新结点区间的测度
function insert (line 246) | void insert(int st, int ed, int v)
function Delete (line 267) | void Delete(int st, int ed, int v)
type line (line 288) | struct line
function cmp (line 294) | bool cmp(line t1, line t2) // 为线段排序的函数,方便从左向右的扫描
function main (line 301) | int main()
function cal_C (line 338) | void cal_C(int n)
FILE: ACM 模板代码/f-线索二叉树/f-线索二叉树/main.cpp
type BiThrNode (line 18) | struct BiThrNode
type BiThrNode (line 21) | struct BiThrNode
function CreateBiThrTree (line 30) | void CreateBiThrTree(BiThrTree *T)
function InThreading (line 53) | void InThreading(BiThrTree T)
function InOrderThreading (line 78) | void InOrderThreading(BiThrTree *p, BiThrTree T)
function visit (line 101) | void visit(char c)
function InOrderTraverse (line 109) | void InOrderTraverse( BiThrTree T )
function main (line 135) | int main()
FILE: ACM 模板代码/f-组合数C(n, r)/f-组合数C(n, r)/main.cpp
function com (line 13) | int com(int n, int r) // return C(n, r)
function main (line 31) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-莫比乌斯反演/f-莫比乌斯反演/main.cpp
function Moblus (line 22) | void Moblus()
function main (line 54) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-莫队算法/f-莫队算法/main.cpp
type Point (line 134) | struct Point
function cmp (line 139) | bool cmp(Point a, Point b)
type BIT (line 152) | struct BIT
method init (line 155) | void init()
type Edge (line 163) | struct Edge
function cmpedge (line 168) | bool cmpedge(Edge a, Edge b)
function find (line 177) | int find(int x)
function addedge (line 189) | void addedge(int u, int v, int d)
type Graph (line 197) | struct Graph
function _addedge (line 204) | void _addedge(int u, int v)
function lowbit (line 212) | int lowbit(int x)
function update (line 217) | void update(int i, int val, int pos)
function ask (line 231) | int ask(int i, int m)
function dist (line 246) | int dist(Point a, Point b)
function Manhattan_minimum_spanning_tree (line 251) | void Manhattan_minimum_spanning_tree(int n, Point p[])
type Ans (line 314) | struct Ans
function add (line 321) | void add(int l, int r)
function del (line 332) | void del(int l, int r)
function dfs (line 343) | void dfs(int l1, int r1, int l2, int r2, int idx, int pre)
function gcd (line 391) | long long gcd(long long a, long long b)
function main (line 403) | int main()
FILE: ACM 模板代码/f-赫夫曼编码/f-赫夫曼编码/huffman.cpp
function htTree (line 15) | htTree *buildTree(char *inputString)
function traverseTree (line 74) | void traverseTree(htNode *treeNode, hlTable ** table, int k, char code[2...
function hlTable (line 112) | hlTable *buildTable(htTree *huffmanTree)
function encode (line 126) | void encode(hlTable *table, char *stringToEncode)
function decode (line 146) | void decode(htTree *tree, char *stringToDecode)
FILE: ACM 模板代码/f-赫夫曼编码/f-赫夫曼编码/huffman.hpp
type _htNode (line 14) | struct _htNode // 树结点
type _htNode (line 17) | struct _htNode
type _htTree (line 20) | struct _htTree // 树
type _hlNode (line 25) | struct _hlNode // 表结点
type _hlNode (line 29) | struct _hlNode
type _hlTable (line 32) | struct _hlTable // 表
FILE: ACM 模板代码/f-赫夫曼编码/f-赫夫曼编码/main.cpp
function main (line 12) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-赫夫曼编码/f-赫夫曼编码/queue.cpp
function initPQueue (line 13) | void initPQueue(pQueue **queue)
function addPQueue (line 22) | void addPQueue(pQueue **queue, TYPE val, unsigned int priority)
function TYPE (line 80) | TYPE getPQueue(pQueue **queue)
FILE: ACM 模板代码/f-赫夫曼编码/f-赫夫曼编码/queue.hpp
type _pQueueNode (line 18) | struct _pQueueNode // 队列结点
type _pQueueNode (line 22) | struct _pQueueNode
type _pQueue (line 25) | struct _pQueue // 队列
FILE: ACM 模板代码/f-逆序数/f-逆序数/main.cpp
function main (line 81) | int main()
FILE: ACM 模板代码/f-邻接表/f-邻接表/main.cpp
type Edge (line 14) | struct Edge
type Edge (line 18) | struct Edge
type Table (line 22) | struct Table
function main (line 28) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-阶乘最后非零位/f-阶乘最后非零位/main.cpp
function lastDigit (line 19) | int lastDigit(char *buf)
function main (line 44) | int main(int argc, const char * argv[])
FILE: ACM 模板代码/f-集合划分问题/f-集合划分问题/main.cpp
function NGetM (line 22) | void NGetM(int m, int n) // m 个数 n 个集合
function compute (line 53) | void compute(int m)
function main (line 69) | int main(int argc, const char * argv[]) {
FILE: ACM 模板代码/f-集合相关问题/f-集合相关问题/main.cpp
class SeqList (line 326) | class SeqList
method SeqList (line 329) | SeqList(){length=0;}
method SeqList (line 330) | SeqList(T a[],int n)//带参构造函数
method SeqList (line 338) | SeqList(const SeqList&A)//A中元素的值不变
method Length (line 344) | int Length()//求长度
method T (line 348) | T Get(int i)
method Locate (line 352) | int Locate(T item)//查找相同的元素
method Insert (line 363) | void Insert(int i,T item)//插入操作，在第i个位置前插入一个元素item
method T (line 381) | T Delete(int i)//删除操作
method display (line 398) | void display()//输出操作
method empty (line 403) | int empty()//判断是否为空
method clear (line 409) | void clear()//清理
function Union (line 418) | SeqList<T>Union(SeqList<T>A,SeqList<T> B)//集合的交集运算
function Toge (line 444) | SeqList<T>Toge(SeqList<T>A,SeqList<T> B)//集合的并集运算
function Subm (line 478) | SeqList<T>Subm(SeqList<T>A,SeqList<T> B)//集合的差集运算
function main (line 511) | int main()
FILE: ACM 模板代码/f-高斯消元/f-高斯消元/main.cpp
function Gauss (line 27) | int Gauss()
function main (line 74) | int main(int argc, const char * argv[]) {
FILE: 按 OJ 分类/51Nod/f-51Nod-1000-A+B/f-51Nod-1000-A+B/main.c
function main (line 11) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1001-数组中和等于K的数对/f-51Nod-1001-数组中和等于K的数对/main.cpp
type node (line 68) | struct node
function cmp (line 73) | int cmp(node x, node y)
function main (line 82) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1002-数塔取数问题/f-51Nod-1002-数塔取数问题/main.cpp
function main (line 19) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1003-阶乘后面的0的数量/f-51Nod-1003-阶乘后面的0的数量/main.c
function main (line 12) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1004-n^n的末位数字/f-51Nod-1004-n^n的末位数字/main.c
function main (line 12) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1005-大数加法/f-51Nod-1005-大数加法/main.c
function Carrying (line 17) | void Carrying(int tag, int i, int *p)
function Abdicate (line 30) | void Abdicate(int tag, int i, int *p)
function size (line 43) | void size(int numOneLen, int numTwoLen)
function addOrSub (line 82) | void addOrSub(int numOneLen, int numTwoLen, int flag) //flag加法为1减法为0
function print (line 140) | void print()
function main (line 158) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1006-Tick and Tick/f-51Nod-1006-Tick and Tick/main.cpp
function MAX (line 30) | inline double MAX(double a, double b, double c)
function MIN (line 44) | inline double MIN(double a, double b, double c)
function main (line 58) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1006-最长公共子序列Lcs/f-51Nod-1006-最长公共子序列Lcs/main.c
function max (line 17) | short max(short a, short b, short c)
function main (line 26) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1007-正整数分组/f-51Nod-1007-正整数分组/main.cpp
function main (line 22) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1008-N的阶乘 mod P/f-51Nod-1008-N的阶乘 mod P/main.c
function main (line 11) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1009-数字1的数量/f-51Nod-1009-数字1的数量/main.cpp
function getlen (line 80) | int getlen(int n)
function main (line 91) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1010-只包含2 3 5的数/f-51Nod-1010-只包含2 3 5的数/main.cpp
function init (line 28) | void init()
function bs (line 56) | int bs(ull a[], int l, int h, ull v)
function main (line 74) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1011-最大公约数GCD/f-51Nod-1011-最大公约数GCD/main.c
function gcd (line 11) | long gcd(long a, long b)
function main (line 24) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1012-最小公倍数LCM/f-51Nod-1012-最小公倍数LCM/main.c
function lcm (line 29) | long long lcm(long long A, long long B)
function main (line 44) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1013-3的幂的和/f-51Nod-1013-3的幂的和/main.c
type ll (line 140) | typedef long long ll;
function ll (line 142) | ll mod_pow(ll x,ll n)
function main (line 155) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1014-X^2 Mod P/f-51Nod-1014-X^2 Mod P/main.cpp
function main (line 15) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1015-水仙花数/f-51Nod-1015-水仙花数/main.cpp
function main (line 15) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1016-水仙花数 V2/f-51Nod-1016-水仙花数 V2/main.c
function compare (line 12) | int compare(char *a, char *b, int len)
function main (line 28) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1018-排序/f-51Nod-1018-排序/main.c
function swap (line 12) | void swap(long *A, int low, int high)
function Partition (line 24) | int Partition(long *A, int low, int high)
function QSort (line 43) | void QSort(long *A, int low, int high)
function sort (line 54) | void sort(long *A, int N)
function main (line 59) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1019-逆序数/f-51Nod-1019-逆序数/main.c
function merge (line 162) | void merge(int *a, int *b, int m, int mid, int n)
function Mergesort (line 184) | void Mergesort(int *a, int *b, int i, int j)
function main (line 197) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1020-逆序排序/f-51Nod-1020-逆序排序/main.cpp
function init (line 19) | void init()
function main (line 36) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1021-石子归并/f-51Nod-1021-石子归并/main.cpp
function main (line 21) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1022-石子归并 V2/f-51Nod-1022-石子归并 V2/main.cpp
function main (line 21) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1023-石子归并 V3/f-51Nod-1023-石子归并 V3/main.cpp
function dfs (line 24) | void dfs(int now)
function main (line 48) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1024-矩阵中不重复的元素/f-51Nod-1024-矩阵中不重复的元素/main.cpp
function main (line 17) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1027-大数乘法/f-51Nod-1027-大数乘法/main.c
function main (line 14) | int main(int argc, const char * argv[])
function Carrying (line 65) | void Carrying(int tag,int i,int j,int *p)
FILE: 按 OJ 分类/51Nod/f-51Nod-1028-大数乘法 V2/f-51Nod-1028-大数乘法 V2/main.cpp
type Complex (line 19) | struct Complex
method Complex (line 22) | Complex(double _x = 0.0, double _y = 0.0)
method Complex (line 27) | Complex operator - (const Complex &b) const
method Complex (line 31) | Complex operator + (const Complex &b) const
method Complex (line 35) | Complex operator * (const Complex &b) const
function change (line 44) | void change(Complex y[], int len)
function fft (line 72) | void fft(Complex y[], int len, int on)
function conv (line 102) | void conv(Complex a[], Complex b[], int ans[], int len)
function turn (line 120) | void turn(int ans[], int len, int unit)
function init (line 134) | void init(char str_1[], char str_2[])
function solve (line 170) | void solve()
function main (line 187) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1029-大数除法/f-51Nod-1029-大数除法/main.cpp
function powermod (line 18) | int powermod(int a, int exp, int moder)
function addminus (line 32) | void addminus(int *a, int *b, int &lengtha, int &lengthb, int type)
type BigInteger (line 43) | struct BigInteger
method BigInteger (line 53) | BigInteger()
method clear (line 59) | void clear()
method read (line 65) | void read()
method write (line 80) | void write()
method T (line 97) | T tointeger()
method equal (line 107) | bool equal(const BigInteger &p) const &
method greater (line 123) | bool greater(const BigInteger &p) const &
method leftshift (line 147) | void leftshift(int dis)
method rightshift (line 157) | void rightshift(int dis)
method addone (line 171) | void addone()
method minusone (line 193) | void minusone()
method absgreaterequal (line 200) | bool absgreaterequal(BigInteger &q)
method abs (line 220) | void abs()
method neg (line 225) | void neg()
method assign (line 230) | void assign(BigInteger &q)
method assign (line 239) | void assign(T q)
method add (line 254) | void add(BigInteger &q)
method minus (line 283) | void minus(BigInteger &q)
method NTT (line 290) | void NTT(int *a, int length, int type)
method mult (line 328) | void mult(BigInteger &q)
method mult (line 356) | void mult(int q)
method power (line 379) | void power(int exp)
method divide (line 398) | void divide(BigInteger &q)
method divide (line 451) | int divide(int q)
method sqrt (line 474) | void sqrt()
function main (line 525) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1030-大数进制转换/f-51Nod-1030-大数进制转换/main.cpp
function cTon (line 33) | int cTon(char c)
function convert (line 43) | void convert()
function solve (line 58) | void solve()
function print_d (line 88) | inline void print_d(T x)
function output (line 97) | void output()
function init (line 113) | void init()
function main (line 126) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1031-骨牌覆盖/f-51Nod-1031-骨牌覆盖/main.cpp
function main (line 18) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1032-骨牌覆盖 V2/f-51Nod-1032-骨牌覆盖 V2/main.cpp
function dfs (line 27) | void dfs(int col, int pre, int now)
function mul (line 44) | void mul(ll ret[][MAXN], ll a[][MAXN], ll b[][MAXN])
function main (line 62) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1033-骨牌覆盖 V2/f-51Nod-1033-骨牌覆盖 V2/main.cpp
function dfs (line 27) | void dfs(int col, int pre, int now)
function mul (line 44) | void mul(ll ret[][MAXN], ll a[][MAXN], ll b[][MAXN])
function main (line 62) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1035-最长的循环节/f-51Nod-1035-最长的循环节/main.cpp
function euler (line 14) | int euler(int n)
function main (line 37) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1038-X^A Mod P/f-51Nod-1038-X^A Mod P/main.cpp
function ll (line 21) | ll qk_pow(ll a, ll b, ll mod)
function ll (line 36) | ll ex_gcd(ll a, ll b, ll &x, ll &y)
function check (line 54) | bool check(ll g, ll p)
function ll (line 68) | ll primitive_root(ll p)
type sa (line 98) | struct sa
function ll (line 114) | ll discerte_log(ll x, ll n, ll m)
function residue (line 154) | vector<ll> residue(ll p, ll n, ll a)
function main (line 193) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1040-最大公约数之和/f-51Nod-1040-最大公约数之和/main.cpp
function euler (line 17) | unsigned euler(unsigned x)
function main (line 38) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1042-数字0~9的数量/f-51Nod-1042-数字0~9的数量/main.cpp
function init (line 22) | void init()
function ll (line 33) | ll count(ll x, int place) // 数是x，查询的数位是place
function main (line 76) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1043-幸运号码/f-51Nod-1043-幸运号码/main.cpp
function main (line 22) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1046-A^B Mod C/f-51Nod-1046-A^B Mod C/main.c
function PowerMod (line 36) | long PowerMod(long long A, long long B, long long C)
function main (line 52) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1049-最大子段和/f-51Nod-1049-最大子段和/main.c
function solve (line 52) | long long solve()
function main (line 66) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1050-循环数组最大子段和/f-51Nod-1050-循环数组最大子段和/main.cpp
function ll (line 21) | ll MaxSubStringOne(ll *A, int n)
function ll (line 34) | ll MaxSubStringTwo(ll *A, int n, ll sum)
function main (line 47) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1051-最大子矩阵和/f-51Nod-1051-最大子矩阵和/main.cpp
function main (line 20) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1052-最大M子段和/f-51Nod-1052-最大M子段和/main.cpp
function main (line 27) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1053-最大M子段和 V2/f-51Nod-1053-最大M子段和 V2/main.cpp
function scan_d (line 23) | inline bool scan_d(T &ret)
function _erase (line 51) | void _erase(int x)
function main (line 64) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1054-最长等差数列/f-51Nod-1054-最长等差数列/main.cpp
function main (line 20) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1055-最长等差数列/f-51Nod-1055-最长等差数列/main.cpp
function main (line 18) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1056-最长等差数列 V2/f-51Nod-1056-最长等差数列 V2/main.cpp
function read (line 26) | inline int read(){
function exist (line 32) | inline bool exist(int v){
function insert (line 38) | inline void insert(int v){
function main (line 42) | int main(){
FILE: 按 OJ 分类/51Nod/f-51Nod-1057-N的阶乘/f-51Nod-1057-N的阶乘/main.c
function main (line 83) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1058-N的阶乘的长度/f-51Nod-1058-N的阶乘的长度/main.c
function main (line 58) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1059-N的阶乘 V2/f-51Nod-1059-N的阶乘 V2/main.cpp
type complex (line 18) | struct complex
method complex (line 22) | complex(double real1 = 0.0, double imag1 = 0.0)
function complex (line 35) | complex operator * (const complex &n1, const complex &n2)
method complex (line 22) | complex(double real1 = 0.0, double imag1 = 0.0)
function complex (line 40) | complex operator + (const complex &n1, const complex &n2)
method complex (line 22) | complex(double real1 = 0.0, double imag1 = 0.0)
function complex (line 45) | complex operator - (const complex &n1, const complex &n2)
method complex (line 22) | complex(double real1 = 0.0, double imag1 = 0.0)
type BigInteger (line 66) | struct BigInteger
function Reverse (line 75) | void Reverse(int N, int bitlength)
function DFT (line 88) | void DFT(complex *A, complex *w1, complex *e, int N)
function Multiplication (line 123) | void Multiplication(int l1, int r1, int l2, int r2, int *a, int *b, int ...
function Print (line 208) | void Print(int len, int *a)
function factorial (line 264) | void factorial()
function init (line 303) | void init(int n)
function main (line 364) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1060-最复杂的数/f-51Nod-1060-最复杂的数/main.cpp
function dfs (line 20) | void dfs(ll cur, ll num, int key, ll pre) // 当前值/当前约数数量/当前深度/上一个数
function solve (line 54) | void solve()
function main (line 63) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1062-序列中的最大数/f-51Nod-1062-序列中的最大数/main.cpp
function init (line 20) | void init()
function main (line 51) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1063-序列中最大的数 V2/f-51Nod-1063-序列中最大的数 V2/main.cpp
function main (line 11) | int main(int argc, const char * argv[]) {
FILE: 按 OJ 分类/51Nod/f-51Nod-1065-最小正子段和/f-51Nod-1065-最小正子段和/main.cpp
type node (line 15) | struct node
function cmp (line 21) | bool cmp(node &a, node &b)
function main (line 26) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1066-Bash游戏/f-51Nod-1066-Bash游戏/main.c
function bash (line 18) | int bash(int N, int K)
function main (line 25) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1067-Bash游戏 V2/f-51Nod-1067-Bash游戏 V2/main.cpp
function main (line 15) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1068-Bash游戏 V3/f-51Nod-1068-Bash游戏 V3/main.cpp
function main (line 16) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1069-Nim游戏/f-51Nod-1069-Nim游戏/main.c
function main (line 12) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1070-Bash游戏 V4/f-51Nod-1070-Bash游戏 V4/main.cpp
function init (line 16) | void init()
function bs (line 28) | int bs(int a[], int l, int h, int N)
function main (line 50) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1072-威佐夫游戏/f-51Nod-1072-威佐夫游戏/main.c
function main (line 12) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1073-约瑟夫环/f-51Nod-1073-约瑟夫环/main.c
function main (line 12) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1074-约瑟夫环 V2/f-51Nod-1074-约瑟夫环 V2/main.cpp
function main (line 15) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1076-2条不相交的路径/f-51Nod-1076-2条不相交的路径/main.cpp
function init (line 34) | void init()
function tarjan (line 46) | void tarjan(int u, int fa)
function solve (line 81) | void solve()
function main (line 92) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1079-中国剩余定理/f-51Nod-1079-中国剩余定理/main.c
function main (line 11) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1080-两个数的平方和/f-51Nod-1080-两个数的平方和/main.cpp
function main (line 14) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1081-子段求和/f-51Nod-1081-子段求和/main.c
function main (line 12) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1082-与7无关的数/f-51Nod-1082-与7无关的数/main.cpp
function debug (line 20) | void debug()
function init (line 29) | void init()
function solve (line 55) | void solve()
function main (line 73) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1083-矩阵取数问题/f-51Nod-1083-矩阵取数问题/main.cpp
function main (line 20) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1084-矩阵取数问题 V2/f-51Nod-1084-矩阵取数问题 V2/main.cpp
function input (line 24) | void input()
function solve (line 37) | void solve()
function main (line 65) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1085-背包问题/f-51Nod-1085-背包问题/main.c
function KanpSack (line 15) | int KanpSack(int N, int *Wi, int *Pi, int W)
function main (line 45) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1086-背包问题 V2/f-51Nod-1086-背包问题 V2/main.cpp
function ZeroOnepark (line 130) | void ZeroOnepark(int val, int vol)
function Completepark (line 139) | void Completepark(int val, int vol)
function Multiplepark (line 148) | void Multiplepark(int val, int vol, int amount)
function main (line 170) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1087-1 10 100 1000/f-51Nod-1087-1 10 100 1000/main.cpp
function main (line 15) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1088-最长回文子串/f-51Nod-1088-最长回文子串/main.c
function main (line 69) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1089-最长回文子串 V2（Manacher算法）/f-51Nod-1089-最长回文子串 V2（Manacher算法）/main.c
function main (line 16) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1090-3个数和为0/f-51Nod-1090-3个数和为0/main.cpp
function main (line 18) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1091-线段的重叠/f-51Nod-1091-线段的重叠/main.cpp
type line (line 17) | struct line
function cmp (line 22) | bool cmp(line a, line b)
function main (line 27) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1092-回文字符串/f-51Nod-1092-回文字符串/main.cpp
function main (line 19) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1093-骆驼和香蕉/f-51Nod-1093-骆驼和香蕉/main.cpp
function main (line 13) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1094-和为k的连续区间/f-51Nod-1094-和为k的连续区间/main.cpp
function main (line 20) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1095-Anigram单词/f-51Nod-1095-Anigram单词/main.cpp
function main (line 16) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1096-距离之和最小/f-51Nod-1096-距离之和最小/main.cpp
function main (line 18) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1097-拼成最小的数/f-51Nod-1097-拼成最小的数/main.cpp
type num (line 20) | struct num
function cmp (line 27) | bool cmp(num a, num b)
function main (line 79) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1098-最小方差/f-51Nod-1098-最小方差/main.cpp
function main (line 21) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1099-任务执行顺序/f-51Nod-1099-任务执行顺序/main.cpp
function main (line 16) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1100-斜率最大/f-51Nod-1100-斜率最大/main.cpp
type point (line 17) | struct point
function cmp_p (line 23) | bool cmp_p(point a, point b)
type line (line 28) | struct line
function cmp_l (line 34) | bool cmp_l(line a, line b)
function main (line 39) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1101-换零钱/f-51Nod-1101-换零钱/main.cpp
function main (line 21) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1102-面积最大的矩形/f-51Nod-1102-面积最大的矩形/main.cpp
type a (line 19) | struct a
function main (line 26) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1103-N的倍数/f-51Nod-1103-N的倍数/main.cpp
function main (line 22) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1105-第K大的数/f-51Nod-1105-第K大的数/main.cpp
function ll (line 29) | ll check(ll x)
function main (line 50) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1106-质数检测/f-51Nod-1106-质数检测/main.c
function main (line 17) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1107-斜率小于0的连线数量/f-51Nod-1107-斜率小于0的连线数量/main.cpp
type node (line 107) | struct node
function cmp (line 122) | inline bool cmp(const node &nd1, const node &nd2)
function sum (line 127) | inline int sum(int i, int *bit)
function add (line 137) | inline void add(int i, int adder, int *bit)
function main (line 145) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1108-距离之和最小 V2/f-51Nod-1108-距离之和最小 V2/main.cpp
function main (line 20) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1109-01组成的N的倍数/f-51Nod-1109-01组成的N的倍数/main.cpp
type node (line 17) | struct node
function DFS (line 27) | void DFS(int pos)
function BFS (line 40) | void BFS()
function main (line 78) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1110-距离之和最小 V3/f-51Nod-1110-距离之和最小 V3/main.cpp
type point (line 16) | struct point
function cmp (line 22) | bool cmp(point a, point b)
function main (line 27) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1112-KGold/f-51Nod-1112-KGold/main.cpp
function intersection (line 118) | pair<double, double> intersection(ll x1, ll y1, ll x2, ll y2, ll x3, ll ...
type node (line 134) | struct node
type RESULT (line 146) | struct RESULT
function cmp_1 (line 152) | bool cmp_1(const node &nd1, const node &nd2)
function cmp_2 (line 157) | bool cmp_2(const RESULT &p1, const RESULT &p2)
function g_times (line 170) | int g_times(int time)
function main (line 188) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1113-矩阵快速幂/f-51Nod-1113-矩阵快速幂/main.cpp
type mat (line 20) | struct mat
function mat (line 26) | mat operator * (mat a, mat b)
function init_unit (line 45) | void init_unit()
function mat (line 54) | mat pow_mat(mat a, LL n)
function main (line 70) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1116-K进制下的大数/f-51Nod-1116-K进制下的大数/main.cpp
function main (line 19) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1117-聪明的木匠/f-51Nod-1117-聪明的木匠/main.cpp
function main (line 16) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1118-机器人走方格/f-51Nod-1118-机器人走方格/main.c
function path (line 37) | int path(int M, int N)
function main (line 52) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1119-机器人走方格 V2/f-51Nod-1119-机器人走方格 V2/main.cpp
function ll (line 18) | ll extend_gcd(ll a, ll b, ll &x, ll &y)
function ll (line 37) | ll mod_reverse(ll a, ll n)
function ll (line 51) | ll c(ll m, ll n)
function main (line 66) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1120-机器人走方格 V3/f-51Nod-1120-机器人走方格 V3/main.cpp
function QPow (line 20) | int QPow(int x, int n)
function init (line 38) | void init()
function C (line 52) | inline int C(int n, int m)
function lucas (line 61) | inline int lucas(int n, int m)
function main (line 66) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1122-机器人走方格 V4/f-51Nod-1122-机器人走方格 V4/main.cpp
type mat (line 23) | struct mat
function mat (line 29) | mat operator * (mat a, mat &b)
function init_unit (line 50) | void init_unit()
function mat (line 59) | mat pow_mat(mat a, LL n)
function main (line 74) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1124-N!的非0最低位/f-51Nod-1124-N!的非0最低位/main.cpp
function last_digit (line 18) | int last_digit()
function main (line 48) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1125-交换机器的最小代价/f-51Nod-1125-交换机器的最小代价/main.cpp
type machin (line 17) | struct machin
function solve (line 26) | long long solve(int k)
function cmp (line 44) | bool cmp(const machin a, const machin b)
function main (line 49) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1126-求递推序列的第N项/f-51Nod-1126-求递推序列的第N项/main.cpp
function main (line 15) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1127-最短的包含字符串/f-51Nod-1127-最短的包含字符串/main.cpp
function main (line 20) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1128-正整数分组 V2/f-51Nod-1128-正整数分组 V2/main.cpp
function check (line 21) | int check(ll num)
function ll (line 44) | ll bs(ll l, ll r)
function main (line 61) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1130-N的阶乘的长度 V2（斯特林近似）/f-51Nod-1130-N的阶乘的长度 V2（斯特林近似）/main.c
function main (line 14) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1131-覆盖数字的数量/f-51Nod-1131-覆盖数字的数量/main.cpp
function main (line 18) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1133-不重叠的线段/f-51Nod-1133-不重叠的线段/main.cpp
type line (line 17) | struct line
function cmp (line 22) | bool cmp(line a, line b)
function main (line 27) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1134-最长递增子序列/f-51Nod-1134-最长递增子序列/main.c
function upper_bound (line 48) | int upper_bound(int len, int A)
function list (line 61) | int list(int n)
function main (line 71) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1135-原根/f-51Nod-1135-原根/main.c
function store (line 19) | void store()
function QPow (line 44) | long long QPow(long long x, long long n)
function check (line 63) | int check(int g)
function solve (line 76) | int solve()
function main (line 88) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1136-欧拉函数/f-51Nod-1136-欧拉函数/main.cpp
function euler (line 14) | long long euler(long long x)
function main (line 35) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1137-矩阵乘法/f-51Nod-1137-矩阵乘法/main.cpp
function main (line 18) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1138-连续整数的和/f-51Nod-1138-连续整数的和/main.cpp
function main (line 15) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1140-矩阵相乘结果的判断/f-51Nod-1140-矩阵相乘结果的判断/main.cpp
function main (line 22) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1149-Pi的递推式/f-51Nod-1149-Pi的递推式/main.cpp
function QPow (line 26) | int QPow(int x, int y)
function C (line 43) | int C(int n, int m)
function init (line 49) | void init()
function main (line 63) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1153-选择子序列/f-51Nod-1153-选择子序列/main.cpp
function max_ (line 81) | int max_(int a, int b)
function main (line 86) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1154-回文串划分/f-51Nod-1154-回文串划分/main.cpp
function search (line 22) | int search(int pos)
function search_ (line 41) | int search_(int pos)
function main (line 63) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1157-全是1的最大子矩阵/f-51Nod-1157-全是1的最大子矩阵/main.cpp
function Run (line 18) | int Run(const int &m, const int &n) // a[1...m][1...n]
function main (line 74) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1158-全是1的最大子矩阵/f-51Nod-1158-全是1的最大子矩阵/main.cpp
function main (line 17) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1161-Partial Sums/f-51Nod-1161-Partial Sums/main.cpp
function getInv (line 21) | void getInv()
function init (line 32) | void init(int n, int k)
function main (line 41) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1163-最高的奖励/f-51Nod-1163-最高的奖励/main.cpp
type task (line 76) | struct task
function cmp (line 85) | bool cmp(const task a, const task b)
function find (line 90) | int find(int x)
function main (line 106) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1166-大数开平方/f-51Nod-1166-大数开平方/main.cpp
class BigInteger (line 20) | class BigInteger
method apply (line 30) | void apply(int length)
method destroy (line 40) | void destroy()
method resize (line 50) | void resize(int length)
method BigInteger (line 70) | BigInteger(int length) : length(length), sig(0)
method BigInteger (line 75) | BigInteger(const BigInteger &p, int length) : length(length), sig(p.sig)
method absgreaterequal (line 81) | bool absgreaterequal(const BigInteger &q) const &
method BigInteger (line 101) | BigInteger operator << (const int &dis) const &
method BigInteger (line 114) | BigInteger operator >> (const int &dis) const &
method powermod (line 126) | int powermod(int a, int exp) const &
method NTT (line 140) | void NTT(int *a, int length, int type) const &
method divide (line 176) | int divide(BigInteger &p, const int &q) const &
method BigInteger (line 204) | BigInteger() : length(0), sig(0) { a = nullptr; }
method BigInteger (line 205) | BigInteger(const BigInteger &p) : length(p.length), sig(p.sig)
method getlength (line 210) | int getlength() { return length; }
method positive (line 211) | bool positive() { return sig > 0; }
method iszero (line 212) | bool iszero() { return !sig; }
method negative (line 213) | bool negative() { return sig < 0; }
method even (line 214) | bool even() { return !sig || !(a[0] & 1); }
method BigInteger (line 216) | BigInteger &operator = (const BigInteger &p)
method BigInteger (line 227) | BigInteger &operator = (const T &p)
method read (line 241) | void read()
method write (line 269) | void write()
method T (line 286) | T tointeger()
method BigInteger (line 336) | BigInteger &operator ++ ()
method BigInteger (line 354) | BigInteger &operator -- ()
method BigInteger (line 362) | BigInteger operator ++ (int)
method BigInteger (line 369) | BigInteger operator -- (int)
method BigInteger (line 376) | BigInteger operator + (const BigInteger &p) const &
method BigInteger (line 409) | BigInteger operator - () const &
method BigInteger (line 416) | BigInteger operator - (const BigInteger &p) const & { return *this + (...
method BigInteger (line 418) | BigInteger operator * (const BigInteger &p) const &
method BigInteger (line 448) | BigInteger operator * (const int &p) const &
method BigInteger (line 474) | BigInteger operator / (const BigInteger &p) const &
method BigInteger (line 520) | BigInteger operator / (const int &p) const &
method BigInteger (line 528) | BigInteger sqrt() const &
method BigInteger (line 578) | BigInteger operator % (const BigInteger &p) const &
method BigInteger (line 597) | BigInteger operator * (const int &q, const BigInteger &p) { return p *...
method BigInteger (line 598) | BigInteger &operator += (const BigInteger &p) { *this = *this + p; ret...
method BigInteger (line 599) | BigInteger &operator -= (const BigInteger &p) { *this = *this - p; ret...
method BigInteger (line 600) | BigInteger &operator *= (const BigInteger &p) { *this = *this * p; ret...
method BigInteger (line 601) | BigInteger &operator *= (const int &p) { *this = *this * p; return *th...
method BigInteger (line 602) | BigInteger &operator /= (const BigInteger &p) { *this = *this / p; ret...
method BigInteger (line 603) | BigInteger &operator /= (const int &p) { *this = *this / p; return *th...
method BigInteger (line 604) | BigInteger &operator %= (const BigInteger &p) { *this = *this % p; ret...
method BigInteger (line 605) | BigInteger &operator %= (const int &p) { *this = *this % p; return *th...
method BigInteger (line 608) | BigInteger power(T exp) const &
function main (line 626) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1174-区间中最大数/f-51Nod-1174-区间中最大数/main.cpp
function initRMQ (line 22) | void initRMQ(int n, int b[])
function rmq (line 40) | int rmq(int x, int y)
function main (line 46) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1175-区间中第K大的数/f-51Nod-1175-区间中第K大的数/main.cpp
function Init_hash (line 22) | void Init_hash()
function build (line 32) | int build(int l, int r)
function hash_ (line 44) | int hash_(int x)
function update (line 49) | int update(int root, int pos, int val)
function query (line 78) | int query(int left_root, int right_root, int k)
function main (line 101) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1179-最大的最大公约数/f-51Nod-1179-最大的最大公约数/main.cpp
function main (line 19) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1181-质数中的质数（质数筛法）/f-51Nod-1181-质数中的质数（质数筛法）/main.cpp
function getPrime (line 22) | void getPrime()
function main (line 42) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1182-完美字符串/f-51Nod-1182-完美字符串/main.cpp
function main (line 19) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1183-编辑距离/f-51Nod-1183-编辑距离/main.cpp
function main (line 23) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1184-第N个质数/f-51Nod-1184-第N个质数/main.cpp
function ll (line 22) | ll g(ll n, int m)
function check (line 50) | bool check(ll x)
function init (line 56) | void init()
function main (line 87) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1185-威佐夫游戏 V2/f-51Nod-1185-威佐夫游戏 V2/main.cpp
function main (line 19) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1186-质数检测 V2/f-51Nod-1186-质数检测 V2/main.cpp
type bnum (line 19) | struct bnum
method read (line 24) | void read()
method bnum (line 54) | bnum & operator = (const int x)
method bnum (line 61) | bnum operator + (const bnum &x)
method bnum (line 74) | bnum operator - (const bnum &x)
method bnum (line 95) | bnum operator % (const bnum &x)
method bnum (line 112) | bnum & div2()
method is_odd (line 124) | bool is_odd()
method is_zero (line 129) | bool is_zero()
function mulmod (line 142) | void mulmod(bnum &a0, bnum &b0, bnum &p, bnum &ans)
function powmod (line 157) | void powmod(bnum &a0, bnum &b0, bnum &p, bnum &ans)
function MillerRabinTest (line 172) | bool MillerRabinTest(bnum &p, int iter)
function main (line 239) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1188-最大公约数之和 V2/f-51Nod-1188-最大公约数之和 V2/main.cpp
function get_phi (line 25) | void get_phi()
function init (line 58) | void init()
function scan_d (line 85) | inline void scan_d(T &ret)
function print_d (line 97) | inline void print_d(T x)
function main (line 106) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1189-阶乘分数/f-51Nod-1189-阶乘分数/main.cpp
function getPrime (line 29) | void getPrime()
function ll (line 49) | ll qPow(ll a, ll n)
function main (line 64) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1191-消灭兔子/f-51Nod-1191-消灭兔子/main.cpp
function main (line 128) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1192-Gcd表中的质数/f-51Nod-1192-Gcd表中的质数/main.cpp
function init (line 26) | void init()
function main (line 68) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1195-斐波那契数列的循环节/f-51Nod-1195-斐波那契数列的循环节/main.cpp
function getFib (line 18) | void getFib()
function main (line 26) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1196-字符串的数量/f-51Nod-1196-字符串的数量/main.cpp
function add (line 327) | void add(ll &x, ll y)
function ll (line 349) | ll modAdd(ll a, ll b)
function ll (line 355) | ll modMul(ll a , ll b)
function multiply (line 361) | void multiply(const vector<ll> &Q, vector<ll> &Qr)
function cal (line 380) | void cal(ll *A, ll n, ll k, ll *C)
function power (line 432) | int power(ll x, ll y)
function guass (line 446) | void guass(ll n)
function Count (line 487) | long long Count(vector<ll> A, ll R)
function main (line 503) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1197-字符串的数量 V2/f-51Nod-1197-字符串的数量 V2/main.cpp
function add (line 22) | void add(ll &x, ll y)
function ll (line 44) | ll modAdd(ll a, ll b)
function ll (line 50) | ll modMul(ll a , ll b)
function multiply (line 56) | void multiply(const vector<ll> &Q, vector<ll> &Qr)
function cal (line 75) | void cal(ll *A, ll n, ll k, ll *C)
function power (line 127) | int power(ll x, ll y)
function guass (line 141) | void guass(ll n)
function Count (line 182) | long long Count(vector<ll> A, ll R)
function main (line 198) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1198-字符串的数量 V3/f-51Nod-1198-字符串的数量 V3/main.cpp
function add (line 22) | void add(ll &x, ll y)
function ll (line 44) | ll modAdd(ll a, ll b)
function ll (line 50) | ll modMul(ll a , ll b)
function multiply (line 56) | void multiply(const vector<ll> &Q, vector<ll> &Qr)
function cal (line 75) | void cal(ll *A, ll n, ll k, ll *C)
function power (line 127) | int power(ll x, ll y)
function guass (line 141) | void guass(ll n)
function Count (line 182) | long long Count(vector<ll> A, ll R)
function main (line 198) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1199-Money out of Thin Air/f-51Nod-1199-Money out of Thin Air/main.cpp
type edge (line 22) | struct edge
method edge (line 27) | edge()
function read (line 37) | int read()
function add (line 52) | void add(int p, int pos)
type node (line 69) | struct node
function dfsI (line 78) | void dfsI(int x = 1, int pre = 0)
function dfsII (line 96) | void dfsII(int x = 1)
function build (line 113) | void build(int l = 1, int r = N, int x = 1)
function pushdown (line 127) | void pushdown(int x, int cnt)
function update1 (line 154) | void update1(int p, int add, int l, int r, int x)
function update2 (line 167) | void update2(int tl, int tr, int add, int l, int r, int x)
function ll (line 195) | ll query1(int p, int l, int r, int x)
function ll (line 206) | ll query2(int tl, int tr, int l, int r, int x)
function main (line 226) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1201-整数划分/f-51Nod-1201-整数划分/main.cpp
function main (line 18) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1202-子序列个数/f-51Nod-1202-子序列个数/main.cpp
function main (line 22) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1203-JZPLCM/f-51Nod-1203-JZPLCM/main.cpp
type note (line 21) | struct note
function QPow (line 39) | int QPow(int x, int y)
function add (line 53) | void add(int x, int y)
function find (line 61) | int find(int x)
function main (line 72) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1204-Parity/f-51Nod-1204-Parity/main.cpp
function find (line 16) | int find(int x)
function join (line 25) | void join(int x, int y)
function init (line 33) | void init()
function main (line 41) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1205-流水线调度/f-51Nod-1205-流水线调度/main.cpp
type task (line 17) | struct task
function cmpA (line 23) | bool cmpA(task a, task b)
function cmpB (line 28) | bool cmpB(task a, task b)
function main (line 33) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1208-Stars in Your Window/f-51Nod-1208-Stars in Your Window/main.cpp
type node1 (line 20) | struct node1
type node2 (line 26) | struct node2
type sta (line 33) | struct sta
function cmp_1 (line 43) | bool cmp_1(double a, double b)
function cmp_2 (line 48) | bool cmp_2(const node2 a, const node2 b)
function build_tree (line 60) | void build_tree(int root, int L, int R)
function add_tree (line 75) | void add_tree(int root, int L, int R, int c)
function main (line 102) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1212-无向图最小生成树/f-51Nod-1212-无向图最小生成树/main.cpp
function updata (line 27) | void updata(int x, int y, int v)
function Prim (line 34) | int Prim(int cost[][MAXN], int n) // 0 ~ n - 1
function main (line 72) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1215-数组的宽度/f-51Nod-1215-数组的宽度/main.cpp
type num (line 16) | struct num
method num (line 22) | num() : maxLeft(1), maxRight(1), minLeft(1), minRight(1) {}
function stackClear (line 30) | void stackClear()
function getMax (line 38) | void getMax()
function getMin (line 70) | void getMin()
function solve (line 102) | void solve()
function main (line 111) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1217-Minimum Modular/f-51Nod-1217-Minimum Modular/main.cpp
function read (line 134) | inline void read(int &x)
function main (line 148) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1220-约数之和/f-51Nod-1220-约数之和/main.cpp
function inc (line 27) | inline void inc(int &x, int y)
function dec (line 36) | inline void dec(int &x, int y)
function num1 (line 45) | inline int num1(int x)
function num1 (line 50) | inline int num1(int L, int R)
function calc_imu (line 57) | int calc_imu(int x)
function calc_imu (line 78) | inline int calc_imu(int L, int R)
function calc_g (line 85) | int calc_g(int n)
function calc_h (line 96) | int calc_h(int n)
function main (line 107) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1222-最小公倍数计数/f-51Nod-1222-最小公倍数计数/main.cpp
function init (line 27) | void init()
function ll (line 57) | ll calc(ll n)
function main (line 92) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1225-余数之和/f-51Nod-1225-余数之和/main.cpp
function main (line 16) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1227-平均最小公倍数/f-51Nod-1227-平均最小公倍数/main.cpp
function HX (line 28) | int HX(int q)
function ll (line 39) | ll SM(ll s, ll t)
function ll (line 44) | ll Gphi(int q)
function ll (line 69) | ll Gans(int n)
function init (line 81) | void init()
function main (line 114) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1228-序列求和/f-51Nod-1228-序列求和/main.cpp
function init (line 26) | void init()
function main (line 56) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1230-幸运数/f-51Nod-1230-幸运数/main.cpp
function init (line 29) | void init()
function ll (line 52) | ll dfs(int pos, int sum, int sqrt_sum, int flag)
function ll (line 76) | ll solve(ll n)
function main (line 87) | int main(void)
FILE: 按 OJ 分类/51Nod/f-51Nod-1232-完美数/f-51Nod-1232-完美数/main.cpp
function ll (line 27) | ll gcd(ll x, ll y)
function init (line 39) | void init()
function ll (line 54) | ll dfs(ll n, ll tag = 1, ll lcm = 1, ll num = 0)
function ll (line 92) | ll solve(ll x)
function main (line 109) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1237-最大公约数之和 V3/f-51Nod-1237-最大公约数之和 V3/main.cpp
function hash_ (line 27) | int hash_(ll x)
function ll (line 37) | ll Gphi(ll n)
function init (line 63) | void init()
function main (line 98) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1238-最小公倍数之和 V3/f-51Nod-1238-最小公倍数之和 V3/main.cpp
function HX (line 27) | int HX(ll q)
function ll (line 37) | ll SM(ll s, ll t)
function ll (line 47) | ll PF(ll q)
function ll (line 53) | ll Gphi(ll q)
function init (line 78) | void init()
function main (line 112) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1239-欧拉函数之和/f-51Nod-1239-欧拉函数之和/main.cpp
function add (line 32) | void add(int x, ll y, ll z)
function ll (line 40) | ll cal(ll x)
function init (line 67) | void init()
function main (line 101) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1240-莫比乌斯函数/f-51Nod-1240-莫比乌斯函数/main.cpp
function MOD (line 16) | int MOD(int a, int b)
function miu (line 21) | int miu(int n)
function main (line 49) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1241-特殊的排序/f-51Nod-1241-特殊的排序/main.cpp
function main (line 19) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1242-斐波那契数列的第N项/f-51Nod-1242-斐波那契数列的第N项/main.cpp
type MATRIX (line 17) | struct MATRIX
function ANS_Cf (line 25) | void ANS_Cf(MATRIX a)
function MATRIX (line 32) | MATRIX MATRIX_Cf(MATRIX a, MATRIX b)
function MATRIX (line 53) | MATRIX MATRIX_Pow(MATRIX a, long long n)
function main (line 72) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1243-排船的问题/f-51Nod-1243-排船的问题/main.cpp
function judge (line 20) | int judge(int d)
function bs (line 50) | int bs(int left, int right)
function main (line 70) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1244-莫比乌斯函数之和/f-51Nod-1244-莫比乌斯函数之和/main.cpp
function add (line 30) | void add(int x, ll y, int z)
function ll (line 38) | ll cal(ll x)
function init (line 64) | void init()
function main (line 99) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1246-罐子和硬币/f-51Nod-1246-罐子和硬币/main.cpp
function main (line 15) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1247-可能的路径/f-51Nod-1247-可能的路径/main.cpp
function ll (line 17) | ll kgcd(ll a, ll b)
function main (line 45) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1249-近似有序区间/f-51Nod-1249-近似有序区间/main.cpp
function build (line 25) | void build(int rt, int l, int r)
function query (line 40) | int query(int rt, int l, int r, int x, int y, int mx)
function main (line 68) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1254-最大子段和 V2/f-51Nod-1254-最大子段和 V2/main.cpp
function scan_d (line 26) | inline bool scan_d(T &ret)
function main (line 48) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1255-字典序最小的子序列/f-51Nod-1255-字典序最小的子序列/main.cpp
function main (line 96) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1256-乘法逆元/f-51Nod-1256-乘法逆元/main.cpp
function extendGcd (line 17) | long long extendGcd(long long a, long long b, long long &x, long long &y)
function modReverse (line 35) | long long modReverse(long long a, long long n)
function main (line 49) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1257-背包问题 V3/f-51Nod-1257-背包问题 V3/main.cpp
type article (line 21) | struct article
function gcd (line 27) | int gcd(int a, int b)
function cmp (line 36) | int cmp(article a, article b)
function charge (line 41) | int charge(int &x, int &y, double m)
function main (line 68) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1258-序列求和 V4/f-51Nod-1258-序列求和 V4/main.cpp
function main (line 11) | int main(int argc, const char * argv[]) {
FILE: 按 OJ 分类/51Nod/f-51Nod-1259-整数划分 V2/f-51Nod-1259-整数划分 V2/main.cpp
function main (line 21) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1262-扔球/f-51Nod-1262-扔球/main.cpp
function euler (line 17) | unsigned euler(unsigned x)
function main (line 38) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1264-线段相交/f-51Nod-1264-线段相交/main.cpp
type point (line 15) | struct point
function min (line 20) | double min(double a, double b)
function max (line 25) | double max(double a, double b)
function inter (line 30) | bool inter(point a, point b, point c, point d)
function main (line 44) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1265-四点共面/f-51Nod-1265-四点共面/main.cpp
type point (line 14) | struct point
method point (line 17) | point operator - (point &o)
function dot_product (line 27) | double dot_product(const point &a, const point &b)
function point (line 32) | point cross_product(const point &a, const point &b)
method point (line 17) | point operator - (point &o)
function main (line 41) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1266-蚂蚁/f-51Nod-1266-蚂蚁/main.cpp
function main (line 14) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1267-4个数和为0/f-51Nod-1267-4个数和为0/main.cpp
type node (line 96) | struct node
function init (line 104) | void init()
function insert_hash (line 111) | int insert_hash(int x)
function check_hash (line 121) | int check_hash(int x)
function main (line 134) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1268-和为K的组合/f-51Nod-1268-和为K的组合/main.cpp
function solve (line 133) | void solve()
function main (line 177) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1270-数组的最大代价/f-51Nod-1270-数组的最大代价/main.cpp
function main (line 52) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1272-最大距离/f-51Nod-1272-最大距离/main.cpp
type node (line 80) | struct node
function main (line 85) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1273-旅行计划/f-51Nod-1273-旅行计划/main.cpp
type node (line 21) | struct node
function add (line 29) | void add(int u, int v)
type node2 (line 36) | struct node2
method node2 (line 40) | node2(int x_, int d_, int cnt_ = 0) : x(x_), d(d_), cnt(cnt_) {}
function dfs (line 53) | void dfs(int x, int pr)
function cmp (line 77) | bool cmp(node2 a, node2 b)
function main (line 84) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1274-最长递增路径/f-51Nod-1274-最长递增路径/main.cpp
type edge (line 16) | struct edge
function cmp (line 25) | bool cmp(edge a, edge b)
function main (line 30) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1275-连续子段的差异/f-51Nod-1275-连续子段的差异/main.cpp
function solve (line 23) | void solve()
function main (line 66) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1276-岛屿的数量/f-51Nod-1276-岛屿的数量/main.cpp
type island (line 22) | struct island
type query (line 28) | struct query
function cmpI (line 34) | bool cmpI(island a, island b)
function cmpQ (line 39) | bool cmpQ(query a, query b)
function work (line 44) | void work()
function main (line 96) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1277-字符串中的最大值/f-51Nod-1277-字符串中的最大值/main.cpp
function getNext (line 21) | void getNext()
function main (line 38) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1278-相离的圆/f-51Nod-1278-相离的圆/main.cpp
type line (line 17) | struct line
function cmp (line 23) | bool cmp(line a, line b)
function bs (line 30) | int bs(line a[], int l, int h, int v)
function main (line 48) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1279-扔盘子/f-51Nod-1279-扔盘子/main.cpp
function main (line 19) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1280-前缀后缀集合/f-51Nod-1280-前缀后缀集合/main.cpp
function main (line 20) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1281-山峰和旗子/f-51Nod-1281-山峰和旗子/main.cpp
function get_peak_dis (line 104) | int get_peak_dis(int n)
function get_peak (line 123) | int get_peak(int n)
function can_value (line 138) | bool can_value(int n, int k)
function search_value (line 156) | int search_value(int n)
function main (line 175) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1282-时钟/f-51Nod-1282-时钟/main.cpp
function input (line 144) | void input()
function getMin (line 165) | int getMin(int *C)
function solve (line 198) | void solve()
function main (line 220) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1283-最小周长/f-51Nod-1283-最小周长/main.cpp
function main (line 15) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1284-2 3 5 7的倍数/f-51Nod-1284-2 3 5 7的倍数/main.c
type ll (line 11) | typedef long long ll;
function main (line 13) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1285-山峰和分段/f-51Nod-1285-山峰和分段/main.cpp
function main (line 21) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1287-加农炮/f-51Nod-1287-加农炮/main.cpp
function main (line 74) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1288-汽油补给/f-51Nod-1288-汽油补给/main.cpp
function main (line 21) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1289-大鱼吃小鱼/f-51Nod-1289-大鱼吃小鱼/main.c
function main (line 11) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1293-球与切换器/f-51Nod-1293-球与切换器/main.cpp
function main (line 144) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1294-修改数组/f-51Nod-1294-修改数组/main.cpp
function bsearch (line 24) | int bsearch(const int *f, int size, const int &a)
function LIS (line 46) | int LIS(const int *a, const int &n)
function main (line 71) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1295-XOR key/f-51Nod-1295-XOR key/main.cpp
function scan_d (line 26) | inline void scan_d(T &ret)
function insert (line 37) | void insert(int v, int &x, int y)
function find (line 49) | int find(int v, int x, int y)
function main (line 62) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1296-有限制的排列/f-51Nod-1296-有限制的排列/main.cpp
function main (line 22) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1298-圆与三角形/f-51Nod-1298-圆与三角形/main.cpp
function ll (line 24) | ll distance(Point *p_1, Point *p_2)
function segOnCircle (line 30) | int segOnCircle(Point *p_1, Point *p_2)
function intersect (line 64) | int intersect()
function main (line 81) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1299-监狱逃离/f-51Nod-1299-监狱逃离/main.cpp
function dfs (line 27) | void dfs(int x, int pre)
function init (line 65) | void init()
function main (line 73) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1307-绳子与重物/f-51Nod-1307-绳子与重物/main.cpp
type line (line 16) | struct line
function main (line 25) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1310-Chandrima and XOR/f-51Nod-1310-Chandrima and XOR/main.cpp
function init (line 22) | void init()
function BToD (line 31) | long long BToD()
function main (line 41) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1315-合法整数集/f-51Nod-1315-合法整数集/main.cpp
function main (line 16) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1316-回文矩阵/f-51Nod-1316-回文矩阵/main.cpp
function next (line 27) | void next(int &x)
function main (line 42) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1319-跳跃游戏/f-51Nod-1319-跳跃游戏/main.cpp
function main (line 20) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1320-合法尾数序列/f-51Nod-1320-合法尾数序列/main.cpp
function init (line 23) | void init()
function solve (line 46) | void solve(int n)
function main (line 86) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1322-关于树的函数/f-51Nod-1322-关于树的函数/main.cpp
type edge (line 31) | struct edge
function tii (line 39) | tii dfs_(int last, int root)
function dfs (line 72) | void dfs(int last, int root)
function main (line 85) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1328-比赛往事/f-51Nod-1328-比赛往事/main.cpp
function ins (line 21) | void ins(int *a, int k, int x)
function main (line 31) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1330-雕像投影/f-51Nod-1330-雕像投影/main.cpp
function charge (line 28) | int charge(int x, int y, int z)
function dfs (line 53) | void dfs(int x, int y, int z)
function charge_ (line 69) | int charge_()
function main (line 144) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1333-无聊的数学家们/f-51Nod-1333-无聊的数学家们/main.cpp
function getPrime (line 126) | void getPrime()
function main (line 154) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1335-子序列翻转/f-51Nod-1335-子序列翻转/main.cpp
function main (line 20) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1337-翻转游戏/f-51Nod-1337-翻转游戏/main.cpp
function init (line 18) | void init()
function main (line 27) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1341-混合序列/f-51Nod-1341-混合序列/main.cpp
type matrix (line 20) | struct matrix
method matrix (line 23) | matrix()
method output (line 27) | void output()
function matrix (line 40) | matrix mat(matrix &a, matrix &b)
method matrix (line 23) | matrix()
method output (line 27) | void output()
function extgcd (line 57) | void extgcd(ll a, ll b, ll &d, ll &x, ll &y)
function ll (line 73) | ll inverse(ll a,ll n)
function ll (line 80) | ll pow_mod(ll x, ll n)
function ll (line 97) | ll solve(ll n)
function main (line 123) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1344-走格子/f-51Nod-1344-走格子/main.cpp
function main (line 14) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1345-画点集/f-51Nod-1345-画点集/main.cpp
function check (line 25) | bool check(pair<int, int> &s, pair<int, int> &e, bool tag)
function solve (line 70) | int solve(int n)
function main (line 182) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1346-递归/f-51Nod-1346-递归/main.cpp
function get_c (line 95) | inline int get_c(int x, int y)
function main (line 116) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1347-旋转字符串/f-51Nod-1347-旋转字符串/main.c
function main (line 12) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1349-最大值/f-51Nod-1349-最大值/main.cpp
type node (line 22) | struct node
method node (line 29) | node() : left(1), right(1) {}
function get_max (line 37) | void get_max()
function get_b (line 71) | void get_b()
function get_c (line 81) | void get_c()
function main (line 90) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1350-斐波那契表示/f-51Nod-1350-斐波那契表示/main.cpp
function ll (line 85) | ll F(ll n)
function main (line 97) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1351-吃点心/f-51Nod-1351-吃点心/main.cpp
type dessert (line 16) | struct dessert
function cmpA (line 22) | bool cmpA(dessert a, dessert b)
function cmpB (line 27) | bool cmpB(dessert a, dessert b)
function main (line 32) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1352-集合计数/f-51Nod-1352-集合计数/main.cpp
function ll (line 19) | ll extgcd(ll a, ll b, ll &x, ll &y)
function ll (line 34) | ll solve()
function main (line 67) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1353-树/f-51Nod-1353-树/main.cpp
type edge (line 24) | struct edge
function AND_MOD (line 30) | void AND_MOD(int &x, int y)
function dfs (line 39) | void dfs(int u, int fa)
function main (line 66) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1354-选数字/f-51Nod-1354-选数字/main.cpp
function main (line 79) | int main(void)
FILE: 按 OJ 分类/51Nod/f-51Nod-1355-斐波那契的最小公倍数/f-51Nod-1355-斐波那契的最小公倍数/main.cpp
function scan_d (line 21) | inline void scan_d(T &ret)
function ll (line 32) | ll QPow(ll x, ll n)
function ll (line 50) | inline ll get_inv(ll a)
function init (line 60) | void init()
function main (line 84) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1358-浮波那契/f-51Nod-1358-浮波那契/main.cpp
type matrix (line 23) | struct matrix
function matrix (line 28) | matrix mu(matrix A, matrix B)
function matrix (line 49) | matrix multi(matrix mat, long long x)
function input (line 73) | void input()
function solve (line 78) | void solve()
function main (line 109) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1359-循环探求/f-51Nod-1359-循环探求/main.cpp
function init (line 36) | void init()
function read (line 44) | void read()
function mul (line 59) | void mul(ll res[], ll scr[])
function solve (line 77) | void solve()
function print (line 148) | void print()
function main (line 165) | int main ()
FILE: 按 OJ 分类/51Nod/f-51Nod-1363-最小公倍数之和/f-51Nod-1363-最小公倍数之和/main.cpp
function ll (line 24) | ll qpow(ll x, ll y)
function init (line 38) | void init()
function main (line 61) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1364-最大字典序排列/f-51Nod-1364-最大字典序排列/main.cpp
type node (line 26) | struct node
function push_up (line 33) | void push_up(int root)
function build_tree (line 48) | void build_tree(int root, int l, int r)
function update (line 71) | void update(int root, int pos)
function query (line 92) | void query(int root, int l, int r)
function query_k (line 116) | int query_k(int root, int k)
function query_sum (line 133) | int query_sum(int root, int l, int r)
function main (line 152) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1366-贫富差距/f-51Nod-1366-贫富差距/main.cpp
function Floyd (line 189) | void Floyd(MGraph G)
FILE: 按 OJ 分类/51Nod/f-51Nod-1371-填数字/f-51Nod-1371-填数字/main.cpp
function main (line 23) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1376-最长递增子序列的数量/f-51Nod-1376-最长递增子序列的数量/main.cpp
function read (line 19) | inline int read()
function get (line 35) | inline int get(int c, int x)
function main (line 53) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1377-最慢的快排/f-51Nod-1377-最慢的快排/main.cpp
function main (line 23) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1378-夹克老爷的愤怒/f-51Nod-1378-夹克老爷的愤怒/main.cpp
function dfs (line 27) | void dfs(int x, int pre)
function main (line 61) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1379-索函数/f-51Nod-1379-索函数/main.cpp
function init (line 22) | void init()
function ll (line 32) | ll pow_mod(ll x, ll n)
function main (line 47) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1380-夹克老爷的逢三抽一/f-51Nod-1380-夹克老爷的逢三抽一/main.cpp
function del (line 24) | void del(int x)
function main (line 31) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1381-硬币游戏/f-51Nod-1381-硬币游戏/main.cpp
function main (line 13) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1383-整数分解为2的幂/f-51Nod-1383-整数分解为2的幂/main.cpp
function init (line 19) | void init()
function main (line 34) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1384-全排列/f-51Nod-1384-全排列/main.cpp
function main (line 102) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1385-凑数字/f-51Nod-1385-凑数字/main.cpp
function main (line 17) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1388-六边形平面/f-51Nod-1388-六边形平面/main.cpp
function countX (line 142) | void countX(int l, int r)
function dfs (line 188) | void dfs()
function canFind (line 203) | void canFind(int sti, int stj, int tox, int toy, int step)
function findOddCycle (line 234) | void findOddCycle()
function main (line 265) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1390-游戏得分/f-51Nod-1390-游戏得分/main.cpp
function main (line 136) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1391-01串/f-51Nod-1391-01串/main.cpp
function main (line 23) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1393-0和1相等串/f-51Nod-1393-0和1相等串/main.cpp
function main (line 22) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1394-差和问题/f-51Nod-1394-差和问题/main.cpp
type o (line 24) | struct o
function lowbit (line 35) | int lowbit(int x)
function add (line 40) | void add(int x, ll y, ll arr[])
function ll (line 49) | ll sum(int x, ll arr[])
function discretize (line 61) | void discretize()
function build (line 77) | void build()
function scan_d (line 93) | inline void scan_d(T &ret)
function Out (line 105) | void Out(T a)
function main (line 114) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1396-还是01串/f-51Nod-1396-还是01串/main.cpp
function main (line 21) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1398-等公交/f-51Nod-1398-等公交/main.cpp
function main (line 25) | int main ()
FILE: 按 OJ 分类/51Nod/f-51Nod-1400-序列分解/f-51Nod-1400-序列分解/main.cpp
function dfs (line 22) | void dfs(int posA, int posB, int posC)
function main (line 64) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1402-最大值/f-51Nod-1402-最大值/main.cpp
function main (line 18) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1403-有趣的堆栈/f-51Nod-1403-有趣的堆栈/main.cpp
function solve (line 20) | void solve(int l, int r)
function scan_d (line 33) | inline void scan_d(T &ret)
function out (line 44) | inline void out(int x)
function main (line 53) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1405-树的距离之和/f-51Nod-1405-树的距离之和/main.cpp
function DFS (line 107) | void DFS(int a, int last)
function main (line 135) | int main ()
FILE: 按 OJ 分类/51Nod/f-51Nod-1406-与查询/f-51Nod-1406-与查询/main.cpp
function in (line 22) | void in(int &res)
function out (line 37) | void out(int a)
function main (line 54) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1409-加强版贪吃蛇/f-51Nod-1409-加强版贪吃蛇/main.cpp
function bfs (line 30) | void bfs(int x, int y)
function scan_d (line 65) | inline bool scan_d(T &ret)
function main (line 87) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1412-AVL树的种类/f-51Nod-1412-AVL树的种类/main.cpp
function init (line 81) | void init()
function main (line 101) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1413-权势二进制/f-51Nod-1413-权势二进制/main.cpp
function main (line 13) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1414-冰雕/f-51Nod-1414-冰雕/main.cpp
function calc (line 66) | int calc(int cnt, int step)
function main (line 82) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1416-两点/f-51Nod-1416-两点/main.cpp
function solve (line 22) | void solve(int x, int y, int tag)
function main (line 76) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1417-天堂里的游戏/f-51Nod-1417-天堂里的游戏/main.cpp
function gcd (line 14) | long long gcd(long long x, long long y)
function main (line 24) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1418-放球游戏/f-51Nod-1418-放球游戏/main.cpp
function main (line 20) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1419-最小公倍数挑战/f-51Nod-1419-最小公倍数挑战/main.cpp
function main (line 13) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1420-数袋鼠好有趣/f-51Nod-1420-数袋鼠好有趣/main.cpp
function bs (line 19) | int bs(int l, int h, int v)
function main (line 37) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1421-最大MOD值/f-51Nod-1421-最大MOD值/main.cpp
function scan_d (line 21) | inline void scan_d(T &ret)
function main (line 32) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1422-沙拉酱前缀/f-51Nod-1422-沙拉酱前缀/main.cpp
type ope (line 22) | struct ope
function input (line 33) | void input()
function solve (line 53) | void solve()
function main (line 86) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1423-最大二"货"/f-51Nod-1423-最大二"货"/main.cpp
function scan_d (line 22) | inline void scan_d(T &ret)
function main (line 33) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1424-零树/f-51Nod-1424-零树/main.cpp
function scan_d (line 27) | inline bool scan_d(T &ret)
function dfs (line 49) | void dfs(int root, int pre)
function main (line 66) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1425-减减数/f-51Nod-1425-减减数/main.cpp
function pll (line 21) | pll dfs(ll mx, ll n)
function main (line 44) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1428-活动安排问题/f-51Nod-1428-活动安排问题/main.cpp
type party (line 17) | struct party
function addParty (line 25) | void addParty(int Begin, int End)
function cmp (line 33) | bool cmp(party a, party b)
function main (line 38) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1429-巧克力/f-51Nod-1429-巧克力/main.cpp
function get_cnt (line 111) | void get_cnt(int &cnt_A, int & cnt_B, int div)
function main (line 125) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1430-奇偶游戏/f-51Nod-1430-奇偶游戏/main.cpp
function D_win (line 13) | void D_win()
function S_win (line 18) | void S_win()
function main (line 25) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1431-快乐排队/f-51Nod-1431-快乐排队/main.cpp
function scan_d (line 17) | inline void scan_d(T &ret)
function main (line 31) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1432-独木舟/f-51Nod-1432-独木舟/main.cpp
function main (line 21) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1433-0和5/f-51Nod-1433-0和5/main.cpp
function main (line 15) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1434-区间LCM/f-51Nod-1434-区间LCM/main.cpp
function main (line 95) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1435-位数阶乘/f-51Nod-1435-位数阶乘/main.cpp
function main (line 22) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1436-方程的解数/f-51Nod-1436-方程的解数/main.cpp
type matrix (line 21) | struct matrix
function ans_cf (line 28) | void ans_cf(matrix a)
function matrix (line 34) | matrix matrix_cf(matrix a, matrix b)
function matrix (line 53) | matrix matrix_pow(matrix a, ll n)
function ll (line 71) | ll qpow(ll a, ll b)
function init (line 87) | void init()
function main (line 93) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1437-迈克步/f-51Nod-1437-迈克步/main.cpp
type num (line 18) | struct num
method num (line 23) | num() : minLeft(1), minRight(1) {}
function stackClear (line 30) | void stackClear()
function getMin (line 38) | void getMin()
function solve (line 72) | void solve()
function scan_d (line 86) | inline void scan_d(T &ret)
function Out (line 97) | void Out(int a)
function main (line 111) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1438-方阵与完全平方数/f-51Nod-1438-方阵与完全平方数/main.cpp
function sear (line 26) | long long sear(long long num)
function dfs (line 38) | void dfs(int x, int y, long long value)
function main (line 153) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1439-互质对/f-51Nod-1439-互质对/main.cpp
function dfs (line 26) | void dfs(int pos, int mul, int sym, int flag)
function init (line 48) | void init()
function main (line 64) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1441-士兵的数字游戏/f-51Nod-1441-士兵的数字游戏/main.cpp
function scan (line 147) | inline void scan(int &a)
function getPrime (line 164) | void getPrime()
function main (line 186) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1442-士兵的旅行/f-51Nod-1442-士兵的旅行/main.cpp
type edge (line 23) | struct edge
method edge (line 27) | edge(int a, int b, int c)
function add_edge (line 39) | void add_edge(int from, int to, int cap)
function bfs (line 45) | void bfs(int s)
function dfs (line 69) | int dfs(int v, int t, int f)
function max_flow (line 94) | int max_flow(int s, int t)
function main (line 117) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1443-路径和树/f-51Nod-1443-路径和树/main.cpp
type Edge (line 30) | struct Edge
method Edge (line 34) | Edge(int U = -1, int V = -1, ll C = -1)
function find (line 49) | int find(int x)
function merge (line 61) | void merge(int x, int y)
function spfa (line 72) | void spfa(int star)
function ll (line 107) | ll Kruskal()
function main (line 130) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1444-破坏道路/f-51Nod-1444-破坏道路/main.cpp
function bfs (line 26) | void bfs()
function charge (line 56) | bool charge(int s1, int t1, int s2, int t2, int i, int j)
function main (line 61) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1445-变色DNA/f-51Nod-1445-变色DNA/main.cpp
function init (line 16) | void init()
function dijkstra (line 33) | void dijkstra(int pos)
function main (line 61) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1448-二染色问题/f-51Nod-1448-二染色问题/main.cpp
function main (line 22) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1449-砝码称重/f-51Nod-1449-砝码称重/main.cpp
function main (line 13) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1451-合法三角形/f-51Nod-1451-合法三角形/main.cpp
function solve (line 26) | void solve()
function main (line 65) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1452-加括号/f-51Nod-1452-加括号/main.cpp
function main (line 26) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1453-抽彩球/f-51Nod-1453-抽彩球/main.cpp
function LL (line 89) | LL ppow(LL x, LL y)
function LL (line 104) | LL work(LL m, LL i)
function main (line 109) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1454-升排列/f-51Nod-1454-升排列/main.cpp
function main (line 22) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1455-宝石猎人/f-51Nod-1455-宝石猎人/main.cpp
function solve (line 93) | void solve()
function main (line 144) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1456-小K的技术/f-51Nod-1456-小K的技术/main.cpp
function find (line 29) | int find(int x)
function Tarjan (line 41) | void Tarjan(int u)
function solve (line 71) | void solve()
function scan_d (line 128) | inline void scan_d(T &ret)
function init (line 139) | void init()
function main (line 159) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1459-迷宫游戏/f-51Nod-1459-迷宫游戏/main.cpp
function Dij (line 25) | void Dij(int v)
function main (line 70) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1460-连接小岛/f-51Nod-1460-连接小岛/main.cpp
type node (line 22) | struct node
function input (line 44) | void input()
function solve (line 72) | void solve()
function main (line 89) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1461-稳定桌/f-51Nod-1461-稳定桌/main.cpp
function scan_d (line 24) | inline void scan_d(T &ret)
type leg (line 35) | struct leg
type node (line 44) | struct node
function pushup (line 53) | inline void pushup(int k)
function build (line 59) | void build(int l, int r, int k)
function update (line 76) | void update(int l, int r, int k)
function ll (line 102) | ll query(int l, int r, int k)
function main (line 121) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1463-找朋友/f-51Nod-1463-找朋友/main.cpp
type node (line 21) | struct node
type interval (line 29) | struct interval // 区间
function build (line 51) | void build(int root, int l, int r)
function query (line 66) | void query(int root, int l, int r)
function insert (line 89) | void insert(int root, int pos, int val)
function main (line 107) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1464-半回文/f-51Nod-1464-半回文/main.cpp
type Tree (line 225) | struct Tree
method Tree (line 230) | Tree()
function init (line 237) | void init()
function insert_tree (line 267) | void insert_tree(Tree *ptemp, char *s)
function dfs (line 290) | void dfs(Tree *ptemp)
function solve (line 308) | void solve()
function main (line 325) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1467-旋转绳/f-51Nod-1467-旋转绳/main.cpp
type snag (line 21) | struct snag
function bs (line 30) | int bs(int x)
function scan_d (line 50) | inline bool scan_d(T &ret)
function out_d (line 73) | inline void out_d(T a)
function main (line 87) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1468-小Y的IP地址/f-51Nod-1468-小Y的IP地址/main.cpp
function main (line 23) | int main ()
FILE: 按 OJ 分类/51Nod/f-51Nod-1469-淋漓尽致子串/f-51Nod-1469-淋漓尽致子串/main.cpp
function cmp (line 26) | int cmp(int *r, int a, int b, int l)
function da (line 31) | void da(char str[], int n, int m)
function solve (line 120) | int solve(int len)
function main (line 177) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1473-等幂映射/f-51Nod-1473-等幂映射/main.cpp
function ll (line 138) | ll gcd(ll a, ll b)
function ll (line 143) | ll lcm(ll a, ll b)
function main (line 150) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1475-建设国家/f-51Nod-1475-建设国家/main.cpp
type city (line 17) | struct city
function cmp (line 25) | bool cmp(city a, city b)
function main (line 30) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1476-括号序列的最小代价/f-51Nod-1476-括号序列的最小代价/main.cpp
function main (line 24) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1478-括号序列的最长合法子段/f-51Nod-1478-括号序列的最长合法子段/main.cpp
function main (line 103) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1480-打广告/f-51Nod-1480-打广告/main.cpp
function scan_d (line 21) | inline void scan_d(T &ret)
type node (line 32) | struct node
function cmp (line 42) | bool cmp(node a, node b)
function main (line 47) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1483-化学变换/f-51Nod-1483-化学变换/main.cpp
function F (line 22) | void F(int temp, int cnt)
function main (line 32) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1484-猜数游戏/f-51Nod-1484-猜数游戏/main.cpp
function pri (line 19) | void pri(int i)
function dfs (line 43) | void dfs(ll L, ll R, int high)
function main (line 119) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1485-字母排序/f-51Nod-1485-字母排序/main.cpp
function split (line 26) | void split(int p)
function merge (line 82) | void merge(int l, int r, int k)
function scan_d (line 106) | inline void scan_d(T &ret)
function main (line 117) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1486-大大走格子/f-51Nod-1486-大大走格子/main.cpp
type node (line 21) | struct node
function cmp (line 30) | int cmp(node a, node b)
function ll (line 35) | ll pow(ll x, ll k)
function init (line 50) | void init()
function main (line 66) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1487-占领资源/f-51Nod-1487-占领资源/main.cpp
function RMQ_init (line 113) | void RMQ_init(int n)
function RMQ_max (line 128) | int RMQ_max(int L, int R)
function max_ (line 138) | bool max_(int &a, int b)
function ID (line 148) | inline int ID(int x, int y)
function solve (line 153) | int solve()
function main (line 220) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1489-蜥蜴和地下室/f-51Nod-1489-蜥蜴和地下室/main.cpp
function main (line 122) | int main ()
FILE: 按 OJ 分类/51Nod/f-51Nod-1490-多重游戏/f-51Nod-1490-多重游戏/main.cpp
function init (line 25) | void init()
function inser (line 32) | void inser(char *s)
function losses (line 52) | int losses(int u)
function gains (line 85) | int gains(int u)
function main (line 113) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1491-黄金系统/f-51Nod-1491-黄金系统/main.cpp
function judge (line 20) | bool judge(char C[], int i)
function main (line 31) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1493-数据关联/f-51Nod-1493-数据关联/main.cpp
function scan_d (line 23) | inline void scan_d(T &ret)
function main (line 34) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1494-选举拉票/f-51Nod-1494-选举拉票/main.cpp
function update (line 29) | void update(int rt, int l, int r, int x)
function query (line 51) | int query(int rt, int l, int r, int x)
function scan_d (line 74) | inline void scan_d(T &ret)
function main (line 85) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1495-中国好区间/f-51Nod-1495-中国好区间/main.cpp
function solve (line 20) | void solve()
function main (line 63) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1496-最小异或和/f-51Nod-1496-最小异或和/main.cpp
function main (line 17) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1499-图/f-51Nod-1499-图/main.cpp
type Edge (line 70) | struct Edge
function addedge (line 81) | void addedge(int from, int to, int cap)
function bfs (line 87) | void bfs(int S)
function dfs (line 110) | int dfs(int v, int t, int f)
function maxflow (line 135) | int maxflow(int S, int T)
function main (line 156) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1500-苹果曼和树/f-51Nod-1500-苹果曼和树/main.cpp
function dfs (line 24) | void dfs(int r, int pre)
function main (line 48) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1503-猪和回文/f-51Nod-1503-猪和回文/main.cpp
function add (line 18) | void add(int &x, int y)
function main (line 27) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1509-加长棒/f-51Nod-1509-加长棒/main.cpp
function ll (line 15) | ll Solve(ll a, ll b, ll c, ll L) // a是三边之间最大的
function main (line 30) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1510-最小化序列/f-51Nod-1510-最小化序列/main.cpp
function scan_d (line 23) | inline bool scan_d(T &ret)
function main (line 45) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1513-树上的回文/f-51Nod-1513-树上的回文/main.cpp
function dfs (line 28) | void dfs(int x, int h)
function solve (line 45) | int solve(int x, int h)
function init (line 68) | void init()
function scan_d (line 79) | inline void scan_d(T &ret)
function main (line 90) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1515-明辨是非/f-51Nod-1515-明辨是非/main.cpp
function find (line 22) | int find(int x)
function main (line 27) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1519-拆方块/f-51Nod-1519-拆方块/main.cpp
function scan_d (line 22) | inline void scan_d(T &ret)
function main (line 33) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1521-一维战舰/f-51Nod-1521-一维战舰/main.cpp
function main (line 70) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1522-上下序列/f-51Nod-1522-上下序列/main.cpp
function charge (line 27) | bool charge(int t1, int t2, int l, int r)
function main (line 63) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1523-非回文/f-51Nod-1523-非回文/main.cpp
function check (line 130) | bool check(int v)
function solve (line 143) | bool solve(int v)
function main (line 180) | int main ()
FILE: 按 OJ 分类/51Nod/f-51Nod-1524-可除图的最大团/f-51Nod-1524-可除图的最大团/main.cpp
function scan_d (line 21) | inline void scan_d(T &ret)
function main (line 32) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1525-重组公司/f-51Nod-1525-重组公司/main.cpp
function find (line 20) | int find(int x)
function merge_1 (line 25) | void merge_1(int x, int y)
function merge_2 (line 35) | void merge_2(int x, int y)
function scan_d (line 46) | inline void scan_d(T &ret)
function init (line 57) | void init()
function main (line 66) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1526-分配笔名/f-51Nod-1526-分配笔名/main.cpp
function dfs (line 26) | void dfs(int x)
function main (line 47) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1530-稳定方块/f-51Nod-1530-稳定方块/main.cpp
function judge (line 28) | bool judge(int a, int b)
function scan_d (line 55) | inline bool scan_d(T &ret)
function main (line 77) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1533-一堆的堆/f-51Nod-1533-一堆的堆/main.cpp
function lowbit (line 25) | int lowbit(int x)
function add (line 30) | void add(int x, int d)
function query (line 39) | int query(int x)
function solve (line 50) | void solve ()
function scan_d (line 79) | inline bool scan_d(T &ret)
function main (line 101) | int main(void)
FILE: 按 OJ 分类/51Nod/f-51Nod-1534-棋子游戏/f-51Nod-1534-棋子游戏/main.cpp
function solve (line 16) | void solve()
function main (line 44) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1535-深海探险/f-51Nod-1535-深海探险/main.cpp
function dfs (line 19) | void dfs(int st)
function main (line 31) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1536-不一样的猜数游戏/f-51Nod-1536-不一样的猜数游戏/main.cpp
function getPrime (line 24) | void getPrime(int n)
function main (line 47) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1540-俄罗斯赌轮盘/f-51Nod-1540-俄罗斯赌轮盘/main.cpp
function main (line 22) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1548-欧姆诺姆和糖果/f-51Nod-1548-欧姆诺姆和糖果/main.cpp
type candy (line 16) | struct candy
function main (line 23) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1552-白兰地定位系统/f-51Nod-1552-白兰地定位系统/main.cpp
function scan_d (line 24) | inline void scan_d(T &ret)
function main (line 35) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1554-欧姆诺姆和项链/f-51Nod-1554-欧姆诺姆和项链/main.cpp
function get_nt (line 19) | void get_nt()
function main (line 36) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1556-计算/f-51Nod-1556-计算/main.cpp
function ll (line 22) | ll inv(ll a, ll m)
function main (line 36) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1557-两个集合/f-51Nod-1557-两个集合/main.cpp
function bs (line 21) | int bs(int l, int h, int v)
function main (line 43) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1560-扔人游戏/f-51Nod-1560-扔人游戏/main.cpp
function near (line 27) | int near(int s)
function dfs (line 41) | void dfs(int d)
function main (line 129) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1562-玻璃切割/f-51Nod-1562-玻璃切割/main.cpp
function scan_d (line 112) | inline void scan_d(int &ret)
function findW (line 123) | int findW(int x)
function joinW (line 132) | void joinW(int x, int y)
function findH (line 147) | int findH(int x)
function joinH (line 156) | void joinH(int x, int y)
function init (line 172) | void init()
function main (line 189) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1563-坐标轴上的最大团/f-51Nod-1563-坐标轴上的最大团/main.cpp
type node (line 18) | struct node
function cmp (line 26) | bool cmp(node a, node b)
function main (line 35) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1564-区间的价值/f-51Nod-1564-区间的价值/main.cpp
function solve (line 23) | void solve(int l, int r)
function main (line 55) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1571-最近等对/f-51Nod-1571-最近等对/main.cpp
type node (line 21) | struct node
function cmp (line 34) | int cmp(node a, node b)
function build (line 39) | void build(int rt, int l, int r)
function pushup (line 51) | void pushup(int rt)
function pushdown (line 56) | void pushdown(int rt)
function update (line 68) | void update(int rt, int l, int r, int l_, int r_, int v)
function query (line 90) | int query(int rt, int l, int r, int l_, int r_)
function slove (line 112) | void slove()
function scan_d (line 141) | inline bool scan_d(T &ret)
function print_d (line 164) | inline void print_d(T x)
function main (line 173) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1572-宝岛地图/f-51Nod-1572-宝岛地图/main.cpp
type node (line 143) | struct node
type order (line 148) | struct order
function ok (line 158) | bool ok(int x, int y)
function Sum (line 163) | int Sum(int a, int b, int c, int d)
function charge (line 168) | bool charge(int x, int y)
function main (line 224) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1573-美丽的集合/f-51Nod-1573-美丽的集合/main.cpp
function scan_d (line 26) | inline void scan_d(T &ret)
function find (line 37) | int find(int x)
function main (line 42) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1574-排列转换/f-51Nod-1574-排列转换/main.cpp
function abs (line 22) | int abs(int a)
function main (line 27) | int main ()
FILE: 按 OJ 分类/51Nod/f-51Nod-1580-铺管道/f-51Nod-1580-铺管道/main.cpp
function solve (line 24) | void solve(bool T[][MAXN], int n, int m, int flag)
function main (line 81) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1581-摆放骨牌/f-51Nod-1581-摆放骨牌/main.cpp
function BFS (line 26) | void BFS(int x, int y)
function main (line 70) | int main ()
FILE: 按 OJ 分类/51Nod/f-51Nod-1582-n叉树/f-51Nod-1582-n叉树/main.cpp
type Matrix (line 23) | struct Matrix
function Matrix (line 28) | Matrix mul(Matrix x, Matrix y)
function Matrix (line 50) | Matrix qpow(Matrix x, int k)
function main (line 76) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1586-约数和/f-51Nod-1586-约数和/main.cpp
function scan_d (line 22) | inline void scan_d(T &ret)
function print_d (line 34) | inline void print_d(T x)
function main (line 43) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1589-移数博弈/f-51Nod-1589-移数博弈/main.cpp
function del (line 27) | void del(int now)
function main (line 33) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1593-公园晨跑/f-51Nod-1593-公园晨跑/main.cpp
type point (line 23) | struct point
method point (line 28) | point()
type Seg (line 34) | struct Seg
method Seg (line 40) | Seg()
method push_up (line 45) | void push_up(point &a, int rt)
method update (line 59) | void update(int x, int l, int r, int rt)
method update (line 76) | void update(int x, ll k)
method query (line 82) | void query(int l, int r, int L, int R, int rt)
method query (line 102) | int query(int l, int r)
function scan_d (line 117) | inline void scan_d(T &ret)
function print_d (line 129) | inline void print_d(T x)
function main (line 138) | int main ()
FILE: 按 OJ 分类/51Nod/f-51Nod-1594-Gcd and Phi/f-51Nod-1594-Gcd and Phi/main.cpp
function solve (line 28) | void solve()
function main (line 94) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1595-回文度/f-51Nod-1595-回文度/main.cpp
function Manacher (line 20) | void Manacher(int len)
function main (line 45) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1596-搬货物/f-51Nod-1596-搬货物/main.cpp
function scan_d (line 20) | inline void scan_d(T &ret)
function main (line 31) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1597-有限背包计数问题/f-51Nod-1597-有限背包计数问题/main.cpp
function main (line 28) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1603-限高二叉排列树/f-51Nod-1603-限高二叉排列树/main.cpp
function main (line 19) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1605-棋盘问题/f-51Nod-1605-棋盘问题/main.cpp
function main (line 15) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1607-卷积和/f-51Nod-1607-卷积和/main.cpp
function ll (line 24) | ll dfs(int len, int pos)
function ll (line 101) | ll solve(ll x)
function init (line 116) | void init()
function main (line 138) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1610-路径计数/f-51Nod-1610-路径计数/main.cpp
function ll (line 35) | ll dfs(int u, int d)
function ll (line 53) | ll cal(int u)
function main (line 72) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1612-合法表达式/f-51Nod-1612-合法表达式/main.cpp
function main (line 21) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1613-翻硬币/f-51Nod-1613-翻硬币/main.cpp
function main (line 15) | int main ()
FILE: 按 OJ 分类/51Nod/f-51Nod-1615-跳跃的杰克/f-51Nod-1615-跳跃的杰克/main.cpp
function main (line 13) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1616-最小集合/f-51Nod-1616-最小集合/main.cpp
function scan_d (line 21) | inline void scan_d(T &ret)
function kgcd (line 32) | int kgcd(int a, int b)
function main (line 60) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1617-奇偶数组/f-51Nod-1617-奇偶数组/main.cpp
function cal (line 17) | long long cal(long long a, long long b, long long c)
function _cal (line 43) | long long _cal(long long ll, long long rr, long long c, int d)
function main (line 79) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1618-树或非树/f-51Nod-1618-树或非树/main.cpp
type node (line 22) | struct node
method put (line 30) | void put(int i, int j)
method lazy (line 40) | void lazy(int i)
method rt (line 47) | void rt(int i, int j)
method splay (line 78) | void splay(int i, int j)
method update (line 98) | void update(int i)
method access (line 104) | void access(int i)
method cover (line 115) | void cover(int i)
function link (line 124) | void link(int a, int b)
function find (line 131) | int find(int i)
function dfs1 (line 136) | void dfs1(int i, int h)
function dfs2 (line 161) | void dfs2(int i, int h)
function scan_d (line 174) | inline void scan_d(T &ret)
function main (line 185) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1619-完全二叉树的方差/f-51Nod-1619-完全二叉树的方差/main.cpp
function ll (line 27) | ll Ml(ll x, ll y)
function ll (line 46) | ll Mr(ll x, ll y)
function ll (line 61) | ll check(ll x)
function cmp (line 88) | bool cmp(ll x, ll y)
function scan_d (line 94) | inline void scan_d(T &ret)
function main (line 105) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1621-花钱买车牌/f-51Nod-1621-花钱买车牌/main.cpp
function get_AB (line 22) | void get_AB(int tmp[], int tot)
function cmp_AB (line 49) | bool cmp_AB()
function main (line 66) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1622-集合对/f-51Nod-1622-集合对/main.cpp
function ll (line 19) | ll QPow(ll x, ll n)
function main (line 37) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1623-完美消除/f-51Nod-1623-完美消除/main.cpp
function change (line 26) | int change(int s, int x)
function ll (line 39) | ll dfs(int len, int cnt, int tag, int flag)
function ll (line 72) | ll solve(ll x)
function main (line 86) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1625-夹克爷发红包/f-51Nod-1625-夹克爷发红包/main.cpp
function count (line 143) | int count(int num)
function cmp (line 157) | bool cmp(const LL &a, const LL &b)
function main (line 162) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1629-B君的圆锥/f-51Nod-1629-B君的圆锥/main.cpp
function main (line 17) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1630-B君的竞技场/f-51Nod-1630-B君的竞技场/main.cpp
function get_dp (line 20) | void get_dp(int x, int y, double z[], double w[])
function get_res (line 32) | double get_res(int x, int y)
function main (line 43) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1631-小鲨鱼在51Nod小学/f-51Nod-1631-小鲨鱼在51Nod小学/main.cpp
type Node (line 120) | struct Node
function cmp (line 131) | bool cmp(const Node &p1, const Node &p2)
function main (line 136) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1635-第K个幸运排列/f-51Nod-1635-第K个幸运排列/main.cpp
function ll (line 27) | ll dp(ll x)
function reverse_cantor (line 86) | void reverse_cantor(ll n, ll k, ll base)
function check (line 110) | bool check(ll n)
function init (line 128) | void init()
function main (line 141) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1636-教育改革/f-51Nod-1636-教育改革/main.cpp
type lesson (line 23) | struct lesson
function _max (line 36) | void _max(ll &a, ll b)
function main (line 41) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1637-幸运数字转换/f-51Nod-1637-幸运数字转换/main.cpp
function main (line 19) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1638-字符串重组/f-51Nod-1638-字符串重组/main.cpp
function kmp (line 21) | void kmp()
function exkmp (line 54) | void exkmp()
function main (line 95) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1639-绑鞋带/f-51Nod-1639-绑鞋带/main.cpp
function main (line 14) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1640-天气晴朗的魔法/f-51Nod-1640-天气晴朗的魔法/main.cpp
type edge (line 22) | struct edge
function addEdge (line 31) | void addEdge(int u, int v, int w)
function cmp_0 (line 40) | bool cmp_0(edge a, edge b)
function cmp_1 (line 46) | bool cmp_1(edge a, edge b)
function find (line 51) | int find(int x)
function Kruskal_0 (line 64) | int Kruskal_0(int n) // 传入点数，返回最小生成树的最大边权值，如果不连通返回-1
function ll (line 102) | ll Kruskal_1(int n) // 传入点数，返回最大生成树的权值，如果不连通返回-1
function main (line 140) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1645-中位数变换/f-51Nod-1645-中位数变换/main.cpp
function scan_d (line 22) | inline void scan_d(T &ret)
function main (line 33) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1649-齐头并进/f-51Nod-1649-齐头并进/main.cpp
function init (line 25) | void init()
function dijkstra (line 31) | void dijkstra(int map[][MAXN])
function main (line 63) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1650-穿越无人区/f-51Nod-1650-穿越无人区/main.cpp
function main (line 16) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1661-黑板上的游戏/f-51Nod-1661-黑板上的游戏/main.cpp
function ll (line 26) | ll SG(ll x)
function main (line 36) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1670-打怪兽/f-51Nod-1670-打怪兽/main.cpp
function init (line 24) | void init()
function ll (line 34) | ll exp_mod(ll a, ll b)
function input (line 49) | void input()
function solve (line 61) | void solve()
function main (line 84) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1671-货物运输/f-51Nod-1671-货物运输/main.cpp
function check (line 21) | bool check(int m)
function main (line 48) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1673-树有几多愁/f-51Nod-1673-树有几多愁/main.cpp
function scan_d (line 33) | inline void scan_d(T &ret)
function dfs (line 44) | void dfs(int u, int pre)
function main (line 66) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1674-区间的价值 V2/f-51Nod-1674-区间的价值 V2/main.cpp
function cinDiy (line 17) | int cinDiy()
function solve (line 38) | void solve(int l, int r)
function main (line 79) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1675-序列变换/f-51Nod-1675-序列变换/main.cpp
function Mobius (line 80) | void Mobius()
function ll (line 117) | ll cal(int t)
function main (line 135) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1677-treecnt/f-51Nod-1677-treecnt/main.cpp
function ll (line 23) | ll QPow(ll x, ll n)
function init (line 41) | void init()
function ll (line 55) | ll C(ll a, ll b)
function ll (line 75) | ll dfs(ll s)
function main (line 99) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1678-lyk与gcd/f-51Nod-1678-lyk与gcd/main.cpp
function init (line 25) | void init()
function update (line 36) | void update(int pos, int b)
function getFactors (line 61) | void getFactors(int x)
function solve (line 82) | long long solve(int x)
function scan_d (line 115) | inline void scan_d(T &ret)
function out (line 127) | inline void out(T x)
function main (line 136) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1679-连通率/f-51Nod-1679-连通率/main.cpp
type Edge (line 22) | struct Edge
function addEdge (line 27) | void addEdge(int u, int v)
function dfs (line 35) | void dfs(int rt, int pre)
function init (line 55) | void init()
function scan_d (line 65) | inline void scan_d(T &ret)
function main (line 76) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1681-公共祖先/f-51Nod-1681-公共祖先/main.cpp
type node (line 27) | struct node
type Edge (line 32) | struct Edge
function init (line 37) | void init()
function addedge (line 44) | void addedge(int u, int v)
function dfs (line 51) | void dfs(int u, int pre, int flag)
function scan_d (line 84) | inline void scan_d(T &ret)
function update (line 95) | void update(int &rt, int l, int r, int num)
function query (line 116) | int query(int x, int y, int L, int R, int l, int r)
function main (line 135) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1684-子集价值/f-51Nod-1684-子集价值/main.cpp
function get_mod (line 23) | void get_mod(int &x)
function get (line 31) | int get(int x, int y)
function main (line 52) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1685-第K大区间2/f-51Nod-1685-第K大区间2/main.cpp
function add (line 28) | void add(int rt, int x, int y = 1)
function get_sum (line 41) | int get_sum(int rt, int x)
function ll (line 55) | ll check(int x)
function scan_d (line 75) | inline void scan_d(T &ret)
function main (line 86) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1686-第K大区间/f-51Nod-1686-第K大区间/main.cpp
function ll (line 21) | ll mul(ll x)
function ll (line 30) | ll cala(int x)
function main (line 55) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1689-逛街/f-51Nod-1689-逛街/main.cpp
function scan_d (line 27) | inline void scan_d(T &ret)
function main (line 38) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1693-水群/f-51Nod-1693-水群/main.cpp
function spfa_bfs (line 23) | int spfa_bfs(int n)
function main (line 65) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1705-七星剑/f-51Nod-1705-七星剑/main.cpp
function scan_d (line 21) | inline void scan_d(T &ret)
function main (line 38) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1711-平均数/f-51Nod-1711-平均数/main.cpp
type note (line 20) | struct note
function cmp (line 26) | bool cmp(note a, note b)
function lowbit (line 31) | inline int lowbit(int t)
function add (line 42) | void add(int x)
function ll (line 50) | ll find(int x)
function check (line 61) | bool check(double m)
function scan_d (line 98) | inline void scan_d(T &ret)
function main (line 109) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1712-区间求和/f-51Nod-1712-区间求和/main.cpp
function in (line 23) | void in(uint &w)
function uint (line 38) | uint mult(uint a, uint b)
function main (line 53) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1714-B君的游戏/f-51Nod-1714-B君的游戏/main.cpp
function getSG (line 24) | void getSG(int n)
FILE: 按 OJ 分类/51Nod/f-51Nod-1716-多项式?/f-51Nod-1716-多项式?/main.cpp
function main (line 15) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1718-"多项式"/f-51Nod-1718-"多项式"/main.cpp
function main (line 15) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1719-数值计算/f-51Nod-1719-数值计算/main.cpp
function main (line 20) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1732-51Nod婚姻介绍所/f-51Nod-1732-51Nod婚姻介绍所/main.cpp
function cmp (line 36) | bool cmp(int *r, int a, int b, int l)
function da (line 41) | void da(int str[], int sa[], int rank[], int height[], int n, int m)
function initRMQ (line 133) | void initRMQ(int n)
function askRMQ (line 162) | int askRMQ(int a, int b)
function lcp (line 172) | int lcp(int a, int b)
function scan_d (line 187) | inline void scan_d(int &ret)
function prin_d (line 199) | inline void prin_d(int x)
function main (line 209) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1737-配对/f-51Nod-1737-配对/main.cpp
function init (line 37) | void init()
function dfs (line 49) | void dfs(int r)
function dfs_ (line 72) | void dfs_(int x)
function main (line 86) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1742-开心的小Q/f-51Nod-1742-开心的小Q/main.cpp
function getPrime (line 25) | void getPrime()
function init (line 47) | void init()
function ll (line 66) | ll F(int n)
function ll (line 81) | ll S(int n)
function main (line 95) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1747-近似多项式/f-51Nod-1747-近似多项式/main.cpp
function mod_inv (line 25) | inline int mod_inv(int x)
function init (line 30) | void init()
function main (line 46) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1753-相似子串/f-51Nod-1753-相似子串/main.cpp
type FastIO (line 23) | struct FastIO
method IO_fread (line 28) | void IO_fread()
method s_read (line 34) | void s_read(char *s)
method c_read (line 76) | char c_read() // 读取一个字符 不读 空格换行
method read (line 103) | int read()
type HASH (line 152) | struct HASH
method HASH (line 156) | HASH(int k1 = 0, int k2 = 0, int k3 = 0) : k1(k1), k2(k2), k3(k3) {}
method HASH (line 162) | HASH operator + (const HASH &a) const
method HASH (line 166) | HASH operator - (const HASH &a) const
type node (line 172) | struct node
method node (line 176) | node(int k = 0, int d = -1) : k(k), d(d) {}
function Pow (line 193) | int Pow(int a, int b, int mod)
function init (line 212) | void init()
type bf (line 233) | struct bf
method clear (line 237) | void clear()
method bf (line 245) | bf()
method find (line 250) | int find(int a)
method merg (line 260) | void merg(int a, int b)
function camp (line 272) | int camp(int b)
function main (line 324) | int main ()
FILE: 按 OJ 分类/51Nod/f-51Nod-1765-谷歌的恐龙/f-51Nod-1765-谷歌的恐龙/main.cpp
function main (line 13) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1766-树上的最远点对/f-51Nod-1766-树上的最远点对/main.cpp
function scan_d (line 22) | inline void scan_d(T &ret)
function print_d (line 34) | void print_d(T a)
type ST (line 50) | struct ST
method init (line 54) | void init(int n)
method query (line 70) | int query(int a, int b) // 查询[a,b]之间最小值的下标
type Edge (line 81) | struct Edge
function init (line 96) | void init()
function add_edge (line 102) | void add_edge(int u, int v, int w)
function dfs (line 110) | void dfs(int u, int pre, int dep)
function LCA_init (line 129) | void LCA_init(int root, int node_num) // 查询LCA前的初始化
function query_lca (line 136) | int query_lca(int u, int v) // 查询u,v的lca编号
function get_dis (line 141) | int get_dis(int a, int b)
type node (line 147) | struct node
function cal (line 154) | void cal(int root, int a, int b)
function push_up (line 165) | void push_up(int root)
function build (line 175) | void build(int root, int l, int r)
function get_ft (line 195) | void get_ft(int a, int b, int &len)
function query (line 205) | void query(int root, int l, int r, int &ta, int &tb)
function main (line 241) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1773-A国的贸易/f-51Nod-1773-A国的贸易/main.cpp
function scan_d (line 20) | inline void scan_d(T &ret)
function print_d (line 32) | inline void print_d(T x)
function FWT (line 44) | inline void FWT(int c[], int tf_utf) // tf_utf 1:tf; 0:utf
function QPow (line 77) | int QPow(int a, int k)
function main (line 95) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1779-逆序对统计/f-51Nod-1779-逆序对统计/main.cpp
function main (line 23) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1780-完美序列/f-51Nod-1780-完美序列/main.cpp
function scan_d (line 29) | inline bool scan_d(T &ret)
function init (line 51) | void init()
function main (line 63) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1781-Pinball/f-51Nod-1781-Pinball/main.cpp
type node (line 25) | struct node
function build (line 31) | void build(int rt, int l, int r)
function update (line 46) | void update(int rt, int a, ll c)
function ll (line 65) | ll query(int rt, int a, int b)
function scan_d (line 91) | inline void scan_d(T &ret)
function main (line 102) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1785-数据流中的算法/f-51Nod-1785-数据流中的算法/main.cpp
function read (line 18) | inline void read(int &ret)
function variance (line 30) | double variance()
function midNum (line 44) | double midNum()
function main (line 73) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1791-合法括号子段/f-51Nod-1791-合法括号子段/main.cpp
function solve (line 28) | void solve(int l, int r)
function main (line 71) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1799-二分答案/f-51Nod-1799-二分答案/main.cpp
function ll (line 19) | ll fac(ll x)
function main (line 33) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1800-汉诺塔/f-51Nod-1800-汉诺塔/main.cpp
function cal (line 23) | int cal()
function main (line 34) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1803-森林直径/f-51Nod-1803-森林直径/main.cpp
function scan_d (line 35) | inline void scan_d(T &ret)
function dfs (line 46) | void dfs(int x)
function init (line 100) | void init()
function main (line 112) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1804-小C的多边形/f-51Nod-1804-小C的多边形/main.cpp
function intToChar (line 22) | void intToChar(int &pos, int a)
function main (line 36) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1805-小树/f-51Nod-1805-小树/main.cpp
function ll (line 20) | ll QPow(ll x, ll n)
function init (line 38) | void init()
function ll (line 52) | ll C(ll a, ll b)
function main (line 65) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1806-wangyurzee的树/f-51Nod-1806-wangyurzee的树/main.cpp
function ll (line 29) | ll QPow(ll x, ll n)
function init (line 47) | void init()
function scan_d (line 62) | inline void scan_d(T &ret)
function main (line 73) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1810-连续区间/f-51Nod-1810-连续区间/main.cpp
function scan_d (line 27) | inline void scan_d(T &ret)
function solve (line 38) | void solve(int l, int r)
function main (line 124) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1811-联通分量计数/f-51Nod-1811-联通分量计数/main.cpp
function scan_d (line 30) | inline void scan_d(T &ret)
function ll (line 41) | ll get_n(int n)
function add (line 46) | void add(int x, int y)
function ins (line 53) | void ins(int &x, int l, int r, int a)
function merge (line 122) | int merge(int x, int y, int l, int r)
function dfs (line 188) | void dfs(int rt, int pre)
function main (line 204) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1815-调查任务/f-51Nod-1815-调查任务/main.cpp
type node (line 21) | struct node
function add_edge (line 33) | void add_edge(int u, int v)
function add_edge_23 (line 39) | void add_edge_23(int u, int v)
function tarjan (line 57) | void tarjan(int x)
function BFS (line 111) | void BFS()
function scan_d (line 182) | inline void scan_d(T &ret)
function main (line 193) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1821-最优集合/f-51Nod-1821-最优集合/main.cpp
function scan_d (line 24) | inline bool scan_d(T &ret)
function exc (line 36) | int exc(int n, int m)
function main (line 56) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1829-函数/f-51Nod-1829-函数/main.cpp
function ll (line 22) | ll QPow(ll x, ll n)
function init (line 40) | void init()
function ll (line 54) | ll C(ll a, ll b)
function main (line 67) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1831-小C的游戏/f-51Nod-1831-小C的游戏/main.cpp
function init (line 85) | void init()
function main (line 131) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1832-先序遍历与后序遍历/f-51Nod-1832-先序遍历与后序遍历/main.cpp
type BigInt (line 16) | struct BigInt
method BigInt (line 24) | BigInt()
method BigInt (line 30) | BigInt(int v)
method BigInt (line 42) | BigInt operator * (const BigInt &b) const
method output (line 68) | void output()
function get_id (line 86) | int get_id(int l, int r, int num)
function calc (line 99) | int calc(int num)
function dfs (line 113) | void dfs(int a_l, int a_r, int b_l, int b_r)
function main (line 140) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1833-环/f-51Nod-1833-环/main.cpp
function scan_d (line 24) | inline void scan_d(T &ret)
function cal (line 35) | int cal(int x)
function main (line 50) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1835-完全图/f-51Nod-1835-完全图/main.cpp
function ll (line 22) | ll QPow(ll x, ll n)
function init (line 40) | void init()
function main (line 52) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1836-战忽局的手段/f-51Nod-1836-战忽局的手段/main.cpp
function __float128 (line 13) | __float128 QPow(__float128 x, long long p)
function main (line 33) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1837-砝码称重/f-51Nod-1837-砝码称重/main.cpp
function main (line 16) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1849-Clarke and package/f-51Nod-1849-Clarke and package/main.cpp
function scan_d (line 20) | inline void scan_d(T &ret)
type package (line 31) | struct package
function cmp (line 36) | bool cmp(const package &x, const package &y)
function main (line 45) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1859-Clarke and number/f-51Nod-1859-Clarke and number/main.cpp
function ll (line 19) | ll sqrt(ll x)
function main (line 42) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1868-彩色树/f-51Nod-1868-彩色树/main.cpp
function scan_d (line 20) | inline void scan_d(T &ret)
function addEdge (line 36) | void addEdge(int x, int y)
function cal (line 43) | int cal(int x)
function dfs (line 55) | void dfs(int rt, int pre)
function main (line 77) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1874-字符串排序/f-51Nod-1874-字符串排序/main.cpp
function MergeSort (line 28) | void MergeSort(char *a, int l, int r)
function main (line 70) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1946-特殊表示法/f-51Nod-1946-特殊表示法/main.cpp
function main (line 21) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1952-栈/f-51Nod-1952-栈/main.cpp
function scan_d (line 26) | inline void scan_d(T &ret)
function main (line 37) | signed main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1962-区间计数/f-51Nod-1962-区间计数/main.cpp
function scan_d (line 19) | inline void scan_d(T &ret)
function ins (line 38) | int ins(pii x, pii y)
function main (line 51) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1967-路径定向/f-51Nod-1967-路径定向/main.cpp
function dfs (line 30) | void dfs(int x)
function main (line 52) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1969-Fire!/f-51Nod-1969-Fire!/main.cpp
function scan_d (line 23) | inline void scan_d(T &ret)
function init (line 34) | void init()
function main (line 45) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-1981-如何愉快地与STL玩耍/f-51Nod-1981-如何愉快地与STL玩耍/main.cpp
type node (line 26) | struct node
function scan_d (line 32) | inline void scan_d(T &ret)
function print_d (line 44) | void print_d(T x)
function _insert (line 53) | void _insert(int l, int r)
function query (line 74) | void query(int l, int r)
function check (line 95) | inline size_t check(int m)
function solve (line 101) | void solve()
function init (line 135) | void init()
function main (line 145) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-1995-三子棋/f-51Nod-1995-三子棋/main.cpp
function main (line 13) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-2000-四边形分割平面/f-51Nod-2000-四边形分割平面/main.cpp
function main (line 15) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-2006-飞行员配对（二分图最大匹配）/f-51Nod-2006-飞行员配对（二分图最大匹配）/main.cpp
type edge (line 23) | struct edge
function add_edge (line 40) | void add_edge(int x, int y, int flow)
function init (line 56) | void init()
function SPFA (line 73) | bool SPFA()
function Dinic (line 115) | void Dinic()
function solve (line 178) | void solve()
function main (line 186) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-2020-排序相减/f-51Nod-2020-排序相减/main.cpp
function cmp (line 19) | bool cmp(const int &a, const int &b)
function main (line 24) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-TalkingData数据科学精英夏令营挑战赛-A-初中的算术/f-51Nod-TalkingData数据科学精英夏令营挑战赛-A-初中的算术/main.cpp
type BigNum (line 17) | struct BigNum
function find_dot (line 25) | int find_dot(char a, char str[])
function print (line 38) | void print(struct BigNum s)
function trans (line 55) | void trans(BigNum &a, char str[])
function BigNum (line 82) | BigNum mul(BigNum a, BigNum b)
function main (line 122) | int main()
FILE: 按 OJ 分类/51Nod/f-51Nod-TalkingData数据科学精英夏令营挑战赛-B-丢手绢/f-51Nod-TalkingData数据科学精英夏令营挑战赛-B-丢手绢/main.cpp
function main (line 18) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-TalkingData数据科学精英夏令营挑战赛-C-好数/f-51Nod-TalkingData数据科学精英夏令营挑战赛-C-好数/main.cpp
function main (line 18) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-TalkingData数据科学精英夏令营挑战赛-D-数据流中的算法-众数/f-51Nod-TalkingData数据科学精英夏令营挑战赛-D-数据流中的算法-众数/main.cpp
type SetCmp (line 23) | struct SetCmp
function scan_d (line 34) | inline void scan_d(int &ret)
function Out (line 45) | inline void Out(int a)
function main (line 54) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-TalkingData数据科学精英夏令营挑战赛-E-路径定向/f-51Nod-TalkingData数据科学精英夏令营挑战赛-E-路径定向/main.cpp
function main (line 11) | int main(int argc, const char * argv[]) {
FILE: 按 OJ 分类/51Nod/f-51Nod-算法马拉松13-A-取余最长路/f-51Nod-算法马拉松13-A-取余最长路/main.c
function init (line 18) | void init(int n)
function map (line 39) | void map(int n)
function main (line 53) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-算法马拉松13-B-数有几多愁/f-51Nod-算法马拉松13-B-数有几多愁/main.c
function main (line 11) | int main(int argc, const char * argv[]) {
FILE: 按 OJ 分类/51Nod/f-51Nod-算法马拉松13-C-比大小/f-51Nod-算法马拉松13-C-比大小/main.c
type ll (line 11) | typedef long long ll;
function ll (line 16) | ll setA(ll N)
function main (line 26) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-算法马拉松15（脱欧专场）-A-B君的游戏/f-51Nod-算法马拉松15（脱欧专场）-A-B君的游戏/main.cpp
function scanDIY (line 16) | inline void scanDIY(T &ret)
function main (line 26) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-算法马拉松16-A-B君的连通/f-51Nod-算法马拉松16-A-B君的连通/main.cpp
function ll (line 48) | ll power(ll a, ll b)
function init (line 64) | void init()
function main (line 75) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-51Nod-算法马拉松16-B-卷积和/51Nod-算法马拉松16-B-卷积和/main.cpp
function init (line 20) | void init()
function main (line 34) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-BSG白山极客挑战赛-A-数数字/f-BSG白山极客挑战赛-A-数数字/main.c
function main (line 12) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-BSG白山极客挑战赛-B-AVL树的种类/f-BSG白山极客挑战赛-B-AVL树的种类/main.c
function main (line 11) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-算法马拉松17（告别奥运）-B-分解/f-算法马拉松17（告别奥运）-B-分解/main.cpp
type Matrix (line 18) | struct Matrix
method Matrix (line 22) | Matrix()
function Matrix (line 33) | Matrix isit(Matrix x, long long c)
method Matrix (line 22) | Matrix()
function Matrix (line 46) | Matrix Matlab(Matrix x, Matrix s)
method Matrix (line 22) | Matrix()
function FastMatrix (line 65) | long long FastMatrix(Matrix tmp, long long n)
function main (line 98) | int main()
FILE: 按 OJ 分类/51Nod/f-算法马拉松18-A-染色问题/f-算法马拉松18-A-染色问题/main.cpp
function main (line 13) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/51Nod/f-算法马拉松18-B-非010串/f-算法马拉松18-B-非010串/main.cpp
function mat_ab (line 24) | void mat_ab(E *a, E *b) // a*b-->a
function mat_aa (line 41) | void mat_aa(E *a, E *b) // a^2-->b
function init (line 56) | void init()
function ll (line 68) | ll solve(ll n)
function main (line 95) | int main ()
FILE: 按 OJ 分类/BNUOJ/f-BNUOJ-4052-BT马/f-BNUOJ-4052-BT马/main.c
type step (line 13) | struct step
type step (line 20) | struct step
function main (line 22) | int main()
FILE: 按 OJ 分类/BZOJ/f-BZOJ-2301-[HAOI2011]Problem b/f-BZOJ-2301-[HAOI2011]Problem b/main.cpp
function Moblus (line 28) | void Moblus()
function solve (line 64) | long long solve(int n, int m)
function main (line 79) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CCF/f-CCF模拟-1-出现次数最多的数/f-CCF模拟-1-出现次数最多的数/main.cpp
function main (line 19) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CCF/f-CCF模拟-2-ISBN号码/f-CCF模拟-2-ISBN号码/main.cpp
function main (line 20) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CCF/f-CCF模拟-3-最大的矩阵/f-CCF模拟-3-最大的矩阵/main.cpp
function main (line 18) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CCF/f-CCF模拟-4-有趣的数/f-CCF模拟-4-有趣的数/main.cpp
function main (line 21) | int main()
FILE: 按 OJ 分类/CCF/f-CCF模拟-5-I’m stuck!/f-CCF模拟-5-I’m stuck!/main.cpp
function dfsS (line 24) | void dfsS(int x, int y)
function dfsT (line 75) | void dfsT(int x, int y, int preX, int preY)
function main (line 122) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CDOJ/f-CDOJ-2016-A-柱爷与咸鱼神功/f-CDOJ-2016-A-柱爷与咸鱼神功/main.c
function main (line 14) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CDOJ/f-CDOJ-2016-B-柱爷与最大区间和/f-CDOJ-2016-B-柱爷与最大区间和/main.c
function main (line 64) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CDOJ/f-CDOJ-2016-C-柱爷的下凡/f-CDOJ-2016-C-柱爷的下凡/main.c
function MIN (line 13) | int MIN(int a, int b, int c)
function main (line 19) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CDOJ/f-CDOJ-2016-F-柱爷与三叉戟不得不说的故事/f-CDOJ-2016-F-柱爷与三叉戟不得不说的故事/main.c
function dfs (line 18) | int dfs(int i, int ans)
function main (line 54) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-BNU Training 2016.07.29 Div. 2-B-Levko and Table/f-BNU Training 2016.07.29 Div. 2-B-Levko and Table/main.cpp
function main (line 11) | int main()
FILE: 按 OJ 分类/CF/f-CF-Avito Code Challenge 2018-A-Antipalindrome/f-CF-Avito Code Challenge 2018-A-Antipalindrome/main.cpp
function main (line 16) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Avito Code Challenge 2018-B-Businessmen Problems/f-CF-Avito Code Challenge 2018-B-Businessmen Problems/main.cpp
function main (line 17) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Avito Code Challenge 2018-C-Useful Decomposition/f-CF-Avito Code Challenge 2018-C-Useful Decomposition/main.cpp
function dfs (line 21) | void dfs(int u, int pre)
function main (line 38) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Avito Code Challenge 2018-D-Bookshelves/f-CF-Avito Code Challenge 2018-D-Bookshelves/main.cpp
function main (line 23) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Avito Code Challenge 2018-E-Addition on Segments/f-CF-Avito Code Challenge 2018-E-Addition on Segments/main.cpp
type Q (line 16) | struct Q
function main (line 28) | int main()
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #210 (Div. 1)-A-Levko and Array Recovery/f-CF-Codeforces Round #210 (Div. 1)-A-Levko and Array Recovery/main.cpp
function main (line 22) | int main()
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #365 (Div. 2)-A-Mishka and Game/f-CF-Codeforces Round #365 (Div. 2)-A-Mishka and Game/main.cpp
function main (line 14) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #365 (Div. 2)-B-Mishka and trip/f-CF-Codeforces Round #365 (Div. 2)-B-Mishka and trip/main.cpp
function main (line 13) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #366 (Div. 2)-A-Hulk/f-CF-Codeforces Round #366 (Div. 2)-A-Hulk/main.cpp
function main (line 16) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #377 (Div. 2)-A-Buy a Shovel/f-CF-Codeforces Round #377 (Div. 2)-A-Buy a Shovel/main.cpp
function main (line 15) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #377 (Div. 2)-B-Cormen — The Best Friend Of a Man/f-CF-Codeforces Round #377 (Div. 2)-B-Cormen — The Best Friend Of a Man/main.cpp
type value (line 17) | struct value
function main (line 24) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #392 (Div. 2)-A-Holiday Of Equality/f-CF-Codeforces Round #392 (Div. 2)-A-Holiday Of Equality/main.cpp
function main (line 17) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #392 (Div. 2)-B-Blown Garland/f-CF-Codeforces Round #392 (Div. 2)-B-Blown Garland/main.cpp
function init (line 19) | void init()
function main (line 24) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-A-Vicious Keyboard/f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-A-Vicious Keyboard/main.cpp
function main (line 14) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-B-Valued Keys/f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-B-Valued Keys/main.cpp
function main (line 14) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-C-Voltage Keepsake/f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-C-Voltage Keepsake/main.cpp
type device (line 17) | struct device
function main (line 30) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-D-Volatile Kite/f-CF-Codeforces Round #409 (rated, Div. 2, based on VK Cup 2017 Round 2)-D-Volatile Kite/main.cpp
function main (line 11) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #410 (Div. 2)-A-Mike and palindrome/f-CF-Codeforces Round #410 (Div. 2)-A-Mike and palindrome/main.cpp
function main (line 14) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #410 (Div. 2)-B-Mike and strings/f-CF-Codeforces Round #410 (Div. 2)-B-Mike and strings/main.cpp
function main (line 112) | int main()
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #410 (Div. 2)-C-Mike and gcd problem/f-CF-Codeforces Round #410 (Div. 2)-C-Mike and gcd problem/main.cpp
function gcd (line 19) | int gcd(int x, int y)
function main (line 29) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #410 (Div. 2)-D-Mike and distribution/f-CF-Codeforces Round #410 (Div. 2)-D-Mike and distribution/main.cpp
function main (line 154) | int main()
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #418 (Div. 2)-C-An impassioned circulation of affection/f-CF-Codeforces Round #418 (Div. 2)-C-An impassioned circulation of affection/main.cpp
function main (line 22) | int main()
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #420 (Div. 2)-A-Okabe and Future Gadget Laboratory/f-CF-Codeforces Round #420 (Div. 2)-A-Okabe and Future Gadget Laboratory/main.cpp
function main (line 20) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #420 (Div. 2)-B-Okabe and Banana Trees/f-CF-Codeforces Round #420 (Div. 2)-B-Okabe and Banana Trees/main.cpp
function main (line 17) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #420 (Div. 2)-C-Okabe and Boxes/f-CF-Codeforces Round #420 (Div. 2)-C-Okabe and Boxes/main.cpp
function main (line 20) | int main()
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #420 (Div. 2)-D-Okabe and City/f-CF-Codeforces Round #420 (Div. 2)-D-Okabe and City/main.cpp
type edge (line 27) | struct edge
method edge (line 30) | edge() {}
method edge (line 31) | edge(int to_, int cost_) : to(to_), cost(cost_) {}
function add_edge (line 34) | void add_edge(vector<edge> G[], int r, int c)
function dijkstra (line 59) | void dijkstra(int s)
function main (line 91) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #420 (Div. 2)-E-Okabe and El Psy Kongroo/f-CF-Codeforces Round #420 (Div. 2)-E-Okabe and El Psy Kongroo/main.cpp
type Matrix (line 21) | struct Matrix
function mat (line 28) | mat matrix_mul(mat a, mat b, int len)
function init (line 49) | void init()
function Matrix (line 73) | Matrix matrix_quick_power(mat a, ll k, int len)
function main (line 93) | int main()
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #483 (Div. 2)-A-Game/f-CF-Codeforces Round #483 (Div. 2)-A-Game/main.cpp
function main (line 19) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #483 (Div. 2)-B-Minesweeper/f-CF-Codeforces Round #483 (Div. 2)-B-Minesweeper/main.cpp
type cell (line 21) | struct cell
function judge (line 30) | bool judge(int x, int y)
function change (line 40) | void change(int x, int y)
function main (line 55) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #483 (Div. 2)-C-Finite or not?/f-CF-Codeforces Round #483 (Div. 2)-C-Finite or not?/main.cpp
function ll (line 20) | ll gcd(ll x, ll y)
function main (line 32) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #483 (Div. 2)-D-XOR-pyramid/f-CF-Codeforces Round #483 (Div. 2)-D-XOR-pyramid/main.cpp
function fun_dp (line 20) | int fun_dp(int l, int r)
function fun_dp_1 (line 33) | int fun_dp_1(int l, int r)
function main (line 46) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #485 (Div. 2)/A-Infinity Gauntlet/main.cpp
function init (line 25) | static void init()
function main (line 35) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #485 (Div. 2)/B-High School: Become Human/main.cpp
function main (line 22) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #485 (Div. 2)/C-Three displays/main.cpp
function main (line 27) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #485 (Div. 2)/D-Fair/main.cpp
function solve (line 32) | void solve()
function main (line 62) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #485 (Div. 2)/E-Petr and Permutations/main.cpp
function main (line 50) | int main()
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #487 (Div. 2)/A-A Blend of Springtime/main.cpp
function main (line 21) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #487 (Div. 2)/B-A Tide of Riverscape/main.cpp
function main (line 20) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #487 (Div. 2)/C-A Mist of Florescence/main.cpp
function output (line 22) | void output()
function main (line 35) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Codeforces Round #487 (Div. 2)/D-A Shade of Moonlight/main.cpp
function main (line 23) | int main()
FILE: 按 OJ 分类/CF/f-CF-Educational Codeforces Round 15-A-Maximum Increase/f-CF-Educational Codeforces Round 15-A-Maximum Increase/main.cpp
function main (line 17) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Educational Codeforces Round 15-B-Powers of Two/CF-Educational Codeforces Round 15-B-Powers of Two/main.cpp
function cinDiy (line 20) | inline void cinDiy(int &ret)
function main (line 31) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-A-Chess Placing/f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-A-Chess Placing/main.cpp
function main (line 20) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-B-Switches and Lamps/f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-B-Switches and Lamps/main.cpp
function main (line 20) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-C-Liebig's Barrels/f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-C-Liebig's Barrels/main.cpp
function main (line 20) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-D-Sand Fortress/f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-D-Sand Fortress/main.cpp
function cal (line 15) | double cal(double x)
function check (line 22) | bool check(ll m)
function main (line 45) | int main()
FILE: 按 OJ 分类/CF/f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-E-Pencils and Boxes/f-CF-Educational Codeforces Round 44 (Rated for Div. 2)-E-Pencils and Boxes/main.cpp
function main (line 68) | int main()
FILE: 按 OJ 分类/CF/f-CF-Tinkoff Challenge-Elimination Round-A-Oleg and shares/f-CF-Tinkoff Challenge-Elimination Round-A-Oleg and shares/main.cpp
function main (line 18) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Tinkoff Challenge-Elimination Round-B-Igor and his way to work/f-CF-Tinkoff Challenge-Elimination Round-B-Igor and his way to work/main.cpp
function main (line 23) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/CF/f-CF-Tinkoff Challenge-Elimination Round-C-Mice problem/f-CF-Tinkoff Challenge-Elimination Round-C-Mice problem/main.cpp
function getT (line 21) | void getT(double mx, double mvx, double mtx, double mtx_)
function main (line 62) | int main()
FILE: 按 OJ 分类/CF/f-CF-Tinkoff Challenge-Elimination Round-D-Presents in Bankopolis/f-CF-Tinkoff Challenge-Elimination Round-D-Presents in Bankopolis/main.cpp
function init (line 27) | void init()
function getDP (line 33) | int getDP(int st, int ed, int k, int dir)
function main (line 72) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/EOJ/f-EOJ-大学生程序设计邀请赛（华东师范大学）-A-拼音魔法/f-EOJ-大学生程序设计邀请赛（华东师范大学）-A-拼音魔法/main.cpp
function main (line 19) | int main()
FILE: 按 OJ 分类/EOJ/f-EOJ-大学生程序设计邀请赛（华东师范大学）-B-分词/f-EOJ-大学生程序设计邀请赛（华东师范大学）-B-分词/main.cpp
function format (line 25) | void format(int x)
function main (line 44) | int main()
FILE: 按 OJ 分类/EOJ/f-EOJ-大学生程序设计邀请赛（华东师范大学）-C-袋鼠妈妈找孩子/f-EOJ-大学生程序设计邀请赛（华东师范大学）-C-袋鼠妈妈找孩子/main.cpp
function dfs (line 21) | bool dfs(int x, int y, int lim)
function main (line 60) | int main()
FILE: 按 OJ 分类/EOJ/f-EOJ-大学生程序设计邀请赛（华东师范大学）-D-实验室传染病/f-EOJ-大学生程序设计邀请赛（华东师范大学）-D-实验室传染病/main.cpp
function update (line 24) | void update()
function update_ (line 63) | void update_()
function main (line 102) | int main()
FILE: 按 OJ 分类/EOJ/f-EOJ-大学生程序设计邀请赛（华东师范大学）-E-黑心啤酒厂/f-EOJ-大学生程序设计邀请赛（华东师范大学）-E-黑心啤酒厂/main.cpp
function gcd (line 13) | long long gcd(long long x, long long y)
function main (line 23) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/EOJ/f-EOJ-大学生程序设计邀请赛（华东师范大学）-F-丽娃河的狼人传说/f-EOJ-大学生程序设计邀请赛（华东师范大学）-F-丽娃河的狼人传说/main.cpp
type section (line 19) | struct section
function cmp (line 26) | bool cmp(section a, section b)
function main (line 35) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/EOJ/f-EOJ-大学生程序设计邀请赛（华东师范大学）-G-铁路修复计划/f-EOJ-大学生程序设计邀请赛（华东师范大学）-G-铁路修复计划/main.cpp
type Edge (line 29) | struct Edge
function addEdge (line 38) | void addEdge(int u, int v, double w)
function addEdge0 (line 46) | void addEdge0(int u, int v, double w)
function addEdge1 (line 54) | void addEdge1(int u, int v, double w)
function cmp (line 62) | bool cmp(Edge a, Edge b)
function find (line 68) | int find(int x)
function Kruskal (line 82) | double Kruskal(int n) // 传入点数，返回最小生成树的权值，如果不连通则返回-1
function charge (line 126) | bool charge(double mid)
function main (line 145) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/EOJ/f-EOJ-大学生程序设计邀请赛（华东师范大学）-H-法国传统舞蹈/f-EOJ-大学生程序设计邀请赛（华东师范大学）-H-法国传统舞蹈/main.cpp
function main (line 22) | int main()
FILE: 按 OJ 分类/EOJ/f-EOJ-大学生程序设计邀请赛（华东师范大学）-I-七巧板/f-EOJ-大学生程序设计邀请赛（华东师范大学）-I-七巧板/main.cpp
type Lpoint (line 21) | struct Lpoint
function area_of_polygon (line 30) | double area_of_polygon(int vcount, Lpoint plg[])
function main (line 49) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/GDUT/f-GDUT-1164-找出出现次数超过一半的数/f-GDUT-1164-找出出现次数超过一半的数/main.cpp
function main (line 22) | int main()
FILE: 按 OJ 分类/HDU/ICPC Asia Regional Qingdao Online-1001-Apple/ICPC Asia Regional Qingdao Online-1001-Apple/main.cpp
function main (line 242) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/ICPC Asia Regional Qingdao Online-1003-The Dominator of Strings/ICPC Asia Regional Qingdao Online-1003-The Dominator of Strings/main.cpp
function main (line 23) | int main()
FILE: 按 OJ 分类/HDU/ICPC Asia Regional Qingdao Online-1008-Chinese Zodiac/ICPC Asia Regional Qingdao Online-1008-Chinese Zodiac/main.cpp
function main (line 19) | int main()
FILE: 按 OJ 分类/HDU/ICPC Asia Regional Qingdao Online-1009-Smallest Minimum Cut/ICPC Asia Regional Qingdao Online-1009-Smallest Minimum Cut/main.cpp
function ll (line 26) | ll min(ll a, ll b)
type EDGE (line 38) | struct EDGE
function edgeini (line 44) | void edgeini()
function edgemake (line 50) | void edgemake(int from, int to, ll c)
function make (line 58) | void make(int from, int to, ll c)
function makelevel (line 64) | bool makelevel(int s, int t)
function ll (line 91) | ll dfs(int now, int t, ll maxf)
function ll (line 120) | ll maxflow(int s, int t)
function main (line 130) | int main()
FILE: 按 OJ 分类/HDU/ICPC Asia Regional Qingdao Online-1010-Brute Force Sorting/ICPC Asia Regional Qingdao Online-1010-Brute Force Sorting/main.cpp
function main (line 28) | int main(void)
FILE: 按 OJ 分类/HDU/ICPC Asia Regional Qingdao Online-1011-A Cubic number and A Cubic Number/ICPC Asia Regional Qingdao Online-1011-A Cubic number and A Cubic Number/main.cpp
function main (line 22) | int main()
FILE: 按 OJ 分类/HDU/ICPC Asia Regional Shenyang Online-1001-string string string/ICPC Asia Regional Shenyang Online-1001-string string string/main.cpp
class SAM (line 19) | class SAM
method clear (line 33) | void clear(char *_s)
method extend (line 50) | void extend(char ch)
method build (line 88) | void build()
method calc (line 102) | void calc(int k)
function main (line 143) | int main()
FILE: 按 OJ 分类/HDU/ICPC Asia Regional Shenyang Online-1002-cable cable cable/ICPC Asia Regional Shenyang Online-1002-cable cable cable/main.cpp
function main (line 15) | int main()
FILE: 按 OJ 分类/HDU/ICPC Asia Regional Shenyang Online-1004-array array array/ICPC Asia Regional Shenyang Online-1004-array array array/main.cpp
function main (line 22) | int main()
FILE: 按 OJ 分类/HDU/ICPC Asia Regional Shenyang Online-1005-number number number/ICPC Asia Regional Shenyang Online-1005-number number number/main.cpp
function mull (line 23) | void mull(ll a[2][2], ll b[2][2])
function mul_pow (line 39) | void mul_pow(ll n)
function main (line 54) | int main()
FILE: 按 OJ 分类/HDU/ICPC Asia Regional Shenyang Online-1008-transaction transaction transaction/ICPC Asia Regional Shenyang Online-1008-transaction transaction transaction/main.cpp
type Node (line 24) | struct Node
function AddEdge (line 29) | void AddEdge(int u, int v, int w)
function spfa (line 37) | void spfa(int s)
function init (line 67) | void init()
function main (line 73) | int main()
FILE: 按 OJ 分类/HDU/ICPC Asia Regional Shenyang Online-1012-card card card/ICPC Asia Regional Shenyang Online-1012-card card card/main.cpp
function main (line 19) | int main()
FILE: 按 OJ 分类/HDU/f-2016"百度之星"-资格赛-1001-A/f-2016"百度之星"-资格赛-1001-A/main.c
function inv (line 24) | int inv(int a, int b) //b = MOD - 2
function main (line 39) | int main()
FILE: 按 OJ 分类/HDU/f-2017"百度之星"程序设计大赛-资格赛-1002-度度熊的王国战略/f-2017"百度之星"程序设计大赛-资格赛-1002-度度熊的王国战略/main.cpp
function find (line 23) | int find(int x)
function main (line 32) | int main(void)
FILE: 按 OJ 分类/HDU/f-2017"百度之星"程序设计大赛-资格赛-1003-度度熊与邪恶大魔王/f-2017"百度之星"程序设计大赛-资格赛-1003-度度熊与邪恶大魔王/main.cpp
function main (line 29) | int main()
FILE: 按 OJ 分类/HDU/f-2017"百度之星"程序设计大赛-资格赛-1004-度度熊的午饭时光/f-2017"百度之星"程序设计大赛-资格赛-1004-度度熊的午饭时光/main.cpp
type meal (line 22) | struct meal
function main (line 32) | int main()
FILE: 按 OJ 分类/HDU/f-HDOJ-2066-一个人的旅行/f-HDOJ-2066-一个人的旅行/main.c
type Status (line 109) | typedef void Status;
type QElemType (line 110) | typedef int QElemType;
type node (line 112) | struct node
type SqQueue (line 128) | typedef struct
function Status (line 136) | Status InitQueue(SqQueue *Q)
function QueueLength (line 144) | int QueueLength(SqQueue Q)
function Status (line 150) | Status EnQueue(SqQueue *Q, QElemType e)
function Status (line 163) | Status DeQueue(SqQueue *Q)
function init (line 173) | void init()
function add (line 182) | void add(int a, int b, int time)
function spfa (line 191) | void spfa(int neiCity)
function main (line 225) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-1003-Max Sum/f-HDU-1003-Max Sum/main.cpp
function main (line 17) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-1004-Let the Balloon Rise/f-HDU-1004-Let the Balloon Rise/main.cpp
function main (line 18) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1005-Number Sequence/f-HDU-1005-Number Sequence/main.cpp
function main (line 18) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1007-Quoit Design/f-HDU-1007-Quoit Design/main.cpp
type Point (line 19) | struct Point
function main (line 34) | int main()
function closest (line 59) | double closest(Point a[],Point b[],Point c[],int p,int q)
function dis (line 122) | double dis(Point p, Point q)
function merge (line 128) | int merge(Point p[], Point q[], int s, int m, int t)
function cmp_x (line 154) | int cmp_x(const void *p, const void *q)
function cmp_y (line 171) | int cmp_y(const void *p, const void *q)
function min (line 188) | inline double min(double p, double q)
FILE: 按 OJ 分类/HDU/f-HDU-1008-Elevator/f-HDU-1008-Elevator/main.cpp
function main (line 13) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1009-FatMouse' Trade/f-HDU-1009-FatMouse' Trade/main.cpp
type room (line 16) | struct room
function cmp (line 23) | bool cmp(room a, room b)
function main (line 28) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1010-Tempter of the Bone/f-HDU-1010-Tempter of the Bone/main.cpp
function init (line 27) | void init()
function dfs (line 60) | void dfs(int x, int y, int steps)
function main (line 98) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1011-Starship Troopers/f-HDU-1011-Starship Troopers/main.cpp
function max (line 27) | inline int max(int a, int b)
function dfs (line 32) | void dfs(int p)
function main (line 58) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-1021-Fibonacci Again/f-HDU-1021-Fibonacci Again/main.cpp
function main (line 13) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1050-Moving Tables/f-HDU-1050-Moving Tables/main.cpp
function main (line 11) | int main(int argc, const char * argv[]) {
FILE: 按 OJ 分类/HDU/f-HDU-1102-Constructing Roads/f-HDU-1102-Constructing Roads/main.cpp
function updata (line 29) | void updata(int x, int y, int v)
function Prim (line 36) | int Prim(int cost[][MAXN], int n) // 0 ~ n - 1
function main (line 74) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1142-A Walk Through the Forest/f-HDU-1142-A Walk Through the Forest/main.cpp
function Dijkstra (line 26) | void Dijkstra(int cost[][MAXN], int lowcost[], int n, int beg)
function dfs (line 67) | int dfs(int s, int n)
function main (line 91) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1162-Eddy's picture/f-HDU-1162-Eddy's picture/main.cpp
type land (line 17) | struct land
type land (line 34) | struct land
function updata (line 37) | void updata(int x, int y, double v)
function Prim (line 44) | double Prim(double cost[][MAXN], int n) // 0 ~ n - 1
function main (line 82) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1166-敌兵布阵/f-HDU-1166-敌兵布阵/main.cpp
type node (line 21) | struct node
method node (line 28) | node()
function Tree (line 34) | Tree *CreateTree(int a, int b)
function update (line 57) | void update(Tree *r, int a, int b)
function find (line 76) | void find(Tree* r, int a, int b)
function main (line 99) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-1176-免费馅饼/f-HDU-1176-免费馅饼/main.cpp
function main (line 21) | int main ( )
FILE: 按 OJ 分类/HDU/f-HDU-1198-Farm Irrigation/f-HDU-1198-Farm Irrigation/main.cpp
function find (line 31) | int find(int x)
function join (line 49) | void join(int x, int y)
function main (line 102) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1213-How Many Tables/f-HDU-1213-How Many Tables/main.cpp
function find (line 22) | int find(int x)
function join (line 40) | void join(int x, int y)
function main (line 51) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1217-Arbitrage/f-HDU-1217-Arbitrage/main.cpp
function Floyd (line 135) | void Floyd(typec edges[][MAXN], int n)
function main (line 158) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-1224-Free DIY Tour/f-HDU-1224-Free DIY Tour/main.cpp
type A (line 14) | struct A
function main (line 25) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-1232-畅通工程/f-HDU-1232-畅通工程/main.cpp
function find (line 23) | int find(int x)
function join (line 41) | void join(int x, int y)
function main (line 53) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1233-还是畅通工程/f-HDU-1233-还是畅通工程/main.cpp
function updata (line 29) | void updata(int x, int y, int v)
function Prim (line 36) | int Prim(int cost[][MAXN], int n) // 0 ~ n - 1
function main (line 74) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1245-Saving James Bond/f-HDU-1245-Saving James Bond/main.cpp
type cro (line 18) | struct cro
type cro (line 24) | struct cro
function dijkstra (line 39) | void dijkstra(int st, int n)
function getDis (line 86) | double getDis(struct cro a, struct cro b)
function getDis_ (line 92) | double getDis_(struct cro c)
function main (line 101) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1272-小希的迷宫/f-HDU-1272-小希的迷宫/main.cpp
function find (line 25) | int find(int x)
function join (line 43) | void join(int x, int y)
function main (line 69) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1286-找新朋友/f-HDU-1286-找新朋友/main.cpp
function phi_and_prime_table (line 28) | void phi_and_prime_table(int N)
function main (line 61) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1301-Jungle Roads/f-HDU-1301-Jungle Roads/main.cpp
function updata (line 29) | void updata(int x, int y, int v)
function Prim (line 36) | int Prim(int cost[][MAXN], int n) // 0 ~ n - 1
function main (line 74) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1317-XYZZY/f-HDU-1317-XYZZY/main.cpp
type edge (line 23) | struct edge
function floyd (line 30) | void floyd()
function bellman_ford (line 44) | bool bellman_ford(int s)
function main (line 75) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-1325-Is It A Tree?/f-HDU-1325-Is It A Tree?/main.cpp
function init (line 145) | void init()
function find_root (line 156) | int find_root(int a)
function union_set (line 165) | void union_set(int a, int b)
function main (line 176) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-1385-Minimum Transport Cost/f-HDU-1385-Minimum Transport Cost/main.cpp
function Floyd (line 26) | void Floyd(int n)
function main (line 59) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1394-Minimum Inversion Number/f-HDU-1394-Minimum Inversion Number/main.cpp
function pushUp (line 18) | void pushUp(int root)
function build (line 23) | void build(int root, int l, int r)
function update (line 36) | void update(int root, int val, int l, int r)
function query (line 57) | int query(int L, int R, int l, int r, int root)
function main (line 79) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1402-A*B Problem Plus/f-HDU-1402-A*B Problem Plus/main.cpp
type Complex (line 27) | struct Complex
method Complex (line 30) | Complex(double _x = 0.0, double _y = 0.0)
method Complex (line 35) | Complex operator - (const Complex &b) const
method Complex (line 39) | Complex operator + (const Complex &b) const
method Complex (line 43) | Complex operator * (const Complex &b) const
function change (line 52) | void change(Complex y[], int len)
function fft (line 80) | void fft(Complex y[], int len, int on)
function main (line 113) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1512-Monkey King/f-HDU-1512-Monkey King/main.cpp
type node (line 16) | struct node
function init (line 25) | void init(int p, int k)
function find (line 33) | int find(int x)
function merge (line 45) | int merge(int x, int y)
function del (line 79) | int del(int x)
function solve (line 89) | int solve(int x, int y)
function main (line 101) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1532-Drainage Ditches/f-HDU-1532-Drainage Ditches/main.cpp
type edge (line 26) | struct edge
function addedge (line 34) | void addedge(int x, int y, typec c)
function typec (line 49) | typec flow(int n, int s, int t)
function main (line 123) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-1535-Invitation Cards/f-HDU-1535-Invitation Cards/main.cpp
type Edge (line 19) | struct Edge
method Edge (line 23) | Edge(int _v = 0, int _cost = 0) : v(_v), cost(_cost) {}
function init (line 28) | void init()
function addEdge (line 36) | void addEdge(int u, int v, int w)
function SPFA (line 45) | bool SPFA(int start, int n)
function main (line 94) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1546-Idiomatic Phrases Game/f-HDU-1546-Idiomatic Phrases Game/main.cpp
function dijkstra (line 23) | void dijkstra(int n, int beg)
function store (line 63) | void store(int n)
function main (line 97) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1548-A strange lift/f-HDU-1548-A strange lift/main.cpp
function Dijkstra (line 26) | void Dijkstra(int cost[][MAXN], int lowcost[], int n, int beg)
function main (line 66) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1558-Segment set/f-HDU-1558-Segment set/main.cpp
type point (line 14) | struct point
type edge (line 19) | struct edge
type edge (line 27) | struct edge
function min (line 29) | double min(double a, double b)
function max (line 34) | double max(double a, double b)
function inter (line 39) | bool inter(point a, point b, point c, point d)
function find (line 53) | int find(int x)
function join (line 71) | void join(int x, int y)
function main (line 84) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1573-X问题/f-51Nod-1573-X问题/main.cpp
function ll (line 17) | ll extgcd(ll a, ll b, ll &x, ll &y)
function main (line 35) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1576-A÷B/f-HDU-1576-A÷B/main.cpp
function extgcd (line 15) | int extgcd(int a, int b, int &x, int &y)
function modeq (line 32) | int modeq(int a, int b, int n)
function main (line 43) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1595-find the longest of the shortest/f-HDU-1595-find the longest of the shortest/main.cpp
function Dijkstra (line 25) | void Dijkstra(int cost[][MAXN], int lowcost[], int n, int beg, int flag)
function main (line 71) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1596-find the safest road/f-HDU-1596-find the safest road/main.cpp
function Floyd (line 20) | void Floyd(int n)
function main (line 40) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1598-find the most comfortable road/f-HDU-1598-find the most comfortable road/main.cpp
type Edge (line 21) | struct Edge
function addEdge (line 30) | void addEdge(int u, int v, int w)
function cmp (line 38) | bool cmp(Edge a, Edge b)
function find (line 44) | int find(int x)
function join (line 56) | void join(int x, int y)
function init (line 67) | void init(int n)
function main (line 75) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-1599-find the mincost route/f-HDU-1599-find the mincost route/main.cpp
function solve (line 22) | int solve(int i, int j, int k)
function main (line 35) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-1688-Sightseeing/f-HDU-1688-Sightseeing/main.cpp
type Edge (line 21) | struct Edge
type node (line 26) | struct node
function init (line 48) | void init()
function Dijstra (line 58) | void Dijstra(int st, int ed)
function main (line 125) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-1690-Bus System/f-HDU-1690-Bus System/main.cpp
function ll (line 25) | ll getC(ll dis)
function floyd (line 46) | void floyd(int n)
function main (line 60) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1695-GCD/f-HDU-1695-GCD/main.cpp
function init (line 22) | void init()
function main (line 52) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-1698-Just a Hook/f-HDU-1698-Just a Hook/main.cpp
type node (line 15) | struct node
function build (line 25) | void build(int root, int left, int right)
function updata (line 45) | void updata(int root, int left, int right, int data)
function main (line 88) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-1754-I Hate It/f-HDU-1754-I Hate It/main.cpp
function build (line 27) | int build(int root, int left, int right)
function find (line 48) | int find(int root, int left, int right)
function update (line 67) | int update(int root, int pos, int val)
function main (line 88) | int main ()
FILE: 按 OJ 分类/HDU/f-HDU-1811-Rank of Tetris/f-HDU-1811-Rank of Tetris/main.cpp
type node (line 212) | struct node
function find (line 220) | int find(int u)
function join (line 229) | void join(int a, int b)
function addEdge (line 239) | void addEdge(int a, int b)
type rel (line 246) | struct rel
function main (line 253) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-1829-A Bug's Life/f-HDU-1829-A Bug's Life/main.cpp
function init (line 17) | void init(int n)
function find (line 27) | int find(int x)
function join (line 39) | void join(int x, int y)
function main (line 60) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-1839-Delay Constrained Maximum Capacity Path/f-HDU-1839-Delay Constrained Maximum Capacity Path/main.cpp
type Edge (line 21) | struct Edge
function init (line 35) | void init()
function addEdge (line 41) | void addEdge(int u, int v, int c, int d)
function Dijkstra (line 50) | int Dijkstra(int src)
function main (line 85) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-1846-Brave Game/f-HDU-1846-Brave Game/main.cpp
function bash (line 17) | int bash(int N, int K)
function main (line 26) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-1847-Good Luck in CET-4 Everybody!/f-HDU-1847-Good Luck in CET-4 Everybody!/main.cpp
function get_SG (line 22) | void get_SG(int n)
function main (line 45) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1850-Being a Good Boy in Spring Festival/f-HDU-1850-Being a Good Boy in Spring Festival/main.cpp
function main (line 20) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1856-More is better/f-HDU-1856-More is better/main.cpp
function find (line 25) | int find(int x)
function join (line 43) | void join(int x, int y)
function main (line 65) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1863-畅通工程/f-HDU-1863-畅通工程/main.cpp
function updata (line 29) | void updata(int x, int y, int v)
function Prim (line 36) | int Prim(int cost[][MAXN], int n) // 0 ~ n - 1
function main (line 74) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1869-六度分离/f-HDU-1869-六度分离/main.cpp
function Floyd (line 24) | void Floyd(int n)
function main (line 46) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1874-畅通工程续/f-HDU-1874-畅通工程续/main.cpp
function Dijkstra (line 26) | void Dijkstra(int cost[][MAXN], int lowcost[], int n, int beg)
function main (line 67) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-1875-畅通工程再续/f-HDU-1875-畅通工程再续/main.cpp
type land (line 17) | struct land
type land (line 34) | struct land
function updata (line 37) | void updata(int x, int y, double v)
function Prim (line 44) | double Prim(double cost[][MAXN], int n) // 0 ~ n - 1
function main (line 82) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-1879-继续畅通工程/f-HDU-1879-继续畅通工程/main.cpp
function updata (line 29) | void updata(int x, int y, int v)
function Prim (line 36) | int Prim(int cost[][MAXN], int n) // 0 ~ n - 1
function main (line 74) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-2000-ASCII码排序/f-HDU-2000-ASCII码排序/main.cpp
function main (line 5) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2007-平方和与立方和/f-HDU-2007-平方和与立方和/main.cpp
function main (line 13) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2010-水仙花数/f-HDU-2010-水仙花数/main.cpp
function main (line 13) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛1-1001-Add More Zero/f-HDU-2017 多校训练赛1-1001-Add More Zero/main.cpp
function main (line 16) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛1-1002-Balala Power!/f-HDU-2017 多校训练赛1-1002-Balala Power!/main.cpp
type node (line 140) | struct node
function cmp (line 148) | bool cmp(node &A, node &B)
function main (line 163) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛1-1003-Colorful Tree/f-HDU-2017 多校训练赛1-1003-Colorful Tree/main.cpp
type Edge (line 26) | struct Edge
function ll (line 31) | inline ll get_cnt(int x)
function dfs (line 36) | int dfs(int rt, int pre)
function scan_d (line 57) | inline void scan_d(T &ret)
function main (line 68) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛1-1006-Function/f-HDU-2017 多校训练赛1-1006-Function/main.cpp
type Node (line 19) | struct Node
function Tarjan (line 38) | void Tarjan(int u)
function init (line 72) | void init()
function solve (line 81) | int solve()
function AddEdge (line 102) | void AddEdge(int u, int v)
function main (line 110) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛1-1008-Hints of sd0061/f-HDU-2017 多校训练赛1-1008-Hints of sd0061/main.cpp
type xxx (line 21) | struct xxx
function rng61 (line 32) | inline unsigned rng61()
function main (line 45) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛1-1011-KazaQ's Socks/f-HDU-2017 多校训练赛1-1011-KazaQ's Socks/main.cpp
function main (line 17) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛10-1001-Admiral/f-HDU-2017 多校训练赛10-1001-Admiral/main.cpp
type node (line 26) | struct node
function ll (line 34) | ll _hash(node &t)
function bfs (line 51) | int bfs(node &s, node &t)
function main (line 116) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛10-1002-Array Challenge/f-HDU-2017 多校训练赛10-1002-Array Challenge/main.cpp
type matrix (line 22) | struct matrix
method matrix (line 26) | matrix()
function init (line 35) | void init()
function matrix (line 46) | matrix mul(matrix a, matrix b)
method matrix (line 26) | matrix()
function matrix (line 63) | matrix pow(matrix p, ll k)
method matrix (line 26) | matrix()
function main (line 80) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛10-1008-Monkeys/f-HDU-2017 多校训练赛10-1008-Monkeys/main.cpp
type FastIO (line 24) | struct FastIO
method FastIO (line 31) | FastIO() : wpos(0) {}
method xchar (line 33) | inline int xchar()
method xint (line 51) | inline int xint()
function main (line 81) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛10-1010-Schedule/f-HDU-2017 多校训练赛10-1010-Schedule/main.cpp
type node (line 22) | struct node
function cmp (line 27) | bool cmp(node a, node b)
function main (line 34) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛10-1011-Two Paths/f-HDU-2017 多校训练赛10-1011-Two Paths/main.cpp
type Edge (line 28) | struct Edge
method Edge (line 32) | Edge() {}
method Edge (line 33) | Edge(int _u, int _v, ll _c) : u(_u), v(_v), c(_c) {}
type qnode (line 36) | struct qnode
method qnode (line 41) | qnode() {}
method qnode (line 43) | qnode(int _v, ll _c) : v(_v), c(_c) {}
function addedge (line 51) | void addedge(int u, int v, ll c)
function dij (line 60) | void dij(int src)
function ll (line 94) | ll a_star(int src)
function main (line 127) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛2-1001-Is Derek lying?/f-HDU-2017 多校训练赛2-1001-Is Derek lying?/main.cpp
function main (line 19) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛2-1003-Maximum Sequence/f-HDU-2017 多校训练赛2-1003-Maximum Sequence/main.cpp
function scan_d (line 25) | inline void scan_d(T &ret)
function main (line 36) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛2-1006-Funny Function/f-HDU-2017 多校训练赛2-1006-Funny Function/main.cpp
function ll (line 17) | ll QPow(ll x, ll n)
function ll (line 32) | ll inv(ll x)
function main (line 41) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛2-1008-To my boyfriend/f-HDU-2017 多校训练赛2-1008-To my boyfriend/main.cpp
type node (line 18) | struct node
method node (line 21) | node() {}
method node (line 22) | node(int a, int b)
function get_cnt (line 36) | int get_cnt(int l, int r, int i, int j, int col)
function scan_d (line 65) | inline void scan_d(T &ret)
function main (line 76) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛2-1009-TrickGCD/f-HDU-2017 多校训练赛2-1009-TrickGCD/main.cpp
function mobius (line 22) | void mobius(int x)
function ll (line 37) | ll QPow(ll x, int y)
function scan_d (line 54) | inline void scan_d(T &ret)
function main (line 65) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛2-1011-Regular polygon/f-HDU-2017 多校训练赛2-1011-Regular polygon/main.cpp
type Node (line 16) | struct Node
type hashTable (line 21) | struct hashTable
method hashTable (line 26) | hashTable()
function insert (line 35) | void insert(int k)
function find (line 61) | bool find(int x, int y)
function main (line 87) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛3-1001-simple counting problem/f-HDU-2017 多校训练赛3-1001-simple counting problem/main.cpp
function main (line 11) | int main(int argc, const char * argv[]) {
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛3-1003-Kanade’s sum/f-HDU-2017 多校训练赛3-1003-Kanade’s sum/main.cpp
function scan_d (line 21) | inline void scan_d(T &ret)
function erase (line 39) | void erase(int x)
function solve (line 54) | void solve()
function main (line 88) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛3-1004-Kanade's trio/f-HDU-2017 多校训练赛3-1004-Kanade's trio/main.cpp
function scan_d (line 20) | inline void scan_d(T &ret)
function main (line 38) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛3-1005-RXD and dividing/f-HDU-2017 多校训练赛3-1005-RXD and dividing/main.cpp
type Edge (line 26) | struct Edge
method Edge (line 30) | Edge(int a = 0, int b = 0, int c = 0) : to(a), dis(b), net(c) {}
function add (line 33) | void add(int u, int v, int w)
function bfs (line 39) | void bfs(int src)
function solve (line 71) | void solve()
function main (line 81) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛3-1008-RXD and math/f-HDU-2017 多校训练赛3-1008-RXD and math/main.cpp
function ll (line 20) | ll QPow(ll x, ll n)
function main (line 38) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛3-1011-RXD's date/f-HDU-2017 多校训练赛3-1011-RXD's date/main.cpp
function main (line 17) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛4-1003-Counting Divisors/f-HDU-2017 多校训练赛4-1003-Counting Divisors/main.cpp
function init (line 24) | void init()
function solve (line 45) | void solve()
function main (line 91) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛4-1004-Dirt Ratio/f-HDU-2017 多校训练赛4-1004-Dirt Ratio/main.cpp
function pushdown (line 29) | inline void pushdown(int rt)
function build (line 41) | void build(int rt, int l, int r, double w)
function update (line 55) | void update(int rt, int l, int r, int ql, int qr)
function query (line 77) | void query(int rt, int l, int r, int p)
function scan_d (line 98) | inline void scan_d(T &ret)
function main (line 109) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛4-1007-Matching In Multiplication/f-HDU-2017 多校训练赛4-1007-Matching In Multiplication/main.cpp
function add (line 23) | inline void add(int x, int y, int z)
function go (line 38) | inline int go(int x)
function get (line 51) | inline int get(int x, int y)
function init (line 64) | void init()
function main (line 74) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛4-1009-Questionnaire/f-HDU-2017 多校训练赛4-1009-Questionnaire/main.cpp
function main (line 15) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛4-1011-Time To Get Up/f-HDU-2017 多校训练赛4-1011-Time To Get Up/main.cpp
function check (line 21) | int check()
function main (line 73) | int main(int argc, const char * argv[])
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛4-1012-Wavel Sequence/f-HDU-2017 多校训练赛4-1012-Wavel Sequence/main.cpp
function get_mod (line 19) | inline void get_mod(int &x, int y)
function main (line 28) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛5-1001-Rikka with Candies/f-HDU-2017 多校训练赛5-1001-Rikka with Candies/main.cpp
function solve (line 22) | void solve(int mk)
function scan_d (line 41) | inline void scan_d(T &ret)
function main (line 52) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训练赛5-1006-Rikka with Graph/f-HDU-2017 多校训练赛5-1006-Rikka with Graph/main.cpp
function main (line 17) | int main()
FILE: 按 OJ 分类/HDU/f-HDU-2017 多校训
Copy disabled (too large)
Download .json
Condensed preview — 1386 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (11,928K chars).
[
{
"path": ".gitignore",
"chars": 812,
"preview": "# C++\n\n# Prerequisites\n*.d\n\n# Compiled Object files\n*.slo\n*.lo\n*.o\n*.obj\n\n# Precompiled Headers\n*.gch\n*.pch\n\n# Compiled "
},
{
"path": "ACM 模板代码/f-0-1分数规划/f-0-1分数规划/main.cpp",
"chars": 649,
"preview": "//\n// main.cpp\n// f-0-1分数规划\n//\n// Created by ZYJ on 16/7/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inc"
},
{
"path": "ACM 模板代码/f-2-SAT/f-2-SAT/main.cpp",
"chars": 2324,
"preview": "//\n// main.cpp\n// f-2-SAT\n//\n// Created by ZYJ on 16/7/18.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-AC自动机/f-AC自动机/main.cpp",
"chars": 2824,
"preview": "//\n// main.cpp\n// f-AC自动机\n//\n// Created by ZYJ on 16/7/12.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-Baby-Step Giant-Step/f-Baby-Step Giant-Step/main.cpp",
"chars": 1310,
"preview": "//\n// main.cpp\n// f-Baby-Step Giant-Step\n//\n// Created by ZYJ on 16/7/9.\n// Copyright © 2016年 ZYJ. All rights reserv"
},
{
"path": "ACM 模板代码/f-DAG的深度优先搜索标记/f-DAG的深度优先搜索标记/main.cpp",
"chars": 1211,
"preview": "//\n// main.cpp\n// f-DAG的深度优先搜索标记\n//\n// Created by ZYJ on 16/6/13.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n"
},
{
"path": "ACM 模板代码/f-FFT/f-FFT/main.cpp",
"chars": 3464,
"preview": "//\n// main.cpp\n// f-FFT\n//\n// Created by ZYJ on 16/7/4.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#include "
},
{
"path": "ACM 模板代码/f-FWT/f-FWT/main.cpp",
"chars": 1184,
"preview": "//\n// main.cpp\n// f-FWT\n//\n// Created by ZYJ on 2017/7/6.\n// Copyright © 2017年 ZYJ. All rights reserved.\n//\n\n/*\n * "
},
{
"path": "ACM 模板代码/f-Floyd求最小环/f-Floyd求最小环/main.cpp",
"chars": 2562,
"preview": "//\n// main.cpp\n// f-Floyd求最小环\n//\n// Created by ZYJ on 16/7/18.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#i"
},
{
"path": "ACM 模板代码/f-GCD/f-GCD/main.cpp",
"chars": 1211,
"preview": "//\n// main.cpp\n// f-GCD\n//\n// Created by ZYJ on 16/6/28.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#include"
},
{
"path": "ACM 模板代码/f-Graham求凸包/f-Graham求凸包/main.cpp",
"chars": 1243,
"preview": "//\n// main.cpp\n// f-Graham求凸包\n//\n// Created by ZYJ on 16/7/23.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#i"
},
{
"path": "ACM 模板代码/f-KMP算法/f-KMP算法/main.cpp",
"chars": 2914,
"preview": "//\n// main.cpp\n// f-KMP算法\n//\n// Created by ZYJ on 16/6/16.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-Karp-Rabin算法/f-Karp-Rabin算法/main.cpp",
"chars": 3080,
"preview": "//\n// main.cpp\n// f-Karp-Rabin算法\n//\n// Created by ZYJ on 16/6/21.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n"
},
{
"path": "ACM 模板代码/f-LCA/f-LCA/main.cpp",
"chars": 8445,
"preview": "//\n// main.cpp\n// f-LCA\n//\n// Created by ZYJ on 16/7/14.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#include"
},
{
"path": "ACM 模板代码/f-Liuctic的计算几何库/f-Liuctic的计算几何库/main.cpp",
"chars": 7136,
"preview": "//\n// main.cpp\n// f-Liuctic的计算几何库\n//\n// Created by ZYJ on 16/7/23.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//"
},
{
"path": "ACM 模板代码/f-MST/f-MST/main.cpp",
"chars": 2754,
"preview": "//\n// main.cpp\n// f-MST\n//\n// Created by ZYJ on 16/7/17.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#include"
},
{
"path": "ACM 模板代码/f-Manacher算法/f-Manacher算法/main.cpp",
"chars": 1360,
"preview": "//\n// main.cpp\n// f-Manacher算法\n//\n// Created by ZYJ on 16/6/20.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#"
},
{
"path": "ACM 模板代码/f-Polya计数/f-Polya计数/main.cpp",
"chars": 835,
"preview": "//\n// main.cpp\n// f-Polya计数\n//\n// Created by ZYJ on 16/7/10.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inc"
},
{
"path": "ACM 模板代码/f-RMQ/f-RMQ/main.cpp",
"chars": 3338,
"preview": "//\n// main.cpp\n// f-RMQ\n//\n// Created by ZYJ on 16/7/20.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#include"
},
{
"path": "ACM 模板代码/f-SPFA/f-SPFA/main.cpp",
"chars": 4000,
"preview": "//\n// main.cpp\n// f-SPFA\n//\n// Created by ZYJ on 16/7/12.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#includ"
},
{
"path": "ACM 模板代码/f-Sunday Algorithm/f-Sunday Algorithm/main.cpp",
"chars": 2151,
"preview": "//\n// main.cpp\n// f-Sunday Algorithm\n//\n// Created by ZYJ on 16/7/12.\n// Copyright © 2016年 ZYJ. All rights reserved."
},
{
"path": "ACM 模板代码/f-Tarian强连通分量/f-Tarian强连通分量/main.cpp",
"chars": 1105,
"preview": "//\n// main.cpp\n// f-Tarian强连通分量\n//\n// Created by ZYJ on 16/7/17.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n"
},
{
"path": "ACM 模板代码/f-Treap/f-Treap/main.cpp",
"chars": 5450,
"preview": "//\n// main.cpp\n// f-Treap\n//\n// Created by ZYJ on 16/7/21.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-Trie树/f-Trie树/main.cpp",
"chars": 3142,
"preview": "//\n// main.cpp\n// f-Trie树\n//\n// Created by ZYJ on 16/7/21.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-Ugly Numbers/f-Ugly Numbers/main.cpp",
"chars": 1108,
"preview": "//\n// main.cpp\n// f-Ugly Numbers\n//\n// Created by ZYJ on 16/6/23.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n"
},
{
"path": "ACM 模板代码/f-simpson积分/f-simpson积分/main.cpp",
"chars": 1073,
"preview": "//\n// main.cpp\n// f-simpson积分\n//\n// Created by ZYJ on 16/7/10.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#i"
},
{
"path": "ACM 模板代码/f-strstr函数/f-strstr函数/main.cpp",
"chars": 485,
"preview": "//\n// main.cpp\n// f-strstr函数\n//\n// Created by ZYJ on 16/6/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#in"
},
{
"path": "ACM 模板代码/f-一般图匹配带花树/f-一般图匹配带花树/main.cpp",
"chars": 3713,
"preview": "//\n// main.cpp\n// f-一般图匹配带花树\n//\n// Created by ZYJ on 16/7/13.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#in"
},
{
"path": "ACM 模板代码/f-主席树/f-主席树/main.cpp",
"chars": 15137,
"preview": "//\n// main.cpp\n// f-主席树\n//\n// Created by ZYJ on 16/7/21.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#include"
},
{
"path": "ACM 模板代码/f-二分图匹配/f-二分图匹配/main.cpp",
"chars": 10748,
"preview": "//\n// main.cpp\n// f-二分图匹配\n//\n// Created by ZYJ on 16/7/18.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-二分图多重匹配/f-二分图多重匹配/main.cpp",
"chars": 1183,
"preview": "//\n// main.cpp\n// f-二分图多重匹配\n//\n// Created by ZYJ on 16/7/18.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inc"
},
{
"path": "ACM 模板代码/f-二分查找/f-二分查找/main.cpp",
"chars": 865,
"preview": "//\n// main.cpp\n// f-二分查找\n//\n// Created by ZYJ on 16/7/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#includ"
},
{
"path": "ACM 模板代码/f-二叉排序树/f-二叉排序树/main.cpp",
"chars": 2719,
"preview": "//\n// main.cpp\n// f-二叉排序树\n//\n// Created by ZYJ on 16/7/27.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-二叉查找树/f-二叉查找树/main.cpp",
"chars": 11050,
"preview": "//\n// main.cpp\n// f-二叉查找树\n//\n// Created by ZYJ on 16/6/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-伸展数/f-伸展数/main.cpp",
"chars": 7175,
"preview": "//\n// main.cpp\n// f-伸展数\n//\n// Created by ZYJ on 16/7/20.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#include"
},
{
"path": "ACM 模板代码/f-使序列有序的最少交换次数/f-使序列有序的最少交换次数/main.cpp",
"chars": 2015,
"preview": "//\n// main.cpp\n// f-使序列有序的最少交换次数\n//\n// Created by ZYJ on 2017/5/16.\n// Copyright © 2017年 ZYJ. All rights reserved.\n/"
},
{
"path": "ACM 模板代码/f-划分树/f-划分树/main.cpp",
"chars": 2289,
"preview": "//\n// main.cpp\n// f-划分树\n//\n// Created by ZYJ on 16/7/20.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#include"
},
{
"path": "ACM 模板代码/f-判断线段相交/f-判断线段相交/main.cpp",
"chars": 855,
"preview": "//\n// main.cpp\n// f-判断线段相交\n//\n// Created by ZYJ on 16/7/23.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#incl"
},
{
"path": "ACM 模板代码/f-动态树/f-动态树/main.cpp",
"chars": 5547,
"preview": "//\n// main.cpp\n// f-动态树\n//\n// Created by ZYJ on 16/7/20.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#include"
},
{
"path": "ACM 模板代码/f-区间最大频率/f-区间最大频率/main.cpp",
"chars": 3444,
"preview": "//\n// main.cpp\n// f-区间最大频率\n//\n// Created by ZYJ on 16/7/23.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#incl"
},
{
"path": "ACM 模板代码/f-半平面交/f-半平面交/main.cpp",
"chars": 6361,
"preview": "//\n// main.cpp\n// f-半平面交\n//\n// Created by ZYJ on 16/7/25.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#includ"
},
{
"path": "ACM 模板代码/f-双连通分支/f-双连通分支/main.cpp",
"chars": 6687,
"preview": "//\n// main.cpp\n// f-双连通分支\n//\n// Created by ZYJ on 16/7/17.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-取第k个元素/f-取第k个元素/main.cpp",
"chars": 795,
"preview": "//\n// main.cpp\n// f-取第k个元素\n//\n// Created by ZYJ on 16/7/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#incl"
},
{
"path": "ACM 模板代码/f-合数相关/f-合数相关/main.cpp",
"chars": 1336,
"preview": "//\n// main.cpp\n// f-合数相关\n//\n// Created by ZYJ on 16/7/1.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#include"
},
{
"path": "ACM 模板代码/f-后缀数组/f-后缀数组/main.cpp",
"chars": 7821,
"preview": "//\n// main.cpp\n// f-后缀数组\n//\n// Created by ZYJ on 16/7/12.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#includ"
},
{
"path": "ACM 模板代码/f-后缀自动机/f-后缀自动机/main.cpp",
"chars": 2380,
"preview": "//\n// main.cpp\n// f-后缀自动机\n//\n// Created by ZYJ on 16/7/12.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-周期性方程/f-周期性方程/main.cpp",
"chars": 1275,
"preview": "//\n// main.cpp\n// f-周期性方程\n//\n// Created by ZYJ on 16/7/10.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-培训作业/f-培训作业/main.cpp",
"chars": 8211,
"preview": "//#include<stdio.h>\n//#include<string.h>\n//#define BG 1000000007\n//#define MAXN 2501\n//\n//typedef long long __int64;\n//\n"
},
{
"path": "ACM 模板代码/f-堆/f-堆/main.cpp",
"chars": 884,
"preview": "//\n// main.cpp\n// f-堆\n//\n// Created by ZYJ on 2017/7/25.\n// Copyright © 2017年 ZYJ. All rights reserved.\n//\n\n#include"
},
{
"path": "ACM 模板代码/f-堆栈/f-堆栈/main.cpp",
"chars": 1147,
"preview": "//\n// main.cpp\n// f-堆栈\n//\n// Created by ZYJ on 16/7/23.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#include "
},
{
"path": "ACM 模板代码/f-多项式求根（牛顿法）/f-多项式求根（牛顿法）/main.cpp",
"chars": 1715,
"preview": "//\n// main.cpp\n// f-多项式求根（牛顿法）\n//\n// Created by ZYJ on 16/7/10.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#"
},
{
"path": "ACM 模板代码/f-大数取模的二进制方法/f-大数取模的二进制方法/main.cpp",
"chars": 1119,
"preview": "//\n// main.cpp\n// f-大数取模的二进制方法\n//\n// Created by ZYJ on 16/7/10.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#"
},
{
"path": "ACM 模板代码/f-大数平方根（字符串数组表示）/f-大数平方根（字符串数组表示）/main.cpp",
"chars": 1130,
"preview": "//\n// main.cpp\n// f-大数平方根（字符串数组表示）\n//\n// Created by ZYJ on 16/7/10.\n// Copyright © 2016年 ZYJ. All rights reserved.\n/"
},
{
"path": "ACM 模板代码/f-大数运算/f-大数运算/main.cpp",
"chars": 12357,
"preview": "//\n// main.cpp\n// f-大数运算\n//\n// Created by ZYJ on 16/7/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#includ"
},
{
"path": "ACM 模板代码/f-字符串 HASH/f-字符串 HASH/main.cpp",
"chars": 1071,
"preview": "//\n// main.cpp\n// f-字符串 HASH\n//\n// Created by ZYJ on 16/6/15.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#in"
},
{
"path": "ACM 模板代码/f-容斥/f-容斥/main.cpp",
"chars": 730,
"preview": "//\n// main.cpp\n// f-容斥\n//\n// Created by ZYJ on 2017/9/12.\n// Copyright © 2017年 ZYJ. All rights reserved.\n//\n\n#includ"
},
{
"path": "ACM 模板代码/f-左偏树/f-左偏树/main.cpp",
"chars": 3075,
"preview": "//\n// main.cpp\n// f-左偏树\n//\n// Created by ZYJ on 16/7/21.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#include"
},
{
"path": "ACM 模板代码/f-带权值的并查集/f-带权值的并查集/main.cpp",
"chars": 1116,
"preview": "//\n// main.cpp\n// f-带权值的并查集\n//\n// Created by ZYJ on 16/7/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inc"
},
{
"path": "ACM 模板代码/f-平衡二叉树/f-平衡二叉树/main.cpp",
"chars": 4021,
"preview": "//\n// main.cpp\n// f-平衡二叉树\n//\n// Created by ZYJ on 16/7/28.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-平面最近点对/f-平面最近点对/main.cpp",
"chars": 3547,
"preview": "//\n// main.cpp\n// f-平面最近点对\n//\n// Created by ZYJ on 16/7/23.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#incl"
},
{
"path": "ACM 模板代码/f-弦图判断/f-弦图判断/main.cpp",
"chars": 1724,
"preview": "//\n// main.cpp\n// f-弦图判断\n//\n// Created by ZYJ on 16/7/17.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#includ"
},
{
"path": "ACM 模板代码/f-弦图的PERFECT ELIMINATION点排列/f-弦图的PERFECT ELIMINATION点排列/main.cpp",
"chars": 985,
"preview": "//\n// main.cpp\n// f-弦图的PERFECT ELIMINATION点排列\n//\n// Created by ZYJ on 16/7/18.\n// Copyright © 2016年 ZYJ. All rights "
},
{
"path": "ACM 模板代码/f-快排/f-快排/main.cpp",
"chars": 517,
"preview": "//\n// main.cpp\n// f-快排\n//\n// Created by ZYJ on 16/7/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#include "
},
{
"path": "ACM 模板代码/f-所有数位相加/f-所有数位相加/main.cpp",
"chars": 737,
"preview": "//\n// main.cpp\n// f-所有数位相加\n//\n// Created by ZYJ on 16/7/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#incl"
},
{
"path": "ACM 模板代码/f-扩展KMP/f-扩展KMP/main.cpp",
"chars": 1546,
"preview": "//\n// main.cpp\n// f-扩展KMP\n//\n// Created by ZYJ on 16/6/19.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-拓扑排序/f-拓扑排序/main.cpp",
"chars": 1046,
"preview": "//\n// main.cpp\n// f-拓扑排序\n//\n// Created by ZYJ on 16/7/18.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#includ"
},
{
"path": "ACM 模板代码/f-排列组合/f-排列组合/main.cpp",
"chars": 7442,
"preview": "//\n// main.cpp\n// f-排列组合\n//\n// Created by ZYJ on 16/7/11.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#includ"
},
{
"path": "ACM 模板代码/f-散列表查找/f-散列表查找/main.cpp",
"chars": 1404,
"preview": "//\n// main.cpp\n// f-散列表查找\n//\n// Created by ZYJ on 16/9/2.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#includ"
},
{
"path": "ACM 模板代码/f-旋转卡壳/f-旋转卡壳/main.cpp",
"chars": 8474,
"preview": "//\n// main.cpp\n// f-旋转卡壳\n//\n// Created by ZYJ on 16/7/24.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#includ"
},
{
"path": "ACM 模板代码/f-无向图找桥/f-无向图找桥/main.cpp",
"chars": 1501,
"preview": "//\n// main.cpp\n// f-无向图找桥\n//\n// Created by ZYJ on 16/6/13.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-无向图最小割/f-无向图最小割/main.cpp",
"chars": 1812,
"preview": "//\n// main.cpp\n// f-无向图最小割\n//\n// Created by ZYJ on 16/7/18.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#incl"
},
{
"path": "ACM 模板代码/f-无向图连通分支/f-无向图连通分支/main.cpp",
"chars": 1591,
"preview": "//\n// main.cpp\n// f-无向图连通分支\n//\n// Created by ZYJ on 16/7/18.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inc"
},
{
"path": "ACM 模板代码/f-无向图连通度（割）/f-无向图连通度（割）/main.cpp",
"chars": 1392,
"preview": "//\n// main.cpp\n// f-无向图连通度（割）\n//\n// Created by ZYJ on 16/6/14.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#i"
},
{
"path": "ACM 模板代码/f-星期问题/f-星期问题/main.cpp",
"chars": 978,
"preview": "//\n// main.cpp\n// f-星期问题\n//\n// Created by ZYJ on 16/7/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#includ"
},
{
"path": "ACM 模板代码/f-曼哈顿最小生成树/f-曼哈顿最小生成树/main.cpp",
"chars": 3614,
"preview": "//\n// main.cpp\n// f-曼哈顿最小生成树\n//\n// Created by ZYJ on 16/6/9.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n//PO"
},
{
"path": "ACM 模板代码/f-最佳点割集/f-最佳点割集/main.cpp",
"chars": 2524,
"preview": "//\n// main.cpp\n// f-最佳点割集\n//\n// Created by ZYJ on 16/7/20.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-最佳边割集/f-最佳边割集/main.cpp",
"chars": 2488,
"preview": "//\n// main.cpp\n// f-最佳边割集\n//\n// Created by ZYJ on 16/7/20.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-最大1矩阵/f-最大1矩阵/main.cpp",
"chars": 1664,
"preview": "//\n// main.cpp\n// f-最大1矩阵\n//\n// Created by ZYJ on 16/7/10.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-最大团问题/f-最大团问题/main.cpp",
"chars": 1330,
"preview": "//\n// main.cpp\n// f-最大团问题\n//\n// Created by ZYJ on 16/7/12.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-最大流/f-最大流/main.cpp",
"chars": 16412,
"preview": "//\n// main.cpp\n// f-最大流\n//\n// Created by ZYJ on 16/7/19.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#include"
},
{
"path": "ACM 模板代码/f-最小树形图/f-最小树形图/main.cpp",
"chars": 3364,
"preview": "//\n// main.cpp\n// f-最小树形图\n//\n// Created by ZYJ on 16/7/13.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n//#inc"
},
{
"path": "ACM 模板代码/f-最小点割集/f-最小点割集/main.cpp",
"chars": 2602,
"preview": "//\n// main.cpp\n// f-最小点割集\n//\n// Created by ZYJ on 16/7/20.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-最小生成树/f-最小生成树/main.cpp",
"chars": 2508,
"preview": "//\n// main.cpp\n// f-最小生成树\n//\n// Created by ZYJ on 16/6/8.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#includ"
},
{
"path": "ACM 模板代码/f-最小费用流/f-最小费用流/main.cpp",
"chars": 7342,
"preview": "//\n// main.cpp\n// f-最小费用流\n//\n// Created by ZYJ on 16/7/19.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-最小路径覆盖/f-最小路径覆盖/main.cpp",
"chars": 257,
"preview": "//\n// main.cpp\n// f-最小路径覆盖\n//\n// Created by ZYJ on 16/7/20.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#incl"
},
{
"path": "ACM 模板代码/f-最小边割集/f-最小边割集/main.cpp",
"chars": 2447,
"preview": "//\n// main.cpp\n// f-最小边割集\n//\n// Created by ZYJ on 16/7/20.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-最少找钱币问题/f-最少找钱币问题/main.cpp",
"chars": 1177,
"preview": "//\n// main.cpp\n// f-最少找钱币问题\n//\n// Created by ZYJ on 16/7/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inc"
},
{
"path": "ACM 模板代码/f-最短公共祖先/f-最短公共祖先/main.cpp",
"chars": 2173,
"preview": "//\n// main.cpp\n// f-最短公共祖先\n//\n// Created by ZYJ on 16/7/12.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#incl"
},
{
"path": "ACM 模板代码/f-最短路/f-最短路/main.cpp",
"chars": 5562,
"preview": "//\n// main.cpp\n// f-最短路\n//\n// Created by ZYJ on 16/6/6.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#include "
},
{
"path": "ACM 模板代码/f-最长公共子序列/f-最长公共子序列/main.cpp",
"chars": 995,
"preview": "//\n// main.cpp\n// f-最长公共子序列\n//\n// Created by ZYJ on 16/7/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inc"
},
{
"path": "ACM 模板代码/f-最长公共递增子序列/f-最长公共递增子序列/main.cpp",
"chars": 1102,
"preview": "//\n// main.cpp\n// f-最长公共递增子序列\n//\n// Created by ZYJ on 16/7/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#i"
},
{
"path": "ACM 模板代码/f-最长有序子序列/f-最长有序子序列/main.cpp",
"chars": 1234,
"preview": "//\n// main.cpp\n// f-最长有序子序列\n//\n// Created by ZYJ on 16/7/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inc"
},
{
"path": "ACM 模板代码/f-有上下界的流/f-有上下界的流/main.cpp",
"chars": 2885,
"preview": "//\n// main.cpp\n// f-有上下界的流\n//\n// Created by ZYJ on 16/7/19.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#incl"
},
{
"path": "ACM 模板代码/f-有向图强连通分支/f-有向图强连通分支/main.cpp",
"chars": 1771,
"preview": "//\n// main.cpp\n// f-有向图强连通分支\n//\n// Created by ZYJ on 16/7/18.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#in"
},
{
"path": "ACM 模板代码/f-有向图最小树形图/f-有向图最小树形图/main.cpp",
"chars": 2576,
"preview": "//\n// main.cpp\n// f-有向图最小树形图\n//\n// Created by ZYJ on 16/7/17.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#in"
},
{
"path": "ACM 模板代码/f-有向图最小点基/f-有向图最小点基/main.cpp",
"chars": 954,
"preview": "//\n// main.cpp\n// f-有向图最小点基\n//\n// Created by ZYJ on 16/7/18.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inc"
},
{
"path": "ACM 模板代码/f-有向图的强连通分量/f-有向图的强连通分量/main.cpp",
"chars": 3672,
"preview": "//\n// main.cpp\n// f-有向图的强连通分量\n//\n// Created by ZYJ on 16/7/17.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#i"
},
{
"path": "ACM 模板代码/f-树状数组/f-树状数组/main.cpp",
"chars": 1267,
"preview": "//\n// main.cpp\n// f-树状数组\n//\n// Created by ZYJ on 16/7/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#includ"
},
{
"path": "ACM 模板代码/f-树链剖分/f-树链剖分/main.cpp",
"chars": 7974,
"preview": "//\n// main.cpp\n// f-树链剖分\n//\n// Created by ZYJ on 16/7/20.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#includ"
},
{
"path": "ACM 模板代码/f-棋盘分割/f-棋盘分割/main.cpp",
"chars": 3481,
"preview": "//\n// main.cpp\n// f-棋盘分割\n//\n// Created by ZYJ on 16/7/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#includ"
},
{
"path": "ACM 模板代码/f-模线性方程（组）/f-模线性方程（组）/main.cpp",
"chars": 1398,
"preview": "//\n// main.cpp\n// f-模线性方程（组）\n//\n// Created by ZYJ on 16/6/29.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#in"
},
{
"path": "ACM 模板代码/f-次小生成树/f-次小生成树/main.cpp",
"chars": 1610,
"preview": "//\n// main.cpp\n// f-次小生成树\n//\n// Created by ZYJ on 16/6/8.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#includ"
},
{
"path": "ACM 模板代码/f-欧拉函数PHI/f-欧拉函数PHI/main.cpp",
"chars": 2363,
"preview": "//\n// main.cpp\n// f-欧拉函数PHI\n//\n// Created by ZYJ on 16/6/28.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inc"
},
{
"path": "ACM 模板代码/f-欧拉路/f-欧拉路/main.cpp",
"chars": 10669,
"preview": "//\n// main.cpp\n// f-欧拉路\n//\n// Created by ZYJ on 16/6/11.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#include"
},
{
"path": "ACM 模板代码/f-母函数/f-母函数/main.cpp",
"chars": 870,
"preview": "//\n// main.cpp\n// f-母函数\n//\n// Created by ZYJ on 2017/9/12.\n// Copyright © 2017年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-求A^B的约数之和/f-求A^B的约数之和/main.cpp",
"chars": 2267,
"preview": "//\n// main.cpp\n// f-求A^B的约数之和\n//\n// Created by ZYJ on 16/7/7.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#in"
},
{
"path": "ACM 模板代码/f-求多边形重心/f-求多边形重心/main.cpp",
"chars": 765,
"preview": "//\n// main.cpp\n// f-求多边形重心\n//\n// Created by ZYJ on 16/7/23.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#incl"
},
{
"path": "ACM 模板代码/f-求逆元/f-求逆元/main.cpp",
"chars": 1548,
"preview": "//\n// main.cpp\n// f-求逆元\n//\n// Created by ZYJ on 16/7/2.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#include "
},
{
"path": "ACM 模板代码/f-汉诺塔/f-汉诺塔/main.cpp",
"chars": 1750,
"preview": "//\n// main.cpp\n// f-汉诺塔\n//\n// Created by ZYJ on 16/7/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#include"
},
{
"path": "ACM 模板代码/f-生成树计数/f-生成树计数/main.cpp",
"chars": 4317,
"preview": "//\n// main.cpp\n// f-生成树计数\n//\n// Created by ZYJ on 16/7/17.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-稳定婚姻问题/f-稳定婚姻问题/main.cpp",
"chars": 2413,
"preview": "//\n// main.cpp\n// f-稳定婚姻问题\n//\n// Created by ZYJ on 16/7/18.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#incl"
},
{
"path": "ACM 模板代码/f-第K短路/f-第K短路/main.cpp",
"chars": 4424,
"preview": "//\n// main.cpp\n// f-第K短路\n//\n// Created by ZYJ on 16/6/7.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n//WHU 16"
},
{
"path": "ACM 模板代码/f-素数相关/f-素数相关/main.cpp",
"chars": 4853,
"preview": "//\n// main.cpp\n// f-素数相关\n//\n// Created by ZYJ on 16/6/30.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#includ"
},
{
"path": "ACM 模板代码/f-约瑟夫环问题/f-约瑟夫环问题/main.cpp",
"chars": 846,
"preview": "//\n// main.cpp\n// f-约瑟夫环问题\n//\n// Created by ZYJ on 16/7/10.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#incl"
},
{
"path": "ACM 模板代码/f-线性方程组/f-线性方程组/main.cpp",
"chars": 3329,
"preview": "//\n// main.cpp\n// f-线性方程组\n//\n// Created by ZYJ on 16/6/29.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-线段树/f-线段树/main.cpp",
"chars": 7620,
"preview": "//\n// main.cpp\n// f-线段树\n//\n// Created by ZYJ on 16/7/21.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#include"
},
{
"path": "ACM 模板代码/f-线索二叉树/f-线索二叉树/main.cpp",
"chars": 2740,
"preview": "//\n// main.cpp\n// f-线索二叉树\n//\n// Created by ZYJ on 16/6/21.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-组合数C(n, r)/f-组合数C(n, r)/main.cpp",
"chars": 570,
"preview": "//\n// main.cpp\n// f-组合数C(n, r)\n//\n// Created by ZYJ on 16/7/10.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#"
},
{
"path": "ACM 模板代码/f-莫比乌斯反演/f-莫比乌斯反演/main.cpp",
"chars": 1032,
"preview": "//\n// main.cpp\n// f-莫比乌斯反演\n//\n// Created by ZYJ on 16/7/7.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-莫队算法/f-莫队算法/main.cpp",
"chars": 7784,
"preview": "//\n// main.cpp\n// f-莫队算法\n//\n// Created by ZYJ on 16/7/24.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#includ"
},
{
"path": "ACM 模板代码/f-赫夫曼编码/f-赫夫曼编码/huffman.cpp",
"chars": 4288,
"preview": "//\n// huffman.cpp\n// f-赫夫曼编码\n//\n// Created by ZYJ on 16/6/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#in"
},
{
"path": "ACM 模板代码/f-赫夫曼编码/f-赫夫曼编码/huffman.hpp",
"chars": 788,
"preview": "//\n// huffman.hpp\n// f-赫夫曼编码\n//\n// Created by ZYJ on 16/6/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#if"
},
{
"path": "ACM 模板代码/f-赫夫曼编码/f-赫夫曼编码/main.cpp",
"chars": 832,
"preview": "//\n// main.cpp\n// f-赫夫曼编码\n//\n// Created by ZYJ on 16/6/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inclu"
},
{
"path": "ACM 模板代码/f-赫夫曼编码/f-赫夫曼编码/queue.cpp",
"chars": 2113,
"preview": "//\n// queue.cpp\n// f-赫夫曼编码\n//\n// Created by ZYJ on 16/6/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#incl"
},
{
"path": "ACM 模板代码/f-赫夫曼编码/f-赫夫曼编码/queue.hpp",
"chars": 720,
"preview": "//\n// queue.hpp\n// f-赫夫曼编码\n//\n// Created by ZYJ on 16/6/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#ifnd"
},
{
"path": "ACM 模板代码/f-逆序数/f-逆序数/main.cpp",
"chars": 2308,
"preview": "//\n// main.cpp\n// f-逆序数\n//\n// Created by ZYJ on 16/7/22.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#include"
},
{
"path": "ACM 模板代码/f-邻接表/f-邻接表/main.cpp",
"chars": 2167,
"preview": "//\n// main.cpp\n// f-邻接表\n//\n// Created by ZYJ on 16/6/23.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#include"
},
{
"path": "ACM 模板代码/f-阶乘最后非零位/f-阶乘最后非零位/main.cpp",
"chars": 901,
"preview": "//\n// main.cpp\n// f-阶乘最后非零位\n//\n// Created by ZYJ on 16/7/11.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#inc"
},
{
"path": "ACM 模板代码/f-集合划分问题/f-集合划分问题/main.cpp",
"chars": 1318,
"preview": "//\n// main.cpp\n// f-集合划分问题\n//\n// Created by ZYJ on 16/7/10.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#incl"
},
{
"path": "ACM 模板代码/f-集合相关问题/f-集合相关问题/main.cpp",
"chars": 12424,
"preview": "//\n// main.cpp\n// f-集合相关问题\n//\n// Created by ZYJ on 16/6/26.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n//#in"
},
{
"path": "ACM 模板代码/f-高斯消元/f-高斯消元/main.cpp",
"chars": 1532,
"preview": "//\n// main.cpp\n// f-高斯消元\n//\n// Created by ZYJ on 16/7/4.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n#include"
},
{
"path": "ACM 模版-f_zyj 更新至 v 2.1/v 1.1/ACM模板-f_zyj v 1.1.pages/Metadata/BuildVersionHistory.plist",
"chars": 273,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/P"
},
{
"path": "ACM 模版-f_zyj 更新至 v 2.1/v 1.1/ACM模板-f_zyj v 1.1.pages/Metadata/DocumentIdentifier",
"chars": 36,
"preview": "D6185F94-161B-4AB9-8719-B2043C6A300C"
},
{
"path": "README.md",
"chars": 827,
"preview": "# ACM\n包含 ACM模板-f_zyj v 2.1，以及个人平时的训练代码……\n\n## ACM 模板-f_zyj 更新至 v 2.1\n此文件包含 《ACM 模板-f_zyj》 v 1.1 与 v 2.1 两个版本的 .ppt 格式和 .p"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1000-A+B/f-51Nod-1000-A+B/main.c",
"chars": 272,
"preview": "//\n// main.c\n// f-51Nod-1000-A+B\n//\n// Created by ZYJ on 16/4/15.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1001-数组中和等于K的数对/f-51Nod-1001-数组中和等于K的数对/main.cpp",
"chars": 2251,
"preview": "//\n// main.cpp\n// f-51Nod-1001-数组中和等于K的数对\n//\n// Created by ZYJ on 16/7/30.\n// Copyright © 2016年 ZYJ. All rights rese"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1002-数塔取数问题/f-51Nod-1002-数塔取数问题/main.cpp",
"chars": 869,
"preview": "//\n// main.cpp\n// f-51Nod-1002-数塔取数问题\n//\n// Created by ZYJ on 16/7/30.\n// Copyright © 2016年 ZYJ. All rights reserved"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1003-阶乘后面的0的数量/f-51Nod-1003-阶乘后面的0的数量/main.c",
"chars": 525,
"preview": "//\n// main.c\n// f-51Nod-1003-阶乘后面的0的数量\n//\n// Created by ZYJ on 16/5/17.\n// Copyright © 2016年 ZYJ. All rights reserve"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1004-n^n的末位数字/f-51Nod-1004-n^n的末位数字/main.c",
"chars": 373,
"preview": "//\n// main.c\n// f-51Nod-1004-n^n的末位数字\n//\n// Created by ZYJ on 16/5/17.\n// Copyright © 2016年 ZYJ. All rights reserved"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1005-大数加法/f-51Nod-1005-大数加法/main.c",
"chars": 4042,
"preview": "//\n// main.c\n// f-51Nod-1005-大数加法\n//\n// Created by ZYJ on 16/4/15.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1006-Tick and Tick/f-51Nod-1006-Tick and Tick/main.cpp",
"chars": 2503,
"preview": "//\n// main.cpp\n// f-51Nod-1006-Tick and Tick\n//\n// Created by ZYJ on 2016/10/14.\n// Copyright © 2016年 ZYJ. All right"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1006-最长公共子序列Lcs/f-51Nod-1006-最长公共子序列Lcs/main.c",
"chars": 986,
"preview": "//\n// main.c\n// f-51Nod-1006-最长公共子序列Lcs\n//\n// Created by ZYJ on 16/4/15.\n// Copyright © 2016年 ZYJ. All rights reserv"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1007-正整数分组/f-51Nod-1007-正整数分组/main.cpp",
"chars": 1009,
"preview": "//\n// main.cpp\n// f-51Nod-1007-正整数分组\n//\n// Created by ZYJ on 16/7/31.\n// Copyright © 2016年 ZYJ. All rights reserved."
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1008-N的阶乘 mod P/f-51Nod-1008-N的阶乘 mod P/main.c",
"chars": 387,
"preview": "//\n// main.c\n// f-51Nod-1008-N的阶乘 mod P\n//\n// Created by ZYJ on 16/4/15.\n// Copyright © 2016年 ZYJ. All rights reserv"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1009-数字1的数量/f-51Nod-1009-数字1的数量/main.cpp",
"chars": 2610,
"preview": "//\n// main.cpp\n// f-51Nod-1009-数字1的数量\n//\n// Created by ZYJ on 16/7/30.\n// Copyright © 2016年 ZYJ. All rights reserved"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1010-只包含2 3 5的数/f-51Nod-1010-只包含2 3 5的数/main.cpp",
"chars": 1638,
"preview": "//\n// main.cpp\n// f-51Nod-1010-只包含2 3 5的数\n//\n// Created by ZYJ on 16/7/31.\n// Copyright © 2016年 ZYJ. All rights rese"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1011-最大公约数GCD/f-51Nod-1011-最大公约数GCD/main.c",
"chars": 418,
"preview": "//\n// main.c\n// f-51Nod-1011-最大公约数GCD\n//\n// Created by ZYJ on 16/4/15.\n// Copyright © 2016年 ZYJ. All rights reserved"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1012-最小公倍数LCM/f-51Nod-1012-最小公倍数LCM/main.c",
"chars": 756,
"preview": "//\n// main.c\n// f-51Nod-1012-最小公倍数LCM\n//\n// Created by ZYJ on 16/4/15.\n// Copyright © 2016年 ZYJ. All rights reserved"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1013-3的幂的和/f-51Nod-1013-3的幂的和/main.c",
"chars": 2832,
"preview": "//\n// main.c\n// f-51Nod-1013-3的幂的和\n//\n// Created by ZYJ on 16/4/23.\n// Copyright © 2016年 ZYJ. All rights reserved.\n/"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1014-X^2 Mod P/f-51Nod-1014-X^2 Mod P/main.cpp",
"chars": 597,
"preview": "//\n// main.cpp\n// f-51Nod-1014-X^2 Mod P\n//\n// Created by ZYJ on 16/7/31.\n// Copyright © 2016年 ZYJ. All rights reser"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1015-水仙花数/f-51Nod-1015-水仙花数/main.cpp",
"chars": 506,
"preview": "//\n// main.cpp\n// f-51Nod-1015-水仙花数\n//\n// Created by ZYJ on 16/7/30.\n// Copyright © 2016年 ZYJ. All rights reserved.\n"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1016-水仙花数 V2/f-51Nod-1016-水仙花数 V2/main.c",
"chars": 2635,
"preview": "//\n// main.c\n// f-51Nod-1016-水仙花数 V2\n//\n// Created by ZYJ on 16/5/16.\n// Copyright © 2016年 ZYJ. All rights reserved."
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1018-排序/f-51Nod-1018-排序/main.c",
"chars": 1224,
"preview": "//\n// main.c\n// f-51Nod-1018-排序\n//\n// Created by ZYJ on 16/4/15.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n\n"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1019-逆序数/f-51Nod-1019-逆序数/main.c",
"chars": 3908,
"preview": "//\n// main.c\n// f-51Nod-1009-逆序数\n//\n// Created by ZYJ on 16/4/16.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//\n"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1020-逆序排序/f-51Nod-1020-逆序排序/main.cpp",
"chars": 881,
"preview": "//\n// main.cpp\n// f-51Nod-1020-逆序排序\n//\n// Created by ZYJ on 2016/10/9.\n// Copyright © 2016年 ZYJ. All rights reserved"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1021-石子归并/f-51Nod-1021-石子归并/main.cpp",
"chars": 1009,
"preview": "//\n// main.cpp\n// f-51Nod-1021-石子归并\n//\n// Created by ZYJ on 16/8/5.\n// Copyright © 2016年 ZYJ. All rights reserved.\n/"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1022-石子归并 V2/f-51Nod-1022-石子归并 V2/main.cpp",
"chars": 1317,
"preview": "//\n// main.cpp\n// f-51Nod-1022-石子归并 V2\n//\n// Created by ZYJ on 2016/10/20.\n// Copyright © 2016年 ZYJ. All rights rese"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1023-石子归并 V3/f-51Nod-1023-石子归并 V3/main.cpp",
"chars": 1138,
"preview": "//\n// main.cpp\n// f-51Nod-1023-石子归并 V3\n//\n// Created by ZYJ on 2017/9/3.\n// Copyright © 2017年 ZYJ. All rights reserv"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1024-矩阵中不重复的元素/f-51Nod-1024-矩阵中不重复的元素/main.cpp",
"chars": 605,
"preview": "//\n// main.cpp\n// f-51Nod-1024-矩阵中不重复的元素\n//\n// Created by ZYJ on 16/7/31.\n// Copyright © 2016年 ZYJ. All rights reser"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1027-大数乘法/f-51Nod-1027-大数乘法/main.c",
"chars": 1705,
"preview": "//\n// main.c\n// f-51Nod-1027-大数乘法\n//\n// Created by ZYJ on 16/4/17.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1028-大数乘法 V2/f-51Nod-1028-大数乘法 V2/main.cpp",
"chars": 3505,
"preview": "//\n// main.cpp\n// f-51Nod-1028-大数乘法 V2\n//\n// Created by ZYJ on 2016/10/9.\n// Copyright © 2016年 ZYJ. All rights reser"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1029-大数除法/f-51Nod-1029-大数除法/main.cpp",
"chars": 12597,
"preview": "//\n// main.cpp\n// f-51Nod-1029-大数除法\n//\n// Created by ZYJ on 2017/8/5.\n// Copyright © 2017年 ZYJ. All rights reserved."
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1030-大数进制转换/f-51Nod-1030-大数进制转换/main.cpp",
"chars": 2562,
"preview": "//\n// main.cpp\n// f-51Nod-1030-大数进制转换\n//\n// Created by ZYJ on 2017/8/16.\n// Copyright © 2017年 ZYJ. All rights reserv"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1031-骨牌覆盖/f-51Nod-1031-骨牌覆盖/main.cpp",
"chars": 538,
"preview": "//\n// main.cpp\n// f-51Nod-1031-骨牌覆盖\n//\n// Created by ZYJ on 16/7/31.\n// Copyright © 2016年 ZYJ. All rights reserved.\n"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1032-骨牌覆盖 V2/f-51Nod-1032-骨牌覆盖 V2/main.cpp",
"chars": 1739,
"preview": "//\n// main.cpp\n// f-51Nod-1032-骨牌覆盖 V2\n//\n// Created by ZYJ on 2017/11/11.\n// Copyright © 2017年 ZYJ. All rights rese"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1033-骨牌覆盖 V2/f-51Nod-1033-骨牌覆盖 V2/main.cpp",
"chars": 1740,
"preview": "//\n// main.cpp\n// f-51Nod-1033-骨牌覆盖 V2\n//\n// Created by ZYJ on 2017/8/20.\n// Copyright © 2017年 ZYJ. All rights reser"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1035-最长的循环节/f-51Nod-1035-最长的循环节/main.cpp",
"chars": 1346,
"preview": "//\n// main.cpp\n// f-51Nod-1035-最长的循环节\n//\n// Created by ZYJ on 16/8/5.\n// Copyright © 2016年 ZYJ. All rights reserved."
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1038-X^A Mod P/f-51Nod-1038-X^A Mod P/main.cpp",
"chars": 3488,
"preview": "//\n// main.cpp\n// f-51Nod-1038-X^A Mod P\n//\n// Created by ZYJ on 2017/9/28.\n// Copyright © 2017年 ZYJ. All rights res"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1040-最大公约数之和/f-51Nod-1040-最大公约数之和/main.cpp",
"chars": 1014,
"preview": "//\n// main.cpp\n// f-51Nod-1040-最大公约数之和\n//\n// Created by ZYJ on 2016/10/10.\n// Copyright © 2016年 ZYJ. All rights rese"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1042-数字0~9的数量/f-51Nod-1042-数字0~9的数量/main.cpp",
"chars": 2053,
"preview": "//\n// main.cpp\n// f-51Nod-1042-数字0~9的数量\n//\n// Created by ZYJ on 16/7/31.\n// Copyright © 2016年 ZYJ. All rights reserv"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1043-幸运号码/f-51Nod-1043-幸运号码/main.cpp",
"chars": 1352,
"preview": "//\n// main.cpp\n// f-51Nod-1043-幸运号码\n//\n// Created by ZYJ on 16/8/5.\n// Copyright © 2016年 ZYJ. All rights reserved.\n/"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1046-A^B Mod C/f-51Nod-1046-A^B Mod C/main.c",
"chars": 1287,
"preview": "//\n// main.c\n// f-51Nod-1046-A^B Mod C\n//\n// Created by ZYJ on 16/4/17.\n// Copyright © 2016年 ZYJ. All rights reserve"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1047-整数分解为2的幂/f-51Nod-1047-整数分解为2的幂/main.cpp",
"chars": 133,
"preview": "//\n// main.cpp\n// f-51Nod-1047-整数分解为2的幂\n//\n// Created by ZYJ on 2017/11/11.\n// Copyright © 2017年 ZYJ. All rights res"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1049-最大子段和/f-51Nod-1049-最大子段和/main.c",
"chars": 1275,
"preview": "//\n// main.c\n// f-51Nod-1049-最大子段和\n//\n// Created by ZYJ on 16/4/18.\n// Copyright © 2016年 ZYJ. All rights reserved.\n/"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1050-循环数组最大子段和/f-51Nod-1050-循环数组最大子段和/main.cpp",
"chars": 1282,
"preview": "//\n// main.cpp\n// f-51Nod-1050-循环数组最大子段和\n//\n// Created by ZYJ on 16/8/1.\n// Copyright © 2016年 ZYJ. All rights reserv"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1051-最大子矩阵和/f-51Nod-1051-最大子矩阵和/main.cpp",
"chars": 1124,
"preview": "//\n// main.cpp\n// f-51Nod-1051-最大子矩阵和\n//\n// Created by ZYJ on 16/8/1.\n// Copyright © 2016年 ZYJ. All rights reserved."
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1052-最大M子段和/f-51Nod-1052-最大M子段和/main.cpp",
"chars": 1370,
"preview": "//\n// main.cpp\n// f-51Nod-1052-最大M子段和\n//\n// Created by ZYJ on 2016/10/10.\n// Copyright © 2016年 ZYJ. All rights reser"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1053-最大M子段和 V2/f-51Nod-1053-最大M子段和 V2/main.cpp",
"chars": 2164,
"preview": "//\n// main.cpp\n// f-51Nod-1053-最大M子段和 V2\n//\n// Created by ZYJ on 2017/9/6.\n// Copyright © 2017年 ZYJ. All rights rese"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1054-最长等差数列/f-51Nod-1054-最长等差数列/main.cpp",
"chars": 1402,
"preview": "//\n// main.cpp\n// f-51Nod-1054-最长等差数列\n//\n// Created by ZYJ on 2017/11/11.\n// Copyright © 2017年 ZYJ. All rights reser"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1055-最长等差数列/f-51Nod-1055-最长等差数列/main.cpp",
"chars": 1371,
"preview": "//\n// main.cpp\n// f-51Nod-1055-最长等差数列\n//\n// Created by ZYJ on 2016/10/13.\n// Copyright © 2016年 ZYJ. All rights reser"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1056-最长等差数列 V2/f-51Nod-1056-最长等差数列 V2/main.cpp",
"chars": 1428,
"preview": "//\n// main.cpp\n// f-51Nod-1056-最长等差数列 V2\n//\n// Created by ZYJ on 2016/10/14.\n// Copyright © 2016年 ZYJ. All rights re"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1057-N的阶乘/f-51Nod-1057-N的阶乘/main.c",
"chars": 2301,
"preview": "//\n// main.c\n// f-51Nod-1057-N的阶乘\n//\n// Created by ZYJ on 16/4/18.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1058-N的阶乘的长度/f-51Nod-1058-N的阶乘的长度/main.c",
"chars": 1168,
"preview": "//\n// main.c\n// f-51Nod-1058-N的阶乘的长度\n//\n// Created by ZYJ on 16/4/19.\n// Copyright © 2016年 ZYJ. All rights reserved."
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1059-N的阶乘 V2/f-51Nod-1059-N的阶乘 V2/main.cpp",
"chars": 7743,
"preview": "//\n// main.cpp\n// f-51Nod-1059-N的阶乘 V2\n//\n// Created by ZYJ on 2017/8/30.\n// Copyright © 2017年 ZYJ. All rights reser"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1060-最复杂的数/f-51Nod-1060-最复杂的数/main.cpp",
"chars": 1241,
"preview": "//\n// main.cpp\n// f-51Nod-1060-最复杂的数\n//\n// Created by ZYJ on 16/8/16.\n// Copyright © 2016年 ZYJ. All rights reserved."
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1062-序列中的最大数/f-51Nod-1062-序列中的最大数/main.cpp",
"chars": 962,
"preview": "//\n// main.cpp\n// f-51Nod-1062-序列中的最大数\n//\n// Created by ZYJ on 16/8/2.\n// Copyright © 2016年 ZYJ. All rights reserved"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1063-序列中最大的数 V2/f-51Nod-1063-序列中最大的数 V2/main.cpp",
"chars": 275,
"preview": "//\n// main.cpp\n// f-51Nod-1063-序列中最大的数 V2\n//\n// Created by ZYJ on 2017/12/21.\n// Copyright © 2017年 ZYJ. All rights r"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1065-最小正子段和/f-51Nod-1065-最小正子段和/main.cpp",
"chars": 1271,
"preview": "//\n// main.cpp\n// f-51Nod-1065-最小正子段和\n//\n// Created by ZYJ on 16/8/1.\n// Copyright © 2016年 ZYJ. All rights reserved."
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1066-Bash游戏/f-51Nod-1066-Bash游戏/main.c",
"chars": 722,
"preview": "//\n// main.c\n// f-51Nod-1066-Bash游戏\n//\n// Created by ZYJ on 16/4/20.\n// Copyright © 2016年 ZYJ. All rights reserved.\n"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1067-Bash游戏 V2/f-51Nod-1067-Bash游戏 V2/main.cpp",
"chars": 513,
"preview": "//\n// main.cpp\n// f-51Nod-1067-Bash游戏 V2\n//\n// Created by ZYJ on 16/8/2.\n// Copyright © 2016年 ZYJ. All rights reserv"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1068-Bash游戏 V3/f-51Nod-1068-Bash游戏 V3/main.cpp",
"chars": 670,
"preview": "//\n// main.cpp\n// f-51Nod-1068-Bash游戏 V3\n//\n// Created by ZYJ on 16/8/2.\n// Copyright © 2016年 ZYJ. All rights reserv"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1069-Nim游戏/f-51Nod-1069-Nim游戏/main.c",
"chars": 412,
"preview": "//\n// main.c\n// f-51Nod-1069-Nim游戏\n//\n// Created by ZYJ on 16/4/20.\n// Copyright © 2016年 ZYJ. All rights reserved.\n/"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1070-Bash游戏 V4/f-51Nod-1070-Bash游戏 V4/main.cpp",
"chars": 987,
"preview": "//\n// main.cpp\n// f-51Nod-1070-Bash游戏 V4\n//\n// Created by ZYJ on 16/8/2.\n// Copyright © 2016年 ZYJ. All rights reserv"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1072-威佐夫游戏/f-51Nod-1072-威佐夫游戏/main.c",
"chars": 592,
"preview": "//\n// main.c\n// f-51Nod-1072-威佐夫游戏\n//\n// Created by ZYJ on 16/4/20.\n// Copyright © 2016年 ZYJ. All rights reserved.\n/"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1073-约瑟夫环/f-51Nod-1073-约瑟夫环/main.c",
"chars": 360,
"preview": "//\n// main.c\n// f-51Nod-1073-约瑟夫环\n//\n// Created by ZYJ on 16/4/20.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1074-约瑟夫环 V2/f-51Nod-1074-约瑟夫环 V2/main.cpp",
"chars": 619,
"preview": "//\n// main.cpp\n// f-51Nod-1074-约瑟夫环 V2\n//\n// Created by ZYJ on 2017/9/14.\n// Copyright © 2017年 ZYJ. All rights reser"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1076-2条不相交的路径/f-51Nod-1076-2条不相交的路径/main.cpp",
"chars": 2179,
"preview": "//\n// main.cpp\n// f-51Nod-1076-2条不相交的路径\n//\n// Created by ZYJ on 16/8/17.\n// Copyright © 2016年 ZYJ. All rights reserv"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1079-中国剩余定理/f-51Nod-1079-中国剩余定理/main.c",
"chars": 690,
"preview": "//\n// main.c\n// f-51Nod-1079-中国剩余定理\n//\n// Created by ZYJ on 16/4/20.\n// Copyright © 2016年 ZYJ. All rights reserved.\n"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1080-两个数的平方和/f-51Nod-1080-两个数的平方和/main.cpp",
"chars": 788,
"preview": "//\n// main.cpp\n// f-51Nod-1080-两个数的平方和\n//\n// Created by ZYJ on 16/7/30.\n// Copyright © 2016年 ZYJ. All rights reserve"
},
{
"path": "按 OJ 分类/51Nod/f-51Nod-1081-子段求和/f-51Nod-1081-子段求和/main.c",
"chars": 864,
"preview": "//\n// main.c\n// f-51Nod-1081-子段求和\n//\n// Created by ZYJ on 16/4/21.\n// Copyright © 2016年 ZYJ. All rights reserved.\n//"
}
]
// ... and 1186 more files (download for full content)
About this extraction
This page contains the full source code of the f-zyj/ACM GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1386 files (11.0 MB), approximately 3.0M tokens, and a symbol index with 3923 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.