是我自己分的一个类吧，感觉和其他的不太一样
就是把输入的数组中的元素，分成几堆。
目前遇到这几个情况：
（1）这几堆值相同
（2）尽量分均匀，求其中的最大值，即最小的最大值

473. 火柴拼正方形

473. 火柴拼正方形
因为如果有很大的火柴，必然无法拼成正方形，所以排序之后，倒着遍历，能够大大大大提升效率：
image.png

  1. class Solution {
  2.     public boolean makesquare(int[] matchsticks) {
  3.         int sum=0;
  4.         int k=0;
  5.         for(int i:matchsticks) sum+=i;
  6.         if(sum%4!=0) return false;
  7.         else k=sum/4;
  8.         int[] path=new int[4];
  9.         Arrays.sort(matchsticks);
  10.         return backtrack(matchsticks.length-1,k,path,matchsticks);
  11.     }
  13.     private boolean backtrack(int i,int k,int[] path,int[] matchsticks){
  14.         if(i==-1){
  15.             return path[0]==path[1]&&path[1]==path[2]&&path[2]==path[3];
  16.         }
  17.         for(int j=0;j<path.length;j++){
  18.             if(path[j]+matchsticks[i]>k) continue;
  19.             path[j]+=matchsticks[i];
  20.             if(backtrack(i-1, k, path, matchsticks)) return true;
  21.             path[j]-=matchsticks[i];
  22.         }
  23.         return false;
  24.     }
  25. }

1723. 完成所有工作的最短时间

1723. 完成所有工作的最短时间
普通方法会超时。
用了一个HashSet来提高效率。

  1. class Solution {
  2.     int res=Integer.MAX_VALUE;
  3.     public int minimumTimeRequired(int[] jobs, int k) {
  4.         int[] worker=new int[k];
  5.         backtrack(0,0,worker,jobs);
  6.         return res;
  7.     }
  9.     private void backtrack(int i,int max,int[] worker,int[] jobs){
  10.         if(i==jobs.length){
  11.             res=Math.min(res,max);
  12.             return;
  13.         }
  14.         Set<Integer> set = new HashSet<>();
  15.         for(int j=0;j<worker.length;j++){
  16.             //同一层相同的值已经计算过了，就不需要在计算了，直接跳过
  17.             if(!set.add(worker[j])) continue;
  18.             if(worker[j]+jobs[i]>res) continue;
  19.             worker[j]+=jobs[i];
  20.             backtrack(i+1, Math.max(max,worker[j]), worker, jobs);
  21.             worker[j]-=jobs[i];
  22.         }
  23.     }
  24. }