diff --git a/Big_data_example/spark-rest-submitter/src/main/java/com/markilue/sparkSubmit/test.java b/Big_data_example/spark-rest-submitter/src/main/java/com/markilue/sparkSubmit/test.java new file mode 100644 index 0000000..90cd32e --- /dev/null +++ b/Big_data_example/spark-rest-submitter/src/main/java/com/markilue/sparkSubmit/test.java @@ -0,0 +1,33 @@ +package com.markilue.sparkSubmit; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +/** + * @BelongsProject: spark-rest-submitter + * @BelongsPackage: com.markilue.sparkSubmit + * @Author: markilue + * @CreateTime: 2022-11-18 15:33 + * @Description: TODO + * @Version: 1.0 + */ +public class test { + + //反编译 + /** + *java -cp "E:\software\idea2022\IntelliJ IDEA 2022.1.3\plugins\java-decompiler\lib\java-decompiler.jar" org.jetbrains.java.decompiler.main.decompiler.ConsoleDecompiler -dgs=true spark-rest-submitter-0.0.3-SNAPSHOT.jar spark-rest-submitter + + */ + + public static void main(String[] args) { + + List list = new ArrayList<>(); + list.add("ding"); + list.add("yang"); + String[] strings = list.toArray(new String[0]); + Object[] objects = list.toArray(); + + System.out.println(Arrays.toString(strings)); + } +} diff --git a/Leecode/src/main/java/com/markilue/leecode/dynamic/T01_Fib.java b/Leecode/src/main/java/com/markilue/leecode/dynamic/T01_Fib.java new file mode 100644 index 0000000..72c0e77 --- /dev/null +++ b/Leecode/src/main/java/com/markilue/leecode/dynamic/T01_Fib.java @@ -0,0 +1,152 @@ +package com.markilue.leecode.dynamic; + +import org.junit.Test; + +/** + * @BelongsProject: Leecode + * @BelongsPackage: com.markilue.leecode.dynamic + * @Author: markilue + * @CreateTime: 2022-11-21 10:21 + * @Description: + * TODO 力扣509题 斐波那契数： + * 斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是： + * F(0) = 0，F(1) = 1 + * F(n) = F(n - 1) + F(n - 2)，其中 n > 1 + * 给定 n ，请计算 F(n) 。 + * @Version: 1.0 + */ +public class T01_Fib { + + @Test + public void test(){ + System.out.println(fib1(4)); + } + + + /** + * 自己的思路：理论上来说，最直接的思路就是递归 + * 速度击败5.26%，内存击败91.99% + * 时间复杂度O(2^n),空间复杂度O(n) + * @param n + * @return + */ + public int fib(int n) { + if(n==0){ + return 0; + } + if(n==1){ + return 1; + } + + return fib(n-1)+fib(n-2); + } + + + /** + * 自己的思路：尝试动态规划法 + * 速度击败100%，内存击败33.98% + * 时间复杂度O(n),空间复杂度O(N) + * @param n + * @return + */ + public int fib1(int n) { + if(n==0){ + return 0; + } + if(n==1){ + return 1; + } + + int[] dp = new int[n+1]; + dp[0]=0;//初始化状态方程 + dp[1]=1;//初始化状态方程 + int i=2; + + while (i<=n){ + dp[i]=dp[i-1]+dp[i-2]; + i++; + } + + return dp[n]; + + } + + + /** + * 代码随想录动态规划法： + * 速度击败100%，内存击败84.22% + * 时间复杂度O(N),空间复杂度O(1) + * 相比于自己的思路，优化在于没必要一直记录之前的不需要的数字: + * TODO 递归五部曲分析如下： + * (1)确定dp数组及下标含义：dp[i]是第i个数的斐波那契数值是dp[i] + * (2)确定递推公式：题目已经把递推公式直接给我们了：状态转移方程 dp[i] = dp[i - 1] + dp[i - 2]; + * (3)dp数组如何初始化：dp[0] = 0;dp[1] = 1; + * (4)确定遍历顺序：从递归公式dp[i] = dp[i - 1] + dp[i - 2];中可以看出，dp[i]是依赖 dp[i - 1] 和 dp[i - 2]，那么遍历的顺序一定是从前到后遍历的 + * (5)举例推导dp数组：当N为10的时候，dp数组应该是如下的数列：0 1 1 2 3 5 8 13 21 34 55 + * + * @param n + * @return + */ + public int fib2(int n) { + if(n<2)return n; + + int[] dp = new int[2]; + dp[0]=0;//初始化状态方程 + dp[1]=1;//初始化状态方程 + + for (int i = 2; i <= n; i++) { + int sum=dp[0]+dp[1]; + dp[0]=dp[1]; + dp[1]=sum; + } + + return dp[1]; + + } + + + /** + * 官方解法：矩阵快速幂,具体思路参照笔记，实际上是一种数学上的解法，利用公式快速推导 + * 时间复杂度O(logn),空间复杂度O(1) + * @param n + * @return + */ + public int fib3(int n) { + if (n < 2) { + return n; + } + int[][] q = {{1, 1}, {1, 0}}; + int[][] res = pow(q, n - 1); + return res[0][0]; + } + + public int[][] pow(int[][] a, int n) { + int[][] ret = {{1, 0}, {0, 1}}; + while (n > 0) { + if ((n & 1) == 1) { + ret = multiply(ret, a); + } + n >>= 1; + a = multiply(a, a); + } + return ret; + } + + public int[][] multiply(int[][] a, int[][] b) { + int[][] c = new int[2][2]; + for (int i = 0; i < 2; i++) { + for (int j = 0; j < 2; j++) { + c[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j]; + } + } + return c; + } + + + + + + + + +} diff --git a/Leecode/src/main/java/com/markilue/leecode/dynamic/T02_ClimbStairs.java b/Leecode/src/main/java/com/markilue/leecode/dynamic/T02_ClimbStairs.java new file mode 100644 index 0000000..8ad32f0 --- /dev/null +++ b/Leecode/src/main/java/com/markilue/leecode/dynamic/T02_ClimbStairs.java @@ -0,0 +1,114 @@ +package com.markilue.leecode.dynamic; + +import org.junit.Test; + +/** + * @BelongsProject: Leecode + * @BelongsPackage: com.markilue.leecode.dynamic + * @Author: markilue + * @CreateTime: 2022-11-21 11:16 + * @Description: + * TODO 力扣70题 爬楼梯： + * 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。 + * 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？ + * @Version: 1.0 + */ +public class T02_ClimbStairs { + + @Test + public void test(){ + int n =4; + System.out.println(climbStairs1(n)); + } + + + /** + *自己思路：这题似乎可以使用回溯类似的做法，n-当前步数；最后的出来条件就是当前n<0就result就不加1，刚好等于0就+1，这种做法时间复杂度应该在O(2^n)左右 + * 结果：在10以内是对的，44以后超过时间限制 + * 自己尝试动态规划法感觉没有什么思路，被困在这个状态方程到底是什么，如果dp[i]是i步的方法数又找不到递推公式；如果dp[i]是第[i]次走过的步数，这个状态转移方程好像又有两个分支 + * @param n + * @return + */ + public int climbStairs(int n) { + backtracking(n); + return result; + } + int result =0; + public void backtracking(int n){ + if(n<0){ + return; + } + if(n==0){ + result++; + return; + } + + for (int i = 1; i <= 2; i++) { + //当前可以选择走1还是2步,由于n可以不变，因此省去了回溯过程 + //这里还可以剪枝，如果已经超过了2，后续就不需要在遍历2的了 + backtracking(n-i); + } + + } + + + + /** + *代码随想录动态规划法思路： + * 爬第一层楼梯有一种方法，爬到第二层有两种方法；第三层可以从第一层爬两楼；可以从第二层爬一楼， + * 所以爬三楼可以从爬一楼和爬两楼的状态推导出来，以此类推 dp[i] = dp[i - 1] +dp[i - 2]即该楼的方法，可以从下一层爬一楼，也可以从下两层爬二楼 + * TODO 递归五部曲如下： + * (1)确定dp数组及下标含义：dp[i]是i楼可能的方法数是dp[i] + * (2)确定递推公式：题目已经把递推公式直接给我们了：状态转移方程 dp[i] = dp[i - 1] + dp[i - 2] + * (3)dp数组如何初始化：dp[1] = 1，dp[2] = 2 + * (4)确定遍历顺序：从递归公式dp[i] = dp[i - 1] + dp[i - 2];中可以看出，dp[i]是依赖 dp[i - 1] 和dp[i - 2]，那么遍历的顺序一定是从前到后遍历的 + * (5)举例推导dp数组：当N为10的时候，dp数组应该是如下的数列：0 1 2 3 5 8 13 21 + * 速度击败100%，内存击败5.7% + * @param n + * @return + */ + public int climbStairs1(int n) { + if(n==1){ + return 1; + } + if(n==2){ + return 2; + } + int last1=1,last2=2,now=0; + for (int i = 3; i <= n; i++) { + now=last1+last2; + last1=last2; + last2=now; + } + + return now; + } + + /** + * 代码随想录实际实现 + * 速度击败100%，内存击败45.87% + * @param n + * @return + */ + public int climbStairs2(int n) { + if(n<=1){ + return n; + } + int[] dp=new int[3]; + dp[1]=1; + dp[2]=2; + + for (int i = 3; i <= n; i++) { + int now=dp[1]+dp[2]; + dp[1]=dp[2]; + dp[2]=now; + } + + return dp[2]; + } + + + + + +} diff --git a/phm_rotate/backend/phm_backend/common/common-linux/src/main/resources/flumeConfig.properties b/phm_rotate/backend/phm_backend/common/common-linux/src/main/resources/flumeConfig.properties new file mode 100644 index 0000000..ac04ba9 --- /dev/null +++ b/phm_rotate/backend/phm_backend/common/common-linux/src/main/resources/flumeConfig.properties @@ -0,0 +1,18 @@ +# ??phm102,phm103???? + +# phm102 +phm102.host=phm102 +phm102.username=root +phm102.password=dingjiawen.123 + +# phm102 +phm103.host=phm103 +phm103.username=root +phm103.password=YSL. + + +# ?????? +template.base.localPath=E:/self_example/phm_rotate/backend/phm_backend/collecting/mqtt-collect-flume/src/main/java/com/cqu/mqtt/conf/ +# ???linux??? +template.base.linuxPath=/opt/module/flume-1.9.0/jobs/phm + diff --git a/phm_rotate/backend/phm_backend/common/common-utils/src/main/java/com/cqu/utils/utils/MyPropertiesUtil.java b/phm_rotate/backend/phm_backend/common/common-utils/src/main/java/com/cqu/utils/utils/MyPropertiesUtil.java new file mode 100644 index 0000000..f5aecd8 --- /dev/null +++ b/phm_rotate/backend/phm_backend/common/common-utils/src/main/java/com/cqu/utils/utils/MyPropertiesUtil.java @@ -0,0 +1,29 @@ +package com.cqu.utils.utils; + +import java.io.IOException; +import java.io.InputStreamReader; +import java.util.Properties; + +/** + * @BelongsProject: phm_parent + * @BelongsPackage: com.cqu.utils.Utils + * @Author: markilue + * @CreateTime: 2022-11-18 17:41 + * @Description: TODO 读取配置文件信息的工具类 + * @Version: 1.0 + */ +public class MyPropertiesUtil { + + public static Properties load(String propertiesName){ + Properties properties = new Properties(); + try { + properties.load(new InputStreamReader(Thread.currentThread().getContextClassLoader(). + getResourceAsStream(propertiesName),"UTF-8")); + } catch (IOException e) { + System.err.println("配置文件不存在"); + throw new RuntimeException(e); + } + + return properties; + } +}