【Java】递推专题训练（动态规划）

已于 2022-06-06 08:52:53 修改
阅读量404 收藏
点赞数
分类专栏： 专题训练 文章标签： java 动态规划 算法
于 2022-02-09 01:37:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51226527/article/details/122793333
版权

文章目录

题目链接

HENAU冬令营-递推专题
密码：202202060000

知识汇总

dp套路+优化思想
dp经典例题多类型详解
算法训练：数字三角形（含优化）
背包问题（多类型算法模板）
完全背包&多重背包

题目列表

快输模板

import java.io.*;
import java.util.*;
import java.util.regex.*;
public class Main {
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        boolean hasNext() {
            if (st != null && st.hasMoreTokens())
                return true;
            try {
                st = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                return false;
            }
            return true;
        }
    }

    static PrintWriter out = new PrintWriter(
            new BufferedWriter(new OutputStreamWriter(System.out)));
    /*
    核心代码区
    */
}

A - 上台阶2

51nod 2116

	static long dp[];
    static int mod=100003;
    public static void main(String[] args) {
        FastReader sc = new FastReader();
        int n=sc.nextInt();
        dp=new long[n+1];
        for(int i=1;i<=n;i++){
            if(i<=2)dp[i]=1;
            else if(i==3)dp[i]=dp[i-1]+1;
            else if(i==4)dp[i]=dp[i-1]+dp[i-3];
            else if(i==5)dp[i]=dp[i-1]+dp[i-3]+1;
            else dp[i]=(dp[i-1]+dp[i-3]+dp[i-5])%mod;
        }
        out.println(dp[n]);
        out.flush();
    }

B - 数字三角形

B & C两题为同一类型题目，解法参考 ：
算法训练：数字三角形（含优化）

	static int map[][];
    static int n;
    public static void main(String[] args) {
        FastReader sc = new FastReader();
        n=sc.nextInt();
        map=new int[n+1][n+1];
        for(int i=1;i<=n;i++)
            for(int j=1;j<=i;j++)
                map[i][j]=sc.nextInt();
        dp();
        out.println(getMax());
        out.flush();
    }
    public static void dp(){
        for(int i=2;i<=n;i++)
            for(int j=1;j<=i;j++)
                map[i][j]=Math.max(map[i-1][j-1],map[i-1][j])+map[i][j];
    }
    public static int getMax(){
        int max=map[n][1];
        for(int i=2;i<=n;i++)
            if(map[n][i]>max) max=map[n][i];
        return max;
    }

C - 矩阵取数问题

	static int map[][];
    static int n;
    public static void main(String[] args) {
        FastReader sc = new FastReader();
        n=sc.nextInt();
        map=new int[n+1][n+1];
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                map[i][j]=sc.nextInt();
        dp();
        out.println(getMax());
        out.flush();
    }
    public static void dp(){
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                map[i][j]=Math.max(map[i-1][j],map[i][j-1])+map[i][j];
    }
    public static int getMax(){
        int max=map[n][1];
        for(int i=2;i<=n;i++)
            if(map[n][i]>max) max=map[n][i];
        return max;
    }

D - 背包问题（01背包）

递推打表法

	static int dp[],w[],p[];//w[]容积数组,p[]价值数组
    static int n,w0;//数量,容量
    public static void main(String[] args) {
        FastReader sc = new FastReader();
        n=sc.nextInt();
        w0=sc.nextInt();
        //dp数组：放入容量为v的背包中的最大价值
        dp=new int[w0+1];
        w=new int[n+1];
        p=new int[n+1];
        for(int i=1;i<=n;i++){
            w[i]=sc.nextInt();
            p[i]=sc.nextInt();
        }
        for(int i=1;i<=n;i++){
            for(int v=w0;v>0;v--){
                if(v>=w[i])
                    dp[v]=Math.max(dp[v],dp[v-w[i]]+p[i]);
            }
        }
        out.println(dp[w0]);
        out.flush();
    }

