欢迎使用CSDN-markdown编辑器

Window sum

/* package whatever; // don't place package name! */import java.io.*;import java.util.*;class myCode{    public static ArrayList<Integer> getWindowSize(int[] nums,int k){        if(nums.length==0||nums==null){            return new ArrayList<Integer>();        }        if(k<0||k>nums.length){            return null;        }        ArrayList<Integer> list = new ArrayList<>();        int sum = 0;        for(int i=0;i<nums.length;i++){            sum += nums[i];            if(i-k+1>=0){                list.add(sum);                sum -= nums[i-k+1];            }        }         return list;      }     public static void main (String[] args) throws java.lang.Exception    {        int[] nums = {1,1,2,3,4,5};        if(getWindowSize(nums,-1)==null)             System.out.println("null");            return;    }}

Company Tree

/* package whatever; // don't place package name! */import java.io.*;import java.util.*;//company Treeclass ResultWrapper{        int sum;        int num;        double maxAvg;        public ResultWrapper(int sum,int num,double maxAvg){            this.sum = sum;            this.num = num;            this.maxAvg = maxAvg;        }} class Node{        public int val;        ArrayList<Node> children = new ArrayList<>();               public Node(int val){            this.val = val;        } }class myCode    {   public static Node getMaxAvg(Node root){        if(root==null) return null;        Node[] ans = new Node[1];        dfs(root,ans);        return ans[0];    }public static ResultWrapper dfs(Node root,Node[] ans){        int sum = root.val;        int num = 1;        double maxAvg = Integer.MIN_VALUE;               if(root.children==null||root.children.size()==0){            return new ResultWrapper(sum,num,maxAvg);        }        for(Node node:root.children){            ResultWrapper res = dfs(node,ans);            sum += res.sum;            num += res.num;            maxAvg = Math.max(maxAvg,res.maxAvg);        }        double curAvg = (double)sum/num;        if(curAvg>maxAvg){            maxAvg = curAvg;            System.out.println(maxAvg);            ans[0] = root;        }        return new ResultWrapper(sum,num,maxAvg);    } public static void main (String[] args) throws java.lang.Exception    {        Node n1 = new Node(1);        Node n2 = new Node(2);        Node n3 = new Node(3);        Node n4 = new Node(4);        n1.children.add(n2);        n1.children.add(n3);        n1.children.add(n4);        Node n5 = new Node(5);        Node n6 = new Node(6);        Node n7 = new Node(7);        n2.children.add(n5);        n2.children.add(n6);        n2.children.add(n7);        Node res = getMaxAvg(n1);             System.out.println(res.val);        System.out.println("Hello Java");    }}

Order Dependency

