动态规划相关题目——NWU_LK

最新推荐文章于 2021-03-23 10:44:10 发布
最新推荐文章于 2021-03-23 10:44:10 发布
阅读量174 收藏
点赞数
分类专栏： leetcode 文章标签： 动态规划 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NWU_LK/article/details/108545765
版权

动态规划经典题目

  1. 爬楼梯（70题，509斐波那契数相同）
    在这里插入图片描述
class Solution {
    public int climbStairs(int n) {
        int[] dp=new int[n+1];
        if (n==1||n==2){
            return n;
        }
        dp[1]=1;dp[2]=2;
        for (int i=3;i<=n;i++){
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[n];
    }
}
  1. 使用最小花费爬楼梯（746题）
    在这里插入图片描述
class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int n =cost.length;
        int[] dp=new int[n+1];
        dp[0]=0;dp[1]=0;
        for (int i=2;i<=n;i++){
            dp[i]=Math.min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]);
        }
        return dp[n];
    }
}
  1. 打家劫舍（198题）
    在这里插入图片描述
class Solution {
    public int rob(int[] nums) {
        if (nums.length==0){
            return 0;
        }
        if (nums.length==1){
            return nums[0];
        }
        int[] dp=new int[nums.length];
        dp[0]=nums[0];
        dp[1]=Math.max(nums[0],nums[1]);
        for (int i=2;i<nums.length;i++){
            dp[i]=Math.max(dp[i-1],dp[i-2]+nums[i]);
        }
        return dp[nums.length-1];
    }
}
  1. 打家劫舍2（213题）
    在这里插入图片描述
class Solution {
    public int rob(int[] nums) {
        if (nums.length==0) return 0;
        if (nums.length==1) return nums[0];
        if (nums.length==2) return Math.max(nums[0],nums[1]);
        return Math.max(rob(nums,0,nums.length-2),rob(nums,1,nums.length-1));
    }
    public int rob(int[] nums,int start,int end){
        int[] dp=new int[nums.length];
        dp[start]=nums[start];
        dp[start+1]=Math.max(nums[start],nums[start+1]);
        for (int i=start+2;i<=end;i++){
            dp[i]=Math.max(dp[i-1],dp[i-2]+nums[i]);
        }
        return dp[end];
    }
}
  1. 打家劫舍3（337题）
    在这里插入图片描述
class Solution {
    public int rob(TreeNode root) {
        int[] res= dfs(root);
        return Math.max(res[0],res[1]);
    }
    public int[] dfs(TreeNode node){
        if (node==null) return new int[]{0,0};
        int[] left = dfs(node.left);
        int[] right = dfs(node.right);
        int select = node.val + left[1] + right[1];
        int unselect = Math.max(left[0],left[1])+Math.max(right[0],right[1]);
        return new int[]{select,unselect};
    }
}
  1. 最大子序和（53题）
    在这里插入图片描述
class Solution {
    public int maxSubArray(int[] nums) {
        int[] dp=new int[nums.length];
        int max=nums[0];
        dp[0]=nums[0];
        for (int i=1;i<nums.length;i++){
            dp[i]=Math.max(dp[i-1]+nums[i],nums[i]);
            if (dp[i]>max){
                max=dp[i];
            }
        }
        return max;
    }
}
  1. 零钱兑换(322题)
    在这里插入图片描述
class Solution {
    public int coinChange(int[] coins, int amount) {
        int[] dp=new int[amount+1];
        Arrays.fill(dp,-1);
        dp[0]=0;
        for (int i=1;i<=amount;i++){
            for(int coin:coins){
                if (i-coin>=0 && dp[i-coin]!=-1){
                    if (dp[i]==-1||dp[i-coin]+1<dp[i]){
                        dp[i]=dp[i-coin]+1;
                    }
                }
            }
        }
        return dp[amount];
    }
}
  1. 三角形最小路径和（120题）
    在这里插入图片描述