暴力枚举法，以防MLE
HENAUOJ1259

	/**
     * 直接用动归会MLE，所以用暴力枚举
     */
    static int n,W;//数量,容量
    public static void main(String[] args) {
        W=sc.nextInt();
        n=sc.nextInt();
        Node[] data = new Node[n];
        for(int i=0;i<n;i++)data[i]=new Node(i+1,0,0);
        for(int i=0;i<n;i++)data[i].w=sc.nextInt();
        for(int i=0;i<n;i++)data[i].v=sc.nextInt();

        long vmax=0,wsum,vsum;
        int flag[]=new int[n];//判断是否添加此物品
        //1<<n n件物品，每件物品都有取或不取两种可能 总共由2^n种情况
        for(int i=0;i<1<<n;i++) {
            wsum=0;vsum=0;
            for(int j=0;j<n;j++) {
                if(flag[j]==0) {
                    flag[j]=1;
                    continue;
                }
                else {
                    flag[j]=0;
                    break;
                }
            }
            for(int j=0;j<n;j++) {
                if(flag[j]==1) {
                    wsum+=data[j].w;
                    vsum+=data[j].v;
                }
            }
            if(wsum<=W && vmax<vsum) {
                vmax=vsum;
            }
        }
        out.println(vmax);
        out.flush();
    }

class Node{
    int no,w,v;
    public Node(int no,int w,int v) {
        this.no=no;this.w=w;this.v=v;
    }
}

E - 完全背包

转自动态规划：完全背包、多重背包

0-1背包和完全背包的不同：
　　从二维数组上区别0-1背包和完全背包也就是状态转移方程就差别在放第i中物品时，完全背包在选择放这个物品时，最优解是F[i][j-c[i]]+w[i]即画表格中同行的那一个，而0-1背包比较的是F[i-1][j-c[i]]+w[i]，上一行的那一个。
　　从一维数组上区别0-1背包和完全背包差别就在循环顺序上，0-1背包必须逆序，因为这样保证了不会重复选择已经选择的物品，而完全背包是顺序，顺序会覆盖以前的状态，所以存在选择多次的情况，也符合完全背包的题意。状态转移方程都为F[i]= max(F[i],dp[F-c[i]]+v[i])。

	static int dp[],w[],p[];//w[]容积数组,p[]价值数组
    static int n,w0;//数量,容量
    public static void main(String[] args) {
        FastReader sc = new FastReader();
        n=sc.nextInt();
        w0=sc.nextInt();
        //dp数组：放入容量为v的背包中的最大价值
        dp=new int[w0+1];
        w=new int[n+1];
        p=new int[n+1];
        for(int i=1;i<=n;i++){
            w[i]=sc.nextInt();
            p[i]=sc.nextInt();
        }
        for(int i=1;i<=n;i++){
            for(int v=w[i];v<=w0;v++){
                if(v>=w[i])
                    dp[v]=Math.max(dp[v],dp[v-w[i]]+p[i]);
            }
        }
        out.println(dp[w0]);
        out.flush();
    }

F - 背包问题 V2

51nod 1086
解法参考：庆功会

	static int dp[],w[],p[];//w[]容积数组,p[]价值数组
    static int n,w0,n1;//数量,容量,计数器
    public static void main(String[] args) {
        FastReader sc = new FastReader();
        n=sc.nextInt();
        w0=sc.nextInt();
        //dp数组：放入容量为v的背包中的最大价值
        dp=new int[w0+1];
        w=new int[2000010];
        p=new int[2000010];
        for(int i=1;i<=n;i++){
            int ww=sc.nextInt();//体积
            int pp=sc.nextInt();//价值
            int c=sc.nextInt();//第i件物品数量
            int t=1;
            while (c>=t) {
                w[++n1]=ww*t;//相当于n1++;  w[n1]=w[i]*t;
                p[n1]=pp*t;
                c-=t;
                t*=2;
            }
            w[++n1]=ww*c;
            p[n1]=pp*c;
        }
        for(int i=1;i<=n1;i++){
            for(int v=w0;v>=w[i]/*终止条件更改到for语句中*/;v--){
                dp[v]=Math.max(dp[v],dp[v-w[i]]+p[i]);
            }
        }
        out.println(dp[w0]);
        out.flush();
    }

G - 最长上升子序列

	//dp[n]：代表以第n个元素结尾的LIS序列的长度
    static int dp[],a[];
    static int n;
    public static void main(String[] args) {
        FastReader sc = new FastReader();
        n=sc.nextInt();
        dp=new int[n];
        a=new int[n];
        for(int i=0;i<n;i++) a[i]=sc.nextInt();
        dp[0]=1;
        for(int i=1;i<n;i++) {
            int t=0;
            for(int j=0;j<i;j++) {
                if(a[j]<a[i]) {
                    if(t<dp[j])t=dp[j];
                }
            }
            dp[i]=t+1;
        }
        int t=0;
        for(int i=0;i<n;i++) {
            if(t<dp[i])t=dp[i];
        }
        out.println(t);
        out.flush();
    }

