频率很高的笔试题--动态规划类型(中)

àì夳堔傛蜴生んèń 2023-06-19 02:57 156阅读 0赞

### 动态规划解题算法 ###

*   *   *  1、预测赢家
         *  2、乘积最大子序列
         *  3、丑数
         *  4、跳跃游戏
         *  5、最长连接序列
         *  6、爬楼梯
         *  7、接雨水
         *  8、最长公共子序列
         *   *   *  可以不连续的子序列
                 *  要求连续的子序列
                 *  要求输出最长公共子串
         *  9、背包问题
         *   *   *  01 背包
                 *  完全背包
                 *  多重背包

### 1、预测赢家 ###

给定一个表示分数的非负整数数组。 玩家1从数组任意一端拿取一个分数，随后玩家2继续从剩余数组任意一端拿取分数，然后玩家1拿，……。每次一个玩家只能拿取一个分数，分数被拿取之后不再可取。直到没有剩余分数可取时游戏结束。最终获得分数总和最多的玩家获胜。

给定一个表示分数的数组，预测玩家1是否会成为赢家。你可以假设每个玩家的玩法都会使他的分数最大化。

> 示例1  
> 输入: \[1, 5, 2\]  
> 输出: False  
> 解释: 一开始，玩家1可以从1和2中进行选择。  
> 如果他选择2（或者1），那么玩家2可以从1（或者2）和5中进行选择。如果玩家2选择了5，那么玩家1则只剩下1（或者2）可选。  
> 所以，玩家1的最终分数为 1 + 2 = 3，而玩家 2 为 5  
> 因此，玩家1永远不会成为赢家，返回 False

> 示例2  
> 输入: \[1, 5, 233, 7\]  
> 输出: True  
> 解释: 玩家1一开始选择1。然后玩家2必须从5和7中进行选择。无论玩家2选择了哪个，玩家1都可以选择233  
> 最终，玩家1（234分）比玩家2（12分）获得更多的分数，所以返回 True，表示玩家1可以成为赢家

思路：这道题还是很难理解的，首先 `dp[i][j]` 表示的意思是先手比后手多拿的分数.

动态转移方程为：  
`dp = max(nums[i]-dp[i+1][j],nums[j]-dp[i][j-1])`

def PredictTheWinner(self, nums: List[int]) -> bool:
            # 如果个数时偶数的话，玩家1一定赢
            # 因为共有两种选择方案，一种赢一种输，让玩家1那选赢的那一方就行了
            # 输赢是由方案的选择决定的
            if len(nums)%2==0:
                return True
            # 如果是奇数的话，输赢是根据先手或者后手决定的
            # 先手可能会赢，也可能会输，但是题目要求的是玩家1先手
            # 所以就是接下来就是判断，先手拿数字是输还是赢？
            n = len(nums)
            dp = [[0]*n for _ in nums]  
            for j in range(n):
                for i in range(j-1, -1, -1):                 
                    dp[i][j] = max(nums[i]-dp[i+1][j], nums[j]-dp[i][j-1])         
            return dp[0][n-1]>=0

C++版本

bool PredictTheWinner(vector<int>& nums) { 
            int n = nums.size();
            if(n%2==0){ 
                return true;
            }
            vector<vector<int>>dp(n,vector<int>(n,0));
            for(int i = n-1;i>=0;--i){ 
                dp[i][i] = nums[i];
                for(int j = i+1;j<n;++j){ 
                    dp[i][j] = max(nums[i]-dp[i+1][j],nums[j]-dp[i][j-1]);
                }
            }
            return dp[0][n-1]>=0;
        }

> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70]

### 2、乘积最大子序列 ###

给定一个整数数组 nums ，找出一个序列中乘积最大的连续子序列（该序列至少包含一个数）

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

> 示例2  
> 输入: \[-2,0,-1\]  
> 输出: 0  
> 解释: 结果不能为 2, 因为 \[-2,-1\] 不是子数组

注意事项：比较典型的错误思维