class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        int n=triangle.size();
        int[][] dp=new int[n][n];
        dp[0][0]=triangle.get(0).get(0);
        for (int i=1;i<n;i++){
            dp[i][0]=dp[i-1][0]+triangle.get(i).get(0);
            for (int j=1;j<i;j++){
                int ele=triangle.get(i).get(j);
                dp[i][j]=ele+Math.min(dp[i-1][j-1],dp[i-1][j]);
            }
            dp[i][i]=dp[i-1][i-1]+triangle.get(i).get(i);
        }
        int min=dp[n-1][0];
        for (int j=1;j<n;j++){
            min=Math.min(min,dp[n-1][j]);
        }
        return min;
    }
}
  1. 最长上升子序列（300题）
    在这里插入图片描述
class Solution {
    public int lengthOfLIS(int[] nums) {
        if (nums.length == 0) {
            return 0;
        }
        int[] dp=new int[nums.length];
        dp[0]=1;
        int maxCount=1;
        for (int i=1;i<dp.length;i++){
            int m=0;
            for (int j=0;j<i;j++){
                if (nums[j]<nums[i]){
                    m=Math.max(dp[j],m);
                }
            }
            dp[i]=m+1;
            maxCount=Math.max(maxCount,dp[i]);
        }
        return maxCount;
    }
}
  1. 最小路径和（64题）
    在这里插入图片描述
class Solution {
    public int minPathSum(int[][] grid) {
        int[][] dp=new int[grid.length][grid[0].length];
        dp[0][0]=grid[0][0];
        for (int i=1;i<grid[0].length;i++){
            dp[0][i]=dp[0][i-1]+grid[0][i];
        }
        for (int j=1;j<grid.length;j++){
            dp[j][0]=dp[j-1][0]+grid[j][0];
        }
        for(int i=1;i<grid.length;i++){
            for(int j=1;j<grid[0].length;j++){
                dp[i][j]=Math.min(dp[i-1][j],dp[i][j-1])+grid[i][j];
            }
        }
        return dp[grid.length-1][grid[0].length-1];
    }
}
  1. K站中转内最便宜的航班（787题）
    在这里插入图片描述
class Solution {
    public int findCheapestPrice(int n, int[][] flights, int src, int dst, int K) {
        // dp[i][k]是经过k个中转站后到达站 i 的最小费用
        int[][] dp = new int[n][K + 1];

        // 循环初始化整个二维数组。
        for(int i = 0; i < n; ++i) Arrays.fill(dp[i], Integer.MAX_VALUE);

        // 利用flights中的信息初始化src可直达的班次
        for(int[] flight : flights) {
            if(flight[0] == src){
                dp[flight[1]][0] = flight[2];
            }
        }

        // 循环初始化数组中dst == src的行
        for(int i = 0; i <= K; i++){
            dp[src][i] = 0;
        }

        //动态规划状态转移方程，开始填表
        //直达的已经初始化了（即k = 0的情况），现在从k = 1 的开始，即只有一个中转站开始
        for(int k = 1; k <= K; k++){
            for(int[] flight : flights){
                //结合题目理解
                if(dp[flight[0]][k - 1] != Integer.MAX_VALUE){
                    dp[flight[1]][k] = Math.min(dp[flight[1]][k], dp[flight[0]][k - 1] + flight[2]);
                }
            }
        }
        return dp[dst][K] == Integer.MAX_VALUE? -1: dp[dst][K];
    }
}
  1. 二维区域和检索 - 矩阵不可变（304题）
class NumMatrix {

    private int[][] dp;

    public NumMatrix(int[][] matrix) {
        if (matrix.length == 0 || matrix[0].length == 0) return;
        dp = new int[matrix.length + 1][matrix[0].length + 1];
        for (int r = 0; r < matrix.length; r++) {
            for (int c = 0; c < matrix[0].length; c++) {
                dp[r + 1][c + 1] = dp[r + 1][c] + dp[r][c + 1] + matrix[r][c] - dp[r][c];
            }
        }
    }

    public int sumRegion(int row1, int col1, int row2, int col2) {
       return dp[row2+1][col2+1]-dp[row2+1][col1]-dp[row1][col2+1]+dp[row1][col1];
    }
}
  1. 矩阵区域和（1314题）

在这里插入图片描述