H - 最长公共子序列

dfs找最优解

	/*
	状态转移方程如下：
 	x[i]=y[i]:   dp[i][j]=dp[i-1][j-1]+1
	x[i]!=y[j]:  dp[i][j]=max(dp[i-1][j],dp[i][j-1])
	i=0||j=0:    dp[i][j]=0
	*/
	static char c1[],c2[];
    static int n,m;
    static int dp[][];
    public static void main(String[] args) {
        FastReader sc = new FastReader();
        c1=(" "+sc.next()).toCharArray();
        c2=(" "+sc.next()).toCharArray();
        n=c1.length-1;m=c2.length-1;
        //dp[i][j]:字符串1的前i位和字符串2的前j位的LCS长度
        dp=new int[n+1][m+1];
        for(int i=1;i<=n;i++) {
            for(int j=1;j<=m;j++) {
                if(c1[i]==c2[j]) {
                    dp[i][j]=dp[i-1][j-1]+1;
                }
                else {
                    dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);
                }
            }
        }
        dfs(n,m);
        out.println();
        out.flush();
    }
    public static int dfs(int i,int j) {
        //字符串第一位均是空位，不算
        if(i==0||j==0) return 0;
        if(c1[i]==c2[j]){
            dfs(i-1,j-1);
            out.print(c1[i]);
        }
        else{
            if(dp[i-1][j]>dp[i][j-1])dfs(i-1,j);
            else dfs(i,j-1);
        }
        return 0;
    }

I - 石子合并（环形合并）

解法参考：洛谷P1880

	static int n,minl,maxl;//n堆石子
    //f[i][j]:表示从i到j堆石子合并后的最大f1/最小得分f2
    static int num[],s[],f1[][],f2[][];
    //转移方程：f[i][j] = max(f[i][k]+f[k+1][j]+d[i][j];
    //d(i,j)表示从i到j石子个数的和
    public static void main(String[] args) {
        FastReader sc = new FastReader();
        n=sc.nextInt();
        int N=2*n+1;
        //因为是一个环，所以需要开到两倍再枚举分界线，最后肯定是最大的
        num=new int[N];
        s=new int[N];
        f1=new int[N][N];//max
        f2=new int[N][N];//min
        for(int i=1;i<=n+n;i++){
            if(i<=n){
                num[i]=sc.nextInt();
                num[i+n]=num[i];
            }
            s[i]=s[i-1]+num[i];
        }
        for(int p=1;p<n;p++) {
            for(int i=1,j=i+p;(j<n+n) && (i<n+n);i++,j=i+p) {
                f2[i][j]=999999999;
                for(int k=i;k<j;k++)
                {
                    f1[i][j] = Math.max(f1[i][j], f1[i][k]+f1[k+1][j]+d(i,j));
                    f2[i][j] = Math.min(f2[i][j], f2[i][k]+f2[k+1][j]+d(i,j));
                }
            }
        }
        minl=999999999;
        for(int i=1;i<=n;i++)
        {
            maxl=Math.max(maxl,f1[i][i+n-1]);
            minl=Math.min(minl,f2[i][i+n-1]);
        }
        out.printf("%d\n%d",minl,maxl);
        out.flush();
    }
    public static int d(int i,int j){return s[j]-s[i-1];}

J - 循环数组最大子段和

找到最小的子段，数组和减去最小子段和，就是最大循环子段和
解法参考：51nod 1050

	public static void main(String[] args) {
        FastReader sc = new FastReader();
        int n=sc.nextInt();
        long sum=0;
        int num[]=new int[n+1];
        for(int i=0;i<n;i++){
            num[i]=sc.nextInt();
            sum+=num[i];
        }
        //样例超出int范围
        long dp[]=new long[n];
        for(int i=0;i<n;i++)//找最大子段
            if(i>0&&dp[i-1]>0)
                dp[i]=dp[i-1]+num[i];
            else
                dp[i]=num[i];
        long min=(int)1e9+7,max=0;
        for(int i=0;i<n;i++)
            if(max<dp[i])
                max=dp[i];
        for(int i=0;i<n;i++)//找最小子段
            if(i>0&&dp[i-1]<0)
                dp[i]=dp[i-1]+num[i];
            else
                dp[i]=num[i];
        for(int i=0;i<n;i++)
            if(min>dp[i])
                min=dp[i];
        min=sum-min;
        out.println(Math.max(min,max));
        out.flush();
    }

