写一下项目里怎么拿到BeanFactory

class Solution {
    public int findLucky(int[] arr) {
        int[] counts = new int[501];
        for(int a : arr) {
            counts[a]++;
        }
        for (int i = 500;i>=1;i--) {
            if (counts[i] == i) {
                return i;
            }
        }
        return -1;
    }
}

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        Queue<Integer> pqueue = new PriorityQueue<>((a,b)->(b-a));
        if (k == 0) {
            return new int[]{};
        }
        for (int i = 0; i < arr.length;i++) {
            if (i < k) {
                pqueue.offer(arr[i]);
                continue;
            }
            if (pqueue.peek() > arr[i]) {
                pqueue.poll();
                pqueue.offer(arr[i]);
            }
        }
        int[] res = new int[k];
        for (int i = 0; i < k;i++) {
            res[i] = pqueue.poll();
        }
        return res;
    }
}

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        randomizedSelected(arr, 0, arr.length - 1, k);
        int[] vec = new int[k];
        for (int i = 0; i < k; ++i) {
            vec[i] = arr[i];
        }
        return vec;
    }

    private void randomizedSelected(int[] arr, int l, int r, int k) {
        if (l >= r) {
            return;
        }
        int pos = randomizedPartition(arr, l, r);
        int num = pos - l + 1;
        if (k == num) {
            return;
        } else if (k < num) {
            randomizedSelected(arr, l, pos - 1, k);
        } else {
            randomizedSelected(arr, pos + 1, r, k - num);
        }
    }

    // 基于随机的划分
    private int randomizedPartition(int[] nums, int l, int r) {
        int i = new Random().nextInt(r - l + 1) + l;
        swap(nums, r, i);
        return partition(nums, l, r);
    }

    private int partition(int[] nums, int l, int r) {
        int pivot = nums[r];
        int i = l - 1;
        for (int j = l; j <= r - 1; ++j) {
            if (nums[j] <= pivot) {
                i = i + 1;
                swap(nums, i, j);
            }
        }
        swap(nums, i + 1, r);
        return i + 1;
    }

    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/zui-xiao-de-kge-shu-lcof/solution/zui-xiao-de-kge-shu-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode insertIntoMaxTree(TreeNode root, int val) {
        if (val > root.val) {
            TreeNode newRoot = new TreeNode(val);
            newRoot.left = root;
            return newRoot;
        }
        dfs(root, val, null, true);
        return root;
    }

    boolean dfs(TreeNode node, int val, TreeNode parent, boolean isLeft) {
        if (node == null || node.val < val) {
            TreeNode newNode = new TreeNode(val);
            if (isLeft) {
                parent.left = newNode;
            } else {
                parent.right = newNode;
            }
            newNode.left = node;
            return true;
        }

        if(dfs(node.right, val, node, false)  ) {
            return true;
        }
        return false;
    }
}

class Solution {
    public int monotoneIncreasingDigits(int n) {
        String s = String.valueOf(n);
        boolean is9 = false;
        int max = 0;
        char[] cs = new char[s.length()];
        for (int i = 0; i < s.length();i++) {
            if (is9) {
                cs[i] = '9';
                continue;
            }

            int num = s.charAt(i) - '0';

            if (i+1 < s.length() && num > s.charAt(i+1) - '0') {
                // 往前面找到可以满足减1的
                int j = i;
                while(j>=0&&num == s.charAt(j) - '0') {
                    j--;
                }
                j++;
                i = j;
                cs[i] = (char)(s.charAt(i) - 1);
                is9 = true;
            } else {
                cs[i] = (char)(num + '0');
                max = Math.max(num, max);
            }
        }
        return Integer.valueOf(new String(cs));
    }
}

class Solution {
    public int[] findErrorNums(int[] nums) {
       int xorSum = 0;
       for (int i = 0; i < nums.length;i++) {
           xorSum ^= (i+1);
           xorSum ^= nums[i];
       }
       int diffBit = xorSum & (-xorSum);
       int sum0 = 0, sum1 = 0;
       for (int i = 0; i < nums.length;i++) {
           if ((nums[i] & diffBit) > 0) {
               sum1 ^= nums[i];
           } else {
               sum0 ^= nums[i];
           }

           if (((i+1) & diffBit) > 0) {
               sum1 ^= (i+1) ;
           } else {
               sum0 ^= (i+1) ;
           }
       }

       for (int num : nums) {
           if (num == sum1) {
               return new int[]{sum1, sum0};
           } else if (num == sum0){
               return new int[]{sum0, sum1};
           }
       }
       return new int[]{};
    }
 
}

class Solution {
    public boolean backspaceCompare(String s, String t) {
        int si = s.length()-1, ti = t.length()-1;
        int spopCount = 0, tpopCount = 0;
        while(true) {
            while(si >=0 && (s.charAt(si) == '#' || spopCount > 0)) {
                if (s.charAt(si) == '#') {
                    spopCount++;
                } else {
                    spopCount--;
                }
                si--;
            }

            while(ti >=0 && (tpopCount >0 || t.charAt(ti) == '#')) {
                if (t.charAt(ti) == '#') {
                    tpopCount++;
                } else {
                    tpopCount--;
                }
                ti--;
            }
            if (si ==-1 && ti == -1) {
                return true;
            } else if (si == -1 || ti == -1) {
                return false;
            }
            if (si >=0 && ti >= 0 && s.charAt(si) != t.charAt(ti)) {
                return false;
            }
            si--;
            ti--;
        }
    }


}