class Solution {
    public int[][] matrixBlockSum(int[][] mat, int K) {
        int[][] dp =new int[mat.length+1][mat[0].length+1];
        for(int i=0;i<mat.length;i++){
            for (int j=0;j<mat[0].length;j++){
                dp[i+1][j+1]=dp[i+1][j]+dp[i][j+1]+mat[i][j]-dp[i][j];
            }
        }
        int[][] res=new int[mat.length][mat[0].length];
        
        for(int i=0;i<mat.length;i++){
            for (int j=0;j<mat[0].length;j++){
                int topLeft_i=Math.max(i-K,0);
                int topLeft_j=Math.max(j-K,0);
                int bottomRight_i= Math.min(i + K, mat.length-1);
                int bottomRight_j=Math.min(j + K, mat[0].length-1);
                res[i][j]=dp[bottomRight_i+1][bottomRight_j+1]-dp[bottomRight_i+1][topLeft_j]-dp[topLeft_i][bottomRight_j+1]+dp[topLeft_i][topLeft_j];
            }
        }
        return res;
    }
}
  1. 不同路径（62题，63相似）
    在这里插入图片描述
class Solution {
    public int uniquePaths(int m, int n) {
        int[][] dp=new int[m][n];
        for (int i=0;i<m;i++){
            dp[i][0]=1;
        }
        for (int j=0;j<n;j++){
            dp[0][j]=1;
        }
        for (int i=1;i<m;i++){
            for (int j=1;j<n;j++){
                dp[i][j]=dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }
}
  1. 不同的二叉搜索树
    在这里插入图片描述
class Solution {
    public int numTrees(int n) {
        if(n<=2){
            return n;
        }
        int[] dp=new int[n+1];
        dp[0]=1;dp[1]=1;dp[2]=2;
        for (int i=3;i<=n;i++){
            int index=0;
            while (index<i){
                dp[i]+=dp[index]*dp[i-1-index];
                index++;
            }
        }
        return dp[n];
    }
}
  1. 最长公共子串
public class Solution {
    public String LCS (String str1, String str2) {
        if(str1.length() == 0 || str2.length() == 0){
            return "-1";
        }
        char[] s1 = str1.toCharArray();
        char[] s2 = str2.toCharArray();
        int max = 0;   //记录最大长度
        int endIndex = -1;  //记录最大子串末尾的下标
        
        int[][] dp = new int[s1.length][s2.length];
        for (int i = 0; i < s1.length; i++) {
            for (int j = 0; j < s2.length; j++) {
                if(i==0 || j==0) {
                    dp[i][j] = s1[i] == s2[j] ? 1: 0;
                } else {
                    if(s1[i] == s2[j]) {
                        dp[i][j] = dp[i-1] [j-1] + 1;
                    }
                }
                if(dp[i][j] > max) {
                    max = dp[i][j];
                    endIndex = i;
                }
            }
        }

        return endIndex==-1 ? "-1" : str1.substring(endIndex-max+1, endIndex+1);
    }
}
  1. 最长公共子序列（1143题，583题、1035题可以使用）
    在这里插入图片描述
    这里的dp[i][j]表示从字符串s1的位置i到字符串s2的位置j的之前最长的公共子序列长度
class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int[][] dp=new int[text1.length()+1][text2.length()+1];
        for (int i=1;i<=text1.length();i++){
            for (int j=1;j<=text2.length();j++){
                if (text1.charAt(i-1)==text2.charAt(j-1)){
                    dp[i][j]=dp[i-1][j-1]+1;
                }else {
                    dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);
                }
            }
        }
        return dp[text1.length()][text2.length()];
    }
}
  1. 最长回文子串（516题）
    在这里插入图片描述
    dp[i][j]代表从i到j的最长回文子串
class Solution {
    public int longestPalindromeSubseq(String s) {
        int n = s.length();
        int[][] dp=new int[s.length()][s.length()];
        for (int i=n-1;i>=0;i--){
            dp[i][i]=1;
            for (int j=i+1;j<n;j++){
                if (s.charAt(i)==s.charAt(j)){
                    dp[i][j] = dp[i+1][j-1]+2;
                }else {
                    dp[i][j] = Math.max(dp[i+1][j],dp[i][j-1]);
                }
            }
        }
        return dp[0][n-1];
    }
}
  1. 回文子串
    在这里插入图片描述
    dp[i][j]表示从i到j的字符串是否为回文字符串，当i和j字符相等时，分为三种情况，一种是i=j时一定是回文，一种是j=i+1时一定是回文，最后一种基于dp[i+1][j-1]来判断
