
![image.png](/static/img/5e39f6e741ab1754cb82597f54dd8720.image.webp)

```java
class Solution {
    public int tribonacci(int n) {
        if (n == 0) return 0;
        if (n == 1 || n == 2) return 1;

        int[] dp = new int[n + 1];
        dp[0] = 0;
        dp[1] = 1;
        dp[2] = 1;

        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3];
        }

        return dp[n];
    }
}
````

![image.png](/static/img/b4c9d8dc97f3b4810536fdbb2d2aa7eb.image.webp)


```java
class Solution {
    public int rob(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        if (nums.length == 1) {
            return nums[0];
        }
        
        int n = nums.length;
        int[] dp = new int[n];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0], nums[1]);
        
        for (int i = 2; i < n; i++) {
            dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
        }
        
        return dp[n - 1];
    }

}
```



![image.png](/static/img/4b04702b1e8a7bd8111a22f824c849d2.image.webp)

```java
class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        int n = triangle.size();
        int[] dp = new int[n];
        
        // 初始化dp数组为三角形的最后一行
        for (int i = 0; i < n; i++) {
            dp[i] = triangle.get(n - 1).get(i);
        }
        
        // 从三角形的倒数第二行开始向上计算
        for (int i = n - 2; i >= 0; i--) {
            for (int j = 0; j <= i; j++) {
                // 状态转移方程
                dp[j] = Math.min(dp[j], dp[j + 1]) + triangle.get(i).get(j);
            }
        }
        
        // dp[0] 就是从顶部到底部的最小路径和
        return dp[0];
    }
}
```

今日刷题


![image.png](/static/img/c1831ee52daa441ecf1bd6d3da4c7913.image.webp)

```java

// 这是我乱搞的答案
class Solution {
    public int minimumRounds(int[] tasks) {
        int size = tasks.length + 1;
        int[] mid = new int[10000001];
        
        for(int i : tasks) {
            mid[i % mid.length]++;
        } 

   
        int res = 0;
        // System.out.println(mid[2]);
        for(int x : mid) {
            if(x == 1) {
                return -1;
            }
            
            if(x % 3 == 0) {
                res += (x/3);
            }else if(x % 3 == 1) {
                res += (x/3);
                res++;
            }else if(x % 3 == 2) {
                res += (x/3);
                res++;
            }

            
        }

        return res;
    }
}

//
public class Solution {
    public int minimumRounds(int[] tasks) {
        // 使用HashMap来统计每个难度级别的任务数量
        Map<Integer, Integer> taskCounts = new HashMap<>();
        for (int task : tasks) {
            taskCounts.put(task, taskCounts.getOrDefault(task, 0) + 1);
        }

        // 将HashMap中的元素转移到一个列表中，并根据任务数量对列表进行排序
        List<Map.Entry<Integer, Integer>> sortedEntries = new ArrayList<>(taskCounts.entrySet());
        sortedEntries.sort((a, b) -> b.getValue() - a.getValue());

        int rounds = 0;
        // 遍历排序后的列表
        for (Map.Entry<Integer, Integer> entry : sortedEntries) {
            int count = entry.getValue();
            // 如果任务数量为1，则无法完成，返回-1
            if (count == 1) {
                return -1;
            }
            // 计算完成当前难度级别任务所需的轮数
            rounds += (count + 2) / 3;
        }

        return rounds;
    }
}




```


![image.png](/static/img/b65cb9326a2a647aac8452e1f165514b.image.webp)

```java
public class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        // 使用HashMap来记录每个元素出现的频率
        Map<Integer, Integer> frequencyMap = new HashMap<>();
        for (int num : nums) {
            frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
        }

        // 创建一个最小堆来存储元素及其频率
        PriorityQueue<Map.Entry<Integer, Integer>> minHeap = new PriorityQueue<>(
                Map.Entry.comparingByValue()
        );

        // 遍历HashMap，将元素及其频率添加到最小堆中
        for (Map.Entry<Integer, Integer> entry : frequencyMap.entrySet()) {
            minHeap.offer(entry);
            if (minHeap.size() > k) {
                minHeap.poll(); // 如果堆的大小超过k，移除堆顶元素
            }
        }

        // 从最小堆中取出所有元素，这些元素就是出现频率前k高的元素
        int[] result = new int[k];
        for (int i = 0; i < k; i++) {
            result[i] = minHeap.poll().getKey();
        }
        return result;
    }
}

```



![image.png](/static/img/ed6e8d4972897dceb7a6b78f43d15100.image.webp)

```java
class Solution {
    public char findTheDifference(String s, String t) {
        int[] mid1 = new int[128];
        int[] mid2 = new int[128];
        char res = ' ';
        for(char a : s.toCharArray()) {
            mid1[a] ++;
        }

        for(char a : t.toCharArray()) {
            // 
            mid2[a] ++;
        }

        for(int i = 0;i < 128;i++) {
            if(mid1[i] != mid2[i]) {
                res = (char)i;
            }
        }

        return res;
    }
}

public class Solution {
    public char findTheDifference(String s, String t) {
        int[] charCount = new int[26];
        // 计算s中每个字母的出现次数
        for (int i = 0; i < s.length(); i++) {
            charCount[s.charAt(i) - 'a']++;
        }
        // 减去t中每个字母的出现次数
        for (int i = 0; i < t.length(); i++) {
            charCount[t.charAt(i) - 'a']--;
        }
        // 找到第一个计数不为0的字母
        for (int i = 0; i < charCount.length; i++) {
            if (charCount[i] != 0) {
                return (char) (i + 'a');
            }
        }
        return ' '; // 如果没有找到，返回一个空格字符
    }
}


