Eason的博客

https://codeforces.com/contest/1153/problem/D思路: 用dp[i]表示，结点i最少要有dp[i]个最大的结点肯定被忽略掉（因为题目要求最大化，因此我们希望被忽略掉的最大点尽可能少，所以dp表示的是“最少”的个数）。那么对于整个树，根节点的dp[1]即为整颗树最少要丢弃的结点个数，因此最终答案为k-dp[1]+1（因为我们要选中一个答案，所以少丢弃一个...

Estimater.predict是tensorflow的高阶API，但是在使用中常常会遇到如下情况： 单次预测一个大文件的速度正常，但是想做成接口来实时预测速度却缓慢：因为每次预测都会重新reload一遍计算图。那么这个问题是否有解呢？答案：yes。可以在Estimater的层面，实现tensorflow Estimater.predict 的实时预测，将计算图只读取一遍后常驻内存（这里吐槽一...

Estimater.predict是tensorflow的高阶API，但是在使用中常常会遇到如下情况： 单次预测一个大文件的速度正常，但是想做成接口来实时预测速度却缓慢：因为每次预测都会重新reload一遍计算图。那么这个问题是否有解呢？答案：yes。可以在Estimater的层面，实现tensorflow Estimater.predict 的实时预测，将计算图只读取一遍后常驻内存（这里吐槽一...

问题是这样的： 4e1bafcdbc6f: Waiting bafbeb6b464b: Waiting c0e0660d6638: Waiting 269e6f7314e4: Waiting 05fd6d8029a7: Waiting 0aab41d51f2d: Waiting error pulling image configuration: Get...

Agriculture_KnowledgeGraphdemo：http://ecnukg.vicp.io github：https://github.com/qq547276542/Agriculture_KnowledgeGraph 欢迎star&fork~命名实体识别进入主页面，输入文本，即可看到以下命名实体和分词的结果（确保django和neo4j都处于开启状态）...

GreenPlum数据仓库快速配置，通过python连接数据库期末作业要用GP开发一个项目，弄的蛋疼，这里总结下我的快速配置过程…1.docker官网下载docker客户端，安装官网链接： 点击这里2.拉取GP的docker镜像，挂载按照这个来https://yq.aliyun.com/articles/57656#1，照做1.1~4.3步(5.1开始的就不一样了，版本