/* package whatever; // don't place package name! */import java.io.*;import java.util.*;class Order{    String order = "";    public Order(String order){        this.order = order;    }}class Order_Dependency{    Order cur;    Order pre;    public Order_Dependency(Order cur,Order pre){         this.cur = cur;         this.pre = pre;    }}class myCode    {    public static List<Order> getOrders(List<Order_Dependency> Order_Dependencies){    List<Order> result = new ArrayList<Order>();    // record the graph's nodes indegree    HashMap<Order,Integer> mapIn = new HashMap<>();    // record the graph's node's post nodes    HashMap<Order,ArrayList<Order>> mapOut = new HashMap<>();    HashSet<Order> set = new HashSet<>();          for(Order_Dependency order_dd:Order_Dependencies){        Order pre = order_dd.pre;        Order cur = order_dd.cur;        set.add(pre);        set.add(cur);        if(!mapOut.containsKey(pre)){            ArrayList<Order> list = new ArrayList<Order>();            list.add(cur);            mapOut.put(pre,list);           // mapOut.get([pre]).add()        }        else{            mapOut.get(pre).add(cur);        }        if(!mapOut.containsKey(cur)){            mapOut.put(cur,new ArrayList<Order>());        }        if(!mapIn.containsKey(cur)){            mapIn.put(cur,1);        }        else{            mapIn.put(cur,mapIn.get(cur)+1);        }        if(!mapIn.containsKey(pre)){            mapIn.put(pre,0);        }    }    Queue<Order> queue = new LinkedList<Order>();    for(Order order:mapIn.keySet()){        int indegree = mapIn.get(order);        if(indegree==0) queue.offer(order);    }    while(!queue.isEmpty()){        Order temp = queue.poll();        result.add(temp);        for(Order testOrder:mapOut.get(temp)){             int indegreeOftest = mapIn.get(testOrder)-1;             if(indegreeOftest==0){                 queue.offer(testOrder);             }        }    }        System.out.println(result.size());    if(result.size()!=set.size()) return new ArrayList<Order>();           return result;    }         public static void main (String[] args) throws java.lang.Exception    {        Order o1 = new Order("A");        Order o2 = new Order("B");        Order o3 = new Order("C");        Order o4 = new Order("D");        List<Order_Dependency> list = new ArrayList<>(            Arrays.asList(                new Order_Dependency(o1, o2),                new Order_Dependency(o2, o3),                new Order_Dependency(o1, o4)        )    );    for (Order o : getOrders(list)){          System.out.println(o.order);            }        System.out.println("Hello Java");    }    }

Random List(deep copy)

public class Solution {    public RandomListNode copyRandomList(RandomListNode head) {        if(head==null) return null;    HashMap<RandomListNode,RandomListNode> map = new HashMap<>();    RandomListNode newHead = new RandomListNode(head.label);    map.put(head,newHead);    RandomListNode p = head;    RandomListNode q = newHead;    p = p.next;    while(p!=null){        RandomListNode temp = new RandomListNode(p.label);        map.put(p,temp);        q.next = temp;        q = temp;        p = p.next;    }    p = head;    q = newHead;    while(p!=null){     if(p.random!=null){            q.random = map.get(p.random);     }     else{            q.random = null;      }        p = p.next;        q = q.next;    }    return newHead;  }}

K nearest positions

public class Point {    int x;    int y;    public Point(int x,int y){        this.x = x;        this.y = y;    }    public int getdistance(Point p1,Point p2){        return (p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y);    }}public class getKnearestPoints {    public Point[] getKnearestPoints(Point[] points,int k){        if(points==null||points.length==0) return points;        if(k<0) return null;        Point original = new Point(0,0);        Arrays.sort(points, new Comparator<Point>() {            public int compare(Point p1, Point p2) {                return p1.getdistance(p1,original) - p2.getdistance(p2,original);            }        });        ArrayList<Point> list = new ArrayList<Point>();        Point[] res = new Point[k];        if(points.length<k) return points;        for(int i=0;i<k;i++){            res[i] = points[i];        }        return res;    }}

看是不是回文串

public static isPalindrom(String s){           if(s==null||s.length()==0) return "";       int n = s.length();       boolean[][] dp = new boolean[n][n];       int end = 0;       int start = 0;       for(int i=n-1;i>=0;i++){          for(int j=i;j<s.length();j++){            if(i==j){                dp[i][j] = true;            }            else if(j = i+1){                dp[i][j] = s.charAt(i)==s.charAt(j);            }            else{                dp[i][j] = dp[i-1][j+1]&&s.charAt(i)==s.charAt(j);            }            if(dp[i][j]&&j-i>end-start){                end = j;                start = i;            }         }      }      return s.substring(start,end+1);}

City Connection

/* package whatever; // don't place package name! */import java.io.*;import java.util.*;class Connection{    String city1;    String city2;    int cost;    public Connection(String city1,String city2,int cost){        this.city1 = city1;        this.city2 = city2;        this.cost = cost;    }}class myCode{    public static List<Connection> getshorstDistance(List<Connection> list){         List<Connection> res = new ArrayList<>();         if(list==null||list.size()==0) return res;        Collections.sort(list,new Comparator<Connection>(){            public int compare(Connection c1,Connection c2){                return c1.cost-c2.cost;            }        });        HashMap<String,Integer> unionMap = new HashMap<String,Integer>();        int[] cityNo = new int[1];        for(Connection connection: list){            String city1 = connection.city1;            String city2 = connection.city2;            if(union(unionMap,cityNo,city1,city2)){                                res.add(connection);                         }            }        if(!allConnected(res,unionMap)) return null;        Collections.sort(res,new Comparator<Connection>(){            public int compare(Connection o1,Connection o2){                if(o1.city1.equals(o2.city1)){                    return o1.city2.compareTo(o2.city2);                }                return o1.city2.compareTo(o2.city2);                }        });        return res;        }    public static boolean allConnected(List<Connection> list,HashMap<String,Integer> map){           int aU = map.get(list.get(0).city1);           for(String key:map.keySet()){               if(map.get(key)!=aU)  return false;           }        return true;    }    public static boolean union(HashMap<String,Integer> map,int[] cityNo,String city1,String city2){        if(!map.containsKey(city1)&&!map.containsKey(city2)){            map.put(city1,cityNo[0]);            map.put(city2,cityNo[0]);            cityNo[0]++;            return true;        }        if(!map.containsKey(city1)&&map.containsKey(city2)){            int city2U = map.get(city2);            map.put(city1,city2U);            return true;        }        if(map.containsKey(city1)&&!map.containsKey(city2)){            int city1U = map.get(city1);            map.put(city2,city1U);            return true;        }        int city1U = map.get(city1);        int city2U = map.get(city2);        if(city1U==city2U) return false;        for(String s:map.keySet()){                     if(map.get(s)==city2U) map.put(s,city1U);        }        return true;    }    public static void main (String[] args) throws java.lang.Exception    {    List<Connection> connections = new ArrayList<>(Arrays.asList(      new Connection("A", "B", 6),      new Connection("B", "C", 4),      new Connection("C", "D", 5),      new Connection("E", "F", 2),      new Connection("E", "A", 2)    ));    for (Connection c : getshorstDistance(connections)){        System.out.printf("%s <-> %s (%d)\n", c.city1, c.city2, c.cost);    }        System.out.println("Hello Java");    }}