【寒假训练/Java】递推专题

最新推荐文章于 2024-05-16 10:23:10 发布
最新推荐文章于 2024-05-16 10:23:10 发布
阅读量207 收藏
点赞数
分类专栏： 专题训练 文章标签： java 算法 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51226527/article/details/128773038
版权

文章目录

题目链接

递推专题-牛客链接
比赛密码：202301272000

题目列表

快输

import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        out.flush();
    }

    static class FastReader{
        BufferedReader br;
        StringTokenizer st;
        String tmp;

        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());}

        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 {
                tmp=br.readLine();
                st=new StringTokenizer(tmp);
            }catch(IOException e) {
                return false;
            }
            return true;
        }
    }

    static PrintWriter out=new PrintWriter(
            new BufferedWriter(new OutputStreamWriter(System.out)));
    static FastReader sc=new FastReader();
}

A - 小乐乐走台阶

    static int[] dp;
    public static void main(String[] args) {
        int n=sc.nextInt();
        dp=new int[n+1];
        dp[1]=1;
        dp[2]=2;
        for(int i=3;i<=n;i++){
            dp[i]=dp[i-1]+dp[i-2];
        }
        out.println(dp[n]);
        out.flush();
    }

B - 滑雪（DFS）

深搜遍历得到所有以当前点为起始的最长滑坡的长度

    static int n,m;//区域大小
    static int[][] dp,mp;//从当前点开始的最长滑坡，地图高度
    static int[][] dir={{1,0},{-1,0},{0,-1},{0,1}};//搜索方向
    public static void main(String[] args) {
        n=sc.nextInt();
        m=sc.nextInt();
        dp=new int[n+1][m+1];
        mp=new int[n+1][m+1];
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)
                mp[i][j]=sc.nextInt();
        int s=0;//遍历找最大值
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)
                s=Math.max(find(i,j), s);
        out.println(s);
        out.flush();
    }
    //找出从该点开始能进行的最大次数
    public static int find(int x,int y){
        if(dp[x][y]!=0) return dp[x][y];

        int t=1,nx,ny;
        //从四个方向搜索最长滑坡
        for(int i=0;i<4;i++) {
            nx=x+dir[i][0];
            ny=y+dir[i][1];
            //若超出临界范围  或者不满足 下一个点的高度小于当前点的高度 这个条件，需要跳过
            if(nx<=0||nx>n||ny<=0||ny>m||mp[x][y]<=mp[nx][ny]) continue;
            t=Math.max(find(nx,ny)+1,t);
        }
        dp[x][y]=t;
        return t;
    }

C - [NOIP2005]采药（01背包）

    public static void main(String[] args) {
        int T=sc.nextInt(),M=sc.nextInt();//采药总时间（容量），草药数（数量）
        //dp:当前时间可以采到的草药的最大价值，t:采药时间，w:草药价值
        int[] dp=new int[T+1],t=new int[M+1],w=new int[M+1];
        for(int i=1;i<=M;i++){
            t[i]=sc.nextInt();
            w[i]=sc.nextInt();
        }
        for(int i=1;i<=M;i++){
            for(int j=T;j>=t[i];j--){
                dp[j]=Math.max(dp[j],dp[j-t[i]]+w[i]);
            }
        }
        out.println(dp[T]);
        out.flush();
    }

D - [NOIP2002]过河卒

dp数组表示从（0,0）点出发，到达该点的路径的条数；