int[] inCount = new int[k+1];
List<Integer>[] outLists = new List[k+1];
for (int i = 1; i <=k;i++) {
    outLists[i] = new ArrayList();
}
for (int[] row : rowConditions) {
    inCount[row[1]]++;
    outLists[row[0]].add(row[1]);
}
int y = 0;
boolean[] vis = new boolean[k+1];
int n = inCount.length; 
while (n-->0) {
    int i;
    for (i = 1; i <= k; i++) {
        if (inCount[i]  > 0 || vis[i]) {
            continue;
        }
        vis[i] = true;
        for (int out : outLists[i]) {
            inCount[out]--;
        }
        // 记录这个点
        break;
    }
}

List<Integer> result = new ArrayList<>();
while(!queue.isEmpty()) {
    int size = queue.size();
    List<Integer> needDeleteNodes = new ArrayList<>();
    needDeleteNodes.addAll(queue);
    queue.clear();
    // 要每次都更新这个result
    result = new ArrayList<>();
    for (int needDeleNode : needDeleteNodes) {
        result.add(needDeleNode);
        for (int nextNode : nextNodes[needDeleNode]) {
            // 不能delete
            edgCounts[nextNode]--;
            if (edgCounts[nextNode] == 1) {
                queue.offer(nextNode);
            }
        }
    }
}

class Solution {

    public int[] answerQueries(int[] nums, int[] queries) {
        Arrays.sort(nums);
        int[] res = new int[queries.length];
        for (int i = 0; i < queries.length;i++) {
            int sum = 0;
            int len = 0;
            for (int j = 0;j<nums.length;j++) {
                if (sum + nums[j] > queries[i]) {
                    break;
                }
                sum += nums[j];
                len++;
            }
            res[i] = len;
        }
        return res;
    }
}

class Solution {
    public String removeStars(String s) {
        boolean[] bs = new boolean[s.length()];
        int needDeduceCount = 0;
        for (int i = s.length()-1;i>=0;i--) {
            if (s.charAt(i) == '*') {
                needDeduceCount++;
                bs[i] = true;
            } else if (needDeduceCount > 0) {
                needDeduceCount--;
                bs[i] = true;
            }
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < s.length();i++) {
            if (bs[i]) {
                continue;
            }
            sb.append(s.charAt(i));
        }
        return sb.toString();
    }
}

class Solution {
  public int garbageCollection(String[] garbage, int[] travel) {
        char[] cs = new char[]{'G', 'P', 'M'};
        int res = 0;
        for (char c : cs) {
            int sum = 0;
            int realSum = 0;
            for (int i = 0; i < garbage.length; i++) {
                String garba = garbage[i];
                int count = 0;
                for (char g : garba.toCharArray()) {
                    if (g == c) {
                        count++;
                    }
                }
                if (count > 0) {
                    sum += count;
                    realSum = sum;
                }
                if (i != garbage.length-1) {
                    sum += travel[i];
                }
            }
            res += realSum;
        }
        return res;
    }
}

class Solution {
public int[][] buildMatrix(int k, int[][] rowConditions, int[][] colConditions) {
        int[] rows = new int[k+1];
        int[] cols = new int[k+1];
        if (!sort(k, rowConditions, rows) 
                ||  !sort(k, colConditions, cols)) {
            return new int[][]{};
        }
        
        int[][] res = new int[k][k];
        for (int i = 1; i <=k;i++) {
            res[rows[i]][cols[i]] = i;
        }
        return res;
    }

    private boolean sort(int k, int[][] rowConditions, int[] rows) {
        int[] inCount = new int[k+1];
        List<Integer>[] outLists = new List[k+1];
        for (int i = 1; i <=k;i++) {
            outLists[i] = new ArrayList();
        }
        for (int[] row : rowConditions) {
            inCount[row[1]]++;
            outLists[row[0]].add(row[1]);
        }
        int y = 0;
        boolean[] vis = new boolean[k+1];
        while (true) {
            int i;
            for (i = 1; i <= k; i++) {
                if (inCount[i]  > 0 || vis[i]) {
                    continue;
                }
                vis[i] = true;
                for (int out : outLists[i]) {
                    inCount[out]--;
                }
                rows[i] = y;
                y++;
                break;
            }
            if(i == k+1) {
                break;
            }
        }
        for (int i = 1;i<=k;i++) {
            if (inCount[i] >0) {
                return false;
            }
        }
        return true;
    }
}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    int res = 0;
    public int widthOfBinaryTree(TreeNode root) {
        dfs(root, 0, 0);
        return res;
    }
    Map<Integer, Integer> minHIndex = new HashMap<>();
    void dfs(TreeNode node, int index, int h) {
        if (node == null) {
            return;
        }
        if (!minHIndex.containsKey(h)) {
            minHIndex.put(h, index);
        }
        res = Math.max(index - minHIndex.get(h) + 1, res);
        

        dfs(node.left, index*2, h+1);
        dfs(node.right, index*2+1, h+1);
    }
}

