精华内容
下载资源
问答
  • 基于FPGA的m序列发生器实现.pdf
    2021-05-25 05:03:27

    基于FPGA的m序列发生器实现.pdf

    第11卷第7期 V01.11No.7

    2009年7月 鼷讲廖孝 Jul.2009

    doi:lO.3969/j.issn.1563-4795.2009.07.014

    基于FPGA的m序歹U发生器实现

    段颖妮

    (西安文理学院,陕西 西安710065)

    摘要:讨论了应用移位寄存器理论实现基于FPGA的伪随机序列发生器的方法,通过理论

    分析给出了m序列本原多项式与m序列移位寄存器反馈多项式间的关系。同时给出了运用

    VHDL语言编程.并rXAltera醚JQuartuslI软件为开发平台醚Jm序列的仿真波形。

    关键词:伪随机序列;m序列;移位寄存器;VHDL语言

    O引言

    240PQFP来实现线性m序列。

    伪随机序列的伪随机性表现在预先的可确定

    性、可重复产生与处理。伪随机序列可广泛应用 1 m序列

    于密码学、通信、雷达、导航、系统辨识、流媒

    n级线性移位寄存器产生的非零周期序列X=

    体的处理与芯片内建自测试、电子对抗、数字网

    络系统的故障诊断等多个领域,因此,目前对伪 埘瘁:…Xp-1的极小多项式为n次本原多项式,这样

    随机序列已经有了比较深入的研究,传统的伪随

    机序列主要是用m序列作为驱动序列经过非线性 一凡次本原多项式和不同的初始状态可以得到多

    个m序列。但它们只不过相差若干步位移。这些

    组合或非线性前馈来生成。可用钟控序列生成器

    m序列称作一个平移等价类。在全部凡级m序列

    (包括stop—and_go牛_成器、缩减生成器、自缩生成

    器)并用简单方法使m序列的代数性质面目全非, 中,平移等价类的个数为9(2“一1)/n,其中9

    从而提高其线性复杂度以得到令人满意的结果。 p)表示口的欧拉函数。可以通过对某一n级m序列

    进行采样来获得m序列其它所有的平移等价类

    应用复杂性理论产生序列。如用混沌映射产生伪

    随机序列。然后通过映射函数、生成规则以及初 (即求取全部的本原多项式)。

    始条件便能确定一个几乎无法破译的加密序列。 m序列有一个有趣的性质,那就是包含它的

    同时可应用遗传算法(Genetic 平移等价类再添上零序列正好可以构成一个线性

    Algorithm)在FP—

    GA上产生伪随机序列或用二维细胞自动机产生 空间,具体讲就是:如果序列X=.go:91名2…戈,1的周

    伪随机序列。在已有的序列中,m序列应用最为 期是p,a阮。一许i柑…石;+律i)是凡级m序列移位寄存

    成熟和广泛,为此,本文给出线性m序列的FPGA器在某一i时刻的内部状态,那么,集合{a,

    实现方法。 k,…,Lp--a,0l对加法是封闭的,其中L是左

    FPGA的内部逻辑功能是通过向内部静态存移算子。或者说对于任意的0≤i可≤p一1,有0≤

    储器单元加载配置数据来实现的。配置文件决定

    了逻辑单元的逻辑功能以及模块间或与I/O间的 可加性,平移可加性是m序列的一个特征性质。

    连接。并最终决定FPGA实现的功能。FPGA的这通常凡级线性移位寄存器(LF'SR)可以产生

    种结构允许多次编程.并享有快速有效地对新设 多个m序列(一个平移等价类算作一个m序列,

    计进行优化的灵活性,因此,现今的电子系统大 一个平移等价类对应着一个本原多项式),而每

    量采用FPGA作为系统的核心控制器件。本文选一个m序列对应着一个确定的线性反馈函数。m

    更多相关内容
  • 序列 子数组问题 53. 最大子序 给定一个整数数组 nums ,找到一个具有最大的连续子数组(子数组最少包含一个元素),返回其最大。 示例 1: 输入:nums = [-2,1,-3,4,-1,2,1,-5,4] 输出:6 解释:连续子数组...

    子序列 子数组问题

    53. 最大子序和

    给定一个整数数组 nums ,找到一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。

    示例 1:

    输入:nums = [-2,1,-3,4,-1,2,1,-5,4]
    输出:6
    解释:连续子数组 [4,-1,2,1] 的和最大,为 6 。
    

    解法1: 贪心法

    class Solution:
        def maxSubArray(self, nums: List[int]) -> int:
            max_sum = nums[0]
            cur_sum = 0
            for i in range(0, len(nums)):
                cur_sum += nums[i]
                max_sum = max(max_sum, cur_sum)
                if cur_sum < 0:  # 小于0 再加也会减少
                    cur_sum = 0
    
            return max_sum
    

    解法2: 动态规划

    class Solution:
        def maxSubArray(self, nums: List[int]) -> int:
            # 动态规划,
            for i in range(1, len(nums)):
                if nums[i-1] > 0: # 大于0 加
                    nums[i] = nums[i] + nums[i-1]
    
            return max(nums)
    

    674. 最长连续递增序列

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

    连续递增的子序列 可以由两个下标 lrl < r)确定,如果对于每个 l <= i < r,都有 nums[i] < nums[i + 1] ,那么子序列 [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] 就是连续递增子序列。

    示例 1:

    输入:nums = [1,3,5,4,7]
    输出:3
    解释:最长连续递增序列是 [1,3,5], 长度为3。
    尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的,因为 5 和 7 在原数组里被 4 隔开。 
    

    解法1:

    class Solution:
        def findLengthOfLCIS(self, nums: List[int]) -> int:
            # 最长 且 连续递增 子序列
            if not nums:
                return 0
            max_length = 1
            temp = 1 # 计算连续递增子序列个数
            for i in range(1, len(nums)):
                if nums[i] > nums[i-1]:
                    temp += 1
                    max_length = max(max_length, temp)
                else:
                    temp = 1
            return max_length
    

    300. 最长递增子序列 ** 重点复习

    给你一个整数数组 nums ,找到其中最长严格递增子序列的长度。

    子序列是由数组派生而来的序列,删除(或不删除)数组中的元素而不改变其余元素的顺序。例如,[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

    示例 1:

    输入:nums = [10,9,2,5,3,7,101,18]
    输出:4
    解释:最长递增子序列是 [2,3,7,101],因此长度为 4 。
    

    解法1: 动态规划 O ( n 2 ) O(n^2) O(n2)

    class Solution:
        def lengthOfLIS(self, nums: List[int]) -> int:
            # 最长严格递增子序列的长度
            # 子序列 和 子数组是不同的;
            #  动态规划
            nums_len = len(nums)
            dp = [] # dp[i]: 表示 到i时 最长严格递增子序列的长度
            for i in range(nums_len):
                dp.append(1) # 从1开始
                # i 和之前的 每个j 比较,若严格递增,则dp[j]+1 比较 
                for j in range(len(dp)):
                    if nums[j] < nums[i]:
                        dp[i] = max(dp[i], dp[j]+1)
    
            return max(dp)
    

    解法2: O ( n l o g ( n ) ) O(nlog(n)) O(nlog(n))

    673. 最长递增子序列的个数 ** 重点复习

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

    示例 1:

    输入: [1,3,5,4,7]
    输出: 2
    解释: 有两个最长递增子序列,分别是 [1, 3, 4, 7] 和[1, 3, 5, 7]。
    

    解法1: 动态规划 O ( n 2 ) O(n^2) O(n2)

    class Solution:
        def findNumberOfLIS(self, nums: List[int]) -> int:
            # 个数
            nums_len = len(nums)
            length = []
            counts = [] # 第i结尾时,最长递增序列的个数
            for i in range(nums_len):
                length.append(1)
                counts.append(1)
                for j in range(i):
                    if nums[j] < nums[i]: # i 可以放到j后 构成递增序列
                        if length[i] <= length[j]:  # 或者 length[i] < length[j] + 1:
                            length[i] = length[j]+1
                            counts[i] = counts[j] # 长度个数更新
                        elif length[i] == length[j]+1:
                            # 相等
                            counts[i] += counts[j] # 相加
                        
            max_length = max(length)
            max_count = 0
            for i in range(len(length)):  # 长度最长的 对应count数目之和
                if length[i] == max_length:
                    max_count += counts[i]
    
            return max_count
    

    1143. 最长公共子序列 ** 动态规划典型题目

    给定两个字符串 text1text2,返回这两个字符串的最长公共子序列的长度。

    一个字符串的 子序列 是指这样一个新的字符串:它是由原字符串在不改变字符的相对顺序的情况下删除某些字符(也可以不删除任何字符)后组成的新字符串。
    例如,"ace" 是 “abcde” 的子序列,但 “aec” 不是 “abcde” 的子序列。两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。

    若这两个字符串没有公共子序列,则返回 0。

    示例 1:

    输入:text1 = "abcde", text2 = "ace" 
    输出:3  
    解释:最长公共子序列是 "ace",它的长度为 3。
    

    解法1: 动态规划重点题

    class Solution:
        def longestCommonSubsequence(self, text1: str, text2: str) -> int:
            # 两个字符串的 最长公共子序列
            # 典型动态规划题目, 面试常考题 重点复习记忆, 和 不同路径题目 很相似,都是 典型动态规划题目
            text1_len = len(text1)
            text2_len = len(text2)
            dp = [[0] * (text2_len+1) for _ in range(text1_len+1)]  
            # dp[i][j]: 表示text1[0...i-1]和text2[0...j-1]的最长公共子序列的长度
            # dp[0][0]: 表示 text1和text2为null时 最长公共子序列 为0;
            # dp[1][1]: 表示text1[0]和text2[0]的 最长公共子序列长度; 
            for i in range(1, text1_len+1): # 注意边界条件
                for j in range(1, text2_len+1):
                    if text1[i-1] == text2[j-1]:
                        dp[i][j] = dp[i-1][j-1] + 1
                    else:  # 递归公式
                        dp[i][j] = max(dp[i][j-1], dp[i-1][j])
           
            return dp[text1_len][text2_len]
    

    718. 最长重复子数组 ** 动态规划

    给两个整数数组 AB ,返回两个数组中公共的、长度最长的子数组的长度。
    示例:

    输入:
    A: [1,2,3,2,1]
    B: [3,2,1,4,7]
    输出:3
    解释:
    长度最长的公共子数组是 [3, 2, 1] 。
    

    解法1: 动态规划

    class Solution:
        def findLength(self, A: List[int], B: List[int]) -> int:
            #  动态规划
            # 子数组 是 连续的!切记! 子序列不是连续的! 连续子序列是连续的!
            A_len = len(A)
            B_len = len(B)
            dp = [[0]*(B_len+1) for _ in range(A_len+1)]
            max_res = 0
            for i in range(1, A_len+1):
                for j in range(1, B_len+1):
                    if A[i-1] == B[j-1]:  # 连续条件的判断呢? 
                        dp[i][j] = dp[i-1][j-1] + 1
                    else:  # 注意递推条件的改变;
                        dp[i][j] = 0  # 不相等就是 0,【保证连续】
                        # dp[i][j] = max(dp[i][j-1], dp[i-1][j])
                    max_res = max(max_res, dp[i][j])
            # print(dp)
            return max_res
    

    724. 寻找数组的中心索引

    给你一个整数数组 nums,请编写一个能够返回数组 “中心索引” 的方法。

    数组 中心索引 是数组的一个索引,其左侧所有元素相加的和等于右侧所有元素相加的和。

    如果数组不存在中心索引,返回 -1 。如果数组有多个中心索引,应该返回最靠近左边的那一个。

    注意: 中心索引可能出现在数组的两端。

    解法1: 前缀和

    class Solution:
        def pivotIndex(self, nums: List[int]) -> int:
            total = sum(nums)
            acc_sum = 0
            for i in range(len(nums)):
                if acc_sum == total - acc_sum - nums[i]:
                    return i
                acc_sum += nums[i]
            return -1
    

    560. 和为K的子数组 *

    给定一个整数数组和一个整数 k,你需要找到该数组中和为 k 的连续的子数组的个数。

    示例 1:

    输入:nums = [1,1,1], k = 2
    输出: 2 , [1,1] 与 [1,1] 为两种不同的情况。
    

    说明 :

    • 数组的长度为 [1, 20,000]。
    • 数组中元素的范围是 [-1000, 1000] ,且整数 k 的范围是 [-1e7, 1e7]。
    class Solution:
        def subarraySum(self, nums: List[int], k: int) -> int:
            # python 枚举超时
            # 前缀和 + 哈希表 优化
            count = 0
            hashtable = {0:1} # 前缀和作为key,出现次数为value, 存储前缀和;
            preSum = 0 # 前缀和
            for item in nums:
                preSum += item
                if hashtable.get(preSum-k): # 脑子疼..........
                    count += hashtable.get(preSum-k)
                if preSum not in hashtable:
                    hashtable[preSum] = 1  # 
                else:
                    hashtable[preSum] = hashtable[preSum] + 1
            # print(hashtable)
            return count
    

    523. 连续的子数组和 * 重点复习

    给定一个包含 非负数 的数组和一个目标 整数 k,编写一个函数来判断该数组是否含有连续的子数组,其大小至少为 2,且总和为 k 的倍数,即总和为 n*k,其中 n 也是一个整数

    示例 1:

    输入:[23,2,4,6,7], k = 6
    输出:True
    解释:[2,4] 是一个大小为 2 的子数组,并且和为 6。
    

    示例 2:

    输入:[23,2,6,4,7], k = 6
    输出:True
    解释:[23,2,6,4,7]是大小为 5 的子数组,并且和为 42。
    

    说明:

    • 数组的长度不会超过 10,000 。
    • 你可以认为所有数字总和在 32 位有符号整数范围内。

    解法1: 前缀和的 思想
    详解

    class Solution:
        def checkSubarraySum(self, nums: List[int], k: int) -> bool:
            # 连续子数组 其大小 >= 2;
            # n 是一个整数,有可能是负数(k<0)
            hashtable = {0:-1} # key: 前缀和%k, value: 索引
            preSum = 0
            for index, item in enumerate(nums):
                preSum += item
                if k != 0:
                    preSum = preSum % k  # 重点
                if hashtable.get(preSum) != None: # python 为0 也算 (索引有可能为0)
                    if index - hashtable.get(preSum)> 1:
                        return True
                else:
                    hashtable[preSum] = index
    
            return False
    

    974. 和可被 K 整除的子数组

    给定一个整数数组 A,返回其中元素之和可被 K 整除的(连续、非空)子数组的数目。

    示例:

    输入:A = [4,5,0,-2,-3,1], K = 5
    输出:7
    解释:
    有 7 个子数组满足其元素之和可被 K = 5 整除:
    [4, 5, 0, -2, -3, 1], [5], [5, 0], [5, 0, -2, -3], [0], [0, -2, -3], [-2, -3]
    

    提示:

    • 1 <= A.length <= 30000
    • -10000 <= A[i] <= 10000
    • 2 <= K <= 10000

    解法1: 前缀和
    思路:
    那么每个连续子数组的和 s u m ( i , j ) sum(i,j) sum(i,j)就可以写成$ P[j] - P[i-1]$, 此时,判断子数组的和能否被 K K K 整除就等价于判断 ( P [ j ] − P [ i − 1 ] )   m o d   K = = 0 (P[j] - P[i-1]) \bmod K == 0 (P[j]P[i1])modK==0,根据 同余定理,只要 P [ j ]   m o d   K = = P [ i − 1 ]   m o d   K P[j] \bmod K == P[i-1] \bmod K P[j]modK==P[i1]modK,就可以保证上面的等式成立。

    class Solution:
        def subarraysDivByK(self, A: List[int], K: int) -> int:
            dicts = {0:1}
            preSum = 0
            count = 0
            for item in A:
                preSum += item
                if K != 0:
                    preSum = preSum % K  ## 取模
                if dicts.get(preSum) != None:
                    count += dicts[preSum]   ## 统计已有的, 已有的每个和 当前这个 都可以组成满足条件的 子数组;
                    dicts[preSum] += 1
                else:
                    dicts[preSum] = 1
    
            return count
    

    1248. 统计「优美子数组」

    给你一个整数数组 nums 和一个整数 k

    如果某个 连续 子数组中恰好有 k 个奇数数字,我们就认为这个子数组是「优美子数组」。

    请返回这个数组中「优美子数组」的数目。

    示例 1:

    输入:nums = [1,1,2,1,1], k = 3
    输出:2
    解释:包含 3 个奇数的子数组是 [1,1,2,1] 和 [1,2,1,1] 。
    

    方法1:

    class Solution:
        def numberOfSubarrays(self, nums: List[int], k: int) -> int:
            # 如何统计k个 奇数数字 
            odd_list = {0:1}
            odd_s = 0 # 类似前缀和 (奇数出现之和)
            count = 0  
            for item in nums:
                if item % 2 != 0: # 奇数
                    odd_s += 1
                if odd_list.get(odd_s - k):
                    count += odd_list.get(odd_s - k)
                # count += odd_list.get(odd_s - k, 0)
                if odd_s not in odd_list:
                    odd_list[odd_s] = 1
                else:
                    odd_list[odd_s] += 1
            
            return count
    

    713. 乘积小于K的子数组 ** 多复习

    给定一个正整数数组 nums

    找出该数组内乘积小于 k 的连续的子数组的个数。

    示例 1:

    输入: nums = [10,5,2,6], k = 100
    输出: 8
    解释: 8个乘积小于100的子数组分别为: [10], [5], [2], [6], [10,5], [5,2], [2,6], [5,2,6]。
    需要注意的是 [10,5,2] 并不是乘积小于100的子数组。
    

    解法1: 双指针

    class Solution:
        def numSubarrayProductLessThanK(self, nums: List[int], k: int) -> int:
            # 数组内都是正整数
            if k <= 1:
                return 0
            acc = 1
            left = 0
            count = 0
            for right, value in enumerate(nums):
                acc *= value
                while acc >= k:  # 组内都是正整数才满足
                    acc /= nums[left]
                    left += 1
                count += right - left + 1  # 很巧妙
            return count
    

    325. 和等于 k 的最长子数组长度

    给定一个数组 nums 和一个目标值 k,找到和等于 k 的最长子数组长度。如果不存在任意一个符合要求的子数组,则返回 0。

    注意:
    nums 数组的总和是一定在 32 位有符号整数范围之内的。

    示例 1:

    输入: nums = [1, -1, 5, -2, 3], k = 3
    输出: 4 
    解释: 子数组 [1, -1, 5, -2] 和等于 3,且长度最长。
    

    解法1: 前缀和

    class Solution:
        def maxSubArrayLen(self, nums: List[int], k: int) -> int:
            # 记下索引位置吗
            prelist = {0:-1}
            presum = 0
            max_len = 0
            for index, item in enumerate(nums):
                presum += item
                if prelist.get(presum-k) != None: # 切记必须使用None
                    max_len = max(max_len, index-prelist.get(presum-k))
                if presum not in prelist:
                    prelist[presum] = index
    
            return max_len
    

    152. 乘积最大子数组 *

    给你一个整数数组 nums ,请你找出数组中乘积最大的连续子数组(该子数组中至少包含一个数字),并返回该子数组所对应的乘积。

    示例 1:

    输入: [2,3,-2,4]
    输出: 6
    解释: 子数组 [2,3] 有最大乘积 6。
    

    解法1: 动态规划

    class Solution:
        def maxProduct(self, nums: List[int]) -> int:
            # 求乘积和求和是 有些不同
            # 动态规划
            if len(nums) <= 0:
                return 0
            # 两个数组 
            minValue = nums[0] # 有最大值 最小值 
            maxValue = nums[0]
            ans = nums[0]
            for i in range(1, len(nums)):
                temp = minValue # 切记 ; 
                minValue = min(minValue*nums[i], nums[i], maxValue*nums[i])
                maxValue = max(temp*nums[i], nums[i], maxValue*nums[i])
                ans = max(ans, maxValue)
            return ans
    

    238. 除自身以外数组的乘积 *

    给你一个长度为 n 的整数数组 nums,其中 n > 1,返回输出数组 output ,其中 output[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。

    示例:

    输入: [1,2,3,4]
    输出: [24,12,8,6]
    

    提示: 题目数据保证数组之中任意元素的全部前缀元素和后缀(甚至是整个数组)的乘积都在 32 位整数范围内。

    说明: 请不要使用除法,且在 O(n) 时间复杂度内完成此题。

    进阶:
    你可以在常数空间复杂度内完成这个题目吗?( 出于对空间复杂度分析的目的,输出数组不被视为额外空间。)

    解法1: 左部分*右部分, 注意边界条件

    class Solution:
        def productExceptSelf(self, nums: List[int]) -> List[int]:
            # 两次遍历, 左部分乘积, 右部分乘积;结果:左部分乘积*右部分乘积;
            # 左右两端,都为1
            left = 1
            nums_len = len(nums)
            res = [0]*nums_len
            for i in range(nums_len):
                if i > 0:  # 注意边界条件
                    left = left*nums[i-1]
                res[i] = left
            # 右部分
            right = 1
            for i in range(nums_len-1, -1, -1):
                if i < nums_len-1:
                    right = right*nums[i+1]
                res[i] = res[i]*right  # 注意边界条件
            return res
    
    展开全文
  • ISAM表如果把一个NULL插入到一个AUTO_INCREMENT数据列里去,MySQL将自动生成下一个序列编号。编号从1开始,并1为基数递增。当插入记录时,没有为AUTO_INCREMENT明确指定值,则等同插入NULL值。当插入记...

    在数据库应用,我们经常要用到唯一编号。在MySQL中可通过字段的AUTO_INCREMENT属性来自动生成。MySQL支持多种数据表,每种数据表的自增属性都有所不同。

    ISAM表

    如果把一个NULL插入到一个AUTO_INCREMENT数据列里去,MySQL将自动生成下一个序列编号。编号从1开始,并1为基数递增。

    当插入记录时,没有为AUTO_INCREMENT明确指定值,则等同插入NULL值。

    当插入记录时,如果为AUTO_INCREMENT字段明确指定了一个数值,则会出现两种情况,情况一,如果插入的值与已有的编号重复,则会出现出错信息,因为AUTO_INCREMENT数据列的值必须是唯一的;情况二,如果插入的值大于已编号的值,则会把该插入到数据列中,并使在下一个编号将从这个新值开始递增。也就是说,可以跳过一些编号。

    如果自增序列的最大值被删除了,则在插入新记录时,该值被重用。

    如果用UPDATE命令更新自增列,如果列值与已有的值重复,则会出错。如果大于已有值,则下一个编号从该值开始递增。

    如果用replace命令基于AUTO_INCREMENT数据列里的值来修改数据表里的现有记录,即AUTO_INCREMENT数据列出现在了replace命令的where子句里,相应的AUTO_INCREMENT值将不会发生变化。但如果replace命令是通过其它的PRIMARY

    KEY OR

    UNIQUE索引来修改现有记录的(即AUTO_INCREMENT数据列没有出现在replace命令的where子句中),相应的AUTO_INCREMENT值--如果设置其为NULL(如没有对它赋值)的话--就会发生变化。

    last_insert_id()函数可获得自增列自动生成的最后一个编号。但该函数只与服务器的本次会话过程中生成的值有关。如果在与服务器的本次会话中尚未生成AUTO_INCREMENT值,则该函数返回0。

    其它数据表的自动编号机制都以ISAM表中的机制为基础。

    MyISAM数据表

    删除最大编号的记录后,该编号不可重用。

    可在建表时可用“AUTO_INCREMENT=n”选项来指定一个自增的初始值。

    可用alter table table_name AUTO_INCREMENT=n命令来重设自增的起始值。

    可使用复合索引在同一个数据表里创建多个相互独立的自增序列,具体做法是这样的:为数据表创建一个由多个数据列组成的PRIMARY KEY OR

    UNIQUE索引,并把AUTO_INCREMENT数据列包括在这个索引里作为它的最后一个数据列。这样,这个复合索引里,前面的那些数据列每构成一种独一无二的组合,最末尾的AUTO_INCREMENT数据列就会生成一个与该组合相对应的序列编号。

    HEAP数据表

    HEAP数据表从MySQL4.1开始才允许使用自增列。

    自增值可通过CREATE TABLE语句的 AUTO_INCREMENT=n选项来设置。

    可通过ALTER TABLE语句的AUTO_INCREMENT=n选项来修改自增始初值。

    编号不可重用。

    HEAP数据表不支持在一个数据表中使用复合索引来生成多个互不干扰的序列编号。

    BDB数据表

    不可通过CREATE TABLE OR ALTER TABLE的AUTO_INCREMENT=n选项来改变自增初始值。

    可重用编号。

    支持在一个数据表里使用复合索引来生成多个互不干扰的序列编号。

    InnDB数据表

    不可通过CREATE TABLE OR ALTER TABLE的AUTO_INCREMENT=n选项来改变自增初始值。

    不可重用编号。

    不支持在一个数据表里使用复合索引来生成多个互不干扰的序列编号。

    注意

    在使用AUTO_INCREMENT时,应注意以下几点:

    AUTO_INCREMENT是数据列的一种属性,只适用于整数类型数据列。

    设置AUTO_INCREMENT属性的数据列应该是一个正数序列,所以应该把该数据列声明为UNSIGNED,这样序列的编号个可增加一倍。

    AUTO_INCREMENT数据列必须有唯一索引,以避免序号重复。

    AUTO_INCREMENT数据列必须具备NOT NULL属性。

    AUTO_INCREMENT数据列序号的最大值受该列的数据类型约束,如TINYINT数据列的最大编号是127,如加上UNSIGNED,则最大为255。一旦达到上限,AUTO_INCREMENT就会失效。

    当进行全表删除时,AUTO_INCREMENT会从1重新开始编号。全表删除的意思是发出以下两条语句时:

    delete from table_name;或者 truncate table

    table_name

    这是因为进行全表操作时,MySQL实际是做了这样的优化操作:先把数据表里的所有数据和索引删除,然后重建数据表。如果想删除所有的数据行又想保留序列编号信息,可这样用一个带where的delete命令以抑制MySQL的优化:

    delete from table_name where 1;

    这将迫使MySQL为每个删除的数据行都做一次条件表达式的求值操作。

    强制MySQL不复用已经使用过的序列值的方法是:另外创建一个专门用来生成AUTO_INCREMENT序列的数据表,并做到永远不去删除该表的记录。当需要在主数据表里插入一条记录时,先在那个专门生成序号的表中插入一个NULL值以产生一个编号,然后,在往主数据表里插入数据时,利用LAST_INSERT_ID()函数取得这个编号,并把它赋值给主表的存放序列的数据列。如:

    insert into id set id = NULL;insert into main set main_id =

    LAST_INSERT_ID();

    可用alter命令给一个数据表增加一个具有AUTO_INCREMENT属性的数据列。MySQL会自动生成所有的编号。

    要重新排列现有的序列编号,最简单的方法是先删除该列,再重建该,MySQL会重新生连续的编号序列。

    在不用AUTO_INCREMENT的情况下生成序列,可利用带参数的LAST_INSERT_ID()函数。如果用一个带参数的LAST_INSERT_ID(expr)去插入或修改一个数据列,紧接着又调用不带参数的LAST_INSERT_ID()函数,则第二次函数调用返回的就是expr的值。下面演示该方法的具体操作:

    先创建一个只有一个数据行的数据表:create table seq_table (id int unsigned not null);insert

    into seq_table values (0);接着用以下操作检索出序列号:

    update seq_table set seq = LAST_INSERT_ID( seq + 1 );select

    LAST_INSERT_ID();

    通过修改seq+1中的常数值,可生成不同步长的序列,如seq+10可生成步长为10的序列。

    该方法可用于计数器,在数据表中插入多行以记录不同的计数值。再配合LAST_INSERT_ID()函数的返回值生成不同内容的计数值。这种方法的优点是不用事务或LOCK,UNLOCK表就可生成唯一的序列编号。不会影响其它客户程序的正常表操作。

    展开全文
  • java的序列序列化 1、我们先看一下《java编程思想》第四版中对序列化定义 对象序列化 Java 1.1 增添了一种有趣的特性,名为“对象序列化”( Object Serialization)。它面向那些实现了 ...

      java的序列化 和 反序列化

    1、我们先看一下《java编程思想》第四版中对序列化定义

    对象序列化
    Java 1.1 增添了一种有趣的特性,名为“对象序列化”( Object Serialization)。它面向那些实现了
    Serializable 接口的对象,可将它们转换成一系列字节,并可在以后完全恢复回原来的样子。这一过程亦可
    通过网络进行。这意味着序列化机制能自动补偿操作系统间的差异。换句话说,可以先在Windows 机器上创
    建一个对象,对其序列化,然后通过网络发给一台 Unix 机器,然后在那里准确无误地重新“装配”。不必关
    心数据在不同机器上如何表示,也不必关心字节的顺序或者其他任何细节。
    就其本身来说,对象的序列化是非常有趣的,因为利用它可以实现“有限持久化”。请记住“持久化”意味
    着对象的“生存时间”并不取决于程序是否正在执行—— 它存在或“生存”于程序的每一次调用之间。通过
    序列化一个对象,将其写入磁盘,以后在程序重新调用时重新恢复那个对象,就能圆满实现一种“持久”效
    果。之所以称其为“有限”,是因为不能用某种“ persistent”(持久)关键字简单地地定义一个对象,并
    让系统自动照看其他所有细节问题(尽管将来可能成为现实)。相反,必须在自己的程序中明确地序列化和
    组装对象。
    语言里增加了对象序列化的概念后,可提供对两种主要特性的支持。 Java 1.1 的“远程方法调用”( RMI)
    使本来存在于其他机器的对象可以表现出好象就在本地机器上的行为。将消息发给远程对象时,需要通过对
    象序列化来传输参数和返回值。 RMI 将在第 15 章作具体讨论。
    对象的序列化也是 Java Beans 必需的,后者由 Java 1.1 引入。使用一个 Bean 时,它的状态信息通常在设计
    期间配置好。程序启动以后,这种状态信息必须保存下来,以便程序启动以后恢复;具体工作由对象序列化
    完成。
    对象的序列化处理非常简单,只需对象实现了 Serializable 接口即可(该接口仅是一个标记,没有方法)。
    在 Java 1.1 中,许多标准库类都发生了改变,以便能够序列化—— 其中包括用于基本数据类型的全部封装
    器、所有集合类以及其他许多东西。甚至 Class 对象也可以序列化(第 11 章讲述了具体实现过程)。
    为序列化一个对象,首先要创建某些 OutputStream 对象,然后将其封装到 ObjectOutputStream 对象内。此
    时,只需调用 writeObject()即可完成对象的序列化,并将其发送给 OutputStream。相反的过程是将一个
    InputStream 封装到 ObjectInputStream 内,然后调用 readObject()。和往常一样,我们最后获得的是指向
    一个上溯造型 Object 的句柄,所以必须下溯造型,以便能够直接设置。
    对象序列化特别“聪明”的一个地方是它不仅保存了对象的“全景图”,而且能追踪对象内包含的所有句柄
    并保存那些对象;接着又能对每个对象内包含的句柄进行追踪;以此类推。我们有时将这种情况称为“对象
    网”,单个对象可与之建立连接。而且它还包含了对象的句柄数组以及成员对象。若必须自行操纵一套对象
    序列化机制,那么在代码里追踪所有这些链接时可能会显得非常麻烦。在另一方面,由于Java 对象的序列化
    似乎找不出什么缺点,所以请尽量不要自己动手,让它用优化的算法自动维护整个对象网。

    下面是序列化的小例子:

    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    
    public class Person implements Serializable {
    	private static final long serialVersionUID = 1L;
    	private String name;
    	
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	
    	@Override
    	public String toString() {
    		return "Person [name=" + name + "]";
    	}
    	public static void main(String[] args)  {
    		Person p=new Person();
    		p.setName("张三");
    		try {
    			
    		File f=new File("d:/3.txt");
    		if(!f.exists()){
    			f.createNewFile();
    		}
    		
    		ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(f));
    		
    		
    		oos.writeObject(p);
    		oos.flush();
    		oos.close();
    		
    		} catch (Exception e) {
    			e.printStackTrace();
    			// TODO: handle exception
    		}
    		
    		try {
    			ObjectInputStream ois=new ObjectInputStream(new FileInputStream("d:/3.txt"));
    			
    			Person pp=(Person)ois.readObject();
    			System.out.println(pp);
    			
    		} catch (Exception e) {
    			e.printStackTrace();
    			// TODO: handle exception
    		}
    	
    		
    	}
    	
    	
    }
    
    结果为:

    Person [name=张三]

    从上面的代码中可以知道序列化对象读取序列化对象过程中最要的两个函数是OutStream的writeObject和InputStream的readObject ,这个序列化过程是默认的。当然如果有特殊要求可以自己定制序列化。下面是书中例子

    2、序列化的控制
    正如大家看到的那样,默认的序列化机制并不难操纵。然而,假若有特殊要求又该怎么办呢?我们可能有特殊的安全问题,不希望对象的某一部分序列化;或者某一个子对象完全不必序列化,因为对象恢复以后,那一部分需要重新创建。此时,通过实现 Externalizable 接口,用它代替 Serializable 接口,便可控制序列化的具体过程。这个
    Externalizable 接口扩展了 Serializable,并增添了两个方法: writeExternal()和 readExternal()。在序
    列化和重新装配的过程中,会自动调用这两个方法,以便我们执行一些特殊操作。
    下面这个例子展示了 Externalizable 接口方法的简单应用。注意 Blip1 和 Blip2 几乎完全一致,除了极微小

    的差别(自己研究一下代码,看看是否能发现):

    //: Blips.java
    // Simple use of Externalizable & a pitfall
    import java.io.*;
    import java.util.*;
    
    class Blip1 implements Externalizable {
        public Blip1() {
            System.out.println("Blip1 Constructor");
        }
    
        public void writeExternal(ObjectOutput out) throws IOException {
            System.out.println("Blip1.writeExternal");
        }
    
        public void readExternal(ObjectInput in) throws IOException,
                ClassNotFoundException {
            System.out.println("Blip1.readExternal");
        }
    }
    
    class Blip2 implements Externalizable {
        Blip2() {
            System.out.println("Blip2 Constructor");
        }
    
        public void writeExternal(ObjectOutput out) throws IOException {
            System.out.println("Blip2.writeExternal");
        }
    
        public void readExternal(ObjectInput in) throws IOException,
                ClassNotFoundException {
            System.out.println("Blip2.readExternal");
        }
    }
    
    public class Blips {
        public static void main(String[] args) {
            System.out.println("Constructing objects:");
            Blips b1 = new Blips();
            Blip2 b2 = new Blip2();
            try {
                ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream(
                        "Blips.out"));
                System.out.println("Saving objects:");
                o.writeObject(b1);
                o.writeObject(b2);
                o.close();
                // Now get them back:
                ObjectInputStream in = new ObjectInputStream(new FileInputStream(
                        "Blips.out"));
                System.out.println("Recovering b1:");
                b1 = (Blips) in.readObject();
                // OOPS! Throws an exception:
                // ! System.out.println("Recovering b2:");
                // ! b2 = (Blip2)in.readObject();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    } // /:~
    

    该程序输出如下:
    Constructing objects:
    Blip1 Constructor
    Blip2 Constructor
    Saving objects:
    Blip1.writeExternal
    Blip2.writeExternal
    Recovering b1:
    Blip1 Constructor
    Blip1.readExternal
    未恢复 Blip2 对象的原因是那样做会导致一个违例。你找出了 Blip1 和 Blip2 之间的区别吗? Blip1 的构建
    器是“公共的”( public), Blip2 的构建器则不然,这样便会在恢复时造成违例。试试将 Blip2 的构建器
    属性变成“ public”,然后删除//!注释标记,看看是否能得到正确的结果。
    恢复 b1 后,会调用 Blip1 默认构建器。这与恢复一个 Serializable(可序列化)对象不同。在后者的情况
    下,对象完全以它保存下来的二进制位为基础恢复,不存在构建器调用。而对一个Externalizable 对象,所
    有普通的默认构建行为都会发生(包括在字段定义时的初始化),而且会调用readExternal()。必须注意这
    一事实—— 特别注意所有默认的构建行为都会进行— — 否则很难在自己的 Externalizable 对象中产生正确的
    行为。
    下面这个例子揭示了保存和恢复一个 Externalizable 对象必须做的全部事情:

    //: Blip3.java
    // Reconstructing an externalizable object
    import java.io.Externalizable;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInput;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutput;
    import java.io.ObjectOutputStream;
    
    class Blip3 implements Externalizable {
    	int i;
    	String s; // No initialization
    
    	public Blip3() {
    		System.out.println("Blip3 Constructor");
    		// s, i not initialized
    	}
    
    	public Blip3(String x, int a) {
    		System.out.println("Blip3(String x, int a)");
    		s = x;
    		i = a;
    		// s & i initialized only in non-default
    		// constructor.
    	}
    
    	public String toString() {
    		return s + i;
    	}
    
    	public void writeExternal(ObjectOutput out) throws IOException {
    		System.out.println("Blip3.writeExternal");
    		// You must do this:
    		out.writeObject(s);
    		out.writeInt(i);
    	}
    
    	public void readExternal(ObjectInput in) throws IOException,
    			ClassNotFoundException {
    		System.out.println("Blip3.readExternal");
    		// You must do this:
    		s = (String) in.readObject();
    		i = in.readInt();
    	}
    
    	public static void main(String[] args) {
    		System.out.println("Constructing objects:");
    		Blip3 b3 = new Blip3("A String ", 47);
    		System.out.println(b3.toString());
    		try {
    			ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream(
    					"Blip3.out"));
    			System.out.println("Saving object:");
    			o.writeObject(b3);
    			o.close();
    			// Now get it back:
    			ObjectInputStream in = new ObjectInputStream(new FileInputStream(
    					"Blip3.out"));
    			System.out.println("Recovering b3:");
    			b3 = (Blip3) in.readObject();
    			System.out.println(b3.toString());
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    } // /:~

    其中,字段 s 和 i 只在第二个构建器中初始化,不关默认构建器的事。这意味着假如不在readExternal 中初
    始化 s 和 i,它们就会成为 null(因为在对象创建的第一步中已将对象的存储空间清除为 1)。若注释掉跟
    随于“ You must do this”后面的两行代码,并运行程序,就会发现当对象恢复以后, s 是 null,而 i 是
    零。
    若从一个 Externalizable 对象继承,通常需要调用 writeExternal()和 readExternal()的基础类版本,以便
    正确地保存和恢复基础类组件。
    所以为了让一切正常运作起来,千万不可仅在 writeExternal()方法执行期间写入对象的重要数据(没有默
    认的行为可用来为一个 Externalizable 对象写入所有成员对象)的,而是必须在 readExternal()方法中也
    恢复那些数据。初次操作时可能会有些不习惯,因为Externalizable 对象的默认构建行为使其看起来似乎正
    在进行某种存储与恢复操作。但实情并非如此。

    3、transient(临时)关键字


    控制序列化过程时,可能有一个特定的子对象不愿让Java 的序列化机制自动保存与恢复。一般地,若那个子
    对象包含了不想序列化的敏感信息(如密码),就会面临这种情况。即使那种信息在对象中具有“ private”
    (私有)属性,但一旦经序列化处理,人们就可以通过读取一个文件,或者拦截网络传输得到它。
    为防止对象的敏感部分被序列化,一个办法是将自己的类实现为Externalizable,就象前面展示的那样。这
    样一来,没有任何东西可以自动序列化,只能在writeExternal()明确序列化那些需要的部分。
    然而,若操作的是一个 Serializable 对象,所有序列化操作都会自动进行。为解决这个问题,可以用
    transient(临时) 逐个字段地关闭序列化,它的意思是“不要麻烦你(指自动机制)保存或恢复它了—— 我
    会自己处理的”。
    例如,假设一个 Login 对象包含了与一个特定的登录会话有关的信息。校验登录的合法性时,一般都想将数
    据保存下来,但不包括密码。为做到这一点,最简单的办法是实现Serializable,并将 password 字段设为
    transient。有时候需要序列化的对象中的属性包含有不能序列化的对象。例如下面的例子:

    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    
    public class Person implements Serializable {
    	private static final long serialVersionUID = 1L;
    	private String name;
    	private Student student;
    	
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public Student getStudent() {
    		return student;
    	}
    	public void setStudent(Student student) {
    		this.student = student;
    	}
    	
    	@Override
    	public String toString() {
    		return "Person [name=" + name + ", student=" + student + "]";
    	}
    	public static void main(String[] args)  {
    		Person p=new Person();
    		p.setStudent(new Student("张三","4岁"));
    		p.setName("学生");
    		try {
    			
    		File f=new File("d:/3.txt");
    		if(!f.exists()){
    			f.createNewFile();
    		}
    		
    		ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(f));
    		
    		
    		oos.writeObject(p);
    		oos.flush();
    		oos.close();
    		
    		} catch (Exception e) {
    			e.printStackTrace();
    			// TODO: handle exception
    		}
    		
    		try {
    			ObjectInputStream ois=new ObjectInputStream(new FileInputStream("d:/3.txt"));
    			
    			Person pp=(Person)ois.readObject();
    			System.out.println(pp);
    			
    		} catch (Exception e) {
    			e.printStackTrace();
    			// TODO: handle exception
    		}
    	
    		
    	}
    	
    	
    }
    
    class Student {
    
    	private String name;
    	private String age;
    	
    	
    	
    	public Student() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    	
    	public Student(String name, String age) {
    		super();
    		this.name = name;
    		this.age = age;
    	}
    
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getAge() {
    		return age;
    	}
    	public void setAge(String age) {
    		this.age = age;
    	}
    	@Override
    	public String toString() {
    		return "Student [name=" + name + ", age=" + age + "]";
    	}
    	
    	
    	
    }
    

    执行结果报错:

    java.io.NotSerializableException: Student

    这是由于Student 类不可以序列化, 在这种情况下,可以给Student 添加 transient 关键字,

        private transient Student student;

    执行结果:

    Person [name=学生, student=null]

    如果Student是可以序列化的,Student类实现Serializable,去掉transient 关键字:

    执行结果:

    Person [name=学生, student=Student [name=张三, age=4岁]]

    4 总结
    序列化:将java对象转换为字节序列的过程叫做序列化

    反序列化:将字节对象转换为java对象的过程叫做反序列化

    通过实现 Externalizable 接口,用它代替 Serializable 接口,便可控制序列化的具体过程,这个
    Externalizable 接口扩展了 Serializable,并增添了两个方法: writeExternal()和 readExternal()。

    transient 可以使某些属性不被序列化,但是如果是实现了Externalizable接口的类中属性添加 transient也是会被序列化的.



    本文参考了<java编程思想>第四版 第10章第九节

    展开全文
  • 卷积神经网络通过学习模块化模式概念的层次结构来表示视觉世界。 卷积神经网络学到的表示很容易可视化,卷积神经网络不是黑盒。 现在你能够从头开始训练自己的卷积神经网络来解决图像分类问题。 你知道了如何使用...
  • 6416490681073670164 = ... 10 | 20redis提供了TIME命令,取得redis服务器的秒值微秒值毫秒值获取命令:EVAL "local current = redis.call('TIME') ;return a[1]*1000 + a[2]/1000" 0生成最终ID : current &...
  • /** * * @author sosozha *在学习求最大子序列和的时候自己也能写出前两种方法,第三种方法需要费点心思去想,然后引出其与快排类似的用法 而后引出快排代码的原理解释 */public class MaxSubSequence {...
  • 本文解决最大子序列和问题,有两个题目组成,第二个题目比第一个要求多一些(其实就是要求输出子序列首尾元素)。  01-复杂度1最大子列问题(20分)  给定KK个整数组成的序列{N1​​,N2​​, ...,NK​​},...
  • 冒泡排序及其优化

    2020-08-11 21:17:52
    冒泡排序算法是一种典型的比较交换排序算法,在一个序列中进行数据的两两比较,如何目标序列的规则相反就进行位置交换,如果相符,则两者的位置不变。故而冒泡排序是一个稳定的排序算法。 二 冒泡排序的实现过程 ...
  • 还以为要手工加入(開是手工加入的),今天遇到分页的问题,才发现生成的时候能够加入插件。既然分页能够有插件。序列化是不是也有呢。 果然SerializablePlugin,已经给我们提供好了。 &lt;plugin type=&...
  • 最长递增子序列(LIS)

    2021-05-25 20:18:17
    Input: [6,3,4,5,7,1,2] Output: 4 complexity O ( n 2 ) O(n^2) O(n2)(常见的有:LCS最长公共子序列、等值长优先、等长小优先) O ( n ∗ log ⁡ n ) O(n*\log{n}) O(n∗logn)(常见的有:等值长优先优化、...
  • 而我们可能从到终都用不到该实例对象,从而在一定程度上造成内存的浪费。 懒汉式 解决饿汉式浪费内存的问题 public class Singleton { private static Singleton instance; private Singleton() { } public static...
  • 运筹优化(七)--动态规划解析

    万次阅读 多人点赞 2019-01-15 20:15:30
    动态规划的思想随处可见,用同事的话说,就是一种很朴素的方法,我之所以记录这么多文字,是今天看完动态规划,突然发现,有时候,静下心,好好理解理解最最基础的理论原理,你对这个算法的体会理解会完全不一样。...
  • 3675: [Apio2014]序列切割 Time Limit: 40 Sec Memory Limit: 128 MB ...Submit: 1468 Solved: 607 ...小H近期迷上了一个分隔序列的...小H须要将一个长度为n的非负整数序列切割成k+1个非空的子序列。为了得...
  • 直接用DP写了 然后就超时了 后来看到别人说要用二分把时间复杂度优化到O(n*logn) 果然如此 用一个栈s保存长度为i的LIS的最小尾部s[i] top为栈顶即当前LIS的长度 初始s[1]=a[1] top=1 遍历整个序列 当a...
  • 用法:CREATE TABLE test(id INT UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT,...在ISAM表如果把一个NULL插入到一个AUTO_INCREMENT数据列里去,MySQL将自动生成下一个序列编号。编号从1开始,并1为基数递增。把0插...
  • 单调递增子序列(二) 时间限制:1000ms | 内存限制:65535KB 难度:4 描写叙述 给定一整型数列{a1,a2...,an}(0<n<=100000)。找出单调递增最长子序列,并求出其长度。 如:1 9 10 5 11 2 13...
  • 计算机视觉算法机器学习算法大量使用了最优化理论。这篇文章简单总(fan)结(yi)了一下数值优化[1]这本书的第一章到第四章。包括了数值优化的定义,分类,以及无约束的非线性优化算法概述,介绍了梯度下降法,牛顿法...
  • 软件架构优化和设计

    千次阅读 2018-05-28 14:35:47
    软件架构优化和设计 本文转载自infoq,原文链接为 关于架构优化和设计,架构师必须知道的事情 概述 你可以叫它SOA的新玩法、微服务、或者任意其它酷炫的名字。近几年来随着互联网的飞速发展,新的架构实践方式...
  • 人脸识别库的优化

    千次阅读 2019-01-23 21:00:00
    所以,信息平台在做大型人员识别的优化时,主要从这三个方向入手: 1.终端优化 终端的优化分为硬件与软件。硬件上,主要针对摄像头采用宽动态技术,IPS优化,从捕捉画面前景与背景处理上达到清晰均衡的要求,解决...
  • 坐标轴交替下降法最速下降法牛顿法拟牛顿法线搜索下降算法:Step 0 给定初始点 , ;Step 1 判断 是否满足终止条件;是,则终止;Step 2 寻找 处的下降方向 ;Step 3 选择合适的步长 ...收敛速度设序列 收敛到 ,若存...
  • or truncate table table_name 这是因为进行全表操作时,MySQL实际是做了这样的优化操作:先把数据表里的所有数据索引删除,然 后重建数据表。如果想删除所有的数据行又想保留序列编号信息,可这样用一个带where...
  • 梯度法,共轭梯度法,牛顿法,拟牛顿法,蒙特卡洛法、Steepest Descent(SD)、L-BFGS等参数优化方法。 参数优化目标 在机器学习中,在定义好损失函数好,希望通过参数优化,使得损失函数最小。 2 梯度下降法(最...
  • 单例模式,顾名思义,就是一个类从至终只产生一个对象。现实生活中的例子有很多,比如在太阳系考虑问题,那么太阳地球都可称为单例,再比如工具类,有时候没有把所有方法用static修饰(这不是个好办法),就应该...
  • 优化问题2.多阶段决策3.最优性原理4.动态规划法的设计思想图问题中的动态规划TSP问题1.问题定义2.引入方程3.建立表格小感悟多段图的最短路径1.问题定义2.引入方程组合问题中的动态规划法0/1背包问题1.问题定义2....
  • IGDATaiwan上Unity 优化讲座III (罗志达) https://www.youtube.com/user/IGDATaiwan 议程:https://2019.tgdf.tw/agenda 今年 TGDF 台北遊戲開發者論壇,將有共五位Unity原廠講師,進行最前沿的技術分享,包括...
  • 长短期记忆细胞神经网络(LSTM)的出现较好地解决了股票预测这类的复杂序列化数据学习的问题。然而前期研究结果表明单一使用该方法仍存在预测不平衡、陷入局部极值导致能力不佳的问题。基于上述问题,文中利用将...
  • mysql自动序列生成

    千次阅读 2010-09-04 15:15:06
    这是因为进行全表操作时,MySQL实际是做了这样的优化操作:先把数据表里的所有数据索引删除,然后重建数据表。如果想删除所有的数据行又想保留序列编号信息,可这样用一个带where的delete命令以抑制MySQL的优化: ...
  • mysql自增序列

    2012-10-19 09:55:36
    这是因为进行全表操作时,MySQL实际是做了这样的优化操作:先把数据表里的所有数据索引删除,然后重建数据表。如果想删除所有的数据行又想保留序列编号信息,可这样用一个带where的delete命令以抑制MySQL的优化: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,596
精华内容 3,038
关键字:

优化序列和原始序列