fasttext是个好东西，是由facebook在2016年推出的一个训练词向量的模型。相比于之前Google的word2vec，fasttext可以解决out of vocabulary的问题。更赞的是，facebook提供了200多种语言的预训练模型和词向量。 然而，在安装完fasttext后，当我读取了3GB的中文模型时，却出了下面的问题：Traceback (most recent cal

问题是这样的：本人自己用一台Linux服务器，平时当FTP和爬虫用。还有一台mac开发用，经常需要用网线和linux通过网线直连来传输数据和控制服务器。蛋疼的事发生了：Linux服务器一旦插上网线，网络流量就只能经过有线网络了，导致Linux服务器不能上网。 查了很多资料，在我的服务器上都行不通。最后终于用route路由表配置默认网关解决了。具体方法很简单，如下：1.查看当前网关信息 ip rou

知识图谱的定义与架构知识图谱的定义知识图谱是结构化的语义知识库，用于以符号形式描述物理世界中的概念及其相互关系。其基本组成单位是“实体-关系-实体”三元组。通过知识图谱，可以实现Web从网页链接向概念链接的转变。知识图谱的架构从逻辑上可以划分为2个层次：数据层和模式层。在知识图谱的数据层，知识以事实（fact）为单位存储在图数据库。图数据中有“实体-关系-实体”或者“实体-属性-属性值”两种三元组，

香农信息量信息量表示不确定性的大小。 信息量的单位是比特（bit）。香农信息量=log1p=−logp(以2为底)香农信息量=\log\frac{1}{p}=-\log p\quad(以2为底)上式中，p越小，则不确定性越大，包含的信息量就越多。比如32支球队，在无任何先验信息的前提下，用二分法猜冠军队伍，最多猜5次，那么信息量就是log132=5\log \frac{1}{32}=5。信息熵（En

随机森林算法学习最近在做kaggle的时候，发现随机森林这个算法在分类问题上效果十分的好，大多数情况下效果远要比svm，log回归，knn等算法效果好。因此想琢磨琢磨这个算法的原理。要学随机森林，首先先简单介绍一下集成学习方法和决策树算法。下文仅对该两种方法做简单介绍（具体学习推荐看统计学习方法的第5章和第8章）。Bagging和Boosting的概念与区别该部分主要学习自：http://www.c

词向量（Word Embedding）  词向量主要用于将自然语言中的词符号数学化，这样才能作为机器学习问题的输入。  数学化表示词的方式很多，最简单的有独热编码，即“足球”=[0,0,1,0,0,0,0,…]，“篮球”=[0,0,0,0,0,1,0,…]，向量的长度为总词数。显然，独热编码有以下缺点：1.可能导致维数过大，对深度学习来说复杂度过高。2.两个词的相似程度无法表示。  词向量与独热编码

近端梯度法（Proximal Gradient Method ，PG）算法简介  近端梯度法是一种特殊的梯度下降方法，主要用于求解目标函数不可微的最优化问题。如果目标函数在某些点是不可微的，那么该点的梯度无法求解，传统的梯度下降法也就无法使用。PG算法的思想是，使用临近算子作为近似梯度，进行梯度下降。概念定义临近算子（proximity operator）proxf(x)=argminy∈Rnf(y

共轭梯度法学习自知乎：https://www.zhihu.com/question/27157047和非线性规划课程简介在数值线性代数中，共轭梯度法是一种求解对称正定线性方程组Ax=b的迭代方法。事实上，求解Ax=b等价于求解： min||Ax−b||22min||Ax-b||_2^2 ,将其展开后可以得到：minxTATAx−bTAx+bTbmin \quad x^TA^TAx-b^TAx+b^T

什么是DBMS？Database Management System（DBMS）数据库管理系统是一个为存储和管理数据库的软件包。数据库技术发展历史（1）从数据模型的发展来看：无管理（60年代之前）：科学计算文件系统：简单的数据管理数据管理需求不断增长，数据库管理系统应运而生文件系统vsDBMS应用程序负责数据在内存和二级存储设备之间的数据交换（比如缓存、基于页面的存取）不同的查询编写不同

局部最优的充分和必要条件∇f(x∗)=0,∇2f(x∗)≻0(Hessian矩阵正定)⇒x∗为局部最优点
abla f(x^*)=0, \quad
abla^2 f(x^*)\succ 0 (Hessian矩阵正定) \quad \Rightarrow \quad x^*为局部最优点x∗为局部最优点⇒∇f(x∗)=0,∇2f(x∗)⪰0(Hessian矩阵半正定)x^*为局部最优点\qu

常见的损失函数1.0-1损失函数(0-1 loss function)L(Y,f(X))={1,Y≠f(X)0,Y=f(X)L(Y,f(X))=\left\{ \begin{aligned}&1,\quad Y
e f(X)\\& 0,\quad Y=f(X) \end{aligned} \right.  可以看出，该损失函数的意义就是，当预测错误时，损失函数值为1，预测正确时，损失函数值为0

前言(本文主要学习自该博主的文章：http://blog.csdn.net/itplus，以下是本人的笔记，主要记录了结论部分，省略了推导的部分。对具体推导过程有兴趣的同学请访问原博主的博客~)   拟牛顿法是求解非线性优化问题最有效的方法之一，其中DFP方法，BFGS方法以及L-BFGS方法都是重要的拟牛顿法。我们现在考虑如下无约束的极小化问题： >minxf(x),其中x=(x1,x2

欠拟合与过拟合L1正则化和L2正则化分类和回归偏差和方差监督学习和无监督学习分类和聚类判别模型和生成模型归一化与标准化协方差和相关系数

灰色预测模型灰色预测的概念（1）灰色系统、白色系统和黑色系统白色系统是指一个系统的内部特征是完全已知的，既系统信息是完全充分的。黑色系统是一个系统的内部信息对外界来说是一无所知的，只能通过它与外界的联系来加以观测研究。灰色系统介于白色和黑色之间，灰色系统内的一部分信息是已知的，另一部分信息是未知的，系统内各因素间有不确定的关系。（2）灰色预测法灰色预测法是一种预测灰色系统的预测方法。灰色

动态规划解TSP问题（状态压缩dp）TSP问题简述  给定图上若干个点，以及他们之间的距离，求一条距离和最小的回路，使得该回路正好经过每个点一次。TSP也叫旅行商问题、货郎担问题。。。状态转移方程  用 V’ 表示一个点的集合，假设从顶点 s 出发， d ( i , V’ ) 表示当前到达顶点 i，经过 V’ 集合中所有顶点一次的最小花费。1.当 V’ 为仅包含起点的集合，也就是：d ( s , {

遗传算法遗传算法简介  遗传算法(Genetic Algorithms，简称 GA)是一种基于自然选择原理和自然遗传机制的搜索(寻优)算法，它是模拟自然界中的生命进化机制，在人工系统中实现特定目标的优化。遗传算法的实质是通过群体搜索技术，根据适者生存的原则逐代进化，最终得到最优解或准最优解。它必须做以下操作:初始群体的产生、求每一个体的适应度、根据适者生存的原则选择优良个体、被选出的优良个体两两配对

模拟退火算法算法简介  模拟退火算法得益于材料的统计力学的研究成果。统计力学表明材料中粒子的不同结构对应于粒子的不同能量水平。在高温条件下，粒子的能量较高，可以自由运动和重新排列。在低温条件下，粒子能量较低。如果从高温开始，非常缓慢地降温(这个过程被称为退火)，粒子就可以在每个温度下达到热平衡。当系统完全被冷却时，最终形成处于低能状态的晶体。  假定我们要解决的问题是一个寻找最小值的优化问题。将物理

插值与拟合简介1.插值方法1.1 拉格朗日（Lagrange）多项式插值  最基本，求一个至多n次多项式φn(x)=a0+a1x+...+anxn​\varphi_n(x)=a_0+a_1x+...+a_nx^n​，使其在给定点处与f(x)同值，即满足插值条件φn(xi)=f(xi)=yi(i=0,1,…,n)​\varphi_n(x_i)=f(x_i)=y_i \quad(i=0,1,…,n)​。

层次分析法（AHP）问题的提出日常生活中有许多决策问题。决策是指在面临多种方案时需要依据一定的标准选择某一种方案。购物：买钢笔，一般要依据质量、颜色、实用性、价格等方面的因素来选择某一只钢笔。 买饭，则要依据色、香、味等方面的因素选择某种饭菜。旅游：选择旅游地的时候，一般会依据景色、费用、食宿条件等因素选择去哪个地方。面临各种各样的方案，要进行比较、判断、评价、最后做出决策。这个过程主观因

排队论入门学习 （for 数学建模）文字部分引用了很多浙大数学建模排队论ppt中的内容，本人做个总结和代码实现为什么研究排队论？研究排队问题，就是要把排队的时间控制到一定的程度内，在服务质量的提高和成本的降低之间取得平衡，找到最适当的解。排队系统的组成：1.输入过程： 输入过程是说明顾客按照怎样的规律到达系统，分为三个方面：顾客总数：有限与无限顾客到达的方式：单个或者成批顾客相继到达的时间间隔

————————————配置———————————— jdbc.properties中加入： excelUrl=/……xlsx文件目录路径/ (excelUrl + “xxxx.xlsx” 为完整路径)   导入poi-3.16下的6个jar包，poi-3.16/lib下的5个jar包，poi-3.16/ooxml-lib下的2个jar包

对于一个预测问题，同时有多种可用的模型，每种模型有多种可用的参数。如何选择一个最合适的模型？总题过程分为2个部分：1.对于一个模型，如何评估该模型在特定问题上的好坏？2.选择了最好的模型后，如何选择最优的参数？      对于模型的评估，我们一般使用交叉验证(cross validation)来进行评估。 在这里我们使用了k折叠法，将训练集划分为相等的k份。然后从1

首先要下载poi的jar包：下载地址之后在项目中需要把poi下载目录里的所有jar包导入。然后我自己封装了一个xlsx读取类，输入文件地址，要获取的列。输出二维数组，第一维代表一行数据，第二维代表每一行的单元格数据。import java.io.File;import java.io.FileInputStream;import java.io.IOException;impor

最近的项目需要导入大量的数据，插入的过程中还需要边查询边插入。插入的数据量在100w左右。一开始觉得100w的数据量不大，于是就插啊插，吃了个饭，回来一看，在插入了50多w条数据后，每秒就只能插10条了。。觉得很奇怪，为啥越插越慢呢？于是就开始分析插入的时间损耗，想到了如下的解决方案：（mysql使用的INNODB引擎）1.分析是否是由主码，外码，索引造成的插入效率降低主码：由于主

starting resourcemanager, logging to /Users/hadoop/hadoop-2.7.3/logs/yarn-hadoop-resourcemanager-MacBook-Pro-2.local.outnohup: can't detach from console: Inappropriate ioctl for deviceMac下的nohup似乎

首先本文参考了点击打开链接 这篇博客，然后可能时间有点久远，Kaggle的这道题给的数据文档和之前的不一样了，以及还有一些注意点这篇文章里没有突出。因此这里重新做个总结，希望大家能早点入个门。这里我使用的sklearn中的支持向量机来解决手写识别问题。这里的svm是可以解决多分类问题的。核函数使用的是高斯核（rbf），松弛变量c选择的是5.kaggle这道题一共提供了3个文件：train.

ps. 现在不用配置这些了，直接装个coderunner插件即可。。本人mac版本10.12.5 ，vscode版本为 1.13步骤很简单，添加好各种与c++有关的插件后，reload一次，重启vscode。在helloworld.cpp所在文件夹下创建.vscode文件夹，在.vscode中创建2个文件：tasks.json , launch.json接着是各个文件的内容：...

朴素贝叶斯（naive bayes）模型主要用于文本分类，比如要将邮件分类为正常邮件和带侮辱性词汇邮件对于一封邮件来说其特征可以表示为该邮件中单词出现的情况。比如我们有一个5000个词的词典表，那么邮件的特征可表示成一个特征向量，特征向量的维数等于词典表的单词个数，特征向量每一维的取值空间为0或1（即这个单词是否出现）对于p(x|y),在某一组样本中：p(x1x2...x5000|

关于逻辑回归的学习，建议大家看看这篇blog，讲的很清楚：点击打开链接逻辑回归，实际上就是对线性回归多增加了一个函数映射，使其值域由无穷区间映射到[0,1]区间在线性回归中，估计函数为  其中delta是参数向量，x是输入样本的特征向量而在逻辑回归中，估计函数实际上就是在线性回归的基础上，嵌套了一个sigmoid函数。逻辑回归的估计函数为   其中，e的指数部分就是线性回归的输

中心性定义了网络中一个结点的重要性。换句话说，我们要求的是，在社会网络中，谁是中心角色（具有影响力的用户）举个例子，某个明星开通了微博，在短短数小时内，就有几十万的粉丝关注了他的微博。我们可以认为，他的“受欢迎程度”很高。如果把社交网络中的关注行为看做一条有向边，那么受关注的结点一般拥有很高的“入度”，那么我们能够把一个结点的入度看做是结点中心性的度量指标。当然这只是一个最简单的估计方法，还有

为了大家方便，直接把数据放在github了：https://github.com/qq547276542/Louvain算法介绍：Louvain 算法是基于模块度的社区发现算法，该算法在效率和效果上都表现较好，并且能够发现层次性的社区结构，其优化目标是最大化整个社区网络的模块度。社区网络的模块度（Modularity）是评估一个社区网络划分好坏的度量方法，它的含义是社区内节点的连边数与随机情况下的...

主要是整理了mapreduce常用的操作模板主函数（请忽略主类的名字。。忘记改了）：package hadoop.wordCount;import java.io.IOException;import org.apache.hadoop.conf.Configuration;import org.apache.hadoop.fs.Path;import org.ap

MySQLdb 是链接python和mysql数据库的工具，Ubuntu 自带了python，但是这个工具还是需要我们自己安装配置的前提：系统安装了python和mysql1：下载MySQLdb：点击链接  http://downloads.sourceforge.net/project/mysql-python/mysql-python-test/1.2.3c1/MySQL-pyth

使用 alternate 机制可以自由切换python默认版本，只需要在终端输入简单的几个指令：sudo update-alternatives --install /usr/bin/python python /usr/bin/python2 100sudo update-alternatives --install /usr/bin/python python /usr/bin/py

数据表插入不了中文，折腾了1个小时，终于找到错误所在。首先设置数据库的默认字符集 ：打开终端，输入  mysql -uroot -p  ，输入密码，进入mysql命令行输入 status;  查看当前字符集状态Current database:　　order_movie_ticketServer characterset:    utf8Db     character

bool is_sqrt(long long n) { int m = sqrt(n); if (m*m == n) return true; else return false;}int solve(long long n) { if (is_sqrt(n)) return 1; while (n % 4

#include#include#include#include#include#includeusing namespace std;const int maxn=507;const double eps=1e-7;double A[2*maxn][maxn]; //增广矩阵double x[maxn]; //解集//equ: 方程个数 var：变元个数int Ga

const int maxn=1e3+7;struct Topo { int indeg[maxn],n; vector G[maxn],path; void init(int n) { this->n=n; for(int i=0; i<=n; i++) G[i].clear(); memset(i

1、从canvas中直接提取图片元数据// 图片导出为 png 格式var type = 'png';var imgData = canvas.toDataURL(type);上面的代码得到的数据格式为：data:image/png;base64,.....2、将mime-type改

完善：HTML5表单新特征简介与举例这篇文章发布于 2011年01月6日，星期四，00:29，归类于 css相关。 阅读 44141 次, 今日 19 次by zhangxinxu from http://www.zhangxinxu.com本文地址： http://www.zhangxinxu.com/wordpress/?p=1379一、前言一撇其实

单点替换，单点增加，区间求最值，区间求和#include #include #include using namespace std;#define lson l , m , rt << 1#define rson m + 1 , r , rt << 1 | 1const int maxn = 100007;const int INF=0x7fffffff;int MAX[maxn

首先是思路，face++要求获取图片的URL，因此首先将前端上传的文件直接上传到云数据库（无需通过后台），我使用的是bmob云数据库，如何使用bmob请到官网查阅文档，很简单的使用bmob记得要初始化，我这里就不贴了，直接贴获取url的代码function uploadBmob(){ $("#loading").show(); var fileUploadContro

之前无聊写的，代码在附件里，仅供参考- - AB剪枝只有2层，所以AI战斗力很渣。。AB.javaclass AB { static int round=1; static int n=Jframe.n; static int G[][]=new int[20][20]; static int INF=10000; static void copy(int a[][],int

http://www.html5rocks.com/zh/tutorials/canvas/performance/#toc-intro简介HTML5 画布最初来自 Apple 的一项实验，是网络上最广泛支持的 2D 直接模式图形标准。现在，许多开发人员都依靠 HTML5 画布开发各种多媒体项目、视觉效果和游戏。但是，随着我们构建的应用的复杂程度不断增加，开发人员会在无意中遇到性能

代码如下：//**********************************************// pollard_rho 算法进行质因素分解//////*********************************************long long factor[100];//质因素分解结果（刚返回时时无序的）int tol;//质因素的个数，编号0~to

首先改算法原理是基于费马小定理： 假如p是素数，且gcd(a,p)=1，那么a^(p-1)%p=1推论：  若p是素数且a是正整数，那么a^p%p=a定义：令a是一正整数，若n是合数且满足a^n%n=a,则n称为以a为基的伪素数素数测试原理：取多个a为底，若n都是以a为基的伪素数，则可以近似认为n为素数。取多个底进行试验，次数越多，n为素数的概率就越大typedef

#define N 1000000struct Node{ int idx; int val;}baby[N];bool cmp(Node n1,Node n2){ return n1.val!=n2.val?n1.val<n2.val:n1.idx<n2.idx;}int gcd(int a,int b){ return b==0?a:gcd(b,a%b

//baby_step giant_step// a^x = b (mod n) n为素数，a,b < n// 求解上式 0<=x < n的解#define MOD 76543int hs[MOD],head[MOD],next[MOD],id[MOD],top;void insert(int x,int y) { int k = x%MOD; hs[top] = x,

素数定理：素数有无穷多个，能估计出一个小于正实数x的素数有多少个，并用π(x)来表示，这就是素数定理定理内容： 随着x的增长，π(x)/(x/lnx)=1 具体数据见下表：n            1e3       1e4       1e5       1e6        1e7π(n)       168       1229     9892     78498  

const int N = 210005;const int INF=0x7FFFFFFF;struct SBT{ int key,left,right,size;} tree[N];int root,top;void init(){ root=top=0;}/////以下函数x参数带rootvoid left_rot(int &x){ int y

const int maxn=50;//有equ个方程，var个变元。增广矩阵行数为equ，列数为var+1int equ,var;int a[maxn][maxn]; //增广矩阵int x[maxn]; //解集int free_x[maxn];int free_num;void init(){ memset(a,0,sizeof(a)); memset(x,0

int calc(int n,int m) { //求1~n 与m互质的数的个数 int num=getFactors(m); //先将m分解质因数 int sum=0; //先求出不互质的个数，最后用n减去该数 for(int state=1; state<(1<<num); state++) { //枚举状态 int tmp=1;

typedef long long LL;LL exgcd(LL a,LL b,LL &x,LL &y){ if(a==0&&b==0) return -1; if(b==0) { x=1;y=0; return a; } LL d=exgcd(b,a%b,y,x); y-=a/b*x; return d;}int m[10

typedef long long LL;LL exgcd(LL a,LL b,LL &x,LL &y){ if(a==0&&b==0) return -1; if(b==0) { x=1;y=0; return a; } LL d=exgcd(b,a%b,y,x); y-=a/b*x; return d;}LL cal(LL a,LL b

typedef long long LL;const int maxn=10000;int prime[maxn+7]; //下标从1开始，prime[0]存的是素数个数int getPrime(){ //求小于maxn的所有素数，返回素数个数 memset(prime,0,sizeof(prime)); for(int i=2;i<=maxn;i++){

给出一个区间[L, R]，找出区间内容、相邻的距离最近的两个素数和距离最远的两个素数。我们可以通过2次筛法，第一次先筛选出素数表，第二次通过素数表再筛选出[L,R]之间的素数注意因为L和R的值非常大，但是R-L是小于1e6的，所以我们可以开一个vis2数组，然后将存放区间是否为合数的vis[L,R]映射到vis2[0,R-L](也就是向左偏移L个单位)#include#inc

题目大意：给定一个字符串，问有多少字符串满足UVU的形式，要求U非空，V的长度为g。思路：首先，很容易想到用后缀数组求LCP，能够在O(1)的时间求任意2点的lcp。一开始我想的是枚举v的起点，然后在v的左侧枚举左端u的起点，设左端u的起点为i，那么u_len等于v的起点减i,然后右端起点固定为j=i+u_len+v_len,那么只要lcp(i,j)为u_len，则ans++。  很可惜，

#include#include#include#include#include#include#include#includeusing namespace std;const int maxn=10007;int iscut[maxn]; //割点标志int bccno[maxn]; //i点属于哪个点双连通分块int pre[maxn], dfs_clock, b

在实际问题中，2-SAT问题在大多数时候表现成以下形式：有N对物品，每对物品中必须选取一个，也只能选取一个，并且它们之间存在某些限制关系（如某两个物品不能都选，某两个物品不能都不选，某两个物品必须且只能选一个，某个物品必选）等，这时，可以将每对物品当成一个布尔值（选取第一个物品相当于0，选取第二个相当于1），如果所有的限制关系最多只对两个物品进行限制，则它们都可以转化成9种基本限制关系，从而转化为

#include#include #include #include #include #include #include #include #include using namespace std;const int MAXN=220010;/* da(str ,sa,rank,height,n ,128);//n是字符串长度;*例如：*n = 8，实际元素有9个，最

const int maxn=1e5+7;int ufs[maxn];int Find(int x) { if(ufs[x]<0) return x; return ufs[x]=Find(ufs[x]); //查找根的同时进行路径压缩}void init() { memset(ufs,-1,sizeof(ufs));} void U(int a, int

#include #include #include #include #include #include #include #include #include using namespace std;const int maxn=300007;char str[maxn];int p[maxn=0;--i){ s[i+i+2]=s[i];

//返回字符串最小,最大表示的首下标 （同构字符串中字典序最小/最大的字符串起始下标）int MinimumRepresentation(char *str) { //最小表示法 int i,j,l,m=strlen(str); i=0; j=1; while(i str[(j+l)%m]) i=i+l+1; else j=j+l+1; if(i==j) j=i+1; } if(i<j) retu

#include #include #include #include #include #include using namespace std;const int maxn=2007;const int INF=0x7fffffff;struct Edge{ int from,to,cap,flow,cost;};struct MCMF{ int n,m,s,

string min_pre(string str){ //原串中为树的dfs路线，0代表进入子树，1代表返回父节点 vector box; string ret = ""; int equal = 0, st = 0; for(int i = 0; i < str.size(); i++){ if(str[i] == '0

#include #include #include #include using namespace std;/* * 最小树形图(确定根，求有向图最小生成树) * int型 * 复杂度O(NM) * 点从0开始 */const int INF = 0x7fffffff;const int MAXN = 1010;const int MAXM = 40010；stru

#include #include #include #include #include #include #include #include using namespace std;const int MAXN = 10010;int rmq[2*MAXN];//rmq数组，就是欧拉序列对应的深度序列struct ST { int mm[2*MAXN]; i

#include #include #include #include #include #include #include #include using namespace std;const int MAXN = 50010;struct Edge { int to,next;} edge[MAXN*2];int head[MAXN],tot;int top[

Point center;bool PointCmp(const Point &a,const Point &b){ if (a.x >= 0 && b.x < 0) return true; if (a.x == 0 && b.x == 0) return a.y > b.y; //向量OA和向量OB的叉积 int det =

#include #include #include #include using namespace std;const int MOD = 10007;int INV[MOD];//求ax = 1( mod m) 的x值，就是逆元(0<a<m)long long inv(long long a,long long m) { if(a == 1)return 1;

int G[maxn][maxn],indegree[maxn],topo[maxn],n,m; //topo[]可打印topo排序void Addedge(int u,int v) //添加有向边u->v{ G[u][v]=1; indegree[v]++; //终点入度+1}void init() //初始化边和入度{ memset(

typedef long long ll;struct Lucas { ll n, m, p; ll qPow (ll a, ll k) { ll ans = 1; while (k) { if (k&1) ans = (ans * a) % p; a = (a * a) % p; k /= 2; } return ans; } ll C (ll a, ll b) { if (a a - b)

int d[50000][40];vector A;void RMQ_init(const vector & A){ //RMQ 初始化 int n=A.size(); for(int i=0;i<n;i++)d[i][0]=A[i]; for(int j=1;(1<<j)<=n;j++) for(int i=0;i+(1<<j)-1<n;i+

#define LL long longint mod = 1000000007;int n; //矩阵宽度const int maxn=100; //maxn不要超过160struct Mat //矩阵结构体{ LL mat[maxn][maxn];};Mat operator * (Mat a, Mat b) //2个边长为n的正方形矩阵乘法 a*b mod p

const int maxn=50050;const int INF=0x7fffffff;#define M 11#define LL long longstruct Edge{ int from,to,cap,flow; Edge(int u,int v,int c,int f):from(u),to(v),cap(c),flow(f){}};struct Dinic

//模板long long dp[1005][1005];long long f(int n,int m){ //返回和为n，每个数不超过m的划分个数 n,m都不能为0 if(dp[n][m]) return dp[n][m]; if(n==1||m==1) return dp[n][m]=1; if(m>n) return dp

int next[1000070]; //next 数组int ans;void getNext(char *p,int *next) //构造next数组{ int j=0,k=-1; next[0]=-1; int len=strlen(p); while(j<len) { if(k==-1||p[j]==p[k])

#include#include#include#include#includeusing namespace std;const int maxnode=1000007;const int SIGMA_SIZE=26; //若字符串可能出现所有字符，则要将该值改为128，并且将idx函数中“ -‘a’ "去掉//给定多个模板，一个文本，能够找出模板在文本中的位置与附加信息va

const int maxn=10010; //树状数组可能的最大长度struct BIT { //设树状数组为A[],下标从1开始 int N; int C[maxn]; //辅助数组 void init(int BIT_size) { //初始化,BIT_size 为树状数组的长度 N=BIT_size; memset(C,0,s

const int hashsize = 1000003;const int maxstate = 1000000;typedef int State;int head[hashsize],Next[maxstate];State st[maxstate];//需要定义一个状态数组int id=0;//状态数组的下标，访问状态void init(){memset(head,0,size

typedef long long LL;typedef pair PII;typedef pair pii;const int maxn = 1000005; //点的数量const int maxD = 2; //维数，根据题目维数修改此处const int maxM = 12;const LL INF = 4611686018427387903LL;int now;s

const int maxnode=100003;const int sigma_size=26; //字符集大小,注意idx函数也要随着修改struct Trie{ int ch[maxnode][sigma_size]; int val[maxnode]; int sz; void init() { sz=1;memset(ch[0],0,sizeof(c

#include #include #include #include #include #include #include using namespace std;const int INF=1<<30;const int maxn=2000+10;struct INtervalTree2D{ //2维线段树x轴y轴的下标均从1开始 int Max[maxn][maxn

# define N 100100int e; //记录横坐标个数,注意主函数里不要有同名变量struct node1{ double x,y1,y2; int f;} line[N*2];struct node2{ double rf,lf,cnt,incnt; //求矩形交可以没有cnt，求矩形并可以没有incnt int l,r,c;} tr

# define N 5005int e;struct node1 { int x,y1,y2; int f;} line[2*N];struct node2 { int l,r; int lf,rf;/*左右区间所对应的y值*/ int cnt;/*节点上线段的测度*/ int count;/*节点被线段完全覆盖的次数*/ int

HDU 2089 不要62http://acm.hdu.edu.cn/showproblem.php?pid=2089不能出现4，或者相邻的62，这题可以暴力打表解决具体的在代码里都有解释 #include  #include  #include  #include  #include  #include  #define N 55  #define inf

const int MAXV = 1 << 9;int d[MAXV],v,w;int m,n,V; //背包大小为V，n种物品,每种物品m个void ZeroOnePack( int* f, int C, int W) { //01背包 int v; for( v = V; v >= C; v --) f[v] = max( f[v], f[v - C]

正式的定义，网上一大把，但他们的作用是让人看不懂……二分图：把点分成两个集合X,Y，使得图的边的两个端点总是分别落在X和Y上，不会有X中的点连向X中的点，不会有Y中的点连向Y中的点匹配：实质上是二分图中的一个边集，边集中出现的点不会重合，比如有a-b了，就不会有a-c了，要是有了a就重合了最大匹配：这个边集的数目最大的那个匹配匈牙利算法——增广路：一条在X和

/*去掉桥，其余的连通分支就是边双连通分支了。一个有桥的连通图要变成边双连通图的话，把双连通子图收缩为一个点，形成一颗树。通过遍历所有桥来统计缩点树的各结点度数，需要加的边为(leaf+1)/2(leaf 为叶子结点个数)*/const int MAXN = 5010;//点数const int MAXM = 20010;//边数，因为是无向图，所以这个值要*2struct Edge {

const int MAXN=10010,MAXM=100010;//点的下标切记转换成由1~nstruct Edge{ int to,next; bool cut; //是否为桥的标记*******}edge[MAXM]; //边数组/* 遍历点u的临接边 for(int i=head[u];i!=-1;i=edge[i].next) { edg

#include #include #include #include #include #include #include #include using namespace std;const double PI=acos(0)*2;struct Point{ double x,y; Point(double x=0,double y=0):x(x),y(

///////////////////////////////////////////////////////////////////////////////////////////////struct Line { //定义直线类型 Point P; // 直线上任意一点 Vector v; // 方向向量 double ang; // 极角，即从

三点求圆心坐标（三角形外心）//过三点求圆心坐标Point waixin(Point a,Point b,Point c) { double a1 = b.x - a.x, b1 = b.y - a.y, c1 = (a1*a1 + b1*b1)/2; double a2 = c.x - a.x, b2 = c.y - a.y, c2 = (a2*a2 + b2*b2)/2;

//////////////////////凸包/////////////////////////// int ConvexHull(Point *p,int n,Point* ch) { //返回凸包顶点数，凸包顶点存在ch中 sort(p,p+n); int m=0; for(int i=0; i1&&Cross(ch[m-1]-ch[m-2],p[i]-ch[m-2