2017年10月26日

Author: lxfgit

.idea/findbugs-idea.xml

@@ -0,0 +1,21 @@
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Scanner;
+
+/**
+ * Created by LXF on 2017/8/15.
+ */
+public class CodeSort {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int n = scanner.nextInt();
+        ArrayList<String> arrayLists = new ArrayList<>();
+        while (n-->0) {
+            arrayLists.add(scanner.next());
+        }
+        Collections.sort(arrayLists);
+        for (String arrayList : arrayLists) {
+            System.out.println(arrayList);
+        }
+    }
+}

.idea/misc.xml

@@ -0,0 +1,73 @@
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * Created by LXF on 2017/8/11.
+ */
+public class Dche {
+    public static int qTime(int taxiNum, int[] heng, int[] zong, Point gs, int wt, int tt) {
+
+        HashMap<Point, Integer> taxi = new HashMap<Point, Integer>();
+        int n = heng.length;
+        int zouLu = (Math.abs(gs.x) + Math.abs(gs.y)) * wt;
+        if (n == 0) {
+            return (wt > tt ? tt : wt) * (gs.x + gs.y);
+        }
+        for (int i = 0; i < n; i++) {
+            Point point = new Point(heng[i], zong[i]);
+            taxi.put(point, 0);
+        }
+
+        Iterator map = taxi.entrySet().iterator();
+        while (map.hasNext()) {
+            Map.Entry entry = (Map.Entry) map.next();
+            Point point  = (Point) entry.getKey();
+            int zouD = (Math.abs(point.x) + Math.abs(point.y)) * wt;
+            int dacheD = Math.abs((gs.x-point.x) + Math.abs(gs.y-point.y)) * tt;
+            entry.setValue(Math.min(zouLu, zouD + dacheD));
+        }
+        int min = Integer.MAX_VALUE;
+        Iterator iter = (Iterator) taxi.values();
+        while (iter.hasNext()) {
+            int d = (int) iter.next();
+            min = Math.min(min, d);
+        }
+        return min;
+    }
+
+
+    static class Point{
+        int x;
+        int y;
+
+        public Point(int x, int y) {
+            this.x = x;
+            this.y = y;
+        }
+    }
+
+    public static void main(String[] args) {
+//        Scanner scanner = new Scanner(System.in);
+//        int n = scanner.nextInt();
+//        String[] h = scanner.nextLine().toCharArray().toString().split(" ");
+//        String[] z = scanner.nextLine().toCharArray().toString().split(" ");
+//        int x = scanner.nextInt();
+//        int y = scanner.nextInt();
+        Point gs = new Point(-4, -2);
+        int[] heng = new int[]{-2,-2};
+        int[] zong = new int[]{0,-2};
+//
+//        for (int i = 0;i<n;i++) {
+//            heng[i] = Integer.parseInt(h[i]);
+//            zong[i] = Integer.parseInt(z[i]);
+//        }
+//        int w = scanner.nextInt();
+//        int t = scanner.nextInt();
+
+        int n = 2;
+
+        System.out.println(qTime(n, heng, zong, gs, 15, 3));
+    }
+
+}

src/CodeSort.java

@@ -0,0 +1,55 @@
+/**
+ * Created by LXF on 2017/8/10.
+ */
+import java.util.Scanner;
+
+public class Main {
+
+/** 请完成下面这个函数，实现题目要求的功能 **/
+    /** 当然，你也可以不按照这个模板来作答，完全按照自己的想法来 ^-^  **/
+//    static int maxScore(int[] score) {
+//        int[] max = new int[score.length];
+//      for(int i=0;i<score.length;i++) {
+//          if (score[i]!=0) {
+//              if (i - 1 < 0 || score[i] == 0||score[i+1]>) {
+//                  int left = 1;
+//              }
+//          }
+//      }
+//
+//    }
+    static int maxScore(int[] score) {
+        int n = score.length;
+        int[] nums = new int[n + 2];
+        for (int i = 0; i < n; i++)
+            nums[i + 1] = score[i];
+        nums[0] = nums[n + 1] = 1;
+        int[][] alibaba = new int[n + 2][n + 2];
+        for (int k = 1; k <= n; k++) {
+            for (int i = 1; i <= n - k + 1; i++) {
+                int j = i + k - 1;
+                for (int x = i; x <= j; x++) {
+                    alibaba[i][j] = Math.max(alibaba[i][j], alibaba[i][x - 1] + nums[i - 1] * nums[x] * nums[j + 1] + alibaba[x + 1][j]) ;
+                }
+            }
+        }
+        return alibaba[1][n];
+    }
+    public static void main(String[] args){
+        Scanner in = new Scanner(System.in);
+        int res;
+
+        int _score_size = 0;
+        _score_size = Integer.parseInt(in.nextLine().trim());
+        int[] _score = new int[_score_size];
+        int _score_item;
+        for(int _score_i = 0; _score_i < _score_size; _score_i++) {
+            _score_item = Integer.parseInt(in.nextLine().trim());
+            _score[_score_i] = _score_item;
+        }
+
+        res = maxScore(_score);
+        System.out.println(String.valueOf(res));
+
+    }
+}

