update

Author: peckfly

刷题/LeetCode/DP/LeetCode - 268. Missing Number(位运算) & 674. Longest Continuous Increasing Subsequence(DP).md

@@ -14,6 +14,7 @@
 #### 解析
 题目要求在`O(n)`时间和`O(1)`空间内完成。
 也是一个很有意思的题目，简单的想法: 
+
 * 用一个变量`sumAll`记录包含没有丢失的那个数的所有的和(也可以用等差数列求和公式求出)；
 * 然后求出数组的和`sum`，结果就是`sumAll - sum`；
 
@@ -71,6 +72,7 @@ class Solution {
 
 #### 题目
 求最长连续递增<font color =red>子串</font>(不是子序列)。
+
 ![在这里插入图片描述](images/674_t.png)
 
 #### 解析

刷题/Other/acwing/Algorithm/AcWing-100. IncDec序列(差分).md

@@ -0,0 +1,104 @@
+# AcWing-100. IncDec序列
+
+## [题目链接](https://www.acwing.com/problem/content/102/)
+
+> https://www.acwing.com/problem/content/102/
+
+## 题目
+
+给定一个长度为 nn 的数列 a1,a2,…,ana1,a2,…,an，每次可以选择一个区间 [l,r]，使下标在这个区间内的数都加一或者都减一。
+
+求至少需要多少次操作才能使数列中的所有数都一样，并求出在保证最少次数的前提下，最终得到的数列可能有多少种。
+
+#### 输入格式
+
+第一行输入正整数nn。
+
+接下来nn行，每行输入一个整数，第i+1行的整数代表aiai。
+
+#### 输出格式
+
+第一行输出最少操作次数。
+
+第二行输出最终能得到多少种结果。
+
+#### 数据范围
+
+0<n≤1050<n≤105,
+0≤ai<21474836480≤ai<2147483648
+
+#### 输入样例：
+
+```
+4
+1
+1
+2
+2
+```
+
+#### 输出样例：
+
+```
+1
+2
+```
+## 解析
+
+思路：首先这题一个重点，就是区间`[l,r]`的修改操作。因为这道题目的修改操作有一个特性，就是只加一或者只减一，而不是+x，也不是−x，所以说我们并不需要用到高级的数据结构，线段树和树状数组，而只是需要用差分即可。
+
+差分定义：对于一个给定的数列A，它的差分数列B定义为,` B[1]=A[1],B[i]=Ai−Ai−1(2<=i<=n)`这里只说性质，也就是把序列A的区间[L,R]加d，也就是把`[Al,Al+1....Ar]`都加上d，其实就是它的差分序列B中，`Bl+d,Br+1−d` 其他的位置统统不改变。
+
+
+
+即给区间`[l, r]`加上一个常数c，则`b[l] += c, b[r+1] -= c`。
+
+
+
+因此在这道题目中，我们就可以利用这个非常有用的性质，因为我们只要求A序列中所有的数相同，而不在意这些方案具体是什么，所以说我们就可以转化题目，也就是将对A序列的+1,−1操作，让A序列相同，改成目标把`B2,…,Bn`变成全0即可，也就是A序列全部相等。而且最后得到的序列，就是这n个B1贪心：因为我们有上面所说的性质，那么我们就可以，每一次选取Bi和Bj，`2<=i,j<=n`而且这两个数，一个为正数，一个为负数，至于为什么要是正负配对，因为我们是要这个B序列2~n都要为0，所以这样负数增加，正数减少，就可以最快地到达目标为0的状态。至于那些无法配对的数Bk可以选B1或者Bn+1，这两个不影响的数，进行修改。
+
+```java
+1、  2 <= i, j <= n
+2、  i = 1, 2 <= j <= n
+3、  2 <= i <= n, j = n+1
+4、  i=1, j = n+1 （不影响）
+```
+
+
+
+所以说我们这道题目得出的答案就是，最少操作数`min(p,q)+abs(p−q)=max(p,q)`然后最终序列a可能会有`abs(p−q)+1`种情况。p为b序列中正数之和，而q为b序列中负数之和。
+
+
+```java
+import java.io.BufferedInputStream;
+import java.io.PrintWriter;
+import java.util.Scanner;
+
+public class Main {
+
+    static Scanner in = new Scanner(new BufferedInputStream(System.in));
+    static PrintWriter out = new PrintWriter(System.out);
+
+    public static void main(String[] args) {
+
+        int n = in.nextInt();
+        int[] a = new int[n];
+        for(int i = 0; i < n; i++) a[i] = in.nextInt();
+
+        for(int i = n-1; i > 0; i--) a[i] -= a[i-1]; //差分，从后往前遍历
+
+        long pos = 0, neg = 0;
+        for(int i = 1 ; i < n; i++){
+            if(a[i] > 0) pos += a[i];
+            else neg -= a[i];
+        }
+        out.println(Math.min(pos, neg) + Math.abs(pos - neg));
+        out.println(Math.abs(pos - neg) + 1);
+        out.close();
+
+    }
+
+}
+
+```
+

刷题/Other/acwing/Algorithm/AcWing-101. 最高的牛(差分).md

@@ -0,0 +1,143 @@
+# AcWing-101. 最高的牛
+
+## [题目链接](https://www.acwing.com/problem/content/103/)
+
+> https://www.acwing.com/problem/content/103/
+
+## 题目
+
+有 NN 头牛站成一行，被编队为1、2、3…N，每头牛的身高都为整数。
+
+当且仅当两头牛中间的牛身高都比它们矮时，两头牛方可看到对方。
+
+现在，我们只知道其中最高的牛是第 PP 头，它的身高是 HH ，剩余牛的身高未知。
+
+但是，我们还知道这群牛之中存在着 MM 对关系，每对关系都指明了某两头牛 AA 和 BB 可以相互看见。
+
+求每头牛的身高的最大可能值是多少。
+
+#### 输入格式
+
+第一行输入整数N,P,H,MN,P,H,M，数据用空格隔开。
+
+接下来M行，每行输出两个整数 AA 和 BB ，代表牛 AA 和牛 BB 可以相互看见，数据用空格隔开。
+
+#### 输出格式
+
+一共输出 NN 行数据，每行输出一个整数。
+
+第 ii 行输出的整数代表第 ii 头牛可能的最大身高。
+
+#### 数据范围
+
+1≤N≤100001≤N≤10000,
+1≤H≤10000001≤H≤1000000,
+1≤A,B≤100001≤A,B≤10000,
+0≤M≤100000≤M≤10000
+
+#### 输入样例：
+
+```
+9 3 5 5
+1 3
+5 3
+4 3
+3 7
+9 8
+```
+
+#### 输出样例：
+
+```
+5
+4
+5
+3
+4
+4
+5
+5
+5
+```
+
+##### 注意：
+
+- 此题中给出的关系对可能存在重复
+
+## 解析
+
+这道题目一个核心要点，就是如何处理这些特殊的关系，也就是两头牛互相看见。
+
+其实题目中已经告诉我们如何处理，因为我们发现，题目中要求牛的身高最高，那么既然如此，我们完全可以将每一组关系(A,B)，看作`[A+1,B−1]`这组牛身高只比`A,B`这两头牛矮1。
+
+各位可以画一个图，来更好的理解这道题目。
+
+![1567126568387](assets/1567126568387.png)
+
+因此我们可以可以利用区间处理小操作，也就是前缀和加差分。设一个数组D，`D[i]`为比最高牛矮多少，则`D[P]=0`，那么对于一组关系，我们可以这样操作,`D[A+1]–,D[B]++;`然后从左到右前缀和，就可以求出矮多少。具体可以看代码实现。
+
+```java
+import java.io.BufferedInputStream;
+import java.io.PrintWriter;
+import java.util.HashSet;
+import java.util.Objects;
+import java.util.Scanner;
+
+public class Main {
+
+
+    static Scanner in = new Scanner(new BufferedInputStream(System.in));
+    static PrintWriter out = new PrintWriter(System.out);
+
+    static class Node{
+        int a, b;
+        Node(int a, int b){
+            this.a = a;
+            this.b = b;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            Node node = (Node) o;
+            return a == node.a &&
+                    b == node.b;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(a, b);
+        }
+    }
+
+    public static void main(String[] args) {
+
+        int n = in.nextInt(), p = in.nextInt(), h = in.nextInt(), m = in.nextInt();
+        int[] height = new int[n+1];
+        height[1] = h; // b数组，可以让所有的牛都是最高
+        HashSet<Node> set = new HashSet<>();
+        for(int i = 0; i < m; i ++){
+            int a = in.nextInt(), b = in.nextInt();
+            if(a > b){
+                int t = a;
+                a = b;
+                b = t;
+            }
+            Node node = new Node(a, b);
+            if(!set.contains(node)){
+                set.add(node);
+                height[a+1]--;
+                height[b]++;
+            }
+        }
+        for(int i = 1; i <= n; i++){
+            height[i] += height[i-1];
+            out.println(height[i]);
+        }
+        out.close();
+    }
+}
+
+```
+

刷题/Other/acwing/Algorithm/assets/1567126568387.png

@@ -14,6 +14,8 @@
 
 ## AOP（Aspect Oriented Programming）
 
+https://www.cnblogs.com/qf123/p/8671479.html AOP原理最好的文章
+
 (1). AOP面向方面编程基于IoC，是对OOP的有益补充；
 
 (2). AOP利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了 多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的 逻辑或责任封装起来，比如日志记录，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。