class Solution {
    public int countSubstrings(String s) {
        int n = s.length();
        boolean[][] dp=new boolean[s.length()][s.length()];
        int ans = 0;
        for (int i=n-1;i>=0;i--){
            for (int j=i;j<n;j++){
                if (s.charAt(i)==s.charAt(j)  && (j - i <= 1 || dp[i + 1][j - 1])){
                    dp[i][j] = true;
                    ans++;
                }
            }
        }
        return ans;
    }
}
  1. 编辑距离（72题）
    在这里插入图片描述

这里的dp数组代表字符串s1的前i个字符和字符串s2的前j个字符的最小编辑距离，然后比较当前两个字母，如果相同则等于dp[i-1][j-1]，不同则为dp[i-1][j]、dp[i][j-1]、dp[i-1][j-1]的最小值。分别代表从s1中插入

class Solution {
    public int minDistance(String word1, String word2) {
        int len1=word1.length();
        int len2=word2.length();
        int[][] dp=new int[len1+1][len2+1];
        for(int i=1; i<=len1; i++){
            dp[i][0] = i;
        }
        for(int i=1; i<=len2; i++){
            dp[0][i] = i;
        }
        for(int i=1;i<=len1;i++){
            char c = word1.charAt(i-1);
            for(int j=1;j<=len2;j++){
                if(c==word2.charAt(j-1)){
                    dp[i][j]=dp[i-1][j-1];
                }else{
                    dp[i][j]=1+Math.min(Math.min(dp[i-1][j],dp[i][j-1]),dp[i-1][j-1]);
                }
            }
        }
        return dp[len1][len2];
    }
}
  1. 不同的子序和（115题）
    在这里插入图片描述

这里的dp表示字符串t的前j位在s的前i位中出现的次数

class Solution {
    public int numDistinct(String s, String t) {
        int m = s.length(),n=t.length();
        if (m<n) return 0;
        int[][] dp=new int[m+1][n+1];
        for (int i=0;i<=m;i++){
            dp[i][0]=1;
        }
        for (int i=1;i<=m;i++){
            for (int j=1;j<=n;j++){
                if (s.charAt(i-1)==t.charAt(j-1)){
                    dp[i][j]=dp[i-1][j-1]+dp[i-1][j];
                }else {
                    dp[i][j] = dp[i-1][j];
                }
            }
        }
        return dp[m][n];
    }
}
  1. 整数拆分（343题）

此题贪心算法更快

class Solution {
    public int integerBreak(int n) {
        int[] dp = new int[n + 1];
        dp[2]=1;
        for (int i = 3; i <= n; i++) {
            for (int j = 1; j < i; j++) {
                dp[i] = Math.max(dp[i], Math.max(j * (i - j), j * dp[i - j]));
            }
        }
        return dp[n];
    }
}

还在不断增加经典题目

