Page 7 of 61

油猴脚本,抓取LeetCode题解

用来抓取自己之前写的LeetCode刷题写的题解

// ==UserScript==
// @name         LeetCode Test
// @namespace    http://tampermonkey.net/
// @version      0.1
// @description  try to take over the world!
// @author       You
// @match        https://leetcode.cn/problems/*/solution/*
// @grant        none
// ==/UserScript==





(function() {
    'use strict';
    let createButton = (func, btnText, top) => {
        let btn = document.createElement("button")
        btn.style.position = "fixed"
        btn.style.right = 0
        // btn.style.top='30%'
        btn.style.top = top
        btn.style.padding = "10px"
        btn.style.zIndex = 99999
        btn.innerText = btnText
        btn.addEventListener("click", func)
        document.body.append(btn)
    }

    let dbName = 'solutionArticle', version = 1, storeName = 'mySolution'

    let indexedDB = window.indexedDB
    let db
    const request = indexedDB.open(dbName, version)
    request.onsuccess = function(event) {
        db = event.target.result // 数据库对象
        console.log('数据库打开成功')
    }

    request.onerror = function(event) {
        console.log('数据库打开报错')
    }

    request.onupgradeneeded = function(event) {
        // 数据库创建或升级的时候会触发
        console.log('onupgradeneeded')
        db = event.target.result // 数据库对象
        let objectStore
        if (!db.objectStoreNames.contains(storeName)) {
            objectStore = db.createObjectStore(storeName, { keyPath: 'questionFrontendId' }) // 创建表
            // objectStore.createIndex('name', 'name', { unique: true }) // 创建索引 可以让你搜索任意字段
        }
    }
    let saveToIndeDB = (data)=>{
        let request = db.transaction([storeName], 'readwrite') // 事务对象 指定表格名称和操作模式("只读"或"读写")
        .objectStore(storeName) // 仓库对象
        .add(data)

        request.onsuccess = function(event) {
            console.log('数据写入成功')
        }

        request.onerror = function(event) {
            console.log('数据写入失败')
            throw new Error(event.target.error)
        }
    }
    let cursorGetData = () =>{
        let list = []
        let store = db.transaction(storeName, 'readwrite') // 事务
        .objectStore(storeName) // 仓库对象
        let request = store.openCursor() // 指针对象
        return new Promise((resolve, reject) => {
            request.onsuccess = function(e) {
                let cursor = e.target.result
                if (cursor) {
                    // 必须要检查
                    list.push(cursor.value)
                    cursor.continue() // 遍历了存储对象中的所有内容
                } else {
                    resolve(list)
                }
            }
            request.onerror = function(e) {
                reject(e)
            }
        })
    }

    createButton( ()=>{
        cursorGetData().then(list=>{
            console.log(list)
        })
    } , "列表", "160px")




    let key = ''
    let addLocal = (k,v)=>{
        let oldJson = localStorage.getItem(key)
        if(null==oldJson){
            oldJson = {}
        }else{
            oldJson = JSON.parse(oldJson);
        }
        oldJson[k] = v;
        localStorage.setItem(key,JSON.stringify(oldJson))
    }
    let getQuestion = (slug)=>{
        let p = {
            "operationName":"questionData",
            "variables":{"titleSlug":slug},
            "query":"query questionData($titleSlug: String!) {\n  question(titleSlug: $titleSlug) {\n    questionId\n    questionFrontendId\n    categoryTitle\n    boundTopicId\n    title\n    titleSlug\n    content\n    translatedTitle\n    translatedContent\n    isPaidOnly\n    difficulty\n    likes\n    dislikes\n    isLiked\n    similarQuestions\n    contributors {\n      username\n      profileUrl\n      avatarUrl\n      __typename\n    }\n    langToValidPlayground\n    topicTags {\n      name\n      slug\n      translatedName\n      __typename\n    }\n    companyTagStats\n    codeSnippets {\n      lang\n      langSlug\n      code\n      __typename\n    }\n    stats\n    hints\n    solution {\n      id\n      canSeeDetail\n      __typename\n    }\n    status\n    sampleTestCase\n    metaData\n    judgerAvailable\n    judgeType\n    mysqlSchemas\n    enableRunCode\n    envInfo\n    book {\n      id\n      bookName\n      pressName\n      source\n      shortDescription\n      fullDescription\n      bookImgUrl\n      pressImgUrl\n      productUrl\n      __typename\n    }\n    isSubscribed\n    isDailyQuestion\n    dailyRecordStatus\n    editorType\n    ugcQuestionId\n    style\n    exampleTestcases\n    jsonExampleTestcases\n    __typename\n  }\n}\n"
        }
        let options = {
            method: 'POST',
            headers: {
                'Accept': 'application/json',
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(p)
        }
        fetch("https://leetcode.cn/graphql/",options).then((res)=>{
            if(res.ok){
                //如果取数据成功
                res.json().then((data)=>{
                    //转化为json数据进行处理
                    console.log(data.data)
                    let question = data.data.question
                    addLocal('questionTitle',question.translatedTitle)
                    addLocal('questionFrontendId',question.questionFrontendId)
                    addLocal('questionFullTittle',"LeetCode刷题【"+question.questionFrontendId+"】"+question.translatedTitle)
                    let questionContentAppend = "<div>Related Topics</div><div><ul>"
                    let questionTags = [];
                    for(let tag of question.topicTags){
                        questionTags.push(tag.translatedName);
                        questionContentAppend += "<li>"+tag.translatedName+"</li>"
                    }
                    questionContentAppend += "</ul></div></div><br><div><li>👍 "+question.likes+"</li><li>👎 "+question.dislikes+"</li></div>"
                    addLocal('questionContent',question.translatedContent+questionContentAppend)
                    addLocal('questionTags',questionTags)
                    addLocal('questionTagsStr',"算法,LeetCode,"+questionTags.join(",")+",")
                    saveToIndeDB(JSON.parse(localStorage.getItem(key)))

                })
            }else{
                console.log(res.status);
                //查看获取状态
            }
        }).catch((res)=>{
            //输出一些错误信息
            console.log(res.status);
        })
    }
    let pathname = window.location.pathname
    let param = {
        "operationName":"solutionDetailArticle",
        "variables":{
            "slug":pathname.split("/")[4],
            "orderBy":"DEFAULT"
        },
        "query":"query solutionDetailArticle($slug: String!, $orderBy: SolutionArticleOrderBy!) {\n  solutionArticle(slug: $slug, orderBy: $orderBy) {\n    ...solutionArticle\n    content\n    question {\n      questionTitleSlug\n      __typename\n    }\n    position\n    next {\n      slug\n      title\n      __typename\n    }\n    prev {\n      slug\n      title\n      __typename\n    }\n    __typename\n  }\n}\n\nfragment solutionArticle on SolutionArticleNode {\n  rewardEnabled\n  canEditReward\n  uuid\n  title\n  slug\n  sunk\n  chargeType\n  status\n  identifier\n  canEdit\n  canSee\n  reactionType\n  reactionsV2 {\n    count\n    reactionType\n    __typename\n  }\n  tags {\n    name\n    nameTranslated\n    slug\n    tagType\n    __typename\n  }\n  createdAt\n  thumbnail\n  author {\n    username\n    profile {\n      userAvatar\n      userSlug\n      realName\n      __typename\n    }\n    __typename\n  }\n  summary\n  topic {\n    id\n    commentCount\n    viewCount\n    __typename\n  }\n  byLeetcode\n  isMyFavorite\n  isMostPopular\n  isEditorsPick\n  hitCount\n  videosInfo {\n    videoId\n    coverUrl\n    duration\n    __typename\n  }\n  __typename\n}\n"
    }
    let options = {
        method: 'POST',
        headers: {
            'Accept': 'application/json',
            'Content-Type': 'application/json'
        },
        body: JSON.stringify(param)
    }
    fetch("https://leetcode.cn/graphql/",options).then((res)=>{
        if(res.ok){
            //如果取数据成功
            res.json().then((data)=>{
                //转化为json数据进行处理
                //console.log(data);
                let {data:solutionArticle} = data
                let {solutionArticle:{author,content,question,title}} = solutionArticle
                if(author.username != "cheungq-6"){
                    return
                }
                console.log(solutionArticle)
                getQuestion(question.questionTitleSlug)
                key = '_____'+question.questionTitleSlug
                console.error("key:"+key)
                addLocal('title',title)
                addLocal('content',title+"\n"+content)
                addLocal('slug',question.questionTitleSlug)
            })
        }else{
            console.log(res.status);
            //查看获取状态
        }
    }).catch((res)=>{
        //输出一些错误信息
        console.log(res.status);
    })
    // Your code here...
})();

抓到的数据最终存到indexdDB中,中间存了下localStorage,后来改的存indexdDB,但是没删掉中间存localStorage的过程

动态规划入门(个人总结)

本篇其实是去年的时候在部门内部做的一次简单的分享的内容,也是对自己坚持学习了一个多月的动态规划内容的一些简单的总结和整理

从斐波那契数列到01背包问题

起始

在正式介绍动态规划之前,我们先从一个简单且不陌生的题目开始
斐波那契数列

首先我们来看下这个题目
斐波那契数,通常用 F(n) 表示,形成的序列称为 斐波那契数列 。该数列由01开始,后面的每一项数字都是前面两项数字的和。也就是:

F(0) = 0,F(1)&nbsp;= 1
F(n) = F(n - 1) + F(n - 2),其中 n > 1

这里我们题面已经明确的给出了实现的逻辑了,是的,就是一眼就能看出来的递归。

最基本的实现代码如下,非常的简单,也很好理解

class Solution {
    public int fib(int n) {
        if (n<2){
            return n;
        }
        return fib(n-1) + fib(n-2);
    }
}

但是,真的就这样结束了么?显然不是,首先我们能直观的看到这个是一个递归的过程,如果输入的n不是很大尚且还好,但是当你的n足够大的时候,比如20000?虽然这也不是非常大,那么会发生什么呢?

此时也许你会说,那我可以改jvm参数,增大可用栈深度,那你的栈深度又能增加到多少呢?200万?还是2000万? 我们不妨仔细分析一下这个过程

F(   n   ) = F(n - 1) + F(n - 2)
F( n - 1 ) = F(n - 2) + F(n - 3)
F( n - 2 ) = F(n - 5) + F(n - 4)
F( n - 3 ) = F(n - 4) + F(n - 5)

可以很容易的看出来,中间经历的大量的重复运算,思考一下,我们是不是有什么办法能把这个中间的大量的重复运算的过程省略过去呢?

这个时候你也许会想到哈希表,是的,这个方向是对的,不过在面对这种int的key的时候,我们一般有一种更加简单更加轻便的作法来实现哈希表的功能,那就是数组。我们可以声明一个int[]的数组来实现我们需要的功能,且其本身比Map型数据结构更加的轻便简单,相对的速度也更快

而且,这个过程中,我们不再是从F(N)F(0)求解,而是正向的从0N求解,那么代码如下

class Solution {
    public int fib(int n) {
        if (n<2){
            return n;
        }
        int[] dp = new int[n+1];
        dp[1] = 1;
        int idx = 1;
        while (++idx <=n){
            dp[idx] = dp[idx-1] + dp[idx-2];
        }
        return dp[n];
    }
}

我们在算法中,给这样这种的数组一个独特的名字叫滚动数组,这样是不是就规避了最大栈深度的限制了呢?那我们入参给个Integer.MAX_VALUE看看会发生什么?内部的值相加是否会超出int型上限我们姑且先不论,直接入参给入跑一下看看

那么接下来我们要对这份代码再做一点优化,而数组长度上限的问题,你可以自己再思考下看看这个问题"java中数组的长度上限是多少"而又为什么会有这个上限。

拓展小知识:循环遍历和递归是可以相互转化的,最经典的例子莫过于二叉树的深度优先搜索(DFS)和广度优先搜索(BFS),一个是递归遍历,一个是循环遍历,这是另外一个不小的话题,这里不做展开讨论了

现在我们再次观察下这份代码,n位置的值,只和n-1n-2位置的值有关,那么我们就确实没有必要声明一个长度为n+1的数组,对此我们做一点点修改

Continue reading

LeetCode刷题【941】有效的山脉数组

给定一个整数数组 arr,如果它是有效的山脉数组就返回 true,否则返回 false

让我们回顾一下,如果 arr 满足下述条件,那么它是一个山脉数组:

  • arr.length >= 3
  • 在 0 < i < arr.length - 1 条件下,存在 i 使得:
    • arr[0] < arr[1] < ... arr[i-1] < arr[i]
    • arr[i] > arr[i+1] > ... > arr[arr.length - 1]

 

示例 1:

输入:arr = [2,1]
输出:false

示例 2:

输入:arr = [3,5,5]
输出:false

示例 3:

输入:arr = [0,3,2,1]
输出:true

 

提示:

  • 1 <= arr.length <= 104
  • 0 <= arr[i] <= 104
Related Topics
  • 数组

  • 👍 178
  • 👎 0
  • 双指针从两头往中间遍历
    双指针从两头往中间遍历
    最终判断两个指针是否在中间相遇,相遇点不能是左边界也不能是又边界

    代码

    class Solution {
        public boolean validMountainArray(int[] arr) {
            int l = 0;
            int r = arr.length-1;
            while (l<r && arr[l+1] > arr[l]){
                l++;
            }
            while (r>0 && arr[r-1] > arr[r]){
                r--;
            }
            return l==r && l!=0 && l != arr.length-1;
        }
    }

    LeetCode刷题【1518】换酒问题

    小区便利店正在促销,用 numExchange 个空酒瓶可以兑换一瓶新酒。你购入了 numBottles 瓶酒。

    如果喝掉了酒瓶中的酒,那么酒瓶就会变成空的。

    请你计算 最多 能喝到多少瓶酒。

     

    示例 1:

    输入:numBottles = 9, numExchange = 3
    输出:13
    解释:你可以用 3 个空酒瓶兑换 1 瓶酒。
    所以最多能喝到 9 + 3 + 1 = 13 瓶酒。
    

    示例 2:

    输入:numBottles = 15, numExchange = 4
    输出:19
    解释:你可以用 4 个空酒瓶兑换 1 瓶酒。
    所以最多能喝到 15 + 3 + 1 = 19 瓶酒。
    

    示例 3:

    输入:numBottles = 5, numExchange = 5
    输出:6
    

    示例 4:

    输入:numBottles = 2, numExchange = 3
    输出:2
    

     

    提示:

    • 1 <= numBottles <= 100
    • 2 <= numExchange <= 100
    Related Topics
    • 数学
    • 模拟

  • 👍 140
  • 👎 0
  • 模拟,记得一次换不了的剩余空瓶可以攒着一起换
    没啥好说的,直接模拟,需要有一天个注意的地方,我们需要记录下没被换掉的剩余的空瓶

    可以几次攒下来不够换的空瓶,攒够了numExchange个后来换

    所以

    1. 初始我们买了numBottles瓶,喝了这么多之后就有这么多空瓶
    2. 第一次换酒剩余了left = numBottles%numExchange;瓶无法兑换
    3. 第一次换酒换到了numBottles /= numExchange;瓶,即喝到的瓶数增加了这么多
    4. 那么此时手中剩余空瓶数量为numBottles + left瓶空瓶,重新回到步骤1开始模拟

    代码

    class Solution {
        public int numWaterBottles(int numBottles, int numExchange) {
            int ans = numBottles;
            int left = 0;
            while (numBottles >= numExchange){
                left = numBottles%numExchange;
                numBottles /= numExchange;
                ans += numBottles;
                numBottles += left;
            }
            return ans;
        }
    }

    LeetCode刷题【372】超级次方

    你的任务是计算 ab 对 1337 取模,a 是一个正整数,b 是一个非常大的正整数且会以数组形式给出。

     

    示例 1:

    输入:a = 2, b = [3]
    输出:8
    

    示例 2:

    输入:a = 2, b = [1,0]
    输出:1024
    

    示例 3:

    输入:a = 1, b = [4,3,3,8,5,2]
    输出:1
    

    示例 4:

    输入:a = 2147483647, b = [2,0,0]
    输出:1198
    

     

    提示:

    • 1 <= a <= 231 - 1
    • 1 <= b.length <= 2000
    • 0 <= b[i] <= 9
    • b 不含前导 0
    Related Topics
    • 数学
    • 分治

  • 👍 275
  • 👎 0
  • 快速幂使用,注意识别中途取余的情况
    先了解下快速幂相关的知识,可以尝试下做下剑指 Offer 16. 数值的整数次方

    另外一个知识点同底数幂相乘,底数不变,指数相加a^m * a^n = a^(m+n)

    分析

    所以当我们面对int[] b次幂的时候,即等同于

    a^(b[0] * 100...0) * ... * a^(b[i])

    举个栗子假设int[] b[2,3,4]

    那么结果即为a^200 * a^30 * a^4 等同于
    a^(100+100) * a^(10+10+10) * a^4
    a^100 * a^100 * a^10 * a^10 * a^10 * a^1 * a^1 * a^1 * a^1
    最终我们可以得到
    (a^100)^2 * (a^10)^3 * (a^1)^4

    这样我们从末位开始往前遍历,中间可以重复利用 a^(10^n)的结果

    自定义快速幂函数pow(int a, int b)中注意处理各种要取模的情况

    代码

    class Solution {
        int mod = 1337;
    
        public int superPow(int a, int[] b) {
            int ans = 1;
            for (int i = b.length - 1; i >= 0; i--) {
                ans *= pow(a,b[i]);
                ans %= mod;
                a = pow(a,10);
            }
            return ans;
        }
    
    
        public int pow(int a, int b){
            if (b==0) return 1;
            if (b==1) return a%mod;
            int ans = pow(a,b/2);
            return ((ans * ans)%mod) * pow(a,b%2) % mod;
        }
    }

    LeetCode刷题【475】供暖器

    冬季已经来临。 你的任务是设计一个有固定加热半径的供暖器向所有房屋供暖。

    在加热器的加热半径范围内的每个房屋都可以获得供暖。

    现在,给出位于一条水平线上的房屋 houses 和供暖器 heaters 的位置,请你找出并返回可以覆盖所有房屋的最小加热半径。

    说明:所有供暖器都遵循你的半径标准,加热的半径也一样。

     

    示例 1:

    输入: houses = [1,2,3], heaters = [2]
    输出: 1
    解释: 仅在位置2上有一个供暖器。如果我们将加热半径设为1,那么所有房屋就都能得到供暖。
    

    示例 2:

    输入: houses = [1,2,3,4], heaters = [1,4]
    输出: 1
    解释: 在位置1, 4上有两个供暖器。我们需要将加热半径设为1,这样所有房屋就都能得到供暖。
    

    示例 3:

    输入:houses = [1,5], heaters = [2]
    输出:3
    

     

    提示:

    • 1 <= houses.length, heaters.length <= 3 * 104
    • 1 <= houses[i], heaters[i] <= 109
    Related Topics
    • 数组
    • 双指针
    • 二分查找
    • 排序

  • 👍 406
  • 👎 0
  • 简单粗暴点的二分

    代码

    class Solution {
        public int findRadius(int[] houses, int[] heaters) {
            Arrays.sort(heaters);
            int ans = 0;
            for (int house : houses) {
                int l = 0;
                int r = heaters.length-1;
                int tmp = (int) 1e9+1;
                while (l<=r){
                    int mid = (l + r)/2;
                    //怕遗漏边缘情况不好处理就每次二分的结果都比较下
                    tmp = Math.min(tmp, Math.abs(heaters[mid] - house));
                    if (heaters[mid] > house){
                        r = mid-1;
                    }else if (heaters[mid] < house){
                        l = mid+1;
                    }else {
                        break;
                    }
                }
                ans = Math.max(ans,tmp);
            }
            return ans;
        }
    }

    LeetCode刷题【1610】可见点的最大数目

    给你一个点数组 points 和一个表示角度的整数 angle ,你的位置是 location ,其中 location = [posx, posy]points[i] = [xi, yi] 都表示 X-Y 平面上的整数坐标。

    最开始,你面向东方进行观测。你 不能 进行移动改变位置,但可以通过 自转 调整观测角度。换句话说,posxposy 不能改变。你的视野范围的角度用 angle 表示, 这决定了你观测任意方向时可以多宽。设 d 为你逆时针自转旋转的度数,那么你的视野就是角度范围 [d - angle/2, d + angle/2] 所指示的那片区域。

    对于每个点,如果由该点、你的位置以及从你的位置直接向东的方向形成的角度 位于你的视野中 ,那么你就可以看到它。

    同一个坐标上可以有多个点。你所在的位置也可能存在一些点,但不管你的怎么旋转,总是可以看到这些点。同时,点不会阻碍你看到其他点。

    返回你能看到的点的最大数目。

     

    示例 1:

    输入:points = [[2,1],[2,2],[3,3]], angle = 90, location = [1,1]
    输出:3
    解释:阴影区域代表你的视野。在你的视野中,所有的点都清晰可见,尽管 [2,2] 和 [3,3]在同一条直线上,你仍然可以看到 [3,3] 。

    示例 2:

    输入:points = [[2,1],[2,2],[3,4],[1,1]], angle = 90, location = [1,1]
    输出:4
    解释:在你的视野中,所有的点都清晰可见,包括你所在位置的那个点。

    示例 3:

    输入:points = [[1,0],[2,1]], angle = 13, location = [1,1]
    输出:1
    解释:如图所示,你只能看到两点之一。

     

    提示:

    • 1 <= points.length <= 105
    • points[i].length == 2
    • location.length == 2
    • 0 <= angle < 360
    • 0 <= posx, posy, xi, yi <= 100
    Related Topics
    • 几何
    • 数组
    • 数学
    • 排序
    • 滑动窗口

  • 👍 113
  • 👎 0
  • 相对坐标信息转换为弧度信息,排序后滑窗统计
    前置基本知识

    1. 弧度,360° = π * 2 的弧度,180° = π 弧度
    2. 滑动窗口

    基本步骤

    1. List<List<Integer>> points数组和List<Integer> location数组分别计算,得到各个点对应的弧度值,如果你直接用角度计算的话也一样
    2. 如果这个点和List<Integer> location位置相同,则这个点永远可见,不做计算,并计数永远可见点数量加1
    3. Math.atan2计算的弧度值是从π范围的,直接用于后续计算不行,所以我们将0范围内的数据统一加,即将最终结果映射到0区间中
    4. 前面有永远可见点占位清理下,同时记得对现在已经计算出来的弧度数组重新排序,因为题面中给的List<List<Integer>> points数组位置顺序并非按照弧度顺序排序的
    5. 转链为环,因为这边得到结果是一个数组,不方便计算从结尾到开头时候的情况,即滑窗开始在结尾,滑窗结束在开头的情况,所以我们使用了常用的作法之一,数组复制双倍,这样环的数据就可以处理了,不过不需要整个数组复制双倍,只需把弧度0到窗口弧度内的数据重新接在数组结尾即可
    6. 接下来就是常规的滑动窗口统计窗口内最大数量的问题了,比较简单,不做赘述了
    7. 记得最终结果要加上之前统计到的永远可见点数量

    没做过画图或者3d之类的开发的话这题拿到手可能有点懵,有幸之前学习研究过一段时间ThreeJS,空间、平面信息的转换上能稍微有点感觉,拿到手之后思路还是非常明确的。就是各种边边角角的细节逻辑采坑略多,想想下location点是一个相机Camera,这个angle就是对应的相机镜头的视角应该还是比较好理解的

    从坐标转换为弧度,

    最终将弧度信息映射在从0区间的数据

    代码

    class Solution {
        public int visiblePoints(List<List<Integer>> points, int angle, List<Integer> location) {
            double x1 = (double) location.get(0);
            double y1 = (double) location.get(1);
    
            double[] radianList = new double[points.size()];
            double radianWin = angle * Math.PI / 180;
            int alwaysSee = 0;
    
            int idx = -1;
            for (List<Integer> point : points) {
                double x2 = (double) point.get(0);
                double y2 = (double) point.get(1);
                if (x1 == x2 && y1 == y2){
                    alwaysSee++;
                    continue;
                }
                radianList[++idx] = Math.atan2(y2-y1,x2-x1);
                if (radianList[idx] < 0){
                    radianList[idx] += Math.PI * 2;
                }
            }
            Arrays.sort(radianList);
    
            if (alwaysSee>0){
                double[] tmp = new double[radianList.length-alwaysSee];
                System.arraycopy(radianList,alwaysSee,tmp,0,radianList.length-alwaysSee);
                radianList = tmp;
            }
    
            //开始滑窗统计
            int l = 0;
            int r = 0;
            int max = 0 ;
            //窗口初始化
            while (r + 1 < radianList.length && radianList[r+1] <= radianList[l] + radianWin ){
                r++;
                max = r-l+1;
            }
    
            //在原来的radianList数组之后,在拼上一段radianWin弧度的数据,这段数据为从弧度0开始到弧度radianWin之内的所有数据
            //而这里得0到滑窗弧度范围内的点的值
            if (radianList.length>0 && radianList[l] <= radianWin){
                double[] tmp = new double[radianList.length + max];
                System.arraycopy(radianList,0,tmp,0,radianList.length);
                System.arraycopy(radianList,0,tmp,radianList.length,max);
                for (int i = radianList.length; i < tmp.length; i++) {
                    tmp[i] += Math.PI * 2;
                }
                radianList = tmp;
            }
            //开始滑动
            while (l<radianList.length && radianList[l]+ radianWin <= radianList[radianList.length-1]){
                l++;
                while (r + 1 < radianList.length && radianList[r+1] <= radianList[l]+radianWin ){
                    r++;
                }
                max = Math.max(max,r-l+1);
            }
           return max+alwaysSee;
        }
    }