K - 没有上司的舞会

题目：51nod 2605
解法参考：树形dp总结
反思：
如果树形dp数组直接存list或者vector，会报以下编译错误。

注: : 有关详细信息, 请使用 -Xlint:unchecked 重新编译。

查了一下，大概是这样的操作不安全，可能使程序崩溃。
改成用结点类封装list，再进行操作就编译通过了。
ps：如果用二维数组代替list的功能可能会MLE（甚至出现了RE :- (）

	//主程序
	static node tree[];
    static int ri[],vis[],f[][];//ri[]快乐指数
    static int n;//总人数
    //f[i][0]:i不来的情况下以i为根节点的子树的最大快乐值
    //f[i][1]:i来的情况下以i为根节点的子树的最大快乐值
    public static void main(String[] args) {
        FastReader sc = new FastReader();
        n=sc.nextInt();
        ri=new int[n+1];
        vis=new int[n+1];
        tree=new node[n+1];
        f=new int[n+1][2];
        for(int i=1;i<=n;i++)ri[i]=sc.nextInt();
        for(int i=1;i<n;i++){
            int x=sc.nextInt();
            int y=sc.nextInt();
            if(tree[x]==null)tree[x]=new node();
            if(tree[y]==null)tree[y]=new node();
            tree[x].ad(y);
            tree[y].ad(x);
        }
        dfs(1);//从根节点找子树
        out.println(Math.max(f[1][0],f[1][1]));
        out.flush();
    }
    public static void dfs(int x){
        vis[x]=1;
        f[x][0]=0;
        f[x][1]=ri[x];
        for(int i=0;i<tree[x].length;i++){
            int son=tree[x].gt(i);
            if(vis[son]!=0)continue;
            dfs(son);
            f[x][0]+=Math.max(f[son][0],f[son][1]);
            f[x][1]+=f[son][0];
        }
    }

//结点类
class node{
    int length;
    List<Integer> ls;
    public node() {
        ls=new ArrayList<>();
        length=0;
    }
    public void ad(int x){
        ls.add(x);
        length++;
    }
    public int gt(int x){
        return ls.get(x);
    }
}

L - 滑雪

解法参考：滑雪

	static int n,m;//row & column
    static int dp[][]=new int[110][110];
    static int mp[][]=new int[110][110];//地图(高度)
    static int dir[][]={{1,0},{-1,0},{0,-1},{0,1}};//搜索方向
    public static void main(String[] args) {
        FastReader sc = new FastReader();
        int i,j;
        n=sc.nextInt();
        m=sc.nextInt();
        for(i=1;i<=n;i++)
            for(j=1;j<=m;j++)
                mp[i][j]=sc.nextInt();
        int s=0;
        for(i=1;i<=n;i++)
            for(j=1;j<=m;j++)
                s=Math.max(find(i,j), s);
        out.printf("%d\n",s);
        out.flush();
    }
    public static int find(int x,int y) //找出从该点开始能进行的最大次数
    {
        if(dp[x][y]!=0)
            return dp[x][y];
        int d=1,tx,ty;
        for(int k=0;k<4;k++)
        {
            tx=x+dir[k][0];
            ty=y+dir[k][1];
            if(tx>=1&&tx<=n&&ty>=1&&ty<=m&&mp[x][y]>mp[tx][ty])
                d=Math.max(find(tx,ty)+1,d);
        }
        dp[x][y]=d;
        return d;
    }

M - Palindrome

题意：求最少增加几个字符使得给定的字符串形成回文串
来源：HenauOJ1245
题解：源字符串插入最少字符生成回文串

 	/**题目：
     * 求最少增加几个字符使得给定的字符串形成回文串
     * 思路：
     * 转化为求最长回文子串的问题；最终结果为 原串长-最长回文子串的长度
     * 核心算法：最长公共子序列
     * dp[i][j]:字符串1的前i位和字符串2的前j位的LCS长度；本题中字符串1、2为同一字符串。
     */
    public static void main(String[] args) {
        FastReader sc = new FastReader();
        int n=sc.nextInt();
        char c[]=(" "+sc.next()).toCharArray();
        int dp[][]=new int[n+1][n+1];//dp[i][j] : 表示从 i 到 j 的最长回文子串长度
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(c[i]==c[n-j+1])dp[i][j]=dp[i-1][j-1]+1;
                else dp[i][j]=Math.max(dp[i][j-1],dp[i-1][j]);
            }
        }
        out.println(n-dp[n][n]);
        out.flush();
    }