将对方马的坐标及其控制点标记为特殊值。在初始化时，第0行和第0列起始值均为1，倘若遇到某一点为-1，即该点为控制点，这个点和之后的所有点均需标记为-1，表示不可达；

    //马的八个控制点
    static int[][] dir={{2,-1},{1,-2},{-1,-2},{-2,-1},{-2,1},{-1,2},{1,2},{2,1}};
    public static void main(String[] args) {
        //B点的坐标(n,m)，对方马的坐标(X,Y)以及临时坐标
        int n=sc.nextInt(),m=sc.nextInt(),X=sc.nextInt(),Y=sc.nextInt(),nx,ny;
        //结果可能爆int
        long[][] dp=new long[n+1][m+1];
        //对方马的控制点标记为-1
        dp[X][Y]=-1;
        for(int i=0;i<8;i++){
            nx=X+dir[i][0];
            ny=Y+dir[i][1];
            if(nx<0||nx>n||ny<0||ny>m)continue;
            dp[nx][ny]=-1;
        }
        //经测试，不会存在出发点是对方马的控制点的情况，这里写上表示逻辑完整
        if(dp[0][0]==-1)out.println(0);
        else{
            //初始化：第0行和第0列起始值均为1，倘若遇到某一点为-1，即该点为控制点，这个点和之后的所有点均需标记为-1，表示不可达
            int f=0;
            for(int i=1;i<=n;i++){
                if(f==0&&dp[i][0]==-1)f=-2;
                else dp[i][0]=1+f;
            }
            f=0;
            for(int i=1;i<=m;i++){
                if(f==0&&dp[0][i]==-1)f=-2;
                else dp[0][i]=1+f;
            }

            for(int i=1;i<=n;i++){
                for(int j=1;j<=m;j++){
                    //控制点跳过
                    if(dp[i][j]<0)continue;
                    //到达该点有两条路：从上边点或者从左边点
                    dp[i][j]=dp[i-1][j]+dp[i][j-1];
                    //dp数组中控制点的值为-1，所以要+1变为0
                    if(dp[i-1][j]<0)dp[i][j]++;
                    if(dp[i][j-1]<0)dp[i][j]++;
                }
            }

            out.println(dp[n][m]);
        }
        out.flush();
    }

E - [NOIP2006]金明的预算方案(01背包)

01背包
将只考虑买不买当前物品，转化为：

①只买主件
②买主件&第一个附件
③买主件&第二个附件
④买主件&第所有附件(最多两个附件)

    public static void main(String[] args) {
        int N=sc.nextInt(),m=sc.nextInt();//总钱数，希望购买物品的个数
        int v,p,q;//价格，重要度，主件0 or 附件所属主件的编号>0
        /**
         * dp:不超过当前钱数的物品的价格与重要度乘积的总和的最大值
         * c:价格
         * w:物品的价格与重要度乘积
         * 二维数组的第二维表示主件0 or 附件编号>0
         */
        int[] dp=new int[N+1],c[]=new int[m+1][3],w[]=new int[m+1][3];
        for(int i=1;i<=m;i++){
            v=sc.nextInt();p=sc.nextInt();q=sc.nextInt();
            if(q==0){//主件
                c[i][0]=v;
                w[i][0]=v*p;
            }else{
                if(c[q][1]==0){//第一个附件
                    c[q][1]=v;
                    w[q][1]=v*p;
                }else{//第二个附件
                    c[q][2]=v;
                    w[q][2]=v*p;
                }
            }
        }

        //01背包
        for(int i=1;i<=m;i++){
            for(int j=N;j>=1;j--){
                int s1=0,s2=0;
                //只买主件
                if(j>=c[i][0])
                    dp[j]=Math.max(dp[j],dp[j-c[i][0]]+w[i][0]);
                //买主件&第一个附件
                s1=c[i][0]+c[i][1];
                s2=w[i][0]+w[i][1];
                if(j>=s1)
                    dp[j]=Math.max(dp[j],dp[j-s1]+s2);
                //买主件&第二个附件
                s1=c[i][0]+c[i][2];
                s2=w[i][0]+w[i][2];
                if(j>=s1)
                    dp[j]=Math.max(dp[j],dp[j-s1]+s2);
                //买主件&第所有附件
                s1=c[i][0]+c[i][1]+c[i][2];
                s2=w[i][0]+w[i][1]+w[i][2];
                if(j>=s1)
                    dp[j]=Math.max(dp[j],dp[j-s1]+s2);
            }
        }
        out.println(dp[N]);
        out.flush();
    }

F - [NOIP2006]开心的金明(01背包)

    public static void main(String[] args) {
        int N=sc.nextInt(),m=sc.nextInt();//总钱数，希望购买物品的个数
        int v,p;//价格，重要度
        /**
         * dp:不超过当前钱数的物品的价格与重要度乘积的总和的最大值
         * c:价格
         * w:物品的价格与重要度乘积
         */
        int[] dp=new int[N+1],c=new int[m+1],w=new int[m+1];
        for(int i=1;i<=m;i++){
            v=sc.nextInt();p=sc.nextInt();
            c[i]=v;
            w[i]=v*p;
        }

        //01背包
        for(int i=1;i<=m;i++){
            for(int j=N;j>=c[i];j--){
                dp[j]=Math.max(dp[j],dp[j-c[i]]+w[i]);
            }
        }
        out.println(dp[N]);
        out.flush();
    }