NWU_LK
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Nwudev_python_contaud:NWU内部审计连续审计python脚本
04-19
NWU内部审计连续审计技术手册条款21162395 = Albert B Janse van Rensburg（Snr内部审计师） 24670804 = Jacques Oosthuizen（系统专员） IA =西北大学内部审计。 由21162395代表。 IT =西北大学IT运营和基础架构。 ...
parallel_dbscan:基于NWU代码的并行dbscan的Python模块
05-05
并行dbscan是基于西北大学代码的Python打包的DBSCAN并行版本。 原始文件可以在这里找到： : 可以在parallel_dbscan / dbscan-v1.0.0中找到原始代码，其中包括原始软件包提供的所有内容，包括版权声明。
有一种神奇的性格叫——INTJ
热门推荐
濯君
03-23 2万+
2.3.1 沙箱 要了解 INTJ 的性格，首先要明确一个叫做沙箱的概念。 INTJ，我们从这四个字母就能看出他的性格特点：内向的人本身就不喜欢与人交往，直觉让他们倾向于自己冥想，理性的思维使他们只关注事物的本身逻辑，判断的的特性让他们很少做出理解他人感受的举动。这四个功能都是那种较少和外界接触，相对独立的功能，合在一起自然使 INTJ成了十六种性格里最独立也最封闭的一种性格。 大多数人的功能是为了适应和认识外在的世界，INTJ 就完全走向另一个极端，纯粹的构建一个心中的完美的世界，也就是他...
INTJINTJ——内向+直觉+思维+判
weixin_33910759的博客
12-06 3417
INTJ INTJ——内向+直觉+思维+判断。INTJ型的人是完美主义者。他们强烈地要求个人自由和能力，同时在他们独创的思想中，不可动摇的信仰促使他们达到目标。 INTJ型的人思维严谨、有逻辑性、足智多谋，他们能够看到新计划实行后的结果和生活中转变为真实物质的理论体系。他们对自己和别人都很苛求，往往几乎同样强硬地逼迫别人和自己。他们并不十分受冷漠与批评的干扰，作为所有性格类型中最独立...
MBTI职业性格测试
cmhss2588的博客
03-14 461
地址：http://www.psytopic.com/mag/post/820.htmlPsytopic分析：您的性格类型是“INTJ”(内向+直觉+思维+判断) 在实现自己的想法和达成自己的目标时有创新的想法和非凡的动力。能很...
求序列中第k小的数_题库 | 百度数据结构 / 算法面试题型介绍及解析 第 3 期
weixin_39781452的博客
11-27 257
题目1：求一个数组的最长递减子序列，比如 {9，4，3，2，5，4，3，2} 的最长递减子序列为 {9，5，4，3，2}动态规划。假设 0 到 i-1 这段数列的最长递减序列的长度为 s，且这些序列们的末尾值中的最大值是 t。对于 a [i] 有一下情况：(1) 如果 a [i] 比 t 小，那么将 a [i] 加入任何一个子序列都会使 0 到 i 的最长单调序列长度变成 s+1，这样的...
动态规划，最大连续子序列和，C/C++
这个年纪的_我
01-31 1554
给定一个数字序列，A1,A2......An,求i，j,使得Ai +  .....+ Aj最大，输出这个最大和。 #include&lt;cstdio&gt; #include&lt;algorithm&gt; using namespace std; const int maxn = 110; int A[maxn],dp[maxn]; int main(){ int n; ...
NWU.ICU:课程评价网站
04-04
目前拥有课程评价和自动填报两个模块，更多功能正在计划中.. 起步 本项目使用Django开发，并使用pipenv来管理依赖。 安装依赖： pipenv sync --dev 进入虚拟环境： pipenv shell 根据development.py.sample建立...
2021-09-13-NWU-Online
04-12
有关 的页面，和详细介绍了我们的工作方式和原因。 并且请注意：如果您要教Git，请供学习者练习。 创建一个仓库 登录到GitHub。 （如果您没有帐户，则可以免费快速创建一个帐户。）您必须先登录才
Unity使用Gif动态图片
03-22
本文将深入探讨在Unity中使用GIF动态图片的方法，以及一些相关技巧。 首先，Unity原生并不支持GIF格式的直接导入和播放。因此，我们需要借助第三方插件或者自定义解决方案来实现这一功能。一个常见的方法是将GIF...
框架前的总结
一个学习的人的博客
09-16 382
1：JDK开发环境搭建 Java的开发环境(JDK): JDK里面包含了Java提供给我们的一些常用开发工具,以及Java的运行环境。 Java的运行环境(JRE): JRE是Java的运行环境,我们编写的代码都在JRE里面的Java虚拟机运行 Java的虚拟机(JVM): JVM是Java的虚拟机,我们写的代码都运行在虚拟机之中。 JDK包含有 JRE 而 JRE 包含有 JVM 编程语言的种类： 1：解释型语言 2：编译+解释型语言 3：编译型语言 Java属于编译+解释型语言,我们调用Javac 工
积性函数线性筛
cheng__yu_的博客
09-17 195
积性函数线性筛1、莫比乌斯函数 μ\muμ2、欧拉函数 φ\varphiφ3、约数个数函数d4、约数和函数σσσ5、积性函数 1、莫比乌斯函数 μ\muμ const int N=6e6; int visit[N+10],prime[N+10],mu[N+10],cnt; void init() { cnt=0,mu[1]=1; for(int i=2;i<=N;++i) { if(!visit[i]) prime[++cnt]=i,mu[i]=-1; for(int j=1;j<
干货！高频手撕算法合集来了
CSDN资讯
09-16 2735
作者 |L的存在来源 |我是程序员小贱(ID:Lanj1995Q)基础数据结构的融合是成为庞大系统的基石。比如Redis中的跳跃表，数据库索引B+树等，只有对基础的数据结构足够的熟悉...
我的才储分析，赶脚蛮符合的
weixin_30563917的博客
02-15 388
INTJ 专家型——追求能力与独立 报告接收人: 才储成员1405671 日期: 2013-02-15 一、你的MBTI图形 MBTI倾向示意图(类型：INTJ 总倾向：16.2) 外向（E） （I）内向 实感（S） （N）直觉 思考（T） （F）情感 判断（J） （P）知觉 倾向示意图表示四个维度分别的倾向程度。从中间往两侧看，绿色指示条对应...
寻找最大子序列
博客——XiaoTang
03-23 481
寻找最大子序列 using namespace std; #define Max 100000 int a[100]; //用来存储序列数 int dp[100]; //用来存储长度为i时 的结尾元素的值，也就是在该长度时的最大值 int main() { int n; cin >> n; int i; for (i=0;i<n;...
动态规划系列【2】最长递增子序列LIS
weixin_34327761的博客
03-03 76
Givenanunsortedarrayofintegers,findthelengthoflongestincreasingsubsequence. Forexample, Given[10,9,2,5,3,7,101,18], Thelongestincreasingsubsequenceis[2,3,7,101]...
蓝桥杯第六届C/C++ B省赛题目及题解
maniac_ran的博客
09-16 830
第一题：奖券数目 有些人很迷信数字，比如带“4”的数字，认为和“死”谐音，就觉得不吉利。 虽然这些说法纯属无稽之谈，但有时还要迎合大众的需求。某抽奖活动的奖券号码是5位数（10000-99999），要求其中不要出现带“4”的号码，主办单位请你计算一下，如果任何两张奖券不重号，最多可发出奖券多少张。 请提交该数字（一个整数），不要写任何多余的内容或说明性文字。 答案：52488 #include<iostream> #include<string> #include&lt.
CF372D. Choosing Subtree is Fun
xmr_pursue_dreams的博客
09-17 227
CF372D. Choosing Subtree is Fun Solution 想了一晚都不会，一觉醒来就悟了QwQQwQQwQ 之前一直想着如何用类似树形DPDPDP的方法求出每一个点的贡献再合并，然后突然发现直接枚举区间就行了。 考虑区间确定时，其实就是求区间内节点在原树上的斯坦纳树的点数。 我们枚举左端点lll，显然随着lll的增加，rrr时非降的，因此动态维护斯坦纳树的点数即可。 因为斯坦纳树的点数就是每个关键点的深度和减去dfsdfsdfs序相邻的关键点的LCALCALCA的深度和，每次操作会加
左神算法初级班笔记7：递归、动态规划
aLinxi的博客
09-17 341
文章目录01 | 暴力递归1. 求 n! 的结果2. 汉诺塔问题3. 打印一个字符串的全部子序列，包括空字符串4.打印一个字符串的全部排列5.打印一个字符串的全部排列，要求不要出现重复的排列6.母牛每年生一只母牛，新出生的母牛成长三年后也能每年生一只 母牛，假设不会死。求N年后，母牛的数量。7. 如果每只母牛只能活10年，求N年后，母牛的数量。02 | 动态规划 01 | 暴力递归 暴力递归： 把问题转化为规模缩小了的同类问题的子问题 有明确的不需要继续进行递归的条件(base case) 有当得到了子
huntian oy (数论&卷积&杜教筛)
Harris-H的博客
09-18 437
huntian oy (数论&卷积&杜教筛) 思路： f(n,a,b)=∑i=1n∑j=1igcd(ia−ja,ib−jb)[gcd(i,j)=1](mod109+7)f(n,a,b)=\sum\limits_{i=1}^n \sum\limits_{j=1}^i gcd(i^a-j^a,i^b-j^b)[gcd(i,j)=1]\pmod{10^9+7}f(n,a,b)=i=1∑n​j=1∑i​gcd(ia−ja,ib−jb)[gcd(i,j)=1](mod109+7) gcd(ia−ja,
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值