欢迎使用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 Tree
class 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");

    }
}