精华内容
下载资源
问答
  • // 日期按、周、月 递增 public function completeChartData ( $data, $map ) { if(empty($map['start_date']) || empty($map['end_date'])){ return $data; } s...

    // 日期按日、周、月 递增

     
    public function completeChartData ( $data, $map )
        {
            if(empty($map['start_date']) || empty($map['end_date'])){
                return $data;
            }
    
            switch($map['dateline']){
                case 'WEEK':
                    $diff_time = '+1 WEEK';
                    break;
                case 'MONTH':
                    $diff_time = '+1 MONTH';
                    break;
                default:
                    $diff_time = '+1 DAY';
            }
    
            $start_time = $map['start_date'];
            $end_time   = $map['end_date'];
    
            do {
                $xAxis[] = $start_time;
                $start_time = date ( 'Y-m-d', strtotime ( $diff_time, strtotime($start_time) ) );
            } while ( $start_time <= $end_time );
     
            dump($xAxis);
            exit;
    
        }
    

      

    展开全文
  • 给定一个未经排序的整数数组,找到最长且连续的的递增序列。 算法思路 遍历。 class Solution: def findLengthOfLCIS(self, nums: List[int]) -> int: if not nums:return 0 n,MAX=1,0 for i in range(1,len...

    题目描述

    给定一个未经排序的整数数组,找到最长且连续的的递增序列。

    算法思路

    遍历。

    class Solution:
        def findLengthOfLCIS(self, nums: List[int]) -> int:
            if not nums:return 0
            n,MAX=1,0
    
            for i in range(1,len(nums)):
                if nums[i]>nums[i-1]:n+=1
                else:
                    MAX=max(MAX,n)
                    n=1
            MAX=max(MAX,n)
            return MAX
    
    
    展开全文
  • 最长递增子序列

    千次阅读 2013-07-08 19:40:07
    最长递增子序列(Longest Increasing Subsequence)长度有很多种解决方法,这里介绍两种,一种是动态规划的实现,一种是O(NlogN)的解决方法(参考编程之美) 动态规划 我们假定w1,w2,...,wn为一串正整数序列,前i个数...

    概述

    最长递增子序列(Longest Increasing Subsequence)长度有很多种解决方法,这里介绍两种,一种是动态规划的实现,一种是O(NlogN)的解决方法(参考编程之美)

    动态规划

    我们假定w0,w1,...,wn-1为一串正整数序列,前i个数的最长递增子序列的长度为A(i),则最优解结构为:

    • A(0) = 1
    • A(i)  = max{A(j) + 1, 0 <= j < i}

    时间复杂度为O(n * n)


    实现代码也很简单,贴一下c的实现代码(11月7日增加了打印最长递增子序列的代码)

    题目


    题目描述:
    给定一个整数序列,请问如何去掉最少的元素使得原序列变成一个全递增的序列。
    输入:
    输入的第一行包括一个整数N(1<=N<=10000)。
    接下来的一行是N个满足题目描述条件的整数。
    输出:
    可能有多组测试数据,对于每组数据,
    输出去掉最少的元素后的全递增序列。
    样例输入:
    8
    186 186 150 200 160 130 197 220
    样例输出:
    150 160 197 220
    提示:
    如果有多个结果序列满足条件,输出相对位置靠前的那个序列。

    ac代码


    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
     
    #define N 10050
     
    int dp[N], seq[N], pre[N];
    int count, maxindex;
     
    int longIS(int *arr, int n)
    {
        int i, j, lis;
     
        dp[0] = 1;  
        memset(pre, 0, sizeof(pre));
     
        for (i = 1, lis = 1, maxindex = 0; i < n; i ++) {
            dp[i] = 1;
            for (j = 0; j < i; j ++) {
                if (arr[j] < arr[i] && dp[j] + 1 > dp[i]) {
                    dp[i] = dp[j] + 1;
                    pre[i] = j;
                }
            }
            if (dp[i] > lis) {
                lis = dp[i];
                maxindex = i;
            }
        }
     
        return lis;
    }
     
    void outputLis(int *arr, int lis)
    {
        for (count = 0; lis > 0; lis --, count ++) {
            seq[count] = arr[maxindex];
            maxindex = pre[maxindex];
        }
    }
     
    int main(void)
    {
        int i, n, lis, *arr;
     
        while (scanf("%d", &n) != EOF) {
            arr = (int *)malloc(sizeof(int) * n);
     
            for (i = 0; i < n; i ++) {
                scanf("%d", arr + i);
            }
     
            lis = longIS(arr, n);
     
            outputLis(arr, lis);
     
            for (i = count - 1; i >= 0; i --) {
                if (i == 0) {
                    printf("%d\n", seq[i]);
                } else {
                    printf("%d ", seq[i]);
                }
            }
     
            free(arr);  arr = NULL;
        }
     
        return 0;
    }
    /**************************************************************
        Problem: 1262
        User: wangzhengyi
        Language: C
        Result: Accepted
        Time:20 ms
        Memory:1032 kb
    ****************************************************************/



    O(nLogn)算法实现

    这里参考了别人的实现算法,原文链接:http://www.felix021.com/blog/read.php?1587

    算法思路

    这里举一个例子来讲解这个算法,假设一个序列 arr[8] = {3, 2, 6, 4, 7, 5, 9, 10}, 可以看出这里的LIS长度为5.我们尝试一步步的推理一下:

    我们定义一个序列seq,然后另i = 1 to 8考察这个序列,同时用len记录LIS的长度

    1. 首先,把arr[1]放到seq里,令seq[1] = 3,就是说当只有一个数字3时,长度为1的LIS的最小末尾是3,这时len为1
    2. 然后,把arr[2]有序的放到seq里,令seq[1] = 2,就是说长度为1的LIS最小末尾是1,seq[1] = 3已经没用了,这时len仍为1(ps:应该比较好理解)
    3. 接着,arr[3] = 6, arr[3] > seq[1],所以令seq[1 + 1] = seq[2] = arr[3] = 6,也就是说长度为2的LIS的最小末尾是6,这时len为2
    4. 再来,arr[4] = 4,它正好在2, 6之间,放在2的位置显然不合适,因为2  < 4,长度为1的LIS最小末尾应该为2,这样很容易推理出长度为2的LIS最小末尾应该为4,于是把6淘汰,这时seq[2] = {2, 4}, len为2
    5. 继续,arr[5] = 7,它在seq[2]后面,因此seq[2 + 1] = seq[3] = 7,这时len为3
    6. 第6个,arr[6] = 5, 它在4和7之间,因此把7替换掉,seq[3] = {2, 4, 5}, len为3
    7. 第7个,arr[7] = 9, 它在seq[3]后面,因此seq[4] = {2, 4, 5, 9}, len为4
    8. 第8个,arr[8] = 10,它在seq[4]后面,因此seq[5] = {2, 4, 5, 9, 10}, len为5 

    同时,可以发现每次往seq插入数据时,seq是有序的,也就是说我们可以用二分查找算法确定每次插入的位置,于是算法复杂度也就为O(NlogN)

    实现代码

    #include <stdio.h>
    #include <stdlib.h>
    
    void longest_increasing_seq(int *arr, int n)
    {
    	int i, len, left, right, mid, *seq;
    	seq = (int *)malloc(sizeof(int) * n);
    
    	// 初始化
    	seq[0] = arr[0];
    	len = 1;
    	for (i = 1; i < n; i ++) {
    		if (arr[i] > seq[len - 1]) { // arr[i]比seq序列所有数字都大,则插入到seq末尾,len自加1
    			seq[len] = arr[i];
    			len += 1;
    		} else {
    			left = 0, right = len - 1;
    			while (left <= right) {
    				mid = left + ((right - left) >> 1);	// 防止溢出
    				if (arr[i] < seq[mid])
    					right = mid - 1;
    				else if (arr[i] > seq[mid])
    					left = mid + 1;
    				else
    					break;
    			}
    			seq[mid] = arr[i];
    		}
    	}
    
    	printf("%d\n", len);
    	free(seq);	
    }
    
    
    int main(void)
    {
    	int i, n, *arr;
    
    	while (scanf("%d", &n) != EOF) {
    		arr = (int *)malloc(sizeof(int) * n);
    		for (i = 0; i < n; i ++)
    			scanf("%d", arr + i);
    
    		longest_increasing_seq(arr, n);
    		free(arr);
    	}
    
    	return 0;
    }
    


    起因

    说下起因吧,也是因为在九度oj做题目,一道明显最长递增字串的题目,用动态规划做的时候,5个case只能通过三个,第4个case超时了,悲剧,所以学习了一种新的求最长递增字串的方法,挺不错的,顺便复习了二分查找(ps:注意我二分查找的几处细节,据说90%的程序员无法写出正确的二分查找算法,但是我一定是那百分之10以内的)

    题目描述

    题目描述:
    在读高中的时候,每天早上学校都要组织全校的师生进行跑步来锻炼身体,每当出操令吹响时,大家就开始往楼下跑了,然后身高矮的排在队伍的前面,身高较高的就要排在队尾。突然,有一天出操负责人想了一个主意,想要变换一下队形,就是当大家都从楼上跑下来后,所有的学生都随机地占在一排,然后出操负责人从队伍中抽取出一部分学生,使得队伍中剩余的学生的身高从前往后看,是一个先升高后下降的“山峰”形状。据说这样的形状能够给大家带来好运,祝愿大家在学习的道路上勇攀高峰。(注,山峰只有一边也符合条件,如1,1、2,2、1均符合条件)
    输入:
    输入可能包含多个测试样例。
    对于每个测试案例,输入的第一行是一个整数n(1<=n<=1000000):代表将要输入的学生个数。
    输入的第二行包括n个整数:代表学生的身高(cm)(身高为不高于200的正整数)。
    输出:
    对应每个测试案例,输出需要抽出的最少学生人数。
    样例输入:
    6
    100 154 167 159 132 105
    5
    152 152 152 152 152
    样例输出:
    0
    4

    动态规划的问题



    用O(n * n)的解法会超时,因此改用二分查找这种解决方法

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
     
    void lis(int *queue, int n)
    {
        int i, k, l, r, mid, max, *seq, *left, *right;
        seq = (int *)malloc(sizeof(int) * n);
        left = (int *)malloc(sizeof(int) * n);
        right = (int *)malloc(sizeof(int) * n);
     
        seq[0] = queue[0];
        left[0] = 1;
        k = 1;
        for (i = 1; i < n; i ++) {
            if (queue[i] > seq[k - 1]) {
                left[i] = k + 1;
                seq[k] = queue[i];
                k += 1;
            } else {
                left[i] = k;
                l = 0, r = k - 1;
                while (l <= r) {
                    mid = (l + r) >> 1;
                    if (seq[mid] > queue[i])
                        r = mid - 1;
                    else if (seq[mid] < queue[i])
                        l = mid + 1;
                    else {
                        l = mid;
                        break;
                    }
                }
                seq[l] = queue[i];
            }
        }
         
        /* 打印测试
        for (i = 0; i < n; i ++)
            printf("%d ", left[i]);
        printf("\n");
        */
     
        memset(seq, 0, sizeof(seq));
        seq[0] = queue[n - 1];
        right[n - 1] = 1;
        k = 1;
        for (i = n - 2; i >= 0; i --) {
            if (queue[i] > seq[k - 1]) {
                right[i] = k + 1;
                seq[k] = queue[i];
                k += 1;
            } else {
                right[i] = k;
                l = 0, r = k - 1;
                while (l <= r) {
                    mid = (l + r) >> 1;
                    if (seq[mid] > queue[i])
                        r = mid - 1;
                    else if (seq[mid] < queue[i])
                        l = mid + 1;
                    else {
                        l = mid;
                        break;
                    }
                }
                seq[l] = queue[i];
            }
        }
     
        /* 打印测试
        for (i = 0; i < n; i ++)
            printf("%d ", right[i]);
        printf("\n");
        */
     
        for (i = 0, max = 0; i < n; i ++) {
            if (left[i] + right[i] - 1 > max)
                max = left[i] + right[i] - 1;
        }
     
        printf("%d\n", n - max);
     
        free(seq);
        free(left);
        free(right);
    }
     
     
    int main(void)
    {
        int i, n, *queue;
     
        while (scanf("%d", &n) != EOF) {
            // 初始化
            queue = (int *)malloc(sizeof(int) * n);
     
            for (i = 0; i < n; i ++)
                scanf("%d", queue + i);
     
            lis(queue, n);
            free(queue);
        }
     
        return 0;
    }
     
    /**************************************************************
        Problem: 1500
        User: wangzhengyi
        Language: C
        Result: Accepted
        Time:950 ms
        Memory:16544 kb
    ****************************************************************/

    后记

    本来早就该发表这篇文章,无奈二分查找赋值那里浪费了一些时间,不过ac了这到题目我进入了九度oj排行榜的第10名,得瑟一下:



    这里可以看到,高手都是苦逼过来的,继续加油!



    展开全文
  • 题目:单调递增最长子序列时间限制:3000 ms | 内存限制:65535 KB难度:4描述求一个字符串的最长递增子序列的长度如:dabdbf最长递增子序列就是abdf,长度为4输入第一行一个整数0&lt;n&lt;20,表示有n个...

    题目:

    单调递增最长子序列

    时间限制:3000 ms  |  内存限制:65535 KB
    难度:4
    描述
    求一个字符串的最长递增子序列的长度
    如:dabdbf最长递增子序列就是abdf,长度为4
    输入
    第一行一个整数0<n<20,表示有n个字符串要处理
    随后的n行,每行有一个字符串,该字符串的长度不会超过10000
    输出
    输出字符串的最长递增子序列的长度
    样例输入
    3
    aaa
    ababc
    abklmncdefg
    样例输出
    1
    3
    7
    来源
    经典题目
    上传者
    iphxer

    代码1:

    #include <stdio.h>
    #include <string.h>
    #include <math.h>
    #include <algorithm>
    #define mem(a,b) memset(a,b,sizeof(a))
    using namespace std;
    int main()
    {
        int n;
        char str[10005];//存储字符串
        int num[10005];//当前元素作为最大元素的最长递增序列
        scanf("%d",&n);
        while(n--)
        {
            mem(str,'\0');
            mem(num,0);//初始化str和num
            int sum=0;
            num[0]=1;//第一个元素的最长递增序列一定为1
            scanf("%s",str);
            int len=strlen(str);
    
            for(int i=1; i<len; i++)
            {
                int flag=0;//代表num[i]的值
                for(int j=0; j<i; j++)
                {
                    if(str[i]>str[j]&&flag<num[j])//把当前的第i个元素和前面的每一个元素比较&&递增序列必须连续递增
                    {
                        flag=num[j];//更新序列长度
                    }
                }
                num[i]=flag+1;
            }
            for(int i=0; i<len; i++)
            {
                sum=max(sum,num[i]);//找出里面最大的长度
            }
            printf("%d\n",sum);
        }
        return 0;
    }
    

    把上面的代码优化一下,可以用逆推的方式这么写

    代码2:

    #include<stdio.h>  
    #include<string.h>  
    int dp[10010];  
    char a[10010];  
    int main()  
    {  
        int t;  
        scanf("%d",&t);  
        while(t--)  
        {  
            memset(dp,0,sizeof(dp));  
            int i,la,j,maxn=-1;  
            scanf("%s",a+1);  
            la=strlen(a+1);  
            for(i=1;i<=la;i++)  
                {  
                    for(j=i-1;j>=0;j--)  
                    {  
                        if(a[j]<a[i]&&dp[i]<dp[j]+1)//判断是否递增,并且判断当前元素所处递增序列的长度  
                            dp[i]=dp[j]+1;//更新递增序列的最大长度  
                    }  
                    if(dp[i]>maxn)  
                        maxn=dp[i];  
                }  
                printf("%d\n",maxn);  
        }  
        return 0;  
    }  



    关于这个问题有一篇博客写的很好:-->最长递增子序列详解(longest increasing subsequence)

    以下内容摘自上述博客
    -----------------------------------------------------------------关于单调递增子序列--------------------------------------------------------------------------------

    对于动态规划问题,往往存在递推解决方法,这个问题也不例外。要求长度为i的序列的Ai{a1,a2,……,ai}最长递增子序列,需要先求出序列Ai-1{a1,a2,……,ai-1}中以各元素(a1,a2,……,ai-1)作为最大元素的最长递增序列,然后把所有这些递增序列与ai比较,如果某个长度为m序列的末尾元素aj(j<i)比ai要小,则将元素ai加入这个递增子序列,得到一个新的长度为m+1的新序列,否则其长度不变,将处理后的所有i个序列的长度进行比较,其中最长的序列就是所求的最长递增子序列。举例说明,对于序列A{35, 36, 39, 3, 15, 27, 6, 42}当处理到第六个元素(27)时,以35, 36, 39, 3, 15, 27, 6为最末元素的最长递增序列分别为
        35
        35,36
        35,36,39
        3
        3,15
        3,15,27
        3,6
    当新加入第10个元素42时,这些序列变为
        35,42
        35,36,42
        35,36,39,42,
        3,42
        3,15,42
        3,15,27,42
        3,6,42

    这其中最长的递增序列为(35,36,39,42)和(3,15,27,42),所以序列A的最长递增子序列的长度为4,同时在A中长度为4的递增子序列不止一个。

    算法的思想十分简单,如果要得出Ai序列的最长递增子序列,就需要计算出Ai-1的所有元素作为最大元素的最长递增序列,依次

    递推Ai-2,Ai-3,……,将此过程倒过来,即可得到递推算法,依次推出A1,A2,……,直到推出Ai为止

    2018年3月31日20:06:37重写O(N^2)

    #include <bits/stdc++.h>
    using namespace std;
    int dp[10000+100];
    int main()
    {
        int t;
        cin>>t;
        while(t--)
        {
            int maxx=0;
            string s;
            cin>>s;
            int len=s.length();
            for(int i=0; i<len; i++)
            {
                dp[i]=1;
                for(int j=0; j<i; j++)
                {
                    if(s[j]<s[i]&&dp[j]+1>dp[i])
                    {
                        dp[i]=dp[j]+1;
                    }
                }
                maxx=max(maxx,dp[i]);
            }
            cout<<maxx<<endl;
        }
        return 0;
    }


    展开全文
  • 直接上代码: DELIMITER $$ drop procedure if exists proc_test$$ create procedure proc_test() begin declare id int; --对象id declare done int; --循环结束的标志 ... --循环递增的起始时间 declare tempV
  • AngularJS分页序号递增

    千次阅读 2016-12-15 14:33:50
    AngularJS分页序号递增的几种实现方式
  • 递增顺序把二叉查找树进行重新排列 解答1: 分治算法(本质是中序遍历的递归实现) 代码: class Solution { public TreeNode increasingBST(TreeNode root) { TreeNode newRoot = root;
  • C#数字+字母生成递增号,其中支持位数没有限制,2位、3位、4位、5位、6位等等,都可以,还有可以区分大小写,规则如下:例如4位数字+字母混合递增,先按照数字递增,然后按照字符递增
  • WICSAndroidPresentationExample 2015 年 1 月 28 WICS Android 示例计数器。 这个简单的 Android 示例程序递增和重置视图中存在的计数器。
  • 单目递增运算符的重载 单目递增运算符重载简介 弹幕递增运算符重载(++)可分为前缀和后缀两种,即++I,i++两种。为此我们也将重载分为两类,前缀单目递增运算符重载与后缀弹幕递增运算符重载。 系统默认++i这种...
  • 674. 最长连续递增序列 给定一个未经排序的整数数组,找到最长且 连续递增的子序列,并返回该序列的长度。 连续递增的子序列 可以由两个下标 l 和 r(l < r)确定,如果对于每个 l <= i < r,都有 nums[i] ...
  • 最长递增子序列问题

    千次阅读 2016-03-07 17:00:16
    (递增子序列是指,子序列的元素是递增的) 例如:5 1 6 8 2 4 5 10,最长递增子序列是1 2 4 5 10。Input 第1行:1个数N,N为序列的长度(2 ) 第2 - N + 1行:每行1个数,对应序列的元素(-10^9 <= S
  • include_once "inc/class/db.php";$db = new Db();function getPrimary($db,$table_name,$field_name){ $sql = "select max($field_name) from ".$table_name; $str = $db->fetchOne($sql); if(!isset($str)
  • id*5,记录时间列) DateAdd函数DATEADD(datepart,number,date)datepart缩写年yy, yyyy季度qq, q月mm, m年中的dy, ydd, d周wk, ww星期dw, w小时hh分钟mi, n秒ss, s毫秒ms微妙mcs纳秒ns按5分钟递增n,表示增加的...
  • 递增单链表删除重复的元素 设单链表递增排好序的,删除其重复的元素。 特点:单链表,递增排列。 思路:一次性遍历链表,同时比较相邻的元素。当相邻元素不同时把元素重新放在链表里。 C++代码实现如下: #include &...
  • java根据年月编号递增

    2014-09-22 15:50:43
    KH_201401(年月)_0001(按年月归类递增)) ,2014年9月的编号如:KH_201409_0001,KH_201409_0002 当月份增到10月,要重新计算,从KH_201410_0001开始。 请问该如何实现编程,要不要数据库序列配合?
  • 1.获取当前时间年月 如:2018-01-15 00:00:00 2018-01-15 24:00:00 2.查询表中对应日期字段是否在当天时间段内 3.若是在,则从0开始递增 4.若是不在,则查找msgno最大数值,在此基础上+1 ②上代码...
  • 蓝桥杯训练——最长递增子序列

    千次阅读 2017-09-21 16:48:50
    问题描述:最长递增子序列 习题3.4 最长连续递增子序列(20 分) 给定一个顺序存储的线性表,请设计一个算法查找该线性表...第2行给出n个整数,其间空格分隔。 输出格式: 在一行中输出第一次出现的最长连续递增
  • 使用sql语句将查询的数据中的值按时间递增累加
  • 1134 最长递增子序列 基准时间限制:1 秒 空间限制:131072 KB 分值: 0 难度:基础题 收藏 关注 给出长度为N的数组,找出这个数组的最长递增子序列。(递增子序列是指,子序列的元素是递增的) 例如:5 1 6 8 2 4 ...
  • java中自动递增和递减(i++)

    千次阅读 2018-08-26 13:27:58
    概念 前缀递增(++i):先执行运算,再生成值。 后缀递增(i++) : 先生成值,再执行运算。 示例 ...概念说的多了反而糊涂,不如直接看代码来的直接。... * @date: 2017年3月7 下午3:57:08 ...
  • 时间:2021年1月24 题目链接 题目 给定一个未经排序的整数数组,找到最长且 连续递增的子序列,并返回该序列的长度。 连续递增的子序列 可以由两个下标 l 和 r(l < r)确定,如果对于每个 l <= i < r,...
  • js 按月递增 算法

    千次阅读 2017-09-06 16:59:30
    最近业务上遇到一个问题:已知格式为 xxxx/xx/xx的起始日期和结束日期,要得到一个数组,数组中存放从起始日期开始到结束期间的若干个日期,每一个日期元素都比之前的日期大一个月。以上是问题。下面是代码:...
  • 我们希望计算一个股票最长的连续上涨的天数,也即,给定一个未经排序的字符串,找到最长且连续递增的子序列,并返回该序列的长度。 连续递增的子序列可以由两个下标l和 r(l < r)确定,如果对于每个 l <= i ...
  • 如果这样的元素存在,那么对所有aj,都有一个aj为末元素的最长递增子序列的长度f(j),把其中最大的f(j)选出来,那么f(i)就等于最大的f(j)加上1,即ai为末元素的最长递增子序列,等于使f(j)最大的那个aj为末元素...
  • 需求中可能存在在一个单元格中同时出现日期和星期,又想要递增,这个时候如果自己一个一个添加的话太过繁琐,无故添加很多的工作量。 这个时候我们可以这么做: 1、首先在需要输入数据的单元格中打开设置单元格格式...
  • 第九届蓝桥杯 JavaB 递增三元组 标题:递增三元组 给定三个整数数组 A = [A1, A2, … AN], B = [B1, B2, … BN], C = [C1, C2, … CN], 请你统计有多少个三元组(i, j, k) 满足: 1 <= i, j, k <= ...
  • 自动递增和递减(i++)

    千次阅读 2017-03-07 16:06:36
    自动递增与自动递减运算是不错的快捷运算。本文只介绍自动递增,自动递减同理。 概念 前缀递增(++i):先执行运算,再生成值。 后缀递增(i++) : 先生成值,再执行运算。 示例概念说的多了反而糊涂,不如...
  • 测试AtomicInteger与普通int值在多线程下的递增操作

    万次阅读 热门讨论 2014-06-10 19:23:43
    日期: 2014年6月10作者: 铁锚Java针对多线程下的数值安全计数器设计了一些类,这些类叫做原子类,其中一部分如下:java.util.concurrent.atomic.AtomicBoolean; java.util.concurrent.atomic.AtomicInteger; java....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,104
精华内容 13,241
关键字:

以日递增