def maxProduct(self, nums: List[int]) -> int:
            n = len(nums)
            dp_max = [nums[0]]*n
            res = nums[0]
            for i in range(1,n):  
                dp_max[i] = max(dp_max[i-1]*nums[i], nums[i])
                res = max(res,dp_max[i])           
            return res

如果计算的最大子序列和，这种思路就是对的。

存在一种情况是，负数乘以负数得到的是正数  
就比如下面案列

> 案列3：\[-2,3,-4\]

如果返回的是3，就错了，最大子序列积应该是 24

所以在遍历的时候，不应该保存最大值，同时也把最小值保存下来，说不定下一个数是负数，然后就把最小的数变为最大的数了

参考 code

int maxProduct(vector<int>& nums) { 
            int n = nums.size();
            int a = 1,b=1;
            int maxVal = INT_MIN;
            for(int i = 0;i<n;++i){ 
                int aa = a * nums[i];
                int bb = b * nums[i];
    
                a = min(nums[i],min(aa,bb));
                b = max(nums[i],max(aa,bb));
                maxVal = max(maxVal,b);
            }
            return maxVal;
        }

### 3、丑数 ###

编写一个程序判断给定的数是否为丑数。

丑数就是只包含质因数 2, 3, 5 的正整数。

> 示例1  
> 输入: 6  
> 输出: true  
> 解释: 6 = 2 × 3

> 示例2  
> 输入: 8  
> 输出: true  
> 解释: 8 = 2 × 2 × 2

> 示例3  
> 输入: 14  
> 输出: false  
> 解释: 14 不是丑数，因为它包含了另外一个质因数 7

思路：把 2 , 3 ，5 定义在一个列表中，利用取模和取余的方法来判断它是否只包含 2,3,5 这三个因数。

def isUgly(self, num: int) -> bool:
            temp = [2,3,5]
            if num==0:
                return False
            while num != 1:
                if num%temp[0] == 0:
                    num = num/temp[0]
                elif num%temp[1] == 0:
                    num = num/temp[1]
                elif num%temp[2] == 0:
                    num = num/temp[2]
                else:
                    return False
            if num ==1:
                return True
            else:
                return False

简化代码版本

def isUgly(self, num: int) -> bool:
            if num<=0:
                return False
            for i in [2, 3, 5]:
                while num % i == 0:
                    num /= i
            return num == 1

进阶：编写一个程序，找出第 n 个丑数

> 示例  
> 输入: n = 10  
> 输出: 12  
> 解释: 1, 2, 3, 4, 5, 6, 8, 9, 10, 12 是前 10 个丑数

思路：从小到大依次计算出第i个丑数，知道第n个为止

丑数的计算方法：已有的丑数分别乘以 2，3，5 后得到的值中最小的那一个

def nthUglyNumber(self, n: int) -> int:
            ugly = [1]
            l2 = l3 = l5 = 0
            while n>1:
                u2,u3,u5 = 2*ugly[l2],3*ugly[l3],5*ugly[l5]
                umin = min(u2,u3,u5)
                if umin == u2:
                    l2+=1
                if umin == u3:
                    l3+=1
                if umin == u5:
                    l5+=1
                ugly.append(umin)
                n-=1
            return ugly[-1]

### 4、跳跃游戏 ###

给定一个非负整数数组，你最初位于数组的第一个位置。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个位置。

> 示例1  
> 输入: \[2,3,1,1,4\]  
> 输出: true  
> 解释: 从位置 0 到 1 跳 1 步, 然后跳 3 步到达最后一个位置。

> 示例2  
> 输入: \[3,2,1,0,4\]  
> 输出: false  
> 解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。

思路：第一次做的时候把题看错了，我以为是跳跃的距离必须是当前元素的值，一度以为题错了，然后发现题上说的是最大距离，意思就是当前距离是 3 ，但是我也可以跳跃两步，也可以跳跃一步，只要能到达终点就可以了！

首先我们在遍历数据的时候，记录一个变量 furth ，它的意思是当前我们可以到达的最远距离。