G - 石子合并(区间DP)

    public static void main(String[] args) {
        //沙子的堆数
        int n=sc.nextInt(),MAXN=(int)1e9+7;
        //dp：将第i-j堆沙子合并的最小代价
        int[] dp[]=new int[n+1][n+1],s=new int[n+1];

        for(int i=0;i<=n;i++)Arrays.fill(dp[i],MAXN);
        //前缀和
        for(int i=1;i<=n;i++) {
            s[i]=s[i-1]+sc.nextInt();
        }
        for(int j=1;j<=n;j++) {//区间长度以及区间右端点
            for(int i=j;i>=1;i--){//1~j
                if(j==i)dp[i][j]=0;
                for(int k=i;k<j;k++){
                    //第i-j堆沙子被分成两部分，这两部分合并需要加上代价 - 第i-j堆沙子数量之和
                    dp[i][j]=Math.min(dp[i][j],dp[i][k]+dp[k+1][j]+s[j]-s[i-1]);
                }
            }
        }
        out.println(dp[1][n]);
        out.flush();
    }

H - 没有上司的舞会(DFS)

构建一个职员类,其中维护一个list存储与其互斥的职员;

二维dp数组求最大快乐值:
该职员来:其互斥职员只能不来;
该职员不来:其互斥职员可以来 or 不来;
第二维保存该职员来或不来的状态

递归过程利用深搜实现:
最终返回一条使快乐值最大的子树

import java.io.*;
import java.util.*;
//职员类
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);
    }
}

public class Main {
    /**
     * Hi:快乐指数
     * f[i][0]:i不来的情况下以i为根节点的子树的最大快乐值
     * f[i][1]:i来的情况下以i为根节点的子树的最大快乐值
     * n:总人数
     */
    static node[] tree;
    static int[] Hi,vis,f[];
    static int n,l,k;

    public static void main(String[] args) {
        n=sc.nextInt();
        Hi=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++){
            Hi[i]=sc.nextInt();
            tree[i]=new node();
        }
        for(int i=1;i<n;i++){
            l=sc.nextInt();
            k=sc.nextInt();
            tree[l].ad(k);
            tree[k].ad(l);
        }//最后一行输入0,0 代码中不必体现,否则RE:根据测试,某些样例不含此输入
        
        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]=Hi[x];
        for(int i=0;i<tree[x].length;i++){
            int son=tree[x].gt(i);
            if(vis[son]!=0)continue;
            dfs(son);
            //x没有来，son可以来or不来
            f[x][0]+=Math.max(f[son][0],f[son][1]);
            //x来了，son只能不来
            f[x][1]+=f[son][0];
        }
    }

    static class FastReader{
        BufferedReader br;
        StringTokenizer st;
        String tmp;

        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());}

        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 {
                tmp=br.readLine();
                st=new StringTokenizer(tmp);
            }catch(IOException e) {
                return false;
            }
            return true;
        }
    }

    static PrintWriter out=new PrintWriter(
            new BufferedWriter(new OutputStreamWriter(System.out)));
    static FastReader sc=new FastReader();
}

I - [NOIP2004]合唱队形(最长上升子序列LIS)

求最少需要几位同学出列,转为求最长上升子序列问题:

本题的上升序列最高点在中间,可以分别求出正序和反序的LIS,再枚举每一个点的正反向LIS长度之和,即为本题中所求最大长度;

总人数减去这个最大长度即为最少出列人数.

    public static void main(String[] args) {
        int n=sc.nextInt(),ans=0;
        //下标从1-n
        int[] T=new int[n+2],dp1=new int[n+2],dp2=new int[n+2];
        for(int i=1;i<=n;i++) T[i]=sc.nextInt();
        //从1到n求LIS
        for(int i=1;i<=n;i++)
            for(int j=0;j<i;j++)
                if(T[i]>T[j]) dp1[i]=Math.max(dp1[i],dp1[j]+1);
                
        //从n到1求LIS
        for(int i=n;i>=1;i--)
            for(int j=n+1;j>i;j--)
                if(T[i]>T[j]) dp2[i]=Math.max(dp2[i],dp2[j]+1);

        for(int i=1;i<=n;i++)
            //枚举Ti，从1到Ti的LIS长度+从TK到Ti的LIS长度-1(Ti被算了两次)
            ans=Math.max(dp1[i]+dp2[i]-1,ans);
            
        out.println(n-ans);
        out.flush();
    }

