n2

T1.开屏雷击： Bitset Master O ( n m ) O(nm) O ( n m ) 暴力。 出题人开了时限 6 s 6s 6 s ，然后心机的让 m = 3 n m = 3n m = 3 n ， 奈何 O ( n m ) O(nm) O ( n m ) 跑过了 n = 30000 n = 30000 n = 3 0 0 0 0 的点。 O ( n m w + n 2 ) O(\frac {nm}w + n^2) O ( w n m ​ + n 2 ) 算法： 每次合并的时候同时维护一个 u u u 被多少个节点 v v v 包含。 合并可以用 b i t s e t bitset b i t s e t 优化成 O ( n m w ) O(\frac {nm}w) O ( w n m ​ ) , 合并 u , v u,v u , v 时可以考虑求出 S ( u ) x o r S ( v ) S(u) xor S(v) S ( u ) x o r S ( v ) 也就是集合中不同的点，然后对这些点维护一个 u u u 被多少个节点 v v v 包含，总共只会维护 O ( n 2 ) O(n^2) O ( n 2 ) 次。 O ( m ) O(m) O ( m ) 的解决先做完所有修改再询问的数据点的算法： 详见 O ( ( n + m ) log ⁡ 2 n ) O(

方法一：代换法(代入法) 这种方法分为两个步骤： 1、 猜答案 ，我们只需要猜一下大致的形式 比如 T(n)= 4T(n/2) +n 通过观察该递归式，注意到当n加倍时，输出增加4倍，于是猜测该递归式时间复杂度为O(n 2 )，即T(n) = O(n 2 ) 。 2、 数学归纳法证明 我们用带常数系数的展开 T(k) ≤ c 1 k 2 -c 2 k(k<n) T(n) ≤4[c 1 (n/2) 2 -c 2 (n/2)]+n=c 1 n 2 +(1-2c 2 )n = c 1 n 2 -c 2 n-(c 2 -1)n≤c 1 n^2-c 2 n 这里我们就得到了时间复杂度O(n 2 ) 那么我们为什么不用ck 2 呢，看上式看不出来的话，可以推导一下，化简为 cn 2 +n,这个式子我们得不到T(n) ≤cn 2 ,所以通过降阶来实现(算时间复杂度我们只考虑高阶，不用管低阶) 方法二：递归树法(迭代法) 这个应该式比较好理解的了吧，就是一项一项展开，项数以等比数列方式增长(d k-1 ，每次可以递归d次，k为递归的层数)，这里的话就可以理解成 满d叉树 。 来源： CSDN 作者： 萌小兔~ 链接： https://blog.csdn.net/weixin_44417475/article/details/104703670

1 package solution39; 2 3 class Solution { 4 public int solution(String s1,String s2) { 5 int n1 = s1.length(); 6 int n2 = s2.length(); 7 int count = 0; 8 int i = n1-1; 9 int j = n2-1; 10 while(i>=0 && j>=0){ 11 if(s1.charAt(i)==s2.charAt(j)){ 12 count += 1; 13 i -= 1; 14 j -= 1; 15 } 16 else{ 17 break; 18 } 19 } 20 return n1 + n2 - 2 * count; 21 } 22 } 算法思路：贪心算法。 两个字符串从后向前逐字符比对，如果发现不同字符，则停止比对。 来源： https://www.cnblogs.com/asenyang/p/12425127.html

1. 题目 2. 思路 常规题 3. 注意点 无 4. 代码 #include<cstdio> #include<algorithm> #include<set> #include<map> #include<vector> #include<string> using namespace std; struct num{ int n1; int n2; int n3; num(){ } num(int n1, int n2, int n3){ this->n1 = n1; this->n2 = n2; this->n3 = n3; } }; num add(num a, num b){ num c; int flag1 = 0, flag2 = 0; if(a.n3 + b.n3 >= 29){ flag1 = 1; } c.n3 = (a.n3 + b.n3) % 29; if(a.n2 + b.n2 + flag1 < 17){ flag2 = 0; }else{ flag2 = 1; } c.n2 = (a.n2 + b.n2 + flag1) % 17; c.n1 = a.n1 + b.n1 + flag2; return c; } int n1, n2, n3; int main(){ scanf("%d.%d.%d", &n1, &n2, &n3); num a(n1

1. 引入 　　简单工厂的本质是，工厂根据传入的参数，动态的决定应该使用哪一个产品（产品是接口的具体实现）。其中涉及三类角色： 　　（1）工厂角色。负责创建所有实例。工厂类中创建产品类的方法可以被外界直接调用，创建所需的产品对象。 　　（2）抽象产品角色。简单工厂模式所创建的所有对象的父类，负责描述所有实例共有的公共接口。 　　（3）具体产品角色。是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。　 2. 场景实现 　　场景描述：使用c#、java、c、VB任意一种语言实现一个计算器控制台应用程序，要求输入两个数和运算符号，得到结果。 2.1 代码实现 class Program { static void Main(string[] args) { Console.WriteLine("请输入数字1"); string num1 = Console.ReadLine(); Console.WriteLine("请输入数字2"); string num2 = Console.ReadLine(); Console.WriteLine("请输入运算符号"); string sysbol = Console.ReadLine(); string result = ""; switch (sysbol) { case "+":result = Convert

UVA294 题目要求指定范围内约数数目最多的数以及对应的约数数量。 根据唯一分解定理，对于任意正整数 2 ≤ N 2\leq N 2 ≤ N ，有： N = ∑ i = 1 n p i a i ， p 为 素 数 N=\sum\limits_{i=1}^{n}p_i^{a_i}，p为素数 N = i = 1 ∑ n ​ p i a i ​ ​ ， p 为 素 数 那么根据乘法原理，约数的总数目为： f ( N ) = ∏ i = 1 n ( 1 + a i ) f(N)=\prod\limits_{i=1}^{n}(1+a^i) f ( N ) = i = 1 ∏ n ​ ( 1 + a i ) # include <iostream> # include <algorithm> # include <cmath> # include <vector> using namespace std ; const int MAXN = 1000001 ; int main ( ) { int T ; cin >> T ; int Left , Right ; while ( T -- ) { cin >> Left >> Right ; int Ans = 0 , Node = Left ; for ( int n = Left ; n <= Right ; ++ n ) { int

表达式求值是关于栈的应用，涉及到中缀与后缀式的转换，本文关于10以内不带括号的四则运算。 9 + 3 + 4 x 3 = 24 1 x 9 - 5 / 9 = 9 5 x 9 - 4 + 6 - 2 x 3 + 1 = 42 思路：遇到数字直接入数字栈。遇到运算符，第一个运算符直接入符号栈，后面的需要与符号栈栈顶元素比较优先级。若当前优先级大于符号栈顶优先级(乘除大于加减），则直接入栈， 否则先取栈内符号运算，至符号栈为空 ，再将当前符号入栈。 #include<bits/stdc++.h> #define maxsize 500 using namespace std; stack<int> num; stack<char> op; map<char,int> mp={{'+',-1},{'-',-1},{'x',1},{'/',1}}; void deal(char *s) { int len = strlen(s); int n1,n2; while(!num.empty()) num.pop(); for(int i = 0;i < len; ++i){ if(s[i] >= '0' && s [i] <= '9') num.push(s[i]-'0'); else{ if(op.empty())///第一个运算符处理 op.push(s[i]); else{ if(mp

一个分布式系统最多只能同时满足一致性（Consistency）、可用性（Availability）和分区容错性（Partition tolerance）这三项中的两项 。 CAP的证明 上图是我们证明CAP的基本场景，网络中有两个节点N1和N2，可以简单的理解N1和N2分别是两台计算机，他们之间网络可以连通，N1中有一个应用程序A，和一个数据库V，N2也有一个应用程序B2和一个数据库V。现在，A和B是分布式系统的两个部分，V是分布式系统的数据存储的两个子数据库。 在满足一致性的时候，N1和N2中的数据是一样的，V0=V0。在满足可用性的时候，用户不管是请求N1或者N2，都会得到立即响应。在满足分区容错性的情况下，N1和N2有任何一方宕机，或者网络不通的时候，都不会影响N1和N2彼此之间的正常运作。 上图是分布式系统正常运转的流程，用户向N1机器请求数据更新，程序A更新数据库Vo为V1，分布式系统将数据进行同步操作M，将V1同步的N2中V0，使得N2中的数据V0也更新为V1，N2中的数据再响应N2的请求。 这里，可以定义N1和N2的数据库V之间的数据是否一样为一致性；外部对N1和N2的请求响应为可用性；N1和N2之间的网络环境为分区容错性。 这是正常运作的场景，也是理想的场景，然而现实是残酷的，当错误发生的时候，一致性和可用性还有分区容错性，是否能同时满足，还是说要进行取舍呢？

一、UML类图 面向对象编程时，在整理对象之间关系时，用UML类图梳理，会更加清晰。 二、简单工厂模式 1.简单工厂模简介 简单工厂模式，利用一个工厂来生产不同类型的对象，达到服务层代码根据需求更改时，客户端代码接口不用进行修改。客户端可直接创建自己新增的需求对象并进行操作。由于比较简单，见代码很容易理解，故不做赘述。 2.C++代码如下 //定义基类操作数OperatorDP #ifndef _MOPERATORDP_HPP #define _MOPERATORDP_HPP class OperatorDP{ public: OperatorDP() = default; OperatorDP(double _num1, double _num2) : num1(_num1), num2(_num2){} double getNum1(){return num1;} double getNum2(){return num2;} void setNum1(double num){num1 = num;} void setNum2(double num){num2 = num;} virtual double getResult() = 0; // 虚函数 private: double num1; double num2; };#endif // 加法类 #ifndef

PAT甲级1010. Radix (25) 题意： 给定一对正整数，例如6和110，这个等式6 = 110可以是真的吗？答案是“是”，如果6是十进制数，110是二进制数。 现在对于任何一对正整数N1和N2，你的任务是找到一个数字的基数，而另一个数字的基数。 输入规格： 每个输入文件包含一个测试用例。每个案例占用一个包含4个正整数的行： N1 N2标签基数 这里N1和N2每个不超过10位数。数字小于其基数，并从集合{0-9，a-z}中选择，其中0-9表示十进制数0-9，a-z表示十进制数10-35。 如果“标签”为1，最后一个数字“radix”为N1的基数，如果“tag”为2，则为N2。 输出规格： 对于每个测试用例，以一行打印另一个数字的基数，使得方程式N1 = N2为真。如果方程不可能，打印“不可能”。如果解决方案不是唯一的，输出最小可能的基数。 思路： 就是给你两个数，已知其中一个数的进制，然后求另外一个数是多少进制就可以让两个数相等。 暴力遍历会在测试点7超时。 二分搜索后，如果不考虑溢出会在测试点10报错。 二分搜索查找进制，下界是n2中最大的一个数字 + 1；上界是n1的10进制数 + 1；别的没有什么坑点感觉。 ac代码： C++ // pat1010_radix.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include