[LC1152][Brute Force][Java]

Just follow what the problem description want us to do.

Author: xxks-kkk

docs/source/problems/leetcode.rst

@@ -156,7 +156,26 @@ Let's consider a few examples.
 Implementation wise, make sure the direction change is calculated correctly. For example, when the robot change from facing north to facing west. The direction vector changes
 from :math:`\langle 0,1 \rangle` to :math:`\langle -1,0 \rangle`. If the direction vector is :math:`\langle vec_x, vec_y \rangle`, then after the direction change, the direction vector
 becomes :math:`\langle -vec_y, vec_x \rangle`.
-      
+
+************************************
+1152. AnalyzeUserWebsiteVisitPattern
+************************************
+
+The brute force solution is sufficient for this problem. A few remarks:
+
+- We can use the following nested loops to generate all possible list of length 3 following the same ordering from a given list::
+
+        for (int i = 0; i < list.size(); i++) {
+                        for (int j = i + 1; j < list.size(); j++) {
+                                            for (int k = j + 1; k < list.size(); k++) {
+
+  In general, to generate all possible length :math:`k`, we need :math:`k` nested loops.
+
+- Be alert the case of "visit the same 3-seq in one user". That is , one user may visit the same pattern multiple times.
+
+- We don't have to sort timestamps and then username and website following the ordering of timestamp at the very beginning.
+  We can sort websites by timestamp for each individual user, e.g., ``list.sort(Comparator.comparingInt(a -> a.time));``
+  
 
 ******************************************************
 1481. Least Number of Unique Integers after K Removals

docs/source/topics/dp.rst

@@ -0,0 +1,7 @@
+.. _dp.rst:
+
+###################
+Dynamic Programming
+###################
+
+- :ref:`problems/leetcode:53. Maximum Subarray`

docs/source/topics/java.rst

@@ -29,6 +29,8 @@ Array
 - `extend each list inside a 2D list with one more element using lambda <https://github.com/xxks-kkk/shuati/blob/914af3077ebbbd55fe76fd2cea5aa667ebb54e4a/java/java-leetcode/src/main/java/ThreeSum.java#L50>`__.
   An example is: Given ``[[1,2],[3,4]]``, we add ``5`` to each list and obtain ``[[1,2,5],[3,4,5]]``.
 
+- `create List<String> from String[] <https://github.com/xxks-kkk/shuati/blob/74bc965b4f491e6ad81fc3afc3ea3748352b1a56/java/java-leetcode/src/main/java/AnalyzeUserWebsiteVisitPattern.java#L51-L53>`__  
+
 ========
 Hash Map
 ========

docs/source/topics/two-pointers.rst

@@ -0,0 +1,7 @@
+.. _two-pointers.rst:
+
+############
+Two Pointers
+############
+
+- :ref:`problems/leetcode:15. 3Sum`

java/java-leetcode/src/main/java/AnalyzeUserWebsiteVisitPattern.java

@@ -0,0 +1,68 @@
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+// LC-1152
+public class AnalyzeUserWebsiteVisitPattern
+{
+    public List<String> mostVisitedPattern(String[] username, int[] timestamp, String[] website)
+    {
+        Map<String, List<Pair>> map = new HashMap<>();
+        int n = username.length;
+        // collect the website info for every user, key: username, value: (timestamp, website)
+        for (int i = 0; i < n; i++) {
+            map.putIfAbsent(username[i], new ArrayList<>());
+            map.get(username[i]).add(new Pair(timestamp[i], website[i]));
+        }
+        // count map to record every 3 combination occurring time for the different user.
+        Map<String, Integer> count = new HashMap<>();
+        String res = "";
+        for (String key : map.keySet()) {
+            // this set is to avoid visit the same 3-seq in one user
+            Set<String> set = new HashSet<>();
+            List<Pair> list = map.get(key);
+            // sort by time (this avoids sort timestamp and then sort username, website following timestamp)
+            list.sort(Comparator.comparingInt(a -> a.time));
+            // brutal force O(N ^ 3)
+            for (int i = 0; i < list.size(); i++) {
+                for (int j = i + 1; j < list.size(); j++) {
+                    for (int k = j + 1; k < list.size(); k++) {
+                        String str = list.get(i).web + " " + list.get(j).web + " " + list.get(k).web;
+                        if (!set.contains(str)) {
+                            count.put(str, count.getOrDefault(str, 0) + 1);
+                            set.add(str);
+                        }
+                        if (res.equals("") ||
+                                count.get(res) < count.get(str) ||
+                                (Objects.equals(count.get(res), count.get(str)) && res.compareTo(str) > 0) /* make sure the right lexi order */) {
+                            res = str;
+                        }
+                    }
+                }
+            }
+        }
+        // grab the right answer
+        String[] r = res.split(" ");
+        List<String> result = new ArrayList<>();
+        Collections.addAll(result, r);
+        return result;
+    }
+
+    static class Pair
+    {
+        int time;
+        String web;
+
+        public Pair(int time, String web)
+        {
+            this.time = time;
+            this.web = web;
+        }
+    }
+}

java/java-leetcode/src/test/java/TestAnalyzeUserWebsiteVisitPattern.java

@@ -0,0 +1,46 @@
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+public class TestAnalyzeUserWebsiteVisitPattern
+{
+    private AnalyzeUserWebsiteVisitPattern analyzeUserWebsiteVisitPattern;
+
+    @BeforeAll
+    public void setUp()
+    {
+        analyzeUserWebsiteVisitPattern = new AnalyzeUserWebsiteVisitPattern();
+    }
+
+    private static Object[][] testAnalyzeUserWebsiteVisitPatternDataProvider()
+    {
+        return new Object[][] {
+                {new String[] {"joe", "joe", "joe", "james", "james", "james", "james", "mary", "mary", "mary"},
+                        new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+                        new String[] {"home", "about", "career", "home", "cart", "maps", "home", "home", "about", "career"},
+                        Arrays.asList("home", "about", "career")},
+                {new String[] {"ua", "ua", "ua", "ub", "ub", "ub"},
+                        new int[] {1, 2, 3, 4, 5, 6},
+                        new String[] {"a", "b", "a", "a", "b", "c"},
+                        Arrays.asList("a", "b", "a")}
+        };
+    }
+
+    @ParameterizedTest
+    @MethodSource("testAnalyzeUserWebsiteVisitPatternDataProvider")
+    public void testLeastNumberOfUniqueIntegersAfterKRemovals(String[] username, int[] timestamp, String[] website, List<String> expectation)
+    {
+        List<String> ret = analyzeUserWebsiteVisitPattern.mostVisitedPattern(username, timestamp, website);
+        assertEquals(expectation.size(), ret.size());
+        for (int i = 0; i < ret.size(); ++i) {
+            assertEquals(expectation.get(i), ret.get(i));
+        }
+    }
+}