J - 牛可乐和最长公共子序列

状态转移方程如下：

  • x[i] == y[i]:  DPi,j = DPi-1,j-1 +1;
  • x[i] <> y[j]:  DPi,j = max(DPi-1,j , DPi,j-1);
  • i= 0 | | j= 0:  DPi,j = 0;
import java.io.*;
import java.util.*;

public class Main {
    //dp：字符串1的前i位和字符串2的前j位的LCS长度
    static char[] c1,c2;
    static int n,m;
    static int[][] dp;
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
        	//下标均从1开始
            c1=(" "+sc.next()).toCharArray();
            c2=(" "+sc.next()).toCharArray();
            n=c1.length-1;m=c2.length-1;

            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]);
                    }
                }
            }
            out.println(dp[n][m]);
        }
        out.flush();
    }

    static PrintWriter out=new PrintWriter(
            new BufferedWriter(new OutputStreamWriter(System.out)));
}

K - [NOIP2008]传纸条

参考

    static int N=60;
    static int[][] a=new int[N][N];
    static int[][][] F=new int[N*2][N][N];
    public static void main(String[] args) {
        int m=sc.nextInt(),n=sc.nextInt();
        for(int i=1;i<=m;i++)
            for(int j=1;j<=n;j++)
                a[i][j]=sc.nextInt();

        //赋初值 -1
        for (int[][] ints:F)
            for (int[] Int:ints) Arrays.fill(Int,-1);

        F[2][1][1]=0;//最初的点，在左上角，好感度为0
        for(int k=3;k<m+n;k++)
            for(int i=1;i<n;i++)
                for(int j=i+1;j<=n;j++){
                    int s=getMax(F[k-1][i][j],F[k-1][i-1][j],F[k-1][i][j-1],F[k-1][i-1][j-1],F[k][i][j]);

                    if(s==-1)continue;//当s为-1时，说明四种情况都不能到该点，故不存在。
                    if(k-i<N&&k-j<N)F[k][i][j]=s+a[k-i][i]+a[k-j][j];//该点的值为最大的前一个值与当前F[k][i][j]表示两点的值的和。
                }
        //因为i永远小于j，所以右下角的点不会求到，
        //但是到右下角只有一种情况，就是在右下角的上面和右下角的左边，直接输出就好了。
        out.println(F[m+n-1][n-1][n]);
        out.flush();
    }
    static int getMax(int a,int b,int c,int d,int s){
        return Math.max(Math.max(Math.max(a,b),Math.max(c,d)),s);
    }

L - 费解的开关(位运算/模拟)

