java动态规划,java动态规划最短路径

本文目录一览：

• 1、java 动态规划矩阵多少种走法
• 2、常用的算法在java里边怎么做，例
• 3、怎么设计用动态规划算法和java实现最小
• 4、JAVA动态规划，最长递增子序列的代码太难理解，求大神帮我讲解一下！
• 5、java动态规划 计算数n由k个数相加而成的情况数

java 动态规划矩阵多少种走法

import java.util.Scanner;

public class zhidao3

{

public static void main(String[] args)

{

Scanner scanner = new Scanner(System.in);

int T = scanner.nextInt();

int out[] = new int[T];

scanner.nextLine();

for(int t=0;tT;t++)

{

String a = scanner.nextLine();

char[] ch=a.toCharArray();

int f[][]= new int[ch.length+1][2];

if (ch[0]=’Z’ch[0]=’A’)

{

f[0][1]=2;

f[0][0]=2;

}

if (ch[0]=’z’ch[0]=’a’)

{

f[0][1]=1;

f[0][0]=1;

}

for(int i=1 ;i=ch.length;i++)

{

if (ch[i-1]=’Z’ch[i-1]=’A’)

{

f[i][0] = f[i-1][1] + 2;

f[i][1] = f[i-1][1] + 1;

}

if(ch[i-1]=’z’ch[i-1]=’a’)

{

f[i][0] = f[i-1][0] + 1;

f[i][1] = f[i-1][0] + 2;

}

}

out[t] = Math.min(f[ch.length-1][0],f[ch.length-1][1]);

}

for(int t=0;tT;t++){

System.out.println(out[t]);//最后统一输出

}

scanner.close();

}

}

常用的算法在java里边怎么做，例

（一） 问题描述

给定由n个整数（可能为负整数）组成的序列a1，a2，a3，···，an，求该序列的子段和的最大值。当所有整数均为负整数是定义其最大子段和为0，一次定义，所求的最优质值为：max{0、max子段和}。

（二） 算法描述

动态规划法的基本思想：

动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。

算法设计：

#include “stdafx.h”

int MaxSum(int a[],int n,int Start,intEnd){

intsum=0;

int*b,t;

b=newint[n+1];

b[0]=0;

for(inti=1;i=n;i++){

if(b[i-1]0){

b[i]=b[i-1]+a[i];

}

else {

b[i]=a[i];t=i;

}

if(b[i]sum){

sum=b[i];

Start=t;

End=i;

}

}

delete[]b;

returnsum;

}

int main(int argc, char* argv[])

{

inta[7]={0,-2,11,-4,13,-5,-2},sum,Start,End,i;

sum=MaxSum(a,6,Start,End);

for(i=Start;i=End;i++){

printf(“%d “,a[i]);

}

printf(“\n%d\n”,sum);

getchar();

getchar();

return0;

怎么设计用动态规划算法和java实现最小

import java.util.Arrays;

public class Test {

public static void getCha(int [] a,int []b){

int min =Integer.MAX_VALUE;

int sss=0;

int kkk = 0;

int c = 0;

int d = 0;

for (int i = 0; i a.length; i++) {

for (int j = 0; j b.length; j++) {

int temp = Math.abs(a[i]-b[j]);

if(tempmin){

min = temp;

sss = a[i];

kkk = b[j];

c=i;

d=j;

}

}

}

System.out.println(“最大差距：”+min+”数组A[“+c+”]”+sss+”数组B[“+d+”]”+kkk);

}

public static void main(String[] args) {

int []a = new int[8];

int []b = new int[12];

for (int i = 0; i a.length; i++) {

a[i] = (int)( Math.random()*100);

}

System.out.println(Arrays.toString(a));;

for (int i = 0; i b.length; i++) {

b[i] = (int) (Math.random()*100);

}

System.out.println(Arrays.toString(b));

getCha(a,b);

}

}

JAVA动态规划，最长递增子序列的代码太难理解，求大神帮我讲解一下！

第一层的 if 逻辑表示 如果新的一个数A[i]对于 B[]中的数来说是递增的，则len加1，这是记录递增数列长度的主要逻辑。else中的逻辑保证B[]中的数列是最新的递增数列。

举个例子，如果A数组为[1,2,3,4,5, 3.1, 3.2, 3.3, 3.4]

当i=4时 len=4 B=[x,1,2,3,4,x] 循环结束后 len=5 B=[x,1,2,3,4,5] 第一层判断走if

当i=5时 len=5 B=[x,1,2,3,4,5] 循环结束后 len=5 B=[x,1,2,3,3.1,5] 第一层判断走else

当i=6时 len=5 B=[x,1,2,3,3.1,5] 循环结束后 len=5 B=[x,1,2,3,3.1,3.2] 第一层判断走else

当i=7时 len=5 B=[x,1,2,3,3.1,3.2] 循环结束后 len=6 B=[x,1,2,3,3.1,3.2,3.3] 第一层判断走else

…

其中第一层的else中做的工作就是把B从[x,1,2,3,4,5] 一步步变成 [x,1,2,3,3.1,3.2],最终B[]的最后一个元素变成3.2, 在下一次A[i]=3.3的时候，就又会走第一次if的逻辑（len加1）了。

java动态规划 计算数n由k个数相加而成的情况数

public class MyClass {

    public static void main(String[] args) {

        System.out.println(” result count:” + method(6, 3));

    }

    public static int method(int n, int k) {

        ListListInteger list = new ArrayList();

        for (int i = 0; i  k; i++) {

            if (i == 0) {

                for (int j = 1; j  n; j++) {

                    ListInteger li = new ArrayList();

                    li.add(j);

                    list.add(li);

                }

                continue;

            }

            ListListInteger listNew = new ArrayList();

            for (ListInteger integers : list) {

                for (int j = integers.get(integers.size() – 1); j  n; j++) {

                    ListInteger li = new ArrayList();

                    li.addAll(integers);

                    li.add(j);

                    listNew.add(li);

                    if (i + 1 == k) {

                        int res = 0;

                        for (Integer integer : li) {

                            res += integer;

                        }

                        if (res != n) {

                            listNew.remove(li);

                        }

                    }

                }

            }

            list.clear();

            list.addAll(listNew);

        }

        for (ListInteger integers : list) {

            for (Integer integer : integers) {

                System.out.print(integer + “\t”);

            }

            System.out.println();

        }

        return list.size();

    }

}