class Solution {
    public int numFactoredBinaryTrees(int[] arr) {
        Arrays.sort(arr);
        int mod = 1000000007;
        Map<Integer, Long> map = new HashMap<>();
        long res = 0;
        for (int i = 0; i < arr.length;i++) {
            int big = arr[i];
            long count = 1;
            for (int j = i-1;j>=0;j--) {
                int numLeft = arr[j];
                if (big % numLeft != 0) {
                    continue;
                }
                int numRight = big / numLeft;
                if (!map.containsKey(numRight)) {
                    continue;
                }
                long count1 = map.get(numLeft);
                long count2 = map.get(numRight);
                count += count1 * count2;
                count %= mod;
            }
            map.put(big, count);
            res += count;
            res %= mod;
        }
        return (int)res;
    }
}

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode deleteDuplicatesUnsorted(ListNode head) {
        ListNode newHead = new ListNode(0);
        newHead.next = head;
        ListNode node = head;
        Map<Integer, Integer> map = new HashMap<>(); 
        while(node != null) {
            map.put(node.val, map.getOrDefault(node.val, 0) + 1);
            node = node.next;
        }
        ListNode lastNode = newHead;
        node = head;
        while(node != null) {
            if (map.get(node.val) > 1) {
                lastNode.next = node.next;
                node = node.next;
            } else {
                lastNode = node;
                node = node.next;
            }
        }
        return newHead.next;
    }
}

class Solution {
    Set<Integer> set = new HashSet<>();
    public int numColor(TreeNode root) {
        dfs(root);
        return set.size();
    }
    void dfs(TreeNode node) {
        if (node == null) {
            return;
        }
        set.add(node.val);
        dfs(node.left);
        dfs(node.right);
    }
}

class Solution {
    public boolean makesquare(int[] matchsticks) {
        int sum = Arrays.stream(matchsticks).sum();
        if (sum % 4!=0) {
            return false;
        }
        int[] vis = new int[matchsticks.length];
        Arrays.fill(vis,1);
        return dfs(vis, 
            matchsticks, new HashSet<>(), 0, sum/4);
        
    }

    boolean dfs(int[] vis, int[] matchsticks, Set<Integer> set, int nowSum, int target) {
        int k = 1;
        int sum = 0;
        for (int v :vis) {
            sum += v * k;
            k*=2;
        }

        if (nowSum == target) {
            nowSum = 0;
        } else if(nowSum > target) {
          set.add(sum);
            return false;
        }

        if (nowSum == 0 && sum == 0) {
            return true;
        }
        if (set.contains(sum)) {
            return false;
        }


        for (int i = 0; i < matchsticks.length;i++) {
            if (vis[i] == 0) {
                continue;
            }
            vis[i] = 0;
            if(dfs(vis, matchsticks, set, nowSum + matchsticks[i], target)) {
                return true;
            }
            vis[i] = 1;
        }
        set.add(sum);
        return false;
    }
}

class Solution {
    public int superpalindromesInRange(String left, String right) {
        dfs(0, new StringBuilder());
        Long leftNum = Long.valueOf(left);
        Long rightNum = Long.valueOf(right);
        int leftIndex = -1;
        int rightIndex = -1;
        res.add(1L);
        res.add(4L);
        res.add(9L);
        List<Long> list = new ArrayList<>(res);
        Collections.sort(list);
        System.out.println(list);
        for (int i = 0;i < res.size(); i++) {
            if (leftIndex == -1 && leftNum<= list.get(i)) {
                leftIndex = i;
            }
            if (rightIndex == -1 && rightNum <= list.get(i)) {
                rightIndex = i;
                break;
            }
        }
        if (rightIndex == -1) {
                    rightIndex = list.size();
        }
        System.out.println("right=" + rightIndex + ";left=" + leftIndex);
        return rightIndex - leftIndex;
    }
    Set<Long> res = new HashSet<>();
    void dfs(int index, StringBuilder sb) {
        if (index == 4) {
            String s = Integer.valueOf(sb.toString()).toString();
            if (s.equals("0")) {
                return;
            }
            for (char i = '0'; i <='9';i++) {
                String newS = s + i + new StringBuilder(s).reverse().toString();
                doPalid(newS);
            }
            String newS = s + new StringBuilder(s).reverse().toString();
            doPalid(newS);
            return;
        }
        for (char i = '0'; i <='9';i++) {
            dfs(index+1, sb.append(i));
            sb.deleteCharAt(sb.length()-1);
        }
    }

    public void doPalid(String newS) {
        Long newNum = Long.valueOf(newS);
        Long mulNum = newNum * newNum;
        // 看是否是回文数
        String mulNumS = String.valueOf(mulNum);
        if (mulNumS.equals(new StringBuilder().append(mulNumS).reverse().toString())) {
            res.add(mulNum);
        }
    }

}