如果我们的下标大于 furth ，就返回 False 否则 True,因为如果下标大于furth 的时候，无论你怎么走，都到不了！这个 furth 距离是相对于初始节点的。

def canJump(nums):
            i = farth = 0
            n = len(nums)
            while i < n and i <= farth:
                farth = max(i+nums[i],farth)
                i+=1
            return i==n

进阶：在上一题的基础上额外加一个条件，跳的次数最少是多少次？

这道题就稍微有难度了，通过一个变量 step 来记录走的步数,而且另外还加一个变量，一个是当前距离，另一个是下一个距离，或者叫最大距离，这两个是要进行比较的。

比如案例：\[3,1,7,2,1,1,4\] 我们发现走到 7 的位置要比走到 2 的位置更好，首先保存当前位置最远距离，也就是 3+i，然后遍历到 7 的时候更新最远距离为 7+i 就行了

def jump(nums):
            if not nums or len(nums)==1:
                return 0
            step = cur_futher = next_futher = 0
            for i in range(len(nums)):
           	 	# [3,2,1,0,4]
                next_futher = max(next_futher,nums[i]+i)
                if next_futher>=len(nums)-1:
                    return step+1
                if i == cur_futher:
                    step+=1
                    cur_futher = next_futher
            return step

### 5、最长连接序列 ###

给定一个未排序的整数数组，找出最长连续序列的长度。

要求算法的时间复杂度为 O(n)。

> 示例  
> 输入: \[100, 4, 200, 1, 3, 2\]  
> 输出: 4  
> 解释: 最长连续序列是 \[1, 2, 3, 4\]。它的长度为 4。

思路：先把list用set转换一下，相当于哈希了一下，这样查起来很快。

遍历集合中的元素，若该元素为x，且x-1不在集合中，说明它是某一个连续序列的起点，找x+1是否在集合中，如果在，把x+1赋值给x，再找x+1是否在集合中，若一直在，序列的长度就一直增加，如果不在，计算当前的序列长度。

若该元素为x，且x-1在集合中，不管它，因为它一定不是某段连续区间的起点

def longestConsecutive(self, nums: List[int]) -> int:
            nums = set(nums)
            longstr = 0
            # [100,4,200,1,3,2]
            for num in nums:
                if num-1 not in nums:
                    n = num+1
                    while n in nums:
                        n+=1
                    longstr = max(longstr,n-num)
            return longstr

方法二：利用字典结构

def longestConsecutive(self, nums: List[int]) -> int:
            dic = dict()
            max_length = 0
            # [100,4,200,1,3,2]
            for num in nums:
            	# 去重
                if num not in dic:
                    left = dic.get(num-1,0)
                    right = dic.get(num+1,0)
                    longstr = 1+left+right
                    max_length = max(longstr,max_length)
                    # 更新键对应的值
                    dic[num] = longstr
                    dic[num-left] = longstr
                    dic[num+right] = longstr
            return max_length

### 6、爬楼梯 ###

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

> 示例  
> 输入： 3  
> 输出： 3  
> 解释：有三种方法可以爬到楼顶。  
> 1 阶 + 1 阶 + 1 阶  
> 1 阶 + 2 阶  
> 2 阶 + 1 阶

思路：其实这个题就是我们的斐波那契额数列，只不过是包装了一层外皮而已，然后看起来就好像很难了！

首先假设 有n个台阶，次数为F(n),先跳一个台阶，然后剩下 n-1个台阶,那么次数就是 F(n-1)，或者我们先跳2个台阶，剩下 n-2个台阶，次数是F(n-2)，由于一次性只能跳一个台阶或者两个台阶，所以我们的n个台阶次数就是： F(n) = F(n-1)+F(n-2)

def climbStairs(self, n: int) -> int:
            if n==1:
                return 1
            if n==2:
                return 2
            first = 1
            second = 2
            Sum = 0
            for i in range(2,n):
                Sum = first + second
                first = second
                second = Sum
            return Sum

可以使用动态规划