```



![image.png](/static/img/d0b1c14a3b9c8a1a9cb9743c78a836f0.image.webp)

```java
public class Solution {
    public String multiply(String num1, String num2) {
         if (num1.equals("0") || num2.equals("0")) {
             return "0";
           }

         int[] result = new int[num1.length() + num2.length()];

         for (int i = num1.length() - 1; i >= 0; i--) {
              for (int j = num2.length() - 1; j >= 0; j--) {
                   int mul = (num1.charAt(i) - '0') * (num2.charAt(j) - '0');
                   int p1 = i + j, p2 = i + j + 1;
                   int sum = mul + result[p2];

                   result[p2] = sum % 10;
                   result[p1] += sum / 10;
               }
           }

         StringBuilder sb = new StringBuilder();
          for (int i = 0; i < result.length; i++) {
               if (i == 0 && result[i] == 0) {
                   continue;
               }
               sb.append(result[i]);
           }

          return sb.toString();
       }
}


```



![image.png](/static/img/7817fb7a3e548bdb3680ad73ec9b5980.image.webp)

```java
public class Solution {
    public String[] findRestaurant(String[] list1, String[] list2) {
         Map<String, Integer> indexMap = new HashMap<>();
         for (int i = 0; i < list1.length; i++) {
              indexMap.put(list1[i], i);
          }

         int minIndexSum = Integer.MAX_VALUE;
         List<String> commonRestaurants = new ArrayList<>();

         for (int i = 0; i < list2.length; i++) {
              if (indexMap.containsKey(list2[i])) { // 共同爱好
                  int indexSum = i + indexMap.get(list2[i]); // 计算索引和
                  if (indexSum < minIndexSum) { //是否是最小索引和
                      minIndexSum = indexSum;
                       commonRestaurants.clear();
                       commonRestaurants.add(list2[i]);
                   } else if (indexSum == minIndexSum) {
                       commonRestaurants.add(list2[i]);
                   }
               }
           }
        return commonRestaurants.toArray(new String[0]);
         //return commonRestaurants.toArray(new String[0]);
       }
}


```



![image.png](/static/img/d70e27c05e307837cd9eff227e3cd85f.image.webp)

```java
public class Solution {
    public int coinChange(int[] coins, int amount) {
          // 初始化一个比amount大的数，表示无法凑成的金额
          int max = amount + 1;
          // 初始化dp数组，所有值设为最大值
          int[] dp = new int[amount + 1];
          Arrays.fill(dp, max);
          // 金额为0时，不需要任何硬币
          dp[0] = 0;

          // 遍历所有金额
          for (int i = 1; i <= amount; i++) {
               // 遍历所有硬币
               for (int coin : coins) {
                    // 如果当前金额大于等于硬币面值
                    if (i >= coin) {
                         // 更新dp[i]为dp[i]和dp[i - coin] + 1的最小值
                         dp[i] = Math.min(dp[i], dp[i - coin] + 1);
                    }
               }
          }

          // 如果dp[amount]没有被更新过，说明无法凑成该金额
          return dp[amount] == max ? -1 : dp[amount];
      }
}






```




远程服务器重装系统，ssh报错

![image.png](/static/img/92394867f0d14ec5d1573695f1edff0f.image.webp)

证书无效，需要清除缓存重新连接
```
ssh-keygen -R ip
```

ssh标识证书失效


![image.png](/static/img/73de0bb4a574cddf50cf9507f11220e2.image.webp)

思路都在注释里，就是bfs层序遍历

```java
class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> averages = new ArrayList<>(); //答案数组 
        if (root == null) {  //特判
            return averages; 
        }

        Queue<TreeNode> queue = new LinkedList<>(); //bfs队列
        queue.offer(root); //根结点入队

        while (!queue.isEmpty()) {
              int levelSize = queue.size();
              double sum = 0;
              for (int i = 0; i < levelSize; i++) {  //入队并计算
                  TreeNode node = queue.poll();
                  sum += node.val;
                  if (node.left != null) {
                      queue.offer(node.left);
                  }
                  if (node.right != null) {
                      queue.offer(node.right);
                  }
              }
              averages.add(sum / levelSize);
          }

        return averages;

    }
}
```

![image.png](/static/img/d3473bc81fc37facd3b1aa2349f259e0.image.webp)
```java
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
                 int lenA = 0, lenB = 0;
         ListNode tempA = headA, tempB = headB;

         // 计算两个链表的长度
         while (tempA != null) {
              lenA++;
               tempA = tempA.next;
           }
         while (tempB != null) {
              lenB++;
               tempB = tempB.next;
           }

         // 对齐链表
         tempA = headA;
         tempB = headB;
         if (lenA > lenB) {
              for (int i = 0; i < lenA - lenB; i++) {
                   tempA = tempA.next;
               }
           } else {
               for (int i = 0; i < lenB - lenA; i++) {
                   tempB = tempB.next;
               }
           }

         // 遍历链表，找到相交节点
         while (tempA != null && tempB != null) {
               if (tempA == tempB) {
                   return tempA;
               }
               tempA = tempA.next;
               tempB = tempB.next;
           }

         return null;
       

    }
}
```

![image.png](/static/img/ca4827df78ed637d3db12e838d5bba48.image.webp)

```java
class Solution {
    public boolean isSymmetric(TreeNode root) {
        return isMirror(root.left,root.right);
    }

    private boolean isMirror(TreeNode t1, TreeNode t2) {
        if (t1 == null && t2 == null) return true;
        if (t1 == null || t2 == null) return false;
        return (t1.val == t2.val)
        && isMirror(t1.right, t2.left)
        && isMirror(t1.left, t2.right);
    }

}
```
