本文目录一览：
- 1、~~求解~~用动态规划算法求两数组各元素间差的最小值，JAVA代码或方法思路
- 2、如何用动态规划法解决最小生成树问题
- 3、希音java面试有算法吗
- 4、java动态规划 计算数n由k个数相加而成的情况数
- 5、JAVA动态规划，最长递增子序列的代码太难理解，求大神帮我讲解一下！
- 6、java动态规划01背包编程实现，出错怎么办
~~求解~~用动态规划算法求两数组各元素间差的最小值，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);
}
}
如何用动态规划法解决最小生成树问题
标题： 最小生成树
时 限： 1000 ms
内存限制： 10000 K
总时限： 3000 ms
描述：
有一张城市地图，图中的顶点为城市，无向边代表两个城市间的连通关系，边上的权为在这两个城市之间修建高速公路的造价，研究后发现，这个地图有一个特点，即任一对城市都是连通的。现在的问题是，要修建若干高速公路把所有城市联系起来，问如何设计可使得工程的总造价最少。假定所有输入的根节点或者源为第一个城市或第一组数据。
请使用prim算法求解。
输入：
n（城市数，1=n=100）；
e（边数）；
以下e行，每行3个数i,j,wij，表示在城市i,j之间修建高速公路的造价。
输出：
n-1行，每行为两个城市的序号，表明这两个城市间建一条高速公路。
输入样例：
5
8
1 2 2
1 3 12
1 4 10
2 3 8
2 5 9
3 4 6
3 5 3
4 5 7
输出样例：
1 2
2 3
3 5
3 4
提示：
import java.util.Scanner;
public class Main {
public static void prim(int n,float [][]c)
{
float []lowcost = new float [n+1];
int [] closest = new int [n+1];
boolean [] s = new boolean [n+1];
s[1] = true;
for(int i=2;i=n;i++)
{
lowcost[i] = c[1][i];
closest[i] = 1;
s[i] = false ;
}
for(int i=1;in;i++)
{
float min = Float.MAX_VALUE;
int j =1;
for(int k =2;k=n;k++)
if((lowcost[k]min)(!s[k]))
{
min = lowcost[k];
j =k;
}
System.out.println(closest[j]+" "+j);
s[j] = true;
for(int k =2; k=n;k++)
if((c[j][k]lowcost[k])(!s[k]))
{
lowcost[k] = c[j][k];
closest[k] = j;
}
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n =sc.nextInt();
int m = sc.nextInt();
float [][]c = new float [n+1][n+1];
for(int i = 0;im ;i++)
{
int x =sc.nextInt();
int y = sc.nextInt();
float z = sc.nextFloat();
c[x][y] = z;
}
for(int i =0;i=n;i++)
for(int j =0;j=n;j++)
if(c[i][j]==0)
c[i][j] =Float.MAX_VALUE;
希音java面试有算法吗
有。常见的如下：
一是字符串，如果IDE没有代码自动补全功能，所以你应该记住下面的这些方法。
二是链表，在Java中，链表的实现非常简单，每个节点Node都有一个值val和指向下个节点的链接next。链表两个著名的应用是栈Stack和队列Queue。
三是树，这里的树通常是指二叉树，每个节点都包含一个左孩子节点和右孩子节点。
四是排序，五是递归vs.迭代。
六是动态规划，动态规划是解决下面这些性质类问题的技术：一个问题可以通过更小子问题的解决方法来解决（即问题的最优解包含了其子问题的最优解，也就是最优子结构性质）。
有些子问题的解可能需要计算多次（也就是子问题重叠性质）。子问题的解存储在一张表格里，这样每个子问题只用计算一次。需要额外的空间以节省时间。爬台阶问题完全符合上面的四条性质，因此可以用动态规划法来解决。
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();
}
}
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动态规划01背包编程实现，出错怎么办
数组下标越界.
java技术类文章可以关注微信公账号：码农工作室