def climbStairs(self, n: int) -> int:
            dp = [0]*(n+1)
            if n==1:
                return 1
            if n==2:
                return 2
            dp[1] = 1
            dp[2] = 2
            for i in range(3,n+1):
                dp[i] = dp[i-1]+dp[i-2]
            return dp[n]

### 7、接雨水 ###

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

> 示例  
> 输入: \[0,1,0,2,1,0,1,3,2,1,2,1\]  
> 输出: 6  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70 1]

先来看一个图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70 2]  
思路：黄线高度和红线高度从后往前看，比大小，取出较小值，然后较小的值减去当前柱子的高度就是这根柱子周围的容水量。

当然这道题有点难，思路确实很复杂，红线画法的规则就是，从前往后遍历，找最大值并保留下来，黄线是从后往前看，之所以限制两条线是因为怕一方是极端，就像这样  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70 3]  
这样左边是留不住水的,所以要用左右两边进行限制。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70 4]再说详细点就是，假如从后往前遍历，当走到7的位置，你害怕左边柱子高度都比第7根柱子的高度小，但是不用担心，因为第7根柱子上方的红线高度已经告诉我们在左边还有比第7根柱子更高的柱子。

def trap(height):
        max_left = [0]
        for h in height:
        	# 这就是那条红线
            max_left.append(max(max_left[-1], h))
            
        max_right = 0
        res = 0
        n = len(height)
        
        for i in range(n):
        	# max_right 就相当于黄线
            max_right = max(max_right, height[n-i-1])
    		# 取出较小的值，然后减去当前柱子的高度
            res += min(max_right, max_left[n-i]) - height[n-i-1]
        return res

### 8、最长公共子序列 ###

##### 可以不连续的子序列 #####

输入  
abcfbc abfcab  
programming contest  
abcd mnp

输出  
4  
2  
0