参考

    static int N=6;
    static int[] dx={-1,0,1,0,0},dy={0,1,0,-1,0};
    static char[][] g=new char[N][N];
    static String[] backup=new String[N];
    public static void main(String[] args) {
        int n=sc.nextInt();
        while(n-->0){
            // 按行输入，把每一行当成一个字符串
            for(int i=0;i<5;i++){
                String s=sc.next();
                g[i]=s.toCharArray();
                //把原始数组备份一下，然后操作g，操作完了还原，然后再操作
               	//注意必须是深拷贝
                backup[i]=s;
            }

            int res=10;

            /*
            这里我们枚举了第一行的32种按法，不用管是亮是灭，把第一行所有情况都按一遍
            按每种情况的第一行，去遍历接下来的行
            枚举32种第一行的按法只是可能会减少步数，如果直接从第二行开始答案一定是固定的了，找不到最优解或者可能没有解
             */
            for (int op=0;op<32;op++){
                int step=0;
                // 第一行的按法(在这里 1表示按了, 0表示不按)，这里只是为了输出第一行按完之后的状态
                for (int i=0;i<5;i++)
                    if ((op>>i&1)==1){
                        /*
                        数字2对应了 00010 表示第2个位置的按一下
                        00010 >> 1 & 1  是1所以turn(0, 1)就是第一行第二个位置
                        数字3对应了 00011 表示第1和第2个位置的按一下
                         */
                        step++;
                        turn(0,i);
                    }

                // 然后通过第一行按完之后的状态，按234行
                for (int i=0;i<4;i++)
                    for (int j=0;j<5;j++)
                        if (g[i][j]=='0'){
                            step++;
                            turn(i+1,j);  //如果这个位置是灭的，就按下一行对应的位置
                        }
                //判断最后一行是否全亮
                boolean dark=false;
                for (int j=0;j<5;j++)
                    if(g[4][j]=='0'){
                        dark=true;
                        break;
                    }
                // 对于32种情况的这一种，如果所有的全亮就记录下步数(事实上只记录了最后一行是否dark)
                if(!dark) res=Math.min(res,step);
                for(int i=0;i<5;i++) {
                    g[i]=backup[i].toCharArray();
                }
            }
            if(res>6) res=-1;
            out.println(res);
        }
        out.flush();
    }

    // 这个操作是把(x, y)以及上下左右的灯都变成相反的颜色
    static void turn (int x,int y){
        for(int i=0;i<5;i++) {
            int a=x+dx[i];
            int b=y+dy[i];
            //超出临界范围,跳过
            if (a<0||a>=5||b<0||b>=5) continue;
            if(g[a][b]=='0')g[a][b]='1';
            else g[a][b]='0';
        }
    }