src/Dche.java

@@ -0,0 +1,31 @@
+import org.junit.Test;
+
+import java.util.*;
+
+/**
+ * Created by LXF on 2017/8/12.
+ */
+public class Main1 {
+
+    public List<List<Integer>> subsets(int[] nums) {
+        List<List<Integer>> list = new ArrayList<>();
+        Arrays.sort(nums);
+        backtrack(list, new ArrayList<>(), nums, 0);
+        return list;
+    }
+
+    void backtrack(List<List<Integer>> list , List<Integer> tempList, int [] nums, int start) {
+        list.add(new ArrayList<>(tempList));
+        for (int i = start; i < nums.length; i++) {
+            tempList.add(nums[i]);
+            backtrack(list, tempList, nums, i + 1);
+            tempList.remove(tempList.size() - 1);
+        }
+    }
+
+    @Test
+    public void test() {
+        List<List<Integer>> result = subsets(new int[]{1, 2, 3, 4});
+        System.out.println(result);
+    }
+}

src/Main.java

@@ -0,0 +1,36 @@
+/**
+ * Created by LXF on 2017/8/15.
+ */
+public class Main10 {
+    public static void main(String[] args) {
+        int[] array = new int[]{0, 1, 2, 3, 4, 5};
+        int n = array.length;
+        int[] isdel = new int[n];
+        int k = 0;
+        for (int i = 0; ; i = (i+1) % n) {
+            if (isdel[i] == 0) {
+                k++;
+            }
+            if (k == 3) {
+                isdel[i]=1;
+                k=0;
+                if (getSum(isdel) == n-1) {
+                    break;
+                }
+            }
+        }
+        for (int i = 0; i < n; i++) {
+            if (isdel[i] == 0) {
+                System.out.println(i);
+            }
+        }
+    }
+
+    public static int getSum(int[] a) {
+        int sum = 0;
+        for (int i : a) {
+            sum += i;
+        }
+        return sum;
+    }
+}

src/Main1.java

@@ -0,0 +1,41 @@
+import java.io.Serializable;
+import java.util.Scanner;
+
+/**
+ * Created by LXF on 2017/8/15.
+ */
+public class Main11 implements Serializable {
+    public static int get(int n) {
+        if (n < 2) {
+            return 0;
+        }
+        if (n == 2) {
+            return 1;
+        }
+        int k = n / 3;
+        return k + get(n % 3+k);
+    }
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int[] n = new int[10];
+        for (int i = 0; i < 10; i++) {
+            int c;
+            if ((c=scanner.nextInt()) != 0) {
+                n[i] = c;
+            } else {
+                break;
+            }
+        }
+
+        for (int i = 0; i < n.length; i++) {
+            if (n[i] != 0) {
+                if (n[i] < 2) {
+                    System.out.println(0);
+                } else {
+                    System.out.println(get(n[i]));
+                }
+            }
+        }
+    }
+}

src/Main10.java

@@ -0,0 +1,46 @@
+import java.util.ArrayList;
+import java.util.Scanner;
+
+public class Main12 {
+    static private final int POINT_NUM = 9;
+    static private int[][] e = new int[Integer.MAX_VALUE/20000][Integer.MAX_VALUE/20000];
+
+
+    static ArrayList<Integer> trace=new ArrayList<Integer>();
+    static boolean hasCycle=false;
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        String str = scanner.nextLine();
+        String[] s = str.split(",");
+        System.out.println(s.length);
+
+        MouldeIsCycularDependecy(0);
+        if(!hasCycle)
+            System.out.println("No Cycle.");
+    }
+
+    static void AddDependency(int mId, int dId) {
+        e[mId][dId] = 1;
+    }
+
+    static boolean MouldeIsCycularDependecy(int v) {
+        int j;
+        if((j=trace.indexOf(v))!=-1) {
+            hasCycle=true;
+            return hasCycle;
+        }
+        trace.add(v);
+
+        for(int i=0;i<POINT_NUM;i++)
+        {
+            if(e[v][i]==1)
+                MouldeIsCycularDependecy(i);
+        }
+        trace.remove(trace.size()-1);
+        if (trace.size() == 1) {
+            return hasCycle;
+        }
+        return hasCycle;
+    }
+}

src/Main11.java

@@ -0,0 +1,33 @@
+import java.util.Scanner;
+
+/**
+ * Created by LXF on 2017/8/12.
+ */
+public class Main2 {
+
+    public static int getMaxNum(String str) {
+        int max = 0;
+        int i = 0;
+        while (i+1 < str.length()) {
+            int count = 0;
+            int j = i;
+            while (j+1 < str.length()) {
+                if (str.charAt(j) - str.charAt(j + 1) != 0) {
+                    j++;
+                    count++;
+                }
+                else
+                    break;
+            }
+            max = Math.max(max, count+1);
+            i = j+1;
+        }
+        return max;
+    }
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        String string = scanner.nextLine();
+        System.out.println(getMaxNum(string));
+    }
+}