int findLCS(string str1, int n, string str2, int m) { 
    	//所有值初始化为0
    	vector<vector<int>> dp(n+1, vector<int>(m+1, 0));
    	for (int i = 1; i < n+1; i++){ 
    		for (int j = 1; j < m+1; j++){ 
    			if (str1[i-1] == str2[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[n][m];
    }

下图是 每一个状态的值，也就是公共字符串的个数  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70 5]

##### 要求连续的子序列 #####

int findLongest(string A, int n, string B, int m) { 
    	int ans = 0;
    	//所有值初始化为0
    	vector<vector<int>> dp(n+1, vector<int>(m+1, 0));
    	for (int i = 1; i < n+1; i++){ 
    		for (int j = 1; j < m+1; j++){ 
    			//如果当前结尾的字符相等，则在dp[i-1][j-1]的基础上加1
    			if (A[i-1] == B[j-1]){ 
    				dp[i][j] = dp[i - 1][j - 1] + 1;
    			}
    			//更新最大值
    			ans = max(ans,dp[i][j]);
    		}
    	}
    	return  ans;
    }

##### 要求输出最长公共子串 #####

string findLongest(string& str1,string& str2){ 
        int n = str1.size(),m = str2.size();
        vector<vector<int>>dp(n+1,vector<int>(m+1,0));
        int start = 0,maxlen = 0;
        for(int i = 1;i<n+1;++i){ 
            for(int j = 1;j<m+1;++j){ 
                if(str1[i-1] == str2[j-1]){ 
                    dp[i][j] = dp[i-1][j-1]+1;
                }
                if(dp[i][j] > maxlen){ 
                    maxlen = dp[i][j];
                    start = i - maxlen;
                }
            }
        }
        if(maxlen == 0){ 
            return "";
        }
        return str1.substr(start,maxlen);
    }

### 9、背包问题 ###

##### 01 背包 #####

在不超过背包容量的情况下，计算最大价值

状态：F(i, j): 前i个物品放入大小为j的背包中所获得的最大价值
    状态递推：对于第i个商品，有一种例外，装不下，两种选择，放或者不放
    如果装不下：此时的价值与前i-1个的价值是一样的 F(i,j) = F(i-1,j)
    如果可以装入：需要在两种选择中找最大的 
    F(i, j) = max{F(i-1,j), F(i-1, j - A[i]) + V[i]}
    F(i-1,j): 表示不把第i个物品放入背包中， 所以它的价值就是前i-1个物品放入大小为j的背包的最大价值
    
    F(i-1, j - A[i]) + V[i]：表示把第i个物品放入背包中，价值增加V[i],但是需要腾出j - A[i] 的小放第i个商品
    
    初始化：第0行和第0列都为0，表示没有装物品时的价值都为0
    F(0,j) = F(i,0) = 0
    
    返回值：F(n,m)

int backPackII(int m, vector<int> A, vector<int> V) { 
    	if (A.empty() || V.empty() || m < 1) { 
    		return 0;
    	}
    	//多加一行一列，用于设置初始条件
    	const int N = A.size() + 1;
    	const int M = m + 1;
    	vector<vector<int> > result(N,vector<int>(M,0);
    	for (int i = 1; i < N; ++i) { 
    		for (int j = 1; j != M; ++j) { 
    			//第i个商品在A中对应的索引为i-1: i从1开始
    			//如果第i个商品大于j,说明放不下， 所以(i,j)的最大价值和(i- 1,j)相同
    			if (A[i - 1] > j) { 
    				result[i][j] = result[i - 1][j];
    			}
    			//如果可以装下，分两种情况，装或者不装
    			//如果不装，则即为(i-1, j)
    			//如果装，需要腾出放第i个物品大小的空间： j - A[i-1],装入之后的最大价值即为(i - 1,j - A[i-1]) + 第i个商品的价值V[i - 1]
    			//最后在装与不装中选出最大的价值
    			else { 
    				int newValue = result[i - 1][j - A[i - 1]] + V[i - 1];
    				result[i][j] = max(newValue, result[i - 1][j]);
    			}
    		}
    	}
    	//返回装入前 N个商品，物品大小为 m 的最大价值
    	return result[N - 1][m];
    }

优化

int backPackII(int m, vector<int> A, vector<int> V) { 
    	if (A.empty() || V.empty() || m < 1) { 
    		return 0;
    	}
       
        const int N = A.size();
    	//多加一列，用于设置初始条件，因为第一件商品要用到前面的初始值
    	const int M = m + 1;
    	vector<int> result(M,0);
    	//这里商品的索引位置不需要偏移，要和未优化的方法区分开
        //这里的i-1理解为上一行，或者未更新的一维数组值
    	for (int i = 0; i != N; ++i) { 
    		for (int j = M - 1; j > 0; --j) { 
    			//如果第i个商品大于j,说明放不下， 所以(i,j)的最大价值和(i-1,j)相同
    			//如果可以装下，分两种情况，装或者不装
    			if (A[i] <= j) { 
    			//如果不装，则即为(i-1, j)
    			//如果装，需要腾出放第i个物品大小的空间： j - A[i],装入之后的最大价值即为(i - 1, j- A[i-1]) + 第i个商品的价值V[i]
    			//最后在装与不装中选出最大的价值
    			int newValue = result[j - A[i]] + V[i];
    			result[j] = max(newValue, result[j]);
    		}
    	}
    	//返回装入前N个商品，物品大小为m的最大价值
    	return result[m];
    }

##### 完全背包 #####

在 01 背包的基础上，物件有无限个，求最大价值

// N 是物品种类数，W 是背包容积
    int backPackII(vector<int>&w,vector<int>&v,N,W){ 
    	vector<int>dp(W+1,0);
        for(int i = 1; i <= N; ++i){ 
            for(int j = w[i]; j <= W; ++j)
                dp[j] = max(dp[j], dp[j-w[i]] + v[i]);
        }
        return dp[W];
    }

##### 多重背包 #####

在完全背包的基础上，设置了物品个数为有限个

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200115135829787.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191111143933760.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191115225519421.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191115230315621.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20191115230722603.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20190727180319538.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0,size_16,color_FFFFFF,t_70