MN979323
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++递归/递推经典题目
01-17
这里是本蒟蒻整理/写的递归递推经典题目 上传供大家学习使用 包含：过河卒、过河卒升级版、汉诺塔、级数求和、勒让德多项式、流感传染、判断回文、判断元素是否存在、平方根级数、平面分割升级版、全排列递归版、...
java递推_Java算法-递推算法思想
weixin_34378978的博客
02-15 403
递推算法是常用的算法思想，在数学计算等方面有着广泛的应用。递推算法适合有着明显公式的规律场合。一、递推算法基本思想递推算法是一种理性思维模式的代表，其根据已有的数据和关系，逐步推导而得到结果。递推算法的执行过程如下：根据已知结果和关系，求解中间结果。判断是否达到要求，如果没有达到。则继续根据已知结果和关系求解中间结果；如果满足要求，则表示寻找到一个正确的答案。递推算法往往需要用户知道答案和问题之间...
《备战蓝桥》之递推（Java）
如风暖阳的博客
03-08 557
《备战蓝桥》之递推
java基础算法之递推
季科的博客
04-21 4899
这篇文章我们来谈谈递推：递推的经典例子是兔子数列 斐波那契数列（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 267
像俺一样奋斗在一线的码农们，一谈到学编程，都是说要学会XX语言就OK了，其实我们理解的有一点点的偏差，因为我们只说到了 三分之一，其实真正的编程应该是：编程=数据结构+算法+XX语言。 对的，XX语言只是一个工具而已，就好比我们知道用笔来写字，但是不见得我们就能写出一手让张恨水为之倾倒的好字，其实我也说过 算法不仅仅用于程序设计中，在我们的生活中也处处存在着算法，比如记得我大二学C#...
java递推_【Java】递归递推的应用
weixin_39836726的博客
02-15 172
利用阶乘公式来计算组合式：程序设计思想：根据公式来计算组合数的大小，从键盘输入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实现 LeetCode 790 多米诺和托米诺平铺（递推）
12-20
790. 多米诺和托米诺平铺 有两种形状的瓷砖：一种是 2×1 的多米诺形，另一种是形如 “L” 的托米诺形。两种形状都可以旋转。 XX <- 多米诺 XX <- “L” 托米诺 X 给定 N 的值，有多少种方法可以平铺 2 x N 的...
递推专项训练-M67牛出题
02-28
M67 牛的递推训练，可能会有帮助，总共有十个题左右
ACM 递推专题，很实用的，，快下载吧啊
12-12
编程题当中的常见题型---递推！ 充分发挥你的实际解决问题的能力！
【Java】递推专题训练（动态规划）
m0_51226527的博客
02-09 381
A - 上台阶2 B - 数字三角形 C - 矩阵取数问题 D - 背包问题（01背包） E - 完全背包 F - 背包问题 V2 G - 最长上升子序列 H - 最长公共子序列 I - 石子合并（环形合并） J - 循环数组最大子段和 K - 没有上司的舞会 L - 滑雪 M - Palindrome N - 最长公共子串...
递推java_练习1-递推等
weixin_28224217的博客
02-24 258
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算法递归与递推
weixin_44332957的博客
07-03 662
Java算法----递归与递推递推实现递推思想递归实现递归思想递归实现递推思想递推实现递归思想四种方法的特点 问题：给你一个整数n，如果n是奇数，就进行运算n=n*3+1，如果n是偶数，就进行运算n=n/2，直到n等于1为止，请计数一种进行了多少次运算（使用四种编码方式实现） 递推实现递推思想 /* 递推实现递推思想 */ public static Integer getSum1(Integer n) { if (n <= 0) return 0;/
算法高效技巧之：活用递推（java）
北海_南风
09-29 158
活用递推： （直接暴力会超时）。 对一个确定位置的A来说，以它形成的PAT个数等于它左边P的个数乘以它右边T的个数。 于是问题就转换为，对字符串中的每个A，计算它左边P的个数和它右边T的个数的乘积，然后把所以A的这个乘积相加就是答案。 思路： 设定一个数组numP,记录每一位左边P的个数（含当前位），从头到尾遍历，如果当前位是P，那么numP[i]就等于numP[i-1]+1；如果当前位不是P，那么numP[i]就等于numP[i-1]。 以同样的方法可以计算出每一位右边T的个数，为了节省代码量，不妨在
Java算法--递推算法 求解兔子产子问题或斐波那契数列问题
Android司机
10-30 3899
代码：   package com.xu.main; import java.util.Scanner; public class P7_1 { public static int fibonacci(int n) { int t1,t2; if(n == 1 || n == 2) { return 1; } else
java算法学习笔记--穷举算法/递推算法思想
Qing_zhi_hwl的博客
07-18 1758
1穷举法的适用范围 穷举法算法效率并不高，但是适合一些没有明显规律可循的场合。 2穷举法执行步骤 对于一种可能的情况，计算其结果；判断结果是否正确，不满足则执行第一步。 3例子-鸡兔同笼 问题：今有鸡兔同笼，上有35头，下有94足，问鸡兔各几何。 java代码 int qiongjie(int head,int foot) { int i ,j; for(i=0;i { j
java之递推求解一维多项式
季科的博客
04-30 1183
这篇文章说的是如何计算一个一维多项式的值，一维其实也就是包含一个变量的多项式，类似f(x)=ax^3+bx^2+cx+d   的形式，我们可以将上面的式子写成形如((ax+b)x+c)x+d这样很容易就看出了这个式子可以通过递推的方式来实现，代码： package com.jk.test; /**  *   * @author jk,这段代码写的是如何计算一个一维多项式的值，一维其
Java中常用算法及示例-分治、迭代、递归、递推、动态规划、回溯、穷举、贪心
BADAO_LIUMANG_QIZHI的博客
04-11 2227
1、分治算法的基本思想是将一个计算复杂的问题分成规模较小、计算简单的小问题求解，然后综合各个小问题，得到最终答案。2、穷举(又称枚举)算法的基本思想是从所有可能的情况中搜索正确的答案。3、迭代法(Iterative Method) 无法使用公式一次求解，而需要使用重复结构(即循环)重复执行一段代码来得到答案。4、递归调用是一个方法在其方法体内调用其自身方法。5、递推算法是一种理性思维模式的代表，其根据已有的数据和关系，逐步推导而得到结果。
1sting（JAVA大数+ 递推）
Lancer
09-22 286
1sting Time Limit: 5000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 6264 Accepted Submission(s): 2428Problem Description You will be given a string whi
jar包增量更新分析
最新发布
junlaiyan的专栏
05-16 281
借助jdeps分析出jar包的增量文件
Java递推慢如何用多线程解决
06-06
Java 递推慢可以通过多线程来解决。具体来说，可以采用分而治之的策略，将递推问题分成多个子问题，然后分配给多个线程并行计算。这样可以充分利用多核 CPU 的计算能力，加速递推计算的过程。 下面是一个简单的示例...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值