N - 最长公共子串

解法和最长公共子序列很相似，状态转移方程如下：

   i=0,j=0           dp[i][j]=0
   i,j>0 & xi=yj     dp[i][j]=dp[i-1][j-1]+1
   i,j>0 & xi!=yj    dp[i][j]=0

最长公共子串要求下标连续，最长公共子序列下标严格递增即可。

HENAUOJ1251

	public static void main(String[] args) {
        char c1[]=(" "+sc.next()).toCharArray();
        char c2[]=(" "+sc.next()).toCharArray();
        int n=c1.length-1;int m=c2.length-1;
        int dp[][]=new int[n+1][m+1];
        int max=0;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                if(c1[i]==c2[j])
                    dp[i][j]=dp[i-1][j-1]+1;
                else
                    dp[i][j]=0;
                if(dp[i][j]>max)max=dp[i][j];
            }
        }
        out.println(max);
        out.flush();
    }
MN979323
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中常用算法及示例-分治、迭代、递归、递推、动态规划、回溯、穷举、贪心
BADAO_LIUMANG_QIZHI的博客
04-11 2414
1、分治算法的基本思想是将一个计算复杂的问题分成规模较小、计算简单的小问题求解，然后综合各个小问题，得到最终答案。2、穷举(又称枚举)算法的基本思想是从所有可能的情况中搜索正确的答案。3、迭代法(Iterative Method) 无法使用公式一次求解，而需要使用重复结构(即循环)重复执行一段代码来得到答案。4、递归调用是一个方法在其方法体内调用其自身方法。5、递推算法是一种理性思维模式的代表，其根据已有的数据和关系，逐步推导而得到结果。
动态规划之递推关系PPT
最新发布
08-06
动态规划之递推关系PPT 动态规划是一种常用的算法思想，它通过将复杂问题分解成更小的子问题，然后解决这些子问题，最后将子问题的解组合起来得到原问题的解。递推关系是动态规划的核心概念之一，它定义了如何将子...
java递推_Java算法-递推算法思想
weixin_34378978的博客
02-15 414
递推算法是常用的算法思想，在数学计算等方面有着广泛的应用。递推算法适合有着明显公式的规律场合。一、递推算法基本思想递推算法是一种理性思维模式的代表，其根据已有的数据和关系，逐步推导而得到结果。递推算法的执行过程如下：根据已知结果和关系，求解中间结果。判断是否达到要求，如果没有达到。则继续根据已知结果和关系求解中间结果；如果满足要求，则表示寻找到一个正确的答案。递推算法往往需要用户知道答案和问题之间...
Java算法-递推算法思想
weixin_34218890的博客
08-04 592
2019独角兽企业重金招聘Python工程师标准>>> ...
《备战蓝桥》之递推（Java）
如风暖阳的博客
03-08 568
《备战蓝桥》之递推
递推java_练习1-递推等
weixin_28224217的博客
02-24 267
1000 Problem A时间限制 : 40/20 MS(Java/Others) | 内存限制 : 65536/32768 KB(Java/Others)Submits : 110 | Solved : 24题目描述给定一组无序数值，数值的大小在1到百万之间，数值的个数在10-50万个之间。现需要找出其中第5到第10小的整数。输入要求一组非0整数，(个数>=10个)，0为结束标志。输出要...
Java矩阵连乘问题(动态规划)算法实例分析
08-28
Java矩阵连乘问题(动态规划)算法实例分析 本文主要介绍了Java矩阵连乘问题的动态规划算法实例分析。矩阵连乘问题是指给定n个矩阵，确定计算矩阵连乘积的计算次序，使得依此次序计算矩阵连乘积需要的数乘次数最少。 ...
动态规划专题之斐波那契数列1
08-08
本篇专题讨论的是如何使用动态规划来解决斐波那契数列的问题。斐波那契数列是一个经典的例子，它的定义是：第0项为0，第1项为1，之后的每一项都等于前两项之和。 斐波那契数列可以用以下递推公式表示： F(n) = F(n-...
java 最短路径 问题 动态规划
04-01
根据给定的信息，本文将详细解释Java实现的最短路径问题动态规划算法。该程序的主要目的是寻找图中各个节点到指定终点的最短路径，并输出每个节点到终点的最短距离以及达到这些最短距离时的决策路径。 ### 1. 问题...
贪心算法和动态规划（Java实现） 贪心算法和动态规划.pdf
04-08
"贪心算法和动态规划（Java实现）" 贪心算法是一种常用的算法设计策略，它所做出的选择总是当前看来是最好的。贪心算法的设计关键是选择贪心策略，且必须具备无后效性，即某个状态以后的过程不会影响以前的状态，只...
学习常用算法之(4)递推法
10-15
学习常用算法之(4)递推法
java之递推求解一维多项式
季科的博客
04-30 1193
这篇文章说的是如何计算一个一维多项式的值，一维其实也就是包含一个变量的多项式，类似f(x)=ax^3+bx^2+cx+d   的形式，我们可以将上面的式子写成形如((ax+b)x+c)x+d这样很容易就看出了这个式子可以通过递推的方式来实现，代码： package com.jk.test; /**  *   * @author jk,这段代码写的是如何计算一个一维多项式的值，一维其
java基础算法之递推
季科的博客
04-21 4937
这篇文章我们来谈谈递推：递推的经典例子是兔子数列 斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契（Leonardoda Fibonacci[1]  ）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……在数学上，斐波纳契数列以如下被以递归的方法定义：F（0）=0，F（1）=1，
Java 递推思想
JJiaoAo的专栏
09-14 277
像俺一样奋斗在一线的码农们，一谈到学编程，都是说要学会XX语言就OK了，其实我们理解的有一点点的偏差，因为我们只说到了 三分之一，其实真正的编程应该是：编程=数据结构+算法+XX语言。 对的，XX语言只是一个工具而已，就好比我们知道用笔来写字，但是不见得我们就能写出一手让张恨水为之倾倒的好字，其实我也说过 算法不仅仅用于程序设计中，在我们的生活中也处处存在着算法，比如记得我大二学C#...
java递推_【Java】递归递推的应用
weixin_39836726的博客
02-15 182
利用阶乘公式来计算组合式：程序设计思想：根据公式来计算组合数的大小，从键盘输入n,k的值，设计一个计算阶乘的大小，如果输入的数a为1或0，则直接return 1，否则运用递归，计算a-1的阶乘，直到a为1时，递归结束。程序流程图：程序源代码：public static voidmain(String args[]) {intn ,k,c;Scanner in=newScanner(System.i...
【寒假训练/Java】递推专题
m0_51226527的博客
01-28 227
A - 小乐乐走台阶 B - 滑雪（DFS） C - [NOIP2005]采药（01背包） D - [NOIP2002]过河卒 E - [NOIP2006]金明的预算方案(01背包) F - [NOIP2006]开心的金明(01背包) G - 石子合并(区间DP) H - 没有上司的舞会(DFS) I - [NOIP2004]合唱队形(最长上升子序列LIS) J - 牛可乐和最长公共子序列 K - [NOIP2008]传纸条 L - 费解的开关(位运算/模拟)
HDU 1297 递推 （Java）
117瓶果粒橙
05-03 275
题目 Problem Description There are many students in PHT School. One day, the headmaster whose name is PigHeader wanted all students stand in a line. He prescribed that girl can not be in single. In...
Java-余弦-递推
Just like myself.
03-27 276
C语言实验——余弦Time Limit: 1000 ms Memory Limit: 65536 KiBSubmit StatisticProblem Description输入n的值，计算cos(x)。 Input输入数据有多行，每行两个数，包括x和n。第一数据为x，第二个数据为n。Output输出cos(x)的值，保留4位小数。Sample Input0.0 100Sample Output1...
Java算法递归与递推
weixin_44332957的博客
07-03 705
Java算法----递归与递推递推实现递推思想递归实现递归思想递归实现递推思想递推实现递归思想四种方法的特点 问题：给你一个整数n，如果n是奇数，就进行运算n=n*3+1，如果n是偶数，就进行运算n=n/2，直到n等于1为止，请计数一种进行了多少次运算（使用四种编码方式实现） 递推实现递推思想 /* 递推实现递推思想 */ public static Integer getSum1(Integer n) { if (n <= 0) return 0;/
动态规划：递推逻辑与最优化决策算法
"动态规划是一种有效的算法思想，它通过将复杂问题分解成一系列子问题，并利用子问题的最优解构建原问题的最优解。这种算法常用于解决最优化问题，尤其在处理具有重叠子问题和无后效性特征的问题时表现出色。动态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值